# This file was automatically generated by SWIG (http://www.swig.org).
# Version 3.0.5
#
# 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('_CIntegrateAndFireTransferFunction', [dirname(__file__)])
        except ImportError:
            import _CIntegrateAndFireTransferFunction
            return _CIntegrateAndFireTransferFunction
        if fp is not None:
            try:
                _mod = imp.load_module('_CIntegrateAndFireTransferFunction', fp, pathname, description)
            finally:
                fp.close()
            return _mod
    _CIntegrateAndFireTransferFunction = swig_import_helper()
    del swig_import_helper
else:
    import _CIntegrateAndFireTransferFunction
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):
        if _newclass:
            object.__setattr__(self, name, value)
        else:
            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_nondynamic(self, class_type, name, static=1):
    if (name == "thisown"):
        return self.this.own()
    method = class_type.__swig_getmethods__.get(name, None)
    if method:
        return method(self)
    if (not static):
        return object.__getattr__(self, name)
    else:
        raise AttributeError(name)

def _swig_getattr(self, class_type, name):
    return _swig_getattr_nondynamic(self, class_type, name, 0)


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__ = _CIntegrateAndFireTransferFunction.delete_SwigPyIterator
    __del__ = lambda self: None

    def value(self):
        return _CIntegrateAndFireTransferFunction.SwigPyIterator_value(self)

    def incr(self, n=1):
        return _CIntegrateAndFireTransferFunction.SwigPyIterator_incr(self, n)

    def decr(self, n=1):
        return _CIntegrateAndFireTransferFunction.SwigPyIterator_decr(self, n)

    def distance(self, x):
        return _CIntegrateAndFireTransferFunction.SwigPyIterator_distance(self, x)

    def equal(self, x):
        return _CIntegrateAndFireTransferFunction.SwigPyIterator_equal(self, x)

    def copy(self):
        return _CIntegrateAndFireTransferFunction.SwigPyIterator_copy(self)

    def next(self):
        return _CIntegrateAndFireTransferFunction.SwigPyIterator_next(self)

    def __next__(self):
        return _CIntegrateAndFireTransferFunction.SwigPyIterator___next__(self)

    def previous(self):
        return _CIntegrateAndFireTransferFunction.SwigPyIterator_previous(self)

    def advance(self, n):
        return _CIntegrateAndFireTransferFunction.SwigPyIterator_advance(self, n)

    def __eq__(self, x):
        return _CIntegrateAndFireTransferFunction.SwigPyIterator___eq__(self, x)

    def __ne__(self, x):
        return _CIntegrateAndFireTransferFunction.SwigPyIterator___ne__(self, x)

    def __iadd__(self, n):
        return _CIntegrateAndFireTransferFunction.SwigPyIterator___iadd__(self, n)

    def __isub__(self, n):
        return _CIntegrateAndFireTransferFunction.SwigPyIterator___isub__(self, n)

    def __add__(self, n):
        return _CIntegrateAndFireTransferFunction.SwigPyIterator___add__(self, n)

    def __sub__(self, *args):
        return _CIntegrateAndFireTransferFunction.SwigPyIterator___sub__(self, *args)
    def __iter__(self):
        return self
SwigPyIterator_swigregister = _CIntegrateAndFireTransferFunction.SwigPyIterator_swigregister
SwigPyIterator_swigregister(SwigPyIterator)

class IntVector(_object):
    __swig_setmethods__ = {}
    __setattr__ = lambda self, name, value: _swig_setattr(self, IntVector, name, value)
    __swig_getmethods__ = {}
    __getattr__ = lambda self, name: _swig_getattr(self, IntVector, name)
    __repr__ = _swig_repr

    def iterator(self):
        return _CIntegrateAndFireTransferFunction.IntVector_iterator(self)
    def __iter__(self):
        return self.iterator()

    def __nonzero__(self):
        return _CIntegrateAndFireTransferFunction.IntVector___nonzero__(self)

    def __bool__(self):
        return _CIntegrateAndFireTransferFunction.IntVector___bool__(self)

    def __len__(self):
        return _CIntegrateAndFireTransferFunction.IntVector___len__(self)

    def pop(self):
        return _CIntegrateAndFireTransferFunction.IntVector_pop(self)

    def __getslice__(self, i, j):
        return _CIntegrateAndFireTransferFunction.IntVector___getslice__(self, i, j)

    def __setslice__(self, *args):
        return _CIntegrateAndFireTransferFunction.IntVector___setslice__(self, *args)

    def __delslice__(self, i, j):
        return _CIntegrateAndFireTransferFunction.IntVector___delslice__(self, i, j)

    def __delitem__(self, *args):
        return _CIntegrateAndFireTransferFunction.IntVector___delitem__(self, *args)

    def __getitem__(self, *args):
        return _CIntegrateAndFireTransferFunction.IntVector___getitem__(self, *args)

    def __setitem__(self, *args):
        return _CIntegrateAndFireTransferFunction.IntVector___setitem__(self, *args)

    def append(self, x):
        return _CIntegrateAndFireTransferFunction.IntVector_append(self, x)

    def empty(self):
        return _CIntegrateAndFireTransferFunction.IntVector_empty(self)

    def size(self):
        return _CIntegrateAndFireTransferFunction.IntVector_size(self)

    def clear(self):
        return _CIntegrateAndFireTransferFunction.IntVector_clear(self)

    def swap(self, v):
        return _CIntegrateAndFireTransferFunction.IntVector_swap(self, v)

    def get_allocator(self):
        return _CIntegrateAndFireTransferFunction.IntVector_get_allocator(self)

    def begin(self):
        return _CIntegrateAndFireTransferFunction.IntVector_begin(self)

    def end(self):
        return _CIntegrateAndFireTransferFunction.IntVector_end(self)

    def rbegin(self):
        return _CIntegrateAndFireTransferFunction.IntVector_rbegin(self)

    def rend(self):
        return _CIntegrateAndFireTransferFunction.IntVector_rend(self)

    def pop_back(self):
        return _CIntegrateAndFireTransferFunction.IntVector_pop_back(self)

    def erase(self, *args):
        return _CIntegrateAndFireTransferFunction.IntVector_erase(self, *args)

    def __init__(self, *args):
        this = _CIntegrateAndFireTransferFunction.new_IntVector(*args)
        try:
            self.this.append(this)
        except:
            self.this = this

    def push_back(self, x):
        return _CIntegrateAndFireTransferFunction.IntVector_push_back(self, x)

    def front(self):
        return _CIntegrateAndFireTransferFunction.IntVector_front(self)

    def back(self):
        return _CIntegrateAndFireTransferFunction.IntVector_back(self)

    def assign(self, n, x):
        return _CIntegrateAndFireTransferFunction.IntVector_assign(self, n, x)

    def resize(self, *args):
        return _CIntegrateAndFireTransferFunction.IntVector_resize(self, *args)

    def insert(self, *args):
        return _CIntegrateAndFireTransferFunction.IntVector_insert(self, *args)

    def reserve(self, n):
        return _CIntegrateAndFireTransferFunction.IntVector_reserve(self, n)

    def capacity(self):
        return _CIntegrateAndFireTransferFunction.IntVector_capacity(self)
    __swig_destroy__ = _CIntegrateAndFireTransferFunction.delete_IntVector
    __del__ = lambda self: None
IntVector_swigregister = _CIntegrateAndFireTransferFunction.IntVector_swigregister
IntVector_swigregister(IntVector)

class DoubleVector(_object):
    __swig_setmethods__ = {}
    __setattr__ = lambda self, name, value: _swig_setattr(self, DoubleVector, name, value)
    __swig_getmethods__ = {}
    __getattr__ = lambda self, name: _swig_getattr(self, DoubleVector, name)
    __repr__ = _swig_repr

    def iterator(self):
        return _CIntegrateAndFireTransferFunction.DoubleVector_iterator(self)
    def __iter__(self):
        return self.iterator()

    def __nonzero__(self):
        return _CIntegrateAndFireTransferFunction.DoubleVector___nonzero__(self)

    def __bool__(self):
        return _CIntegrateAndFireTransferFunction.DoubleVector___bool__(self)

    def __len__(self):
        return _CIntegrateAndFireTransferFunction.DoubleVector___len__(self)

    def pop(self):
        return _CIntegrateAndFireTransferFunction.DoubleVector_pop(self)

    def __getslice__(self, i, j):
        return _CIntegrateAndFireTransferFunction.DoubleVector___getslice__(self, i, j)

    def __setslice__(self, *args):
        return _CIntegrateAndFireTransferFunction.DoubleVector___setslice__(self, *args)

    def __delslice__(self, i, j):
        return _CIntegrateAndFireTransferFunction.DoubleVector___delslice__(self, i, j)

    def __delitem__(self, *args):
        return _CIntegrateAndFireTransferFunction.DoubleVector___delitem__(self, *args)

    def __getitem__(self, *args):
        return _CIntegrateAndFireTransferFunction.DoubleVector___getitem__(self, *args)

    def __setitem__(self, *args):
        return _CIntegrateAndFireTransferFunction.DoubleVector___setitem__(self, *args)

    def append(self, x):
        return _CIntegrateAndFireTransferFunction.DoubleVector_append(self, x)

    def empty(self):
        return _CIntegrateAndFireTransferFunction.DoubleVector_empty(self)

    def size(self):
        return _CIntegrateAndFireTransferFunction.DoubleVector_size(self)

    def clear(self):
        return _CIntegrateAndFireTransferFunction.DoubleVector_clear(self)

    def swap(self, v):
        return _CIntegrateAndFireTransferFunction.DoubleVector_swap(self, v)

    def get_allocator(self):
        return _CIntegrateAndFireTransferFunction.DoubleVector_get_allocator(self)

    def begin(self):
        return _CIntegrateAndFireTransferFunction.DoubleVector_begin(self)

    def end(self):
        return _CIntegrateAndFireTransferFunction.DoubleVector_end(self)

    def rbegin(self):
        return _CIntegrateAndFireTransferFunction.DoubleVector_rbegin(self)

    def rend(self):
        return _CIntegrateAndFireTransferFunction.DoubleVector_rend(self)

    def pop_back(self):
        return _CIntegrateAndFireTransferFunction.DoubleVector_pop_back(self)

    def erase(self, *args):
        return _CIntegrateAndFireTransferFunction.DoubleVector_erase(self, *args)

    def __init__(self, *args):
        this = _CIntegrateAndFireTransferFunction.new_DoubleVector(*args)
        try:
            self.this.append(this)
        except:
            self.this = this

    def push_back(self, x):
        return _CIntegrateAndFireTransferFunction.DoubleVector_push_back(self, x)

    def front(self):
        return _CIntegrateAndFireTransferFunction.DoubleVector_front(self)

    def back(self):
        return _CIntegrateAndFireTransferFunction.DoubleVector_back(self)

    def assign(self, n, x):
        return _CIntegrateAndFireTransferFunction.DoubleVector_assign(self, n, x)

    def resize(self, *args):
        return _CIntegrateAndFireTransferFunction.DoubleVector_resize(self, *args)

    def insert(self, *args):
        return _CIntegrateAndFireTransferFunction.DoubleVector_insert(self, *args)

    def reserve(self, n):
        return _CIntegrateAndFireTransferFunction.DoubleVector_reserve(self, n)

    def capacity(self):
        return _CIntegrateAndFireTransferFunction.DoubleVector_capacity(self)
    __swig_destroy__ = _CIntegrateAndFireTransferFunction.delete_DoubleVector
    __del__ = lambda self: None
DoubleVector_swigregister = _CIntegrateAndFireTransferFunction.DoubleVector_swigregister
DoubleVector_swigregister(DoubleVector)

class DoubleVectorVector(_object):
    __swig_setmethods__ = {}
    __setattr__ = lambda self, name, value: _swig_setattr(self, DoubleVectorVector, name, value)
    __swig_getmethods__ = {}
    __getattr__ = lambda self, name: _swig_getattr(self, DoubleVectorVector, name)
    __repr__ = _swig_repr

    def iterator(self):
        return _CIntegrateAndFireTransferFunction.DoubleVectorVector_iterator(self)
    def __iter__(self):
        return self.iterator()

    def __nonzero__(self):
        return _CIntegrateAndFireTransferFunction.DoubleVectorVector___nonzero__(self)

    def __bool__(self):
        return _CIntegrateAndFireTransferFunction.DoubleVectorVector___bool__(self)

    def __len__(self):
        return _CIntegrateAndFireTransferFunction.DoubleVectorVector___len__(self)

    def pop(self):
        return _CIntegrateAndFireTransferFunction.DoubleVectorVector_pop(self)

    def __getslice__(self, i, j):
        return _CIntegrateAndFireTransferFunction.DoubleVectorVector___getslice__(self, i, j)

    def __setslice__(self, *args):
        return _CIntegrateAndFireTransferFunction.DoubleVectorVector___setslice__(self, *args)

    def __delslice__(self, i, j):
        return _CIntegrateAndFireTransferFunction.DoubleVectorVector___delslice__(self, i, j)

    def __delitem__(self, *args):
        return _CIntegrateAndFireTransferFunction.DoubleVectorVector___delitem__(self, *args)

    def __getitem__(self, *args):
        return _CIntegrateAndFireTransferFunction.DoubleVectorVector___getitem__(self, *args)

    def __setitem__(self, *args):
        return _CIntegrateAndFireTransferFunction.DoubleVectorVector___setitem__(self, *args)

    def append(self, x):
        return _CIntegrateAndFireTransferFunction.DoubleVectorVector_append(self, x)

    def empty(self):
        return _CIntegrateAndFireTransferFunction.DoubleVectorVector_empty(self)

    def size(self):
        return _CIntegrateAndFireTransferFunction.DoubleVectorVector_size(self)

    def clear(self):
        return _CIntegrateAndFireTransferFunction.DoubleVectorVector_clear(self)

    def swap(self, v):
        return _CIntegrateAndFireTransferFunction.DoubleVectorVector_swap(self, v)

    def get_allocator(self):
        return _CIntegrateAndFireTransferFunction.DoubleVectorVector_get_allocator(self)

    def begin(self):
        return _CIntegrateAndFireTransferFunction.DoubleVectorVector_begin(self)

    def end(self):
        return _CIntegrateAndFireTransferFunction.DoubleVectorVector_end(self)

    def rbegin(self):
        return _CIntegrateAndFireTransferFunction.DoubleVectorVector_rbegin(self)

    def rend(self):
        return _CIntegrateAndFireTransferFunction.DoubleVectorVector_rend(self)

    def pop_back(self):
        return _CIntegrateAndFireTransferFunction.DoubleVectorVector_pop_back(self)

    def erase(self, *args):
        return _CIntegrateAndFireTransferFunction.DoubleVectorVector_erase(self, *args)

    def __init__(self, *args):
        this = _CIntegrateAndFireTransferFunction.new_DoubleVectorVector(*args)
        try:
            self.this.append(this)
        except:
            self.this = this

    def push_back(self, x):
        return _CIntegrateAndFireTransferFunction.DoubleVectorVector_push_back(self, x)

    def front(self):
        return _CIntegrateAndFireTransferFunction.DoubleVectorVector_front(self)

    def back(self):
        return _CIntegrateAndFireTransferFunction.DoubleVectorVector_back(self)

    def assign(self, n, x):
        return _CIntegrateAndFireTransferFunction.DoubleVectorVector_assign(self, n, x)

    def resize(self, *args):
        return _CIntegrateAndFireTransferFunction.DoubleVectorVector_resize(self, *args)

    def insert(self, *args):
        return _CIntegrateAndFireTransferFunction.DoubleVectorVector_insert(self, *args)

    def reserve(self, n):
        return _CIntegrateAndFireTransferFunction.DoubleVectorVector_reserve(self, n)

    def capacity(self):
        return _CIntegrateAndFireTransferFunction.DoubleVectorVector_capacity(self)
    __swig_destroy__ = _CIntegrateAndFireTransferFunction.delete_DoubleVectorVector
    __del__ = lambda self: None
DoubleVectorVector_swigregister = _CIntegrateAndFireTransferFunction.DoubleVectorVector_swigregister
DoubleVectorVector_swigregister(DoubleVectorVector)

class StringVector(_object):
    __swig_setmethods__ = {}
    __setattr__ = lambda self, name, value: _swig_setattr(self, StringVector, name, value)
    __swig_getmethods__ = {}
    __getattr__ = lambda self, name: _swig_getattr(self, StringVector, name)
    __repr__ = _swig_repr

    def iterator(self):
        return _CIntegrateAndFireTransferFunction.StringVector_iterator(self)
    def __iter__(self):
        return self.iterator()

    def __nonzero__(self):
        return _CIntegrateAndFireTransferFunction.StringVector___nonzero__(self)

    def __bool__(self):
        return _CIntegrateAndFireTransferFunction.StringVector___bool__(self)

    def __len__(self):
        return _CIntegrateAndFireTransferFunction.StringVector___len__(self)

    def pop(self):
        return _CIntegrateAndFireTransferFunction.StringVector_pop(self)

    def __getslice__(self, i, j):
        return _CIntegrateAndFireTransferFunction.StringVector___getslice__(self, i, j)

    def __setslice__(self, *args):
        return _CIntegrateAndFireTransferFunction.StringVector___setslice__(self, *args)

    def __delslice__(self, i, j):
        return _CIntegrateAndFireTransferFunction.StringVector___delslice__(self, i, j)

    def __delitem__(self, *args):
        return _CIntegrateAndFireTransferFunction.StringVector___delitem__(self, *args)

    def __getitem__(self, *args):
        return _CIntegrateAndFireTransferFunction.StringVector___getitem__(self, *args)

    def __setitem__(self, *args):
        return _CIntegrateAndFireTransferFunction.StringVector___setitem__(self, *args)

    def append(self, x):
        return _CIntegrateAndFireTransferFunction.StringVector_append(self, x)

    def empty(self):
        return _CIntegrateAndFireTransferFunction.StringVector_empty(self)

    def size(self):
        return _CIntegrateAndFireTransferFunction.StringVector_size(self)

    def clear(self):
        return _CIntegrateAndFireTransferFunction.StringVector_clear(self)

    def swap(self, v):
        return _CIntegrateAndFireTransferFunction.StringVector_swap(self, v)

    def get_allocator(self):
        return _CIntegrateAndFireTransferFunction.StringVector_get_allocator(self)

    def begin(self):
        return _CIntegrateAndFireTransferFunction.StringVector_begin(self)

    def end(self):
        return _CIntegrateAndFireTransferFunction.StringVector_end(self)

    def rbegin(self):
        return _CIntegrateAndFireTransferFunction.StringVector_rbegin(self)

    def rend(self):
        return _CIntegrateAndFireTransferFunction.StringVector_rend(self)

    def pop_back(self):
        return _CIntegrateAndFireTransferFunction.StringVector_pop_back(self)

    def erase(self, *args):
        return _CIntegrateAndFireTransferFunction.StringVector_erase(self, *args)

    def __init__(self, *args):
        this = _CIntegrateAndFireTransferFunction.new_StringVector(*args)
        try:
            self.this.append(this)
        except:
            self.this = this

    def push_back(self, x):
        return _CIntegrateAndFireTransferFunction.StringVector_push_back(self, x)

    def front(self):
        return _CIntegrateAndFireTransferFunction.StringVector_front(self)

    def back(self):
        return _CIntegrateAndFireTransferFunction.StringVector_back(self)

    def assign(self, n, x):
        return _CIntegrateAndFireTransferFunction.StringVector_assign(self, n, x)

    def resize(self, *args):
        return _CIntegrateAndFireTransferFunction.StringVector_resize(self, *args)

    def insert(self, *args):
        return _CIntegrateAndFireTransferFunction.StringVector_insert(self, *args)

    def reserve(self, n):
        return _CIntegrateAndFireTransferFunction.StringVector_reserve(self, n)

    def capacity(self):
        return _CIntegrateAndFireTransferFunction.StringVector_capacity(self)
    __swig_destroy__ = _CIntegrateAndFireTransferFunction.delete_StringVector
    __del__ = lambda self: None
StringVector_swigregister = _CIntegrateAndFireTransferFunction.StringVector_swigregister
StringVector_swigregister(StringVector)

class MapStringInt(_object):
    __swig_setmethods__ = {}
    __setattr__ = lambda self, name, value: _swig_setattr(self, MapStringInt, name, value)
    __swig_getmethods__ = {}
    __getattr__ = lambda self, name: _swig_getattr(self, MapStringInt, name)
    __repr__ = _swig_repr

    def iterator(self):
        return _CIntegrateAndFireTransferFunction.MapStringInt_iterator(self)
    def __iter__(self):
        return self.iterator()

    def __nonzero__(self):
        return _CIntegrateAndFireTransferFunction.MapStringInt___nonzero__(self)

    def __bool__(self):
        return _CIntegrateAndFireTransferFunction.MapStringInt___bool__(self)

    def __len__(self):
        return _CIntegrateAndFireTransferFunction.MapStringInt___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, key):
        return _CIntegrateAndFireTransferFunction.MapStringInt___getitem__(self, key)

    def __delitem__(self, key):
        return _CIntegrateAndFireTransferFunction.MapStringInt___delitem__(self, key)

    def has_key(self, key):
        return _CIntegrateAndFireTransferFunction.MapStringInt_has_key(self, key)

    def keys(self):
        return _CIntegrateAndFireTransferFunction.MapStringInt_keys(self)

    def values(self):
        return _CIntegrateAndFireTransferFunction.MapStringInt_values(self)

    def items(self):
        return _CIntegrateAndFireTransferFunction.MapStringInt_items(self)

    def __contains__(self, key):
        return _CIntegrateAndFireTransferFunction.MapStringInt___contains__(self, key)

    def key_iterator(self):
        return _CIntegrateAndFireTransferFunction.MapStringInt_key_iterator(self)

    def value_iterator(self):
        return _CIntegrateAndFireTransferFunction.MapStringInt_value_iterator(self)

    def __setitem__(self, *args):
        return _CIntegrateAndFireTransferFunction.MapStringInt___setitem__(self, *args)

    def asdict(self):
        return _CIntegrateAndFireTransferFunction.MapStringInt_asdict(self)

    def __init__(self, *args):
        this = _CIntegrateAndFireTransferFunction.new_MapStringInt(*args)
        try:
            self.this.append(this)
        except:
            self.this = this

    def empty(self):
        return _CIntegrateAndFireTransferFunction.MapStringInt_empty(self)

    def size(self):
        return _CIntegrateAndFireTransferFunction.MapStringInt_size(self)

    def clear(self):
        return _CIntegrateAndFireTransferFunction.MapStringInt_clear(self)

    def swap(self, v):
        return _CIntegrateAndFireTransferFunction.MapStringInt_swap(self, v)

    def get_allocator(self):
        return _CIntegrateAndFireTransferFunction.MapStringInt_get_allocator(self)

    def begin(self):
        return _CIntegrateAndFireTransferFunction.MapStringInt_begin(self)

    def end(self):
        return _CIntegrateAndFireTransferFunction.MapStringInt_end(self)

    def rbegin(self):
        return _CIntegrateAndFireTransferFunction.MapStringInt_rbegin(self)

    def rend(self):
        return _CIntegrateAndFireTransferFunction.MapStringInt_rend(self)

    def count(self, x):
        return _CIntegrateAndFireTransferFunction.MapStringInt_count(self, x)

    def erase(self, *args):
        return _CIntegrateAndFireTransferFunction.MapStringInt_erase(self, *args)

    def find(self, x):
        return _CIntegrateAndFireTransferFunction.MapStringInt_find(self, x)

    def lower_bound(self, x):
        return _CIntegrateAndFireTransferFunction.MapStringInt_lower_bound(self, x)

    def upper_bound(self, x):
        return _CIntegrateAndFireTransferFunction.MapStringInt_upper_bound(self, x)
    __swig_destroy__ = _CIntegrateAndFireTransferFunction.delete_MapStringInt
    __del__ = lambda self: None
MapStringInt_swigregister = _CIntegrateAndFireTransferFunction.MapStringInt_swigregister
MapStringInt_swigregister(MapStringInt)

class MapStringString(_object):
    __swig_setmethods__ = {}
    __setattr__ = lambda self, name, value: _swig_setattr(self, MapStringString, name, value)
    __swig_getmethods__ = {}
    __getattr__ = lambda self, name: _swig_getattr(self, MapStringString, name)
    __repr__ = _swig_repr

    def iterator(self):
        return _CIntegrateAndFireTransferFunction.MapStringString_iterator(self)
    def __iter__(self):
        return self.iterator()

    def __nonzero__(self):
        return _CIntegrateAndFireTransferFunction.MapStringString___nonzero__(self)

    def __bool__(self):
        return _CIntegrateAndFireTransferFunction.MapStringString___bool__(self)

    def __len__(self):
        return _CIntegrateAndFireTransferFunction.MapStringString___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, key):
        return _CIntegrateAndFireTransferFunction.MapStringString___getitem__(self, key)

    def __delitem__(self, key):
        return _CIntegrateAndFireTransferFunction.MapStringString___delitem__(self, key)

    def has_key(self, key):
        return _CIntegrateAndFireTransferFunction.MapStringString_has_key(self, key)

    def keys(self):
        return _CIntegrateAndFireTransferFunction.MapStringString_keys(self)

    def values(self):
        return _CIntegrateAndFireTransferFunction.MapStringString_values(self)

    def items(self):
        return _CIntegrateAndFireTransferFunction.MapStringString_items(self)

    def __contains__(self, key):
        return _CIntegrateAndFireTransferFunction.MapStringString___contains__(self, key)

    def key_iterator(self):
        return _CIntegrateAndFireTransferFunction.MapStringString_key_iterator(self)

    def value_iterator(self):
        return _CIntegrateAndFireTransferFunction.MapStringString_value_iterator(self)

    def __setitem__(self, *args):
        return _CIntegrateAndFireTransferFunction.MapStringString___setitem__(self, *args)

    def asdict(self):
        return _CIntegrateAndFireTransferFunction.MapStringString_asdict(self)

    def __init__(self, *args):
        this = _CIntegrateAndFireTransferFunction.new_MapStringString(*args)
        try:
            self.this.append(this)
        except:
            self.this = this

    def empty(self):
        return _CIntegrateAndFireTransferFunction.MapStringString_empty(self)

    def size(self):
        return _CIntegrateAndFireTransferFunction.MapStringString_size(self)

    def clear(self):
        return _CIntegrateAndFireTransferFunction.MapStringString_clear(self)

    def swap(self, v):
        return _CIntegrateAndFireTransferFunction.MapStringString_swap(self, v)

    def get_allocator(self):
        return _CIntegrateAndFireTransferFunction.MapStringString_get_allocator(self)

    def begin(self):
        return _CIntegrateAndFireTransferFunction.MapStringString_begin(self)

    def end(self):
        return _CIntegrateAndFireTransferFunction.MapStringString_end(self)

    def rbegin(self):
        return _CIntegrateAndFireTransferFunction.MapStringString_rbegin(self)

    def rend(self):
        return _CIntegrateAndFireTransferFunction.MapStringString_rend(self)

    def count(self, x):
        return _CIntegrateAndFireTransferFunction.MapStringString_count(self, x)

    def erase(self, *args):
        return _CIntegrateAndFireTransferFunction.MapStringString_erase(self, *args)

    def find(self, x):
        return _CIntegrateAndFireTransferFunction.MapStringString_find(self, x)

    def lower_bound(self, x):
        return _CIntegrateAndFireTransferFunction.MapStringString_lower_bound(self, x)

    def upper_bound(self, x):
        return _CIntegrateAndFireTransferFunction.MapStringString_upper_bound(self, x)
    __swig_destroy__ = _CIntegrateAndFireTransferFunction.delete_MapStringString
    __del__ = lambda self: None
MapStringString_swigregister = _CIntegrateAndFireTransferFunction.MapStringString_swigregister
MapStringString_swigregister(MapStringString)

class MapStringDouble(_object):
    __swig_setmethods__ = {}
    __setattr__ = lambda self, name, value: _swig_setattr(self, MapStringDouble, name, value)
    __swig_getmethods__ = {}
    __getattr__ = lambda self, name: _swig_getattr(self, MapStringDouble, name)
    __repr__ = _swig_repr

    def iterator(self):
        return _CIntegrateAndFireTransferFunction.MapStringDouble_iterator(self)
    def __iter__(self):
        return self.iterator()

    def __nonzero__(self):
        return _CIntegrateAndFireTransferFunction.MapStringDouble___nonzero__(self)

    def __bool__(self):
        return _CIntegrateAndFireTransferFunction.MapStringDouble___bool__(self)

    def __len__(self):
        return _CIntegrateAndFireTransferFunction.MapStringDouble___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, key):
        return _CIntegrateAndFireTransferFunction.MapStringDouble___getitem__(self, key)

    def __delitem__(self, key):
        return _CIntegrateAndFireTransferFunction.MapStringDouble___delitem__(self, key)

    def has_key(self, key):
        return _CIntegrateAndFireTransferFunction.MapStringDouble_has_key(self, key)

    def keys(self):
        return _CIntegrateAndFireTransferFunction.MapStringDouble_keys(self)

    def values(self):
        return _CIntegrateAndFireTransferFunction.MapStringDouble_values(self)

    def items(self):
        return _CIntegrateAndFireTransferFunction.MapStringDouble_items(self)

    def __contains__(self, key):
        return _CIntegrateAndFireTransferFunction.MapStringDouble___contains__(self, key)

    def key_iterator(self):
        return _CIntegrateAndFireTransferFunction.MapStringDouble_key_iterator(self)

    def value_iterator(self):
        return _CIntegrateAndFireTransferFunction.MapStringDouble_value_iterator(self)

    def __setitem__(self, *args):
        return _CIntegrateAndFireTransferFunction.MapStringDouble___setitem__(self, *args)

    def asdict(self):
        return _CIntegrateAndFireTransferFunction.MapStringDouble_asdict(self)

    def __init__(self, *args):
        this = _CIntegrateAndFireTransferFunction.new_MapStringDouble(*args)
        try:
            self.this.append(this)
        except:
            self.this = this

    def empty(self):
        return _CIntegrateAndFireTransferFunction.MapStringDouble_empty(self)

    def size(self):
        return _CIntegrateAndFireTransferFunction.MapStringDouble_size(self)

    def clear(self):
        return _CIntegrateAndFireTransferFunction.MapStringDouble_clear(self)

    def swap(self, v):
        return _CIntegrateAndFireTransferFunction.MapStringDouble_swap(self, v)

    def get_allocator(self):
        return _CIntegrateAndFireTransferFunction.MapStringDouble_get_allocator(self)

    def begin(self):
        return _CIntegrateAndFireTransferFunction.MapStringDouble_begin(self)

    def end(self):
        return _CIntegrateAndFireTransferFunction.MapStringDouble_end(self)

    def rbegin(self):
        return _CIntegrateAndFireTransferFunction.MapStringDouble_rbegin(self)

    def rend(self):
        return _CIntegrateAndFireTransferFunction.MapStringDouble_rend(self)

    def count(self, x):
        return _CIntegrateAndFireTransferFunction.MapStringDouble_count(self, x)

    def erase(self, *args):
        return _CIntegrateAndFireTransferFunction.MapStringDouble_erase(self, *args)

    def find(self, x):
        return _CIntegrateAndFireTransferFunction.MapStringDouble_find(self, x)

    def lower_bound(self, x):
        return _CIntegrateAndFireTransferFunction.MapStringDouble_lower_bound(self, x)

    def upper_bound(self, x):
        return _CIntegrateAndFireTransferFunction.MapStringDouble_upper_bound(self, x)
    __swig_destroy__ = _CIntegrateAndFireTransferFunction.delete_MapStringDouble
    __del__ = lambda self: None
MapStringDouble_swigregister = _CIntegrateAndFireTransferFunction.MapStringDouble_swigregister
MapStringDouble_swigregister(MapStringDouble)

class MapStringComplexDouble(_object):
    __swig_setmethods__ = {}
    __setattr__ = lambda self, name, value: _swig_setattr(self, MapStringComplexDouble, name, value)
    __swig_getmethods__ = {}
    __getattr__ = lambda self, name: _swig_getattr(self, MapStringComplexDouble, name)
    __repr__ = _swig_repr

    def iterator(self):
        return _CIntegrateAndFireTransferFunction.MapStringComplexDouble_iterator(self)
    def __iter__(self):
        return self.iterator()

    def __nonzero__(self):
        return _CIntegrateAndFireTransferFunction.MapStringComplexDouble___nonzero__(self)

    def __bool__(self):
        return _CIntegrateAndFireTransferFunction.MapStringComplexDouble___bool__(self)

    def __len__(self):
        return _CIntegrateAndFireTransferFunction.MapStringComplexDouble___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, key):
        return _CIntegrateAndFireTransferFunction.MapStringComplexDouble___getitem__(self, key)

    def __delitem__(self, key):
        return _CIntegrateAndFireTransferFunction.MapStringComplexDouble___delitem__(self, key)

    def has_key(self, key):
        return _CIntegrateAndFireTransferFunction.MapStringComplexDouble_has_key(self, key)

    def keys(self):
        return _CIntegrateAndFireTransferFunction.MapStringComplexDouble_keys(self)

    def values(self):
        return _CIntegrateAndFireTransferFunction.MapStringComplexDouble_values(self)

    def items(self):
        return _CIntegrateAndFireTransferFunction.MapStringComplexDouble_items(self)

    def __contains__(self, key):
        return _CIntegrateAndFireTransferFunction.MapStringComplexDouble___contains__(self, key)

    def key_iterator(self):
        return _CIntegrateAndFireTransferFunction.MapStringComplexDouble_key_iterator(self)

    def value_iterator(self):
        return _CIntegrateAndFireTransferFunction.MapStringComplexDouble_value_iterator(self)

    def __setitem__(self, *args):
        return _CIntegrateAndFireTransferFunction.MapStringComplexDouble___setitem__(self, *args)

    def asdict(self):
        return _CIntegrateAndFireTransferFunction.MapStringComplexDouble_asdict(self)

    def __init__(self, *args):
        this = _CIntegrateAndFireTransferFunction.new_MapStringComplexDouble(*args)
        try:
            self.this.append(this)
        except:
            self.this = this

    def empty(self):
        return _CIntegrateAndFireTransferFunction.MapStringComplexDouble_empty(self)

    def size(self):
        return _CIntegrateAndFireTransferFunction.MapStringComplexDouble_size(self)

    def clear(self):
        return _CIntegrateAndFireTransferFunction.MapStringComplexDouble_clear(self)

    def swap(self, v):
        return _CIntegrateAndFireTransferFunction.MapStringComplexDouble_swap(self, v)

    def get_allocator(self):
        return _CIntegrateAndFireTransferFunction.MapStringComplexDouble_get_allocator(self)

    def begin(self):
        return _CIntegrateAndFireTransferFunction.MapStringComplexDouble_begin(self)

    def end(self):
        return _CIntegrateAndFireTransferFunction.MapStringComplexDouble_end(self)

    def rbegin(self):
        return _CIntegrateAndFireTransferFunction.MapStringComplexDouble_rbegin(self)

    def rend(self):
        return _CIntegrateAndFireTransferFunction.MapStringComplexDouble_rend(self)

    def count(self, x):
        return _CIntegrateAndFireTransferFunction.MapStringComplexDouble_count(self, x)

    def erase(self, *args):
        return _CIntegrateAndFireTransferFunction.MapStringComplexDouble_erase(self, *args)

    def find(self, x):
        return _CIntegrateAndFireTransferFunction.MapStringComplexDouble_find(self, x)

    def lower_bound(self, x):
        return _CIntegrateAndFireTransferFunction.MapStringComplexDouble_lower_bound(self, x)

    def upper_bound(self, x):
        return _CIntegrateAndFireTransferFunction.MapStringComplexDouble_upper_bound(self, x)
    __swig_destroy__ = _CIntegrateAndFireTransferFunction.delete_MapStringComplexDouble
    __del__ = lambda self: None
MapStringComplexDouble_swigregister = _CIntegrateAndFireTransferFunction.MapStringComplexDouble_swigregister
MapStringComplexDouble_swigregister(MapStringComplexDouble)

class CToolClass(_object):
    __swig_setmethods__ = {}
    __setattr__ = lambda self, name, value: _swig_setattr(self, CToolClass, name, value)
    __swig_getmethods__ = {}
    __getattr__ = lambda self, name: _swig_getattr(self, CToolClass, name)
    __repr__ = _swig_repr
    __swig_setmethods__["ComplexDict"] = _CIntegrateAndFireTransferFunction.CToolClass_ComplexDict_set
    __swig_getmethods__["ComplexDict"] = _CIntegrateAndFireTransferFunction.CToolClass_ComplexDict_get
    if _newclass:
        ComplexDict = _swig_property(_CIntegrateAndFireTransferFunction.CToolClass_ComplexDict_get, _CIntegrateAndFireTransferFunction.CToolClass_ComplexDict_set)
    __swig_setmethods__["DoubleDict"] = _CIntegrateAndFireTransferFunction.CToolClass_DoubleDict_set
    __swig_getmethods__["DoubleDict"] = _CIntegrateAndFireTransferFunction.CToolClass_DoubleDict_get
    if _newclass:
        DoubleDict = _swig_property(_CIntegrateAndFireTransferFunction.CToolClass_DoubleDict_get, _CIntegrateAndFireTransferFunction.CToolClass_DoubleDict_set)
    __swig_setmethods__["IntDict"] = _CIntegrateAndFireTransferFunction.CToolClass_IntDict_set
    __swig_getmethods__["IntDict"] = _CIntegrateAndFireTransferFunction.CToolClass_IntDict_get
    if _newclass:
        IntDict = _swig_property(_CIntegrateAndFireTransferFunction.CToolClass_IntDict_get, _CIntegrateAndFireTransferFunction.CToolClass_IntDict_set)
    __swig_setmethods__["StringDict"] = _CIntegrateAndFireTransferFunction.CToolClass_StringDict_set
    __swig_getmethods__["StringDict"] = _CIntegrateAndFireTransferFunction.CToolClass_StringDict_get
    if _newclass:
        StringDict = _swig_property(_CIntegrateAndFireTransferFunction.CToolClass_StringDict_get, _CIntegrateAndFireTransferFunction.CToolClass_StringDict_set)

    def setDicts(self, _ComplexDict, _DoubleDict, _IntDict, _StringDict):
        return _CIntegrateAndFireTransferFunction.CToolClass_setDicts(self, _ComplexDict, _DoubleDict, _IntDict, _StringDict)

    def __init__(self):
        this = _CIntegrateAndFireTransferFunction.new_CToolClass()
        try:
            self.this.append(this)
        except:
            self.this = this
    __swig_destroy__ = _CIntegrateAndFireTransferFunction.delete_CToolClass
    __del__ = lambda self: None
CToolClass_swigregister = _CIntegrateAndFireTransferFunction.CToolClass_swigregister
CToolClass_swigregister(CToolClass)


def getComplex(re, im):
    return _CIntegrateAndFireTransferFunction.getComplex(re, im)
getComplex = _CIntegrateAndFireTransferFunction.getComplex

def openFile(nameFile):
    return _CIntegrateAndFireTransferFunction.openFile(nameFile)
openFile = _CIntegrateAndFireTransferFunction.openFile

def closeFile(pFile):
    return _CIntegrateAndFireTransferFunction.closeFile(pFile)
closeFile = _CIntegrateAndFireTransferFunction.closeFile

def getWord(pFile, word):
    return _CIntegrateAndFireTransferFunction.getWord(pFile, word)
getWord = _CIntegrateAndFireTransferFunction.getWord

def readUntilLineEnd(pFile):
    return _CIntegrateAndFireTransferFunction.readUntilLineEnd(pFile)
readUntilLineEnd = _CIntegrateAndFireTransferFunction.readUntilLineEnd

def readUntilFileEnd(pFile):
    return _CIntegrateAndFireTransferFunction.readUntilFileEnd(pFile)
readUntilFileEnd = _CIntegrateAndFireTransferFunction.readUntilFileEnd

def getLinesStart(pFile):
    return _CIntegrateAndFireTransferFunction.getLinesStart(pFile)
getLinesStart = _CIntegrateAndFireTransferFunction.getLinesStart

def goToLine(pFile, nLine):
    return _CIntegrateAndFireTransferFunction.goToLine(pFile, nLine)
goToLine = _CIntegrateAndFireTransferFunction.goToLine

def goToLastLine(pFile):
    return _CIntegrateAndFireTransferFunction.goToLastLine(pFile)
goToLastLine = _CIntegrateAndFireTransferFunction.goToLastLine

def getNLines(nameFile):
    return _CIntegrateAndFireTransferFunction.getNLines(nameFile)
getNLines = _CIntegrateAndFireTransferFunction.getNLines

def updateRanSeed(directoryPath):
    return _CIntegrateAndFireTransferFunction.updateRanSeed(directoryPath)
updateRanSeed = _CIntegrateAndFireTransferFunction.updateRanSeed

def ran1(idum):
    return _CIntegrateAndFireTransferFunction.ran1(idum)
ran1 = _CIntegrateAndFireTransferFunction.ran1

def gasdev(idum):
    return _CIntegrateAndFireTransferFunction.gasdev(idum)
gasdev = _CIntegrateAndFireTransferFunction.gasdev

def expdev(idum):
    return _CIntegrateAndFireTransferFunction.expdev(idum)
expdev = _CIntegrateAndFireTransferFunction.expdev

def gamdev(ia, idum):
    return _CIntegrateAndFireTransferFunction.gamdev(ia, idum)
gamdev = _CIntegrateAndFireTransferFunction.gamdev

def factorial(n):
    return _CIntegrateAndFireTransferFunction.factorial(n)
factorial = _CIntegrateAndFireTransferFunction.factorial

def arrangement(k, n):
    return _CIntegrateAndFireTransferFunction.arrangement(k, n)
arrangement = _CIntegrateAndFireTransferFunction.arrangement

def combinaison(k, n):
    return _CIntegrateAndFireTransferFunction.combinaison(k, n)
combinaison = _CIntegrateAndFireTransferFunction.combinaison

def printVecFloat(vec):
    return _CIntegrateAndFireTransferFunction.printVecFloat(vec)
printVecFloat = _CIntegrateAndFireTransferFunction.printVecFloat

def printVecInt(vec):
    return _CIntegrateAndFireTransferFunction.printVecInt(vec)
printVecInt = _CIntegrateAndFireTransferFunction.printVecInt

def printArrayFloat(vec):
    return _CIntegrateAndFireTransferFunction.printArrayFloat(vec)
printArrayFloat = _CIntegrateAndFireTransferFunction.printArrayFloat

def printArrayInt(vec):
    return _CIntegrateAndFireTransferFunction.printArrayInt(vec)
printArrayInt = _CIntegrateAndFireTransferFunction.printArrayInt
class isEqualValue(_object):
    __swig_setmethods__ = {}
    __setattr__ = lambda self, name, value: _swig_setattr(self, isEqualValue, name, value)
    __swig_getmethods__ = {}
    __getattr__ = lambda self, name: _swig_getattr(self, isEqualValue, name)
    __repr__ = _swig_repr

    def __init__(self, _value=0):
        this = _CIntegrateAndFireTransferFunction.new_isEqualValue(_value)
        try:
            self.this.append(this)
        except:
            self.this = this

    def __call__(self, x):
        return _CIntegrateAndFireTransferFunction.isEqualValue___call__(self, x)
    __swig_destroy__ = _CIntegrateAndFireTransferFunction.delete_isEqualValue
    __del__ = lambda self: None
isEqualValue_swigregister = _CIntegrateAndFireTransferFunction.isEqualValue_swigregister
isEqualValue_swigregister(isEqualValue)

class isEven(_object):
    __swig_setmethods__ = {}
    __setattr__ = lambda self, name, value: _swig_setattr(self, isEven, name, value)
    __swig_getmethods__ = {}
    __getattr__ = lambda self, name: _swig_getattr(self, isEven, name)
    __repr__ = _swig_repr

    def __call__(self, x):
        return _CIntegrateAndFireTransferFunction.isEven___call__(self, x)

    def __init__(self):
        this = _CIntegrateAndFireTransferFunction.new_isEven()
        try:
            self.this.append(this)
        except:
            self.this = this
    __swig_destroy__ = _CIntegrateAndFireTransferFunction.delete_isEven
    __del__ = lambda self: None
isEven_swigregister = _CIntegrateAndFireTransferFunction.isEven_swigregister
isEven_swigregister(isEven)

class isOdd(_object):
    __swig_setmethods__ = {}
    __setattr__ = lambda self, name, value: _swig_setattr(self, isOdd, name, value)
    __swig_getmethods__ = {}
    __getattr__ = lambda self, name: _swig_getattr(self, isOdd, name)
    __repr__ = _swig_repr

    def __call__(self, x):
        return _CIntegrateAndFireTransferFunction.isOdd___call__(self, x)

    def __init__(self):
        this = _CIntegrateAndFireTransferFunction.new_isOdd()
        try:
            self.this.append(this)
        except:
            self.this = this
    __swig_destroy__ = _CIntegrateAndFireTransferFunction.delete_isOdd
    __del__ = lambda self: None
isOdd_swigregister = _CIntegrateAndFireTransferFunction.isOdd_swigregister
isOdd_swigregister(isOdd)

class meanClass(_object):
    __swig_setmethods__ = {}
    __setattr__ = lambda self, name, value: _swig_setattr(self, meanClass, name, value)
    __swig_getmethods__ = {}
    __getattr__ = lambda self, name: _swig_getattr(self, meanClass, name)
    __repr__ = _swig_repr

    def __init__(self, _vecSize=0):
        this = _CIntegrateAndFireTransferFunction.new_meanClass(_vecSize)
        try:
            self.this.append(this)
        except:
            self.this = this
    __swig_setmethods__["meanValue"] = _CIntegrateAndFireTransferFunction.meanClass_meanValue_set
    __swig_getmethods__["meanValue"] = _CIntegrateAndFireTransferFunction.meanClass_meanValue_get
    if _newclass:
        meanValue = _swig_property(_CIntegrateAndFireTransferFunction.meanClass_meanValue_get, _CIntegrateAndFireTransferFunction.meanClass_meanValue_set)
    __swig_setmethods__["vecSize"] = _CIntegrateAndFireTransferFunction.meanClass_vecSize_set
    __swig_getmethods__["vecSize"] = _CIntegrateAndFireTransferFunction.meanClass_vecSize_get
    if _newclass:
        vecSize = _swig_property(_CIntegrateAndFireTransferFunction.meanClass_vecSize_get, _CIntegrateAndFireTransferFunction.meanClass_vecSize_set)

    def __call__(self, v):
        return _CIntegrateAndFireTransferFunction.meanClass___call__(self, v)
    __swig_destroy__ = _CIntegrateAndFireTransferFunction.delete_meanClass
    __del__ = lambda self: None
meanClass_swigregister = _CIntegrateAndFireTransferFunction.meanClass_swigregister
meanClass_swigregister(meanClass)


def meanValue(vec):
    return _CIntegrateAndFireTransferFunction.meanValue(vec)
meanValue = _CIntegrateAndFireTransferFunction.meanValue

def stdValue(vec):
    return _CIntegrateAndFireTransferFunction.stdValue(vec)
stdValue = _CIntegrateAndFireTransferFunction.stdValue

def meanVec(vec):
    return _CIntegrateAndFireTransferFunction.meanVec(vec)
meanVec = _CIntegrateAndFireTransferFunction.meanVec

def stdVec(vec):
    return _CIntegrateAndFireTransferFunction.stdVec(vec)
stdVec = _CIntegrateAndFireTransferFunction.stdVec

def findAll_whereValue(vec, value):
    return _CIntegrateAndFireTransferFunction.findAll_whereValue(vec, value)
findAll_whereValue = _CIntegrateAndFireTransferFunction.findAll_whereValue

def findAll_even(vec):
    return _CIntegrateAndFireTransferFunction.findAll_even(vec)
findAll_even = _CIntegrateAndFireTransferFunction.findAll_even

def getPermutations(vec, begin, end):
    return _CIntegrateAndFireTransferFunction.getPermutations(vec, begin, end)
getPermutations = _CIntegrateAndFireTransferFunction.getPermutations

def getRowFromVecVec(vecVec, row):
    return _CIntegrateAndFireTransferFunction.getRowFromVecVec(vecVec, row)
getRowFromVecVec = _CIntegrateAndFireTransferFunction.getRowFromVecVec

def getColFromVecVec(vecVec, col):
    return _CIntegrateAndFireTransferFunction.getColFromVecVec(vecVec, col)
getColFromVecVec = _CIntegrateAndFireTransferFunction.getColFromVecVec

def getRowsFromVecVec(vecVec, rows):
    return _CIntegrateAndFireTransferFunction.getRowsFromVecVec(vecVec, rows)
getRowsFromVecVec = _CIntegrateAndFireTransferFunction.getRowsFromVecVec

def getVecVecFromVecVec(vecVec, rows, cols):
    return _CIntegrateAndFireTransferFunction.getVecVecFromVecVec(vecVec, rows, cols)
getVecVecFromVecVec = _CIntegrateAndFireTransferFunction.getVecVecFromVecVec

def getCombinaisons(permu, size):
    return _CIntegrateAndFireTransferFunction.getCombinaisons(permu, size)
getCombinaisons = _CIntegrateAndFireTransferFunction.getCombinaisons

def whichIndx(name, names):
    return _CIntegrateAndFireTransferFunction.whichIndx(name, names)
whichIndx = _CIntegrateAndFireTransferFunction.whichIndx

def vecSub(*args):
    return _CIntegrateAndFireTransferFunction.vecSub(*args)
vecSub = _CIntegrateAndFireTransferFunction.vecSub

def vecFromSub(A, B):
    return _CIntegrateAndFireTransferFunction.vecFromSub(A, B)
vecFromSub = _CIntegrateAndFireTransferFunction.vecFromSub

def vecMul(*args):
    return _CIntegrateAndFireTransferFunction.vecMul(*args)
vecMul = _CIntegrateAndFireTransferFunction.vecMul

def vecVecAdd(A, B):
    return _CIntegrateAndFireTransferFunction.vecVecAdd(A, B)
vecVecAdd = _CIntegrateAndFireTransferFunction.vecVecAdd

def range(start, end, step):
    return _CIntegrateAndFireTransferFunction.range(start, end, step)
range = _CIntegrateAndFireTransferFunction.range

def arange(start, end, step):
    return _CIntegrateAndFireTransferFunction.arange(start, end, step)
arange = _CIntegrateAndFireTransferFunction.arange

def vecOnes(sizeVec):
    return _CIntegrateAndFireTransferFunction.vecOnes(sizeVec)
vecOnes = _CIntegrateAndFireTransferFunction.vecOnes

def vecZeros(sizeVec):
    return _CIntegrateAndFireTransferFunction.vecZeros(sizeVec)
vecZeros = _CIntegrateAndFireTransferFunction.vecZeros

def vecVecOnes(sizeVec):
    return _CIntegrateAndFireTransferFunction.vecVecOnes(sizeVec)
vecVecOnes = _CIntegrateAndFireTransferFunction.vecVecOnes

def vecVecZeros(sizeVec):
    return _CIntegrateAndFireTransferFunction.vecVecZeros(sizeVec)
vecVecZeros = _CIntegrateAndFireTransferFunction.vecVecZeros
class doublecomplex(_object):
    __swig_setmethods__ = {}
    __setattr__ = lambda self, name, value: _swig_setattr(self, doublecomplex, name, value)
    __swig_getmethods__ = {}
    __getattr__ = lambda self, name: _swig_getattr(self, doublecomplex, name)
    __repr__ = _swig_repr
    __swig_setmethods__["r"] = _CIntegrateAndFireTransferFunction.doublecomplex_r_set
    __swig_getmethods__["r"] = _CIntegrateAndFireTransferFunction.doublecomplex_r_get
    if _newclass:
        r = _swig_property(_CIntegrateAndFireTransferFunction.doublecomplex_r_get, _CIntegrateAndFireTransferFunction.doublecomplex_r_set)
    __swig_setmethods__["i"] = _CIntegrateAndFireTransferFunction.doublecomplex_i_set
    __swig_getmethods__["i"] = _CIntegrateAndFireTransferFunction.doublecomplex_i_get
    if _newclass:
        i = _swig_property(_CIntegrateAndFireTransferFunction.doublecomplex_i_get, _CIntegrateAndFireTransferFunction.doublecomplex_i_set)

    def __init__(self):
        this = _CIntegrateAndFireTransferFunction.new_doublecomplex()
        try:
            self.this.append(this)
        except:
            self.this = this
    __swig_destroy__ = _CIntegrateAndFireTransferFunction.delete_doublecomplex
    __del__ = lambda self: None
doublecomplex_swigregister = _CIntegrateAndFireTransferFunction.doublecomplex_swigregister
doublecomplex_swigregister(doublecomplex)

class CIntegrateAndFireTransferFunctionClass(CToolClass):
    __swig_setmethods__ = {}
    for _s in [CToolClass]:
        __swig_setmethods__.update(getattr(_s, '__swig_setmethods__', {}))
    __setattr__ = lambda self, name, value: _swig_setattr(self, CIntegrateAndFireTransferFunctionClass, name, value)
    __swig_getmethods__ = {}
    for _s in [CToolClass]:
        __swig_getmethods__.update(getattr(_s, '__swig_getmethods__', {}))
    __getattr__ = lambda self, name: _swig_getattr(self, CIntegrateAndFireTransferFunctionClass, name)
    __repr__ = _swig_repr

    def __init__(self):
        this = _CIntegrateAndFireTransferFunction.new_CIntegrateAndFireTransferFunctionClass()
        try:
            self.this.append(this)
        except:
            self.this = this

    def computeIntegralUpperBound(self):
        return _CIntegrateAndFireTransferFunction.CIntegrateAndFireTransferFunctionClass_computeIntegralUpperBound(self)

    def computeIntegralLowerBound(self):
        return _CIntegrateAndFireTransferFunction.CIntegrateAndFireTransferFunctionClass_computeIntegralLowerBound(self)

    def getErrorFunction(self, z):
        return _CIntegrateAndFireTransferFunction.CIntegrateAndFireTransferFunctionClass_getErrorFunction(self, z)

    def getLifStationaryRate(self):
        return _CIntegrateAndFireTransferFunction.CIntegrateAndFireTransferFunctionClass_getLifStationaryRate(self)

    def old_gsurg(self, xx, yy):
        return _CIntegrateAndFireTransferFunction.CIntegrateAndFireTransferFunctionClass_old_gsurg(self, xx, yy)

    def old_onefone(self, a, c, z, series, deriv):
        return _CIntegrateAndFireTransferFunction.CIntegrateAndFireTransferFunctionClass_old_onefone(self, a, c, z, series, deriv)

    def old_correctionlargey(self, a, c, z, series):
        return _CIntegrateAndFireTransferFunction.CIntegrateAndFireTransferFunctionClass_old_correctionlargey(self, a, c, z, series)

    def old_u01(self, omc, y, seriesu, indic):
        return _CIntegrateAndFireTransferFunction.CIntegrateAndFireTransferFunctionClass_old_u01(self, omc, y, seriesu, indic)

    def old_u23(self, omc, y, seriesu, indic):
        return _CIntegrateAndFireTransferFunction.CIntegrateAndFireTransferFunctionClass_old_u23(self, omc, y, seriesu, indic)

    def RLIF(self, _omega, i):
        return _CIntegrateAndFireTransferFunction.CIntegrateAndFireTransferFunctionClass_RLIF(self, _omega, i)

    def Complex(self, re, im):
        return _CIntegrateAndFireTransferFunction.CIntegrateAndFireTransferFunctionClass_Complex(self, re, im)

    def Cadd(self, a, b):
        return _CIntegrateAndFireTransferFunction.CIntegrateAndFireTransferFunctionClass_Cadd(self, a, b)

    def Csub(self, a, b):
        return _CIntegrateAndFireTransferFunction.CIntegrateAndFireTransferFunctionClass_Csub(self, a, b)

    def Cmul(self, a, b):
        return _CIntegrateAndFireTransferFunction.CIntegrateAndFireTransferFunctionClass_Cmul(self, a, b)

    def Cdiv(self, a, b):
        return _CIntegrateAndFireTransferFunction.CIntegrateAndFireTransferFunctionClass_Cdiv(self, a, b)

    def Conjg(self, z):
        return _CIntegrateAndFireTransferFunction.CIntegrateAndFireTransferFunctionClass_Conjg(self, z)

    def Csqrt(self, z):
        return _CIntegrateAndFireTransferFunction.CIntegrateAndFireTransferFunctionClass_Csqrt(self, z)

    def myCsqrt(self, z):
        return _CIntegrateAndFireTransferFunction.CIntegrateAndFireTransferFunctionClass_myCsqrt(self, z)

    def Cexp(self, a):
        return _CIntegrateAndFireTransferFunction.CIntegrateAndFireTransferFunctionClass_Cexp(self, a)

    def RCmul(self, x, a):
        return _CIntegrateAndFireTransferFunction.CIntegrateAndFireTransferFunctionClass_RCmul(self, x, a)

    def Cabs(self, z):
        return _CIntegrateAndFireTransferFunction.CIntegrateAndFireTransferFunctionClass_Cabs(self, z)

    def Carg(self, z):
        return _CIntegrateAndFireTransferFunction.CIntegrateAndFireTransferFunctionClass_Carg(self, z)

    def getLifPerturbationNullRate(self, DiffVariable):
        return _CIntegrateAndFireTransferFunction.CIntegrateAndFireTransferFunctionClass_getLifPerturbationNullRate(self, DiffVariable)

    def gsurg(self, xx, yy):
        return _CIntegrateAndFireTransferFunction.CIntegrateAndFireTransferFunctionClass_gsurg(self, xx, yy)

    def onefone(self, a, c, z, series, deriv):
        return _CIntegrateAndFireTransferFunction.CIntegrateAndFireTransferFunctionClass_onefone(self, a, c, z, series, deriv)

    def correctionlargey(self, a, c, z, series):
        return _CIntegrateAndFireTransferFunction.CIntegrateAndFireTransferFunctionClass_correctionlargey(self, a, c, z, series)

    def u01(self, omc, y, seriesu, indic):
        return _CIntegrateAndFireTransferFunction.CIntegrateAndFireTransferFunctionClass_u01(self, omc, y, seriesu, indic)

    def u23(self, omc, y, seriesu, indic):
        return _CIntegrateAndFireTransferFunction.CIntegrateAndFireTransferFunctionClass_u23(self, omc, y, seriesu, indic)

    def setBrunelLifPerturbationRate(self, arg2):
        return _CIntegrateAndFireTransferFunction.CIntegrateAndFireTransferFunctionClass_setBrunelLifPerturbationRate(self, arg2)

    def inside_integ(self, x):
        return _CIntegrateAndFireTransferFunction.CIntegrateAndFireTransferFunctionClass_inside_integ(self, x)
    __swig_setmethods__["deriv"] = _CIntegrateAndFireTransferFunction.CIntegrateAndFireTransferFunctionClass_deriv_set
    __swig_getmethods__["deriv"] = _CIntegrateAndFireTransferFunction.CIntegrateAndFireTransferFunctionClass_deriv_get
    if _newclass:
        deriv = _swig_property(_CIntegrateAndFireTransferFunction.CIntegrateAndFireTransferFunctionClass_deriv_get, _CIntegrateAndFireTransferFunction.CIntegrateAndFireTransferFunctionClass_deriv_set)

    def phi_derivs(self, y, phi, dphi, lamda):
        return _CIntegrateAndFireTransferFunction.CIntegrateAndFireTransferFunctionClass_phi_derivs(self, y, phi, dphi, lamda)

    def phi_t_derivs(self, y, phi, dphi, lamda):
        return _CIntegrateAndFireTransferFunction.CIntegrateAndFireTransferFunctionClass_phi_t_derivs(self, y, phi, dphi, lamda)

    def rkck(self, y, dydx, x, h, yout, yerr, lamda, derivs):
        return _CIntegrateAndFireTransferFunction.CIntegrateAndFireTransferFunctionClass_rkck(self, y, dydx, x, h, yout, yerr, lamda, derivs)

    def rkqs(self, y, dydx, x, htry, eps, yscal, hdid, hnext, lamda, derivs):
        return _CIntegrateAndFireTransferFunction.CIntegrateAndFireTransferFunctionClass_rkqs(self, y, dydx, x, htry, eps, yscal, hdid, hnext, lamda, derivs)

    def odeint(self, ystart, x1, x2, eps, h1, hmin, lamda, derivs):
        return _CIntegrateAndFireTransferFunction.CIntegrateAndFireTransferFunctionClass_odeint(self, ystart, x1, x2, eps, h1, hmin, lamda, derivs)

    def phi_t_rka(self, y, lamda, phi_pr):
        return _CIntegrateAndFireTransferFunction.CIntegrateAndFireTransferFunctionClass_phi_t_rka(self, y, lamda, phi_pr)

    def setHakimLifPerturbationRate(self, lamda):
        return _CIntegrateAndFireTransferFunction.CIntegrateAndFireTransferFunctionClass_setHakimLifPerturbationRate(self, lamda)
    __swig_destroy__ = _CIntegrateAndFireTransferFunction.delete_CIntegrateAndFireTransferFunctionClass
    __del__ = lambda self: None
CIntegrateAndFireTransferFunctionClass_swigregister = _CIntegrateAndFireTransferFunction.CIntegrateAndFireTransferFunctionClass_swigregister
CIntegrateAndFireTransferFunctionClass_swigregister(CIntegrateAndFireTransferFunctionClass)

# This file is compatible with both classic and new-style classes.


