python-swiginac 1.5.1.1-2 / usr / lib / python2.7 / dist-packages / swiginac.py

# This file was automatically generated by SWIG (http://www.swig.org).
# Version 2.0.12
#
# 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 >= (2,6,0):
    def swig_import_helper():
        from os.path import dirname
        import imp
        fp = None
        try:
            fp, pathname, description = imp.find_module('_swiginac', [dirname(__file__)])
        except ImportError:
            import _swiginac
            return _swiginac
        if fp is not None:
            try:
                _mod = imp.load_module('_swiginac', fp, pathname, description)
            finally:
                fp.close()
            return _mod
    _swiginac = swig_import_helper()
    del swig_import_helper
else:
    import _swiginac
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


class SwigPyIterator(_object):
    __swig_setmethods__ = {}
    __setattr__ = lambda self, name, value: _swig_setattr(self, SwigPyIterator, name, value)
    __swig_getmethods__ = {}
    __getattr__ = lambda self, name: _swig_getattr(self, SwigPyIterator, name)
    def __init__(self, *args, **kwargs): raise AttributeError("No constructor defined - class is abstract")
    __repr__ = _swig_repr
    __swig_destroy__ = _swiginac.delete_SwigPyIterator
    __del__ = lambda self : None;
    def value(self): return _swiginac.SwigPyIterator_value(self)
    def incr(self, n=1): return _swiginac.SwigPyIterator_incr(self, n)
    def decr(self, n=1): return _swiginac.SwigPyIterator_decr(self, n)
    def distance(self, *args): return _swiginac.SwigPyIterator_distance(self, *args)
    def equal(self, *args): return _swiginac.SwigPyIterator_equal(self, *args)
    def copy(self): return _swiginac.SwigPyIterator_copy(self)
    def next(self): return _swiginac.SwigPyIterator_next(self)
    def __next__(self): return _swiginac.SwigPyIterator___next__(self)
    def previous(self): return _swiginac.SwigPyIterator_previous(self)
    def advance(self, *args): return _swiginac.SwigPyIterator_advance(self, *args)
    def __eq__(self, *args): return _swiginac.SwigPyIterator___eq__(self, *args)
    def __ne__(self, *args): return _swiginac.SwigPyIterator___ne__(self, *args)
    def __iadd__(self, *args): return _swiginac.SwigPyIterator___iadd__(self, *args)
    def __isub__(self, *args): return _swiginac.SwigPyIterator___isub__(self, *args)
    def __add__(self, *args): return _swiginac.SwigPyIterator___add__(self, *args)
    def __sub__(self, *args): return _swiginac.SwigPyIterator___sub__(self, *args)
    def __iter__(self): return self
SwigPyIterator_swigregister = _swiginac.SwigPyIterator_swigregister
SwigPyIterator_swigregister(SwigPyIterator)

class string(_object):
    __swig_setmethods__ = {}
    __setattr__ = lambda self, name, value: _swig_setattr(self, string, name, value)
    __swig_getmethods__ = {}
    __getattr__ = lambda self, name: _swig_getattr(self, string, name)
    __repr__ = _swig_repr
    def length(self): return _swiginac.string_length(self)
    def max_size(self): return _swiginac.string_max_size(self)
    def capacity(self): return _swiginac.string_capacity(self)
    def reserve(self, __res_arg=0): return _swiginac.string_reserve(self, __res_arg)
    def copy(self, *args): return _swiginac.string_copy(self, *args)
    def c_str(self): return _swiginac.string_c_str(self)
    def find(self, *args): return _swiginac.string_find(self, *args)
    def rfind(self, *args): return _swiginac.string_rfind(self, *args)
    def find_first_of(self, *args): return _swiginac.string_find_first_of(self, *args)
    def find_last_of(self, *args): return _swiginac.string_find_last_of(self, *args)
    def find_first_not_of(self, *args): return _swiginac.string_find_first_not_of(self, *args)
    def find_last_not_of(self, *args): return _swiginac.string_find_last_not_of(self, *args)
    def substr(self, *args): return _swiginac.string_substr(self, *args)
    def empty(self): return _swiginac.string_empty(self)
    def size(self): return _swiginac.string_size(self)
    def swap(self, *args): return _swiginac.string_swap(self, *args)
    def get_allocator(self): return _swiginac.string_get_allocator(self)
    def begin(self): return _swiginac.string_begin(self)
    def end(self): return _swiginac.string_end(self)
    def rbegin(self): return _swiginac.string_rbegin(self)
    def rend(self): return _swiginac.string_rend(self)
    def erase(self, *args): return _swiginac.string_erase(self, *args)
    def __init__(self, *args): 
        this = _swiginac.new_string(*args)
        try: self.this.append(this)
        except: self.this = this
    def assign(self, *args): return _swiginac.string_assign(self, *args)
    def resize(self, *args): return _swiginac.string_resize(self, *args)
    def iterator(self): return _swiginac.string_iterator(self)
    def __iter__(self): return self.iterator()
    def __nonzero__(self): return _swiginac.string___nonzero__(self)
    def __bool__(self): return _swiginac.string___bool__(self)
    def __len__(self): return _swiginac.string___len__(self)
    def __getslice__(self, *args): return _swiginac.string___getslice__(self, *args)
    def __setslice__(self, *args): return _swiginac.string___setslice__(self, *args)
    def __delslice__(self, *args): return _swiginac.string___delslice__(self, *args)
    def __delitem__(self, *args): return _swiginac.string___delitem__(self, *args)
    def __getitem__(self, *args): return _swiginac.string___getitem__(self, *args)
    def __setitem__(self, *args): return _swiginac.string___setitem__(self, *args)
    def insert(self, *args): return _swiginac.string_insert(self, *args)
    def replace(self, *args): return _swiginac.string_replace(self, *args)
    def __iadd__(self, *args): return _swiginac.string___iadd__(self, *args)
    def __add__(self, *args): return _swiginac.string___add__(self, *args)
    def __radd__(self, *args): return _swiginac.string___radd__(self, *args)
    def __str__(self): return _swiginac.string___str__(self)
    def __rlshift__(self, *args): return _swiginac.string___rlshift__(self, *args)
    def __eq__(self, *args): return _swiginac.string___eq__(self, *args)
    def __ne__(self, *args): return _swiginac.string___ne__(self, *args)
    def __gt__(self, *args): return _swiginac.string___gt__(self, *args)
    def __lt__(self, *args): return _swiginac.string___lt__(self, *args)
    def __ge__(self, *args): return _swiginac.string___ge__(self, *args)
    def __le__(self, *args): return _swiginac.string___le__(self, *args)
    __swig_destroy__ = _swiginac.delete_string
    __del__ = lambda self : None;
string_swigregister = _swiginac.string_swigregister
string_swigregister(string)
cvar = _swiginac.cvar
string.npos = _swiginac.cvar.string_npos

class ios_base(_object):
    __swig_setmethods__ = {}
    __setattr__ = lambda self, name, value: _swig_setattr(self, ios_base, name, value)
    __swig_getmethods__ = {}
    __getattr__ = lambda self, name: _swig_getattr(self, ios_base, name)
    def __init__(self, *args, **kwargs): raise AttributeError("No constructor defined")
    __repr__ = _swig_repr
    erase_event = _swiginac.ios_base_erase_event
    imbue_event = _swiginac.ios_base_imbue_event
    copyfmt_event = _swiginac.ios_base_copyfmt_event
    def register_callback(self, *args): return _swiginac.ios_base_register_callback(self, *args)
    def flags(self, *args): return _swiginac.ios_base_flags(self, *args)
    def setf(self, *args): return _swiginac.ios_base_setf(self, *args)
    def unsetf(self, *args): return _swiginac.ios_base_unsetf(self, *args)
    def precision(self, *args): return _swiginac.ios_base_precision(self, *args)
    def width(self, *args): return _swiginac.ios_base_width(self, *args)
    __swig_getmethods__["sync_with_stdio"] = lambda x: _swiginac.ios_base_sync_with_stdio
    if _newclass:sync_with_stdio = staticmethod(_swiginac.ios_base_sync_with_stdio)
    def imbue(self, *args): return _swiginac.ios_base_imbue(self, *args)
    def getloc(self): return _swiginac.ios_base_getloc(self)
    __swig_getmethods__["xalloc"] = lambda x: _swiginac.ios_base_xalloc
    if _newclass:xalloc = staticmethod(_swiginac.ios_base_xalloc)
    def iword(self, *args): return _swiginac.ios_base_iword(self, *args)
    def pword(self, *args): return _swiginac.ios_base_pword(self, *args)
    __swig_destroy__ = _swiginac.delete_ios_base
    __del__ = lambda self : None;
ios_base_swigregister = _swiginac.ios_base_swigregister
ios_base_swigregister(ios_base)
ios_base.boolalpha = _swiginac.cvar.ios_base_boolalpha
ios_base.dec = _swiginac.cvar.ios_base_dec
ios_base.fixed = _swiginac.cvar.ios_base_fixed
ios_base.hex = _swiginac.cvar.ios_base_hex
ios_base.internal = _swiginac.cvar.ios_base_internal
ios_base.left = _swiginac.cvar.ios_base_left
ios_base.oct = _swiginac.cvar.ios_base_oct
ios_base.right = _swiginac.cvar.ios_base_right
ios_base.scientific = _swiginac.cvar.ios_base_scientific
ios_base.showbase = _swiginac.cvar.ios_base_showbase
ios_base.showpoint = _swiginac.cvar.ios_base_showpoint
ios_base.showpos = _swiginac.cvar.ios_base_showpos
ios_base.skipws = _swiginac.cvar.ios_base_skipws
ios_base.unitbuf = _swiginac.cvar.ios_base_unitbuf
ios_base.uppercase = _swiginac.cvar.ios_base_uppercase
ios_base.adjustfield = _swiginac.cvar.ios_base_adjustfield
ios_base.basefield = _swiginac.cvar.ios_base_basefield
ios_base.floatfield = _swiginac.cvar.ios_base_floatfield
ios_base.badbit = _swiginac.cvar.ios_base_badbit
ios_base.eofbit = _swiginac.cvar.ios_base_eofbit
ios_base.failbit = _swiginac.cvar.ios_base_failbit
ios_base.goodbit = _swiginac.cvar.ios_base_goodbit
ios_base.app = _swiginac.cvar.ios_base_app
ios_base.ate = _swiginac.cvar.ios_base_ate
ios_base.binary = _swiginac.cvar.ios_base_binary
ios_base.ios_base_in = _swiginac.cvar.ios_base_ios_base_in
ios_base.out = _swiginac.cvar.ios_base_out
ios_base.trunc = _swiginac.cvar.ios_base_trunc
ios_base.beg = _swiginac.cvar.ios_base_beg
ios_base.cur = _swiginac.cvar.ios_base_cur
ios_base.end = _swiginac.cvar.ios_base_end

def ios_base_sync_with_stdio(__sync=True):
  return _swiginac.ios_base_sync_with_stdio(__sync)
ios_base_sync_with_stdio = _swiginac.ios_base_sync_with_stdio

def ios_base_xalloc():
  return _swiginac.ios_base_xalloc()
ios_base_xalloc = _swiginac.ios_base_xalloc

class ios(ios_base):
    __swig_setmethods__ = {}
    for _s in [ios_base]: __swig_setmethods__.update(getattr(_s,'__swig_setmethods__',{}))
    __setattr__ = lambda self, name, value: _swig_setattr(self, ios, name, value)
    __swig_getmethods__ = {}
    for _s in [ios_base]: __swig_getmethods__.update(getattr(_s,'__swig_getmethods__',{}))
    __getattr__ = lambda self, name: _swig_getattr(self, ios, name)
    __repr__ = _swig_repr
    def rdstate(self): return _swiginac.ios_rdstate(self)
    def clear(self, *args): return _swiginac.ios_clear(self, *args)
    def setstate(self, *args): return _swiginac.ios_setstate(self, *args)
    def good(self): return _swiginac.ios_good(self)
    def eof(self): return _swiginac.ios_eof(self)
    def fail(self): return _swiginac.ios_fail(self)
    def bad(self): return _swiginac.ios_bad(self)
    def exceptions(self, *args): return _swiginac.ios_exceptions(self, *args)
    def __init__(self, *args): 
        this = _swiginac.new_ios(*args)
        try: self.this.append(this)
        except: self.this = this
    __swig_destroy__ = _swiginac.delete_ios
    __del__ = lambda self : None;
    def tie(self, *args): return _swiginac.ios_tie(self, *args)
    def rdbuf(self, *args): return _swiginac.ios_rdbuf(self, *args)
    def copyfmt(self, *args): return _swiginac.ios_copyfmt(self, *args)
    def fill(self, *args): return _swiginac.ios_fill(self, *args)
    def imbue(self, *args): return _swiginac.ios_imbue(self, *args)
    def narrow(self, *args): return _swiginac.ios_narrow(self, *args)
    def widen(self, *args): return _swiginac.ios_widen(self, *args)
ios_swigregister = _swiginac.ios_swigregister
ios_swigregister(ios)

class streambuf(_object):
    __swig_setmethods__ = {}
    __setattr__ = lambda self, name, value: _swig_setattr(self, streambuf, name, value)
    __swig_getmethods__ = {}
    __getattr__ = lambda self, name: _swig_getattr(self, streambuf, name)
    def __init__(self, *args, **kwargs): raise AttributeError("No constructor defined")
    __repr__ = _swig_repr
    __swig_destroy__ = _swiginac.delete_streambuf
    __del__ = lambda self : None;
    def pubimbue(self, *args): return _swiginac.streambuf_pubimbue(self, *args)
    def getloc(self): return _swiginac.streambuf_getloc(self)
    def pubsetbuf(self, *args): return _swiginac.streambuf_pubsetbuf(self, *args)
    def pubseekoff(self, *args): return _swiginac.streambuf_pubseekoff(self, *args)
    def pubseekpos(self, *args): return _swiginac.streambuf_pubseekpos(self, *args)
    def pubsync(self): return _swiginac.streambuf_pubsync(self)
    def in_avail(self): return _swiginac.streambuf_in_avail(self)
    def snextc(self): return _swiginac.streambuf_snextc(self)
    def sbumpc(self): return _swiginac.streambuf_sbumpc(self)
    def sgetc(self): return _swiginac.streambuf_sgetc(self)
    def sgetn(self, *args): return _swiginac.streambuf_sgetn(self, *args)
    def sputbackc(self, *args): return _swiginac.streambuf_sputbackc(self, *args)
    def sungetc(self): return _swiginac.streambuf_sungetc(self)
    def sputc(self, *args): return _swiginac.streambuf_sputc(self, *args)
    def sputn(self, *args): return _swiginac.streambuf_sputn(self, *args)
streambuf_swigregister = _swiginac.streambuf_swigregister
streambuf_swigregister(streambuf)

class ostream(ios):
    __swig_setmethods__ = {}
    for _s in [ios]: __swig_setmethods__.update(getattr(_s,'__swig_setmethods__',{}))
    __setattr__ = lambda self, name, value: _swig_setattr(self, ostream, name, value)
    __swig_getmethods__ = {}
    for _s in [ios]: __swig_getmethods__.update(getattr(_s,'__swig_getmethods__',{}))
    __getattr__ = lambda self, name: _swig_getattr(self, ostream, name)
    __repr__ = _swig_repr
    def __init__(self, *args): 
        this = _swiginac.new_ostream(*args)
        try: self.this.append(this)
        except: self.this = this
    __swig_destroy__ = _swiginac.delete_ostream
    __del__ = lambda self : None;
    def __lshift__(self, *args): return _swiginac.ostream___lshift__(self, *args)
    def put(self, *args): return _swiginac.ostream_put(self, *args)
    def write(self, *args): return _swiginac.ostream_write(self, *args)
    def flush(self): return _swiginac.ostream_flush(self)
    def tellp(self): return _swiginac.ostream_tellp(self)
    def seekp(self, *args): return _swiginac.ostream_seekp(self, *args)
ostream_swigregister = _swiginac.ostream_swigregister
ostream_swigregister(ostream)
cin = cvar.cin
cout = cvar.cout
cerr = cvar.cerr
clog = cvar.clog

class istream(ios):
    __swig_setmethods__ = {}
    for _s in [ios]: __swig_setmethods__.update(getattr(_s,'__swig_setmethods__',{}))
    __setattr__ = lambda self, name, value: _swig_setattr(self, istream, name, value)
    __swig_getmethods__ = {}
    for _s in [ios]: __swig_getmethods__.update(getattr(_s,'__swig_getmethods__',{}))
    __getattr__ = lambda self, name: _swig_getattr(self, istream, name)
    __repr__ = _swig_repr
    def __init__(self, *args): 
        this = _swiginac.new_istream(*args)
        try: self.this.append(this)
        except: self.this = this
    __swig_destroy__ = _swiginac.delete_istream
    __del__ = lambda self : None;
    def __rshift__(self, *args): return _swiginac.istream___rshift__(self, *args)
    def gcount(self): return _swiginac.istream_gcount(self)
    def get(self, *args): return _swiginac.istream_get(self, *args)
    def getline(self, *args): return _swiginac.istream_getline(self, *args)
    def ignore(self, *args): return _swiginac.istream_ignore(self, *args)
    def peek(self): return _swiginac.istream_peek(self)
    def read(self, *args): return _swiginac.istream_read(self, *args)
    def readsome(self, *args): return _swiginac.istream_readsome(self, *args)
    def putback(self, *args): return _swiginac.istream_putback(self, *args)
    def unget(self): return _swiginac.istream_unget(self)
    def sync(self): return _swiginac.istream_sync(self)
    def tellg(self): return _swiginac.istream_tellg(self)
    def seekg(self, *args): return _swiginac.istream_seekg(self, *args)
istream_swigregister = _swiginac.istream_swigregister
istream_swigregister(istream)

class iostream(istream,ostream):
    __swig_setmethods__ = {}
    for _s in [istream,ostream]: __swig_setmethods__.update(getattr(_s,'__swig_setmethods__',{}))
    __setattr__ = lambda self, name, value: _swig_setattr(self, iostream, name, value)
    __swig_getmethods__ = {}
    for _s in [istream,ostream]: __swig_getmethods__.update(getattr(_s,'__swig_getmethods__',{}))
    __getattr__ = lambda self, name: _swig_getattr(self, iostream, name)
    __repr__ = _swig_repr
    def __init__(self, *args): 
        this = _swiginac.new_iostream(*args)
        try: self.this.append(this)
        except: self.this = this
    __swig_destroy__ = _swiginac.delete_iostream
    __del__ = lambda self : None;
iostream_swigregister = _swiginac.iostream_swigregister
iostream_swigregister(iostream)

endl_cb_ptr = _swiginac.endl_cb_ptr

def endl(*args):
  return _swiginac.endl(*args)
endl = _swiginac.endl
ends_cb_ptr = _swiginac.ends_cb_ptr

def ends(*args):
  return _swiginac.ends(*args)
ends = _swiginac.ends
flush_cb_ptr = _swiginac.flush_cb_ptr

def flush(*args):
  return _swiginac.flush(*args)
flush = _swiginac.flush
class istringstream(istream):
    __swig_setmethods__ = {}
    for _s in [istream]: __swig_setmethods__.update(getattr(_s,'__swig_setmethods__',{}))
    __setattr__ = lambda self, name, value: _swig_setattr(self, istringstream, name, value)
    __swig_getmethods__ = {}
    for _s in [istream]: __swig_getmethods__.update(getattr(_s,'__swig_getmethods__',{}))
    __getattr__ = lambda self, name: _swig_getattr(self, istringstream, name)
    __repr__ = _swig_repr
    def __init__(self, *args): 
        this = _swiginac.new_istringstream(*args)
        try: self.this.append(this)
        except: self.this = this
    __swig_destroy__ = _swiginac.delete_istringstream
    __del__ = lambda self : None;
    def rdbuf(self): return _swiginac.istringstream_rdbuf(self)
    def str(self, *args): return _swiginac.istringstream_str(self, *args)
istringstream_swigregister = _swiginac.istringstream_swigregister
istringstream_swigregister(istringstream)

class ostringstream(ostream):
    __swig_setmethods__ = {}
    for _s in [ostream]: __swig_setmethods__.update(getattr(_s,'__swig_setmethods__',{}))
    __setattr__ = lambda self, name, value: _swig_setattr(self, ostringstream, name, value)
    __swig_getmethods__ = {}
    for _s in [ostream]: __swig_getmethods__.update(getattr(_s,'__swig_getmethods__',{}))
    __getattr__ = lambda self, name: _swig_getattr(self, ostringstream, name)
    __repr__ = _swig_repr
    def __init__(self, *args): 
        this = _swiginac.new_ostringstream(*args)
        try: self.this.append(this)
        except: self.this = this
    __swig_destroy__ = _swiginac.delete_ostringstream
    __del__ = lambda self : None;
    def rdbuf(self): return _swiginac.ostringstream_rdbuf(self)
    def str(self): return _swiginac.ostringstream_str(self)
ostringstream_swigregister = _swiginac.ostringstream_swigregister
ostringstream_swigregister(ostringstream)

class stringstream(iostream):
    __swig_setmethods__ = {}
    for _s in [iostream]: __swig_setmethods__.update(getattr(_s,'__swig_setmethods__',{}))
    __setattr__ = lambda self, name, value: _swig_setattr(self, stringstream, name, value)
    __swig_getmethods__ = {}
    for _s in [iostream]: __swig_getmethods__.update(getattr(_s,'__swig_getmethods__',{}))
    __getattr__ = lambda self, name: _swig_getattr(self, stringstream, name)
    __repr__ = _swig_repr
    def __init__(self, *args): 
        this = _swiginac.new_stringstream(*args)
        try: self.this.append(this)
        except: self.this = this
    __swig_destroy__ = _swiginac.delete_stringstream
    __del__ = lambda self : None;
    def rdbuf(self): return _swiginac.stringstream_rdbuf(self)
    def str(self, *args): return _swiginac.stringstream_str(self, *args)
stringstream_swigregister = _swiginac.stringstream_swigregister
stringstream_swigregister(stringstream)

class refcounted(_object):
    """Proxy of C++ GiNaC::refcounted class"""
    __swig_setmethods__ = {}
    __setattr__ = lambda self, name, value: _swig_setattr(self, refcounted, name, value)
    __swig_getmethods__ = {}
    __getattr__ = lambda self, name: _swig_getattr(self, refcounted, name)
    __repr__ = _swig_repr
    def __init__(self): 
        """__init__(GiNaC::refcounted self) -> refcounted"""
        this = _swiginac.new_refcounted()
        try: self.this.append(this)
        except: self.this = this
    def add_reference(self):
        """add_reference(refcounted self) -> size_t"""
        return _swiginac.refcounted_add_reference(self)

    def remove_reference(self):
        """remove_reference(refcounted self) -> size_t"""
        return _swiginac.refcounted_remove_reference(self)

    def get_refcount(self):
        """get_refcount(refcounted self) -> size_t"""
        return _swiginac.refcounted_get_refcount(self)

    def set_refcount(self, *args):
        """set_refcount(refcounted self, size_t r)"""
        return _swiginac.refcounted_set_refcount(self, *args)

    __swig_destroy__ = _swiginac.delete_refcounted
    __del__ = lambda self : None;
refcounted_swigregister = _swiginac.refcounted_swigregister
refcounted_swigregister(refcounted)

class registered_class_options(_object):
    """Proxy of C++ GiNaC::registered_class_options class"""
    __swig_setmethods__ = {}
    __setattr__ = lambda self, name, value: _swig_setattr(self, registered_class_options, name, value)
    __swig_getmethods__ = {}
    __getattr__ = lambda self, name: _swig_getattr(self, registered_class_options, name)
    __repr__ = _swig_repr
    def __init__(self, *args): 
        """__init__(GiNaC::registered_class_options self, char const * n, char const * p, std::type_info const & ti) -> registered_class_options"""
        this = _swiginac.new_registered_class_options(*args)
        try: self.this.append(this)
        except: self.this = this
    def get_name(self):
        """get_name(registered_class_options self) -> char const *"""
        return _swiginac.registered_class_options_get_name(self)

    def get_parent_name(self):
        """get_parent_name(registered_class_options self) -> char const *"""
        return _swiginac.registered_class_options_get_parent_name(self)

    def get_id(self):
        """get_id(registered_class_options self) -> std::type_info const *"""
        return _swiginac.registered_class_options_get_id(self)

    def get_print_dispatch_table(self):
        """get_print_dispatch_table(registered_class_options self) -> std::vector< print_functor,std::allocator< print_functor > > const &"""
        return _swiginac.registered_class_options_get_print_dispatch_table(self)

    def set_print_func(self, *args):
        """set_print_func(registered_class_options self, unsigned int id, print_functor const & f)"""
        return _swiginac.registered_class_options_set_print_func(self, *args)

    __swig_destroy__ = _swiginac.delete_registered_class_options
    __del__ = lambda self : None;
registered_class_options_swigregister = _swiginac.registered_class_options_swigregister
registered_class_options_swigregister(registered_class_options)

class ex(_object):
    """Proxy of C++ GiNaC::ex class"""
    __swig_setmethods__ = {}
    __setattr__ = lambda self, name, value: _swig_setattr(self, ex, name, value)
    __swig_getmethods__ = {}
    __getattr__ = lambda self, name: _swig_getattr(self, ex, name)
    __repr__ = _swig_repr
    def eval(self, level=0):
        """
        eval(ex self, int level=0) -> ex
        eval(ex self) -> ex
        """
        return _swiginac.ex_eval(self, level)

    def __init__(self): 
        """__init__(GiNaC::ex self) -> ex"""
        this = _swiginac.new_ex()
        try: self.this.append(this)
        except: self.this = this
    __swig_destroy__ = _swiginac.delete_ex
    __del__ = lambda self : None;
ex_swigregister = _swiginac.ex_swigregister
ex_swigregister(ex)

class lst(_object):
    """Proxy of C++ GiNaC::lst class"""
    __swig_setmethods__ = {}
    __setattr__ = lambda self, name, value: _swig_setattr(self, lst, name, value)
    __swig_getmethods__ = {}
    __getattr__ = lambda self, name: _swig_getattr(self, lst, name)
    __repr__ = _swig_repr
    def __init__(self): 
        """__init__(GiNaC::lst self) -> lst"""
        this = _swiginac.new_lst()
        try: self.this.append(this)
        except: self.this = this
    __swig_destroy__ = _swiginac.delete_lst
    __del__ = lambda self : None;
lst_swigregister = _swiginac.lst_swigregister
lst_swigregister(lst)

class basic(refcounted):
    """Proxy of C++ GiNaC::basic class"""
    __swig_setmethods__ = {}
    for _s in [refcounted]: __swig_setmethods__.update(getattr(_s,'__swig_setmethods__',{}))
    __setattr__ = lambda self, name, value: _swig_setattr(self, basic, name, value)
    __swig_getmethods__ = {}
    for _s in [refcounted]: __swig_getmethods__.update(getattr(_s,'__swig_getmethods__',{}))
    __getattr__ = lambda self, name: _swig_getattr(self, basic, name)
    __repr__ = _swig_repr
    __swig_destroy__ = _swiginac.delete_basic
    __del__ = lambda self : None;
    def __init__(self, *args): 
        """__init__(GiNaC::basic self, basic other) -> basic"""
        this = _swiginac.new_basic(*args)
        try: self.this.append(this)
        except: self.this = this
    def duplicate(self):
        """duplicate(basic self) -> basic"""
        return _swiginac.basic_duplicate(self)

    def eval(self, level=0):
        """
        eval(basic self, int level=0) -> ex
        eval(basic self) -> ex
        """
        return _swiginac.basic_eval(self, level)

    def evalf(self, level=0):
        """
        evalf(basic self, int level=0) -> ex
        evalf(basic self) -> ex
        """
        return _swiginac.basic_evalf(self, level)

    def evalm(self):
        """evalm(basic self) -> ex"""
        return _swiginac.basic_evalm(self)

    def eval_indexed(self, *args):
        """eval_indexed(basic self, basic i) -> ex"""
        return _swiginac.basic_eval_indexed(self, *args)

    def dbgprint(self):
        """dbgprint(basic self)"""
        return _swiginac.basic_dbgprint(self)

    def dbgprinttree(self):
        """dbgprinttree(basic self)"""
        return _swiginac.basic_dbgprinttree(self)

    def precedence(self):
        """precedence(basic self) -> unsigned int"""
        return _swiginac.basic_precedence(self)

    def info(self, *args):
        """info(basic self, unsigned int inf) -> bool"""
        return _swiginac.basic_info(self, *args)

    def nops(self):
        """nops(basic self) -> size_t"""
        return _swiginac.basic_nops(self)

    def op(self, *args):
        """op(basic self, size_t i) -> ex"""
        return _swiginac.basic_op(self, *args)

    def let_op(self, *args):
        """let_op(basic self, size_t i) -> ex"""
        return _swiginac.basic_let_op(self, *args)

    def has(self, *args):
        """
        has(basic self, ex other, unsigned int options=0) -> bool
        has(basic self, ex other) -> bool
        """
        return _swiginac.basic_has(self, *args)

    def match(self, *args):
        """match(basic self, ex pattern, exmap repls) -> bool"""
        return _swiginac.basic_match(self, *args)

    def map(self, *args):
        """map(basic self, GiNaC::map_function & f) -> ex"""
        return _swiginac.basic_map(self, *args)

    def accept(self, *args):
        """accept(basic self, GiNaC::visitor & v)"""
        return _swiginac.basic_accept(self, *args)

    def is_polynomial(self, *args):
        """is_polynomial(basic self, ex var) -> bool"""
        return _swiginac.basic_is_polynomial(self, *args)

    def degree(self, *args):
        """degree(basic self, ex s) -> int"""
        return _swiginac.basic_degree(self, *args)

    def ldegree(self, *args):
        """ldegree(basic self, ex s) -> int"""
        return _swiginac.basic_ldegree(self, *args)

    def coeff(self, *args):
        """
        coeff(basic self, ex s, int n=1) -> ex
        coeff(basic self, ex s) -> ex
        """
        return _swiginac.basic_coeff(self, *args)

    def expand(self, options=0):
        """
        expand(basic self, unsigned int options=0) -> ex
        expand(basic self) -> ex
        """
        return _swiginac.basic_expand(self, options)

    def collect(self, *args):
        """
        collect(basic self, ex s, bool distributed=False) -> ex
        collect(basic self, ex s) -> ex
        """
        return _swiginac.basic_collect(self, *args)

    def series(self, *args):
        """
        series(basic self, relational r, int order, unsigned int options=0) -> ex
        series(basic self, relational r, int order) -> ex
        """
        return _swiginac.basic_series(self, *args)

    def to_rational(self, *args):
        """to_rational(basic self, exmap repl) -> ex"""
        return _swiginac.basic_to_rational(self, *args)

    def to_polynomial(self, *args):
        """to_polynomial(basic self, exmap repl) -> ex"""
        return _swiginac.basic_to_polynomial(self, *args)

    def integer_content(self):
        """integer_content(basic self) -> numeric"""
        return _swiginac.basic_integer_content(self)

    def smod(self, *args):
        """smod(basic self, numeric xi) -> ex"""
        return _swiginac.basic_smod(self, *args)

    def max_coefficient(self):
        """max_coefficient(basic self) -> numeric"""
        return _swiginac.basic_max_coefficient(self)

    def get_free_indices(self):
        """get_free_indices(basic self) -> exvector"""
        return _swiginac.basic_get_free_indices(self)

    def add_indexed(self, *args):
        """add_indexed(basic self, ex self, ex other) -> ex"""
        return _swiginac.basic_add_indexed(self, *args)

    def scalar_mul_indexed(self, *args):
        """scalar_mul_indexed(basic self, ex self, numeric other) -> ex"""
        return _swiginac.basic_scalar_mul_indexed(self, *args)

    def contract_with(self, *args):
        """contract_with(basic self, exvector::iterator self, exvector::iterator other, exvector & v) -> bool"""
        return _swiginac.basic_contract_with(self, *args)

    def return_type(self):
        """return_type(basic self) -> unsigned int"""
        return _swiginac.basic_return_type(self)

    def return_type_tinfo(self):
        """return_type_tinfo(basic self) -> GiNaC::return_type_t"""
        return _swiginac.basic_return_type_tinfo(self)

    def conjugate(self):
        """conjugate(basic self) -> ex"""
        return _swiginac.basic_conjugate(self)

    def real_part(self):
        """real_part(basic self) -> ex"""
        return _swiginac.basic_real_part(self)

    def imag_part(self):
        """imag_part(basic self) -> ex"""
        return _swiginac.basic_imag_part(self)

    def print_dispatch(self, *args):
        """print_dispatch(basic self, GiNaC::registered_class_info const & ri, GiNaC::print_context const & c, unsigned int level)"""
        return _swiginac.basic_print_dispatch(self, *args)

    def subs_one_level(self, *args):
        """subs_one_level(basic self, exmap m, unsigned int options) -> ex"""
        return _swiginac.basic_subs_one_level(self, *args)

    def diff(self, *args):
        """
        diff(basic self, symbol s, unsigned int nth=1) -> ex
        diff(basic self, symbol s) -> ex
        """
        return _swiginac.basic_diff(self, *args)

    def compare(self, *args):
        """compare(basic self, basic other) -> int"""
        return _swiginac.basic_compare(self, *args)

    def is_equal(self, *args):
        """is_equal(basic self, basic other) -> bool"""
        return _swiginac.basic_is_equal(self, *args)

    def hold(self):
        """hold(basic self) -> basic"""
        return _swiginac.basic_hold(self)

    def gethash(self):
        """gethash(basic self) -> unsigned int"""
        return _swiginac.basic_gethash(self)

    def setflag(self, *args):
        """setflag(basic self, unsigned int f) -> basic"""
        return _swiginac.basic_setflag(self, *args)

    def clearflag(self, *args):
        """clearflag(basic self, unsigned int f) -> basic"""
        return _swiginac.basic_clearflag(self, *args)

    def printpython(self):
        """printpython(basic self) -> string"""
        return _swiginac.basic_printpython(self)

    def printlatex(self):
        """printlatex(basic self) -> string"""
        return _swiginac.basic_printlatex(self)

    def printc(self):
        """printc(basic self) -> string"""
        return _swiginac.basic_printc(self)

    def __hash__(self):
        """__hash__(basic self) -> unsigned int"""
        return _swiginac.basic___hash__(self)

    def __nonzero__(self):
        """__nonzero__(basic self) -> bool"""
        return _swiginac.basic___nonzero__(self)

    def __add__(self, *args):
        """
        __add__(basic self, basic b) -> ex
        __add__(basic self, int const & b) -> ex
        __add__(basic self, double const & b) -> ex
        """
        return _swiginac.basic___add__(self, *args)

    def __radd__(self, *args):
        """
        __radd__(basic self, basic b) -> ex
        __radd__(basic self, int const & b) -> ex
        __radd__(basic self, double const & b) -> ex
        """
        return _swiginac.basic___radd__(self, *args)

    def __sub__(self, *args):
        """
        __sub__(basic self, basic b) -> ex
        __sub__(basic self, int const & b) -> ex
        __sub__(basic self, double const & b) -> ex
        """
        return _swiginac.basic___sub__(self, *args)

    def __rsub__(self, *args):
        """
        __rsub__(basic self, basic b) -> ex
        __rsub__(basic self, int const & b) -> ex
        __rsub__(basic self, double const & b) -> ex
        """
        return _swiginac.basic___rsub__(self, *args)

    def __mul__(self, *args):
        """
        __mul__(basic self, basic b) -> ex
        __mul__(basic self, int const & b) -> ex
        __mul__(basic self, double const & b) -> ex
        """
        return _swiginac.basic___mul__(self, *args)

    def __rmul__(self, *args):
        """
        __rmul__(basic self, basic b) -> ex
        __rmul__(basic self, int const & b) -> ex
        __rmul__(basic self, double const & b) -> ex
        """
        return _swiginac.basic___rmul__(self, *args)

    def __div__(self, *args):
        """
        __div__(basic self, basic b) -> ex
        __div__(basic self, int const & b) -> ex
        __div__(basic self, double const & b) -> ex
        """
        return _swiginac.basic___div__(self, *args)

    def __rdiv__(self, *args):
        """
        __rdiv__(basic self, basic b) -> ex
        __rdiv__(basic self, int const & b) -> ex
        __rdiv__(basic self, double const & b) -> ex
        """
        return _swiginac.basic___rdiv__(self, *args)

    def __pow__(self, *args):
        """
        __pow__(basic self, basic b) -> ex
        __pow__(basic self, int const & b) -> ex
        __pow__(basic self, double const & b) -> ex
        """
        return _swiginac.basic___pow__(self, *args)

    def __rpow__(self, *args):
        """
        __rpow__(basic self, basic b) -> ex
        __rpow__(basic self, int const & b) -> ex
        __rpow__(basic self, double const & b) -> ex
        """
        return _swiginac.basic___rpow__(self, *args)

    def __pos__(self):
        """__pos__(basic self) -> ex"""
        return _swiginac.basic___pos__(self)

    def __neg__(self):
        """__neg__(basic self) -> ex"""
        return _swiginac.basic___neg__(self)

    def __lt__(self, *args):
        """
        __lt__(basic self, basic b) -> ex
        __lt__(basic self, int const & b) -> ex
        __lt__(basic self, double const & b) -> ex
        """
        return _swiginac.basic___lt__(self, *args)

    def __le__(self, *args):
        """
        __le__(basic self, basic b) -> ex
        __le__(basic self, int const & b) -> ex
        __le__(basic self, double const & b) -> ex
        """
        return _swiginac.basic___le__(self, *args)

    def __eq__(self, *args):
        """
        __eq__(basic self, basic b) -> ex
        __eq__(basic self, int const & b) -> ex
        __eq__(basic self, double const & b) -> ex
        """
        return _swiginac.basic___eq__(self, *args)

    def __ne__(self, *args):
        """
        __ne__(basic self, basic b) -> ex
        __ne__(basic self, int const & b) -> ex
        __ne__(basic self, double const & b) -> ex
        """
        return _swiginac.basic___ne__(self, *args)

    def __gt__(self, *args):
        """
        __gt__(basic self, basic b) -> ex
        __gt__(basic self, int const & b) -> ex
        __gt__(basic self, double const & b) -> ex
        """
        return _swiginac.basic___gt__(self, *args)

    def __ge__(self, *args):
        """
        __ge__(basic self, basic b) -> ex
        __ge__(basic self, int const & b) -> ex
        __ge__(basic self, double const & b) -> ex
        """
        return _swiginac.basic___ge__(self, *args)

    def set_print_context(self, context_type):
        if context_type == "python":
            self.str = self.printpython
        elif context_type == "tex":
            self.str = self.printlatex
        elif context_type == "c":
            self.str = self.printc

    def __str__(self):
        if not self.__dict__.has_key("str"):
            self.str = self.printpython
        return self.str()

    def __copy__(self):
        return self.copy()


    def subs(self, *args):
        """
        subs(basic self, exmap m, unsigned int options=0) -> ex
        subs(basic self, exmap m) -> ex
        subs(basic self, lst ls, lst lr) -> ex
        subs(basic self, ex e, unsigned int options=0) -> ex
        subs(basic self, ex e) -> ex
        """
        return _swiginac.basic_subs(self, *args)

    def normal(self, *args):
        """
        normal(basic self, exmap repl, exmap rev_lookup, int level=0) -> ex
        normal(basic self, exmap repl, exmap rev_lookup) -> ex
        normal(basic self, int level=0) -> ex
        normal(basic self) -> ex
        """
        return _swiginac.basic_normal(self, *args)

    def denom(self):
        """denom(basic self) -> ex"""
        return _swiginac.basic_denom(self)

    def is_zero(self):
        """is_zero(basic self) -> bool"""
        return _swiginac.basic_is_zero(self)

    def content(self, *args):
        """content(basic self, ex x) -> ex"""
        return _swiginac.basic_content(self, *args)

    def primpart(self, *args):
        """primpart(basic self, ex x) -> ex"""
        return _swiginac.basic_primpart(self, *args)

    def unit(self, *args):
        """unit(basic self, ex x) -> ex"""
        return _swiginac.basic_unit(self, *args)

    def simplify_indexed(self, *args):
        """
        simplify_indexed(basic self, unsigned int options=0) -> ex
        simplify_indexed(basic self) -> ex
        simplify_indexed(basic self, scalar_products sp, unsigned int options=0) -> ex
        simplify_indexed(basic self, scalar_products sp) -> ex
        """
        return _swiginac.basic_simplify_indexed(self, *args)

    def copy(self):
        """copy(basic self) -> ex"""
        return _swiginac.basic_copy(self)

    def toex(self):
        """toex(basic self) -> ex"""
        return _swiginac.basic_toex(self)

basic_swigregister = _swiginac.basic_swigregister
basic_swigregister(basic)

class symbol(basic):
    """Proxy of C++ GiNaC::symbol class"""
    __swig_setmethods__ = {}
    for _s in [basic]: __swig_setmethods__.update(getattr(_s,'__swig_setmethods__',{}))
    __setattr__ = lambda self, name, value: _swig_setattr(self, symbol, name, value)
    __swig_getmethods__ = {}
    for _s in [basic]: __swig_getmethods__.update(getattr(_s,'__swig_getmethods__',{}))
    __getattr__ = lambda self, name: _swig_getattr(self, symbol, name)
    __repr__ = _swig_repr
    def __init__(self, *args): 
        """
        __init__(GiNaC::symbol self) -> symbol
        __init__(GiNaC::symbol self, string initname) -> symbol
        __init__(GiNaC::symbol self, string initname, string texname) -> symbol
        """
        this = _swiginac.new_symbol(*args)
        try: self.this.append(this)
        except: self.this = this
    def conjugate(self):
        """conjugate(symbol self) -> ex"""
        return _swiginac.symbol_conjugate(self)

    def real_part(self):
        """real_part(symbol self) -> ex"""
        return _swiginac.symbol_real_part(self)

    def imag_part(self):
        """imag_part(symbol self) -> ex"""
        return _swiginac.symbol_imag_part(self)

    def __repr__(self):
        return self.__str__()

    __swig_destroy__ = _swiginac.delete_symbol
    __del__ = lambda self : None;
symbol_swigregister = _swiginac.symbol_swigregister
symbol_swigregister(symbol)

class realsymbol(symbol):
    """Proxy of C++ GiNaC::realsymbol class"""
    __swig_setmethods__ = {}
    for _s in [symbol]: __swig_setmethods__.update(getattr(_s,'__swig_setmethods__',{}))
    __setattr__ = lambda self, name, value: _swig_setattr(self, realsymbol, name, value)
    __swig_getmethods__ = {}
    for _s in [symbol]: __swig_getmethods__.update(getattr(_s,'__swig_getmethods__',{}))
    __getattr__ = lambda self, name: _swig_getattr(self, realsymbol, name)
    __repr__ = _swig_repr
    def __init__(self, *args): 
        """
        __init__(GiNaC::realsymbol self) -> realsymbol
        __init__(GiNaC::realsymbol self, string initname) -> realsymbol
        __init__(GiNaC::realsymbol self, string initname, string texname) -> realsymbol
        """
        this = _swiginac.new_realsymbol(*args)
        try: self.this.append(this)
        except: self.this = this
    def conjugate(self):
        """conjugate(realsymbol self) -> ex"""
        return _swiginac.realsymbol_conjugate(self)

    def real_part(self):
        """real_part(realsymbol self) -> ex"""
        return _swiginac.realsymbol_real_part(self)

    def imag_part(self):
        """imag_part(realsymbol self) -> ex"""
        return _swiginac.realsymbol_imag_part(self)

    __swig_destroy__ = _swiginac.delete_realsymbol
    __del__ = lambda self : None;
realsymbol_swigregister = _swiginac.realsymbol_swigregister
realsymbol_swigregister(realsymbol)

class numeric(basic):
    """Proxy of C++ GiNaC::numeric class"""
    __swig_setmethods__ = {}
    for _s in [basic]: __swig_setmethods__.update(getattr(_s,'__swig_setmethods__',{}))
    __setattr__ = lambda self, name, value: _swig_setattr(self, numeric, name, value)
    __swig_getmethods__ = {}
    for _s in [basic]: __swig_getmethods__.update(getattr(_s,'__swig_getmethods__',{}))
    __getattr__ = lambda self, name: _swig_getattr(self, numeric, name)
    __repr__ = _swig_repr
    def add(self, *args):
        """add(numeric self, numeric other) -> numeric"""
        return _swiginac.numeric_add(self, *args)

    def sub(self, *args):
        """sub(numeric self, numeric other) -> numeric"""
        return _swiginac.numeric_sub(self, *args)

    def mul(self, *args):
        """mul(numeric self, numeric other) -> numeric"""
        return _swiginac.numeric_mul(self, *args)

    def div(self, *args):
        """div(numeric self, numeric other) -> numeric"""
        return _swiginac.numeric_div(self, *args)

    def power(self, *args):
        """power(numeric self, numeric other) -> numeric"""
        return _swiginac.numeric_power(self, *args)

    def add_dyn(self, *args):
        """add_dyn(numeric self, numeric other) -> numeric"""
        return _swiginac.numeric_add_dyn(self, *args)

    def sub_dyn(self, *args):
        """sub_dyn(numeric self, numeric other) -> numeric"""
        return _swiginac.numeric_sub_dyn(self, *args)

    def mul_dyn(self, *args):
        """mul_dyn(numeric self, numeric other) -> numeric"""
        return _swiginac.numeric_mul_dyn(self, *args)

    def div_dyn(self, *args):
        """div_dyn(numeric self, numeric other) -> numeric"""
        return _swiginac.numeric_div_dyn(self, *args)

    def power_dyn(self, *args):
        """power_dyn(numeric self, numeric other) -> numeric"""
        return _swiginac.numeric_power_dyn(self, *args)

    def inverse(self):
        """inverse(numeric self) -> numeric"""
        return _swiginac.numeric_inverse(self)

    def csgn(self):
        """csgn(numeric self) -> int"""
        return _swiginac.numeric_csgn(self)

    def compare(self, *args):
        """compare(numeric self, numeric other) -> int"""
        return _swiginac.numeric_compare(self, *args)

    def is_equal(self, *args):
        """is_equal(numeric self, numeric other) -> bool"""
        return _swiginac.numeric_is_equal(self, *args)

    def is_zero(self):
        """is_zero(numeric self) -> bool"""
        return _swiginac.numeric_is_zero(self)

    def is_positive(self):
        """is_positive(numeric self) -> bool"""
        return _swiginac.numeric_is_positive(self)

    def is_negative(self):
        """is_negative(numeric self) -> bool"""
        return _swiginac.numeric_is_negative(self)

    def is_integer(self):
        """is_integer(numeric self) -> bool"""
        return _swiginac.numeric_is_integer(self)

    def is_pos_integer(self):
        """is_pos_integer(numeric self) -> bool"""
        return _swiginac.numeric_is_pos_integer(self)

    def is_nonneg_integer(self):
        """is_nonneg_integer(numeric self) -> bool"""
        return _swiginac.numeric_is_nonneg_integer(self)

    def is_even(self):
        """is_even(numeric self) -> bool"""
        return _swiginac.numeric_is_even(self)

    def is_odd(self):
        """is_odd(numeric self) -> bool"""
        return _swiginac.numeric_is_odd(self)

    def is_prime(self):
        """is_prime(numeric self) -> bool"""
        return _swiginac.numeric_is_prime(self)

    def is_rational(self):
        """is_rational(numeric self) -> bool"""
        return _swiginac.numeric_is_rational(self)

    def is_real(self):
        """is_real(numeric self) -> bool"""
        return _swiginac.numeric_is_real(self)

    def is_cinteger(self):
        """is_cinteger(numeric self) -> bool"""
        return _swiginac.numeric_is_cinteger(self)

    def is_crational(self):
        """is_crational(numeric self) -> bool"""
        return _swiginac.numeric_is_crational(self)

    def to_int(self):
        """to_int(numeric self) -> int"""
        return _swiginac.numeric_to_int(self)

    def to_long(self):
        """to_long(numeric self) -> long"""
        return _swiginac.numeric_to_long(self)

    def to_double(self):
        """to_double(numeric self) -> double"""
        return _swiginac.numeric_to_double(self)

    def to_cl_N(self):
        """to_cl_N(numeric self) -> cln::cl_N"""
        return _swiginac.numeric_to_cl_N(self)

    def real(self):
        """real(numeric self) -> numeric"""
        return _swiginac.numeric_real(self)

    def imag(self):
        """imag(numeric self) -> numeric"""
        return _swiginac.numeric_imag(self)

    def numer(self):
        """numer(numeric self) -> numeric"""
        return _swiginac.numeric_numer(self)

    def denom(self):
        """denom(numeric self) -> numeric"""
        return _swiginac.numeric_denom(self)

    def int_length(self):
        """int_length(numeric self) -> int"""
        return _swiginac.numeric_int_length(self)

    def __init__(self, *args): 
        """
        __init__(GiNaC::numeric self, int i) -> numeric
        __init__(GiNaC::numeric self, unsigned int i) -> numeric
        __init__(GiNaC::numeric self, long i) -> numeric
        __init__(GiNaC::numeric self, unsigned long i) -> numeric
        __init__(GiNaC::numeric self, long numer, long denom) -> numeric
        __init__(GiNaC::numeric self, double d) -> numeric
        __init__(GiNaC::numeric self, char const * arg2) -> numeric
        __init__(GiNaC::numeric self, cln::cl_N const & z) -> numeric
        """
        this = _swiginac.new_numeric(*args)
        try: self.this.append(this)
        except: self.this = this
    def __float__(self):
        """__float__(numeric self) -> double"""
        return _swiginac.numeric___float__(self)

    def __int__(self):
        """__int__(numeric self) -> int"""
        return _swiginac.numeric___int__(self)

    def __repr__(self):
        return self.__str__()

    __swig_destroy__ = _swiginac.delete_numeric
    __del__ = lambda self : None;
numeric_swigregister = _swiginac.numeric_swigregister
numeric_swigregister(numeric)


def PiEvalf():
  """PiEvalf() -> ex"""
  return _swiginac.PiEvalf()

def EulerEvalf():
  """EulerEvalf() -> ex"""
  return _swiginac.EulerEvalf()

def CatalanEvalf():
  """CatalanEvalf() -> ex"""
  return _swiginac.CatalanEvalf()
class relational(basic):
    """Proxy of C++ GiNaC::relational class"""
    __swig_setmethods__ = {}
    for _s in [basic]: __swig_setmethods__.update(getattr(_s,'__swig_setmethods__',{}))
    __setattr__ = lambda self, name, value: _swig_setattr(self, relational, name, value)
    __swig_getmethods__ = {}
    for _s in [basic]: __swig_getmethods__.update(getattr(_s,'__swig_getmethods__',{}))
    __getattr__ = lambda self, name: _swig_getattr(self, relational, name)
    __repr__ = _swig_repr
    equal = _swiginac.relational_equal
    not_equal = _swiginac.relational_not_equal
    less = _swiginac.relational_less
    less_or_equal = _swiginac.relational_less_or_equal
    greater = _swiginac.relational_greater
    greater_or_equal = _swiginac.relational_greater_or_equal
    def __init__(self, *args): 
        """
        __init__(GiNaC::relational self, ex lhs, ex rhs, GiNaC::relational::operators oper=equal) -> relational
        __init__(GiNaC::relational self, ex lhs, ex rhs) -> relational
        """
        this = _swiginac.new_relational(*args)
        try: self.this.append(this)
        except: self.this = this
    def lhs(self):
        """lhs(relational self) -> ex"""
        return _swiginac.relational_lhs(self)

    def rhs(self):
        """rhs(relational self) -> ex"""
        return _swiginac.relational_rhs(self)

    def __repr__(self):
        return self.__str__()

    __swig_destroy__ = _swiginac.delete_relational
    __del__ = lambda self : None;
relational_swigregister = _swiginac.relational_swigregister
relational_swigregister(relational)


def quo(*args):
  """
    quo(ex a, ex b, ex x, bool check_args=True) -> ex
    quo(ex a, ex b, ex x) -> ex
    """
  return _swiginac.quo(*args)

def rem(*args):
  """
    rem(ex a, ex b, ex x, bool check_args=True) -> ex
    rem(ex a, ex b, ex x) -> ex
    """
  return _swiginac.rem(*args)

def decomp_rational(*args):
  """decomp_rational(ex a, ex x) -> ex"""
  return _swiginac.decomp_rational(*args)

def prem(*args):
  """
    prem(ex a, ex b, ex x, bool check_args=True) -> ex
    prem(ex a, ex b, ex x) -> ex
    """
  return _swiginac.prem(*args)

def sprem(*args):
  """
    sprem(ex a, ex b, ex x, bool check_args=True) -> ex
    sprem(ex a, ex b, ex x) -> ex
    """
  return _swiginac.sprem(*args)

def divide(*args):
  """
    divide(ex a, ex b, ex q, bool check_args=True) -> bool
    divide(ex a, ex b, ex q) -> bool
    """
  return _swiginac.divide(*args)

def gcd(*args):
  """
    gcd(ex a, ex b, ex ca=None, ex cb=None, bool check_args=True) -> ex
    gcd(ex a, ex b, ex ca=None, ex cb=None) -> ex
    gcd(ex a, ex b, ex ca=None) -> ex
    gcd(ex a, ex b) -> ex
    """
  return _swiginac.gcd(*args)

def lcm(*args):
  """
    lcm(ex a, ex b, bool check_args=True) -> ex
    lcm(ex a, ex b) -> ex
    """
  return _swiginac.lcm(*args)

def sqrfree(*args):
  """
    sqrfree(ex a, lst l=GiNaC::lst()) -> ex
    sqrfree(ex a) -> ex
    """
  return _swiginac.sqrfree(*args)

def sqrfree_parfrac(*args):
  """sqrfree_parfrac(ex a, symbol x) -> ex"""
  return _swiginac.sqrfree_parfrac(*args)

def collect_common_factors(*args):
  """collect_common_factors(ex e) -> ex"""
  return _swiginac.collect_common_factors(*args)

def resultant(*args):
  """resultant(ex e1, ex e2, ex s) -> ex"""
  return _swiginac.resultant(*args)
class constant(basic):
    """Proxy of C++ GiNaC::constant class"""
    __swig_setmethods__ = {}
    for _s in [basic]: __swig_setmethods__.update(getattr(_s,'__swig_setmethods__',{}))
    __setattr__ = lambda self, name, value: _swig_setattr(self, constant, name, value)
    __swig_getmethods__ = {}
    for _s in [basic]: __swig_getmethods__.update(getattr(_s,'__swig_getmethods__',{}))
    __getattr__ = lambda self, name: _swig_getattr(self, constant, name)
    __repr__ = _swig_repr
    def __init__(self, *args): 
        """
        __init__(GiNaC::constant self) -> constant
        __init__(GiNaC::constant self, string initname, evalffunctype efun=0, string texname=std::string()) -> constant
        __init__(GiNaC::constant self, string initname, evalffunctype efun=0) -> constant
        __init__(GiNaC::constant self, string initname) -> constant
        __init__(GiNaC::constant self, string initname, numeric initnumber, string texname=std::string()) -> constant
        __init__(GiNaC::constant self, string initname, numeric initnumber) -> constant
        """
        this = _swiginac.new_constant(*args)
        try: self.this.append(this)
        except: self.this = this
    def __repr__(self):
        return self.__str__()

    __swig_destroy__ = _swiginac.delete_constant
    __del__ = lambda self : None;
constant_swigregister = _swiginac.constant_swigregister
constant_swigregister(constant)

Pi=cvar.Pi
I=cvar.I

class integral(basic):
    """Proxy of C++ GiNaC::integral class"""
    __swig_setmethods__ = {}
    for _s in [basic]: __swig_setmethods__.update(getattr(_s,'__swig_setmethods__',{}))
    __setattr__ = lambda self, name, value: _swig_setattr(self, integral, name, value)
    __swig_getmethods__ = {}
    for _s in [basic]: __swig_getmethods__.update(getattr(_s,'__swig_getmethods__',{}))
    __getattr__ = lambda self, name: _swig_getattr(self, integral, name)
    __repr__ = _swig_repr
    def __init__(self, *args): 
        """__init__(GiNaC::integral self, ex x_, ex a_, ex b_, ex f_) -> integral"""
        this = _swiginac.new_integral(*args)
        try: self.this.append(this)
        except: self.this = this
    def get_free_indices(self):
        """get_free_indices(integral self) -> exvector"""
        return _swiginac.integral_get_free_indices(self)

    def return_type(self):
        """return_type(integral self) -> unsigned int"""
        return _swiginac.integral_return_type(self)

    def return_type_tinfo(self):
        """return_type_tinfo(integral self) -> GiNaC::return_type_t"""
        return _swiginac.integral_return_type_tinfo(self)

    def eval_integ(self):
        """eval_integ(integral self) -> ex"""
        return _swiginac.integral_eval_integ(self)

    __swig_setmethods__["max_integration_level"] = _swiginac.integral_max_integration_level_set
    __swig_getmethods__["max_integration_level"] = _swiginac.integral_max_integration_level_get
    if _newclass:max_integration_level = _swig_property(_swiginac.integral_max_integration_level_get, _swiginac.integral_max_integration_level_set)
    __swig_setmethods__["relative_integration_error"] = _swiginac.integral_relative_integration_error_set
    __swig_getmethods__["relative_integration_error"] = _swiginac.integral_relative_integration_error_get
    if _newclass:relative_integration_error = _swig_property(_swiginac.integral_relative_integration_error_get, _swiginac.integral_relative_integration_error_set)
    def __repr__(self):
        return self.__str__()

    __swig_destroy__ = _swiginac.delete_integral
    __del__ = lambda self : None;
integral_swigregister = _swiginac.integral_swigregister
integral_swigregister(integral)
Pi = cvar.Pi
Catalan = cvar.Catalan
Euler = cvar.Euler
I = cvar.I


def adaptivesimpson(*args):
  """
    adaptivesimpson(ex x, ex a, ex b, ex f, ex error=relative_integration_error) -> ex
    adaptivesimpson(ex x, ex a, ex b, ex f) -> ex
    """
  return _swiginac.adaptivesimpson(*args)
class matrix(basic):
    """Proxy of C++ GiNaC::matrix class"""
    __swig_setmethods__ = {}
    for _s in [basic]: __swig_setmethods__.update(getattr(_s,'__swig_setmethods__',{}))
    __setattr__ = lambda self, name, value: _swig_setattr(self, matrix, name, value)
    __swig_getmethods__ = {}
    for _s in [basic]: __swig_getmethods__.update(getattr(_s,'__swig_getmethods__',{}))
    __getattr__ = lambda self, name: _swig_getattr(self, matrix, name)
    __repr__ = _swig_repr
    def eval_indexed(self, *args):
        """eval_indexed(matrix self, basic i) -> ex"""
        return _swiginac.matrix_eval_indexed(self, *args)

    def add_indexed(self, *args):
        """add_indexed(matrix self, ex self, ex other) -> ex"""
        return _swiginac.matrix_add_indexed(self, *args)

    def scalar_mul_indexed(self, *args):
        """scalar_mul_indexed(matrix self, ex self, numeric other) -> ex"""
        return _swiginac.matrix_scalar_mul_indexed(self, *args)

    def contract_with(self, *args):
        """contract_with(matrix self, exvector::iterator self, exvector::iterator other, exvector & v) -> bool"""
        return _swiginac.matrix_contract_with(self, *args)

    def rows(self):
        """rows(matrix self) -> unsigned int"""
        return _swiginac.matrix_rows(self)

    def cols(self):
        """cols(matrix self) -> unsigned int"""
        return _swiginac.matrix_cols(self)

    def add(self, *args):
        """add(matrix self, matrix other) -> matrix"""
        return _swiginac.matrix_add(self, *args)

    def sub(self, *args):
        """sub(matrix self, matrix other) -> matrix"""
        return _swiginac.matrix_sub(self, *args)

    def mul(self, *args):
        """
        mul(matrix self, matrix other) -> matrix
        mul(matrix self, numeric other) -> matrix
        """
        return _swiginac.matrix_mul(self, *args)

    def mul_scalar(self, *args):
        """mul_scalar(matrix self, ex other) -> matrix"""
        return _swiginac.matrix_mul_scalar(self, *args)

    def pow(self, *args):
        """pow(matrix self, ex expn) -> matrix"""
        return _swiginac.matrix_pow(self, *args)

    def __call__(self, *args):
        """
        __call__(matrix self, unsigned int ro, unsigned int co) -> ex
        __call__(matrix self, unsigned int ro, unsigned int co) -> ex
        """
        return _swiginac.matrix___call__(self, *args)

    def set(self, *args):
        """set(matrix self, unsigned int ro, unsigned int co, ex value) -> matrix"""
        return _swiginac.matrix_set(self, *args)

    def transpose(self):
        """transpose(matrix self) -> matrix"""
        return _swiginac.matrix_transpose(self)

    def determinant(self, *args):
        """
        determinant(matrix self, unsigned int algo=automatic) -> ex
        determinant(matrix self) -> ex
        """
        return _swiginac.matrix_determinant(self, *args)

    def trace(self):
        """trace(matrix self) -> ex"""
        return _swiginac.matrix_trace(self)

    def charpoly(self, *args):
        """charpoly(matrix self, ex _lambda) -> ex"""
        return _swiginac.matrix_charpoly(self, *args)

    def inverse(self):
        """inverse(matrix self) -> matrix"""
        return _swiginac.matrix_inverse(self)

    def solve(self, *args):
        """
        solve(matrix self, matrix vars, matrix rhs, unsigned int algo=solve_algo::automatic) -> matrix
        solve(matrix self, matrix vars, matrix rhs) -> matrix
        """
        return _swiginac.matrix_solve(self, *args)

    def rank(self):
        """rank(matrix self) -> unsigned int"""
        return _swiginac.matrix_rank(self)

    def __init__(self, *args): 
        """
        __init__(GiNaC::matrix self, unsigned int r, unsigned int c) -> matrix
        __init__(GiNaC::matrix self, unsigned int r, unsigned int c, lst l) -> matrix
        __init__(GiNaC::matrix self, lst l) -> matrix
        """
        this = _swiginac.new_matrix(*args)
        try: self.this.append(this)
        except: self.this = this
    def __len__(self):
        """__len__(matrix self) -> int"""
        return _swiginac.matrix___len__(self)

    def __setitem__(self, *args):
        """__setitem__(matrix self, int idx0, ex e)"""
        return _swiginac.matrix___setitem__(self, *args)

    def __getitem__(self, *args):
        """__getitem__(matrix self, int idx0) -> ex"""
        return _swiginac.matrix___getitem__(self, *args)

    def __repr__(self):
        return self.__str__()

    __swig_destroy__ = _swiginac.delete_matrix
    __del__ = lambda self : None;
matrix_swigregister = _swiginac.matrix_swigregister
matrix_swigregister(matrix)

def matrix2(x):
    return lst_to_matrix(x)



def nops(*args):
  """nops(matrix m) -> size_t"""
  return _swiginac.nops(*args)

def eval(*args):
  """
    eval(matrix m, int level=0) -> ex
    eval(matrix m) -> ex
    """
  return _swiginac.eval(*args)

def evalf(*args):
  """
    evalf(matrix m, int level=0) -> ex
    evalf(matrix m) -> ex
    """
  return _swiginac.evalf(*args)

def rows(*args):
  """rows(matrix m) -> unsigned int"""
  return _swiginac.rows(*args)

def cols(*args):
  """cols(matrix m) -> unsigned int"""
  return _swiginac.cols(*args)

def transpose(*args):
  """transpose(matrix m) -> matrix"""
  return _swiginac.transpose(*args)

def determinant(*args):
  """
    determinant(matrix m, unsigned int options=automatic) -> ex
    determinant(matrix m) -> ex
    """
  return _swiginac.determinant(*args)

def trace(*args):
  """trace(matrix m) -> ex"""
  return _swiginac.trace(*args)

def charpoly(*args):
  """charpoly(matrix m, ex _lambda) -> ex"""
  return _swiginac.charpoly(*args)

def inverse(*args):
  """inverse(matrix m) -> matrix"""
  return _swiginac.inverse(*args)

def rank(*args):
  """rank(matrix m) -> unsigned int"""
  return _swiginac.rank(*args)

def lst_to_matrix(*args):
  """lst_to_matrix(lst l) -> ex"""
  return _swiginac.lst_to_matrix(*args)

def diag_matrix(*args):
  """diag_matrix(lst l) -> ex"""
  return _swiginac.diag_matrix(*args)

def unit_matrix(*args):
  """
    unit_matrix(unsigned int r, unsigned int c) -> ex
    unit_matrix(unsigned int x) -> ex
    """
  return _swiginac.unit_matrix(*args)

def symbolic_matrix(*args):
  """
    symbolic_matrix(unsigned int r, unsigned int c, string base_name, string tex_base_name) -> ex
    symbolic_matrix(unsigned int r, unsigned int c, string base_name) -> ex
    """
  return _swiginac.symbolic_matrix(*args)
EXPAIRSEQ_USE_HASHTAB = _swiginac.EXPAIRSEQ_USE_HASHTAB

def conjugateepvector(*args):
  """conjugateepvector(GiNaC::epvector const & arg1) -> GiNaC::epvector *"""
  return _swiginac.conjugateepvector(*args)
class expairseq(basic):
    """Proxy of C++ GiNaC::expairseq class"""
    __swig_setmethods__ = {}
    for _s in [basic]: __swig_setmethods__.update(getattr(_s,'__swig_setmethods__',{}))
    __setattr__ = lambda self, name, value: _swig_setattr(self, expairseq, name, value)
    __swig_getmethods__ = {}
    for _s in [basic]: __swig_getmethods__.update(getattr(_s,'__swig_getmethods__',{}))
    __getattr__ = lambda self, name: _swig_getattr(self, expairseq, name)
    __repr__ = _swig_repr
    def __init__(self, *args): 
        """
        __init__(GiNaC::expairseq self, ex lh, ex rh) -> expairseq
        __init__(GiNaC::expairseq self, exvector const & v) -> expairseq
        """
        this = _swiginac.new_expairseq(*args)
        try: self.this.append(this)
        except: self.this = this
    def precedence(self):
        """precedence(expairseq self) -> unsigned int"""
        return _swiginac.expairseq_precedence(self)

    __swig_destroy__ = _swiginac.delete_expairseq
    __del__ = lambda self : None;
expairseq_swigregister = _swiginac.expairseq_swigregister
expairseq_swigregister(expairseq)

class mul(expairseq):
    """Proxy of C++ GiNaC::mul class"""
    __swig_setmethods__ = {}
    for _s in [expairseq]: __swig_setmethods__.update(getattr(_s,'__swig_setmethods__',{}))
    __setattr__ = lambda self, name, value: _swig_setattr(self, mul, name, value)
    __swig_getmethods__ = {}
    for _s in [expairseq]: __swig_getmethods__.update(getattr(_s,'__swig_getmethods__',{}))
    __getattr__ = lambda self, name: _swig_getattr(self, mul, name)
    __repr__ = _swig_repr
    def __init__(self, *args): 
        """
        __init__(GiNaC::mul self, ex lh, ex rh) -> mul
        __init__(GiNaC::mul self, exvector const & v) -> mul
        __init__(GiNaC::mul self, GiNaC::epvector const & v) -> mul
        __init__(GiNaC::mul self, ex lh, ex mh, ex rh) -> mul
        """
        this = _swiginac.new_mul(*args)
        try: self.this.append(this)
        except: self.this = this
    def algebraic_subs_mul(self, *args):
        """algebraic_subs_mul(mul self, exmap m, unsigned int options) -> ex"""
        return _swiginac.mul_algebraic_subs_mul(self, *args)

    def __repr__(self):
        return self.__str__()

    __swig_destroy__ = _swiginac.delete_mul
    __del__ = lambda self : None;
mul_swigregister = _swiginac.mul_swigregister
mul_swigregister(mul)

class ncmul(basic):
    """Proxy of C++ GiNaC::ncmul class"""
    __swig_setmethods__ = {}
    for _s in [basic]: __swig_setmethods__.update(getattr(_s,'__swig_setmethods__',{}))
    __setattr__ = lambda self, name, value: _swig_setattr(self, ncmul, name, value)
    __swig_getmethods__ = {}
    for _s in [basic]: __swig_getmethods__.update(getattr(_s,'__swig_getmethods__',{}))
    __getattr__ = lambda self, name: _swig_getattr(self, ncmul, name)
    __repr__ = _swig_repr
    def __init__(self, *args): 
        """
        __init__(GiNaC::ncmul self, ex lh, ex rh) -> ncmul
        __init__(GiNaC::ncmul self, ex f1, ex f2, ex f3) -> ncmul
        __init__(GiNaC::ncmul self, ex f1, ex f2, ex f3, ex f4) -> ncmul
        __init__(GiNaC::ncmul self, ex f1, ex f2, ex f3, ex f4, ex f5) -> ncmul
        __init__(GiNaC::ncmul self, ex f1, ex f2, ex f3, ex f4, ex f5, ex f6) -> ncmul
        """
        this = _swiginac.new_ncmul(*args)
        try: self.this.append(this)
        except: self.this = this
    __swig_destroy__ = _swiginac.delete_ncmul
    __del__ = lambda self : None;
ncmul_swigregister = _swiginac.ncmul_swigregister
ncmul_swigregister(ncmul)

class power(basic):
    """Proxy of C++ GiNaC::power class"""
    __swig_setmethods__ = {}
    for _s in [basic]: __swig_setmethods__.update(getattr(_s,'__swig_setmethods__',{}))
    __setattr__ = lambda self, name, value: _swig_setattr(self, power, name, value)
    __swig_getmethods__ = {}
    for _s in [basic]: __swig_getmethods__.update(getattr(_s,'__swig_getmethods__',{}))
    __getattr__ = lambda self, name: _swig_getattr(self, power, name)
    __repr__ = _swig_repr
    def __init__(self, *args): 
        """__init__(GiNaC::power self, ex lh, ex rh) -> power"""
        this = _swiginac.new_power(*args)
        try: self.this.append(this)
        except: self.this = this
    def __repr__(self):
        return self.__str__()

    __swig_destroy__ = _swiginac.delete_power
    __del__ = lambda self : None;
power_swigregister = _swiginac.power_swigregister
power_swigregister(power)

class add(expairseq):
    """Proxy of C++ GiNaC::add class"""
    __swig_setmethods__ = {}
    for _s in [expairseq]: __swig_setmethods__.update(getattr(_s,'__swig_setmethods__',{}))
    __setattr__ = lambda self, name, value: _swig_setattr(self, add, name, value)
    __swig_getmethods__ = {}
    for _s in [expairseq]: __swig_getmethods__.update(getattr(_s,'__swig_getmethods__',{}))
    __getattr__ = lambda self, name: _swig_getattr(self, add, name)
    __repr__ = _swig_repr
    def __init__(self, *args): 
        """
        __init__(GiNaC::add self, ex lh, ex rh) -> add
        __init__(GiNaC::add self, exvector const & v) -> add
        __init__(GiNaC::add self, GiNaC::epvector const & v) -> add
        """
        this = _swiginac.new_add(*args)
        try: self.this.append(this)
        except: self.this = this
    def __repr__(self):
        return self.__str__()

    __swig_destroy__ = _swiginac.delete_add
    __del__ = lambda self : None;
add_swigregister = _swiginac.add_swigregister
add_swigregister(add)

class function_options(_object):
    """Proxy of C++ GiNaC::function_options class"""
    __swig_setmethods__ = {}
    __setattr__ = lambda self, name, value: _swig_setattr(self, function_options, name, value)
    __swig_getmethods__ = {}
    __getattr__ = lambda self, name: _swig_getattr(self, function_options, name)
    __repr__ = _swig_repr
    def __init__(self, *args): 
        """
        __init__(GiNaC::function_options self) -> function_options
        __init__(GiNaC::function_options self, string n, string tn=std::string()) -> function_options
        __init__(GiNaC::function_options self, string n) -> function_options
        __init__(GiNaC::function_options self, string n, unsigned int np) -> function_options
        """
        this = _swiginac.new_function_options(*args)
        try: self.this.append(this)
        except: self.this = this
    __swig_destroy__ = _swiginac.delete_function_options
    __del__ = lambda self : None;
    def initialize(self):
        """initialize(function_options self)"""
        return _swiginac.function_options_initialize(self)

    def dummy(self):
        """dummy(function_options self) -> function_options"""
        return _swiginac.function_options_dummy(self)

    def set_name(self, *args):
        """
        set_name(function_options self, string n, string tn=std::string()) -> function_options
        set_name(function_options self, string n) -> function_options
        """
        return _swiginac.function_options_set_name(self, *args)

    def latex_name(self, *args):
        """latex_name(function_options self, string tn) -> function_options"""
        return _swiginac.function_options_latex_name(self, *args)

    def eval_func(self, *args):
        """
        eval_func(function_options self, eval_funcp_1 e) -> function_options
        eval_func(function_options self, eval_funcp_2 e) -> function_options
        eval_func(function_options self, eval_funcp_3 e) -> function_options
        eval_func(function_options self, eval_funcp_4 e) -> function_options
        eval_func(function_options self, eval_funcp_5 e) -> function_options
        eval_func(function_options self, eval_funcp_exvector e) -> function_options
        """
        return _swiginac.function_options_eval_func(self, *args)

    def evalf_func(self, *args):
        """
        evalf_func(function_options self, evalf_funcp_1 ef) -> function_options
        evalf_func(function_options self, evalf_funcp_2 ef) -> function_options
        evalf_func(function_options self, evalf_funcp_3 ef) -> function_options
        evalf_func(function_options self, evalf_funcp_4 ef) -> function_options
        evalf_func(function_options self, evalf_funcp_5 ef) -> function_options
        evalf_func(function_options self, evalf_funcp_exvector ef) -> function_options
        """
        return _swiginac.function_options_evalf_func(self, *args)

    def conjugate_func(self, *args):
        """
        conjugate_func(function_options self, conjugate_funcp_1 d) -> function_options
        conjugate_func(function_options self, conjugate_funcp_2 d) -> function_options
        conjugate_func(function_options self, conjugate_funcp_3 d) -> function_options
        conjugate_func(function_options self, conjugate_funcp_4 d) -> function_options
        conjugate_func(function_options self, conjugate_funcp_5 d) -> function_options
        conjugate_func(function_options self, conjugate_funcp_exvector d) -> function_options
        """
        return _swiginac.function_options_conjugate_func(self, *args)

    def derivative_func(self, *args):
        """
        derivative_func(function_options self, derivative_funcp_1 d) -> function_options
        derivative_func(function_options self, derivative_funcp_2 d) -> function_options
        derivative_func(function_options self, derivative_funcp_3 d) -> function_options
        derivative_func(function_options self, derivative_funcp_4 d) -> function_options
        derivative_func(function_options self, derivative_funcp_5 d) -> function_options
        derivative_func(function_options self, derivative_funcp_exvector d) -> function_options
        """
        return _swiginac.function_options_derivative_func(self, *args)

    def series_func(self, *args):
        """
        series_func(function_options self, series_funcp_1 s) -> function_options
        series_func(function_options self, series_funcp_2 s) -> function_options
        series_func(function_options self, series_funcp_3 s) -> function_options
        series_func(function_options self, series_funcp_4 s) -> function_options
        series_func(function_options self, series_funcp_5 s) -> function_options
        series_func(function_options self, series_funcp_exvector s) -> function_options
        """
        return _swiginac.function_options_series_func(self, *args)

    def set_return_type(self, *args):
        """
        set_return_type(function_options self, unsigned int rt, GiNaC::return_type_t const * rtt=None) -> function_options
        set_return_type(function_options self, unsigned int rt) -> function_options
        """
        return _swiginac.function_options_set_return_type(self, *args)

    def do_not_evalf_params(self):
        """do_not_evalf_params(function_options self) -> function_options"""
        return _swiginac.function_options_do_not_evalf_params(self)

    def remember(self, *args):
        """
        remember(function_options self, unsigned int size, unsigned int assoc_size=0, unsigned int strategy=remember_strategies::delete_never) -> function_options
        remember(function_options self, unsigned int size, unsigned int assoc_size=0) -> function_options
        remember(function_options self, unsigned int size) -> function_options
        """
        return _swiginac.function_options_remember(self, *args)

    def overloaded(self, *args):
        """overloaded(function_options self, unsigned int o) -> function_options"""
        return _swiginac.function_options_overloaded(self, *args)

    def set_symmetry(self, *args):
        """set_symmetry(function_options self, symmetry s) -> function_options"""
        return _swiginac.function_options_set_symmetry(self, *args)

    def get_name(self):
        """get_name(function_options self) -> string"""
        return _swiginac.function_options_get_name(self)

    def get_nparams(self):
        """get_nparams(function_options self) -> unsigned int"""
        return _swiginac.function_options_get_nparams(self)

function_options_swigregister = _swiginac.function_options_swigregister
function_options_swigregister(function_options)

class do_taylor(_object):
    """Proxy of C++ GiNaC::do_taylor class"""
    __swig_setmethods__ = {}
    __setattr__ = lambda self, name, value: _swig_setattr(self, do_taylor, name, value)
    __swig_getmethods__ = {}
    __getattr__ = lambda self, name: _swig_getattr(self, do_taylor, name)
    __repr__ = _swig_repr
    def __init__(self): 
        """__init__(GiNaC::do_taylor self) -> do_taylor"""
        this = _swiginac.new_do_taylor()
        try: self.this.append(this)
        except: self.this = this
    __swig_destroy__ = _swiginac.delete_do_taylor
    __del__ = lambda self : None;
do_taylor_swigregister = _swiginac.do_taylor_swigregister
do_taylor_swigregister(do_taylor)

class function(basic):
    """Proxy of C++ GiNaC::function class"""
    __swig_setmethods__ = {}
    for _s in [basic]: __swig_setmethods__.update(getattr(_s,'__swig_setmethods__',{}))
    __setattr__ = lambda self, name, value: _swig_setattr(self, function, name, value)
    __swig_getmethods__ = {}
    for _s in [basic]: __swig_getmethods__.update(getattr(_s,'__swig_getmethods__',{}))
    __getattr__ = lambda self, name: _swig_getattr(self, function, name)
    __repr__ = _swig_repr
    def __init__(self, *args): 
        """
        __init__(GiNaC::function self, unsigned int ser) -> function
        __init__(GiNaC::function self, unsigned int ser, ex param1) -> function
        __init__(GiNaC::function self, unsigned int ser, ex param1, ex param2) -> function
        __init__(GiNaC::function self, unsigned int ser, ex param1, ex param2, ex param3) -> function
        __init__(GiNaC::function self, unsigned int ser, ex param1, ex param2, ex param3, ex param4) -> function
        __init__(GiNaC::function self, unsigned int ser, ex param1, ex param2, ex param3, ex param4, ex param5) -> function
        """
        this = _swiginac.new_function(*args)
        try: self.this.append(this)
        except: self.this = this
    def precedence(self):
        """precedence(function self) -> unsigned int"""
        return _swiginac.function_precedence(self)

    def calchash(self):
        """calchash(function self) -> unsigned int"""
        return _swiginac.function_calchash(self)

    def thiscontainer(self, *args):
        """thiscontainer(function self, exvector const & v) -> ex"""
        return _swiginac.function_thiscontainer(self, *args)

    def register_new(*args):
        """register_new(function_options opt) -> unsigned int"""
        return _swiginac.function_register_new(*args)

    if _newclass:register_new = staticmethod(register_new)
    __swig_getmethods__["register_new"] = lambda x: register_new
    __swig_setmethods__["current_serial"] = _swiginac.function_current_serial_set
    __swig_getmethods__["current_serial"] = _swiginac.function_current_serial_get
    if _newclass:current_serial = _swig_property(_swiginac.function_current_serial_get, _swiginac.function_current_serial_set)
    def find_function(*args):
        """find_function(string name, unsigned int nparams) -> unsigned int"""
        return _swiginac.function_find_function(*args)

    if _newclass:find_function = staticmethod(find_function)
    __swig_getmethods__["find_function"] = lambda x: find_function
    def get_serial(self):
        """get_serial(function self) -> unsigned int"""
        return _swiginac.function_get_serial(self)

    def get_name(self):
        """get_name(function self) -> string"""
        return _swiginac.function_get_name(self)

    def __repr__(self):
        return self.__str__()

    __swig_destroy__ = _swiginac.delete_function
    __del__ = lambda self : None;
function_swigregister = _swiginac.function_swigregister
function_swigregister(function)

def function_register_new(*args):
  """function_register_new(function_options opt) -> unsigned int"""
  return _swiginac.function_register_new(*args)

def function_find_function(*args):
  """function_find_function(string name, unsigned int nparams) -> unsigned int"""
  return _swiginac.function_find_function(*args)


def conjugate(*args):
  """conjugate(ex thisex) -> ex"""
  return _swiginac.conjugate(*args)

def has(*args):
  """has(ex thisex, ex pattern) -> bool"""
  return _swiginac.has(*args)

def find(*args):
  """find(ex thisex, ex pattern, exset & found) -> bool"""
  return _swiginac.find(*args)

def degree(*args):
  """degree(ex thisex, ex s) -> int"""
  return _swiginac.degree(*args)

def ldegree(*args):
  """ldegree(ex thisex, ex s) -> int"""
  return _swiginac.ldegree(*args)

def coeff(*args):
  """
    coeff(ex thisex, ex s, int n=1) -> ex
    coeff(ex thisex, ex s) -> ex
    """
  return _swiginac.coeff(*args)

def numer(*args):
  """numer(ex thisex) -> ex"""
  return _swiginac.numer(*args)

def denom(*args):
  """denom(ex thisex) -> ex"""
  return _swiginac.denom(*args)

def numer_denom(*args):
  """numer_denom(ex thisex) -> ex"""
  return _swiginac.numer_denom(*args)

def normal(*args):
  """
    normal(ex thisex, int level=0) -> ex
    normal(ex thisex) -> ex
    """
  return _swiginac.normal(*args)

def to_rational(*args):
  """to_rational(ex thisex, lst repl_lst) -> ex"""
  return _swiginac.to_rational(*args)

def to_polynomial(*args):
  """to_polynomial(ex thisex, lst repl_lst) -> ex"""
  return _swiginac.to_polynomial(*args)

def collect(*args):
  """
    collect(ex thisex, ex s, bool distributed=False) -> ex
    collect(ex thisex, ex s) -> ex
    """
  return _swiginac.collect(*args)

def evalm(*args):
  """evalm(ex thisex) -> ex"""
  return _swiginac.evalm(*args)

def eval_integ(*args):
  """eval_integ(ex thisex) -> ex"""
  return _swiginac.eval_integ(*args)

def diff(*args):
  """
    diff(ex thisex, symbol s, unsigned int nth=1) -> ex
    diff(ex thisex, symbol s) -> ex
    """
  return _swiginac.diff(*args)

def series(*args):
  """
    series(ex thisex, ex r, int order, unsigned int options=0) -> ex
    series(ex thisex, ex r, int order) -> ex
    """
  return _swiginac.series(*args)

def match(*args):
  """match(ex thisex, ex pattern, exmap repl_lst) -> bool"""
  return _swiginac.match(*args)

def simplify_indexed(*args):
  """
    simplify_indexed(ex thisex, unsigned int options=0) -> ex
    simplify_indexed(ex thisex) -> ex
    simplify_indexed(ex thisex, scalar_products sp, unsigned int options=0) -> ex
    simplify_indexed(ex thisex, scalar_products sp) -> ex
    """
  return _swiginac.simplify_indexed(*args)

def op(*args):
  """op(ex thisex, size_t i) -> ex"""
  return _swiginac.op(*args)

def lhs(*args):
  """lhs(ex thisex) -> ex"""
  return _swiginac.lhs(*args)

def rhs(*args):
  """rhs(ex thisex) -> ex"""
  return _swiginac.rhs(*args)

def swap(*args):
  """swap(ex e1, ex e2)"""
  return _swiginac.swap(*args)

def subs(*args):
  """
    subs(ex thisex, lst ls, lst lr, unsigned int options=0) -> ex
    subs(ex thisex, lst ls, lst lr) -> ex
    subs(ex thisex, ex e) -> ex
    """
  return _swiginac.subs(*args)

def sqrt(*args):
  """sqrt(ex a) -> ex"""
  return _swiginac.sqrt(*args)

def expand(*args):
  """expand(ex thisex) -> ex"""
  return _swiginac.expand(*args)
class conjugate_function_SERIAL(_object):
    """Proxy of C++ GiNaC::conjugate_function_SERIAL class"""
    __swig_setmethods__ = {}
    __setattr__ = lambda self, name, value: _swig_setattr(self, conjugate_function_SERIAL, name, value)
    __swig_getmethods__ = {}
    __getattr__ = lambda self, name: _swig_getattr(self, conjugate_function_SERIAL, name)
    __repr__ = _swig_repr
    __swig_setmethods__["serial"] = _swiginac.conjugate_function_SERIAL_serial_set
    __swig_getmethods__["serial"] = _swiginac.conjugate_function_SERIAL_serial_get
    if _newclass:serial = _swig_property(_swiginac.conjugate_function_SERIAL_serial_get, _swiginac.conjugate_function_SERIAL_serial_set)
    def __init__(self): 
        """__init__(GiNaC::conjugate_function_SERIAL self) -> conjugate_function_SERIAL"""
        this = _swiginac.new_conjugate_function_SERIAL()
        try: self.this.append(this)
        except: self.this = this
    __swig_destroy__ = _swiginac.delete_conjugate_function_SERIAL
    __del__ = lambda self : None;
conjugate_function_SERIAL_swigregister = _swiginac.conjugate_function_SERIAL_swigregister
conjugate_function_SERIAL_swigregister(conjugate_function_SERIAL)


def conjugate_function_basic(*args):
  """conjugate_function_basic(basic p1) -> function"""
  return _swiginac.conjugate_function_basic(*args)

def conjugate_function_int(*args):
  """conjugate_function_int(int const & p1) -> function"""
  return _swiginac.conjugate_function_int(*args)

def conjugate_function_double(*args):
  """conjugate_function_double(double const & p1) -> function"""
  return _swiginac.conjugate_function_double(*args)
def conjugate_function(x):
    if isinstance(x,basic):
        return conjugate_function_basic(x).eval()
    elif isinstance(x,int):
        return conjugate_function_int(x).eval()
    elif isinstance(x,float):
        return conjugate_function_double(x).eval()
    else:
        raise "Unimplented type. Fix in function.i."

class abs_SERIAL(_object):
    """Proxy of C++ GiNaC::abs_SERIAL class"""
    __swig_setmethods__ = {}
    __setattr__ = lambda self, name, value: _swig_setattr(self, abs_SERIAL, name, value)
    __swig_getmethods__ = {}
    __getattr__ = lambda self, name: _swig_getattr(self, abs_SERIAL, name)
    __repr__ = _swig_repr
    __swig_setmethods__["serial"] = _swiginac.abs_SERIAL_serial_set
    __swig_getmethods__["serial"] = _swiginac.abs_SERIAL_serial_get
    if _newclass:serial = _swig_property(_swiginac.abs_SERIAL_serial_get, _swiginac.abs_SERIAL_serial_set)
    def __init__(self): 
        """__init__(GiNaC::abs_SERIAL self) -> abs_SERIAL"""
        this = _swiginac.new_abs_SERIAL()
        try: self.this.append(this)
        except: self.this = this
    __swig_destroy__ = _swiginac.delete_abs_SERIAL
    __del__ = lambda self : None;
abs_SERIAL_swigregister = _swiginac.abs_SERIAL_swigregister
abs_SERIAL_swigregister(abs_SERIAL)
conjugate_function_NPARAMS = cvar.conjugate_function_NPARAMS


def abs_basic(*args):
  """abs_basic(basic p1) -> function"""
  return _swiginac.abs_basic(*args)

def abs_int(*args):
  """abs_int(int const & p1) -> function"""
  return _swiginac.abs_int(*args)

def abs_double(*args):
  """abs_double(double const & p1) -> function"""
  return _swiginac.abs_double(*args)
def abs(x):
    if isinstance(x,basic):
        return abs_basic(x).eval()
    elif isinstance(x,int):
        return abs_int(x).eval()
    elif isinstance(x,float):
        return abs_double(x).eval()
    else:
        raise "Unimplented type. Fix in function.i."

class csgn_SERIAL(_object):
    """Proxy of C++ GiNaC::csgn_SERIAL class"""
    __swig_setmethods__ = {}
    __setattr__ = lambda self, name, value: _swig_setattr(self, csgn_SERIAL, name, value)
    __swig_getmethods__ = {}
    __getattr__ = lambda self, name: _swig_getattr(self, csgn_SERIAL, name)
    __repr__ = _swig_repr
    __swig_setmethods__["serial"] = _swiginac.csgn_SERIAL_serial_set
    __swig_getmethods__["serial"] = _swiginac.csgn_SERIAL_serial_get
    if _newclass:serial = _swig_property(_swiginac.csgn_SERIAL_serial_get, _swiginac.csgn_SERIAL_serial_set)
    def __init__(self): 
        """__init__(GiNaC::csgn_SERIAL self) -> csgn_SERIAL"""
        this = _swiginac.new_csgn_SERIAL()
        try: self.this.append(this)
        except: self.this = this
    __swig_destroy__ = _swiginac.delete_csgn_SERIAL
    __del__ = lambda self : None;
csgn_SERIAL_swigregister = _swiginac.csgn_SERIAL_swigregister
csgn_SERIAL_swigregister(csgn_SERIAL)
abs_NPARAMS = cvar.abs_NPARAMS


def csgn_basic(*args):
  """csgn_basic(basic p1) -> function"""
  return _swiginac.csgn_basic(*args)

def csgn_int(*args):
  """csgn_int(int const & p1) -> function"""
  return _swiginac.csgn_int(*args)

def csgn_double(*args):
  """csgn_double(double const & p1) -> function"""
  return _swiginac.csgn_double(*args)
def csgn(x):
    if isinstance(x,basic):
        return csgn_basic(x).eval()
    elif isinstance(x,int):
        return csgn_int(x).eval()
    elif isinstance(x,float):
        return csgn_double(x).eval()
    else:
        raise "Unimplented type. Fix in function.i."

class eta_SERIAL(_object):
    """Proxy of C++ GiNaC::eta_SERIAL class"""
    __swig_setmethods__ = {}
    __setattr__ = lambda self, name, value: _swig_setattr(self, eta_SERIAL, name, value)
    __swig_getmethods__ = {}
    __getattr__ = lambda self, name: _swig_getattr(self, eta_SERIAL, name)
    __repr__ = _swig_repr
    __swig_setmethods__["serial"] = _swiginac.eta_SERIAL_serial_set
    __swig_getmethods__["serial"] = _swiginac.eta_SERIAL_serial_get
    if _newclass:serial = _swig_property(_swiginac.eta_SERIAL_serial_get, _swiginac.eta_SERIAL_serial_set)
    def __init__(self): 
        """__init__(GiNaC::eta_SERIAL self) -> eta_SERIAL"""
        this = _swiginac.new_eta_SERIAL()
        try: self.this.append(this)
        except: self.this = this
    __swig_destroy__ = _swiginac.delete_eta_SERIAL
    __del__ = lambda self : None;
eta_SERIAL_swigregister = _swiginac.eta_SERIAL_swigregister
eta_SERIAL_swigregister(eta_SERIAL)
csgn_NPARAMS = cvar.csgn_NPARAMS


def eta_basic_basic(*args):
  """eta_basic_basic(basic p1, basic p2) -> function"""
  return _swiginac.eta_basic_basic(*args)

def eta_basic_int(*args):
  """eta_basic_int(basic p1, int const & p2) -> function"""
  return _swiginac.eta_basic_int(*args)

def eta_basic_double(*args):
  """eta_basic_double(basic p1, double const & p2) -> function"""
  return _swiginac.eta_basic_double(*args)

def eta_int_basic(*args):
  """eta_int_basic(int const & p1, basic p2) -> function"""
  return _swiginac.eta_int_basic(*args)

def eta_int_int(*args):
  """eta_int_int(int const & p1, int const & p2) -> function"""
  return _swiginac.eta_int_int(*args)

def eta_int_double(*args):
  """eta_int_double(int const & p1, double const & p2) -> function"""
  return _swiginac.eta_int_double(*args)

def eta_double_basic(*args):
  """eta_double_basic(double const & p1, basic p2) -> function"""
  return _swiginac.eta_double_basic(*args)

def eta_double_int(*args):
  """eta_double_int(double const & p1, int const & p2) -> function"""
  return _swiginac.eta_double_int(*args)

def eta_double_double(*args):
  """eta_double_double(double const & p1, double const & p2) -> function"""
  return _swiginac.eta_double_double(*args)
def eta(x,y):
    def which(p):
        types = [basic,int,float]
        for t in types:
            if isinstance(p,t): 
                return t
        raise "Unimplemented type. Fix in function.i."

    xt = which(x)
    yt = which(y)
    
    func_hash = {(basic,basic) : eta_basic_basic,
                 (basic,int) : eta_basic_int,
                 (basic,float) : eta_basic_double,
                 (int,basic) : eta_int_basic,
                 (int,int) : eta_int_int,
                 (int,float) : eta_int_double,
                 (float,basic) : eta_double_basic,
                 (float,int) : eta_double_int,
                 (float,float) : eta_double_double}

    return func_hash[(xt,yt)](x,y)

class sin_SERIAL(_object):
    """Proxy of C++ GiNaC::sin_SERIAL class"""
    __swig_setmethods__ = {}
    __setattr__ = lambda self, name, value: _swig_setattr(self, sin_SERIAL, name, value)
    __swig_getmethods__ = {}
    __getattr__ = lambda self, name: _swig_getattr(self, sin_SERIAL, name)
    __repr__ = _swig_repr
    __swig_setmethods__["serial"] = _swiginac.sin_SERIAL_serial_set
    __swig_getmethods__["serial"] = _swiginac.sin_SERIAL_serial_get
    if _newclass:serial = _swig_property(_swiginac.sin_SERIAL_serial_get, _swiginac.sin_SERIAL_serial_set)
    def __init__(self): 
        """__init__(GiNaC::sin_SERIAL self) -> sin_SERIAL"""
        this = _swiginac.new_sin_SERIAL()
        try: self.this.append(this)
        except: self.this = this
    __swig_destroy__ = _swiginac.delete_sin_SERIAL
    __del__ = lambda self : None;
sin_SERIAL_swigregister = _swiginac.sin_SERIAL_swigregister
sin_SERIAL_swigregister(sin_SERIAL)
eta_NPARAMS = cvar.eta_NPARAMS


def sin_basic(*args):
  """sin_basic(basic p1) -> function"""
  return _swiginac.sin_basic(*args)

def sin_int(*args):
  """sin_int(int const & p1) -> function"""
  return _swiginac.sin_int(*args)

def sin_double(*args):
  """sin_double(double const & p1) -> function"""
  return _swiginac.sin_double(*args)
def sin(x):
    if isinstance(x,basic):
        return sin_basic(x).eval()
    elif isinstance(x,int):
        return sin_int(x).eval()
    elif isinstance(x,float):
        return sin_double(x).eval()
    else:
        raise "Unimplented type. Fix in function.i."

class cos_SERIAL(_object):
    """Proxy of C++ GiNaC::cos_SERIAL class"""
    __swig_setmethods__ = {}
    __setattr__ = lambda self, name, value: _swig_setattr(self, cos_SERIAL, name, value)
    __swig_getmethods__ = {}
    __getattr__ = lambda self, name: _swig_getattr(self, cos_SERIAL, name)
    __repr__ = _swig_repr
    __swig_setmethods__["serial"] = _swiginac.cos_SERIAL_serial_set
    __swig_getmethods__["serial"] = _swiginac.cos_SERIAL_serial_get
    if _newclass:serial = _swig_property(_swiginac.cos_SERIAL_serial_get, _swiginac.cos_SERIAL_serial_set)
    def __init__(self): 
        """__init__(GiNaC::cos_SERIAL self) -> cos_SERIAL"""
        this = _swiginac.new_cos_SERIAL()
        try: self.this.append(this)
        except: self.this = this
    __swig_destroy__ = _swiginac.delete_cos_SERIAL
    __del__ = lambda self : None;
cos_SERIAL_swigregister = _swiginac.cos_SERIAL_swigregister
cos_SERIAL_swigregister(cos_SERIAL)
sin_NPARAMS = cvar.sin_NPARAMS


def cos_basic(*args):
  """cos_basic(basic p1) -> function"""
  return _swiginac.cos_basic(*args)

def cos_int(*args):
  """cos_int(int const & p1) -> function"""
  return _swiginac.cos_int(*args)

def cos_double(*args):
  """cos_double(double const & p1) -> function"""
  return _swiginac.cos_double(*args)
def cos(x):
    if isinstance(x,basic):
        return cos_basic(x).eval()
    elif isinstance(x,int):
        return cos_int(x).eval()
    elif isinstance(x,float):
        return cos_double(x).eval()
    else:
        raise "Unimplented type. Fix in function.i."

class tan_SERIAL(_object):
    """Proxy of C++ GiNaC::tan_SERIAL class"""
    __swig_setmethods__ = {}
    __setattr__ = lambda self, name, value: _swig_setattr(self, tan_SERIAL, name, value)
    __swig_getmethods__ = {}
    __getattr__ = lambda self, name: _swig_getattr(self, tan_SERIAL, name)
    __repr__ = _swig_repr
    __swig_setmethods__["serial"] = _swiginac.tan_SERIAL_serial_set
    __swig_getmethods__["serial"] = _swiginac.tan_SERIAL_serial_get
    if _newclass:serial = _swig_property(_swiginac.tan_SERIAL_serial_get, _swiginac.tan_SERIAL_serial_set)
    def __init__(self): 
        """__init__(GiNaC::tan_SERIAL self) -> tan_SERIAL"""
        this = _swiginac.new_tan_SERIAL()
        try: self.this.append(this)
        except: self.this = this
    __swig_destroy__ = _swiginac.delete_tan_SERIAL
    __del__ = lambda self : None;
tan_SERIAL_swigregister = _swiginac.tan_SERIAL_swigregister
tan_SERIAL_swigregister(tan_SERIAL)
cos_NPARAMS = cvar.cos_NPARAMS


def tan_basic(*args):
  """tan_basic(basic p1) -> function"""
  return _swiginac.tan_basic(*args)

def tan_int(*args):
  """tan_int(int const & p1) -> function"""
  return _swiginac.tan_int(*args)

def tan_double(*args):
  """tan_double(double const & p1) -> function"""
  return _swiginac.tan_double(*args)
def tan(x):
    if isinstance(x,basic):
        return tan_basic(x).eval()
    elif isinstance(x,int):
        return tan_int(x).eval()
    elif isinstance(x,float):
        return tan_double(x).eval()
    else:
        raise "Unimplented type. Fix in function.i."

class exp_SERIAL(_object):
    """Proxy of C++ GiNaC::exp_SERIAL class"""
    __swig_setmethods__ = {}
    __setattr__ = lambda self, name, value: _swig_setattr(self, exp_SERIAL, name, value)
    __swig_getmethods__ = {}
    __getattr__ = lambda self, name: _swig_getattr(self, exp_SERIAL, name)
    __repr__ = _swig_repr
    __swig_setmethods__["serial"] = _swiginac.exp_SERIAL_serial_set
    __swig_getmethods__["serial"] = _swiginac.exp_SERIAL_serial_get
    if _newclass:serial = _swig_property(_swiginac.exp_SERIAL_serial_get, _swiginac.exp_SERIAL_serial_set)
    def __init__(self): 
        """__init__(GiNaC::exp_SERIAL self) -> exp_SERIAL"""
        this = _swiginac.new_exp_SERIAL()
        try: self.this.append(this)
        except: self.this = this
    __swig_destroy__ = _swiginac.delete_exp_SERIAL
    __del__ = lambda self : None;
exp_SERIAL_swigregister = _swiginac.exp_SERIAL_swigregister
exp_SERIAL_swigregister(exp_SERIAL)
tan_NPARAMS = cvar.tan_NPARAMS


def exp_basic(*args):
  """exp_basic(basic p1) -> function"""
  return _swiginac.exp_basic(*args)

def exp_int(*args):
  """exp_int(int const & p1) -> function"""
  return _swiginac.exp_int(*args)

def exp_double(*args):
  """exp_double(double const & p1) -> function"""
  return _swiginac.exp_double(*args)
def exp(x):
    if isinstance(x,basic):
        return exp_basic(x).eval()
    elif isinstance(x,int):
        return exp_int(x).eval()
    elif isinstance(x,float):
        return exp_double(x).eval()
    else:
        raise "Unimplented type. Fix in function.i."

class log_SERIAL(_object):
    """Proxy of C++ GiNaC::log_SERIAL class"""
    __swig_setmethods__ = {}
    __setattr__ = lambda self, name, value: _swig_setattr(self, log_SERIAL, name, value)
    __swig_getmethods__ = {}
    __getattr__ = lambda self, name: _swig_getattr(self, log_SERIAL, name)
    __repr__ = _swig_repr
    __swig_setmethods__["serial"] = _swiginac.log_SERIAL_serial_set
    __swig_getmethods__["serial"] = _swiginac.log_SERIAL_serial_get
    if _newclass:serial = _swig_property(_swiginac.log_SERIAL_serial_get, _swiginac.log_SERIAL_serial_set)
    def __init__(self): 
        """__init__(GiNaC::log_SERIAL self) -> log_SERIAL"""
        this = _swiginac.new_log_SERIAL()
        try: self.this.append(this)
        except: self.this = this
    __swig_destroy__ = _swiginac.delete_log_SERIAL
    __del__ = lambda self : None;
log_SERIAL_swigregister = _swiginac.log_SERIAL_swigregister
log_SERIAL_swigregister(log_SERIAL)
exp_NPARAMS = cvar.exp_NPARAMS


def log_basic(*args):
  """log_basic(basic p1) -> function"""
  return _swiginac.log_basic(*args)

def log_int(*args):
  """log_int(int const & p1) -> function"""
  return _swiginac.log_int(*args)

def log_double(*args):
  """log_double(double const & p1) -> function"""
  return _swiginac.log_double(*args)
def log(x):
    if isinstance(x,basic):
        return log_basic(x).eval()
    elif isinstance(x,int):
        return log_int(x).eval()
    elif isinstance(x,float):
        return log_double(x).eval()
    else:
        raise "Unimplented type. Fix in function.i."

class asin_SERIAL(_object):
    """Proxy of C++ GiNaC::asin_SERIAL class"""
    __swig_setmethods__ = {}
    __setattr__ = lambda self, name, value: _swig_setattr(self, asin_SERIAL, name, value)
    __swig_getmethods__ = {}
    __getattr__ = lambda self, name: _swig_getattr(self, asin_SERIAL, name)
    __repr__ = _swig_repr
    __swig_setmethods__["serial"] = _swiginac.asin_SERIAL_serial_set
    __swig_getmethods__["serial"] = _swiginac.asin_SERIAL_serial_get
    if _newclass:serial = _swig_property(_swiginac.asin_SERIAL_serial_get, _swiginac.asin_SERIAL_serial_set)
    def __init__(self): 
        """__init__(GiNaC::asin_SERIAL self) -> asin_SERIAL"""
        this = _swiginac.new_asin_SERIAL()
        try: self.this.append(this)
        except: self.this = this
    __swig_destroy__ = _swiginac.delete_asin_SERIAL
    __del__ = lambda self : None;
asin_SERIAL_swigregister = _swiginac.asin_SERIAL_swigregister
asin_SERIAL_swigregister(asin_SERIAL)
log_NPARAMS = cvar.log_NPARAMS


def asin_basic(*args):
  """asin_basic(basic p1) -> function"""
  return _swiginac.asin_basic(*args)

def asin_int(*args):
  """asin_int(int const & p1) -> function"""
  return _swiginac.asin_int(*args)

def asin_double(*args):
  """asin_double(double const & p1) -> function"""
  return _swiginac.asin_double(*args)
def asin(x):
    if isinstance(x,basic):
        return asin_basic(x).eval()
    elif isinstance(x,int):
        return asin_int(x).eval()
    elif isinstance(x,float):
        return asin_double(x).eval()
    else:
        raise "Unimplented type. Fix in function.i."

class acos_SERIAL(_object):
    """Proxy of C++ GiNaC::acos_SERIAL class"""
    __swig_setmethods__ = {}
    __setattr__ = lambda self, name, value: _swig_setattr(self, acos_SERIAL, name, value)
    __swig_getmethods__ = {}
    __getattr__ = lambda self, name: _swig_getattr(self, acos_SERIAL, name)
    __repr__ = _swig_repr
    __swig_setmethods__["serial"] = _swiginac.acos_SERIAL_serial_set
    __swig_getmethods__["serial"] = _swiginac.acos_SERIAL_serial_get
    if _newclass:serial = _swig_property(_swiginac.acos_SERIAL_serial_get, _swiginac.acos_SERIAL_serial_set)
    def __init__(self): 
        """__init__(GiNaC::acos_SERIAL self) -> acos_SERIAL"""
        this = _swiginac.new_acos_SERIAL()
        try: self.this.append(this)
        except: self.this = this
    __swig_destroy__ = _swiginac.delete_acos_SERIAL
    __del__ = lambda self : None;
acos_SERIAL_swigregister = _swiginac.acos_SERIAL_swigregister
acos_SERIAL_swigregister(acos_SERIAL)
asin_NPARAMS = cvar.asin_NPARAMS


def acos_basic(*args):
  """acos_basic(basic p1) -> function"""
  return _swiginac.acos_basic(*args)

def acos_int(*args):
  """acos_int(int const & p1) -> function"""
  return _swiginac.acos_int(*args)

def acos_double(*args):
  """acos_double(double const & p1) -> function"""
  return _swiginac.acos_double(*args)
def acos(x):
    if isinstance(x,basic):
        return acos_basic(x).eval()
    elif isinstance(x,int):
        return acos_int(x).eval()
    elif isinstance(x,float):
        return acos_double(x).eval()
    else:
        raise "Unimplented type. Fix in function.i."

class atan_SERIAL(_object):
    """Proxy of C++ GiNaC::atan_SERIAL class"""
    __swig_setmethods__ = {}
    __setattr__ = lambda self, name, value: _swig_setattr(self, atan_SERIAL, name, value)
    __swig_getmethods__ = {}
    __getattr__ = lambda self, name: _swig_getattr(self, atan_SERIAL, name)
    __repr__ = _swig_repr
    __swig_setmethods__["serial"] = _swiginac.atan_SERIAL_serial_set
    __swig_getmethods__["serial"] = _swiginac.atan_SERIAL_serial_get
    if _newclass:serial = _swig_property(_swiginac.atan_SERIAL_serial_get, _swiginac.atan_SERIAL_serial_set)
    def __init__(self): 
        """__init__(GiNaC::atan_SERIAL self) -> atan_SERIAL"""
        this = _swiginac.new_atan_SERIAL()
        try: self.this.append(this)
        except: self.this = this
    __swig_destroy__ = _swiginac.delete_atan_SERIAL
    __del__ = lambda self : None;
atan_SERIAL_swigregister = _swiginac.atan_SERIAL_swigregister
atan_SERIAL_swigregister(atan_SERIAL)
acos_NPARAMS = cvar.acos_NPARAMS


def atan_basic(*args):
  """atan_basic(basic p1) -> function"""
  return _swiginac.atan_basic(*args)

def atan_int(*args):
  """atan_int(int const & p1) -> function"""
  return _swiginac.atan_int(*args)

def atan_double(*args):
  """atan_double(double const & p1) -> function"""
  return _swiginac.atan_double(*args)
def atan(x):
    if isinstance(x,basic):
        return atan_basic(x).eval()
    elif isinstance(x,int):
        return atan_int(x).eval()
    elif isinstance(x,float):
        return atan_double(x).eval()
    else:
        raise "Unimplented type. Fix in function.i."

class atan2_SERIAL(_object):
    """Proxy of C++ GiNaC::atan2_SERIAL class"""
    __swig_setmethods__ = {}
    __setattr__ = lambda self, name, value: _swig_setattr(self, atan2_SERIAL, name, value)
    __swig_getmethods__ = {}
    __getattr__ = lambda self, name: _swig_getattr(self, atan2_SERIAL, name)
    __repr__ = _swig_repr
    __swig_setmethods__["serial"] = _swiginac.atan2_SERIAL_serial_set
    __swig_getmethods__["serial"] = _swiginac.atan2_SERIAL_serial_get
    if _newclass:serial = _swig_property(_swiginac.atan2_SERIAL_serial_get, _swiginac.atan2_SERIAL_serial_set)
    def __init__(self): 
        """__init__(GiNaC::atan2_SERIAL self) -> atan2_SERIAL"""
        this = _swiginac.new_atan2_SERIAL()
        try: self.this.append(this)
        except: self.this = this
    __swig_destroy__ = _swiginac.delete_atan2_SERIAL
    __del__ = lambda self : None;
atan2_SERIAL_swigregister = _swiginac.atan2_SERIAL_swigregister
atan2_SERIAL_swigregister(atan2_SERIAL)
atan_NPARAMS = cvar.atan_NPARAMS


def atan2_basic_basic(*args):
  """atan2_basic_basic(basic p1, basic p2) -> function"""
  return _swiginac.atan2_basic_basic(*args)

def atan2_basic_int(*args):
  """atan2_basic_int(basic p1, int const & p2) -> function"""
  return _swiginac.atan2_basic_int(*args)

def atan2_basic_double(*args):
  """atan2_basic_double(basic p1, double const & p2) -> function"""
  return _swiginac.atan2_basic_double(*args)

def atan2_int_basic(*args):
  """atan2_int_basic(int const & p1, basic p2) -> function"""
  return _swiginac.atan2_int_basic(*args)

def atan2_int_int(*args):
  """atan2_int_int(int const & p1, int const & p2) -> function"""
  return _swiginac.atan2_int_int(*args)

def atan2_int_double(*args):
  """atan2_int_double(int const & p1, double const & p2) -> function"""
  return _swiginac.atan2_int_double(*args)

def atan2_double_basic(*args):
  """atan2_double_basic(double const & p1, basic p2) -> function"""
  return _swiginac.atan2_double_basic(*args)

def atan2_double_int(*args):
  """atan2_double_int(double const & p1, int const & p2) -> function"""
  return _swiginac.atan2_double_int(*args)

def atan2_double_double(*args):
  """atan2_double_double(double const & p1, double const & p2) -> function"""
  return _swiginac.atan2_double_double(*args)
def atan2(x,y):
    def which(p):
        types = [basic,int,float]
        for t in types:
            if isinstance(p,t): 
                return t
        raise "Unimplemented type. Fix in function.i."

    xt = which(x)
    yt = which(y)
    
    func_hash = {(basic,basic) : atan2_basic_basic,
                 (basic,int) : atan2_basic_int,
                 (basic,float) : atan2_basic_double,
                 (int,basic) : atan2_int_basic,
                 (int,int) : atan2_int_int,
                 (int,float) : atan2_int_double,
                 (float,basic) : atan2_double_basic,
                 (float,int) : atan2_double_int,
                 (float,float) : atan2_double_double}

    return func_hash[(xt,yt)](x,y)

class sinh_SERIAL(_object):
    """Proxy of C++ GiNaC::sinh_SERIAL class"""
    __swig_setmethods__ = {}
    __setattr__ = lambda self, name, value: _swig_setattr(self, sinh_SERIAL, name, value)
    __swig_getmethods__ = {}
    __getattr__ = lambda self, name: _swig_getattr(self, sinh_SERIAL, name)
    __repr__ = _swig_repr
    __swig_setmethods__["serial"] = _swiginac.sinh_SERIAL_serial_set
    __swig_getmethods__["serial"] = _swiginac.sinh_SERIAL_serial_get
    if _newclass:serial = _swig_property(_swiginac.sinh_SERIAL_serial_get, _swiginac.sinh_SERIAL_serial_set)
    def __init__(self): 
        """__init__(GiNaC::sinh_SERIAL self) -> sinh_SERIAL"""
        this = _swiginac.new_sinh_SERIAL()
        try: self.this.append(this)
        except: self.this = this
    __swig_destroy__ = _swiginac.delete_sinh_SERIAL
    __del__ = lambda self : None;
sinh_SERIAL_swigregister = _swiginac.sinh_SERIAL_swigregister
sinh_SERIAL_swigregister(sinh_SERIAL)
atan2_NPARAMS = cvar.atan2_NPARAMS


def sinh_basic(*args):
  """sinh_basic(basic p1) -> function"""
  return _swiginac.sinh_basic(*args)

def sinh_int(*args):
  """sinh_int(int const & p1) -> function"""
  return _swiginac.sinh_int(*args)

def sinh_double(*args):
  """sinh_double(double const & p1) -> function"""
  return _swiginac.sinh_double(*args)
def sinh(x):
    if isinstance(x,basic):
        return sinh_basic(x).eval()
    elif isinstance(x,int):
        return sinh_int(x).eval()
    elif isinstance(x,float):
        return sinh_double(x).eval()
    else:
        raise "Unimplented type. Fix in function.i."

class cosh_SERIAL(_object):
    """Proxy of C++ GiNaC::cosh_SERIAL class"""
    __swig_setmethods__ = {}
    __setattr__ = lambda self, name, value: _swig_setattr(self, cosh_SERIAL, name, value)
    __swig_getmethods__ = {}
    __getattr__ = lambda self, name: _swig_getattr(self, cosh_SERIAL, name)
    __repr__ = _swig_repr
    __swig_setmethods__["serial"] = _swiginac.cosh_SERIAL_serial_set
    __swig_getmethods__["serial"] = _swiginac.cosh_SERIAL_serial_get
    if _newclass:serial = _swig_property(_swiginac.cosh_SERIAL_serial_get, _swiginac.cosh_SERIAL_serial_set)
    def __init__(self): 
        """__init__(GiNaC::cosh_SERIAL self) -> cosh_SERIAL"""
        this = _swiginac.new_cosh_SERIAL()
        try: self.this.append(this)
        except: self.this = this
    __swig_destroy__ = _swiginac.delete_cosh_SERIAL
    __del__ = lambda self : None;
cosh_SERIAL_swigregister = _swiginac.cosh_SERIAL_swigregister
cosh_SERIAL_swigregister(cosh_SERIAL)
sinh_NPARAMS = cvar.sinh_NPARAMS


def cosh_basic(*args):
  """cosh_basic(basic p1) -> function"""
  return _swiginac.cosh_basic(*args)

def cosh_int(*args):
  """cosh_int(int const & p1) -> function"""
  return _swiginac.cosh_int(*args)

def cosh_double(*args):
  """cosh_double(double const & p1) -> function"""
  return _swiginac.cosh_double(*args)
def cosh(x):
    if isinstance(x,basic):
        return cosh_basic(x).eval()
    elif isinstance(x,int):
        return cosh_int(x).eval()
    elif isinstance(x,float):
        return cosh_double(x).eval()
    else:
        raise "Unimplented type. Fix in function.i."

class tanh_SERIAL(_object):
    """Proxy of C++ GiNaC::tanh_SERIAL class"""
    __swig_setmethods__ = {}
    __setattr__ = lambda self, name, value: _swig_setattr(self, tanh_SERIAL, name, value)
    __swig_getmethods__ = {}
    __getattr__ = lambda self, name: _swig_getattr(self, tanh_SERIAL, name)
    __repr__ = _swig_repr
    __swig_setmethods__["serial"] = _swiginac.tanh_SERIAL_serial_set
    __swig_getmethods__["serial"] = _swiginac.tanh_SERIAL_serial_get
    if _newclass:serial = _swig_property(_swiginac.tanh_SERIAL_serial_get, _swiginac.tanh_SERIAL_serial_set)
    def __init__(self): 
        """__init__(GiNaC::tanh_SERIAL self) -> tanh_SERIAL"""
        this = _swiginac.new_tanh_SERIAL()
        try: self.this.append(this)
        except: self.this = this
    __swig_destroy__ = _swiginac.delete_tanh_SERIAL
    __del__ = lambda self : None;
tanh_SERIAL_swigregister = _swiginac.tanh_SERIAL_swigregister
tanh_SERIAL_swigregister(tanh_SERIAL)
cosh_NPARAMS = cvar.cosh_NPARAMS


def tanh_basic(*args):
  """tanh_basic(basic p1) -> function"""
  return _swiginac.tanh_basic(*args)

def tanh_int(*args):
  """tanh_int(int const & p1) -> function"""
  return _swiginac.tanh_int(*args)

def tanh_double(*args):
  """tanh_double(double const & p1) -> function"""
  return _swiginac.tanh_double(*args)
def tanh(x):
    if isinstance(x,basic):
        return tanh_basic(x).eval()
    elif isinstance(x,int):
        return tanh_int(x).eval()
    elif isinstance(x,float):
        return tanh_double(x).eval()
    else:
        raise "Unimplented type. Fix in function.i."

class asinh_SERIAL(_object):
    """Proxy of C++ GiNaC::asinh_SERIAL class"""
    __swig_setmethods__ = {}
    __setattr__ = lambda self, name, value: _swig_setattr(self, asinh_SERIAL, name, value)
    __swig_getmethods__ = {}
    __getattr__ = lambda self, name: _swig_getattr(self, asinh_SERIAL, name)
    __repr__ = _swig_repr
    __swig_setmethods__["serial"] = _swiginac.asinh_SERIAL_serial_set
    __swig_getmethods__["serial"] = _swiginac.asinh_SERIAL_serial_get
    if _newclass:serial = _swig_property(_swiginac.asinh_SERIAL_serial_get, _swiginac.asinh_SERIAL_serial_set)
    def __init__(self): 
        """__init__(GiNaC::asinh_SERIAL self) -> asinh_SERIAL"""
        this = _swiginac.new_asinh_SERIAL()
        try: self.this.append(this)
        except: self.this = this
    __swig_destroy__ = _swiginac.delete_asinh_SERIAL
    __del__ = lambda self : None;
asinh_SERIAL_swigregister = _swiginac.asinh_SERIAL_swigregister
asinh_SERIAL_swigregister(asinh_SERIAL)
tanh_NPARAMS = cvar.tanh_NPARAMS


def asinh_basic(*args):
  """asinh_basic(basic p1) -> function"""
  return _swiginac.asinh_basic(*args)

def asinh_int(*args):
  """asinh_int(int const & p1) -> function"""
  return _swiginac.asinh_int(*args)

def asinh_double(*args):
  """asinh_double(double const & p1) -> function"""
  return _swiginac.asinh_double(*args)
def asinh(x):
    if isinstance(x,basic):
        return asinh_basic(x).eval()
    elif isinstance(x,int):
        return asinh_int(x).eval()
    elif isinstance(x,float):
        return asinh_double(x).eval()
    else:
        raise "Unimplented type. Fix in function.i."

class acosh_SERIAL(_object):
    """Proxy of C++ GiNaC::acosh_SERIAL class"""
    __swig_setmethods__ = {}
    __setattr__ = lambda self, name, value: _swig_setattr(self, acosh_SERIAL, name, value)
    __swig_getmethods__ = {}
    __getattr__ = lambda self, name: _swig_getattr(self, acosh_SERIAL, name)
    __repr__ = _swig_repr
    __swig_setmethods__["serial"] = _swiginac.acosh_SERIAL_serial_set
    __swig_getmethods__["serial"] = _swiginac.acosh_SERIAL_serial_get
    if _newclass:serial = _swig_property(_swiginac.acosh_SERIAL_serial_get, _swiginac.acosh_SERIAL_serial_set)
    def __init__(self): 
        """__init__(GiNaC::acosh_SERIAL self) -> acosh_SERIAL"""
        this = _swiginac.new_acosh_SERIAL()
        try: self.this.append(this)
        except: self.this = this
    __swig_destroy__ = _swiginac.delete_acosh_SERIAL
    __del__ = lambda self : None;
acosh_SERIAL_swigregister = _swiginac.acosh_SERIAL_swigregister
acosh_SERIAL_swigregister(acosh_SERIAL)
asinh_NPARAMS = cvar.asinh_NPARAMS


def acosh_basic(*args):
  """acosh_basic(basic p1) -> function"""
  return _swiginac.acosh_basic(*args)

def acosh_int(*args):
  """acosh_int(int const & p1) -> function"""
  return _swiginac.acosh_int(*args)

def acosh_double(*args):
  """acosh_double(double const & p1) -> function"""
  return _swiginac.acosh_double(*args)
def acosh(x):
    if isinstance(x,basic):
        return acosh_basic(x).eval()
    elif isinstance(x,int):
        return acosh_int(x).eval()
    elif isinstance(x,float):
        return acosh_double(x).eval()
    else:
        raise "Unimplented type. Fix in function.i."

class atanh_SERIAL(_object):
    """Proxy of C++ GiNaC::atanh_SERIAL class"""
    __swig_setmethods__ = {}
    __setattr__ = lambda self, name, value: _swig_setattr(self, atanh_SERIAL, name, value)
    __swig_getmethods__ = {}
    __getattr__ = lambda self, name: _swig_getattr(self, atanh_SERIAL, name)
    __repr__ = _swig_repr
    __swig_setmethods__["serial"] = _swiginac.atanh_SERIAL_serial_set
    __swig_getmethods__["serial"] = _swiginac.atanh_SERIAL_serial_get
    if _newclass:serial = _swig_property(_swiginac.atanh_SERIAL_serial_get, _swiginac.atanh_SERIAL_serial_set)
    def __init__(self): 
        """__init__(GiNaC::atanh_SERIAL self) -> atanh_SERIAL"""
        this = _swiginac.new_atanh_SERIAL()
        try: self.this.append(this)
        except: self.this = this
    __swig_destroy__ = _swiginac.delete_atanh_SERIAL
    __del__ = lambda self : None;
atanh_SERIAL_swigregister = _swiginac.atanh_SERIAL_swigregister
atanh_SERIAL_swigregister(atanh_SERIAL)
acosh_NPARAMS = cvar.acosh_NPARAMS


def atanh_basic(*args):
  """atanh_basic(basic p1) -> function"""
  return _swiginac.atanh_basic(*args)

def atanh_int(*args):
  """atanh_int(int const & p1) -> function"""
  return _swiginac.atanh_int(*args)

def atanh_double(*args):
  """atanh_double(double const & p1) -> function"""
  return _swiginac.atanh_double(*args)
def atanh(x):
    if isinstance(x,basic):
        return atanh_basic(x).eval()
    elif isinstance(x,int):
        return atanh_int(x).eval()
    elif isinstance(x,float):
        return atanh_double(x).eval()
    else:
        raise "Unimplented type. Fix in function.i."

class Li2_SERIAL(_object):
    """Proxy of C++ GiNaC::Li2_SERIAL class"""
    __swig_setmethods__ = {}
    __setattr__ = lambda self, name, value: _swig_setattr(self, Li2_SERIAL, name, value)
    __swig_getmethods__ = {}
    __getattr__ = lambda self, name: _swig_getattr(self, Li2_SERIAL, name)
    __repr__ = _swig_repr
    __swig_setmethods__["serial"] = _swiginac.Li2_SERIAL_serial_set
    __swig_getmethods__["serial"] = _swiginac.Li2_SERIAL_serial_get
    if _newclass:serial = _swig_property(_swiginac.Li2_SERIAL_serial_get, _swiginac.Li2_SERIAL_serial_set)
    def __init__(self): 
        """__init__(GiNaC::Li2_SERIAL self) -> Li2_SERIAL"""
        this = _swiginac.new_Li2_SERIAL()
        try: self.this.append(this)
        except: self.this = this
    __swig_destroy__ = _swiginac.delete_Li2_SERIAL
    __del__ = lambda self : None;
Li2_SERIAL_swigregister = _swiginac.Li2_SERIAL_swigregister
Li2_SERIAL_swigregister(Li2_SERIAL)
atanh_NPARAMS = cvar.atanh_NPARAMS


def Li2_basic(*args):
  """Li2_basic(basic p1) -> function"""
  return _swiginac.Li2_basic(*args)

def Li2_int(*args):
  """Li2_int(int const & p1) -> function"""
  return _swiginac.Li2_int(*args)

def Li2_double(*args):
  """Li2_double(double const & p1) -> function"""
  return _swiginac.Li2_double(*args)
def Li2(x):
    if isinstance(x,basic):
        return Li2_basic(x).eval()
    elif isinstance(x,int):
        return Li2_int(x).eval()
    elif isinstance(x,float):
        return Li2_double(x).eval()
    else:
        raise "Unimplented type. Fix in function.i."

class Li3_SERIAL(_object):
    """Proxy of C++ GiNaC::Li3_SERIAL class"""
    __swig_setmethods__ = {}
    __setattr__ = lambda self, name, value: _swig_setattr(self, Li3_SERIAL, name, value)
    __swig_getmethods__ = {}
    __getattr__ = lambda self, name: _swig_getattr(self, Li3_SERIAL, name)
    __repr__ = _swig_repr
    __swig_setmethods__["serial"] = _swiginac.Li3_SERIAL_serial_set
    __swig_getmethods__["serial"] = _swiginac.Li3_SERIAL_serial_get
    if _newclass:serial = _swig_property(_swiginac.Li3_SERIAL_serial_get, _swiginac.Li3_SERIAL_serial_set)
    def __init__(self): 
        """__init__(GiNaC::Li3_SERIAL self) -> Li3_SERIAL"""
        this = _swiginac.new_Li3_SERIAL()
        try: self.this.append(this)
        except: self.this = this
    __swig_destroy__ = _swiginac.delete_Li3_SERIAL
    __del__ = lambda self : None;
Li3_SERIAL_swigregister = _swiginac.Li3_SERIAL_swigregister
Li3_SERIAL_swigregister(Li3_SERIAL)
Li2_NPARAMS = cvar.Li2_NPARAMS


def Li3_basic(*args):
  """Li3_basic(basic p1) -> function"""
  return _swiginac.Li3_basic(*args)

def Li3_int(*args):
  """Li3_int(int const & p1) -> function"""
  return _swiginac.Li3_int(*args)

def Li3_double(*args):
  """Li3_double(double const & p1) -> function"""
  return _swiginac.Li3_double(*args)
def Li3(x):
    if isinstance(x,basic):
        return Li3_basic(x).eval()
    elif isinstance(x,int):
        return Li3_int(x).eval()
    elif isinstance(x,float):
        return Li3_double(x).eval()
    else:
        raise "Unimplented type. Fix in function.i."

class zetaderiv_SERIAL(_object):
    """Proxy of C++ GiNaC::zetaderiv_SERIAL class"""
    __swig_setmethods__ = {}
    __setattr__ = lambda self, name, value: _swig_setattr(self, zetaderiv_SERIAL, name, value)
    __swig_getmethods__ = {}
    __getattr__ = lambda self, name: _swig_getattr(self, zetaderiv_SERIAL, name)
    __repr__ = _swig_repr
    __swig_setmethods__["serial"] = _swiginac.zetaderiv_SERIAL_serial_set
    __swig_getmethods__["serial"] = _swiginac.zetaderiv_SERIAL_serial_get
    if _newclass:serial = _swig_property(_swiginac.zetaderiv_SERIAL_serial_get, _swiginac.zetaderiv_SERIAL_serial_set)
    def __init__(self): 
        """__init__(GiNaC::zetaderiv_SERIAL self) -> zetaderiv_SERIAL"""
        this = _swiginac.new_zetaderiv_SERIAL()
        try: self.this.append(this)
        except: self.this = this
    __swig_destroy__ = _swiginac.delete_zetaderiv_SERIAL
    __del__ = lambda self : None;
zetaderiv_SERIAL_swigregister = _swiginac.zetaderiv_SERIAL_swigregister
zetaderiv_SERIAL_swigregister(zetaderiv_SERIAL)
Li3_NPARAMS = cvar.Li3_NPARAMS


def zetaderiv_basic_basic(*args):
  """zetaderiv_basic_basic(basic p1, basic p2) -> function"""
  return _swiginac.zetaderiv_basic_basic(*args)

def zetaderiv_basic_int(*args):
  """zetaderiv_basic_int(basic p1, int const & p2) -> function"""
  return _swiginac.zetaderiv_basic_int(*args)

def zetaderiv_basic_double(*args):
  """zetaderiv_basic_double(basic p1, double const & p2) -> function"""
  return _swiginac.zetaderiv_basic_double(*args)

def zetaderiv_int_basic(*args):
  """zetaderiv_int_basic(int const & p1, basic p2) -> function"""
  return _swiginac.zetaderiv_int_basic(*args)

def zetaderiv_int_int(*args):
  """zetaderiv_int_int(int const & p1, int const & p2) -> function"""
  return _swiginac.zetaderiv_int_int(*args)

def zetaderiv_int_double(*args):
  """zetaderiv_int_double(int const & p1, double const & p2) -> function"""
  return _swiginac.zetaderiv_int_double(*args)

def zetaderiv_double_basic(*args):
  """zetaderiv_double_basic(double const & p1, basic p2) -> function"""
  return _swiginac.zetaderiv_double_basic(*args)

def zetaderiv_double_int(*args):
  """zetaderiv_double_int(double const & p1, int const & p2) -> function"""
  return _swiginac.zetaderiv_double_int(*args)

def zetaderiv_double_double(*args):
  """zetaderiv_double_double(double const & p1, double const & p2) -> function"""
  return _swiginac.zetaderiv_double_double(*args)
def zetaderiv(x,y):
    def which(p):
        types = [basic,int,float]
        for t in types:
            if isinstance(p,t): 
                return t
        raise "Unimplemented type. Fix in function.i."

    xt = which(x)
    yt = which(y)
    
    func_hash = {(basic,basic) : zetaderiv_basic_basic,
                 (basic,int) : zetaderiv_basic_int,
                 (basic,float) : zetaderiv_basic_double,
                 (int,basic) : zetaderiv_int_basic,
                 (int,int) : zetaderiv_int_int,
                 (int,float) : zetaderiv_int_double,
                 (float,basic) : zetaderiv_double_basic,
                 (float,int) : zetaderiv_double_int,
                 (float,float) : zetaderiv_double_double}

    return func_hash[(xt,yt)](x,y)

class Li_SERIAL(_object):
    """Proxy of C++ GiNaC::Li_SERIAL class"""
    __swig_setmethods__ = {}
    __setattr__ = lambda self, name, value: _swig_setattr(self, Li_SERIAL, name, value)
    __swig_getmethods__ = {}
    __getattr__ = lambda self, name: _swig_getattr(self, Li_SERIAL, name)
    __repr__ = _swig_repr
    __swig_setmethods__["serial"] = _swiginac.Li_SERIAL_serial_set
    __swig_getmethods__["serial"] = _swiginac.Li_SERIAL_serial_get
    if _newclass:serial = _swig_property(_swiginac.Li_SERIAL_serial_get, _swiginac.Li_SERIAL_serial_set)
    def __init__(self): 
        """__init__(GiNaC::Li_SERIAL self) -> Li_SERIAL"""
        this = _swiginac.new_Li_SERIAL()
        try: self.this.append(this)
        except: self.this = this
    __swig_destroy__ = _swiginac.delete_Li_SERIAL
    __del__ = lambda self : None;
Li_SERIAL_swigregister = _swiginac.Li_SERIAL_swigregister
Li_SERIAL_swigregister(Li_SERIAL)
zetaderiv_NPARAMS = cvar.zetaderiv_NPARAMS


def Li_basic_basic(*args):
  """Li_basic_basic(basic p1, basic p2) -> function"""
  return _swiginac.Li_basic_basic(*args)

def Li_basic_int(*args):
  """Li_basic_int(basic p1, int const & p2) -> function"""
  return _swiginac.Li_basic_int(*args)

def Li_basic_double(*args):
  """Li_basic_double(basic p1, double const & p2) -> function"""
  return _swiginac.Li_basic_double(*args)

def Li_int_basic(*args):
  """Li_int_basic(int const & p1, basic p2) -> function"""
  return _swiginac.Li_int_basic(*args)

def Li_int_int(*args):
  """Li_int_int(int const & p1, int const & p2) -> function"""
  return _swiginac.Li_int_int(*args)

def Li_int_double(*args):
  """Li_int_double(int const & p1, double const & p2) -> function"""
  return _swiginac.Li_int_double(*args)

def Li_double_basic(*args):
  """Li_double_basic(double const & p1, basic p2) -> function"""
  return _swiginac.Li_double_basic(*args)

def Li_double_int(*args):
  """Li_double_int(double const & p1, int const & p2) -> function"""
  return _swiginac.Li_double_int(*args)

def Li_double_double(*args):
  """Li_double_double(double const & p1, double const & p2) -> function"""
  return _swiginac.Li_double_double(*args)
def Li(x,y):
    def which(p):
        types = [basic,int,float]
        for t in types:
            if isinstance(p,t): 
                return t
        raise "Unimplemented type. Fix in function.i."

    xt = which(x)
    yt = which(y)
    
    func_hash = {(basic,basic) : Li_basic_basic,
                 (basic,int) : Li_basic_int,
                 (basic,float) : Li_basic_double,
                 (int,basic) : Li_int_basic,
                 (int,int) : Li_int_int,
                 (int,float) : Li_int_double,
                 (float,basic) : Li_double_basic,
                 (float,int) : Li_double_int,
                 (float,float) : Li_double_double}

    return func_hash[(xt,yt)](x,y)

class S_SERIAL(_object):
    """Proxy of C++ GiNaC::S_SERIAL class"""
    __swig_setmethods__ = {}
    __setattr__ = lambda self, name, value: _swig_setattr(self, S_SERIAL, name, value)
    __swig_getmethods__ = {}
    __getattr__ = lambda self, name: _swig_getattr(self, S_SERIAL, name)
    __repr__ = _swig_repr
    __swig_setmethods__["serial"] = _swiginac.S_SERIAL_serial_set
    __swig_getmethods__["serial"] = _swiginac.S_SERIAL_serial_get
    if _newclass:serial = _swig_property(_swiginac.S_SERIAL_serial_get, _swiginac.S_SERIAL_serial_set)
    def __init__(self): 
        """__init__(GiNaC::S_SERIAL self) -> S_SERIAL"""
        this = _swiginac.new_S_SERIAL()
        try: self.this.append(this)
        except: self.this = this
    __swig_destroy__ = _swiginac.delete_S_SERIAL
    __del__ = lambda self : None;
S_SERIAL_swigregister = _swiginac.S_SERIAL_swigregister
S_SERIAL_swigregister(S_SERIAL)
Li_NPARAMS = cvar.Li_NPARAMS


def S_basic_basic_basic(*args):
  """S_basic_basic_basic(basic p1, basic p2, basic p3) -> function"""
  return _swiginac.S_basic_basic_basic(*args)

def S_basic_basic_int(*args):
  """S_basic_basic_int(basic p1, basic p2, int const & p3) -> function"""
  return _swiginac.S_basic_basic_int(*args)

def S_basic_basic_double(*args):
  """S_basic_basic_double(basic p1, basic p2, double const & p3) -> function"""
  return _swiginac.S_basic_basic_double(*args)

def S_basic_int_basic(*args):
  """S_basic_int_basic(basic p1, int const & p2, basic p3) -> function"""
  return _swiginac.S_basic_int_basic(*args)

def S_basic_int_int(*args):
  """S_basic_int_int(basic p1, int const & p2, int const & p3) -> function"""
  return _swiginac.S_basic_int_int(*args)

def S_basic_int_double(*args):
  """S_basic_int_double(basic p1, int const & p2, double const & p3) -> function"""
  return _swiginac.S_basic_int_double(*args)

def S_basic_double_basic(*args):
  """S_basic_double_basic(basic p1, double const & p2, basic p3) -> function"""
  return _swiginac.S_basic_double_basic(*args)

def S_basic_double_int(*args):
  """S_basic_double_int(basic p1, double const & p2, int const & p3) -> function"""
  return _swiginac.S_basic_double_int(*args)

def S_basic_double_double(*args):
  """S_basic_double_double(basic p1, double const & p2, double const & p3) -> function"""
  return _swiginac.S_basic_double_double(*args)

def S_int_basic_basic(*args):
  """S_int_basic_basic(int const & p1, basic p2, basic p3) -> function"""
  return _swiginac.S_int_basic_basic(*args)

def S_int_basic_int(*args):
  """S_int_basic_int(int const & p1, basic p2, int const & p3) -> function"""
  return _swiginac.S_int_basic_int(*args)

def S_int_basic_double(*args):
  """S_int_basic_double(int const & p1, basic p2, double const & p3) -> function"""
  return _swiginac.S_int_basic_double(*args)

def S_int_int_basic(*args):
  """S_int_int_basic(int const & p1, int const & p2, basic p3) -> function"""
  return _swiginac.S_int_int_basic(*args)

def S_int_int_int(*args):
  """S_int_int_int(int const & p1, int const & p2, int const & p3) -> function"""
  return _swiginac.S_int_int_int(*args)

def S_int_int_double(*args):
  """S_int_int_double(int const & p1, int const & p2, double const & p3) -> function"""
  return _swiginac.S_int_int_double(*args)

def S_int_double_basic(*args):
  """S_int_double_basic(int const & p1, double const & p2, basic p3) -> function"""
  return _swiginac.S_int_double_basic(*args)

def S_int_double_int(*args):
  """S_int_double_int(int const & p1, double const & p2, int const & p3) -> function"""
  return _swiginac.S_int_double_int(*args)

def S_int_double_double(*args):
  """S_int_double_double(int const & p1, double const & p2, double const & p3) -> function"""
  return _swiginac.S_int_double_double(*args)

def S_double_basic_basic(*args):
  """S_double_basic_basic(double const & p1, basic p2, basic p3) -> function"""
  return _swiginac.S_double_basic_basic(*args)

def S_double_basic_int(*args):
  """S_double_basic_int(double const & p1, basic p2, int const & p3) -> function"""
  return _swiginac.S_double_basic_int(*args)

def S_double_basic_double(*args):
  """S_double_basic_double(double const & p1, basic p2, double const & p3) -> function"""
  return _swiginac.S_double_basic_double(*args)

def S_double_int_basic(*args):
  """S_double_int_basic(double const & p1, int const & p2, basic p3) -> function"""
  return _swiginac.S_double_int_basic(*args)

def S_double_int_int(*args):
  """S_double_int_int(double const & p1, int const & p2, int const & p3) -> function"""
  return _swiginac.S_double_int_int(*args)

def S_double_int_double(*args):
  """S_double_int_double(double const & p1, int const & p2, double const & p3) -> function"""
  return _swiginac.S_double_int_double(*args)

def S_double_double_basic(*args):
  """S_double_double_basic(double const & p1, double const & p2, basic p3) -> function"""
  return _swiginac.S_double_double_basic(*args)

def S_double_double_int(*args):
  """S_double_double_int(double const & p1, double const & p2, int const & p3) -> function"""
  return _swiginac.S_double_double_int(*args)

def S_double_double_double(*args):
  """S_double_double_double(double const & p1, double const & p2, double const & p3) -> function"""
  return _swiginac.S_double_double_double(*args)
def S(x,y,z):
    def which(p):
        types = [basic,int,float]
        for t in types:
            if isinstance(p,t): 
                return t
        raise "Unimplemented type. Fix in function.i."

    xt = which(x)
    yt = which(y)
    zt = which(z)
    
    func_hash = {(basic,basic,basic) : S_basic_basic_basic,
                 (basic,basic,int) : S_basic_basic_int,
                 (basic,basic,float) : S_basic_basic_double,
                 (basic,int,basic) : S_basic_int_basic,
                 (basic,int,int) : S_basic_int_int,
                 (basic,int,float) : S_basic_int_double,
                 (basic,float,basic) : S_basic_double_basic,
                 (basic,float,int) : S_basic_double_int,
                 (basic,float,float) : S_basic_double_double,
                 (int,basic,basic) : S_int_basic_basic,
                 (int,basic,int) : S_int_basic_int,
                 (int,basic,float) : S_int_basic_double,
                 (int,int,basic) : S_int_int_basic,
                 (int,int,int) : S_int_int_int,
                 (int,int,float) : S_int_int_double,
                 (int,float,basic) : S_int_double_basic,
                 (int,float,int) : S_int_double_int,
                 (int,float,float) : S_int_double_double,
                 (float,basic,basic) : S_double_basic_basic,
                 (float,basic,int) : S_double_basic_int,
                 (float,basic,float) : S_double_basic_double,
                 (float,int,basic) : S_double_int_basic,
                 (float,int,int) : S_double_int_int,
                 (float,int,float) : S_double_int_double,
                 (float,float,basic) : S_double_double_basic,
                 (float,float,int) : S_double_double_int,
                 (float,float,float) : S_double_double_double}

    return func_hash[(xt,yt,zt)](x,y,z)

class H_SERIAL(_object):
    """Proxy of C++ GiNaC::H_SERIAL class"""
    __swig_setmethods__ = {}
    __setattr__ = lambda self, name, value: _swig_setattr(self, H_SERIAL, name, value)
    __swig_getmethods__ = {}
    __getattr__ = lambda self, name: _swig_getattr(self, H_SERIAL, name)
    __repr__ = _swig_repr
    __swig_setmethods__["serial"] = _swiginac.H_SERIAL_serial_set
    __swig_getmethods__["serial"] = _swiginac.H_SERIAL_serial_get
    if _newclass:serial = _swig_property(_swiginac.H_SERIAL_serial_get, _swiginac.H_SERIAL_serial_set)
    def __init__(self): 
        """__init__(GiNaC::H_SERIAL self) -> H_SERIAL"""
        this = _swiginac.new_H_SERIAL()
        try: self.this.append(this)
        except: self.this = this
    __swig_destroy__ = _swiginac.delete_H_SERIAL
    __del__ = lambda self : None;
H_SERIAL_swigregister = _swiginac.H_SERIAL_swigregister
H_SERIAL_swigregister(H_SERIAL)
S_NPARAMS = cvar.S_NPARAMS


def H_basic_basic(*args):
  """H_basic_basic(basic p1, basic p2) -> function"""
  return _swiginac.H_basic_basic(*args)

def H_basic_int(*args):
  """H_basic_int(basic p1, int const & p2) -> function"""
  return _swiginac.H_basic_int(*args)

def H_basic_double(*args):
  """H_basic_double(basic p1, double const & p2) -> function"""
  return _swiginac.H_basic_double(*args)

def H_int_basic(*args):
  """H_int_basic(int const & p1, basic p2) -> function"""
  return _swiginac.H_int_basic(*args)

def H_int_int(*args):
  """H_int_int(int const & p1, int const & p2) -> function"""
  return _swiginac.H_int_int(*args)

def H_int_double(*args):
  """H_int_double(int const & p1, double const & p2) -> function"""
  return _swiginac.H_int_double(*args)

def H_double_basic(*args):
  """H_double_basic(double const & p1, basic p2) -> function"""
  return _swiginac.H_double_basic(*args)

def H_double_int(*args):
  """H_double_int(double const & p1, int const & p2) -> function"""
  return _swiginac.H_double_int(*args)

def H_double_double(*args):
  """H_double_double(double const & p1, double const & p2) -> function"""
  return _swiginac.H_double_double(*args)
def H(x,y):
    def which(p):
        types = [basic,int,float]
        for t in types:
            if isinstance(p,t): 
                return t
        raise "Unimplemented type. Fix in function.i."

    xt = which(x)
    yt = which(y)
    
    func_hash = {(basic,basic) : H_basic_basic,
                 (basic,int) : H_basic_int,
                 (basic,float) : H_basic_double,
                 (int,basic) : H_int_basic,
                 (int,int) : H_int_int,
                 (int,float) : H_int_double,
                 (float,basic) : H_double_basic,
                 (float,int) : H_double_int,
                 (float,float) : H_double_double}

    return func_hash[(xt,yt)](x,y)

class lgamma_SERIAL(_object):
    """Proxy of C++ GiNaC::lgamma_SERIAL class"""
    __swig_setmethods__ = {}
    __setattr__ = lambda self, name, value: _swig_setattr(self, lgamma_SERIAL, name, value)
    __swig_getmethods__ = {}
    __getattr__ = lambda self, name: _swig_getattr(self, lgamma_SERIAL, name)
    __repr__ = _swig_repr
    __swig_setmethods__["serial"] = _swiginac.lgamma_SERIAL_serial_set
    __swig_getmethods__["serial"] = _swiginac.lgamma_SERIAL_serial_get
    if _newclass:serial = _swig_property(_swiginac.lgamma_SERIAL_serial_get, _swiginac.lgamma_SERIAL_serial_set)
    def __init__(self): 
        """__init__(GiNaC::lgamma_SERIAL self) -> lgamma_SERIAL"""
        this = _swiginac.new_lgamma_SERIAL()
        try: self.this.append(this)
        except: self.this = this
    __swig_destroy__ = _swiginac.delete_lgamma_SERIAL
    __del__ = lambda self : None;
lgamma_SERIAL_swigregister = _swiginac.lgamma_SERIAL_swigregister
lgamma_SERIAL_swigregister(lgamma_SERIAL)
H_NPARAMS = cvar.H_NPARAMS


def lgamma_basic(*args):
  """lgamma_basic(basic p1) -> function"""
  return _swiginac.lgamma_basic(*args)

def lgamma_int(*args):
  """lgamma_int(int const & p1) -> function"""
  return _swiginac.lgamma_int(*args)

def lgamma_double(*args):
  """lgamma_double(double const & p1) -> function"""
  return _swiginac.lgamma_double(*args)
def lgamma(x):
    if isinstance(x,basic):
        return lgamma_basic(x).eval()
    elif isinstance(x,int):
        return lgamma_int(x).eval()
    elif isinstance(x,float):
        return lgamma_double(x).eval()
    else:
        raise "Unimplented type. Fix in function.i."

class tgamma_SERIAL(_object):
    """Proxy of C++ GiNaC::tgamma_SERIAL class"""
    __swig_setmethods__ = {}
    __setattr__ = lambda self, name, value: _swig_setattr(self, tgamma_SERIAL, name, value)
    __swig_getmethods__ = {}
    __getattr__ = lambda self, name: _swig_getattr(self, tgamma_SERIAL, name)
    __repr__ = _swig_repr
    __swig_setmethods__["serial"] = _swiginac.tgamma_SERIAL_serial_set
    __swig_getmethods__["serial"] = _swiginac.tgamma_SERIAL_serial_get
    if _newclass:serial = _swig_property(_swiginac.tgamma_SERIAL_serial_get, _swiginac.tgamma_SERIAL_serial_set)
    def __init__(self): 
        """__init__(GiNaC::tgamma_SERIAL self) -> tgamma_SERIAL"""
        this = _swiginac.new_tgamma_SERIAL()
        try: self.this.append(this)
        except: self.this = this
    __swig_destroy__ = _swiginac.delete_tgamma_SERIAL
    __del__ = lambda self : None;
tgamma_SERIAL_swigregister = _swiginac.tgamma_SERIAL_swigregister
tgamma_SERIAL_swigregister(tgamma_SERIAL)
lgamma_NPARAMS = cvar.lgamma_NPARAMS


def tgamma_basic(*args):
  """tgamma_basic(basic p1) -> function"""
  return _swiginac.tgamma_basic(*args)

def tgamma_int(*args):
  """tgamma_int(int const & p1) -> function"""
  return _swiginac.tgamma_int(*args)

def tgamma_double(*args):
  """tgamma_double(double const & p1) -> function"""
  return _swiginac.tgamma_double(*args)
def tgamma(x):
    if isinstance(x,basic):
        return tgamma_basic(x).eval()
    elif isinstance(x,int):
        return tgamma_int(x).eval()
    elif isinstance(x,float):
        return tgamma_double(x).eval()
    else:
        raise "Unimplented type. Fix in function.i."

class beta_SERIAL(_object):
    """Proxy of C++ GiNaC::beta_SERIAL class"""
    __swig_setmethods__ = {}
    __setattr__ = lambda self, name, value: _swig_setattr(self, beta_SERIAL, name, value)
    __swig_getmethods__ = {}
    __getattr__ = lambda self, name: _swig_getattr(self, beta_SERIAL, name)
    __repr__ = _swig_repr
    __swig_setmethods__["serial"] = _swiginac.beta_SERIAL_serial_set
    __swig_getmethods__["serial"] = _swiginac.beta_SERIAL_serial_get
    if _newclass:serial = _swig_property(_swiginac.beta_SERIAL_serial_get, _swiginac.beta_SERIAL_serial_set)
    def __init__(self): 
        """__init__(GiNaC::beta_SERIAL self) -> beta_SERIAL"""
        this = _swiginac.new_beta_SERIAL()
        try: self.this.append(this)
        except: self.this = this
    __swig_destroy__ = _swiginac.delete_beta_SERIAL
    __del__ = lambda self : None;
beta_SERIAL_swigregister = _swiginac.beta_SERIAL_swigregister
beta_SERIAL_swigregister(beta_SERIAL)
tgamma_NPARAMS = cvar.tgamma_NPARAMS


def beta_basic_basic(*args):
  """beta_basic_basic(basic p1, basic p2) -> function"""
  return _swiginac.beta_basic_basic(*args)

def beta_basic_int(*args):
  """beta_basic_int(basic p1, int const & p2) -> function"""
  return _swiginac.beta_basic_int(*args)

def beta_basic_double(*args):
  """beta_basic_double(basic p1, double const & p2) -> function"""
  return _swiginac.beta_basic_double(*args)

def beta_int_basic(*args):
  """beta_int_basic(int const & p1, basic p2) -> function"""
  return _swiginac.beta_int_basic(*args)

def beta_int_int(*args):
  """beta_int_int(int const & p1, int const & p2) -> function"""
  return _swiginac.beta_int_int(*args)

def beta_int_double(*args):
  """beta_int_double(int const & p1, double const & p2) -> function"""
  return _swiginac.beta_int_double(*args)

def beta_double_basic(*args):
  """beta_double_basic(double const & p1, basic p2) -> function"""
  return _swiginac.beta_double_basic(*args)

def beta_double_int(*args):
  """beta_double_int(double const & p1, int const & p2) -> function"""
  return _swiginac.beta_double_int(*args)

def beta_double_double(*args):
  """beta_double_double(double const & p1, double const & p2) -> function"""
  return _swiginac.beta_double_double(*args)
def beta(x,y):
    def which(p):
        types = [basic,int,float]
        for t in types:
            if isinstance(p,t): 
                return t
        raise "Unimplemented type. Fix in function.i."

    xt = which(x)
    yt = which(y)
    
    func_hash = {(basic,basic) : beta_basic_basic,
                 (basic,int) : beta_basic_int,
                 (basic,float) : beta_basic_double,
                 (int,basic) : beta_int_basic,
                 (int,int) : beta_int_int,
                 (int,float) : beta_int_double,
                 (float,basic) : beta_double_basic,
                 (float,int) : beta_double_int,
                 (float,float) : beta_double_double}

    return func_hash[(xt,yt)](x,y)

class factorial_SERIAL(_object):
    """Proxy of C++ GiNaC::factorial_SERIAL class"""
    __swig_setmethods__ = {}
    __setattr__ = lambda self, name, value: _swig_setattr(self, factorial_SERIAL, name, value)
    __swig_getmethods__ = {}
    __getattr__ = lambda self, name: _swig_getattr(self, factorial_SERIAL, name)
    __repr__ = _swig_repr
    __swig_setmethods__["serial"] = _swiginac.factorial_SERIAL_serial_set
    __swig_getmethods__["serial"] = _swiginac.factorial_SERIAL_serial_get
    if _newclass:serial = _swig_property(_swiginac.factorial_SERIAL_serial_get, _swiginac.factorial_SERIAL_serial_set)
    def __init__(self): 
        """__init__(GiNaC::factorial_SERIAL self) -> factorial_SERIAL"""
        this = _swiginac.new_factorial_SERIAL()
        try: self.this.append(this)
        except: self.this = this
    __swig_destroy__ = _swiginac.delete_factorial_SERIAL
    __del__ = lambda self : None;
factorial_SERIAL_swigregister = _swiginac.factorial_SERIAL_swigregister
factorial_SERIAL_swigregister(factorial_SERIAL)
beta_NPARAMS = cvar.beta_NPARAMS


def factorial_basic(*args):
  """factorial_basic(basic p1) -> function"""
  return _swiginac.factorial_basic(*args)

def factorial_int(*args):
  """factorial_int(int const & p1) -> function"""
  return _swiginac.factorial_int(*args)

def factorial_double(*args):
  """factorial_double(double const & p1) -> function"""
  return _swiginac.factorial_double(*args)
def factorial(x):
    if isinstance(x,basic):
        return factorial_basic(x).eval()
    elif isinstance(x,int):
        return factorial_int(x).eval()
    elif isinstance(x,float):
        return factorial_double(x).eval()
    else:
        raise "Unimplented type. Fix in function.i."

class binomial_SERIAL(_object):
    """Proxy of C++ GiNaC::binomial_SERIAL class"""
    __swig_setmethods__ = {}
    __setattr__ = lambda self, name, value: _swig_setattr(self, binomial_SERIAL, name, value)
    __swig_getmethods__ = {}
    __getattr__ = lambda self, name: _swig_getattr(self, binomial_SERIAL, name)
    __repr__ = _swig_repr
    __swig_setmethods__["serial"] = _swiginac.binomial_SERIAL_serial_set
    __swig_getmethods__["serial"] = _swiginac.binomial_SERIAL_serial_get
    if _newclass:serial = _swig_property(_swiginac.binomial_SERIAL_serial_get, _swiginac.binomial_SERIAL_serial_set)
    def __init__(self): 
        """__init__(GiNaC::binomial_SERIAL self) -> binomial_SERIAL"""
        this = _swiginac.new_binomial_SERIAL()
        try: self.this.append(this)
        except: self.this = this
    __swig_destroy__ = _swiginac.delete_binomial_SERIAL
    __del__ = lambda self : None;
binomial_SERIAL_swigregister = _swiginac.binomial_SERIAL_swigregister
binomial_SERIAL_swigregister(binomial_SERIAL)
factorial_NPARAMS = cvar.factorial_NPARAMS


def binomial_basic_basic(*args):
  """binomial_basic_basic(basic p1, basic p2) -> function"""
  return _swiginac.binomial_basic_basic(*args)

def binomial_basic_int(*args):
  """binomial_basic_int(basic p1, int const & p2) -> function"""
  return _swiginac.binomial_basic_int(*args)

def binomial_basic_double(*args):
  """binomial_basic_double(basic p1, double const & p2) -> function"""
  return _swiginac.binomial_basic_double(*args)

def binomial_int_basic(*args):
  """binomial_int_basic(int const & p1, basic p2) -> function"""
  return _swiginac.binomial_int_basic(*args)

def binomial_int_int(*args):
  """binomial_int_int(int const & p1, int const & p2) -> function"""
  return _swiginac.binomial_int_int(*args)

def binomial_int_double(*args):
  """binomial_int_double(int const & p1, double const & p2) -> function"""
  return _swiginac.binomial_int_double(*args)

def binomial_double_basic(*args):
  """binomial_double_basic(double const & p1, basic p2) -> function"""
  return _swiginac.binomial_double_basic(*args)

def binomial_double_int(*args):
  """binomial_double_int(double const & p1, int const & p2) -> function"""
  return _swiginac.binomial_double_int(*args)

def binomial_double_double(*args):
  """binomial_double_double(double const & p1, double const & p2) -> function"""
  return _swiginac.binomial_double_double(*args)
def binomial(x,y):
    def which(p):
        types = [basic,int,float]
        for t in types:
            if isinstance(p,t): 
                return t
        raise "Unimplemented type. Fix in function.i."

    xt = which(x)
    yt = which(y)
    
    func_hash = {(basic,basic) : binomial_basic_basic,
                 (basic,int) : binomial_basic_int,
                 (basic,float) : binomial_basic_double,
                 (int,basic) : binomial_int_basic,
                 (int,int) : binomial_int_int,
                 (int,float) : binomial_int_double,
                 (float,basic) : binomial_double_basic,
                 (float,int) : binomial_double_int,
                 (float,float) : binomial_double_double}

    return func_hash[(xt,yt)](x,y)

class Order_SERIAL(_object):
    """Proxy of C++ GiNaC::Order_SERIAL class"""
    __swig_setmethods__ = {}
    __setattr__ = lambda self, name, value: _swig_setattr(self, Order_SERIAL, name, value)
    __swig_getmethods__ = {}
    __getattr__ = lambda self, name: _swig_getattr(self, Order_SERIAL, name)
    __repr__ = _swig_repr
    __swig_setmethods__["serial"] = _swiginac.Order_SERIAL_serial_set
    __swig_getmethods__["serial"] = _swiginac.Order_SERIAL_serial_get
    if _newclass:serial = _swig_property(_swiginac.Order_SERIAL_serial_get, _swiginac.Order_SERIAL_serial_set)
    def __init__(self): 
        """__init__(GiNaC::Order_SERIAL self) -> Order_SERIAL"""
        this = _swiginac.new_Order_SERIAL()
        try: self.this.append(this)
        except: self.this = this
    __swig_destroy__ = _swiginac.delete_Order_SERIAL
    __del__ = lambda self : None;
Order_SERIAL_swigregister = _swiginac.Order_SERIAL_swigregister
Order_SERIAL_swigregister(Order_SERIAL)
binomial_NPARAMS = cvar.binomial_NPARAMS


def Order_basic(*args):
  """Order_basic(basic p1) -> function"""
  return _swiginac.Order_basic(*args)

def Order_int(*args):
  """Order_int(int const & p1) -> function"""
  return _swiginac.Order_int(*args)

def Order_double(*args):
  """Order_double(double const & p1) -> function"""
  return _swiginac.Order_double(*args)
def Order(x):
    if isinstance(x,basic):
        return Order_basic(x).eval()
    elif isinstance(x,int):
        return Order_int(x).eval()
    elif isinstance(x,float):
        return Order_double(x).eval()
    else:
        raise "Unimplented type. Fix in function.i."

class zeta1_SERIAL(_object):
    """Proxy of C++ GiNaC::zeta1_SERIAL class"""
    __swig_setmethods__ = {}
    __setattr__ = lambda self, name, value: _swig_setattr(self, zeta1_SERIAL, name, value)
    __swig_getmethods__ = {}
    __getattr__ = lambda self, name: _swig_getattr(self, zeta1_SERIAL, name)
    __repr__ = _swig_repr
    __swig_setmethods__["serial"] = _swiginac.zeta1_SERIAL_serial_set
    __swig_getmethods__["serial"] = _swiginac.zeta1_SERIAL_serial_get
    if _newclass:serial = _swig_property(_swiginac.zeta1_SERIAL_serial_get, _swiginac.zeta1_SERIAL_serial_set)
    def __init__(self): 
        """__init__(GiNaC::zeta1_SERIAL self) -> zeta1_SERIAL"""
        this = _swiginac.new_zeta1_SERIAL()
        try: self.this.append(this)
        except: self.this = this
    __swig_destroy__ = _swiginac.delete_zeta1_SERIAL
    __del__ = lambda self : None;
zeta1_SERIAL_swigregister = _swiginac.zeta1_SERIAL_swigregister
zeta1_SERIAL_swigregister(zeta1_SERIAL)
Order_NPARAMS = cvar.Order_NPARAMS

class zeta2_SERIAL(_object):
    """Proxy of C++ GiNaC::zeta2_SERIAL class"""
    __swig_setmethods__ = {}
    __setattr__ = lambda self, name, value: _swig_setattr(self, zeta2_SERIAL, name, value)
    __swig_getmethods__ = {}
    __getattr__ = lambda self, name: _swig_getattr(self, zeta2_SERIAL, name)
    __repr__ = _swig_repr
    __swig_setmethods__["serial"] = _swiginac.zeta2_SERIAL_serial_set
    __swig_getmethods__["serial"] = _swiginac.zeta2_SERIAL_serial_get
    if _newclass:serial = _swig_property(_swiginac.zeta2_SERIAL_serial_get, _swiginac.zeta2_SERIAL_serial_set)
    def __init__(self): 
        """__init__(GiNaC::zeta2_SERIAL self) -> zeta2_SERIAL"""
        this = _swiginac.new_zeta2_SERIAL()
        try: self.this.append(this)
        except: self.this = this
    __swig_destroy__ = _swiginac.delete_zeta2_SERIAL
    __del__ = lambda self : None;
zeta2_SERIAL_swigregister = _swiginac.zeta2_SERIAL_swigregister
zeta2_SERIAL_swigregister(zeta2_SERIAL)


def zeta_basic(*args):
  """zeta_basic(basic p1) -> function"""
  return _swiginac.zeta_basic(*args)

def zeta_int(*args):
  """zeta_int(int const & p1) -> function"""
  return _swiginac.zeta_int(*args)

def zeta_double(*args):
  """zeta_double(double const & p1) -> function"""
  return _swiginac.zeta_double(*args)
def zeta1(x):
    if isinstance(x,basic):
        return zeta_basic(x).eval()
    elif isinstance(x,int):
        return zeta_int(x).eval()
    elif isinstance(x,float):
        return zeta_double(x).eval()
    else:
        raise "Unimplented type. Fix in function.i."


def zeta_basic_basic(*args):
  """zeta_basic_basic(basic p1, basic p2) -> function"""
  return _swiginac.zeta_basic_basic(*args)

def zeta_basic_int(*args):
  """zeta_basic_int(basic p1, int const & p2) -> function"""
  return _swiginac.zeta_basic_int(*args)

def zeta_basic_double(*args):
  """zeta_basic_double(basic p1, double const & p2) -> function"""
  return _swiginac.zeta_basic_double(*args)

def zeta_int_basic(*args):
  """zeta_int_basic(int const & p1, basic p2) -> function"""
  return _swiginac.zeta_int_basic(*args)

def zeta_int_int(*args):
  """zeta_int_int(int const & p1, int const & p2) -> function"""
  return _swiginac.zeta_int_int(*args)

def zeta_int_double(*args):
  """zeta_int_double(int const & p1, double const & p2) -> function"""
  return _swiginac.zeta_int_double(*args)

def zeta_double_basic(*args):
  """zeta_double_basic(double const & p1, basic p2) -> function"""
  return _swiginac.zeta_double_basic(*args)

def zeta_double_int(*args):
  """zeta_double_int(double const & p1, int const & p2) -> function"""
  return _swiginac.zeta_double_int(*args)

def zeta_double_double(*args):
  """zeta_double_double(double const & p1, double const & p2) -> function"""
  return _swiginac.zeta_double_double(*args)
def zeta2(x,y):
    def which(p):
        types = [basic,int,float]
        for t in types:
            if isinstance(p,t): 
                return t
        raise "Unimplemented type. Fix in function.i."

    xt = which(x)
    yt = which(y)
    
    func_hash = {(basic,basic) : zeta_basic_basic,
                 (basic,int) : zeta_basic_int,
                 (basic,float) : zeta_basic_double,
                 (int,basic) : zeta_int_basic,
                 (int,int) : zeta_int_int,
                 (int,float) : zeta_int_double,
                 (float,basic) : zeta_double_basic,
                 (float,int) : zeta_double_int,
                 (float,float) : zeta_double_double}

    return func_hash[(xt,yt)](x,y)

def zeta(*args):
  if len(args)==1:
    return zeta1(*args)
  elif len(args)==2:
    return zeta2(*args)
  else:
    raise "zeta() takes 1 or 2 arguments"

class G2_SERIAL(_object):
    """Proxy of C++ GiNaC::G2_SERIAL class"""
    __swig_setmethods__ = {}
    __setattr__ = lambda self, name, value: _swig_setattr(self, G2_SERIAL, name, value)
    __swig_getmethods__ = {}
    __getattr__ = lambda self, name: _swig_getattr(self, G2_SERIAL, name)
    __repr__ = _swig_repr
    __swig_setmethods__["serial"] = _swiginac.G2_SERIAL_serial_set
    __swig_getmethods__["serial"] = _swiginac.G2_SERIAL_serial_get
    if _newclass:serial = _swig_property(_swiginac.G2_SERIAL_serial_get, _swiginac.G2_SERIAL_serial_set)
    def __init__(self): 
        """__init__(GiNaC::G2_SERIAL self) -> G2_SERIAL"""
        this = _swiginac.new_G2_SERIAL()
        try: self.this.append(this)
        except: self.this = this
    __swig_destroy__ = _swiginac.delete_G2_SERIAL
    __del__ = lambda self : None;
G2_SERIAL_swigregister = _swiginac.G2_SERIAL_swigregister
G2_SERIAL_swigregister(G2_SERIAL)

class G3_SERIAL(_object):
    """Proxy of C++ GiNaC::G3_SERIAL class"""
    __swig_setmethods__ = {}
    __setattr__ = lambda self, name, value: _swig_setattr(self, G3_SERIAL, name, value)
    __swig_getmethods__ = {}
    __getattr__ = lambda self, name: _swig_getattr(self, G3_SERIAL, name)
    __repr__ = _swig_repr
    __swig_setmethods__["serial"] = _swiginac.G3_SERIAL_serial_set
    __swig_getmethods__["serial"] = _swiginac.G3_SERIAL_serial_get
    if _newclass:serial = _swig_property(_swiginac.G3_SERIAL_serial_get, _swiginac.G3_SERIAL_serial_set)
    def __init__(self): 
        """__init__(GiNaC::G3_SERIAL self) -> G3_SERIAL"""
        this = _swiginac.new_G3_SERIAL()
        try: self.this.append(this)
        except: self.this = this
    __swig_destroy__ = _swiginac.delete_G3_SERIAL
    __del__ = lambda self : None;
G3_SERIAL_swigregister = _swiginac.G3_SERIAL_swigregister
G3_SERIAL_swigregister(G3_SERIAL)


def G_basic_basic(*args):
  """G_basic_basic(basic x, basic y) -> function"""
  return _swiginac.G_basic_basic(*args)

def G_basic_int(*args):
  """G_basic_int(basic x, int const & y) -> function"""
  return _swiginac.G_basic_int(*args)

def G_basic_double(*args):
  """G_basic_double(basic x, double const & y) -> function"""
  return _swiginac.G_basic_double(*args)

def G_int_basic(*args):
  """G_int_basic(int const & x, basic y) -> function"""
  return _swiginac.G_int_basic(*args)

def G_int_int(*args):
  """G_int_int(int const & x, int const & y) -> function"""
  return _swiginac.G_int_int(*args)

def G_int_double(*args):
  """G_int_double(int const & x, double const & y) -> function"""
  return _swiginac.G_int_double(*args)

def G_double_basic(*args):
  """G_double_basic(double const & x, basic y) -> function"""
  return _swiginac.G_double_basic(*args)

def G_double_int(*args):
  """G_double_int(double const & x, int const & y) -> function"""
  return _swiginac.G_double_int(*args)

def G_double_double(*args):
  """G_double_double(double const & x, double const & y) -> function"""
  return _swiginac.G_double_double(*args)
def G2(x,y):
    def which(p):
        types = [basic,int,float]
        for t in types:
            if isinstance(p,t): 
                return t
        raise "Unimplemented type. Fix in function.i."

    xt = which(x)
    yt = which(y)
    
    func_hash = {(basic,basic) : G_basic_basic,
                 (basic,int) : G_basic_int,
                 (basic,float) : G_basic_double,
                 (int,basic) : G_int_basic,
                 (int,int) : G_int_int,
                 (int,float) : G_int_double,
                 (float,basic) : G_double_basic,
                 (float,int) : G_double_int,
                 (float,float) : G_double_double}

    return func_hash[(xt,yt)](x,y)


def G_basic_basic_basic(*args):
  """G_basic_basic_basic(basic x, basic s, basic y) -> function"""
  return _swiginac.G_basic_basic_basic(*args)

def G_basic_basic_int(*args):
  """G_basic_basic_int(basic x, basic s, int const & y) -> function"""
  return _swiginac.G_basic_basic_int(*args)

def G_basic_basic_double(*args):
  """G_basic_basic_double(basic x, basic s, double const & y) -> function"""
  return _swiginac.G_basic_basic_double(*args)

def G_basic_int_basic(*args):
  """G_basic_int_basic(basic x, int const & s, basic y) -> function"""
  return _swiginac.G_basic_int_basic(*args)

def G_basic_int_int(*args):
  """G_basic_int_int(basic x, int const & s, int const & y) -> function"""
  return _swiginac.G_basic_int_int(*args)

def G_basic_int_double(*args):
  """G_basic_int_double(basic x, int const & s, double const & y) -> function"""
  return _swiginac.G_basic_int_double(*args)

def G_basic_double_basic(*args):
  """G_basic_double_basic(basic x, double const & s, basic y) -> function"""
  return _swiginac.G_basic_double_basic(*args)

def G_basic_double_int(*args):
  """G_basic_double_int(basic x, double const & s, int const & y) -> function"""
  return _swiginac.G_basic_double_int(*args)

def G_basic_double_double(*args):
  """G_basic_double_double(basic x, double const & s, double const & y) -> function"""
  return _swiginac.G_basic_double_double(*args)

def G_int_basic_basic(*args):
  """G_int_basic_basic(int const & x, basic s, basic y) -> function"""
  return _swiginac.G_int_basic_basic(*args)

def G_int_basic_int(*args):
  """G_int_basic_int(int const & x, basic s, int const & y) -> function"""
  return _swiginac.G_int_basic_int(*args)

def G_int_basic_double(*args):
  """G_int_basic_double(int const & x, basic s, double const & y) -> function"""
  return _swiginac.G_int_basic_double(*args)

def G_int_int_basic(*args):
  """G_int_int_basic(int const & x, int const & s, basic y) -> function"""
  return _swiginac.G_int_int_basic(*args)

def G_int_int_int(*args):
  """G_int_int_int(int const & x, int const & s, int const & y) -> function"""
  return _swiginac.G_int_int_int(*args)

def G_int_int_double(*args):
  """G_int_int_double(int const & x, int const & s, double const & y) -> function"""
  return _swiginac.G_int_int_double(*args)

def G_int_double_basic(*args):
  """G_int_double_basic(int const & x, double const & s, basic y) -> function"""
  return _swiginac.G_int_double_basic(*args)

def G_int_double_int(*args):
  """G_int_double_int(int const & x, double const & s, int const & y) -> function"""
  return _swiginac.G_int_double_int(*args)

def G_int_double_double(*args):
  """G_int_double_double(int const & x, double const & s, double const & y) -> function"""
  return _swiginac.G_int_double_double(*args)

def G_double_basic_basic(*args):
  """G_double_basic_basic(double const & x, basic s, basic y) -> function"""
  return _swiginac.G_double_basic_basic(*args)

def G_double_basic_int(*args):
  """G_double_basic_int(double const & x, basic s, int const & y) -> function"""
  return _swiginac.G_double_basic_int(*args)

def G_double_basic_double(*args):
  """G_double_basic_double(double const & x, basic s, double const & y) -> function"""
  return _swiginac.G_double_basic_double(*args)

def G_double_int_basic(*args):
  """G_double_int_basic(double const & x, int const & s, basic y) -> function"""
  return _swiginac.G_double_int_basic(*args)

def G_double_int_int(*args):
  """G_double_int_int(double const & x, int const & s, int const & y) -> function"""
  return _swiginac.G_double_int_int(*args)

def G_double_int_double(*args):
  """G_double_int_double(double const & x, int const & s, double const & y) -> function"""
  return _swiginac.G_double_int_double(*args)

def G_double_double_basic(*args):
  """G_double_double_basic(double const & x, double const & s, basic y) -> function"""
  return _swiginac.G_double_double_basic(*args)

def G_double_double_int(*args):
  """G_double_double_int(double const & x, double const & s, int const & y) -> function"""
  return _swiginac.G_double_double_int(*args)

def G_double_double_double(*args):
  """G_double_double_double(double const & x, double const & s, double const & y) -> function"""
  return _swiginac.G_double_double_double(*args)
def G3(x,y,z):
    def which(p):
        types = [basic,int,float]
        for t in types:
            if isinstance(p,t): 
                return t
        raise "Unimplemented type. Fix in function.i."

    xt = which(x)
    yt = which(y)
    zt = which(z)
    
    func_hash = {(basic,basic,basic) : G_basic_basic_basic,
                 (basic,basic,int) : G_basic_basic_int,
                 (basic,basic,float) : G_basic_basic_double,
                 (basic,int,basic) : G_basic_int_basic,
                 (basic,int,int) : G_basic_int_int,
                 (basic,int,float) : G_basic_int_double,
                 (basic,float,basic) : G_basic_double_basic,
                 (basic,float,int) : G_basic_double_int,
                 (basic,float,float) : G_basic_double_double,
                 (int,basic,basic) : G_int_basic_basic,
                 (int,basic,int) : G_int_basic_int,
                 (int,basic,float) : G_int_basic_double,
                 (int,int,basic) : G_int_int_basic,
                 (int,int,int) : G_int_int_int,
                 (int,int,float) : G_int_int_double,
                 (int,float,basic) : G_int_double_basic,
                 (int,float,int) : G_int_double_int,
                 (int,float,float) : G_int_double_double,
                 (float,basic,basic) : G_double_basic_basic,
                 (float,basic,int) : G_double_basic_int,
                 (float,basic,float) : G_double_basic_double,
                 (float,int,basic) : G_double_int_basic,
                 (float,int,int) : G_double_int_int,
                 (float,int,float) : G_double_int_double,
                 (float,float,basic) : G_double_double_basic,
                 (float,float,int) : G_double_double_int,
                 (float,float,float) : G_double_double_double}

    return func_hash[(xt,yt,zt)](x,y,z)

def G(*args):
  if len(args)==2:
    return G2(*args)
  elif len(args)==3:
    return G3(*args)
  else:
    raise "G() takes 2 or 3 arguments"

class psi1_SERIAL(_object):
    """Proxy of C++ GiNaC::psi1_SERIAL class"""
    __swig_setmethods__ = {}
    __setattr__ = lambda self, name, value: _swig_setattr(self, psi1_SERIAL, name, value)
    __swig_getmethods__ = {}
    __getattr__ = lambda self, name: _swig_getattr(self, psi1_SERIAL, name)
    __repr__ = _swig_repr
    __swig_setmethods__["serial"] = _swiginac.psi1_SERIAL_serial_set
    __swig_getmethods__["serial"] = _swiginac.psi1_SERIAL_serial_get
    if _newclass:serial = _swig_property(_swiginac.psi1_SERIAL_serial_get, _swiginac.psi1_SERIAL_serial_set)
    def __init__(self): 
        """__init__(GiNaC::psi1_SERIAL self) -> psi1_SERIAL"""
        this = _swiginac.new_psi1_SERIAL()
        try: self.this.append(this)
        except: self.this = this
    __swig_destroy__ = _swiginac.delete_psi1_SERIAL
    __del__ = lambda self : None;
psi1_SERIAL_swigregister = _swiginac.psi1_SERIAL_swigregister
psi1_SERIAL_swigregister(psi1_SERIAL)

class psi2_SERIAL(_object):
    """Proxy of C++ GiNaC::psi2_SERIAL class"""
    __swig_setmethods__ = {}
    __setattr__ = lambda self, name, value: _swig_setattr(self, psi2_SERIAL, name, value)
    __swig_getmethods__ = {}
    __getattr__ = lambda self, name: _swig_getattr(self, psi2_SERIAL, name)
    __repr__ = _swig_repr
    __swig_setmethods__["serial"] = _swiginac.psi2_SERIAL_serial_set
    __swig_getmethods__["serial"] = _swiginac.psi2_SERIAL_serial_get
    if _newclass:serial = _swig_property(_swiginac.psi2_SERIAL_serial_get, _swiginac.psi2_SERIAL_serial_set)
    def __init__(self): 
        """__init__(GiNaC::psi2_SERIAL self) -> psi2_SERIAL"""
        this = _swiginac.new_psi2_SERIAL()
        try: self.this.append(this)
        except: self.this = this
    __swig_destroy__ = _swiginac.delete_psi2_SERIAL
    __del__ = lambda self : None;
psi2_SERIAL_swigregister = _swiginac.psi2_SERIAL_swigregister
psi2_SERIAL_swigregister(psi2_SERIAL)


def psi_basic(*args):
  """psi_basic(basic p1) -> function"""
  return _swiginac.psi_basic(*args)

def psi_int(*args):
  """psi_int(int const & p1) -> function"""
  return _swiginac.psi_int(*args)

def psi_double(*args):
  """psi_double(double const & p1) -> function"""
  return _swiginac.psi_double(*args)
def psi1(x):
    if isinstance(x,basic):
        return psi_basic(x).eval()
    elif isinstance(x,int):
        return psi_int(x).eval()
    elif isinstance(x,float):
        return psi_double(x).eval()
    else:
        raise "Unimplented type. Fix in function.i."


def psi_basic_basic(*args):
  """psi_basic_basic(basic p1, basic p2) -> function"""
  return _swiginac.psi_basic_basic(*args)

def psi_basic_int(*args):
  """psi_basic_int(basic p1, int const & p2) -> function"""
  return _swiginac.psi_basic_int(*args)

def psi_basic_double(*args):
  """psi_basic_double(basic p1, double const & p2) -> function"""
  return _swiginac.psi_basic_double(*args)

def psi_int_basic(*args):
  """psi_int_basic(int const & p1, basic p2) -> function"""
  return _swiginac.psi_int_basic(*args)

def psi_int_int(*args):
  """psi_int_int(int const & p1, int const & p2) -> function"""
  return _swiginac.psi_int_int(*args)

def psi_int_double(*args):
  """psi_int_double(int const & p1, double const & p2) -> function"""
  return _swiginac.psi_int_double(*args)

def psi_double_basic(*args):
  """psi_double_basic(double const & p1, basic p2) -> function"""
  return _swiginac.psi_double_basic(*args)

def psi_double_int(*args):
  """psi_double_int(double const & p1, int const & p2) -> function"""
  return _swiginac.psi_double_int(*args)

def psi_double_double(*args):
  """psi_double_double(double const & p1, double const & p2) -> function"""
  return _swiginac.psi_double_double(*args)
def psi2(x,y):
    def which(p):
        types = [basic,int,float]
        for t in types:
            if isinstance(p,t): 
                return t
        raise "Unimplemented type. Fix in function.i."

    xt = which(x)
    yt = which(y)
    
    func_hash = {(basic,basic) : psi_basic_basic,
                 (basic,int) : psi_basic_int,
                 (basic,float) : psi_basic_double,
                 (int,basic) : psi_int_basic,
                 (int,int) : psi_int_int,
                 (int,float) : psi_int_double,
                 (float,basic) : psi_double_basic,
                 (float,int) : psi_double_int,
                 (float,float) : psi_double_double}

    return func_hash[(xt,yt)](x,y)

def psi(*args):
  if len(args)==1:
    return psi1(*args)
  elif len(args)==2:
    return psi2(*args)
  else:
    raise "psi() takes 1 or 2 arguments"


def lsolve(*args):
  """
    lsolve(ex eqns, ex symbols, unsigned int options=solve_algo::automatic) -> ex
    lsolve(ex eqns, ex symbols) -> ex
    """
  return _swiginac.lsolve(*args)
class tensor(basic):
    """Proxy of C++ GiNaC::tensor class"""
    __swig_setmethods__ = {}
    for _s in [basic]: __swig_setmethods__.update(getattr(_s,'__swig_setmethods__',{}))
    __setattr__ = lambda self, name, value: _swig_setattr(self, tensor, name, value)
    __swig_getmethods__ = {}
    for _s in [basic]: __swig_getmethods__.update(getattr(_s,'__swig_getmethods__',{}))
    __getattr__ = lambda self, name: _swig_getattr(self, tensor, name)
    __repr__ = _swig_repr
    def __init__(self): 
        """__init__(GiNaC::tensor self) -> tensor"""
        this = _swiginac.new_tensor()
        try: self.this.append(this)
        except: self.this = this
    def replace_contr_index(self, *args):
        """replace_contr_index(tensor self, exvector::iterator self, exvector::iterator other) -> bool"""
        return _swiginac.tensor_replace_contr_index(self, *args)

    __swig_destroy__ = _swiginac.delete_tensor
    __del__ = lambda self : None;
tensor_swigregister = _swiginac.tensor_swigregister
tensor_swigregister(tensor)

class tensdelta(tensor):
    """Proxy of C++ GiNaC::tensdelta class"""
    __swig_setmethods__ = {}
    for _s in [tensor]: __swig_setmethods__.update(getattr(_s,'__swig_setmethods__',{}))
    __setattr__ = lambda self, name, value: _swig_setattr(self, tensdelta, name, value)
    __swig_getmethods__ = {}
    for _s in [tensor]: __swig_getmethods__.update(getattr(_s,'__swig_getmethods__',{}))
    __getattr__ = lambda self, name: _swig_getattr(self, tensdelta, name)
    __repr__ = _swig_repr
    def __init__(self): 
        """__init__(GiNaC::tensdelta self) -> tensdelta"""
        this = _swiginac.new_tensdelta()
        try: self.this.append(this)
        except: self.this = this
    def eval_indexed(self, *args):
        """eval_indexed(tensdelta self, basic i) -> ex"""
        return _swiginac.tensdelta_eval_indexed(self, *args)

    def contract_with(self, *args):
        """contract_with(tensdelta self, exvector::iterator self, exvector::iterator other, exvector & v) -> bool"""
        return _swiginac.tensdelta_contract_with(self, *args)

    __swig_destroy__ = _swiginac.delete_tensdelta
    __del__ = lambda self : None;
tensdelta_swigregister = _swiginac.tensdelta_swigregister
tensdelta_swigregister(tensdelta)

class tensmetric(tensor):
    """Proxy of C++ GiNaC::tensmetric class"""
    __swig_setmethods__ = {}
    for _s in [tensor]: __swig_setmethods__.update(getattr(_s,'__swig_setmethods__',{}))
    __setattr__ = lambda self, name, value: _swig_setattr(self, tensmetric, name, value)
    __swig_getmethods__ = {}
    for _s in [tensor]: __swig_getmethods__.update(getattr(_s,'__swig_getmethods__',{}))
    __getattr__ = lambda self, name: _swig_getattr(self, tensmetric, name)
    __repr__ = _swig_repr
    def __init__(self): 
        """__init__(GiNaC::tensmetric self) -> tensmetric"""
        this = _swiginac.new_tensmetric()
        try: self.this.append(this)
        except: self.this = this
    def eval_indexed(self, *args):
        """eval_indexed(tensmetric self, basic i) -> ex"""
        return _swiginac.tensmetric_eval_indexed(self, *args)

    def contract_with(self, *args):
        """contract_with(tensmetric self, exvector::iterator self, exvector::iterator other, exvector & v) -> bool"""
        return _swiginac.tensmetric_contract_with(self, *args)

    __swig_destroy__ = _swiginac.delete_tensmetric
    __del__ = lambda self : None;
tensmetric_swigregister = _swiginac.tensmetric_swigregister
tensmetric_swigregister(tensmetric)

class minkmetric(tensmetric):
    """Proxy of C++ GiNaC::minkmetric class"""
    __swig_setmethods__ = {}
    for _s in [tensmetric]: __swig_setmethods__.update(getattr(_s,'__swig_setmethods__',{}))
    __setattr__ = lambda self, name, value: _swig_setattr(self, minkmetric, name, value)
    __swig_getmethods__ = {}
    for _s in [tensmetric]: __swig_getmethods__.update(getattr(_s,'__swig_getmethods__',{}))
    __getattr__ = lambda self, name: _swig_getattr(self, minkmetric, name)
    __repr__ = _swig_repr
    def __init__(self, *args): 
        """
        __init__(GiNaC::minkmetric self) -> minkmetric
        __init__(GiNaC::minkmetric self, bool pos_sig) -> minkmetric
        """
        this = _swiginac.new_minkmetric(*args)
        try: self.this.append(this)
        except: self.this = this
    def eval_indexed(self, *args):
        """eval_indexed(minkmetric self, basic i) -> ex"""
        return _swiginac.minkmetric_eval_indexed(self, *args)

    __swig_destroy__ = _swiginac.delete_minkmetric
    __del__ = lambda self : None;
minkmetric_swigregister = _swiginac.minkmetric_swigregister
minkmetric_swigregister(minkmetric)

class spinmetric(tensmetric):
    """Proxy of C++ GiNaC::spinmetric class"""
    __swig_setmethods__ = {}
    for _s in [tensmetric]: __swig_setmethods__.update(getattr(_s,'__swig_setmethods__',{}))
    __setattr__ = lambda self, name, value: _swig_setattr(self, spinmetric, name, value)
    __swig_getmethods__ = {}
    for _s in [tensmetric]: __swig_getmethods__.update(getattr(_s,'__swig_getmethods__',{}))
    __getattr__ = lambda self, name: _swig_getattr(self, spinmetric, name)
    __repr__ = _swig_repr
    def __init__(self): 
        """__init__(GiNaC::spinmetric self) -> spinmetric"""
        this = _swiginac.new_spinmetric()
        try: self.this.append(this)
        except: self.this = this
    def eval_indexed(self, *args):
        """eval_indexed(spinmetric self, basic i) -> ex"""
        return _swiginac.spinmetric_eval_indexed(self, *args)

    def contract_with(self, *args):
        """contract_with(spinmetric self, exvector::iterator self, exvector::iterator other, exvector & v) -> bool"""
        return _swiginac.spinmetric_contract_with(self, *args)

    __swig_destroy__ = _swiginac.delete_spinmetric
    __del__ = lambda self : None;
spinmetric_swigregister = _swiginac.spinmetric_swigregister
spinmetric_swigregister(spinmetric)

class tensepsilon(tensor):
    """Proxy of C++ GiNaC::tensepsilon class"""
    __swig_setmethods__ = {}
    for _s in [tensor]: __swig_setmethods__.update(getattr(_s,'__swig_setmethods__',{}))
    __setattr__ = lambda self, name, value: _swig_setattr(self, tensepsilon, name, value)
    __swig_getmethods__ = {}
    for _s in [tensor]: __swig_getmethods__.update(getattr(_s,'__swig_getmethods__',{}))
    __getattr__ = lambda self, name: _swig_getattr(self, tensepsilon, name)
    __repr__ = _swig_repr
    def __init__(self, *args): 
        """
        __init__(GiNaC::tensepsilon self) -> tensepsilon
        __init__(GiNaC::tensepsilon self, bool minkowski, bool pos_sig) -> tensepsilon
        """
        this = _swiginac.new_tensepsilon(*args)
        try: self.this.append(this)
        except: self.this = this
    def eval_indexed(self, *args):
        """eval_indexed(tensepsilon self, basic i) -> ex"""
        return _swiginac.tensepsilon_eval_indexed(self, *args)

    def contract_with(self, *args):
        """contract_with(tensepsilon self, exvector::iterator self, exvector::iterator other, exvector & v) -> bool"""
        return _swiginac.tensepsilon_contract_with(self, *args)

    __swig_destroy__ = _swiginac.delete_tensepsilon
    __del__ = lambda self : None;
tensepsilon_swigregister = _swiginac.tensepsilon_swigregister
tensepsilon_swigregister(tensepsilon)


def delta_tensor(*args):
  """delta_tensor(ex i1, ex i2) -> ex"""
  return _swiginac.delta_tensor(*args)

def metric_tensor(*args):
  """metric_tensor(ex i1, ex i2) -> ex"""
  return _swiginac.metric_tensor(*args)

def lorentz_g(*args):
  """
    lorentz_g(ex i1, ex i2, bool pos_sig=False) -> ex
    lorentz_g(ex i1, ex i2) -> ex
    """
  return _swiginac.lorentz_g(*args)

def spinor_metric(*args):
  """spinor_metric(ex i1, ex i2) -> ex"""
  return _swiginac.spinor_metric(*args)

def epsilon_tensor(*args):
  """
    epsilon_tensor(ex i1, ex i2) -> ex
    epsilon_tensor(ex i1, ex i2, ex i3) -> ex
    """
  return _swiginac.epsilon_tensor(*args)

def lorentz_eps(*args):
  """
    lorentz_eps(ex i1, ex i2, ex i3, ex i4, bool pos_sig=False) -> ex
    lorentz_eps(ex i1, ex i2, ex i3, ex i4) -> ex
    """
  return _swiginac.lorentz_eps(*args)
class indexed(basic):
    """Proxy of C++ GiNaC::indexed class"""
    __swig_setmethods__ = {}
    for _s in [basic]: __swig_setmethods__.update(getattr(_s,'__swig_setmethods__',{}))
    __setattr__ = lambda self, name, value: _swig_setattr(self, indexed, name, value)
    __swig_getmethods__ = {}
    for _s in [basic]: __swig_getmethods__.update(getattr(_s,'__swig_getmethods__',{}))
    __getattr__ = lambda self, name: _swig_getattr(self, indexed, name)
    __repr__ = _swig_repr
    def __init__(self, *args): 
        """
        __init__(GiNaC::indexed self, ex b) -> indexed
        __init__(GiNaC::indexed self, ex b, ex i1) -> indexed
        __init__(GiNaC::indexed self, ex b, ex i1, ex i2) -> indexed
        __init__(GiNaC::indexed self, ex b, ex i1, ex i2, ex i3) -> indexed
        __init__(GiNaC::indexed self, ex b, ex i1, ex i2, ex i3, ex i4) -> indexed
        __init__(GiNaC::indexed self, ex b, symmetry symm, ex i1, ex i2) -> indexed
        __init__(GiNaC::indexed self, ex b, symmetry symm, ex i1, ex i2, ex i3) -> indexed
        __init__(GiNaC::indexed self, ex b, symmetry symm, ex i1, ex i2, ex i3, ex i4) -> indexed
        __init__(GiNaC::indexed self, ex b, exvector const & iv) -> indexed
        __init__(GiNaC::indexed self, ex b, symmetry symm, exvector const & iv) -> indexed
        __init__(GiNaC::indexed self, symmetry symm, exprseq const & es) -> indexed
        __init__(GiNaC::indexed self, symmetry symm, exvector const & v, bool discardable=False) -> indexed
        __init__(GiNaC::indexed self, symmetry symm, exvector const & v) -> indexed
        """
        this = _swiginac.new_indexed(*args)
        try: self.this.append(this)
        except: self.this = this
    def get_free_indices(self):
        """get_free_indices(indexed self) -> exvector"""
        return _swiginac.indexed_get_free_indices(self)

    def all_index_values_are(self, *args):
        """all_index_values_are(indexed self, unsigned int inf) -> bool"""
        return _swiginac.indexed_all_index_values_are(self, *args)

    def get_indices(self):
        """get_indices(indexed self) -> exvector"""
        return _swiginac.indexed_get_indices(self)

    def get_dummy_indices(self, *args):
        """
        get_dummy_indices(indexed self) -> exvector
        get_dummy_indices(indexed self, indexed other) -> exvector
        """
        return _swiginac.indexed_get_dummy_indices(self, *args)

    def has_dummy_index_for(self, *args):
        """has_dummy_index_for(indexed self, ex i) -> bool"""
        return _swiginac.indexed_has_dummy_index_for(self, *args)

    def get_symmetry(self):
        """get_symmetry(indexed self) -> ex"""
        return _swiginac.indexed_get_symmetry(self)

    __swig_destroy__ = _swiginac.delete_indexed
    __del__ = lambda self : None;
indexed_swigregister = _swiginac.indexed_swigregister
indexed_swigregister(indexed)

class spmapkey(_object):
    """Proxy of C++ GiNaC::spmapkey class"""
    __swig_setmethods__ = {}
    __setattr__ = lambda self, name, value: _swig_setattr(self, spmapkey, name, value)
    __swig_getmethods__ = {}
    __getattr__ = lambda self, name: _swig_getattr(self, spmapkey, name)
    __repr__ = _swig_repr
    def __init__(self, *args): 
        """
        __init__(GiNaC::spmapkey self) -> spmapkey
        __init__(GiNaC::spmapkey self, ex v1, ex v2, ex dim=wild()) -> spmapkey
        __init__(GiNaC::spmapkey self, ex v1, ex v2) -> spmapkey
        """
        this = _swiginac.new_spmapkey(*args)
        try: self.this.append(this)
        except: self.this = this
    def __eq__(self, *args):
        """__eq__(spmapkey self, spmapkey other) -> bool"""
        return _swiginac.spmapkey___eq__(self, *args)

    def __lt__(self, *args):
        """__lt__(spmapkey self, spmapkey other) -> bool"""
        return _swiginac.spmapkey___lt__(self, *args)

    def debugprint(self):
        """debugprint(spmapkey self)"""
        return _swiginac.spmapkey_debugprint(self)

    __swig_destroy__ = _swiginac.delete_spmapkey
    __del__ = lambda self : None;
spmapkey_swigregister = _swiginac.spmapkey_swigregister
spmapkey_swigregister(spmapkey)

class scalar_products(_object):
    """Proxy of C++ GiNaC::scalar_products class"""
    __swig_setmethods__ = {}
    __setattr__ = lambda self, name, value: _swig_setattr(self, scalar_products, name, value)
    __swig_getmethods__ = {}
    __getattr__ = lambda self, name: _swig_getattr(self, scalar_products, name)
    __repr__ = _swig_repr
    def add(self, *args):
        """
        add(scalar_products self, ex v1, ex v2, ex sp)
        add(scalar_products self, ex v1, ex v2, ex dim, ex sp)
        """
        return _swiginac.scalar_products_add(self, *args)

    def add_vectors(self, *args):
        """
        add_vectors(scalar_products self, lst l, ex dim=wild())
        add_vectors(scalar_products self, lst l)
        """
        return _swiginac.scalar_products_add_vectors(self, *args)

    def clear(self):
        """clear(scalar_products self)"""
        return _swiginac.scalar_products_clear(self)

    def is_defined(self, *args):
        """is_defined(scalar_products self, ex v1, ex v2, ex dim) -> bool"""
        return _swiginac.scalar_products_is_defined(self, *args)

    def evaluate(self, *args):
        """evaluate(scalar_products self, ex v1, ex v2, ex dim) -> ex"""
        return _swiginac.scalar_products_evaluate(self, *args)

    def debugprint(self):
        """debugprint(scalar_products self)"""
        return _swiginac.scalar_products_debugprint(self)

    def __init__(self): 
        """__init__(GiNaC::scalar_products self) -> scalar_products"""
        this = _swiginac.new_scalar_products()
        try: self.this.append(this)
        except: self.this = this
    __swig_destroy__ = _swiginac.delete_scalar_products
    __del__ = lambda self : None;
scalar_products_swigregister = _swiginac.scalar_products_swigregister
scalar_products_swigregister(scalar_products)


def get_all_dummy_indices(*args):
  """get_all_dummy_indices(ex e) -> exvector"""
  return _swiginac.get_all_dummy_indices(*args)

def rename_dummy_indices_uniquely(*args):
  """rename_dummy_indices_uniquely(ex a, ex b) -> ex"""
  return _swiginac.rename_dummy_indices_uniquely(*args)

def expand_dummy_sum(*args):
  """
    expand_dummy_sum(ex e, bool subs_idx=False) -> ex
    expand_dummy_sum(ex e) -> ex
    """
  return _swiginac.expand_dummy_sum(*args)
class idx(basic):
    """Proxy of C++ GiNaC::idx class"""
    __swig_setmethods__ = {}
    for _s in [basic]: __swig_setmethods__.update(getattr(_s,'__swig_setmethods__',{}))
    __setattr__ = lambda self, name, value: _swig_setattr(self, idx, name, value)
    __swig_getmethods__ = {}
    for _s in [basic]: __swig_getmethods__.update(getattr(_s,'__swig_getmethods__',{}))
    __getattr__ = lambda self, name: _swig_getattr(self, idx, name)
    __repr__ = _swig_repr
    def __init__(self, *args): 
        """__init__(GiNaC::idx self, ex v, ex dim) -> idx"""
        this = _swiginac.new_idx(*args)
        try: self.this.append(this)
        except: self.this = this
    def is_dummy_pair_same_type(self, *args):
        """is_dummy_pair_same_type(idx self, basic other) -> bool"""
        return _swiginac.idx_is_dummy_pair_same_type(self, *args)

    def get_value(self):
        """get_value(idx self) -> ex"""
        return _swiginac.idx_get_value(self)

    def is_numeric(self):
        """is_numeric(idx self) -> bool"""
        return _swiginac.idx_is_numeric(self)

    def is_symbolic(self):
        """is_symbolic(idx self) -> bool"""
        return _swiginac.idx_is_symbolic(self)

    def get_dim(self):
        """get_dim(idx self) -> ex"""
        return _swiginac.idx_get_dim(self)

    def is_dim_numeric(self):
        """is_dim_numeric(idx self) -> bool"""
        return _swiginac.idx_is_dim_numeric(self)

    def is_dim_symbolic(self):
        """is_dim_symbolic(idx self) -> bool"""
        return _swiginac.idx_is_dim_symbolic(self)

    def replace_dim(self, *args):
        """replace_dim(idx self, ex new_dim) -> ex"""
        return _swiginac.idx_replace_dim(self, *args)

    def minimal_dim(self, *args):
        """minimal_dim(idx self, idx other) -> ex"""
        return _swiginac.idx_minimal_dim(self, *args)

    def __repr__(self):
        return self.__str__()

    __swig_destroy__ = _swiginac.delete_idx
    __del__ = lambda self : None;
idx_swigregister = _swiginac.idx_swigregister
idx_swigregister(idx)

class varidx(idx):
    """Proxy of C++ GiNaC::varidx class"""
    __swig_setmethods__ = {}
    for _s in [idx]: __swig_setmethods__.update(getattr(_s,'__swig_setmethods__',{}))
    __setattr__ = lambda self, name, value: _swig_setattr(self, varidx, name, value)
    __swig_getmethods__ = {}
    for _s in [idx]: __swig_getmethods__.update(getattr(_s,'__swig_getmethods__',{}))
    __getattr__ = lambda self, name: _swig_getattr(self, varidx, name)
    __repr__ = _swig_repr
    def __init__(self, *args): 
        """
        __init__(GiNaC::varidx self, ex v, ex dim, bool covariant=False) -> varidx
        __init__(GiNaC::varidx self, ex v, ex dim) -> varidx
        """
        this = _swiginac.new_varidx(*args)
        try: self.this.append(this)
        except: self.this = this
    def is_dummy_pair_same_type(self, *args):
        """is_dummy_pair_same_type(varidx self, basic other) -> bool"""
        return _swiginac.varidx_is_dummy_pair_same_type(self, *args)

    def is_covariant(self):
        """is_covariant(varidx self) -> bool"""
        return _swiginac.varidx_is_covariant(self)

    def is_contravariant(self):
        """is_contravariant(varidx self) -> bool"""
        return _swiginac.varidx_is_contravariant(self)

    def toggle_variance(self):
        """toggle_variance(varidx self) -> ex"""
        return _swiginac.varidx_toggle_variance(self)

    def __repr__(self):
        return self.__str__()

    __swig_destroy__ = _swiginac.delete_varidx
    __del__ = lambda self : None;
varidx_swigregister = _swiginac.varidx_swigregister
varidx_swigregister(varidx)

class spinidx(varidx):
    """Proxy of C++ GiNaC::spinidx class"""
    __swig_setmethods__ = {}
    for _s in [varidx]: __swig_setmethods__.update(getattr(_s,'__swig_setmethods__',{}))
    __setattr__ = lambda self, name, value: _swig_setattr(self, spinidx, name, value)
    __swig_getmethods__ = {}
    for _s in [varidx]: __swig_getmethods__.update(getattr(_s,'__swig_getmethods__',{}))
    __getattr__ = lambda self, name: _swig_getattr(self, spinidx, name)
    __repr__ = _swig_repr
    def __init__(self, *args): 
        """
        __init__(GiNaC::spinidx self, ex v, ex dim=2, bool covariant=False, bool dotted=False) -> spinidx
        __init__(GiNaC::spinidx self, ex v, ex dim=2, bool covariant=False) -> spinidx
        __init__(GiNaC::spinidx self, ex v, ex dim=2) -> spinidx
        __init__(GiNaC::spinidx self, ex v) -> spinidx
        """
        this = _swiginac.new_spinidx(*args)
        try: self.this.append(this)
        except: self.this = this
    def is_dummy_pair_same_type(self, *args):
        """is_dummy_pair_same_type(spinidx self, basic other) -> bool"""
        return _swiginac.spinidx_is_dummy_pair_same_type(self, *args)

    def is_dotted(self):
        """is_dotted(spinidx self) -> bool"""
        return _swiginac.spinidx_is_dotted(self)

    def is_undotted(self):
        """is_undotted(spinidx self) -> bool"""
        return _swiginac.spinidx_is_undotted(self)

    def toggle_dot(self):
        """toggle_dot(spinidx self) -> ex"""
        return _swiginac.spinidx_toggle_dot(self)

    def toggle_variance_dot(self):
        """toggle_variance_dot(spinidx self) -> ex"""
        return _swiginac.spinidx_toggle_variance_dot(self)

    __swig_destroy__ = _swiginac.delete_spinidx
    __del__ = lambda self : None;
spinidx_swigregister = _swiginac.spinidx_swigregister
spinidx_swigregister(spinidx)


def is_dummy_pair(*args):
  """
    is_dummy_pair(idx i1, idx i2) -> bool
    is_dummy_pair(ex e1, ex e2) -> bool
    """
  return _swiginac.is_dummy_pair(*args)

def find_free_and_dummy(*args):
  """
    find_free_and_dummy(exvector::const_iterator it, exvector::const_iterator itend, exvector & out_free, 
        exvector & out_dummy)
    find_free_and_dummy(exvector const & v, exvector & out_free, exvector & out_dummy)
    """
  return _swiginac.find_free_and_dummy(*args)

def find_dummy_indices(*args):
  """find_dummy_indices(exvector const & v, exvector & out_dummy)"""
  return _swiginac.find_dummy_indices(*args)

def count_dummy_indices(*args):
  """count_dummy_indices(exvector const & v) -> size_t"""
  return _swiginac.count_dummy_indices(*args)

def count_free_indices(*args):
  """count_free_indices(exvector const & v) -> size_t"""
  return _swiginac.count_free_indices(*args)

def minimal_dim(*args):
  """minimal_dim(ex dim1, ex dim2) -> ex"""
  return _swiginac.minimal_dim(*args)
class symmetry(basic):
    """Proxy of C++ GiNaC::symmetry class"""
    __swig_setmethods__ = {}
    for _s in [basic]: __swig_setmethods__.update(getattr(_s,'__swig_setmethods__',{}))
    __setattr__ = lambda self, name, value: _swig_setattr(self, symmetry, name, value)
    __swig_getmethods__ = {}
    for _s in [basic]: __swig_getmethods__.update(getattr(_s,'__swig_getmethods__',{}))
    __getattr__ = lambda self, name: _swig_getattr(self, symmetry, name)
    __repr__ = _swig_repr
    none = _swiginac.symmetry_none
    symmetric = _swiginac.symmetry_symmetric
    antisymmetric = _swiginac.symmetry_antisymmetric
    cyclic = _swiginac.symmetry_cyclic
    def __init__(self, *args): 
        """
        __init__(GiNaC::symmetry self, unsigned int i) -> symmetry
        __init__(GiNaC::symmetry self, GiNaC::symmetry::symmetry_type t, symmetry c1, symmetry c2) -> symmetry
        """
        this = _swiginac.new_symmetry(*args)
        try: self.this.append(this)
        except: self.this = this
    def get_type(self):
        """get_type(symmetry self) -> GiNaC::symmetry::symmetry_type"""
        return _swiginac.symmetry_get_type(self)

    def set_type(self, *args):
        """set_type(symmetry self, GiNaC::symmetry::symmetry_type t)"""
        return _swiginac.symmetry_set_type(self, *args)

    def add(self, *args):
        """
        add(symmetry self, symmetry c) -> symmetry
        add(symmetry self, unsigned int const & c) -> symmetry
        """
        return _swiginac.symmetry_add(self, *args)

    def validate(self, *args):
        """validate(symmetry self, unsigned int n)"""
        return _swiginac.symmetry_validate(self, *args)

    def has_symmetry(self):
        """has_symmetry(symmetry self) -> bool"""
        return _swiginac.symmetry_has_symmetry(self)

    __swig_destroy__ = _swiginac.delete_symmetry
    __del__ = lambda self : None;
symmetry_swigregister = _swiginac.symmetry_swigregister
symmetry_swigregister(symmetry)


def sy_none(*args):
  """
    sy_none() -> symmetry
    sy_none(symmetry c1, symmetry c2) -> symmetry
    sy_none(symmetry c1, symmetry c2, symmetry c3) -> symmetry
    sy_none(symmetry c1, symmetry c2, symmetry c3, symmetry c4) -> symmetry
    """
  return _swiginac.sy_none(*args)

def sy_symm(*args):
  """
    sy_symm() -> symmetry
    sy_symm(symmetry c1, symmetry c2) -> symmetry
    sy_symm(symmetry c1, symmetry c2, symmetry c3) -> symmetry
    sy_symm(symmetry c1, symmetry c2, symmetry c3, symmetry c4) -> symmetry
    """
  return _swiginac.sy_symm(*args)

def sy_anti(*args):
  """
    sy_anti() -> symmetry
    sy_anti(symmetry c1, symmetry c2) -> symmetry
    sy_anti(symmetry c1, symmetry c2, symmetry c3) -> symmetry
    sy_anti(symmetry c1, symmetry c2, symmetry c3, symmetry c4) -> symmetry
    """
  return _swiginac.sy_anti(*args)

def sy_cycl(*args):
  """
    sy_cycl() -> symmetry
    sy_cycl(symmetry c1, symmetry c2) -> symmetry
    sy_cycl(symmetry c1, symmetry c2, symmetry c3) -> symmetry
    sy_cycl(symmetry c1, symmetry c2, symmetry c3, symmetry c4) -> symmetry
    """
  return _swiginac.sy_cycl(*args)

def not_symmetric():
  """not_symmetric() -> symmetry"""
  return _swiginac.not_symmetric()

def symmetric2():
  """symmetric2() -> symmetry"""
  return _swiginac.symmetric2()

def symmetric3():
  """symmetric3() -> symmetry"""
  return _swiginac.symmetric3()

def symmetric4():
  """symmetric4() -> symmetry"""
  return _swiginac.symmetric4()

def antisymmetric2():
  """antisymmetric2() -> symmetry"""
  return _swiginac.antisymmetric2()

def antisymmetric3():
  """antisymmetric3() -> symmetry"""
  return _swiginac.antisymmetric3()

def antisymmetric4():
  """antisymmetric4() -> symmetry"""
  return _swiginac.antisymmetric4()

def canonicalize(*args):
  """canonicalize(exvector::iterator v, symmetry symm) -> int"""
  return _swiginac.canonicalize(*args)

def symmetrize(*args):
  """
    symmetrize(ex thisex) -> ex
    symmetrize(ex thisex, lst l) -> ex
    symmetrize(ex e, exvector::const_iterator first, exvector::const_iterator last) -> ex
    symmetrize(ex e, exvector const & v) -> ex
    """
  return _swiginac.symmetrize(*args)

def antisymmetrize(*args):
  """
    antisymmetrize(ex thisex) -> ex
    antisymmetrize(ex thisex, lst l) -> ex
    antisymmetrize(ex e, exvector::const_iterator first, exvector::const_iterator last) -> ex
    antisymmetrize(ex e, exvector const & v) -> ex
    """
  return _swiginac.antisymmetrize(*args)

def symmetrize_cyclic(*args):
  """
    symmetrize_cyclic(ex thisex) -> ex
    symmetrize_cyclic(ex thisex, lst l) -> ex
    symmetrize_cyclic(ex e, exvector::const_iterator first, exvector::const_iterator last) -> ex
    symmetrize_cyclic(ex e, exvector const & v) -> ex
    """
  return _swiginac.symmetrize_cyclic(*args)
class clifford(indexed):
    """Proxy of C++ GiNaC::clifford class"""
    __swig_setmethods__ = {}
    for _s in [indexed]: __swig_setmethods__.update(getattr(_s,'__swig_setmethods__',{}))
    __setattr__ = lambda self, name, value: _swig_setattr(self, clifford, name, value)
    __swig_getmethods__ = {}
    for _s in [indexed]: __swig_getmethods__.update(getattr(_s,'__swig_getmethods__',{}))
    __getattr__ = lambda self, name: _swig_getattr(self, clifford, name)
    __repr__ = _swig_repr
    def __init__(self, *args): 
        """
        __init__(GiNaC::clifford self, ex b, unsigned char rl=0) -> clifford
        __init__(GiNaC::clifford self, ex b) -> clifford
        __init__(GiNaC::clifford self, ex b, ex mu, ex metr, unsigned char rl=0, int comm_sign=-1) -> clifford
        __init__(GiNaC::clifford self, ex b, ex mu, ex metr, unsigned char rl=0) -> clifford
        __init__(GiNaC::clifford self, ex b, ex mu, ex metr) -> clifford
        __init__(GiNaC::clifford self, unsigned char rl, ex metr, int comm_sign, exvector const & v, bool discardable=False) -> clifford
        __init__(GiNaC::clifford self, unsigned char rl, ex metr, int comm_sign, exvector const & v) -> clifford
        __init__(GiNaC::clifford self, unsigned char rl, ex metr, int comm_sign, std::auto_ptr< exvector > vp) -> clifford
        """
        this = _swiginac.new_clifford(*args)
        try: self.this.append(this)
        except: self.this = this
    def precedence(self):
        """precedence(clifford self) -> unsigned int"""
        return _swiginac.clifford_precedence(self)

    def archive(self, *args):
        """archive(clifford self, archive_node n)"""
        return _swiginac.clifford_archive(self, *args)

    def read_archive(self, *args):
        """read_archive(clifford self, archive_node n, lst sym_lst)"""
        return _swiginac.clifford_read_archive(self, *args)

    def get_representation_label(self):
        """get_representation_label(clifford self) -> unsigned char"""
        return _swiginac.clifford_get_representation_label(self)

    def get_metric(self, *args):
        """
        get_metric(clifford self) -> ex
        get_metric(clifford self, ex i, ex j, bool symmetrised=False) -> ex
        get_metric(clifford self, ex i, ex j) -> ex
        """
        return _swiginac.clifford_get_metric(self, *args)

    def same_metric(self, *args):
        """same_metric(clifford self, ex other) -> bool"""
        return _swiginac.clifford_same_metric(self, *args)

    def get_commutator_sign(self):
        """get_commutator_sign(clifford self) -> int"""
        return _swiginac.clifford_get_commutator_sign(self)

    def nops(self):
        """nops(clifford self) -> size_t"""
        return _swiginac.clifford_nops(self)

    def op(self, *args):
        """op(clifford self, size_t i) -> ex"""
        return _swiginac.clifford_op(self, *args)

    def let_op(self, *args):
        """let_op(clifford self, size_t i) -> ex"""
        return _swiginac.clifford_let_op(self, *args)

    def subs(self, *args):
        """
        subs(clifford self, exmap m, unsigned int options=0) -> ex
        subs(clifford self, exmap m) -> ex
        subs(clifford self, lst ls, lst lr) -> ex
        subs(clifford self, ex e, unsigned int options=0) -> ex
        subs(clifford self, ex e) -> ex
        """
        return _swiginac.clifford_subs(self, *args)

    def __repr__(self):
        return self.__str__()

    __swig_destroy__ = _swiginac.delete_clifford
    __del__ = lambda self : None;
clifford_swigregister = _swiginac.clifford_swigregister
clifford_swigregister(clifford)

class diracone(tensor):
    """Proxy of C++ GiNaC::diracone class"""
    __swig_setmethods__ = {}
    for _s in [tensor]: __swig_setmethods__.update(getattr(_s,'__swig_setmethods__',{}))
    __setattr__ = lambda self, name, value: _swig_setattr(self, diracone, name, value)
    __swig_getmethods__ = {}
    for _s in [tensor]: __swig_getmethods__.update(getattr(_s,'__swig_getmethods__',{}))
    __getattr__ = lambda self, name: _swig_getattr(self, diracone, name)
    __repr__ = _swig_repr
    def __init__(self): 
        """__init__(GiNaC::diracone self) -> diracone"""
        this = _swiginac.new_diracone()
        try: self.this.append(this)
        except: self.this = this
    __swig_destroy__ = _swiginac.delete_diracone
    __del__ = lambda self : None;
diracone_swigregister = _swiginac.diracone_swigregister
diracone_swigregister(diracone)

class cliffordunit(tensor):
    """Proxy of C++ GiNaC::cliffordunit class"""
    __swig_setmethods__ = {}
    for _s in [tensor]: __swig_setmethods__.update(getattr(_s,'__swig_setmethods__',{}))
    __setattr__ = lambda self, name, value: _swig_setattr(self, cliffordunit, name, value)
    __swig_getmethods__ = {}
    for _s in [tensor]: __swig_getmethods__.update(getattr(_s,'__swig_getmethods__',{}))
    __getattr__ = lambda self, name: _swig_getattr(self, cliffordunit, name)
    __repr__ = _swig_repr
    def contract_with(self, *args):
        """contract_with(cliffordunit self, exvector::iterator self, exvector::iterator other, exvector & v) -> bool"""
        return _swiginac.cliffordunit_contract_with(self, *args)

    def __init__(self): 
        """__init__(GiNaC::cliffordunit self) -> cliffordunit"""
        this = _swiginac.new_cliffordunit()
        try: self.this.append(this)
        except: self.this = this
    __swig_destroy__ = _swiginac.delete_cliffordunit
    __del__ = lambda self : None;
cliffordunit_swigregister = _swiginac.cliffordunit_swigregister
cliffordunit_swigregister(cliffordunit)

class diracgamma(cliffordunit):
    """Proxy of C++ GiNaC::diracgamma class"""
    __swig_setmethods__ = {}
    for _s in [cliffordunit]: __swig_setmethods__.update(getattr(_s,'__swig_setmethods__',{}))
    __setattr__ = lambda self, name, value: _swig_setattr(self, diracgamma, name, value)
    __swig_getmethods__ = {}
    for _s in [cliffordunit]: __swig_getmethods__.update(getattr(_s,'__swig_getmethods__',{}))
    __getattr__ = lambda self, name: _swig_getattr(self, diracgamma, name)
    __repr__ = _swig_repr
    def contract_with(self, *args):
        """contract_with(diracgamma self, exvector::iterator self, exvector::iterator other, exvector & v) -> bool"""
        return _swiginac.diracgamma_contract_with(self, *args)

    def __init__(self): 
        """__init__(GiNaC::diracgamma self) -> diracgamma"""
        this = _swiginac.new_diracgamma()
        try: self.this.append(this)
        except: self.this = this
    __swig_destroy__ = _swiginac.delete_diracgamma
    __del__ = lambda self : None;
diracgamma_swigregister = _swiginac.diracgamma_swigregister
diracgamma_swigregister(diracgamma)

class diracgamma5(tensor):
    """Proxy of C++ GiNaC::diracgamma5 class"""
    __swig_setmethods__ = {}
    for _s in [tensor]: __swig_setmethods__.update(getattr(_s,'__swig_setmethods__',{}))
    __setattr__ = lambda self, name, value: _swig_setattr(self, diracgamma5, name, value)
    __swig_getmethods__ = {}
    for _s in [tensor]: __swig_getmethods__.update(getattr(_s,'__swig_getmethods__',{}))
    __getattr__ = lambda self, name: _swig_getattr(self, diracgamma5, name)
    __repr__ = _swig_repr
    def __init__(self): 
        """__init__(GiNaC::diracgamma5 self) -> diracgamma5"""
        this = _swiginac.new_diracgamma5()
        try: self.this.append(this)
        except: self.this = this
    __swig_destroy__ = _swiginac.delete_diracgamma5
    __del__ = lambda self : None;
diracgamma5_swigregister = _swiginac.diracgamma5_swigregister
diracgamma5_swigregister(diracgamma5)

class diracgammaL(tensor):
    """Proxy of C++ GiNaC::diracgammaL class"""
    __swig_setmethods__ = {}
    for _s in [tensor]: __swig_setmethods__.update(getattr(_s,'__swig_setmethods__',{}))
    __setattr__ = lambda self, name, value: _swig_setattr(self, diracgammaL, name, value)
    __swig_getmethods__ = {}
    for _s in [tensor]: __swig_getmethods__.update(getattr(_s,'__swig_getmethods__',{}))
    __getattr__ = lambda self, name: _swig_getattr(self, diracgammaL, name)
    __repr__ = _swig_repr
    def __init__(self): 
        """__init__(GiNaC::diracgammaL self) -> diracgammaL"""
        this = _swiginac.new_diracgammaL()
        try: self.this.append(this)
        except: self.this = this
    __swig_destroy__ = _swiginac.delete_diracgammaL
    __del__ = lambda self : None;
diracgammaL_swigregister = _swiginac.diracgammaL_swigregister
diracgammaL_swigregister(diracgammaL)

class diracgammaR(tensor):
    """Proxy of C++ GiNaC::diracgammaR class"""
    __swig_setmethods__ = {}
    for _s in [tensor]: __swig_setmethods__.update(getattr(_s,'__swig_setmethods__',{}))
    __setattr__ = lambda self, name, value: _swig_setattr(self, diracgammaR, name, value)
    __swig_getmethods__ = {}
    for _s in [tensor]: __swig_getmethods__.update(getattr(_s,'__swig_getmethods__',{}))
    __getattr__ = lambda self, name: _swig_getattr(self, diracgammaR, name)
    __repr__ = _swig_repr
    def __init__(self): 
        """__init__(GiNaC::diracgammaR self) -> diracgammaR"""
        this = _swiginac.new_diracgammaR()
        try: self.this.append(this)
        except: self.this = this
    __swig_destroy__ = _swiginac.delete_diracgammaR
    __del__ = lambda self : None;
diracgammaR_swigregister = _swiginac.diracgammaR_swigregister
diracgammaR_swigregister(diracgammaR)


def dirac_ONE(rl=0):
  """
    dirac_ONE(unsigned char rl=0) -> ex
    dirac_ONE() -> ex
    """
  return _swiginac.dirac_ONE(rl)

def clifford_unit(*args):
  """
    clifford_unit(ex mu, ex metr, unsigned char rl=0) -> ex
    clifford_unit(ex mu, ex metr) -> ex
    """
  return _swiginac.clifford_unit(*args)

def dirac_gamma(*args):
  """
    dirac_gamma(ex mu, unsigned char rl=0) -> ex
    dirac_gamma(ex mu) -> ex
    """
  return _swiginac.dirac_gamma(*args)

def dirac_gamma5(rl=0):
  """
    dirac_gamma5(unsigned char rl=0) -> ex
    dirac_gamma5() -> ex
    """
  return _swiginac.dirac_gamma5(rl)

def dirac_gammaL(rl=0):
  """
    dirac_gammaL(unsigned char rl=0) -> ex
    dirac_gammaL() -> ex
    """
  return _swiginac.dirac_gammaL(rl)

def dirac_gammaR(rl=0):
  """
    dirac_gammaR(unsigned char rl=0) -> ex
    dirac_gammaR() -> ex
    """
  return _swiginac.dirac_gammaR(rl)

def dirac_slash(*args):
  """
    dirac_slash(ex e, ex dim, unsigned char rl=0) -> ex
    dirac_slash(ex e, ex dim) -> ex
    """
  return _swiginac.dirac_slash(*args)

def dirac_trace(*args):
  """
    dirac_trace(ex e, std::set< unsigned char > const & rls, ex trONE=4) -> ex
    dirac_trace(ex e, std::set< unsigned char > const & rls) -> ex
    dirac_trace(ex e, lst rll, ex trONE=4) -> ex
    dirac_trace(ex e, lst rll) -> ex
    dirac_trace(ex e, unsigned char rl=0, ex trONE=4) -> ex
    dirac_trace(ex e, unsigned char rl=0) -> ex
    dirac_trace(ex e) -> ex
    """
  return _swiginac.dirac_trace(*args)

def canonicalize_clifford(*args):
  """canonicalize_clifford(ex e) -> ex"""
  return _swiginac.canonicalize_clifford(*args)

def clifford_prime(*args):
  """clifford_prime(ex e) -> ex"""
  return _swiginac.clifford_prime(*args)

def clifford_bar(*args):
  """clifford_bar(ex e) -> ex"""
  return _swiginac.clifford_bar(*args)

def clifford_star(*args):
  """clifford_star(ex e) -> ex"""
  return _swiginac.clifford_star(*args)

def remove_dirac_ONE(*args):
  """
    remove_dirac_ONE(ex e, unsigned char rl=0, unsigned int options=0) -> ex
    remove_dirac_ONE(ex e, unsigned char rl=0) -> ex
    remove_dirac_ONE(ex e) -> ex
    """
  return _swiginac.remove_dirac_ONE(*args)

def clifford_max_label(*args):
  """
    clifford_max_label(ex e, bool ignore_ONE=False) -> char
    clifford_max_label(ex e) -> char
    """
  return _swiginac.clifford_max_label(*args)

def clifford_norm(*args):
  """clifford_norm(ex e) -> ex"""
  return _swiginac.clifford_norm(*args)

def clifford_inverse(*args):
  """clifford_inverse(ex e) -> ex"""
  return _swiginac.clifford_inverse(*args)

def lst_to_clifford(*args):
  """
    lst_to_clifford(ex v, ex mu, ex metr, unsigned char rl=0) -> ex
    lst_to_clifford(ex v, ex mu, ex metr) -> ex
    lst_to_clifford(ex v, ex e) -> ex
    """
  return _swiginac.lst_to_clifford(*args)

def clifford_to_lst(*args):
  """
    clifford_to_lst(ex e, ex c, bool algebraic=True) -> lst
    clifford_to_lst(ex e, ex c) -> lst
    """
  return _swiginac.clifford_to_lst(*args)

def clifford_moebius_map(*args):
  """
    clifford_moebius_map(ex a, ex b, ex c, ex d, ex v, ex G, unsigned char rl=0) -> ex
    clifford_moebius_map(ex a, ex b, ex c, ex d, ex v, ex G) -> ex
    clifford_moebius_map(ex M, ex v, ex G, unsigned char rl=0) -> ex
    clifford_moebius_map(ex M, ex v, ex G) -> ex
    """
  return _swiginac.clifford_moebius_map(*args)
class color(indexed):
    """Proxy of C++ GiNaC::color class"""
    __swig_setmethods__ = {}
    for _s in [indexed]: __swig_setmethods__.update(getattr(_s,'__swig_setmethods__',{}))
    __setattr__ = lambda self, name, value: _swig_setattr(self, color, name, value)
    __swig_getmethods__ = {}
    for _s in [indexed]: __swig_getmethods__.update(getattr(_s,'__swig_getmethods__',{}))
    __getattr__ = lambda self, name: _swig_getattr(self, color, name)
    __repr__ = _swig_repr
    def __init__(self, *args): 
        """
        __init__(GiNaC::color self, ex b, unsigned char rl=0) -> color
        __init__(GiNaC::color self, ex b) -> color
        __init__(GiNaC::color self, ex b, ex i1, unsigned char rl=0) -> color
        __init__(GiNaC::color self, ex b, ex i1) -> color
        __init__(GiNaC::color self, unsigned char rl, exvector const & v, bool discardable=False) -> color
        __init__(GiNaC::color self, unsigned char rl, exvector const & v) -> color
        __init__(GiNaC::color self, unsigned char rl, std::auto_ptr< exvector > vp) -> color
        """
        this = _swiginac.new_color(*args)
        try: self.this.append(this)
        except: self.this = this
    def get_representation_label(self):
        """get_representation_label(color self) -> unsigned char"""
        return _swiginac.color_get_representation_label(self)

    __swig_destroy__ = _swiginac.delete_color
    __del__ = lambda self : None;
color_swigregister = _swiginac.color_swigregister
color_swigregister(color)

class su3one(tensor):
    """Proxy of C++ GiNaC::su3one class"""
    __swig_setmethods__ = {}
    for _s in [tensor]: __swig_setmethods__.update(getattr(_s,'__swig_setmethods__',{}))
    __setattr__ = lambda self, name, value: _swig_setattr(self, su3one, name, value)
    __swig_getmethods__ = {}
    for _s in [tensor]: __swig_getmethods__.update(getattr(_s,'__swig_getmethods__',{}))
    __getattr__ = lambda self, name: _swig_getattr(self, su3one, name)
    __repr__ = _swig_repr
    def __init__(self): 
        """__init__(GiNaC::su3one self) -> su3one"""
        this = _swiginac.new_su3one()
        try: self.this.append(this)
        except: self.this = this
    __swig_destroy__ = _swiginac.delete_su3one
    __del__ = lambda self : None;
su3one_swigregister = _swiginac.su3one_swigregister
su3one_swigregister(su3one)

class su3t(tensor):
    """Proxy of C++ GiNaC::su3t class"""
    __swig_setmethods__ = {}
    for _s in [tensor]: __swig_setmethods__.update(getattr(_s,'__swig_setmethods__',{}))
    __setattr__ = lambda self, name, value: _swig_setattr(self, su3t, name, value)
    __swig_getmethods__ = {}
    for _s in [tensor]: __swig_getmethods__.update(getattr(_s,'__swig_getmethods__',{}))
    __getattr__ = lambda self, name: _swig_getattr(self, su3t, name)
    __repr__ = _swig_repr
    def __init__(self): 
        """__init__(GiNaC::su3t self) -> su3t"""
        this = _swiginac.new_su3t()
        try: self.this.append(this)
        except: self.this = this
    __swig_destroy__ = _swiginac.delete_su3t
    __del__ = lambda self : None;
su3t_swigregister = _swiginac.su3t_swigregister
su3t_swigregister(su3t)

class su3f(tensor):
    """Proxy of C++ GiNaC::su3f class"""
    __swig_setmethods__ = {}
    for _s in [tensor]: __swig_setmethods__.update(getattr(_s,'__swig_setmethods__',{}))
    __setattr__ = lambda self, name, value: _swig_setattr(self, su3f, name, value)
    __swig_getmethods__ = {}
    for _s in [tensor]: __swig_getmethods__.update(getattr(_s,'__swig_getmethods__',{}))
    __getattr__ = lambda self, name: _swig_getattr(self, su3f, name)
    __repr__ = _swig_repr
    def __init__(self): 
        """__init__(GiNaC::su3f self) -> su3f"""
        this = _swiginac.new_su3f()
        try: self.this.append(this)
        except: self.this = this
    __swig_destroy__ = _swiginac.delete_su3f
    __del__ = lambda self : None;
su3f_swigregister = _swiginac.su3f_swigregister
su3f_swigregister(su3f)

class su3d(tensor):
    """Proxy of C++ GiNaC::su3d class"""
    __swig_setmethods__ = {}
    for _s in [tensor]: __swig_setmethods__.update(getattr(_s,'__swig_setmethods__',{}))
    __setattr__ = lambda self, name, value: _swig_setattr(self, su3d, name, value)
    __swig_getmethods__ = {}
    for _s in [tensor]: __swig_getmethods__.update(getattr(_s,'__swig_getmethods__',{}))
    __getattr__ = lambda self, name: _swig_getattr(self, su3d, name)
    __repr__ = _swig_repr
    def __init__(self): 
        """__init__(GiNaC::su3d self) -> su3d"""
        this = _swiginac.new_su3d()
        try: self.this.append(this)
        except: self.this = this
    __swig_destroy__ = _swiginac.delete_su3d
    __del__ = lambda self : None;
su3d_swigregister = _swiginac.su3d_swigregister
su3d_swigregister(su3d)


def color_ONE(rl=0):
  """
    color_ONE(unsigned char rl=0) -> ex
    color_ONE() -> ex
    """
  return _swiginac.color_ONE(rl)

def color_T(*args):
  """
    color_T(ex a, unsigned char rl=0) -> ex
    color_T(ex a) -> ex
    """
  return _swiginac.color_T(*args)

def color_f(*args):
  """color_f(ex a, ex b, ex c) -> ex"""
  return _swiginac.color_f(*args)

def color_d(*args):
  """color_d(ex a, ex b, ex c) -> ex"""
  return _swiginac.color_d(*args)

def color_h(*args):
  """color_h(ex a, ex b, ex c) -> ex"""
  return _swiginac.color_h(*args)

def color_trace(*args):
  """
    color_trace(ex e, std::set< unsigned char > const & rls) -> ex
    color_trace(ex e, lst rll) -> ex
    color_trace(ex e, unsigned char rl=0) -> ex
    color_trace(ex e) -> ex
    """
  return _swiginac.color_trace(*args)
class wildcard(basic):
    """Proxy of C++ GiNaC::wildcard class"""
    __swig_setmethods__ = {}
    for _s in [basic]: __swig_setmethods__.update(getattr(_s,'__swig_setmethods__',{}))
    __setattr__ = lambda self, name, value: _swig_setattr(self, wildcard, name, value)
    __swig_getmethods__ = {}
    for _s in [basic]: __swig_getmethods__.update(getattr(_s,'__swig_getmethods__',{}))
    __getattr__ = lambda self, name: _swig_getattr(self, wildcard, name)
    __repr__ = _swig_repr
    def __init__(self, *args): 
        """
        __init__(GiNaC::wildcard self) -> wildcard
        __init__(GiNaC::wildcard self, unsigned int label) -> wildcard
        """
        this = _swiginac.new_wildcard(*args)
        try: self.this.append(this)
        except: self.this = this
    def get_label(self):
        """get_label(wildcard self) -> unsigned int"""
        return _swiginac.wildcard_get_label(self)

    __swig_destroy__ = _swiginac.delete_wildcard
    __del__ = lambda self : None;
wildcard_swigregister = _swiginac.wildcard_swigregister
wildcard_swigregister(wildcard)


def wild(label=0):
  """
    wild(unsigned int label=0) -> ex
    wild() -> ex
    """
  return _swiginac.wild(label)

def haswild(*args):
  """haswild(ex x) -> bool"""
  return _swiginac.haswild(*args)
class expand_options(_object):
    """Proxy of C++ GiNaC::expand_options class"""
    __swig_setmethods__ = {}
    __setattr__ = lambda self, name, value: _swig_setattr(self, expand_options, name, value)
    __swig_getmethods__ = {}
    __getattr__ = lambda self, name: _swig_getattr(self, expand_options, name)
    __repr__ = _swig_repr
    expand_indexed = _swiginac.expand_options_expand_indexed
    expand_function_args = _swiginac.expand_options_expand_function_args
    def __init__(self): 
        """__init__(GiNaC::expand_options self) -> expand_options"""
        this = _swiginac.new_expand_options()
        try: self.this.append(this)
        except: self.this = this
    __swig_destroy__ = _swiginac.delete_expand_options
    __del__ = lambda self : None;
expand_options_swigregister = _swiginac.expand_options_swigregister
expand_options_swigregister(expand_options)

class subs_options(_object):
    """Proxy of C++ GiNaC::subs_options class"""
    __swig_setmethods__ = {}
    __setattr__ = lambda self, name, value: _swig_setattr(self, subs_options, name, value)
    __swig_getmethods__ = {}
    __getattr__ = lambda self, name: _swig_getattr(self, subs_options, name)
    __repr__ = _swig_repr
    no_pattern = _swiginac.subs_options_no_pattern
    subs_no_pattern = _swiginac.subs_options_subs_no_pattern
    algebraic = _swiginac.subs_options_algebraic
    subs_algebraic = _swiginac.subs_options_subs_algebraic
    pattern_is_product = _swiginac.subs_options_pattern_is_product
    pattern_is_not_product = _swiginac.subs_options_pattern_is_not_product
    def __init__(self): 
        """__init__(GiNaC::subs_options self) -> subs_options"""
        this = _swiginac.new_subs_options()
        try: self.this.append(this)
        except: self.this = this
    __swig_destroy__ = _swiginac.delete_subs_options
    __del__ = lambda self : None;
subs_options_swigregister = _swiginac.subs_options_swigregister
subs_options_swigregister(subs_options)

class determinant_algo(_object):
    """Proxy of C++ GiNaC::determinant_algo class"""
    __swig_setmethods__ = {}
    __setattr__ = lambda self, name, value: _swig_setattr(self, determinant_algo, name, value)
    __swig_getmethods__ = {}
    __getattr__ = lambda self, name: _swig_getattr(self, determinant_algo, name)
    __repr__ = _swig_repr
    automatic = _swiginac.determinant_algo_automatic
    gauss = _swiginac.determinant_algo_gauss
    divfree = _swiginac.determinant_algo_divfree
    laplace = _swiginac.determinant_algo_laplace
    bareiss = _swiginac.determinant_algo_bareiss
    def __init__(self): 
        """__init__(GiNaC::determinant_algo self) -> determinant_algo"""
        this = _swiginac.new_determinant_algo()
        try: self.this.append(this)
        except: self.this = this
    __swig_destroy__ = _swiginac.delete_determinant_algo
    __del__ = lambda self : None;
determinant_algo_swigregister = _swiginac.determinant_algo_swigregister
determinant_algo_swigregister(determinant_algo)

class info_flags(_object):
    """Proxy of C++ GiNaC::info_flags class"""
    __swig_setmethods__ = {}
    __setattr__ = lambda self, name, value: _swig_setattr(self, info_flags, name, value)
    __swig_getmethods__ = {}
    __getattr__ = lambda self, name: _swig_getattr(self, info_flags, name)
    __repr__ = _swig_repr
    numeric = _swiginac.info_flags_numeric
    real = _swiginac.info_flags_real
    rational = _swiginac.info_flags_rational
    integer = _swiginac.info_flags_integer
    crational = _swiginac.info_flags_crational
    cinteger = _swiginac.info_flags_cinteger
    positive = _swiginac.info_flags_positive
    negative = _swiginac.info_flags_negative
    nonnegative = _swiginac.info_flags_nonnegative
    posint = _swiginac.info_flags_posint
    negint = _swiginac.info_flags_negint
    nonnegint = _swiginac.info_flags_nonnegint
    even = _swiginac.info_flags_even
    odd = _swiginac.info_flags_odd
    prime = _swiginac.info_flags_prime
    relation = _swiginac.info_flags_relation
    relation_equal = _swiginac.info_flags_relation_equal
    relation_not_equal = _swiginac.info_flags_relation_not_equal
    relation_less = _swiginac.info_flags_relation_less
    relation_less_or_equal = _swiginac.info_flags_relation_less_or_equal
    relation_greater = _swiginac.info_flags_relation_greater
    relation_greater_or_equal = _swiginac.info_flags_relation_greater_or_equal
    symbol = _swiginac.info_flags_symbol
    list = _swiginac.info_flags_list
    exprseq = _swiginac.info_flags_exprseq
    polynomial = _swiginac.info_flags_polynomial
    integer_polynomial = _swiginac.info_flags_integer_polynomial
    cinteger_polynomial = _swiginac.info_flags_cinteger_polynomial
    rational_polynomial = _swiginac.info_flags_rational_polynomial
    crational_polynomial = _swiginac.info_flags_crational_polynomial
    rational_function = _swiginac.info_flags_rational_function
    algebraic = _swiginac.info_flags_algebraic
    indexed = _swiginac.info_flags_indexed
    has_indices = _swiginac.info_flags_has_indices
    idx = _swiginac.info_flags_idx
    def __init__(self): 
        """__init__(GiNaC::info_flags self) -> info_flags"""
        this = _swiginac.new_info_flags()
        try: self.this.append(this)
        except: self.this = this
    __swig_destroy__ = _swiginac.delete_info_flags
    __del__ = lambda self : None;
info_flags_swigregister = _swiginac.info_flags_swigregister
info_flags_swigregister(info_flags)

class pseries(basic):
    """Proxy of C++ GiNaC::pseries class"""
    __swig_setmethods__ = {}
    for _s in [basic]: __swig_setmethods__.update(getattr(_s,'__swig_setmethods__',{}))
    __setattr__ = lambda self, name, value: _swig_setattr(self, pseries, name, value)
    __swig_getmethods__ = {}
    for _s in [basic]: __swig_getmethods__.update(getattr(_s,'__swig_getmethods__',{}))
    __getattr__ = lambda self, name: _swig_getattr(self, pseries, name)
    __repr__ = _swig_repr
    def __init__(self, *args): 
        """__init__(GiNaC::pseries self, ex rel_, GiNaC::epvector const & ops_) -> pseries"""
        this = _swiginac.new_pseries(*args)
        try: self.this.append(this)
        except: self.this = this
    def get_var(self):
        """get_var(pseries self) -> ex"""
        return _swiginac.pseries_get_var(self)

    def get_point(self):
        """get_point(pseries self) -> ex"""
        return _swiginac.pseries_get_point(self)

    def convert_to_poly(self, no_order=False):
        """
        convert_to_poly(pseries self, bool no_order=False) -> ex
        convert_to_poly(pseries self) -> ex
        """
        return _swiginac.pseries_convert_to_poly(self, no_order)

    def is_compatible_to(self, *args):
        """is_compatible_to(pseries self, pseries other) -> bool"""
        return _swiginac.pseries_is_compatible_to(self, *args)

    def is_zero(self):
        """is_zero(pseries self) -> bool"""
        return _swiginac.pseries_is_zero(self)

    def is_terminating(self):
        """is_terminating(pseries self) -> bool"""
        return _swiginac.pseries_is_terminating(self)

    def coeffop(self, *args):
        """coeffop(pseries self, size_t i) -> ex"""
        return _swiginac.pseries_coeffop(self, *args)

    def exponop(self, *args):
        """exponop(pseries self, size_t i) -> ex"""
        return _swiginac.pseries_exponop(self, *args)

    def add_series(self, *args):
        """add_series(pseries self, pseries other) -> ex"""
        return _swiginac.pseries_add_series(self, *args)

    def mul_const(self, *args):
        """mul_const(pseries self, numeric other) -> ex"""
        return _swiginac.pseries_mul_const(self, *args)

    def mul_series(self, *args):
        """mul_series(pseries self, pseries other) -> ex"""
        return _swiginac.pseries_mul_series(self, *args)

    def power_const(self, *args):
        """power_const(pseries self, numeric p, int deg) -> ex"""
        return _swiginac.pseries_power_const(self, *args)

    def shift_exponents(self, *args):
        """shift_exponents(pseries self, int deg) -> pseries"""
        return _swiginac.pseries_shift_exponents(self, *args)

    def __repr__(self):
        return self.__str__()

    __swig_destroy__ = _swiginac.delete_pseries
    __del__ = lambda self : None;
pseries_swigregister = _swiginac.pseries_swigregister
pseries_swigregister(pseries)


def series_to_poly(*args):
  """series_to_poly(ex e) -> ex"""
  return _swiginac.series_to_poly(*args)

def is_terminating(*args):
  """is_terminating(pseries s) -> bool"""
  return _swiginac.is_terminating(*args)

def fsolve(*args):
  """fsolve(ex f, symbol x, numeric x1, numeric x2) -> numeric"""
  return _swiginac.fsolve(*args)
class archive_node(_object):
    """Proxy of C++ GiNaC::archive_node class"""
    __swig_setmethods__ = {}
    __setattr__ = lambda self, name, value: _swig_setattr(self, archive_node, name, value)
    __swig_getmethods__ = {}
    __getattr__ = lambda self, name: _swig_getattr(self, archive_node, name)
    __repr__ = _swig_repr
    def __init__(self, *args): 
        """
        __init__(GiNaC::archive_node self) -> archive_node
        __init__(GiNaC::archive_node self, archive ar) -> archive_node
        __init__(GiNaC::archive_node self, archive ar, ex expr) -> archive_node
        """
        this = _swiginac.new_archive_node(*args)
        try: self.this.append(this)
        except: self.this = this
    def add_bool(self, *args):
        """add_bool(archive_node self, string name, bool value)"""
        return _swiginac.archive_node_add_bool(self, *args)

    def add_unsigned(self, *args):
        """add_unsigned(archive_node self, string name, unsigned int value)"""
        return _swiginac.archive_node_add_unsigned(self, *args)

    def add_string(self, *args):
        """add_string(archive_node self, string name, string value)"""
        return _swiginac.archive_node_add_string(self, *args)

    def add_ex(self, *args):
        """add_ex(archive_node self, string name, ex value)"""
        return _swiginac.archive_node_add_ex(self, *args)

    def find_bool(self, *args):
        """
        find_bool(archive_node self, string name, bool & ret, unsigned int index=0) -> bool
        find_bool(archive_node self, string name, bool & ret) -> bool
        """
        return _swiginac.archive_node_find_bool(self, *args)

    def find_unsigned(self, *args):
        """
        find_unsigned(archive_node self, string name, unsigned int & ret, unsigned int index=0) -> bool
        find_unsigned(archive_node self, string name, unsigned int & ret) -> bool
        """
        return _swiginac.archive_node_find_unsigned(self, *args)

    def find_string(self, *args):
        """
        find_string(archive_node self, string name, string ret, unsigned int index=0) -> bool
        find_string(archive_node self, string name, string ret) -> bool
        """
        return _swiginac.archive_node_find_string(self, *args)

    def find_ex(self, *args):
        """
        find_ex(archive_node self, string name, ex ret, lst sym_lst, unsigned int index=0) -> bool
        find_ex(archive_node self, string name, ex ret, lst sym_lst) -> bool
        """
        return _swiginac.archive_node_find_ex(self, *args)

    def find_ex_node(self, *args):
        """
        find_ex_node(archive_node self, string name, unsigned int index=0) -> archive_node
        find_ex_node(archive_node self, string name) -> archive_node
        """
        return _swiginac.archive_node_find_ex_node(self, *args)

    def unarchive(self, *args):
        """unarchive(archive_node self, lst sym_lst) -> ex"""
        return _swiginac.archive_node_unarchive(self, *args)

    def has_same_ex_as(self, *args):
        """has_same_ex_as(archive_node self, archive_node other) -> bool"""
        return _swiginac.archive_node_has_same_ex_as(self, *args)

    def has_ex(self):
        """has_ex(archive_node self) -> bool"""
        return _swiginac.archive_node_has_ex(self)

    def get_ex(self):
        """get_ex(archive_node self) -> ex"""
        return _swiginac.archive_node_get_ex(self)

    def forget(self):
        """forget(archive_node self)"""
        return _swiginac.archive_node_forget(self)

    def printraw(self, *args):
        """printraw(archive_node self, ostream os)"""
        return _swiginac.archive_node_printraw(self, *args)

    __swig_destroy__ = _swiginac.delete_archive_node
    __del__ = lambda self : None;
archive_node_swigregister = _swiginac.archive_node_swigregister
archive_node_swigregister(archive_node)

class archive(_object):
    """Proxy of C++ GiNaC::archive class"""
    __swig_setmethods__ = {}
    __setattr__ = lambda self, name, value: _swig_setattr(self, archive, name, value)
    __swig_getmethods__ = {}
    __getattr__ = lambda self, name: _swig_getattr(self, archive, name)
    __repr__ = _swig_repr
    __swig_destroy__ = _swiginac.delete_archive
    __del__ = lambda self : None;
    def __init__(self, *args): 
        """
        __init__(GiNaC::archive self) -> archive
        __init__(GiNaC::archive self, ex e) -> archive
        __init__(GiNaC::archive self, ex e, char const * n) -> archive
        """
        this = _swiginac.new_archive(*args)
        try: self.this.append(this)
        except: self.this = this
    def archive_ex(self, *args):
        """archive_ex(archive self, ex e, char const * name)"""
        return _swiginac.archive_archive_ex(self, *args)

    def unarchive_ex(self, *args):
        """
        unarchive_ex(archive self, lst sym_lst, char const * name) -> ex
        unarchive_ex(archive self, lst sym_lst, unsigned int index=0) -> ex
        unarchive_ex(archive self, lst sym_lst) -> ex
        unarchive_ex(archive self, lst sym_lst, string name, unsigned int index=0) -> ex
        unarchive_ex(archive self, lst sym_lst, string name) -> ex
        """
        return _swiginac.archive_unarchive_ex(self, *args)

    def num_expressions(self):
        """num_expressions(archive self) -> unsigned int"""
        return _swiginac.archive_num_expressions(self)

    def get_top_node(self, index=0):
        """
        get_top_node(archive self, unsigned int index=0) -> archive_node
        get_top_node(archive self) -> archive_node
        """
        return _swiginac.archive_get_top_node(self, index)

    def clear(self):
        """clear(archive self)"""
        return _swiginac.archive_clear(self)

    def add_node(self, *args):
        """add_node(archive self, archive_node n) -> GiNaC::archive_node_id"""
        return _swiginac.archive_add_node(self, *args)

    def get_node(self, *args):
        """get_node(archive self, GiNaC::archive_node_id id) -> archive_node"""
        return _swiginac.archive_get_node(self, *args)

    def forget(self):
        """forget(archive self)"""
        return _swiginac.archive_forget(self)

    def printraw(self, *args):
        """printraw(archive self, ostream os)"""
        return _swiginac.archive_printraw(self, *args)

    def atomize(self, *args):
        """atomize(archive self, string s) -> GiNaC::archive_atom"""
        return _swiginac.archive_atomize(self, *args)

    def unatomize(self, *args):
        """unatomize(archive self, GiNaC::archive_atom id) -> string"""
        return _swiginac.archive_unatomize(self, *args)

    def load(self, *args):
        """load(archive self, string filename)"""
        return _swiginac.archive_load(self, *args)

    def dump(self, *args):
        """dump(archive self, string filename)"""
        return _swiginac.archive_dump(self, *args)

archive_swigregister = _swiginac.archive_swigregister
archive_swigregister(archive)


def __lshift__(*args):
  """__lshift__(ostream os, archive ar) -> ostream"""
  return _swiginac.__lshift__(*args)

def __rshift__(*args):
  """__rshift__(istream _is, archive ar) -> istream"""
  return _swiginac.__rshift__(*args)
class exvector(_object):
    """Proxy of C++ std::vector<(GiNaC::ex)> class"""
    __swig_setmethods__ = {}
    __setattr__ = lambda self, name, value: _swig_setattr(self, exvector, name, value)
    __swig_getmethods__ = {}
    __getattr__ = lambda self, name: _swig_getattr(self, exvector, name)
    __repr__ = _swig_repr
    def iterator(self):
        """iterator(exvector self) -> SwigPyIterator"""
        return _swiginac.exvector_iterator(self)

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

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

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

    def pop(self):
        """pop(exvector self) -> ex"""
        return _swiginac.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 _swiginac.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 _swiginac.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 _swiginac.exvector___delslice__(self, *args)

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

    def __getitem__(self, *args):
        """
        __getitem__(exvector self, PySliceObject * slice) -> exvector
        __getitem__(exvector self, std::vector< GiNaC::ex >::difference_type i) -> ex
        """
        return _swiginac.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, ex x)
        """
        return _swiginac.exvector___setitem__(self, *args)

    def append(self, *args):
        """append(exvector self, ex x)"""
        return _swiginac.exvector_append(self, *args)

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

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

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

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

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

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

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

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

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

    def pop_back(self):
        """pop_back(exvector self)"""
        return _swiginac.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 _swiginac.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, ex value) -> exvector
        """
        this = _swiginac.new_exvector(*args)
        try: self.this.append(this)
        except: self.this = this
    def push_back(self, *args):
        """push_back(exvector self, ex x)"""
        return _swiginac.exvector_push_back(self, *args)

    def front(self):
        """front(exvector self) -> ex"""
        return _swiginac.exvector_front(self)

    def back(self):
        """back(exvector self) -> ex"""
        return _swiginac.exvector_back(self)

    def assign(self, *args):
        """assign(exvector self, std::vector< GiNaC::ex >::size_type n, ex x)"""
        return _swiginac.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, ex x)
        """
        return _swiginac.exvector_resize(self, *args)

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

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

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

    __swig_destroy__ = _swiginac.delete_exvector
    __del__ = lambda self : None;
exvector_swigregister = _swiginac.exvector_swigregister
exvector_swigregister(exvector)

class exmap(_object):
    """Proxy of C++ std::map<(GiNaC::ex,GiNaC::ex,GiNaC::ex_is_less)> class"""
    __swig_setmethods__ = {}
    __setattr__ = lambda self, name, value: _swig_setattr(self, exmap, name, value)
    __swig_getmethods__ = {}
    __getattr__ = lambda self, name: _swig_getattr(self, exmap, name)
    __repr__ = _swig_repr
    def iterator(self):
        """iterator(exmap self) -> SwigPyIterator"""
        return _swiginac.exmap_iterator(self)

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

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

    def __len__(self):
        """__len__(exmap self) -> std::map< GiNaC::ex,GiNaC::ex,GiNaC::ex_is_less >::size_type"""
        return _swiginac.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, ex key) -> ex"""
        return _swiginac.exmap___getitem__(self, *args)

    def __delitem__(self, *args):
        """__delitem__(exmap self, ex key)"""
        return _swiginac.exmap___delitem__(self, *args)

    def has_key(self, *args):
        """has_key(exmap self, ex key) -> bool"""
        return _swiginac.exmap_has_key(self, *args)

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

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

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

    def __contains__(self, *args):
        """__contains__(exmap self, ex key) -> bool"""
        return _swiginac.exmap___contains__(self, *args)

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

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

    def __setitem__(self, *args):
        """
        __setitem__(exmap self, ex key)
        __setitem__(exmap self, ex key, ex x)
        """
        return _swiginac.exmap___setitem__(self, *args)

    def asdict(self):
        """asdict(exmap self) -> PyObject *"""
        return _swiginac.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
        """
        this = _swiginac.new_exmap(*args)
        try: self.this.append(this)
        except: self.this = this
    def empty(self):
        """empty(exmap self) -> bool"""
        return _swiginac.exmap_empty(self)

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

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

    def swap(self, *args):
        """swap(exmap self, exmap v)"""
        return _swiginac.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 _swiginac.exmap_get_allocator(self)

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

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

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

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

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

    def erase(self, *args):
        """
        erase(exmap self, ex 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 _swiginac.exmap_erase(self, *args)

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

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

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

    __swig_destroy__ = _swiginac.delete_exmap
    __del__ = lambda self : None;
exmap_swigregister = _swiginac.exmap_swigregister
exmap_swigregister(exmap)

_dict = {}
def get_symbols(name, number):
    global _dict
    if not _dict.has_key(name):
         _dict[name] = [symbol("%s%d" % (name,i)) for i in xrange(number)]
    else:
        x = _dict[name]
        n = len(x)
        if n >= number:
            return x[:]
        else:
            _dict[name] += [symbol("%s%d" % (name,i)) for i in xrange(n, number)]

    return _dict[name][:]


def get_symbol(*args):
  """get_symbol(string name) -> symbol"""
  return _swiginac.get_symbol(*args)

def parse_string(*args):
  """parse_string(string str, lst ls) -> ex"""
  return _swiginac.parse_string(*args)

def toex(*args):
  """
    toex(lst l) -> ex
    toex(lst l) -> ex
    toex(basic b) -> ex
    """
  return _swiginac.toex(*args)
# This file is compatible with both classic and new-style classes.