# 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('_CTool', [dirname(__file__)])
        except ImportError:
            import _CTool
            return _CTool
        if fp is not None:
            try:
                _mod = imp.load_module('_CTool', fp, pathname, description)
            finally:
                fp.close()
            return _mod
    _CTool = swig_import_helper()
    del swig_import_helper
else:
    import _CTool
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__ = _CTool.delete_SwigPyIterator
    __del__ = lambda self: None

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

    def __sub__(self, *args):
        return _CTool.SwigPyIterator___sub__(self, *args)
    def __iter__(self):
        return self
SwigPyIterator_swigregister = _CTool.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 _CTool.IntVector_iterator(self)
    def __iter__(self):
        return self.iterator()

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

    def capacity(self):
        return _CTool.IntVector_capacity(self)
    __swig_destroy__ = _CTool.delete_IntVector
    __del__ = lambda self: None
IntVector_swigregister = _CTool.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 _CTool.DoubleVector_iterator(self)
    def __iter__(self):
        return self.iterator()

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

    def capacity(self):
        return _CTool.DoubleVector_capacity(self)
    __swig_destroy__ = _CTool.delete_DoubleVector
    __del__ = lambda self: None
DoubleVector_swigregister = _CTool.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 _CTool.DoubleVectorVector_iterator(self)
    def __iter__(self):
        return self.iterator()

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

    def capacity(self):
        return _CTool.DoubleVectorVector_capacity(self)
    __swig_destroy__ = _CTool.delete_DoubleVectorVector
    __del__ = lambda self: None
DoubleVectorVector_swigregister = _CTool.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 _CTool.StringVector_iterator(self)
    def __iter__(self):
        return self.iterator()

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

    def capacity(self):
        return _CTool.StringVector_capacity(self)
    __swig_destroy__ = _CTool.delete_StringVector
    __del__ = lambda self: None
StringVector_swigregister = _CTool.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 _CTool.MapStringInt_iterator(self)
    def __iter__(self):
        return self.iterator()

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

    def upper_bound(self, x):
        return _CTool.MapStringInt_upper_bound(self, x)
    __swig_destroy__ = _CTool.delete_MapStringInt
    __del__ = lambda self: None
MapStringInt_swigregister = _CTool.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 _CTool.MapStringString_iterator(self)
    def __iter__(self):
        return self.iterator()

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

    def upper_bound(self, x):
        return _CTool.MapStringString_upper_bound(self, x)
    __swig_destroy__ = _CTool.delete_MapStringString
    __del__ = lambda self: None
MapStringString_swigregister = _CTool.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 _CTool.MapStringDouble_iterator(self)
    def __iter__(self):
        return self.iterator()

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

    def upper_bound(self, x):
        return _CTool.MapStringDouble_upper_bound(self, x)
    __swig_destroy__ = _CTool.delete_MapStringDouble
    __del__ = lambda self: None
MapStringDouble_swigregister = _CTool.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 _CTool.MapStringComplexDouble_iterator(self)
    def __iter__(self):
        return self.iterator()

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

    def upper_bound(self, x):
        return _CTool.MapStringComplexDouble_upper_bound(self, x)
    __swig_destroy__ = _CTool.delete_MapStringComplexDouble
    __del__ = lambda self: None
MapStringComplexDouble_swigregister = _CTool.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"] = _CTool.CToolClass_ComplexDict_set
    __swig_getmethods__["ComplexDict"] = _CTool.CToolClass_ComplexDict_get
    if _newclass:
        ComplexDict = _swig_property(_CTool.CToolClass_ComplexDict_get, _CTool.CToolClass_ComplexDict_set)
    __swig_setmethods__["DoubleDict"] = _CTool.CToolClass_DoubleDict_set
    __swig_getmethods__["DoubleDict"] = _CTool.CToolClass_DoubleDict_get
    if _newclass:
        DoubleDict = _swig_property(_CTool.CToolClass_DoubleDict_get, _CTool.CToolClass_DoubleDict_set)
    __swig_setmethods__["IntDict"] = _CTool.CToolClass_IntDict_set
    __swig_getmethods__["IntDict"] = _CTool.CToolClass_IntDict_get
    if _newclass:
        IntDict = _swig_property(_CTool.CToolClass_IntDict_get, _CTool.CToolClass_IntDict_set)
    __swig_setmethods__["StringDict"] = _CTool.CToolClass_StringDict_set
    __swig_getmethods__["StringDict"] = _CTool.CToolClass_StringDict_get
    if _newclass:
        StringDict = _swig_property(_CTool.CToolClass_StringDict_get, _CTool.CToolClass_StringDict_set)

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

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


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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

def printArrayInt(vec):
    return _CTool.printArrayInt(vec)
printArrayInt = _CTool.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 = _CTool.new_isEqualValue(_value)
        try:
            self.this.append(this)
        except:
            self.this = this

    def __call__(self, x):
        return _CTool.isEqualValue___call__(self, x)
    __swig_destroy__ = _CTool.delete_isEqualValue
    __del__ = lambda self: None
isEqualValue_swigregister = _CTool.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 _CTool.isEven___call__(self, x)

    def __init__(self):
        this = _CTool.new_isEven()
        try:
            self.this.append(this)
        except:
            self.this = this
    __swig_destroy__ = _CTool.delete_isEven
    __del__ = lambda self: None
isEven_swigregister = _CTool.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 _CTool.isOdd___call__(self, x)

    def __init__(self):
        this = _CTool.new_isOdd()
        try:
            self.this.append(this)
        except:
            self.this = this
    __swig_destroy__ = _CTool.delete_isOdd
    __del__ = lambda self: None
isOdd_swigregister = _CTool.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 = _CTool.new_meanClass(_vecSize)
        try:
            self.this.append(this)
        except:
            self.this = this
    __swig_setmethods__["meanValue"] = _CTool.meanClass_meanValue_set
    __swig_getmethods__["meanValue"] = _CTool.meanClass_meanValue_get
    if _newclass:
        meanValue = _swig_property(_CTool.meanClass_meanValue_get, _CTool.meanClass_meanValue_set)
    __swig_setmethods__["vecSize"] = _CTool.meanClass_vecSize_set
    __swig_getmethods__["vecSize"] = _CTool.meanClass_vecSize_get
    if _newclass:
        vecSize = _swig_property(_CTool.meanClass_vecSize_get, _CTool.meanClass_vecSize_set)

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


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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

def vecVecZeros(sizeVec):
    return _CTool.vecVecZeros(sizeVec)
vecVecZeros = _CTool.vecVecZeros
# This file is compatible with both classic and new-style classes.


