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

from sys import version_info as _swig_python_version_info
if _swig_python_version_info >= (2, 7, 0):
    def swig_import_helper():
        import importlib
        pkg = __name__.rpartition('.')[0]
        mname = '.'.join((pkg, '_IOHprofiler')).lstrip('.')
        try:
            return importlib.import_module(mname)
        except ImportError:
            return importlib.import_module('_IOHprofiler')
    _IOHprofiler = swig_import_helper()
    del swig_import_helper
elif _swig_python_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('_IOHprofiler', [dirname(__file__)])
        except ImportError:
            import _IOHprofiler
            return _IOHprofiler
        try:
            _mod = imp.load_module('_IOHprofiler', fp, pathname, description)
        finally:
            if fp is not None:
                fp.close()
        return _mod
    _IOHprofiler = swig_import_helper()
    del swig_import_helper
else:
    import _IOHprofiler
del _swig_python_version_info

try:
    _swig_property = property
except NameError:
    pass  # Python < 2.2 doesn't have 'property'.

try:
    import builtins as __builtin__
except ImportError:
    import __builtin__

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(self, class_type, name):
    if (name == "thisown"):
        return self.this.own()
    method = class_type.__swig_getmethods__.get(name, None)
    if method:
        return method(self)
    raise AttributeError("'%s' object has no attribute '%s'" % (class_type.__name__, name))


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

try:
    _object = object
    _newclass = 1
except __builtin__.Exception:
    class _object:
        pass
    _newclass = 0

SHARED_PTR_DISOWN = _IOHprofiler.SHARED_PTR_DISOWN
class SwigPyIterator(_object):
    """Proxy of C++ swig::SwigPyIterator class."""

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

    def value(self):
        """
        value(self) -> PyObject *

        Parameters
        ----------
        self: swig::SwigPyIterator const *

        """
        return _IOHprofiler.SwigPyIterator_value(self)


    def incr(self, n=1):
        """
        incr(self, n=1) -> SwigPyIterator

        Parameters
        ----------
        n: size_t

        incr(self) -> SwigPyIterator

        Parameters
        ----------
        self: swig::SwigPyIterator *

        """
        return _IOHprofiler.SwigPyIterator_incr(self, n)


    def decr(self, n=1):
        """
        decr(self, n=1) -> SwigPyIterator

        Parameters
        ----------
        n: size_t

        decr(self) -> SwigPyIterator

        Parameters
        ----------
        self: swig::SwigPyIterator *

        """
        return _IOHprofiler.SwigPyIterator_decr(self, n)


    def distance(self, x):
        """
        distance(self, x) -> ptrdiff_t

        Parameters
        ----------
        x: swig::SwigPyIterator const &

        """
        return _IOHprofiler.SwigPyIterator_distance(self, x)


    def equal(self, x):
        """
        equal(self, x) -> bool

        Parameters
        ----------
        x: swig::SwigPyIterator const &

        """
        return _IOHprofiler.SwigPyIterator_equal(self, x)


    def copy(self):
        """
        copy(self) -> SwigPyIterator

        Parameters
        ----------
        self: swig::SwigPyIterator const *

        """
        return _IOHprofiler.SwigPyIterator_copy(self)


    def next(self):
        """
        next(self) -> PyObject *

        Parameters
        ----------
        self: swig::SwigPyIterator *

        """
        return _IOHprofiler.SwigPyIterator_next(self)


    def __next__(self):
        """
        __next__(self) -> PyObject *

        Parameters
        ----------
        self: swig::SwigPyIterator *

        """
        return _IOHprofiler.SwigPyIterator___next__(self)


    def previous(self):
        """
        previous(self) -> PyObject *

        Parameters
        ----------
        self: swig::SwigPyIterator *

        """
        return _IOHprofiler.SwigPyIterator_previous(self)


    def advance(self, n):
        """
        advance(self, n) -> SwigPyIterator

        Parameters
        ----------
        n: ptrdiff_t

        """
        return _IOHprofiler.SwigPyIterator_advance(self, n)


    def __eq__(self, x):
        """
        __eq__(self, x) -> bool

        Parameters
        ----------
        x: swig::SwigPyIterator const &

        """
        return _IOHprofiler.SwigPyIterator___eq__(self, x)


    def __ne__(self, x):
        """
        __ne__(self, x) -> bool

        Parameters
        ----------
        x: swig::SwigPyIterator const &

        """
        return _IOHprofiler.SwigPyIterator___ne__(self, x)


    def __iadd__(self, n):
        """
        __iadd__(self, n) -> SwigPyIterator

        Parameters
        ----------
        n: ptrdiff_t

        """
        return _IOHprofiler.SwigPyIterator___iadd__(self, n)


    def __isub__(self, n):
        """
        __isub__(self, n) -> SwigPyIterator

        Parameters
        ----------
        n: ptrdiff_t

        """
        return _IOHprofiler.SwigPyIterator___isub__(self, n)


    def __add__(self, n):
        """
        __add__(self, n) -> SwigPyIterator

        Parameters
        ----------
        n: ptrdiff_t

        """
        return _IOHprofiler.SwigPyIterator___add__(self, n)


    def __sub__(self, *args):
        """
        __sub__(self, n) -> SwigPyIterator

        Parameters
        ----------
        n: ptrdiff_t

        __sub__(self, x) -> ptrdiff_t

        Parameters
        ----------
        x: swig::SwigPyIterator const &

        """
        return _IOHprofiler.SwigPyIterator___sub__(self, *args)

    def __iter__(self):
        return self
SwigPyIterator_swigregister = _IOHprofiler.SwigPyIterator_swigregister
SwigPyIterator_swigregister(SwigPyIterator)

class intvec(_object):
    """Proxy of C++ std::vector<(int)> class."""

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

    def iterator(self):
        """
        iterator(self) -> SwigPyIterator

        Parameters
        ----------
        self: std::vector< int > *

        """
        return _IOHprofiler.intvec_iterator(self)

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

    def __nonzero__(self):
        """
        __nonzero__(self) -> bool

        Parameters
        ----------
        self: std::vector< int > const *

        """
        return _IOHprofiler.intvec___nonzero__(self)


    def __bool__(self):
        """
        __bool__(self) -> bool

        Parameters
        ----------
        self: std::vector< int > const *

        """
        return _IOHprofiler.intvec___bool__(self)


    def __len__(self):
        """
        __len__(self) -> std::vector< int >::size_type

        Parameters
        ----------
        self: std::vector< int > const *

        """
        return _IOHprofiler.intvec___len__(self)


    def __getslice__(self, i, j):
        """
        __getslice__(self, i, j) -> intvec

        Parameters
        ----------
        i: std::vector< int >::difference_type
        j: std::vector< int >::difference_type

        """
        return _IOHprofiler.intvec___getslice__(self, i, j)


    def __setslice__(self, *args):
        """
        __setslice__(self, i, j)

        Parameters
        ----------
        i: std::vector< int >::difference_type
        j: std::vector< int >::difference_type

        __setslice__(self, i, j, v)

        Parameters
        ----------
        i: std::vector< int >::difference_type
        j: std::vector< int >::difference_type
        v: std::vector< int,std::allocator< int > > const &

        """
        return _IOHprofiler.intvec___setslice__(self, *args)


    def __delslice__(self, i, j):
        """
        __delslice__(self, i, j)

        Parameters
        ----------
        i: std::vector< int >::difference_type
        j: std::vector< int >::difference_type

        """
        return _IOHprofiler.intvec___delslice__(self, i, j)


    def __delitem__(self, *args):
        """
        __delitem__(self, i)

        Parameters
        ----------
        i: std::vector< int >::difference_type

        __delitem__(self, slice)

        Parameters
        ----------
        slice: PySliceObject *

        """
        return _IOHprofiler.intvec___delitem__(self, *args)


    def __getitem__(self, *args):
        """
        __getitem__(self, slice) -> intvec

        Parameters
        ----------
        slice: PySliceObject *

        __getitem__(self, i) -> std::vector< int >::value_type const &

        Parameters
        ----------
        i: std::vector< int >::difference_type

        """
        return _IOHprofiler.intvec___getitem__(self, *args)


    def __setitem__(self, *args):
        """
        __setitem__(self, slice, v)

        Parameters
        ----------
        slice: PySliceObject *
        v: std::vector< int,std::allocator< int > > const &

        __setitem__(self, slice)

        Parameters
        ----------
        slice: PySliceObject *

        __setitem__(self, i, x)

        Parameters
        ----------
        i: std::vector< int >::difference_type
        x: std::vector< int >::value_type const &

        """
        return _IOHprofiler.intvec___setitem__(self, *args)


    def pop(self):
        """
        pop(self) -> std::vector< int >::value_type

        Parameters
        ----------
        self: std::vector< int > *

        """
        return _IOHprofiler.intvec_pop(self)


    def append(self, x):
        """
        append(self, x)

        Parameters
        ----------
        x: std::vector< int >::value_type const &

        """
        return _IOHprofiler.intvec_append(self, x)


    def empty(self):
        """
        empty(self) -> bool

        Parameters
        ----------
        self: std::vector< int > const *

        """
        return _IOHprofiler.intvec_empty(self)


    def size(self):
        """
        size(self) -> std::vector< int >::size_type

        Parameters
        ----------
        self: std::vector< int > const *

        """
        return _IOHprofiler.intvec_size(self)


    def swap(self, v):
        """
        swap(self, v)

        Parameters
        ----------
        v: std::vector< int > &

        """
        return _IOHprofiler.intvec_swap(self, v)


    def begin(self):
        """
        begin(self) -> std::vector< int >::iterator

        Parameters
        ----------
        self: std::vector< int > *

        """
        return _IOHprofiler.intvec_begin(self)


    def end(self):
        """
        end(self) -> std::vector< int >::iterator

        Parameters
        ----------
        self: std::vector< int > *

        """
        return _IOHprofiler.intvec_end(self)


    def rbegin(self):
        """
        rbegin(self) -> std::vector< int >::reverse_iterator

        Parameters
        ----------
        self: std::vector< int > *

        """
        return _IOHprofiler.intvec_rbegin(self)


    def rend(self):
        """
        rend(self) -> std::vector< int >::reverse_iterator

        Parameters
        ----------
        self: std::vector< int > *

        """
        return _IOHprofiler.intvec_rend(self)


    def clear(self):
        """
        clear(self)

        Parameters
        ----------
        self: std::vector< int > *

        """
        return _IOHprofiler.intvec_clear(self)


    def get_allocator(self):
        """
        get_allocator(self) -> std::vector< int >::allocator_type

        Parameters
        ----------
        self: std::vector< int > const *

        """
        return _IOHprofiler.intvec_get_allocator(self)


    def pop_back(self):
        """
        pop_back(self)

        Parameters
        ----------
        self: std::vector< int > *

        """
        return _IOHprofiler.intvec_pop_back(self)


    def erase(self, *args):
        """
        erase(self, pos) -> std::vector< int >::iterator

        Parameters
        ----------
        pos: std::vector< int >::iterator

        erase(self, first, last) -> std::vector< int >::iterator

        Parameters
        ----------
        first: std::vector< int >::iterator
        last: std::vector< int >::iterator

        """
        return _IOHprofiler.intvec_erase(self, *args)


    def __init__(self, *args):
        """
        __init__(self) -> intvec
        __init__(self, arg2) -> intvec

        Parameters
        ----------
        arg2: std::vector< int > const &

        __init__(self, size) -> intvec

        Parameters
        ----------
        size: std::vector< int >::size_type

        __init__(self, size, value) -> intvec

        Parameters
        ----------
        size: std::vector< int >::size_type
        value: std::vector< int >::value_type const &

        """
        this = _IOHprofiler.new_intvec(*args)
        try:
            self.this.append(this)
        except __builtin__.Exception:
            self.this = this

    def push_back(self, x):
        """
        push_back(self, x)

        Parameters
        ----------
        x: std::vector< int >::value_type const &

        """
        return _IOHprofiler.intvec_push_back(self, x)


    def front(self):
        """
        front(self) -> std::vector< int >::value_type const &

        Parameters
        ----------
        self: std::vector< int > const *

        """
        return _IOHprofiler.intvec_front(self)


    def back(self):
        """
        back(self) -> std::vector< int >::value_type const &

        Parameters
        ----------
        self: std::vector< int > const *

        """
        return _IOHprofiler.intvec_back(self)


    def assign(self, n, x):
        """
        assign(self, n, x)

        Parameters
        ----------
        n: std::vector< int >::size_type
        x: std::vector< int >::value_type const &

        """
        return _IOHprofiler.intvec_assign(self, n, x)


    def resize(self, *args):
        """
        resize(self, new_size)

        Parameters
        ----------
        new_size: std::vector< int >::size_type

        resize(self, new_size, x)

        Parameters
        ----------
        new_size: std::vector< int >::size_type
        x: std::vector< int >::value_type const &

        """
        return _IOHprofiler.intvec_resize(self, *args)


    def insert(self, *args):
        """
        insert(self, pos, x) -> std::vector< int >::iterator

        Parameters
        ----------
        pos: std::vector< int >::iterator
        x: std::vector< int >::value_type const &

        insert(self, pos, n, x)

        Parameters
        ----------
        pos: std::vector< int >::iterator
        n: std::vector< int >::size_type
        x: std::vector< int >::value_type const &

        """
        return _IOHprofiler.intvec_insert(self, *args)


    def reserve(self, n):
        """
        reserve(self, n)

        Parameters
        ----------
        n: std::vector< int >::size_type

        """
        return _IOHprofiler.intvec_reserve(self, n)


    def capacity(self):
        """
        capacity(self) -> std::vector< int >::size_type

        Parameters
        ----------
        self: std::vector< int > const *

        """
        return _IOHprofiler.intvec_capacity(self)

    __swig_destroy__ = _IOHprofiler.delete_intvec
    __del__ = lambda self: None
intvec_swigregister = _IOHprofiler.intvec_swigregister
intvec_swigregister(intvec)

class doublevec(_object):
    """Proxy of C++ std::vector<(double)> class."""

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

    def iterator(self):
        """
        iterator(self) -> SwigPyIterator

        Parameters
        ----------
        self: std::vector< double > *

        """
        return _IOHprofiler.doublevec_iterator(self)

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

    def __nonzero__(self):
        """
        __nonzero__(self) -> bool

        Parameters
        ----------
        self: std::vector< double > const *

        """
        return _IOHprofiler.doublevec___nonzero__(self)


    def __bool__(self):
        """
        __bool__(self) -> bool

        Parameters
        ----------
        self: std::vector< double > const *

        """
        return _IOHprofiler.doublevec___bool__(self)


    def __len__(self):
        """
        __len__(self) -> std::vector< double >::size_type

        Parameters
        ----------
        self: std::vector< double > const *

        """
        return _IOHprofiler.doublevec___len__(self)


    def __getslice__(self, i, j):
        """
        __getslice__(self, i, j) -> doublevec

        Parameters
        ----------
        i: std::vector< double >::difference_type
        j: std::vector< double >::difference_type

        """
        return _IOHprofiler.doublevec___getslice__(self, i, j)


    def __setslice__(self, *args):
        """
        __setslice__(self, i, j)

        Parameters
        ----------
        i: std::vector< double >::difference_type
        j: std::vector< double >::difference_type

        __setslice__(self, i, j, v)

        Parameters
        ----------
        i: std::vector< double >::difference_type
        j: std::vector< double >::difference_type
        v: std::vector< double,std::allocator< double > > const &

        """
        return _IOHprofiler.doublevec___setslice__(self, *args)


    def __delslice__(self, i, j):
        """
        __delslice__(self, i, j)

        Parameters
        ----------
        i: std::vector< double >::difference_type
        j: std::vector< double >::difference_type

        """
        return _IOHprofiler.doublevec___delslice__(self, i, j)


    def __delitem__(self, *args):
        """
        __delitem__(self, i)

        Parameters
        ----------
        i: std::vector< double >::difference_type

        __delitem__(self, slice)

        Parameters
        ----------
        slice: PySliceObject *

        """
        return _IOHprofiler.doublevec___delitem__(self, *args)


    def __getitem__(self, *args):
        """
        __getitem__(self, slice) -> doublevec

        Parameters
        ----------
        slice: PySliceObject *

        __getitem__(self, i) -> std::vector< double >::value_type const &

        Parameters
        ----------
        i: std::vector< double >::difference_type

        """
        return _IOHprofiler.doublevec___getitem__(self, *args)


    def __setitem__(self, *args):
        """
        __setitem__(self, slice, v)

        Parameters
        ----------
        slice: PySliceObject *
        v: std::vector< double,std::allocator< double > > const &

        __setitem__(self, slice)

        Parameters
        ----------
        slice: PySliceObject *

        __setitem__(self, i, x)

        Parameters
        ----------
        i: std::vector< double >::difference_type
        x: std::vector< double >::value_type const &

        """
        return _IOHprofiler.doublevec___setitem__(self, *args)


    def pop(self):
        """
        pop(self) -> std::vector< double >::value_type

        Parameters
        ----------
        self: std::vector< double > *

        """
        return _IOHprofiler.doublevec_pop(self)


    def append(self, x):
        """
        append(self, x)

        Parameters
        ----------
        x: std::vector< double >::value_type const &

        """
        return _IOHprofiler.doublevec_append(self, x)


    def empty(self):
        """
        empty(self) -> bool

        Parameters
        ----------
        self: std::vector< double > const *

        """
        return _IOHprofiler.doublevec_empty(self)


    def size(self):
        """
        size(self) -> std::vector< double >::size_type

        Parameters
        ----------
        self: std::vector< double > const *

        """
        return _IOHprofiler.doublevec_size(self)


    def swap(self, v):
        """
        swap(self, v)

        Parameters
        ----------
        v: std::vector< double > &

        """
        return _IOHprofiler.doublevec_swap(self, v)


    def begin(self):
        """
        begin(self) -> std::vector< double >::iterator

        Parameters
        ----------
        self: std::vector< double > *

        """
        return _IOHprofiler.doublevec_begin(self)


    def end(self):
        """
        end(self) -> std::vector< double >::iterator

        Parameters
        ----------
        self: std::vector< double > *

        """
        return _IOHprofiler.doublevec_end(self)


    def rbegin(self):
        """
        rbegin(self) -> std::vector< double >::reverse_iterator

        Parameters
        ----------
        self: std::vector< double > *

        """
        return _IOHprofiler.doublevec_rbegin(self)


    def rend(self):
        """
        rend(self) -> std::vector< double >::reverse_iterator

        Parameters
        ----------
        self: std::vector< double > *

        """
        return _IOHprofiler.doublevec_rend(self)


    def clear(self):
        """
        clear(self)

        Parameters
        ----------
        self: std::vector< double > *

        """
        return _IOHprofiler.doublevec_clear(self)


    def get_allocator(self):
        """
        get_allocator(self) -> std::vector< double >::allocator_type

        Parameters
        ----------
        self: std::vector< double > const *

        """
        return _IOHprofiler.doublevec_get_allocator(self)


    def pop_back(self):
        """
        pop_back(self)

        Parameters
        ----------
        self: std::vector< double > *

        """
        return _IOHprofiler.doublevec_pop_back(self)


    def erase(self, *args):
        """
        erase(self, pos) -> std::vector< double >::iterator

        Parameters
        ----------
        pos: std::vector< double >::iterator

        erase(self, first, last) -> std::vector< double >::iterator

        Parameters
        ----------
        first: std::vector< double >::iterator
        last: std::vector< double >::iterator

        """
        return _IOHprofiler.doublevec_erase(self, *args)


    def __init__(self, *args):
        """
        __init__(self) -> doublevec
        __init__(self, arg2) -> doublevec

        Parameters
        ----------
        arg2: std::vector< double > const &

        __init__(self, size) -> doublevec

        Parameters
        ----------
        size: std::vector< double >::size_type

        __init__(self, size, value) -> doublevec

        Parameters
        ----------
        size: std::vector< double >::size_type
        value: std::vector< double >::value_type const &

        """
        this = _IOHprofiler.new_doublevec(*args)
        try:
            self.this.append(this)
        except __builtin__.Exception:
            self.this = this

    def push_back(self, x):
        """
        push_back(self, x)

        Parameters
        ----------
        x: std::vector< double >::value_type const &

        """
        return _IOHprofiler.doublevec_push_back(self, x)


    def front(self):
        """
        front(self) -> std::vector< double >::value_type const &

        Parameters
        ----------
        self: std::vector< double > const *

        """
        return _IOHprofiler.doublevec_front(self)


    def back(self):
        """
        back(self) -> std::vector< double >::value_type const &

        Parameters
        ----------
        self: std::vector< double > const *

        """
        return _IOHprofiler.doublevec_back(self)


    def assign(self, n, x):
        """
        assign(self, n, x)

        Parameters
        ----------
        n: std::vector< double >::size_type
        x: std::vector< double >::value_type const &

        """
        return _IOHprofiler.doublevec_assign(self, n, x)


    def resize(self, *args):
        """
        resize(self, new_size)

        Parameters
        ----------
        new_size: std::vector< double >::size_type

        resize(self, new_size, x)

        Parameters
        ----------
        new_size: std::vector< double >::size_type
        x: std::vector< double >::value_type const &

        """
        return _IOHprofiler.doublevec_resize(self, *args)


    def insert(self, *args):
        """
        insert(self, pos, x) -> std::vector< double >::iterator

        Parameters
        ----------
        pos: std::vector< double >::iterator
        x: std::vector< double >::value_type const &

        insert(self, pos, n, x)

        Parameters
        ----------
        pos: std::vector< double >::iterator
        n: std::vector< double >::size_type
        x: std::vector< double >::value_type const &

        """
        return _IOHprofiler.doublevec_insert(self, *args)


    def reserve(self, n):
        """
        reserve(self, n)

        Parameters
        ----------
        n: std::vector< double >::size_type

        """
        return _IOHprofiler.doublevec_reserve(self, n)


    def capacity(self):
        """
        capacity(self) -> std::vector< double >::size_type

        Parameters
        ----------
        self: std::vector< double > const *

        """
        return _IOHprofiler.doublevec_capacity(self)

    __swig_destroy__ = _IOHprofiler.delete_doublevec
    __del__ = lambda self: None
doublevec_swigregister = _IOHprofiler.doublevec_swigregister
doublevec_swigregister(doublevec)

class stringvec(_object):
    """Proxy of C++ std::vector<(std::string)> class."""

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

    def iterator(self):
        """
        iterator(self) -> SwigPyIterator

        Parameters
        ----------
        self: std::vector< std::string > *

        """
        return _IOHprofiler.stringvec_iterator(self)

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

    def __nonzero__(self):
        """
        __nonzero__(self) -> bool

        Parameters
        ----------
        self: std::vector< std::string > const *

        """
        return _IOHprofiler.stringvec___nonzero__(self)


    def __bool__(self):
        """
        __bool__(self) -> bool

        Parameters
        ----------
        self: std::vector< std::string > const *

        """
        return _IOHprofiler.stringvec___bool__(self)


    def __len__(self):
        """
        __len__(self) -> std::vector< std::string >::size_type

        Parameters
        ----------
        self: std::vector< std::string > const *

        """
        return _IOHprofiler.stringvec___len__(self)


    def __getslice__(self, i, j):
        """
        __getslice__(self, i, j) -> stringvec

        Parameters
        ----------
        i: std::vector< std::string >::difference_type
        j: std::vector< std::string >::difference_type

        """
        return _IOHprofiler.stringvec___getslice__(self, i, j)


    def __setslice__(self, *args):
        """
        __setslice__(self, i, j)

        Parameters
        ----------
        i: std::vector< std::string >::difference_type
        j: std::vector< std::string >::difference_type

        __setslice__(self, i, j, v)

        Parameters
        ----------
        i: std::vector< std::string >::difference_type
        j: std::vector< std::string >::difference_type
        v: std::vector< std::string,std::allocator< std::string > > const &

        """
        return _IOHprofiler.stringvec___setslice__(self, *args)


    def __delslice__(self, i, j):
        """
        __delslice__(self, i, j)

        Parameters
        ----------
        i: std::vector< std::string >::difference_type
        j: std::vector< std::string >::difference_type

        """
        return _IOHprofiler.stringvec___delslice__(self, i, j)


    def __delitem__(self, *args):
        """
        __delitem__(self, i)

        Parameters
        ----------
        i: std::vector< std::string >::difference_type

        __delitem__(self, slice)

        Parameters
        ----------
        slice: PySliceObject *

        """
        return _IOHprofiler.stringvec___delitem__(self, *args)


    def __getitem__(self, *args):
        """
        __getitem__(self, slice) -> stringvec

        Parameters
        ----------
        slice: PySliceObject *

        __getitem__(self, i) -> std::vector< std::string >::value_type const &

        Parameters
        ----------
        i: std::vector< std::string >::difference_type

        """
        return _IOHprofiler.stringvec___getitem__(self, *args)


    def __setitem__(self, *args):
        """
        __setitem__(self, slice, v)

        Parameters
        ----------
        slice: PySliceObject *
        v: std::vector< std::string,std::allocator< std::string > > const &

        __setitem__(self, slice)

        Parameters
        ----------
        slice: PySliceObject *

        __setitem__(self, i, x)

        Parameters
        ----------
        i: std::vector< std::string >::difference_type
        x: std::vector< std::string >::value_type const &

        """
        return _IOHprofiler.stringvec___setitem__(self, *args)


    def pop(self):
        """
        pop(self) -> std::vector< std::string >::value_type

        Parameters
        ----------
        self: std::vector< std::string > *

        """
        return _IOHprofiler.stringvec_pop(self)


    def append(self, x):
        """
        append(self, x)

        Parameters
        ----------
        x: std::vector< std::string >::value_type const &

        """
        return _IOHprofiler.stringvec_append(self, x)


    def empty(self):
        """
        empty(self) -> bool

        Parameters
        ----------
        self: std::vector< std::string > const *

        """
        return _IOHprofiler.stringvec_empty(self)


    def size(self):
        """
        size(self) -> std::vector< std::string >::size_type

        Parameters
        ----------
        self: std::vector< std::string > const *

        """
        return _IOHprofiler.stringvec_size(self)


    def swap(self, v):
        """
        swap(self, v)

        Parameters
        ----------
        v: std::vector< std::string > &

        """
        return _IOHprofiler.stringvec_swap(self, v)


    def begin(self):
        """
        begin(self) -> std::vector< std::string >::iterator

        Parameters
        ----------
        self: std::vector< std::string > *

        """
        return _IOHprofiler.stringvec_begin(self)


    def end(self):
        """
        end(self) -> std::vector< std::string >::iterator

        Parameters
        ----------
        self: std::vector< std::string > *

        """
        return _IOHprofiler.stringvec_end(self)


    def rbegin(self):
        """
        rbegin(self) -> std::vector< std::string >::reverse_iterator

        Parameters
        ----------
        self: std::vector< std::string > *

        """
        return _IOHprofiler.stringvec_rbegin(self)


    def rend(self):
        """
        rend(self) -> std::vector< std::string >::reverse_iterator

        Parameters
        ----------
        self: std::vector< std::string > *

        """
        return _IOHprofiler.stringvec_rend(self)


    def clear(self):
        """
        clear(self)

        Parameters
        ----------
        self: std::vector< std::string > *

        """
        return _IOHprofiler.stringvec_clear(self)


    def get_allocator(self):
        """
        get_allocator(self) -> std::vector< std::string >::allocator_type

        Parameters
        ----------
        self: std::vector< std::string > const *

        """
        return _IOHprofiler.stringvec_get_allocator(self)


    def pop_back(self):
        """
        pop_back(self)

        Parameters
        ----------
        self: std::vector< std::string > *

        """
        return _IOHprofiler.stringvec_pop_back(self)


    def erase(self, *args):
        """
        erase(self, pos) -> std::vector< std::string >::iterator

        Parameters
        ----------
        pos: std::vector< std::string >::iterator

        erase(self, first, last) -> std::vector< std::string >::iterator

        Parameters
        ----------
        first: std::vector< std::string >::iterator
        last: std::vector< std::string >::iterator

        """
        return _IOHprofiler.stringvec_erase(self, *args)


    def __init__(self, *args):
        """
        __init__(self) -> stringvec
        __init__(self, arg2) -> stringvec

        Parameters
        ----------
        arg2: std::vector< std::string > const &

        __init__(self, size) -> stringvec

        Parameters
        ----------
        size: std::vector< std::string >::size_type

        __init__(self, size, value) -> stringvec

        Parameters
        ----------
        size: std::vector< std::string >::size_type
        value: std::vector< std::string >::value_type const &

        """
        this = _IOHprofiler.new_stringvec(*args)
        try:
            self.this.append(this)
        except __builtin__.Exception:
            self.this = this

    def push_back(self, x):
        """
        push_back(self, x)

        Parameters
        ----------
        x: std::vector< std::string >::value_type const &

        """
        return _IOHprofiler.stringvec_push_back(self, x)


    def front(self):
        """
        front(self) -> std::vector< std::string >::value_type const &

        Parameters
        ----------
        self: std::vector< std::string > const *

        """
        return _IOHprofiler.stringvec_front(self)


    def back(self):
        """
        back(self) -> std::vector< std::string >::value_type const &

        Parameters
        ----------
        self: std::vector< std::string > const *

        """
        return _IOHprofiler.stringvec_back(self)


    def assign(self, n, x):
        """
        assign(self, n, x)

        Parameters
        ----------
        n: std::vector< std::string >::size_type
        x: std::vector< std::string >::value_type const &

        """
        return _IOHprofiler.stringvec_assign(self, n, x)


    def resize(self, *args):
        """
        resize(self, new_size)

        Parameters
        ----------
        new_size: std::vector< std::string >::size_type

        resize(self, new_size, x)

        Parameters
        ----------
        new_size: std::vector< std::string >::size_type
        x: std::vector< std::string >::value_type const &

        """
        return _IOHprofiler.stringvec_resize(self, *args)


    def insert(self, *args):
        """
        insert(self, pos, x) -> std::vector< std::string >::iterator

        Parameters
        ----------
        pos: std::vector< std::string >::iterator
        x: std::vector< std::string >::value_type const &

        insert(self, pos, n, x)

        Parameters
        ----------
        pos: std::vector< std::string >::iterator
        n: std::vector< std::string >::size_type
        x: std::vector< std::string >::value_type const &

        """
        return _IOHprofiler.stringvec_insert(self, *args)


    def reserve(self, n):
        """
        reserve(self, n)

        Parameters
        ----------
        n: std::vector< std::string >::size_type

        """
        return _IOHprofiler.stringvec_reserve(self, n)


    def capacity(self):
        """
        capacity(self) -> std::vector< std::string >::size_type

        Parameters
        ----------
        self: std::vector< std::string > const *

        """
        return _IOHprofiler.stringvec_capacity(self)

    __swig_destroy__ = _IOHprofiler.delete_stringvec
    __del__ = lambda self: None
stringvec_swigregister = _IOHprofiler.stringvec_swigregister
stringvec_swigregister(stringvec)

MAXLINESIZE = _IOHprofiler.MAXLINESIZE
MAXKEYNUMBER = _IOHprofiler.MAXKEYNUMBER
class _Dict(_object):
    """Proxy of C++ _Dict class."""

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

    def __init__(self):
        """__init__(self) -> _Dict"""
        this = _IOHprofiler.new__Dict()
        try:
            self.this.append(this)
        except __builtin__.Exception:
            self.this = this
    __swig_destroy__ = _IOHprofiler.delete__Dict
    __del__ = lambda self: None
    __swig_setmethods__["n"] = _IOHprofiler._Dict_n_set
    __swig_getmethods__["n"] = _IOHprofiler._Dict_n_get
    if _newclass:
        n = _swig_property(_IOHprofiler._Dict_n_get, _IOHprofiler._Dict_n_set)
    __swig_setmethods__["size"] = _IOHprofiler._Dict_size_set
    __swig_getmethods__["size"] = _IOHprofiler._Dict_size_get
    if _newclass:
        size = _swig_property(_IOHprofiler._Dict_size_get, _IOHprofiler._Dict_size_set)
    __swig_setmethods__["section"] = _IOHprofiler._Dict_section_set
    __swig_getmethods__["section"] = _IOHprofiler._Dict_section_get
    if _newclass:
        section = _swig_property(_IOHprofiler._Dict_section_get, _IOHprofiler._Dict_section_set)
    __swig_setmethods__["value"] = _IOHprofiler._Dict_value_set
    __swig_getmethods__["value"] = _IOHprofiler._Dict_value_get
    if _newclass:
        value = _swig_property(_IOHprofiler._Dict_value_get, _IOHprofiler._Dict_value_set)
    __swig_setmethods__["key"] = _IOHprofiler._Dict_key_set
    __swig_getmethods__["key"] = _IOHprofiler._Dict_key_get
    if _newclass:
        key = _swig_property(_IOHprofiler._Dict_key_get, _IOHprofiler._Dict_key_set)
_Dict_swigregister = _IOHprofiler._Dict_swigregister
_Dict_swigregister(_Dict)
cvar = _IOHprofiler.cvar

EMPTY = _IOHprofiler.EMPTY
COMMENT = _IOHprofiler.COMMENT
SECTION = _IOHprofiler.SECTION
VALUE = _IOHprofiler.VALUE
CON_ERROR = _IOHprofiler.CON_ERROR
class IOHprofiler_configuration(_object):
    """Proxy of C++ IOHprofiler_configuration class."""

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

    def __init__(self):
        """__init__(self) -> IOHprofiler_configuration"""
        this = _IOHprofiler.new_IOHprofiler_configuration()
        try:
            self.this.append(this)
        except __builtin__.Exception:
            self.this = this

    def set_Dict(self, dict, section, key, value):
        """
        set_Dict(self, dict, section, key, value) -> int

        Parameters
        ----------
        dict: _Dict &
        section: std::string const
        key: std::string const
        value: std::string const

        """
        return _IOHprofiler.IOHprofiler_configuration_set_Dict(self, dict, section, key, value)


    def get_Dict_String(self, dict, section, key):
        """
        get_Dict_String(self, dict, section, key) -> std::string

        Parameters
        ----------
        dict: _Dict const
        section: std::string const
        key: std::string const

        """
        return _IOHprofiler.IOHprofiler_configuration_get_Dict_String(self, dict, section, key)


    def get_Dict_int_vector(self, dict, section, key, _min, _max):
        """
        get_Dict_int_vector(self, dict, section, key, _min, _max) -> intvec

        Parameters
        ----------
        dict: _Dict const
        section: std::string const
        key: std::string const
        _min: int const
        _max: int const

        """
        return _IOHprofiler.IOHprofiler_configuration_get_Dict_int_vector(self, dict, section, key, _min, _max)


    def get_Dict_Int(self, dict, section, key):
        """
        get_Dict_Int(self, dict, section, key) -> int

        Parameters
        ----------
        dict: _Dict const
        section: std::string const
        key: std::string const

        """
        return _IOHprofiler.IOHprofiler_configuration_get_Dict_Int(self, dict, section, key)


    def get_Dict_bool(self, dict, section, key):
        """
        get_Dict_bool(self, dict, section, key) -> bool

        Parameters
        ----------
        dict: _Dict const
        section: std::string const
        key: std::string const

        """
        return _IOHprofiler.IOHprofiler_configuration_get_Dict_bool(self, dict, section, key)


    def add_Line(self, input_line, section, key, value):
        """
        add_Line(self, input_line, section, key, value) -> linecontent

        Parameters
        ----------
        input_line: std::string const
        section: std::string &
        key: std::string &
        value: std::string &

        """
        return _IOHprofiler.IOHprofiler_configuration_add_Line(self, input_line, section, key, value)


    def load(self, filename):
        """
        load(self, filename) -> _Dict

        Parameters
        ----------
        filename: std::string const

        """
        return _IOHprofiler.IOHprofiler_configuration_load(self, filename)


    def readcfg(self, filename):
        """
        readcfg(self, filename)

        Parameters
        ----------
        filename: std::string

        """
        return _IOHprofiler.IOHprofiler_configuration_readcfg(self, filename)


    def get_suite_name(self):
        """
        get_suite_name(self) -> std::string

        Parameters
        ----------
        self: IOHprofiler_configuration *

        """
        return _IOHprofiler.IOHprofiler_configuration_get_suite_name(self)


    def get_problem_id(self):
        """
        get_problem_id(self) -> intvec

        Parameters
        ----------
        self: IOHprofiler_configuration *

        """
        return _IOHprofiler.IOHprofiler_configuration_get_problem_id(self)


    def get_instance_id(self):
        """
        get_instance_id(self) -> intvec

        Parameters
        ----------
        self: IOHprofiler_configuration *

        """
        return _IOHprofiler.IOHprofiler_configuration_get_instance_id(self)


    def get_dimension(self):
        """
        get_dimension(self) -> intvec

        Parameters
        ----------
        self: IOHprofiler_configuration *

        """
        return _IOHprofiler.IOHprofiler_configuration_get_dimension(self)


    def get_output_directory(self):
        """
        get_output_directory(self) -> std::string

        Parameters
        ----------
        self: IOHprofiler_configuration *

        """
        return _IOHprofiler.IOHprofiler_configuration_get_output_directory(self)


    def get_result_folder(self):
        """
        get_result_folder(self) -> std::string

        Parameters
        ----------
        self: IOHprofiler_configuration *

        """
        return _IOHprofiler.IOHprofiler_configuration_get_result_folder(self)


    def get_algorithm_info(self):
        """
        get_algorithm_info(self) -> std::string

        Parameters
        ----------
        self: IOHprofiler_configuration *

        """
        return _IOHprofiler.IOHprofiler_configuration_get_algorithm_info(self)


    def get_algorithm_name(self):
        """
        get_algorithm_name(self) -> std::string

        Parameters
        ----------
        self: IOHprofiler_configuration *

        """
        return _IOHprofiler.IOHprofiler_configuration_get_algorithm_name(self)


    def get_complete_triggers(self):
        """
        get_complete_triggers(self) -> bool

        Parameters
        ----------
        self: IOHprofiler_configuration *

        """
        return _IOHprofiler.IOHprofiler_configuration_get_complete_triggers(self)


    def get_update_triggers(self):
        """
        get_update_triggers(self) -> bool

        Parameters
        ----------
        self: IOHprofiler_configuration *

        """
        return _IOHprofiler.IOHprofiler_configuration_get_update_triggers(self)


    def get_base_evaluation_triggers(self):
        """
        get_base_evaluation_triggers(self) -> intvec

        Parameters
        ----------
        self: IOHprofiler_configuration *

        """
        return _IOHprofiler.IOHprofiler_configuration_get_base_evaluation_triggers(self)


    def get_number_target_triggers(self):
        """
        get_number_target_triggers(self) -> int

        Parameters
        ----------
        self: IOHprofiler_configuration *

        """
        return _IOHprofiler.IOHprofiler_configuration_get_number_target_triggers(self)


    def get_number_interval_triggers(self):
        """
        get_number_interval_triggers(self) -> int

        Parameters
        ----------
        self: IOHprofiler_configuration *

        """
        return _IOHprofiler.IOHprofiler_configuration_get_number_interval_triggers(self)

    __swig_destroy__ = _IOHprofiler.delete_IOHprofiler_configuration
    __del__ = lambda self: None
IOHprofiler_configuration_swigregister = _IOHprofiler.IOHprofiler_configuration_swigregister
IOHprofiler_configuration_swigregister(IOHprofiler_configuration)

class IOHprofiler_observer(_object):
    """Proxy of C++ IOHprofiler_observer class."""

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

    def __init__(self):
        """__init__(self) -> IOHprofiler_observer"""
        this = _IOHprofiler.new_IOHprofiler_observer()
        try:
            self.this.append(this)
        except __builtin__.Exception:
            self.this = this
    __swig_destroy__ = _IOHprofiler.delete_IOHprofiler_observer
    __del__ = lambda self: None

    def set_complete_flag(self, complete_flag):
        """
        set_complete_flag(self, complete_flag)

        Parameters
        ----------
        complete_flag: bool

        """
        return _IOHprofiler.IOHprofiler_observer_set_complete_flag(self, complete_flag)


    def complete_status(self):
        """
        complete_status(self) -> bool

        Parameters
        ----------
        self: IOHprofiler_observer const *

        """
        return _IOHprofiler.IOHprofiler_observer_complete_status(self)


    def complete_trigger(self):
        """
        complete_trigger(self) -> bool

        Parameters
        ----------
        self: IOHprofiler_observer const *

        """
        return _IOHprofiler.IOHprofiler_observer_complete_trigger(self)


    def set_interval(self, interval):
        """
        set_interval(self, interval)

        Parameters
        ----------
        interval: int

        """
        return _IOHprofiler.IOHprofiler_observer_set_interval(self, interval)


    def interval_status(self):
        """
        interval_status(self) -> bool

        Parameters
        ----------
        self: IOHprofiler_observer const *

        """
        return _IOHprofiler.IOHprofiler_observer_interval_status(self)


    def interval_trigger(self, evaluations):
        """
        interval_trigger(self, evaluations) -> bool

        Parameters
        ----------
        evaluations: size_t

        """
        return _IOHprofiler.IOHprofiler_observer_interval_trigger(self, evaluations)


    def set_update_flag(self, update_flag):
        """
        set_update_flag(self, update_flag)

        Parameters
        ----------
        update_flag: bool

        """
        return _IOHprofiler.IOHprofiler_observer_set_update_flag(self, update_flag)


    def update_trigger(self, fitness, optimization_type):
        """
        update_trigger(self, fitness, optimization_type) -> bool

        Parameters
        ----------
        fitness: double
        optimization_type: enum IOH_optimization_type

        """
        return _IOHprofiler.IOHprofiler_observer_update_trigger(self, fitness, optimization_type)


    def update_status(self):
        """
        update_status(self) -> bool

        Parameters
        ----------
        self: IOHprofiler_observer const *

        """
        return _IOHprofiler.IOHprofiler_observer_update_status(self)


    def set_time_points(self, time_points, number_of_evaluations, time_points_exp_base1=10, time_points_exp_base2=10):
        """
        set_time_points(self, time_points, number_of_evaluations, time_points_exp_base1=10, time_points_exp_base2=10)

        Parameters
        ----------
        time_points: std::vector< int,std::allocator< int > > const &
        number_of_evaluations: int const
        time_points_exp_base1: int const
        time_points_exp_base2: int const

        set_time_points(self, time_points, number_of_evaluations, time_points_exp_base1=10)

        Parameters
        ----------
        time_points: std::vector< int,std::allocator< int > > const &
        number_of_evaluations: int const
        time_points_exp_base1: int const

        set_time_points(self, time_points, number_of_evaluations)

        Parameters
        ----------
        time_points: std::vector< int,std::allocator< int > > const &
        number_of_evaluations: int const

        """
        return _IOHprofiler.IOHprofiler_observer_set_time_points(self, time_points, number_of_evaluations, time_points_exp_base1, time_points_exp_base2)


    def time_points_status(self):
        """
        time_points_status(self) -> bool

        Parameters
        ----------
        self: IOHprofiler_observer const *

        """
        return _IOHprofiler.IOHprofiler_observer_time_points_status(self)


    def time_points_trigger(self, evaluations):
        """
        time_points_trigger(self, evaluations) -> bool

        Parameters
        ----------
        evaluations: size_t

        """
        return _IOHprofiler.IOHprofiler_observer_time_points_trigger(self, evaluations)


    def reset_observer(self, optimization_type):
        """
        reset_observer(self, optimization_type)

        Parameters
        ----------
        optimization_type: enum IOH_optimization_type const

        """
        return _IOHprofiler.IOHprofiler_observer_reset_observer(self, optimization_type)


    def do_log(self, log_info):
        """
        do_log(self, log_info)

        Parameters
        ----------
        log_info: std::vector< double,std::allocator< double > > const &

        """
        return _IOHprofiler.IOHprofiler_observer_do_log(self, log_info)


    def track_problem(self, *args):
        """
        track_problem(self, problem)

        Parameters
        ----------
        problem: IOHprofiler_problem< int > const &

        track_problem(self, problem)

        Parameters
        ----------
        problem: IOHprofiler_problem< double > const &

        """
        return _IOHprofiler.IOHprofiler_observer_track_problem(self, *args)

IOHprofiler_observer_swigregister = _IOHprofiler.IOHprofiler_observer_swigregister
IOHprofiler_observer_swigregister(IOHprofiler_observer)

class IOHprofiler_Problem_int(_object):
    """Proxy of C++ IOHprofiler_problem<(int)> class."""

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

    def __init__(self, *args):
        """
        __init__(self, instance_id, dimension) -> IOHprofiler_Problem_int

        Parameters
        ----------
        instance_id: int
        dimension: int

        __init__(self, instance_id) -> IOHprofiler_Problem_int

        Parameters
        ----------
        instance_id: int

        __init__(self) -> IOHprofiler_Problem_int
        """
        this = _IOHprofiler.new_IOHprofiler_Problem_int(*args)
        try:
            self.this.append(this)
        except __builtin__.Exception:
            self.this = this
    __swig_destroy__ = _IOHprofiler.delete_IOHprofiler_Problem_int
    __del__ = lambda self: None

    def internal_evaluate(self, x):
        """
        internal_evaluate(self, x) -> double

        Parameters
        ----------
        x: std::vector< int,std::allocator< int > > const &

        """
        return _IOHprofiler.IOHprofiler_Problem_int_internal_evaluate(self, x)


    def prepare_problem(self):
        """
        prepare_problem(self)

        Parameters
        ----------
        self: IOHprofiler_problem< int > *

        """
        return _IOHprofiler.IOHprofiler_Problem_int_prepare_problem(self)


    def evaluate(self, x):
        """
        evaluate(self, x) -> double

        Parameters
        ----------
        x: std::vector< int,std::allocator< int > >

        """
        return _IOHprofiler.IOHprofiler_Problem_int_evaluate(self, x)


    def customize_optimal(self):
        """
        customize_optimal(self)

        Parameters
        ----------
        self: IOHprofiler_problem< int > *

        """
        return _IOHprofiler.IOHprofiler_Problem_int_customize_optimal(self)


    def calc_optimal(self):
        """
        calc_optimal(self)

        Parameters
        ----------
        self: IOHprofiler_problem< int > *

        """
        return _IOHprofiler.IOHprofiler_Problem_int_calc_optimal(self)


    def reset_problem(self):
        """
        reset_problem(self)

        Parameters
        ----------
        self: IOHprofiler_problem< int > *

        """
        return _IOHprofiler.IOHprofiler_Problem_int_reset_problem(self)


    def loggerCOCOInfo(self):
        """
        loggerCOCOInfo(self) -> doublevec

        Parameters
        ----------
        self: IOHprofiler_problem< int > const *

        """
        return _IOHprofiler.IOHprofiler_Problem_int_loggerCOCOInfo(self)


    def loggerInfo(self):
        """
        loggerInfo(self) -> doublevec

        Parameters
        ----------
        self: IOHprofiler_problem< int > const *

        """
        return _IOHprofiler.IOHprofiler_Problem_int_loggerInfo(self)


    def IOHprofiler_hit_optimal(self):
        """
        IOHprofiler_hit_optimal(self) -> bool

        Parameters
        ----------
        self: IOHprofiler_problem< int > const *

        """
        return _IOHprofiler.IOHprofiler_Problem_int_IOHprofiler_hit_optimal(self)


    def IOHprofiler_get_problem_id(self):
        """
        IOHprofiler_get_problem_id(self) -> int

        Parameters
        ----------
        self: IOHprofiler_problem< int > const *

        """
        return _IOHprofiler.IOHprofiler_Problem_int_IOHprofiler_get_problem_id(self)


    def IOHprofiler_set_problem_id(self, problem_id):
        """
        IOHprofiler_set_problem_id(self, problem_id)

        Parameters
        ----------
        problem_id: int

        """
        return _IOHprofiler.IOHprofiler_Problem_int_IOHprofiler_set_problem_id(self, problem_id)


    def IOHprofiler_get_instance_id(self):
        """
        IOHprofiler_get_instance_id(self) -> int

        Parameters
        ----------
        self: IOHprofiler_problem< int > const *

        """
        return _IOHprofiler.IOHprofiler_Problem_int_IOHprofiler_get_instance_id(self)


    def IOHprofiler_set_instance_id(self, instance_id):
        """
        IOHprofiler_set_instance_id(self, instance_id)

        Parameters
        ----------
        instance_id: int

        """
        return _IOHprofiler.IOHprofiler_Problem_int_IOHprofiler_set_instance_id(self, instance_id)


    def IOHprofiler_get_problem_name(self):
        """
        IOHprofiler_get_problem_name(self) -> std::string

        Parameters
        ----------
        self: IOHprofiler_problem< int > const *

        """
        return _IOHprofiler.IOHprofiler_Problem_int_IOHprofiler_get_problem_name(self)


    def IOHprofiler_set_problem_name(self, problem_name):
        """
        IOHprofiler_set_problem_name(self, problem_name)

        Parameters
        ----------
        problem_name: std::string

        """
        return _IOHprofiler.IOHprofiler_Problem_int_IOHprofiler_set_problem_name(self, problem_name)


    def IOHprofiler_get_problem_type(self):
        """
        IOHprofiler_get_problem_type(self) -> std::string

        Parameters
        ----------
        self: IOHprofiler_problem< int > const *

        """
        return _IOHprofiler.IOHprofiler_Problem_int_IOHprofiler_get_problem_type(self)


    def IOHprofiler_set_problem_type(self, problem_type):
        """
        IOHprofiler_set_problem_type(self, problem_type)

        Parameters
        ----------
        problem_type: std::string

        """
        return _IOHprofiler.IOHprofiler_Problem_int_IOHprofiler_set_problem_type(self, problem_type)


    def IOHprofiler_get_lowerbound(self):
        """
        IOHprofiler_get_lowerbound(self) -> intvec

        Parameters
        ----------
        self: IOHprofiler_problem< int > const *

        """
        return _IOHprofiler.IOHprofiler_Problem_int_IOHprofiler_get_lowerbound(self)


    def IOHprofiler_set_lowerbound(self, *args):
        """
        IOHprofiler_set_lowerbound(self, lowerbound)

        Parameters
        ----------
        lowerbound: int

        IOHprofiler_set_lowerbound(self, lowerbound)

        Parameters
        ----------
        lowerbound: std::vector< int,std::allocator< int > > const &

        """
        return _IOHprofiler.IOHprofiler_Problem_int_IOHprofiler_set_lowerbound(self, *args)


    def IOHprofiler_get_upperbound(self):
        """
        IOHprofiler_get_upperbound(self) -> intvec

        Parameters
        ----------
        self: IOHprofiler_problem< int > const *

        """
        return _IOHprofiler.IOHprofiler_Problem_int_IOHprofiler_get_upperbound(self)


    def IOHprofiler_set_upperbound(self, *args):
        """
        IOHprofiler_set_upperbound(self, upperbound)

        Parameters
        ----------
        upperbound: int

        IOHprofiler_set_upperbound(self, upperbound)

        Parameters
        ----------
        upperbound: std::vector< int,std::allocator< int > > const &

        """
        return _IOHprofiler.IOHprofiler_Problem_int_IOHprofiler_set_upperbound(self, *args)


    def IOHprofiler_get_number_of_variables(self):
        """
        IOHprofiler_get_number_of_variables(self) -> int

        Parameters
        ----------
        self: IOHprofiler_problem< int > const *

        """
        return _IOHprofiler.IOHprofiler_Problem_int_IOHprofiler_get_number_of_variables(self)


    def IOHprofiler_set_number_of_variables(self, *args):
        """
        IOHprofiler_set_number_of_variables(self, number_of_variables)

        Parameters
        ----------
        number_of_variables: int const

        IOHprofiler_set_number_of_variables(self, number_of_variables, best_variables)

        Parameters
        ----------
        number_of_variables: int const
        best_variables: std::vector< int,std::allocator< int > > const &

        """
        return _IOHprofiler.IOHprofiler_Problem_int_IOHprofiler_set_number_of_variables(self, *args)


    def IOHprofiler_get_number_of_objectives(self):
        """
        IOHprofiler_get_number_of_objectives(self) -> int

        Parameters
        ----------
        self: IOHprofiler_problem< int > const *

        """
        return _IOHprofiler.IOHprofiler_Problem_int_IOHprofiler_get_number_of_objectives(self)


    def IOHprofiler_set_number_of_objectives(self, number_of_objectives):
        """
        IOHprofiler_set_number_of_objectives(self, number_of_objectives)

        Parameters
        ----------
        number_of_objectives: int const

        """
        return _IOHprofiler.IOHprofiler_Problem_int_IOHprofiler_set_number_of_objectives(self, number_of_objectives)


    def IOHprofiler_get_raw_objectives(self):
        """
        IOHprofiler_get_raw_objectives(self) -> doublevec

        Parameters
        ----------
        self: IOHprofiler_problem< int > const *

        """
        return _IOHprofiler.IOHprofiler_Problem_int_IOHprofiler_get_raw_objectives(self)


    def IOHprofiler_get_transformed_objectives(self):
        """
        IOHprofiler_get_transformed_objectives(self) -> doublevec

        Parameters
        ----------
        self: IOHprofiler_problem< int > const *

        """
        return _IOHprofiler.IOHprofiler_Problem_int_IOHprofiler_get_transformed_objectives(self)


    def IOHprofiler_get_transformed_number_of_variables(self):
        """
        IOHprofiler_get_transformed_number_of_variables(self) -> int

        Parameters
        ----------
        self: IOHprofiler_problem< int > const *

        """
        return _IOHprofiler.IOHprofiler_Problem_int_IOHprofiler_get_transformed_number_of_variables(self)


    def IOHprofiler_get_transformed_variables(self):
        """
        IOHprofiler_get_transformed_variables(self) -> intvec

        Parameters
        ----------
        self: IOHprofiler_problem< int > const *

        """
        return _IOHprofiler.IOHprofiler_Problem_int_IOHprofiler_get_transformed_variables(self)


    def IOHprofiler_get_best_variables(self):
        """
        IOHprofiler_get_best_variables(self) -> intvec

        Parameters
        ----------
        self: IOHprofiler_problem< int > const *

        """
        return _IOHprofiler.IOHprofiler_Problem_int_IOHprofiler_get_best_variables(self)


    def IOHprofiler_set_best_variables(self, *args):
        """
        IOHprofiler_set_best_variables(self, best_variables)

        Parameters
        ----------
        best_variables: int const

        IOHprofiler_set_best_variables(self, best_variables)

        Parameters
        ----------
        best_variables: std::vector< int,std::allocator< int > > const &

        """
        return _IOHprofiler.IOHprofiler_Problem_int_IOHprofiler_set_best_variables(self, *args)


    def IOHprofiler_get_optimal(self):
        """
        IOHprofiler_get_optimal(self) -> doublevec

        Parameters
        ----------
        self: IOHprofiler_problem< int > const *

        """
        return _IOHprofiler.IOHprofiler_Problem_int_IOHprofiler_get_optimal(self)


    def IOHprofiler_set_optimal(self, *args):
        """
        IOHprofiler_set_optimal(self, optimal)

        Parameters
        ----------
        optimal: double const

        IOHprofiler_set_optimal(self, optimal)

        Parameters
        ----------
        optimal: std::vector< double,std::allocator< double > > const &

        """
        return _IOHprofiler.IOHprofiler_Problem_int_IOHprofiler_set_optimal(self, *args)


    def IOHprofiler_evaluate_optimal(self, *args):
        """
        IOHprofiler_evaluate_optimal(self, best_variables)

        Parameters
        ----------
        best_variables: std::vector< int,std::allocator< int > >

        IOHprofiler_evaluate_optimal(self)

        Parameters
        ----------
        self: IOHprofiler_problem< int > *

        """
        return _IOHprofiler.IOHprofiler_Problem_int_IOHprofiler_evaluate_optimal(self, *args)


    def IOHprofiler_get_evaluations(self):
        """
        IOHprofiler_get_evaluations(self) -> int

        Parameters
        ----------
        self: IOHprofiler_problem< int > const *

        """
        return _IOHprofiler.IOHprofiler_Problem_int_IOHprofiler_get_evaluations(self)


    def IOHprofiler_get_best_so_far_raw_objectives(self):
        """
        IOHprofiler_get_best_so_far_raw_objectives(self) -> doublevec

        Parameters
        ----------
        self: IOHprofiler_problem< int > const *

        """
        return _IOHprofiler.IOHprofiler_Problem_int_IOHprofiler_get_best_so_far_raw_objectives(self)


    def IOHprofiler_get_best_so_far_raw_evaluations(self):
        """
        IOHprofiler_get_best_so_far_raw_evaluations(self) -> int

        Parameters
        ----------
        self: IOHprofiler_problem< int > const *

        """
        return _IOHprofiler.IOHprofiler_Problem_int_IOHprofiler_get_best_so_far_raw_evaluations(self)


    def IOHprofiler_get_best_so_far_transformed_objectives(self):
        """
        IOHprofiler_get_best_so_far_transformed_objectives(self) -> doublevec

        Parameters
        ----------
        self: IOHprofiler_problem< int > const *

        """
        return _IOHprofiler.IOHprofiler_Problem_int_IOHprofiler_get_best_so_far_transformed_objectives(self)


    def IOHprofiler_get_best_so_far_transformed_evaluations(self):
        """
        IOHprofiler_get_best_so_far_transformed_evaluations(self) -> int

        Parameters
        ----------
        self: IOHprofiler_problem< int > const *

        """
        return _IOHprofiler.IOHprofiler_Problem_int_IOHprofiler_get_best_so_far_transformed_evaluations(self)


    def IOHprofiler_get_optimization_type(self):
        """
        IOHprofiler_get_optimization_type(self) -> IOH_optimization_type

        Parameters
        ----------
        self: IOHprofiler_problem< int > const *

        """
        return _IOHprofiler.IOHprofiler_Problem_int_IOHprofiler_get_optimization_type(self)


    def IOHprofiler_set_as_maximization(self):
        """
        IOHprofiler_set_as_maximization(self)

        Parameters
        ----------
        self: IOHprofiler_problem< int > *

        """
        return _IOHprofiler.IOHprofiler_Problem_int_IOHprofiler_set_as_maximization(self)


    def IOHprofiler_set_as_minimization(self):
        """
        IOHprofiler_set_as_minimization(self)

        Parameters
        ----------
        self: IOHprofiler_problem< int > *

        """
        return _IOHprofiler.IOHprofiler_Problem_int_IOHprofiler_set_as_minimization(self)

IOHprofiler_Problem_int_swigregister = _IOHprofiler.IOHprofiler_Problem_int_swigregister
IOHprofiler_Problem_int_swigregister(IOHprofiler_Problem_int)

class IOHprofiler_Problem_double(_object):
    """Proxy of C++ IOHprofiler_problem<(double)> class."""

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

    def __init__(self, *args):
        """
        __init__(self, instance_id, dimension) -> IOHprofiler_Problem_double

        Parameters
        ----------
        instance_id: int
        dimension: int

        __init__(self, instance_id) -> IOHprofiler_Problem_double

        Parameters
        ----------
        instance_id: int

        __init__(self) -> IOHprofiler_Problem_double
        """
        this = _IOHprofiler.new_IOHprofiler_Problem_double(*args)
        try:
            self.this.append(this)
        except __builtin__.Exception:
            self.this = this
    __swig_destroy__ = _IOHprofiler.delete_IOHprofiler_Problem_double
    __del__ = lambda self: None

    def internal_evaluate(self, x):
        """
        internal_evaluate(self, x) -> double

        Parameters
        ----------
        x: std::vector< double,std::allocator< double > > const &

        """
        return _IOHprofiler.IOHprofiler_Problem_double_internal_evaluate(self, x)


    def prepare_problem(self):
        """
        prepare_problem(self)

        Parameters
        ----------
        self: IOHprofiler_problem< double > *

        """
        return _IOHprofiler.IOHprofiler_Problem_double_prepare_problem(self)


    def evaluate(self, x):
        """
        evaluate(self, x) -> double

        Parameters
        ----------
        x: std::vector< double,std::allocator< double > >

        """
        return _IOHprofiler.IOHprofiler_Problem_double_evaluate(self, x)


    def customize_optimal(self):
        """
        customize_optimal(self)

        Parameters
        ----------
        self: IOHprofiler_problem< double > *

        """
        return _IOHprofiler.IOHprofiler_Problem_double_customize_optimal(self)


    def calc_optimal(self):
        """
        calc_optimal(self)

        Parameters
        ----------
        self: IOHprofiler_problem< double > *

        """
        return _IOHprofiler.IOHprofiler_Problem_double_calc_optimal(self)


    def reset_problem(self):
        """
        reset_problem(self)

        Parameters
        ----------
        self: IOHprofiler_problem< double > *

        """
        return _IOHprofiler.IOHprofiler_Problem_double_reset_problem(self)


    def loggerCOCOInfo(self):
        """
        loggerCOCOInfo(self) -> doublevec

        Parameters
        ----------
        self: IOHprofiler_problem< double > const *

        """
        return _IOHprofiler.IOHprofiler_Problem_double_loggerCOCOInfo(self)


    def loggerInfo(self):
        """
        loggerInfo(self) -> doublevec

        Parameters
        ----------
        self: IOHprofiler_problem< double > const *

        """
        return _IOHprofiler.IOHprofiler_Problem_double_loggerInfo(self)


    def IOHprofiler_hit_optimal(self):
        """
        IOHprofiler_hit_optimal(self) -> bool

        Parameters
        ----------
        self: IOHprofiler_problem< double > const *

        """
        return _IOHprofiler.IOHprofiler_Problem_double_IOHprofiler_hit_optimal(self)


    def IOHprofiler_get_problem_id(self):
        """
        IOHprofiler_get_problem_id(self) -> int

        Parameters
        ----------
        self: IOHprofiler_problem< double > const *

        """
        return _IOHprofiler.IOHprofiler_Problem_double_IOHprofiler_get_problem_id(self)


    def IOHprofiler_set_problem_id(self, problem_id):
        """
        IOHprofiler_set_problem_id(self, problem_id)

        Parameters
        ----------
        problem_id: int

        """
        return _IOHprofiler.IOHprofiler_Problem_double_IOHprofiler_set_problem_id(self, problem_id)


    def IOHprofiler_get_instance_id(self):
        """
        IOHprofiler_get_instance_id(self) -> int

        Parameters
        ----------
        self: IOHprofiler_problem< double > const *

        """
        return _IOHprofiler.IOHprofiler_Problem_double_IOHprofiler_get_instance_id(self)


    def IOHprofiler_set_instance_id(self, instance_id):
        """
        IOHprofiler_set_instance_id(self, instance_id)

        Parameters
        ----------
        instance_id: int

        """
        return _IOHprofiler.IOHprofiler_Problem_double_IOHprofiler_set_instance_id(self, instance_id)


    def IOHprofiler_get_problem_name(self):
        """
        IOHprofiler_get_problem_name(self) -> std::string

        Parameters
        ----------
        self: IOHprofiler_problem< double > const *

        """
        return _IOHprofiler.IOHprofiler_Problem_double_IOHprofiler_get_problem_name(self)


    def IOHprofiler_set_problem_name(self, problem_name):
        """
        IOHprofiler_set_problem_name(self, problem_name)

        Parameters
        ----------
        problem_name: std::string

        """
        return _IOHprofiler.IOHprofiler_Problem_double_IOHprofiler_set_problem_name(self, problem_name)


    def IOHprofiler_get_problem_type(self):
        """
        IOHprofiler_get_problem_type(self) -> std::string

        Parameters
        ----------
        self: IOHprofiler_problem< double > const *

        """
        return _IOHprofiler.IOHprofiler_Problem_double_IOHprofiler_get_problem_type(self)


    def IOHprofiler_set_problem_type(self, problem_type):
        """
        IOHprofiler_set_problem_type(self, problem_type)

        Parameters
        ----------
        problem_type: std::string

        """
        return _IOHprofiler.IOHprofiler_Problem_double_IOHprofiler_set_problem_type(self, problem_type)


    def IOHprofiler_get_lowerbound(self):
        """
        IOHprofiler_get_lowerbound(self) -> doublevec

        Parameters
        ----------
        self: IOHprofiler_problem< double > const *

        """
        return _IOHprofiler.IOHprofiler_Problem_double_IOHprofiler_get_lowerbound(self)


    def IOHprofiler_set_lowerbound(self, *args):
        """
        IOHprofiler_set_lowerbound(self, lowerbound)

        Parameters
        ----------
        lowerbound: int

        IOHprofiler_set_lowerbound(self, lowerbound)

        Parameters
        ----------
        lowerbound: std::vector< double,std::allocator< double > > const &

        """
        return _IOHprofiler.IOHprofiler_Problem_double_IOHprofiler_set_lowerbound(self, *args)


    def IOHprofiler_get_upperbound(self):
        """
        IOHprofiler_get_upperbound(self) -> doublevec

        Parameters
        ----------
        self: IOHprofiler_problem< double > const *

        """
        return _IOHprofiler.IOHprofiler_Problem_double_IOHprofiler_get_upperbound(self)


    def IOHprofiler_set_upperbound(self, *args):
        """
        IOHprofiler_set_upperbound(self, upperbound)

        Parameters
        ----------
        upperbound: int

        IOHprofiler_set_upperbound(self, upperbound)

        Parameters
        ----------
        upperbound: std::vector< double,std::allocator< double > > const &

        """
        return _IOHprofiler.IOHprofiler_Problem_double_IOHprofiler_set_upperbound(self, *args)


    def IOHprofiler_get_number_of_variables(self):
        """
        IOHprofiler_get_number_of_variables(self) -> int

        Parameters
        ----------
        self: IOHprofiler_problem< double > const *

        """
        return _IOHprofiler.IOHprofiler_Problem_double_IOHprofiler_get_number_of_variables(self)


    def IOHprofiler_set_number_of_variables(self, *args):
        """
        IOHprofiler_set_number_of_variables(self, number_of_variables)

        Parameters
        ----------
        number_of_variables: int const

        IOHprofiler_set_number_of_variables(self, number_of_variables, best_variables)

        Parameters
        ----------
        number_of_variables: int const
        best_variables: std::vector< double,std::allocator< double > > const &

        """
        return _IOHprofiler.IOHprofiler_Problem_double_IOHprofiler_set_number_of_variables(self, *args)


    def IOHprofiler_get_number_of_objectives(self):
        """
        IOHprofiler_get_number_of_objectives(self) -> int

        Parameters
        ----------
        self: IOHprofiler_problem< double > const *

        """
        return _IOHprofiler.IOHprofiler_Problem_double_IOHprofiler_get_number_of_objectives(self)


    def IOHprofiler_set_number_of_objectives(self, number_of_objectives):
        """
        IOHprofiler_set_number_of_objectives(self, number_of_objectives)

        Parameters
        ----------
        number_of_objectives: int const

        """
        return _IOHprofiler.IOHprofiler_Problem_double_IOHprofiler_set_number_of_objectives(self, number_of_objectives)


    def IOHprofiler_get_raw_objectives(self):
        """
        IOHprofiler_get_raw_objectives(self) -> doublevec

        Parameters
        ----------
        self: IOHprofiler_problem< double > const *

        """
        return _IOHprofiler.IOHprofiler_Problem_double_IOHprofiler_get_raw_objectives(self)


    def IOHprofiler_get_transformed_objectives(self):
        """
        IOHprofiler_get_transformed_objectives(self) -> doublevec

        Parameters
        ----------
        self: IOHprofiler_problem< double > const *

        """
        return _IOHprofiler.IOHprofiler_Problem_double_IOHprofiler_get_transformed_objectives(self)


    def IOHprofiler_get_transformed_number_of_variables(self):
        """
        IOHprofiler_get_transformed_number_of_variables(self) -> int

        Parameters
        ----------
        self: IOHprofiler_problem< double > const *

        """
        return _IOHprofiler.IOHprofiler_Problem_double_IOHprofiler_get_transformed_number_of_variables(self)


    def IOHprofiler_get_transformed_variables(self):
        """
        IOHprofiler_get_transformed_variables(self) -> doublevec

        Parameters
        ----------
        self: IOHprofiler_problem< double > const *

        """
        return _IOHprofiler.IOHprofiler_Problem_double_IOHprofiler_get_transformed_variables(self)


    def IOHprofiler_get_best_variables(self):
        """
        IOHprofiler_get_best_variables(self) -> doublevec

        Parameters
        ----------
        self: IOHprofiler_problem< double > const *

        """
        return _IOHprofiler.IOHprofiler_Problem_double_IOHprofiler_get_best_variables(self)


    def IOHprofiler_set_best_variables(self, *args):
        """
        IOHprofiler_set_best_variables(self, best_variables)

        Parameters
        ----------
        best_variables: double const

        IOHprofiler_set_best_variables(self, best_variables)

        Parameters
        ----------
        best_variables: std::vector< double,std::allocator< double > > const &

        """
        return _IOHprofiler.IOHprofiler_Problem_double_IOHprofiler_set_best_variables(self, *args)


    def IOHprofiler_get_optimal(self):
        """
        IOHprofiler_get_optimal(self) -> doublevec

        Parameters
        ----------
        self: IOHprofiler_problem< double > const *

        """
        return _IOHprofiler.IOHprofiler_Problem_double_IOHprofiler_get_optimal(self)


    def IOHprofiler_set_optimal(self, *args):
        """
        IOHprofiler_set_optimal(self, optimal)

        Parameters
        ----------
        optimal: double const

        IOHprofiler_set_optimal(self, optimal)

        Parameters
        ----------
        optimal: std::vector< double,std::allocator< double > > const &

        """
        return _IOHprofiler.IOHprofiler_Problem_double_IOHprofiler_set_optimal(self, *args)


    def IOHprofiler_evaluate_optimal(self, *args):
        """
        IOHprofiler_evaluate_optimal(self, best_variables)

        Parameters
        ----------
        best_variables: std::vector< double,std::allocator< double > >

        IOHprofiler_evaluate_optimal(self)

        Parameters
        ----------
        self: IOHprofiler_problem< double > *

        """
        return _IOHprofiler.IOHprofiler_Problem_double_IOHprofiler_evaluate_optimal(self, *args)


    def IOHprofiler_get_evaluations(self):
        """
        IOHprofiler_get_evaluations(self) -> int

        Parameters
        ----------
        self: IOHprofiler_problem< double > const *

        """
        return _IOHprofiler.IOHprofiler_Problem_double_IOHprofiler_get_evaluations(self)


    def IOHprofiler_get_best_so_far_raw_objectives(self):
        """
        IOHprofiler_get_best_so_far_raw_objectives(self) -> doublevec

        Parameters
        ----------
        self: IOHprofiler_problem< double > const *

        """
        return _IOHprofiler.IOHprofiler_Problem_double_IOHprofiler_get_best_so_far_raw_objectives(self)


    def IOHprofiler_get_best_so_far_raw_evaluations(self):
        """
        IOHprofiler_get_best_so_far_raw_evaluations(self) -> int

        Parameters
        ----------
        self: IOHprofiler_problem< double > const *

        """
        return _IOHprofiler.IOHprofiler_Problem_double_IOHprofiler_get_best_so_far_raw_evaluations(self)


    def IOHprofiler_get_best_so_far_transformed_objectives(self):
        """
        IOHprofiler_get_best_so_far_transformed_objectives(self) -> doublevec

        Parameters
        ----------
        self: IOHprofiler_problem< double > const *

        """
        return _IOHprofiler.IOHprofiler_Problem_double_IOHprofiler_get_best_so_far_transformed_objectives(self)


    def IOHprofiler_get_best_so_far_transformed_evaluations(self):
        """
        IOHprofiler_get_best_so_far_transformed_evaluations(self) -> int

        Parameters
        ----------
        self: IOHprofiler_problem< double > const *

        """
        return _IOHprofiler.IOHprofiler_Problem_double_IOHprofiler_get_best_so_far_transformed_evaluations(self)


    def IOHprofiler_get_optimization_type(self):
        """
        IOHprofiler_get_optimization_type(self) -> IOH_optimization_type

        Parameters
        ----------
        self: IOHprofiler_problem< double > const *

        """
        return _IOHprofiler.IOHprofiler_Problem_double_IOHprofiler_get_optimization_type(self)


    def IOHprofiler_set_as_maximization(self):
        """
        IOHprofiler_set_as_maximization(self)

        Parameters
        ----------
        self: IOHprofiler_problem< double > *

        """
        return _IOHprofiler.IOHprofiler_Problem_double_IOHprofiler_set_as_maximization(self)


    def IOHprofiler_set_as_minimization(self):
        """
        IOHprofiler_set_as_minimization(self)

        Parameters
        ----------
        self: IOHprofiler_problem< double > *

        """
        return _IOHprofiler.IOHprofiler_Problem_double_IOHprofiler_set_as_minimization(self)

IOHprofiler_Problem_double_swigregister = _IOHprofiler.IOHprofiler_Problem_double_swigregister
IOHprofiler_Problem_double_swigregister(IOHprofiler_Problem_double)

class intProblemPtr(_object):
    """Proxy of C++ std::vector<(std::shared_ptr<(IOHprofiler_problem<(int)>)>)> class."""

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

    def iterator(self):
        """
        iterator(self) -> SwigPyIterator

        Parameters
        ----------
        self: std::vector< std::shared_ptr< IOHprofiler_problem< int > > > *

        """
        return _IOHprofiler.intProblemPtr_iterator(self)

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

    def __nonzero__(self):
        """
        __nonzero__(self) -> bool

        Parameters
        ----------
        self: std::vector< std::shared_ptr< IOHprofiler_problem< int > > > const *

        """
        return _IOHprofiler.intProblemPtr___nonzero__(self)


    def __bool__(self):
        """
        __bool__(self) -> bool

        Parameters
        ----------
        self: std::vector< std::shared_ptr< IOHprofiler_problem< int > > > const *

        """
        return _IOHprofiler.intProblemPtr___bool__(self)


    def __len__(self):
        """
        __len__(self) -> std::vector< std::shared_ptr< IOHprofiler_problem< int > > >::size_type

        Parameters
        ----------
        self: std::vector< std::shared_ptr< IOHprofiler_problem< int > > > const *

        """
        return _IOHprofiler.intProblemPtr___len__(self)


    def __getslice__(self, i, j):
        """
        __getslice__(self, i, j) -> intProblemPtr

        Parameters
        ----------
        i: std::vector< std::shared_ptr< IOHprofiler_problem< int > > >::difference_type
        j: std::vector< std::shared_ptr< IOHprofiler_problem< int > > >::difference_type

        """
        return _IOHprofiler.intProblemPtr___getslice__(self, i, j)


    def __setslice__(self, *args):
        """
        __setslice__(self, i, j)

        Parameters
        ----------
        i: std::vector< std::shared_ptr< IOHprofiler_problem< int > > >::difference_type
        j: std::vector< std::shared_ptr< IOHprofiler_problem< int > > >::difference_type

        __setslice__(self, i, j, v)

        Parameters
        ----------
        i: std::vector< std::shared_ptr< IOHprofiler_problem< int > > >::difference_type
        j: std::vector< std::shared_ptr< IOHprofiler_problem< int > > >::difference_type
        v: std::vector< std::shared_ptr< IOHprofiler_problem< int > >,std::allocator< std::shared_ptr< IOHprofiler_problem< int > > > > const &

        """
        return _IOHprofiler.intProblemPtr___setslice__(self, *args)


    def __delslice__(self, i, j):
        """
        __delslice__(self, i, j)

        Parameters
        ----------
        i: std::vector< std::shared_ptr< IOHprofiler_problem< int > > >::difference_type
        j: std::vector< std::shared_ptr< IOHprofiler_problem< int > > >::difference_type

        """
        return _IOHprofiler.intProblemPtr___delslice__(self, i, j)


    def __delitem__(self, *args):
        """
        __delitem__(self, i)

        Parameters
        ----------
        i: std::vector< std::shared_ptr< IOHprofiler_problem< int > > >::difference_type

        __delitem__(self, slice)

        Parameters
        ----------
        slice: PySliceObject *

        """
        return _IOHprofiler.intProblemPtr___delitem__(self, *args)


    def __getitem__(self, *args):
        """
        __getitem__(self, slice) -> intProblemPtr

        Parameters
        ----------
        slice: PySliceObject *

        __getitem__(self, i) -> std::vector< std::shared_ptr< IOHprofiler_problem< int > > >::value_type const &

        Parameters
        ----------
        i: std::vector< std::shared_ptr< IOHprofiler_problem< int > > >::difference_type

        """
        return _IOHprofiler.intProblemPtr___getitem__(self, *args)


    def __setitem__(self, *args):
        """
        __setitem__(self, slice, v)

        Parameters
        ----------
        slice: PySliceObject *
        v: std::vector< std::shared_ptr< IOHprofiler_problem< int > >,std::allocator< std::shared_ptr< IOHprofiler_problem< int > > > > const &

        __setitem__(self, slice)

        Parameters
        ----------
        slice: PySliceObject *

        __setitem__(self, i, x)

        Parameters
        ----------
        i: std::vector< std::shared_ptr< IOHprofiler_problem< int > > >::difference_type
        x: std::vector< std::shared_ptr< IOHprofiler_problem< int > > >::value_type const &

        """
        return _IOHprofiler.intProblemPtr___setitem__(self, *args)


    def pop(self):
        """
        pop(self) -> std::vector< std::shared_ptr< IOHprofiler_problem< int > > >::value_type

        Parameters
        ----------
        self: std::vector< std::shared_ptr< IOHprofiler_problem< int > > > *

        """
        return _IOHprofiler.intProblemPtr_pop(self)


    def append(self, x):
        """
        append(self, x)

        Parameters
        ----------
        x: std::vector< std::shared_ptr< IOHprofiler_problem< int > > >::value_type const &

        """
        return _IOHprofiler.intProblemPtr_append(self, x)


    def empty(self):
        """
        empty(self) -> bool

        Parameters
        ----------
        self: std::vector< std::shared_ptr< IOHprofiler_problem< int > > > const *

        """
        return _IOHprofiler.intProblemPtr_empty(self)


    def size(self):
        """
        size(self) -> std::vector< std::shared_ptr< IOHprofiler_problem< int > > >::size_type

        Parameters
        ----------
        self: std::vector< std::shared_ptr< IOHprofiler_problem< int > > > const *

        """
        return _IOHprofiler.intProblemPtr_size(self)


    def swap(self, v):
        """
        swap(self, v)

        Parameters
        ----------
        v: std::vector< std::shared_ptr< IOHprofiler_problem< int > > > &

        """
        return _IOHprofiler.intProblemPtr_swap(self, v)


    def begin(self):
        """
        begin(self) -> std::vector< std::shared_ptr< IOHprofiler_problem< int > > >::iterator

        Parameters
        ----------
        self: std::vector< std::shared_ptr< IOHprofiler_problem< int > > > *

        """
        return _IOHprofiler.intProblemPtr_begin(self)


    def end(self):
        """
        end(self) -> std::vector< std::shared_ptr< IOHprofiler_problem< int > > >::iterator

        Parameters
        ----------
        self: std::vector< std::shared_ptr< IOHprofiler_problem< int > > > *

        """
        return _IOHprofiler.intProblemPtr_end(self)


    def rbegin(self):
        """
        rbegin(self) -> std::vector< std::shared_ptr< IOHprofiler_problem< int > > >::reverse_iterator

        Parameters
        ----------
        self: std::vector< std::shared_ptr< IOHprofiler_problem< int > > > *

        """
        return _IOHprofiler.intProblemPtr_rbegin(self)


    def rend(self):
        """
        rend(self) -> std::vector< std::shared_ptr< IOHprofiler_problem< int > > >::reverse_iterator

        Parameters
        ----------
        self: std::vector< std::shared_ptr< IOHprofiler_problem< int > > > *

        """
        return _IOHprofiler.intProblemPtr_rend(self)


    def clear(self):
        """
        clear(self)

        Parameters
        ----------
        self: std::vector< std::shared_ptr< IOHprofiler_problem< int > > > *

        """
        return _IOHprofiler.intProblemPtr_clear(self)


    def get_allocator(self):
        """
        get_allocator(self) -> std::vector< std::shared_ptr< IOHprofiler_problem< int > > >::allocator_type

        Parameters
        ----------
        self: std::vector< std::shared_ptr< IOHprofiler_problem< int > > > const *

        """
        return _IOHprofiler.intProblemPtr_get_allocator(self)


    def pop_back(self):
        """
        pop_back(self)

        Parameters
        ----------
        self: std::vector< std::shared_ptr< IOHprofiler_problem< int > > > *

        """
        return _IOHprofiler.intProblemPtr_pop_back(self)


    def erase(self, *args):
        """
        erase(self, pos) -> std::vector< std::shared_ptr< IOHprofiler_problem< int > > >::iterator

        Parameters
        ----------
        pos: std::vector< std::shared_ptr< IOHprofiler_problem< int > > >::iterator

        erase(self, first, last) -> std::vector< std::shared_ptr< IOHprofiler_problem< int > > >::iterator

        Parameters
        ----------
        first: std::vector< std::shared_ptr< IOHprofiler_problem< int > > >::iterator
        last: std::vector< std::shared_ptr< IOHprofiler_problem< int > > >::iterator

        """
        return _IOHprofiler.intProblemPtr_erase(self, *args)


    def __init__(self, *args):
        """
        __init__(self) -> intProblemPtr
        __init__(self, arg2) -> intProblemPtr

        Parameters
        ----------
        arg2: std::vector< std::shared_ptr< IOHprofiler_problem< int > > > const &

        __init__(self, size) -> intProblemPtr

        Parameters
        ----------
        size: std::vector< std::shared_ptr< IOHprofiler_problem< int > > >::size_type

        __init__(self, size, value) -> intProblemPtr

        Parameters
        ----------
        size: std::vector< std::shared_ptr< IOHprofiler_problem< int > > >::size_type
        value: std::vector< std::shared_ptr< IOHprofiler_problem< int > > >::value_type const &

        """
        this = _IOHprofiler.new_intProblemPtr(*args)
        try:
            self.this.append(this)
        except __builtin__.Exception:
            self.this = this

    def push_back(self, x):
        """
        push_back(self, x)

        Parameters
        ----------
        x: std::vector< std::shared_ptr< IOHprofiler_problem< int > > >::value_type const &

        """
        return _IOHprofiler.intProblemPtr_push_back(self, x)


    def front(self):
        """
        front(self) -> std::vector< std::shared_ptr< IOHprofiler_problem< int > > >::value_type const &

        Parameters
        ----------
        self: std::vector< std::shared_ptr< IOHprofiler_problem< int > > > const *

        """
        return _IOHprofiler.intProblemPtr_front(self)


    def back(self):
        """
        back(self) -> std::vector< std::shared_ptr< IOHprofiler_problem< int > > >::value_type const &

        Parameters
        ----------
        self: std::vector< std::shared_ptr< IOHprofiler_problem< int > > > const *

        """
        return _IOHprofiler.intProblemPtr_back(self)


    def assign(self, n, x):
        """
        assign(self, n, x)

        Parameters
        ----------
        n: std::vector< std::shared_ptr< IOHprofiler_problem< int > > >::size_type
        x: std::vector< std::shared_ptr< IOHprofiler_problem< int > > >::value_type const &

        """
        return _IOHprofiler.intProblemPtr_assign(self, n, x)


    def resize(self, *args):
        """
        resize(self, new_size)

        Parameters
        ----------
        new_size: std::vector< std::shared_ptr< IOHprofiler_problem< int > > >::size_type

        resize(self, new_size, x)

        Parameters
        ----------
        new_size: std::vector< std::shared_ptr< IOHprofiler_problem< int > > >::size_type
        x: std::vector< std::shared_ptr< IOHprofiler_problem< int > > >::value_type const &

        """
        return _IOHprofiler.intProblemPtr_resize(self, *args)


    def insert(self, *args):
        """
        insert(self, pos, x) -> std::vector< std::shared_ptr< IOHprofiler_problem< int > > >::iterator

        Parameters
        ----------
        pos: std::vector< std::shared_ptr< IOHprofiler_problem< int > > >::iterator
        x: std::vector< std::shared_ptr< IOHprofiler_problem< int > > >::value_type const &

        insert(self, pos, n, x)

        Parameters
        ----------
        pos: std::vector< std::shared_ptr< IOHprofiler_problem< int > > >::iterator
        n: std::vector< std::shared_ptr< IOHprofiler_problem< int > > >::size_type
        x: std::vector< std::shared_ptr< IOHprofiler_problem< int > > >::value_type const &

        """
        return _IOHprofiler.intProblemPtr_insert(self, *args)


    def reserve(self, n):
        """
        reserve(self, n)

        Parameters
        ----------
        n: std::vector< std::shared_ptr< IOHprofiler_problem< int > > >::size_type

        """
        return _IOHprofiler.intProblemPtr_reserve(self, n)


    def capacity(self):
        """
        capacity(self) -> std::vector< std::shared_ptr< IOHprofiler_problem< int > > >::size_type

        Parameters
        ----------
        self: std::vector< std::shared_ptr< IOHprofiler_problem< int > > > const *

        """
        return _IOHprofiler.intProblemPtr_capacity(self)

    __swig_destroy__ = _IOHprofiler.delete_intProblemPtr
    __del__ = lambda self: None
intProblemPtr_swigregister = _IOHprofiler.intProblemPtr_swigregister
intProblemPtr_swigregister(intProblemPtr)

class doubleProblemPtr(_object):
    """Proxy of C++ std::vector<(std::shared_ptr<(IOHprofiler_problem<(double)>)>)> class."""

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

    def iterator(self):
        """
        iterator(self) -> SwigPyIterator

        Parameters
        ----------
        self: std::vector< std::shared_ptr< IOHprofiler_problem< double > > > *

        """
        return _IOHprofiler.doubleProblemPtr_iterator(self)

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

    def __nonzero__(self):
        """
        __nonzero__(self) -> bool

        Parameters
        ----------
        self: std::vector< std::shared_ptr< IOHprofiler_problem< double > > > const *

        """
        return _IOHprofiler.doubleProblemPtr___nonzero__(self)


    def __bool__(self):
        """
        __bool__(self) -> bool

        Parameters
        ----------
        self: std::vector< std::shared_ptr< IOHprofiler_problem< double > > > const *

        """
        return _IOHprofiler.doubleProblemPtr___bool__(self)


    def __len__(self):
        """
        __len__(self) -> std::vector< std::shared_ptr< IOHprofiler_problem< double > > >::size_type

        Parameters
        ----------
        self: std::vector< std::shared_ptr< IOHprofiler_problem< double > > > const *

        """
        return _IOHprofiler.doubleProblemPtr___len__(self)


    def __getslice__(self, i, j):
        """
        __getslice__(self, i, j) -> doubleProblemPtr

        Parameters
        ----------
        i: std::vector< std::shared_ptr< IOHprofiler_problem< double > > >::difference_type
        j: std::vector< std::shared_ptr< IOHprofiler_problem< double > > >::difference_type

        """
        return _IOHprofiler.doubleProblemPtr___getslice__(self, i, j)


    def __setslice__(self, *args):
        """
        __setslice__(self, i, j)

        Parameters
        ----------
        i: std::vector< std::shared_ptr< IOHprofiler_problem< double > > >::difference_type
        j: std::vector< std::shared_ptr< IOHprofiler_problem< double > > >::difference_type

        __setslice__(self, i, j, v)

        Parameters
        ----------
        i: std::vector< std::shared_ptr< IOHprofiler_problem< double > > >::difference_type
        j: std::vector< std::shared_ptr< IOHprofiler_problem< double > > >::difference_type
        v: std::vector< std::shared_ptr< IOHprofiler_problem< double > >,std::allocator< std::shared_ptr< IOHprofiler_problem< double > > > > const &

        """
        return _IOHprofiler.doubleProblemPtr___setslice__(self, *args)


    def __delslice__(self, i, j):
        """
        __delslice__(self, i, j)

        Parameters
        ----------
        i: std::vector< std::shared_ptr< IOHprofiler_problem< double > > >::difference_type
        j: std::vector< std::shared_ptr< IOHprofiler_problem< double > > >::difference_type

        """
        return _IOHprofiler.doubleProblemPtr___delslice__(self, i, j)


    def __delitem__(self, *args):
        """
        __delitem__(self, i)

        Parameters
        ----------
        i: std::vector< std::shared_ptr< IOHprofiler_problem< double > > >::difference_type

        __delitem__(self, slice)

        Parameters
        ----------
        slice: PySliceObject *

        """
        return _IOHprofiler.doubleProblemPtr___delitem__(self, *args)


    def __getitem__(self, *args):
        """
        __getitem__(self, slice) -> doubleProblemPtr

        Parameters
        ----------
        slice: PySliceObject *

        __getitem__(self, i) -> std::vector< std::shared_ptr< IOHprofiler_problem< double > > >::value_type const &

        Parameters
        ----------
        i: std::vector< std::shared_ptr< IOHprofiler_problem< double > > >::difference_type

        """
        return _IOHprofiler.doubleProblemPtr___getitem__(self, *args)


    def __setitem__(self, *args):
        """
        __setitem__(self, slice, v)

        Parameters
        ----------
        slice: PySliceObject *
        v: std::vector< std::shared_ptr< IOHprofiler_problem< double > >,std::allocator< std::shared_ptr< IOHprofiler_problem< double > > > > const &

        __setitem__(self, slice)

        Parameters
        ----------
        slice: PySliceObject *

        __setitem__(self, i, x)

        Parameters
        ----------
        i: std::vector< std::shared_ptr< IOHprofiler_problem< double > > >::difference_type
        x: std::vector< std::shared_ptr< IOHprofiler_problem< double > > >::value_type const &

        """
        return _IOHprofiler.doubleProblemPtr___setitem__(self, *args)


    def pop(self):
        """
        pop(self) -> std::vector< std::shared_ptr< IOHprofiler_problem< double > > >::value_type

        Parameters
        ----------
        self: std::vector< std::shared_ptr< IOHprofiler_problem< double > > > *

        """
        return _IOHprofiler.doubleProblemPtr_pop(self)


    def append(self, x):
        """
        append(self, x)

        Parameters
        ----------
        x: std::vector< std::shared_ptr< IOHprofiler_problem< double > > >::value_type const &

        """
        return _IOHprofiler.doubleProblemPtr_append(self, x)


    def empty(self):
        """
        empty(self) -> bool

        Parameters
        ----------
        self: std::vector< std::shared_ptr< IOHprofiler_problem< double > > > const *

        """
        return _IOHprofiler.doubleProblemPtr_empty(self)


    def size(self):
        """
        size(self) -> std::vector< std::shared_ptr< IOHprofiler_problem< double > > >::size_type

        Parameters
        ----------
        self: std::vector< std::shared_ptr< IOHprofiler_problem< double > > > const *

        """
        return _IOHprofiler.doubleProblemPtr_size(self)


    def swap(self, v):
        """
        swap(self, v)

        Parameters
        ----------
        v: std::vector< std::shared_ptr< IOHprofiler_problem< double > > > &

        """
        return _IOHprofiler.doubleProblemPtr_swap(self, v)


    def begin(self):
        """
        begin(self) -> std::vector< std::shared_ptr< IOHprofiler_problem< double > > >::iterator

        Parameters
        ----------
        self: std::vector< std::shared_ptr< IOHprofiler_problem< double > > > *

        """
        return _IOHprofiler.doubleProblemPtr_begin(self)


    def end(self):
        """
        end(self) -> std::vector< std::shared_ptr< IOHprofiler_problem< double > > >::iterator

        Parameters
        ----------
        self: std::vector< std::shared_ptr< IOHprofiler_problem< double > > > *

        """
        return _IOHprofiler.doubleProblemPtr_end(self)


    def rbegin(self):
        """
        rbegin(self) -> std::vector< std::shared_ptr< IOHprofiler_problem< double > > >::reverse_iterator

        Parameters
        ----------
        self: std::vector< std::shared_ptr< IOHprofiler_problem< double > > > *

        """
        return _IOHprofiler.doubleProblemPtr_rbegin(self)


    def rend(self):
        """
        rend(self) -> std::vector< std::shared_ptr< IOHprofiler_problem< double > > >::reverse_iterator

        Parameters
        ----------
        self: std::vector< std::shared_ptr< IOHprofiler_problem< double > > > *

        """
        return _IOHprofiler.doubleProblemPtr_rend(self)


    def clear(self):
        """
        clear(self)

        Parameters
        ----------
        self: std::vector< std::shared_ptr< IOHprofiler_problem< double > > > *

        """
        return _IOHprofiler.doubleProblemPtr_clear(self)


    def get_allocator(self):
        """
        get_allocator(self) -> std::vector< std::shared_ptr< IOHprofiler_problem< double > > >::allocator_type

        Parameters
        ----------
        self: std::vector< std::shared_ptr< IOHprofiler_problem< double > > > const *

        """
        return _IOHprofiler.doubleProblemPtr_get_allocator(self)


    def pop_back(self):
        """
        pop_back(self)

        Parameters
        ----------
        self: std::vector< std::shared_ptr< IOHprofiler_problem< double > > > *

        """
        return _IOHprofiler.doubleProblemPtr_pop_back(self)


    def erase(self, *args):
        """
        erase(self, pos) -> std::vector< std::shared_ptr< IOHprofiler_problem< double > > >::iterator

        Parameters
        ----------
        pos: std::vector< std::shared_ptr< IOHprofiler_problem< double > > >::iterator

        erase(self, first, last) -> std::vector< std::shared_ptr< IOHprofiler_problem< double > > >::iterator

        Parameters
        ----------
        first: std::vector< std::shared_ptr< IOHprofiler_problem< double > > >::iterator
        last: std::vector< std::shared_ptr< IOHprofiler_problem< double > > >::iterator

        """
        return _IOHprofiler.doubleProblemPtr_erase(self, *args)


    def __init__(self, *args):
        """
        __init__(self) -> doubleProblemPtr
        __init__(self, arg2) -> doubleProblemPtr

        Parameters
        ----------
        arg2: std::vector< std::shared_ptr< IOHprofiler_problem< double > > > const &

        __init__(self, size) -> doubleProblemPtr

        Parameters
        ----------
        size: std::vector< std::shared_ptr< IOHprofiler_problem< double > > >::size_type

        __init__(self, size, value) -> doubleProblemPtr

        Parameters
        ----------
        size: std::vector< std::shared_ptr< IOHprofiler_problem< double > > >::size_type
        value: std::vector< std::shared_ptr< IOHprofiler_problem< double > > >::value_type const &

        """
        this = _IOHprofiler.new_doubleProblemPtr(*args)
        try:
            self.this.append(this)
        except __builtin__.Exception:
            self.this = this

    def push_back(self, x):
        """
        push_back(self, x)

        Parameters
        ----------
        x: std::vector< std::shared_ptr< IOHprofiler_problem< double > > >::value_type const &

        """
        return _IOHprofiler.doubleProblemPtr_push_back(self, x)


    def front(self):
        """
        front(self) -> std::vector< std::shared_ptr< IOHprofiler_problem< double > > >::value_type const &

        Parameters
        ----------
        self: std::vector< std::shared_ptr< IOHprofiler_problem< double > > > const *

        """
        return _IOHprofiler.doubleProblemPtr_front(self)


    def back(self):
        """
        back(self) -> std::vector< std::shared_ptr< IOHprofiler_problem< double > > >::value_type const &

        Parameters
        ----------
        self: std::vector< std::shared_ptr< IOHprofiler_problem< double > > > const *

        """
        return _IOHprofiler.doubleProblemPtr_back(self)


    def assign(self, n, x):
        """
        assign(self, n, x)

        Parameters
        ----------
        n: std::vector< std::shared_ptr< IOHprofiler_problem< double > > >::size_type
        x: std::vector< std::shared_ptr< IOHprofiler_problem< double > > >::value_type const &

        """
        return _IOHprofiler.doubleProblemPtr_assign(self, n, x)


    def resize(self, *args):
        """
        resize(self, new_size)

        Parameters
        ----------
        new_size: std::vector< std::shared_ptr< IOHprofiler_problem< double > > >::size_type

        resize(self, new_size, x)

        Parameters
        ----------
        new_size: std::vector< std::shared_ptr< IOHprofiler_problem< double > > >::size_type
        x: std::vector< std::shared_ptr< IOHprofiler_problem< double > > >::value_type const &

        """
        return _IOHprofiler.doubleProblemPtr_resize(self, *args)


    def insert(self, *args):
        """
        insert(self, pos, x) -> std::vector< std::shared_ptr< IOHprofiler_problem< double > > >::iterator

        Parameters
        ----------
        pos: std::vector< std::shared_ptr< IOHprofiler_problem< double > > >::iterator
        x: std::vector< std::shared_ptr< IOHprofiler_problem< double > > >::value_type const &

        insert(self, pos, n, x)

        Parameters
        ----------
        pos: std::vector< std::shared_ptr< IOHprofiler_problem< double > > >::iterator
        n: std::vector< std::shared_ptr< IOHprofiler_problem< double > > >::size_type
        x: std::vector< std::shared_ptr< IOHprofiler_problem< double > > >::value_type const &

        """
        return _IOHprofiler.doubleProblemPtr_insert(self, *args)


    def reserve(self, n):
        """
        reserve(self, n)

        Parameters
        ----------
        n: std::vector< std::shared_ptr< IOHprofiler_problem< double > > >::size_type

        """
        return _IOHprofiler.doubleProblemPtr_reserve(self, n)


    def capacity(self):
        """
        capacity(self) -> std::vector< std::shared_ptr< IOHprofiler_problem< double > > >::size_type

        Parameters
        ----------
        self: std::vector< std::shared_ptr< IOHprofiler_problem< double > > > const *

        """
        return _IOHprofiler.doubleProblemPtr_capacity(self)

    __swig_destroy__ = _IOHprofiler.delete_doubleProblemPtr
    __del__ = lambda self: None
doubleProblemPtr_swigregister = _IOHprofiler.doubleProblemPtr_swigregister
doubleProblemPtr_swigregister(doubleProblemPtr)

IOH_PI = _IOHprofiler.IOH_PI
DEFAULT_SEED = _IOHprofiler.DEFAULT_SEED
RND_MULTIPLIER = _IOHprofiler.RND_MULTIPLIER
RND_MODULUS = _IOHprofiler.RND_MODULUS
RND_MODULUS_DIV = _IOHprofiler.RND_MODULUS_DIV
RND_MOD_MULTIPLIER = _IOHprofiler.RND_MOD_MULTIPLIER
IOHPROFILER_SHORT_LAG = _IOHprofiler.IOHPROFILER_SHORT_LAG
IOHPROFILER_LONG_LAG = _IOHprofiler.IOHPROFILER_LONG_LAG
class IOHprofiler_random(_object):
    """Proxy of C++ IOHprofiler_random class."""

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

    def __init__(self, seed=1000):
        """
        __init__(self, seed=1000) -> IOHprofiler_random

        Parameters
        ----------
        seed: uint32_t

        __init__(self) -> IOHprofiler_random
        """
        this = _IOHprofiler.new_IOHprofiler_random(seed)
        try:
            self.this.append(this)
        except __builtin__.Exception:
            self.this = this

    def IOHprofiler_random_generate(self):
        """
        IOHprofiler_random_generate(self)

        Parameters
        ----------
        self: IOHprofiler_random *

        """
        return _IOHprofiler.IOHprofiler_random_IOHprofiler_random_generate(self)


    def _lcg_rand(inseed):
        """
        _lcg_rand(inseed) -> long

        Parameters
        ----------
        inseed: long const &

        """
        return _IOHprofiler.IOHprofiler_random__lcg_rand(inseed)

    _lcg_rand = staticmethod(_lcg_rand)

    def IOHprofiler_gauss(N, inseed):
        """
        IOHprofiler_gauss(N, inseed) -> doublevec

        Parameters
        ----------
        N: size_t const
        inseed: long const

        """
        return _IOHprofiler.IOHprofiler_random_IOHprofiler_gauss(N, inseed)

    IOHprofiler_gauss = staticmethod(IOHprofiler_gauss)

    def IOHprofiler_uniform_rand(self, *args):
        """
        IOHprofiler_uniform_rand(self, N, inseed, rand_vec)

        Parameters
        ----------
        N: size_t const &
        inseed: long const &
        rand_vec: std::vector< double,std::allocator< double > > &

        IOHprofiler_uniform_rand(self) -> double

        Parameters
        ----------
        self: IOHprofiler_random *

        """
        return _IOHprofiler.IOHprofiler_random_IOHprofiler_uniform_rand(self, *args)


    def IOHprofiler_normal_rand(self):
        """
        IOHprofiler_normal_rand(self) -> double

        Parameters
        ----------
        self: IOHprofiler_random *

        """
        return _IOHprofiler.IOHprofiler_random_IOHprofiler_normal_rand(self)

    __swig_destroy__ = _IOHprofiler.delete_IOHprofiler_random
    __del__ = lambda self: None
IOHprofiler_random_swigregister = _IOHprofiler.IOHprofiler_random_swigregister
IOHprofiler_random_swigregister(IOHprofiler_random)

def IOHprofiler_random__lcg_rand(inseed):
    """
    IOHprofiler_random__lcg_rand(inseed) -> long

    Parameters
    ----------
    inseed: long const &

    """
    return _IOHprofiler.IOHprofiler_random__lcg_rand(inseed)

def IOHprofiler_random_IOHprofiler_gauss(N, inseed):
    """
    IOHprofiler_random_IOHprofiler_gauss(N, inseed) -> doublevec

    Parameters
    ----------
    N: size_t const
    inseed: long const

    """
    return _IOHprofiler.IOHprofiler_random_IOHprofiler_gauss(N, inseed)


def strstrip(s):
    """
    strstrip(s) -> std::string

    Parameters
    ----------
    s: std::string

    """
    return _IOHprofiler.strstrip(s)

def get_int_vector_parse_string(input, _min, _max):
    """
    get_int_vector_parse_string(input, _min, _max) -> intvec

    Parameters
    ----------
    input: std::string
    _min: int const
    _max: int const

    """
    return _IOHprofiler.get_int_vector_parse_string(input, _min, _max)
class IOHprofiler_transformation(_object):
    """Proxy of C++ IOHprofiler_transformation class."""

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

    def variables_transformation(self, *args):
        """
        variables_transformation(self, x, problem_id, instance_id, problem_type)

        Parameters
        ----------
        x: std::vector< int,std::allocator< int > > &
        problem_id: int const
        instance_id: int const
        problem_type: std::string const

        variables_transformation(self, x, problem_id, instance_id, problem_type)

        Parameters
        ----------
        x: std::vector< double,std::allocator< double > > &
        problem_id: int const
        instance_id: int const
        problem_type: std::string const

        """
        return _IOHprofiler.IOHprofiler_transformation_variables_transformation(self, *args)


    def objectives_transformation(self, *args):
        """
        objectives_transformation(self, x, y, problem_id, instance_id, problem_type)

        Parameters
        ----------
        x: std::vector< int,std::allocator< int > > const &
        y: std::vector< double,std::allocator< double > > &
        problem_id: int const
        instance_id: int const
        problem_type: std::string const

        objectives_transformation(self, x, y, problem_id, instance_id, problem_type)

        Parameters
        ----------
        x: std::vector< double,std::allocator< double > > const &
        y: std::vector< double,std::allocator< double > > &
        problem_id: int const
        instance_id: int const
        problem_type: std::string const

        """
        return _IOHprofiler.IOHprofiler_transformation_objectives_transformation(self, *args)


    def xor_compute(x1, x2):
        """
        xor_compute(x1, x2) -> int

        Parameters
        ----------
        x1: int const
        x2: int const

        """
        return _IOHprofiler.IOHprofiler_transformation_xor_compute(x1, x2)

    xor_compute = staticmethod(xor_compute)

    def transform_vars_xor(self, x, seed):
        """
        transform_vars_xor(self, x, seed)

        Parameters
        ----------
        x: std::vector< int,std::allocator< int > > &
        seed: int const

        """
        return _IOHprofiler.IOHprofiler_transformation_transform_vars_xor(self, x, seed)


    def sigma_compute(x, pos):
        """
        sigma_compute(x, pos) -> int

        Parameters
        ----------
        x: std::vector< int,std::allocator< int > > const &
        pos: int const

        """
        return _IOHprofiler.IOHprofiler_transformation_sigma_compute(x, pos)

    sigma_compute = staticmethod(sigma_compute)

    def transform_vars_sigma(self, x, seed):
        """
        transform_vars_sigma(self, x, seed)

        Parameters
        ----------
        x: std::vector< int,std::allocator< int > > &
        seed: int const

        """
        return _IOHprofiler.IOHprofiler_transformation_transform_vars_sigma(self, x, seed)


    def transform_obj_scale(self, *args):
        """
        transform_obj_scale(self, y, seed)

        Parameters
        ----------
        y: std::vector< double,std::allocator< double > > &
        seed: int const

        transform_obj_scale(self, y, seed)

        Parameters
        ----------
        y: double &
        seed: int const

        """
        return _IOHprofiler.IOHprofiler_transformation_transform_obj_scale(self, *args)


    def transform_obj_shift(self, *args):
        """
        transform_obj_shift(self, y, seed)

        Parameters
        ----------
        y: std::vector< double,std::allocator< double > > &
        seed: int const

        transform_obj_shift(self, y, seed)

        Parameters
        ----------
        y: double &
        seed: int const

        """
        return _IOHprofiler.IOHprofiler_transformation_transform_obj_shift(self, *args)


    def __init__(self):
        """__init__(self) -> IOHprofiler_transformation"""
        this = _IOHprofiler.new_IOHprofiler_transformation()
        try:
            self.this.append(this)
        except __builtin__.Exception:
            self.this = this
    __swig_destroy__ = _IOHprofiler.delete_IOHprofiler_transformation
    __del__ = lambda self: None
IOHprofiler_transformation_swigregister = _IOHprofiler.IOHprofiler_transformation_swigregister
IOHprofiler_transformation_swigregister(IOHprofiler_transformation)

def IOHprofiler_transformation_xor_compute(x1, x2):
    """
    IOHprofiler_transformation_xor_compute(x1, x2) -> int

    Parameters
    ----------
    x1: int const
    x2: int const

    """
    return _IOHprofiler.IOHprofiler_transformation_xor_compute(x1, x2)

def IOHprofiler_transformation_sigma_compute(x, pos):
    """
    IOHprofiler_transformation_sigma_compute(x, pos) -> int

    Parameters
    ----------
    x: std::vector< int,std::allocator< int > > const &
    pos: int const

    """
    return _IOHprofiler.IOHprofiler_transformation_sigma_compute(x, pos)

SUITE_BBOB2009_MAX_DIM = _IOHprofiler.SUITE_BBOB2009_MAX_DIM

def bbob2009_fmin(a, b):
    """
    bbob2009_fmin(a, b) -> double

    Parameters
    ----------
    a: double
    b: double

    """
    return _IOHprofiler.bbob2009_fmin(a, b)

def bbob2009_fmax(a, b):
    """
    bbob2009_fmax(a, b) -> double

    Parameters
    ----------
    a: double
    b: double

    """
    return _IOHprofiler.bbob2009_fmax(a, b)

def bbob2009_round(x):
    """
    bbob2009_round(x) -> double

    Parameters
    ----------
    x: double

    """
    return _IOHprofiler.bbob2009_round(x)

def bbob2009_unif(r, N, inseed):
    """
    bbob2009_unif(r, N, inseed)

    Parameters
    ----------
    r: std::vector< double,std::allocator< double > > &
    N: size_t
    inseed: long

    """
    return _IOHprofiler.bbob2009_unif(r, N, inseed)

def bbob2009_reshape(B, vector, m, n):
    """
    bbob2009_reshape(B, vector, m, n)

    Parameters
    ----------
    B: std::vector< std::vector< double,std::allocator< double > >,std::allocator< std::vector< double,std::allocator< double > > > > &
    vector: std::vector< double,std::allocator< double > > const &
    m: size_t const
    n: size_t const

    """
    return _IOHprofiler.bbob2009_reshape(B, vector, m, n)

def bbob2009_gauss(g, N, seed):
    """
    bbob2009_gauss(g, N, seed)

    Parameters
    ----------
    g: std::vector< double,std::allocator< double > > &
    N: size_t const
    seed: long const

    """
    return _IOHprofiler.bbob2009_gauss(g, N, seed)

def bbob2009_compute_rotation(B, seed, DIM):
    """
    bbob2009_compute_rotation(B, seed, DIM)

    Parameters
    ----------
    B: std::vector< std::vector< double,std::allocator< double > >,std::allocator< std::vector< double,std::allocator< double > > > > &
    seed: long const
    DIM: size_t const

    """
    return _IOHprofiler.bbob2009_compute_rotation(B, seed, DIM)

def bbob2009_copy_rotation_matrix(rot, M, b, DIM):
    """
    bbob2009_copy_rotation_matrix(rot, M, b, DIM)

    Parameters
    ----------
    rot: std::vector< std::vector< double,std::allocator< double > >,std::allocator< std::vector< double,std::allocator< double > > > > const &
    M: std::vector< std::vector< double,std::allocator< double > >,std::allocator< std::vector< double,std::allocator< double > > > > &
    b: std::vector< double,std::allocator< double > > &
    DIM: size_t const

    """
    return _IOHprofiler.bbob2009_copy_rotation_matrix(rot, M, b, DIM)

def bbob2009_compute_xopt(xopt, seed, DIM):
    """
    bbob2009_compute_xopt(xopt, seed, DIM)

    Parameters
    ----------
    xopt: std::vector< double,std::allocator< double > > &
    seed: long const
    DIM: size_t const

    """
    return _IOHprofiler.bbob2009_compute_xopt(xopt, seed, DIM)

def bbob2009_compute_fopt(function, instance):
    """
    bbob2009_compute_fopt(function, instance) -> double

    Parameters
    ----------
    function: size_t const
    instance: size_t const

    """
    return _IOHprofiler.bbob2009_compute_fopt(function, instance)

def dummy(number_of_variables, select_rate, inseed):
    """
    dummy(number_of_variables, select_rate, inseed) -> intvec

    Parameters
    ----------
    number_of_variables: int
    select_rate: double
    inseed: long

    """
    return _IOHprofiler.dummy(number_of_variables, select_rate, inseed)

def neutrality(variables, mu):
    """
    neutrality(variables, mu) -> intvec

    Parameters
    ----------
    variables: std::vector< int,std::allocator< int > > const &
    mu: int

    """
    return _IOHprofiler.neutrality(variables, mu)

def epistasis(variables, v):
    """
    epistasis(variables, v) -> intvec

    Parameters
    ----------
    variables: std::vector< int,std::allocator< int > > const &
    v: int

    """
    return _IOHprofiler.epistasis(variables, v)

def ruggedness1(y, number_of_variables):
    """
    ruggedness1(y, number_of_variables) -> double

    Parameters
    ----------
    y: double
    number_of_variables: int

    """
    return _IOHprofiler.ruggedness1(y, number_of_variables)

def ruggedness2(y, number_of_variables):
    """
    ruggedness2(y, number_of_variables) -> double

    Parameters
    ----------
    y: double
    number_of_variables: int

    """
    return _IOHprofiler.ruggedness2(y, number_of_variables)

def ruggedness3(number_of_variables):
    """
    ruggedness3(number_of_variables) -> doublevec

    Parameters
    ----------
    number_of_variables: int

    """
    return _IOHprofiler.ruggedness3(number_of_variables)

def layer_neutrality_compute(xIn, xOut, mu):
    """
    layer_neutrality_compute(xIn, xOut, mu)

    Parameters
    ----------
    xIn: std::vector< int,std::allocator< int > > const &
    xOut: std::vector< int,std::allocator< int > > &
    mu: int const

    """
    return _IOHprofiler.layer_neutrality_compute(xIn, xOut, mu)

def base_epistasis(xIn, start, nu, xOut):
    """
    base_epistasis(xIn, start, nu, xOut)

    Parameters
    ----------
    xIn: std::vector< int,std::allocator< int > > const &
    start: int const
    nu: int const
    xOut: std::vector< int,std::allocator< int > > &

    """
    return _IOHprofiler.base_epistasis(xIn, start, nu, xOut)

def epistasis_compute(xIn, xOut, nu):
    """
    epistasis_compute(xIn, xOut, nu)

    Parameters
    ----------
    xIn: std::vector< int,std::allocator< int > > const &
    xOut: std::vector< int,std::allocator< int > > &
    nu: int const

    """
    return _IOHprofiler.epistasis_compute(xIn, xOut, nu)

def layer_epistasis_compute(x, epistasis_x, block_size):
    """
    layer_epistasis_compute(x, epistasis_x, block_size)

    Parameters
    ----------
    x: std::vector< int,std::allocator< int > > const &
    epistasis_x: std::vector< int,std::allocator< int > > &
    block_size: int const

    """
    return _IOHprofiler.layer_epistasis_compute(x, epistasis_x, block_size)

def max_gamma(q):
    """
    max_gamma(q) -> int

    Parameters
    ----------
    q: int

    """
    return _IOHprofiler.max_gamma(q)

def ruggedness_raw(gamma, q):
    """
    ruggedness_raw(gamma, q) -> intvec

    Parameters
    ----------
    gamma: int
    q: int

    """
    return _IOHprofiler.ruggedness_raw(gamma, q)

def ruggedness_translate(gamma, q):
    """
    ruggedness_translate(gamma, q) -> int

    Parameters
    ----------
    gamma: int
    q: int

    """
    return _IOHprofiler.ruggedness_translate(gamma, q)

def layer_compute_ruggedness(y, dimension, gamma):
    """
    layer_compute_ruggedness(y, dimension, gamma) -> double

    Parameters
    ----------
    y: double const
    dimension: size_t
    gamma: int

    """
    return _IOHprofiler.layer_compute_ruggedness(y, dimension, gamma)
class IOHprofiler_csv_logger(IOHprofiler_observer):
    """Proxy of C++ IOHprofiler_csv_logger class."""

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

    def __init__(self, *args):
        """
        __init__(self) -> IOHprofiler_csv_logger
        __init__(self, directory, folder_name, alg_name, alg_info) -> IOHprofiler_csv_logger

        Parameters
        ----------
        directory: std::string
        folder_name: std::string
        alg_name: std::string
        alg_info: std::string

        """
        this = _IOHprofiler.new_IOHprofiler_csv_logger(*args)
        try:
            self.this.append(this)
        except __builtin__.Exception:
            self.this = this
    __swig_destroy__ = _IOHprofiler.delete_IOHprofiler_csv_logger
    __del__ = lambda self: None

    def folder_exist(self, folder_name):
        """
        folder_exist(self, folder_name) -> bool

        Parameters
        ----------
        folder_name: std::string

        """
        return _IOHprofiler.IOHprofiler_csv_logger_folder_exist(self, folder_name)


    def activate_logger(self):
        """
        activate_logger(self)

        Parameters
        ----------
        self: IOHprofiler_csv_logger *

        """
        return _IOHprofiler.IOHprofiler_csv_logger_activate_logger(self)


    def clear_logger(self):
        """
        clear_logger(self)

        Parameters
        ----------
        self: IOHprofiler_csv_logger *

        """
        return _IOHprofiler.IOHprofiler_csv_logger_clear_logger(self)


    def add_dynamic_attribute(self, *args):
        """
        add_dynamic_attribute(self, attributes)

        Parameters
        ----------
        attributes: std::vector< std::shared_ptr< double >,std::allocator< std::shared_ptr< double > > > const &

        add_dynamic_attribute(self, attributes, attributes_name)

        Parameters
        ----------
        attributes: std::vector< std::shared_ptr< double >,std::allocator< std::shared_ptr< double > > > const &
        attributes_name: std::vector< std::string,std::allocator< std::string > > const &

        """
        return _IOHprofiler.IOHprofiler_csv_logger_add_dynamic_attribute(self, *args)


    def set_dynamic_attributes_name(self, *args):
        """
        set_dynamic_attributes_name(self, attributes_name)

        Parameters
        ----------
        attributes_name: std::vector< std::string,std::allocator< std::string > > const &

        set_dynamic_attributes_name(self, attributes_name, initial_attributes)

        Parameters
        ----------
        attributes_name: std::vector< std::string,std::allocator< std::string > > const &
        initial_attributes: std::vector< double,std::allocator< double > > const &

        """
        return _IOHprofiler.IOHprofiler_csv_logger_set_dynamic_attributes_name(self, *args)


    def set_dynamic_attributes(self, attributes_name, attributes):
        """
        set_dynamic_attributes(self, attributes_name, attributes)

        Parameters
        ----------
        attributes_name: std::vector< std::string,std::allocator< std::string > > const &
        attributes: std::vector< double,std::allocator< double > > const &

        """
        return _IOHprofiler.IOHprofiler_csv_logger_set_dynamic_attributes(self, attributes_name, attributes)


    def add_attribute(self, *args):
        """
        add_attribute(self, arg2, arg3)

        Parameters
        ----------
        arg2: std::string
        arg3: int

        add_attribute(self, arg2, arg3)

        Parameters
        ----------
        arg2: std::string
        arg3: double

        add_attribute(self, arg2, arg3)

        Parameters
        ----------
        arg2: std::string
        arg3: float

        add_attribute(self, arg2, arg3)

        Parameters
        ----------
        arg2: std::string
        arg3: std::string

        """
        return _IOHprofiler.IOHprofiler_csv_logger_add_attribute(self, *args)


    def delete_attribute(self, arg2):
        """
        delete_attribute(self, arg2)

        Parameters
        ----------
        arg2: std::string

        """
        return _IOHprofiler.IOHprofiler_csv_logger_delete_attribute(self, arg2)


    def track_problem(self, *args):
        """
        track_problem(self, problem_id, dimension, instance, problem_name, maximization_minimization_flag)

        Parameters
        ----------
        problem_id: int const
        dimension: int const
        instance: int const
        problem_name: std::string const
        maximization_minimization_flag: enum IOH_optimization_type const

        track_problem(self, problem)

        Parameters
        ----------
        problem: IOHprofiler_problem< int > const &

        track_problem(self, problem)

        Parameters
        ----------
        problem: IOHprofiler_problem< double > const &

        """
        return _IOHprofiler.IOHprofiler_csv_logger_track_problem(self, *args)


    def track_suite(self, suite_name):
        """
        track_suite(self, suite_name)

        Parameters
        ----------
        suite_name: std::string

        """
        return _IOHprofiler.IOHprofiler_csv_logger_track_suite(self, suite_name)


    def openInfo(self, problem_id, dimension, problem_name):
        """
        openInfo(self, problem_id, dimension, problem_name)

        Parameters
        ----------
        problem_id: int
        dimension: int
        problem_name: std::string

        """
        return _IOHprofiler.IOHprofiler_csv_logger_openInfo(self, problem_id, dimension, problem_name)


    def write_info(self, instance, best_y, best_transformed_y, evaluations, last_y, last_transformed_y, last_evaluations):
        """
        write_info(self, instance, best_y, best_transformed_y, evaluations, last_y, last_transformed_y, last_evaluations)

        Parameters
        ----------
        instance: int
        best_y: double
        best_transformed_y: double
        evaluations: int
        last_y: double
        last_transformed_y: double
        last_evaluations: int

        """
        return _IOHprofiler.IOHprofiler_csv_logger_write_info(self, instance, best_y, best_transformed_y, evaluations, last_y, last_transformed_y, last_evaluations)


    def do_log(self, log_info):
        """
        do_log(self, log_info)

        Parameters
        ----------
        log_info: std::vector< double,std::allocator< double > > const &

        """
        return _IOHprofiler.IOHprofiler_csv_logger_do_log(self, log_info)


    def write_line(self, *args):
        """
        write_line(self, evaluations, y, best_so_far_y, transformed_y, best_so_far_transformed_y)

        Parameters
        ----------
        evaluations: size_t const
        y: double const
        best_so_far_y: double const
        transformed_y: double const
        best_so_far_transformed_y: double const

        write_line(self, log_info)

        Parameters
        ----------
        log_info: std::vector< double,std::allocator< double > > const &

        """
        return _IOHprofiler.IOHprofiler_csv_logger_write_line(self, *args)


    def update_logger_info(self, optimal_evaluations, y, transformed_y):
        """
        update_logger_info(self, optimal_evaluations, y, transformed_y)

        Parameters
        ----------
        optimal_evaluations: size_t
        y: double
        transformed_y: double

        """
        return _IOHprofiler.IOHprofiler_csv_logger_update_logger_info(self, optimal_evaluations, y, transformed_y)


    def set_parameters_name(self, *args):
        """
        set_parameters_name(self, parameters_name)

        Parameters
        ----------
        parameters_name: std::vector< std::string,std::allocator< std::string > > const &

        set_parameters_name(self, parameters_name, initial_parameters)

        Parameters
        ----------
        parameters_name: std::vector< std::string,std::allocator< std::string > > const &
        initial_parameters: std::vector< double,std::allocator< double > > const &

        """
        return _IOHprofiler.IOHprofiler_csv_logger_set_parameters_name(self, *args)


    def set_parameters(self, *args):
        """
        set_parameters(self, parameters)

        Parameters
        ----------
        parameters: std::vector< std::shared_ptr< double >,std::allocator< std::shared_ptr< double > > > const &

        set_parameters(self, parameters, parameters_name)

        Parameters
        ----------
        parameters: std::vector< std::shared_ptr< double >,std::allocator< std::shared_ptr< double > > > const &
        parameters_name: std::vector< std::string,std::allocator< std::string > > const &

        set_parameters(self, parameters_name, parameters)

        Parameters
        ----------
        parameters_name: std::vector< std::string,std::allocator< std::string > > const &
        parameters: std::vector< double,std::allocator< double > > const &

        """
        return _IOHprofiler.IOHprofiler_csv_logger_set_parameters(self, *args)

IOHprofiler_csv_logger_swigregister = _IOHprofiler.IOHprofiler_csv_logger_swigregister
IOHprofiler_csv_logger_swigregister(IOHprofiler_csv_logger)
coco_pi = cvar.coco_pi

IOHprofiler_PATH_MAX = _IOHprofiler.IOHprofiler_PATH_MAX
IOHprofiler_MAX_DIMENSION = _IOHprofiler.IOHprofiler_MAX_DIMENSION
DEFAULT_PROBLEM_ID = _IOHprofiler.DEFAULT_PROBLEM_ID
DEFAULT_INSTANCE = _IOHprofiler.DEFAULT_INSTANCE
DEFAULT_DIMENSION = _IOHprofiler.DEFAULT_DIMENSION
MAX_BUFFER_SIZE = _IOHprofiler.MAX_BUFFER_SIZE
IOH_optimization_type_Minimization = _IOHprofiler.IOH_optimization_type_Minimization
IOH_optimization_type_Maximization = _IOHprofiler.IOH_optimization_type_Maximization

def IOH_error(error_info):
    """
    IOH_error(error_info)

    Parameters
    ----------
    error_info: std::string

    """
    return _IOHprofiler.IOH_error(error_info)

def IOH_warning(warning_info):
    """
    IOH_warning(warning_info)

    Parameters
    ----------
    warning_info: std::string

    """
    return _IOHprofiler.IOH_warning(warning_info)

def IOH_log(*args):
    """
    IOH_log(log_info)

    Parameters
    ----------
    log_info: std::string

    IOH_log(log_info, log_stream)

    Parameters
    ----------
    log_info: std::string
    log_stream: std::ofstream &

    """
    return _IOHprofiler.IOH_log(*args)

def transform_obj_norm_by_dim_evaluate(dimension, y):
    """
    transform_obj_norm_by_dim_evaluate(dimension, y)

    Parameters
    ----------
    dimension: int const
    y: std::vector< double,std::allocator< double > > &

    """
    return _IOHprofiler.transform_obj_norm_by_dim_evaluate(dimension, y)

def transform_obj_oscillate_evaluate(y):
    """
    transform_obj_oscillate_evaluate(y)

    Parameters
    ----------
    y: std::vector< double,std::allocator< double > > &

    """
    return _IOHprofiler.transform_obj_oscillate_evaluate(y)

def transform_obj_penalize_evaluate(x, lower_bounds, upper_bounds, factor, y):
    """
    transform_obj_penalize_evaluate(x, lower_bounds, upper_bounds, factor, y)

    Parameters
    ----------
    x: std::vector< double,std::allocator< double > > const &
    lower_bounds: double const
    upper_bounds: double const
    factor: double const
    y: std::vector< double,std::allocator< double > > &

    """
    return _IOHprofiler.transform_obj_penalize_evaluate(x, lower_bounds, upper_bounds, factor, y)

def transform_obj_power_evaluate(y, exponent):
    """
    transform_obj_power_evaluate(y, exponent)

    Parameters
    ----------
    y: std::vector< double,std::allocator< double > > &
    exponent: double const

    """
    return _IOHprofiler.transform_obj_power_evaluate(y, exponent)

def transform_obj_scale_evaluate_function(y, factor):
    """
    transform_obj_scale_evaluate_function(y, factor)

    Parameters
    ----------
    y: std::vector< double,std::allocator< double > > &
    factor: double const

    """
    return _IOHprofiler.transform_obj_scale_evaluate_function(y, factor)

def transform_obj_shift_evaluate_function(y, offset):
    """
    transform_obj_shift_evaluate_function(y, offset)

    Parameters
    ----------
    y: std::vector< double,std::allocator< double > > &
    offset: double const

    """
    return _IOHprofiler.transform_obj_shift_evaluate_function(y, offset)

def transform_vars_affine_evaluate_function(x, M, b):
    """
    transform_vars_affine_evaluate_function(x, M, b)

    Parameters
    ----------
    x: std::vector< double,std::allocator< double > > &
    M: std::vector< std::vector< double,std::allocator< double > >,std::allocator< std::vector< double,std::allocator< double > > > > const &
    b: std::vector< double,std::allocator< double > > const &

    """
    return _IOHprofiler.transform_vars_affine_evaluate_function(x, M, b)

def transform_vars_asymmetric_evaluate_function(x, beta):
    """
    transform_vars_asymmetric_evaluate_function(x, beta)

    Parameters
    ----------
    x: std::vector< double,std::allocator< double > > &
    beta: double const

    """
    return _IOHprofiler.transform_vars_asymmetric_evaluate_function(x, beta)

def transform_vars_brs_evaluate(x):
    """
    transform_vars_brs_evaluate(x)

    Parameters
    ----------
    x: std::vector< double,std::allocator< double > > &

    """
    return _IOHprofiler.transform_vars_brs_evaluate(x)

def transform_vars_conditioning_evaluate(x, alpha):
    """
    transform_vars_conditioning_evaluate(x, alpha)

    Parameters
    ----------
    x: std::vector< double,std::allocator< double > > &
    alpha: double const

    """
    return _IOHprofiler.transform_vars_conditioning_evaluate(x, alpha)

def transform_vars_oscillate_evaluate_function(x):
    """
    transform_vars_oscillate_evaluate_function(x)

    Parameters
    ----------
    x: std::vector< double,std::allocator< double > > &

    """
    return _IOHprofiler.transform_vars_oscillate_evaluate_function(x)

def transform_vars_scale_evaluate(x, factor):
    """
    transform_vars_scale_evaluate(x, factor)

    Parameters
    ----------
    x: std::vector< double,std::allocator< double > > &
    factor: double const

    """
    return _IOHprofiler.transform_vars_scale_evaluate(x, factor)

def transform_vars_shift_evaluate_function(x, offset):
    """
    transform_vars_shift_evaluate_function(x, offset)

    Parameters
    ----------
    x: std::vector< double,std::allocator< double > > &
    offset: std::vector< double,std::allocator< double > > const &

    """
    return _IOHprofiler.transform_vars_shift_evaluate_function(x, offset)

def transform_vars_x_hat_evaluate(x, seed):
    """
    transform_vars_x_hat_evaluate(x, seed)

    Parameters
    ----------
    x: std::vector< double,std::allocator< double > > &
    seed: long const

    """
    return _IOHprofiler.transform_vars_x_hat_evaluate(x, seed)

def transform_vars_x_hat_generic_evaluate(x, sign_vector):
    """
    transform_vars_x_hat_generic_evaluate(x, sign_vector)

    Parameters
    ----------
    x: std::vector< double,std::allocator< double > > &
    sign_vector: std::vector< double,std::allocator< double > > const &

    """
    return _IOHprofiler.transform_vars_x_hat_generic_evaluate(x, sign_vector)

def transform_vars_z_hat_evaluate(x, xopt):
    """
    transform_vars_z_hat_evaluate(x, xopt)

    Parameters
    ----------
    x: std::vector< double,std::allocator< double > > &
    xopt: std::vector< double,std::allocator< double > > const &

    """
    return _IOHprofiler.transform_vars_z_hat_evaluate(x, xopt)
class Coco_Transformation_Data(_object):
    """Proxy of C++ Coco_Transformation_Data class."""

    __swig_setmethods__ = {}
    __setattr__ = lambda self, name, value: _swig_setattr(self, Coco_Transformation_Data, name, value)
    __swig_getmethods__ = {}
    __getattr__ = lambda self, name: _swig_getattr(self, Coco_Transformation_Data, name)
    __repr__ = _swig_repr
    __swig_setmethods__["raw_x"] = _IOHprofiler.Coco_Transformation_Data_raw_x_set
    __swig_getmethods__["raw_x"] = _IOHprofiler.Coco_Transformation_Data_raw_x_get
    if _newclass:
        raw_x = _swig_property(_IOHprofiler.Coco_Transformation_Data_raw_x_get, _IOHprofiler.Coco_Transformation_Data_raw_x_set)
    __swig_setmethods__["xopt"] = _IOHprofiler.Coco_Transformation_Data_xopt_set
    __swig_getmethods__["xopt"] = _IOHprofiler.Coco_Transformation_Data_xopt_get
    if _newclass:
        xopt = _swig_property(_IOHprofiler.Coco_Transformation_Data_xopt_get, _IOHprofiler.Coco_Transformation_Data_xopt_set)
    __swig_setmethods__["tmp1"] = _IOHprofiler.Coco_Transformation_Data_tmp1_set
    __swig_getmethods__["tmp1"] = _IOHprofiler.Coco_Transformation_Data_tmp1_get
    if _newclass:
        tmp1 = _swig_property(_IOHprofiler.Coco_Transformation_Data_tmp1_get, _IOHprofiler.Coco_Transformation_Data_tmp1_set)
    __swig_setmethods__["tmp2"] = _IOHprofiler.Coco_Transformation_Data_tmp2_set
    __swig_getmethods__["tmp2"] = _IOHprofiler.Coco_Transformation_Data_tmp2_get
    if _newclass:
        tmp2 = _swig_property(_IOHprofiler.Coco_Transformation_Data_tmp2_get, _IOHprofiler.Coco_Transformation_Data_tmp2_set)
    __swig_setmethods__["fopt"] = _IOHprofiler.Coco_Transformation_Data_fopt_set
    __swig_getmethods__["fopt"] = _IOHprofiler.Coco_Transformation_Data_fopt_get
    if _newclass:
        fopt = _swig_property(_IOHprofiler.Coco_Transformation_Data_fopt_get, _IOHprofiler.Coco_Transformation_Data_fopt_set)
    __swig_setmethods__["penalty_factor"] = _IOHprofiler.Coco_Transformation_Data_penalty_factor_set
    __swig_getmethods__["penalty_factor"] = _IOHprofiler.Coco_Transformation_Data_penalty_factor_get
    if _newclass:
        penalty_factor = _swig_property(_IOHprofiler.Coco_Transformation_Data_penalty_factor_get, _IOHprofiler.Coco_Transformation_Data_penalty_factor_set)
    __swig_setmethods__["factor"] = _IOHprofiler.Coco_Transformation_Data_factor_set
    __swig_getmethods__["factor"] = _IOHprofiler.Coco_Transformation_Data_factor_get
    if _newclass:
        factor = _swig_property(_IOHprofiler.Coco_Transformation_Data_factor_get, _IOHprofiler.Coco_Transformation_Data_factor_set)
    __swig_setmethods__["lower_bound"] = _IOHprofiler.Coco_Transformation_Data_lower_bound_set
    __swig_getmethods__["lower_bound"] = _IOHprofiler.Coco_Transformation_Data_lower_bound_get
    if _newclass:
        lower_bound = _swig_property(_IOHprofiler.Coco_Transformation_Data_lower_bound_get, _IOHprofiler.Coco_Transformation_Data_lower_bound_set)
    __swig_setmethods__["upper_bound"] = _IOHprofiler.Coco_Transformation_Data_upper_bound_set
    __swig_getmethods__["upper_bound"] = _IOHprofiler.Coco_Transformation_Data_upper_bound_get
    if _newclass:
        upper_bound = _swig_property(_IOHprofiler.Coco_Transformation_Data_upper_bound_get, _IOHprofiler.Coco_Transformation_Data_upper_bound_set)
    __swig_setmethods__["M"] = _IOHprofiler.Coco_Transformation_Data_M_set
    __swig_getmethods__["M"] = _IOHprofiler.Coco_Transformation_Data_M_get
    if _newclass:
        M = _swig_property(_IOHprofiler.Coco_Transformation_Data_M_get, _IOHprofiler.Coco_Transformation_Data_M_set)
    __swig_setmethods__["b"] = _IOHprofiler.Coco_Transformation_Data_b_set
    __swig_getmethods__["b"] = _IOHprofiler.Coco_Transformation_Data_b_get
    if _newclass:
        b = _swig_property(_IOHprofiler.Coco_Transformation_Data_b_get, _IOHprofiler.Coco_Transformation_Data_b_set)
    __swig_setmethods__["M1"] = _IOHprofiler.Coco_Transformation_Data_M1_set
    __swig_getmethods__["M1"] = _IOHprofiler.Coco_Transformation_Data_M1_get
    if _newclass:
        M1 = _swig_property(_IOHprofiler.Coco_Transformation_Data_M1_get, _IOHprofiler.Coco_Transformation_Data_M1_set)
    __swig_setmethods__["b1"] = _IOHprofiler.Coco_Transformation_Data_b1_set
    __swig_getmethods__["b1"] = _IOHprofiler.Coco_Transformation_Data_b1_get
    if _newclass:
        b1 = _swig_property(_IOHprofiler.Coco_Transformation_Data_b1_get, _IOHprofiler.Coco_Transformation_Data_b1_set)
    __swig_setmethods__["rot1"] = _IOHprofiler.Coco_Transformation_Data_rot1_set
    __swig_getmethods__["rot1"] = _IOHprofiler.Coco_Transformation_Data_rot1_get
    if _newclass:
        rot1 = _swig_property(_IOHprofiler.Coco_Transformation_Data_rot1_get, _IOHprofiler.Coco_Transformation_Data_rot1_set)
    __swig_setmethods__["rot2"] = _IOHprofiler.Coco_Transformation_Data_rot2_set
    __swig_getmethods__["rot2"] = _IOHprofiler.Coco_Transformation_Data_rot2_get
    if _newclass:
        rot2 = _swig_property(_IOHprofiler.Coco_Transformation_Data_rot2_get, _IOHprofiler.Coco_Transformation_Data_rot2_set)
    __swig_setmethods__["datax"] = _IOHprofiler.Coco_Transformation_Data_datax_set
    __swig_getmethods__["datax"] = _IOHprofiler.Coco_Transformation_Data_datax_get
    if _newclass:
        datax = _swig_property(_IOHprofiler.Coco_Transformation_Data_datax_get, _IOHprofiler.Coco_Transformation_Data_datax_set)
    __swig_setmethods__["dataxx"] = _IOHprofiler.Coco_Transformation_Data_dataxx_set
    __swig_getmethods__["dataxx"] = _IOHprofiler.Coco_Transformation_Data_dataxx_get
    if _newclass:
        dataxx = _swig_property(_IOHprofiler.Coco_Transformation_Data_dataxx_get, _IOHprofiler.Coco_Transformation_Data_dataxx_set)
    __swig_setmethods__["minus_one"] = _IOHprofiler.Coco_Transformation_Data_minus_one_set
    __swig_getmethods__["minus_one"] = _IOHprofiler.Coco_Transformation_Data_minus_one_get
    if _newclass:
        minus_one = _swig_property(_IOHprofiler.Coco_Transformation_Data_minus_one_get, _IOHprofiler.Coco_Transformation_Data_minus_one_set)
    __swig_setmethods__["condition"] = _IOHprofiler.Coco_Transformation_Data_condition_set
    __swig_getmethods__["condition"] = _IOHprofiler.Coco_Transformation_Data_condition_get
    if _newclass:
        condition = _swig_property(_IOHprofiler.Coco_Transformation_Data_condition_get, _IOHprofiler.Coco_Transformation_Data_condition_set)
    __swig_setmethods__["rseed"] = _IOHprofiler.Coco_Transformation_Data_rseed_set
    __swig_getmethods__["rseed"] = _IOHprofiler.Coco_Transformation_Data_rseed_get
    if _newclass:
        rseed = _swig_property(_IOHprofiler.Coco_Transformation_Data_rseed_get, _IOHprofiler.Coco_Transformation_Data_rseed_set)

    def __init__(self):
        """__init__(self) -> Coco_Transformation_Data"""
        this = _IOHprofiler.new_Coco_Transformation_Data()
        try:
            self.this.append(this)
        except __builtin__.Exception:
            self.this = this
    __swig_destroy__ = _IOHprofiler.delete_Coco_Transformation_Data
    __del__ = lambda self: None
Coco_Transformation_Data_swigregister = _IOHprofiler.Coco_Transformation_Data_swigregister
Coco_Transformation_Data_swigregister(Coco_Transformation_Data)


def coco_tranformation_vars(x, problem_id):
    """
    coco_tranformation_vars(x, problem_id)

    Parameters
    ----------
    x: std::vector< double,std::allocator< double > > &
    problem_id: int const

    """
    return _IOHprofiler.coco_tranformation_vars(x, problem_id)

def coco_tranformation_objs(x, y, problem_id):
    """
    coco_tranformation_objs(x, y, problem_id)

    Parameters
    ----------
    x: std::vector< double,std::allocator< double > > const &
    y: std::vector< double,std::allocator< double > > &
    problem_id: int const

    """
    return _IOHprofiler.coco_tranformation_objs(x, y, problem_id)
class Attractive_Sector(IOHprofiler_Problem_double):
    """Proxy of C++ Attractive_Sector class."""

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

    def __init__(self, instance_id=1, dimension=4):
        """
        __init__(self, instance_id=1, dimension=4) -> Attractive_Sector

        Parameters
        ----------
        instance_id: int
        dimension: int

        __init__(self, instance_id=1) -> Attractive_Sector

        Parameters
        ----------
        instance_id: int

        __init__(self) -> Attractive_Sector
        """
        this = _IOHprofiler.new_Attractive_Sector(instance_id, dimension)
        try:
            self.this.append(this)
        except __builtin__.Exception:
            self.this = this
    __swig_destroy__ = _IOHprofiler.delete_Attractive_Sector
    __del__ = lambda self: None

    def prepare_problem(self):
        """
        prepare_problem(self)

        Parameters
        ----------
        self: Attractive_Sector *

        """
        return _IOHprofiler.Attractive_Sector_prepare_problem(self)


    def internal_evaluate(self, x):
        """
        internal_evaluate(self, x) -> double

        Parameters
        ----------
        x: std::vector< double,std::allocator< double > > const &

        """
        return _IOHprofiler.Attractive_Sector_internal_evaluate(self, x)


    def createInstance(instance_id=1, dimension=4):
        """
        createInstance(instance_id=1, dimension=4) -> Attractive_Sector

        Parameters
        ----------
        instance_id: int
        dimension: int

        createInstance(instance_id=1) -> Attractive_Sector

        Parameters
        ----------
        instance_id: int

        createInstance() -> Attractive_Sector
        """
        return _IOHprofiler.Attractive_Sector_createInstance(instance_id, dimension)

    createInstance = staticmethod(createInstance)
Attractive_Sector_swigregister = _IOHprofiler.Attractive_Sector_swigregister
Attractive_Sector_swigregister(Attractive_Sector)

def Attractive_Sector_createInstance(instance_id=1, dimension=4):
    """
    createInstance(instance_id=1, dimension=4) -> Attractive_Sector

    Parameters
    ----------
    instance_id: int
    dimension: int

    createInstance(instance_id=1) -> Attractive_Sector

    Parameters
    ----------
    instance_id: int

    Attractive_Sector_createInstance() -> Attractive_Sector
    """
    return _IOHprofiler.Attractive_Sector_createInstance(instance_id, dimension)

class Bent_Cigar(IOHprofiler_Problem_double):
    """Proxy of C++ Bent_Cigar class."""

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

    def __init__(self, instance_id=1, dimension=4):
        """
        __init__(self, instance_id=1, dimension=4) -> Bent_Cigar

        Parameters
        ----------
        instance_id: int
        dimension: int

        __init__(self, instance_id=1) -> Bent_Cigar

        Parameters
        ----------
        instance_id: int

        __init__(self) -> Bent_Cigar
        """
        this = _IOHprofiler.new_Bent_Cigar(instance_id, dimension)
        try:
            self.this.append(this)
        except __builtin__.Exception:
            self.this = this
    __swig_destroy__ = _IOHprofiler.delete_Bent_Cigar
    __del__ = lambda self: None

    def prepare_problem(self):
        """
        prepare_problem(self)

        Parameters
        ----------
        self: Bent_Cigar *

        """
        return _IOHprofiler.Bent_Cigar_prepare_problem(self)


    def internal_evaluate(self, x):
        """
        internal_evaluate(self, x) -> double

        Parameters
        ----------
        x: std::vector< double,std::allocator< double > > const &

        """
        return _IOHprofiler.Bent_Cigar_internal_evaluate(self, x)


    def createInstance(instance_id=1, dimension=4):
        """
        createInstance(instance_id=1, dimension=4) -> Bent_Cigar

        Parameters
        ----------
        instance_id: int
        dimension: int

        createInstance(instance_id=1) -> Bent_Cigar

        Parameters
        ----------
        instance_id: int

        createInstance() -> Bent_Cigar
        """
        return _IOHprofiler.Bent_Cigar_createInstance(instance_id, dimension)

    createInstance = staticmethod(createInstance)
Bent_Cigar_swigregister = _IOHprofiler.Bent_Cigar_swigregister
Bent_Cigar_swigregister(Bent_Cigar)

def Bent_Cigar_createInstance(instance_id=1, dimension=4):
    """
    createInstance(instance_id=1, dimension=4) -> Bent_Cigar

    Parameters
    ----------
    instance_id: int
    dimension: int

    createInstance(instance_id=1) -> Bent_Cigar

    Parameters
    ----------
    instance_id: int

    Bent_Cigar_createInstance() -> Bent_Cigar
    """
    return _IOHprofiler.Bent_Cigar_createInstance(instance_id, dimension)

class Bueche_Rastrigin(IOHprofiler_Problem_double):
    """Proxy of C++ Bueche_Rastrigin class."""

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

    def __init__(self, instance_id=1, dimension=4):
        """
        __init__(self, instance_id=1, dimension=4) -> Bueche_Rastrigin

        Parameters
        ----------
        instance_id: int
        dimension: int

        __init__(self, instance_id=1) -> Bueche_Rastrigin

        Parameters
        ----------
        instance_id: int

        __init__(self) -> Bueche_Rastrigin
        """
        this = _IOHprofiler.new_Bueche_Rastrigin(instance_id, dimension)
        try:
            self.this.append(this)
        except __builtin__.Exception:
            self.this = this
    __swig_destroy__ = _IOHprofiler.delete_Bueche_Rastrigin
    __del__ = lambda self: None

    def prepare_problem(self):
        """
        prepare_problem(self)

        Parameters
        ----------
        self: Bueche_Rastrigin *

        """
        return _IOHprofiler.Bueche_Rastrigin_prepare_problem(self)


    def internal_evaluate(self, x):
        """
        internal_evaluate(self, x) -> double

        Parameters
        ----------
        x: std::vector< double,std::allocator< double > > const &

        """
        return _IOHprofiler.Bueche_Rastrigin_internal_evaluate(self, x)


    def createInstance(instance_id=1, dimension=4):
        """
        createInstance(instance_id=1, dimension=4) -> Bueche_Rastrigin

        Parameters
        ----------
        instance_id: int
        dimension: int

        createInstance(instance_id=1) -> Bueche_Rastrigin

        Parameters
        ----------
        instance_id: int

        createInstance() -> Bueche_Rastrigin
        """
        return _IOHprofiler.Bueche_Rastrigin_createInstance(instance_id, dimension)

    createInstance = staticmethod(createInstance)
Bueche_Rastrigin_swigregister = _IOHprofiler.Bueche_Rastrigin_swigregister
Bueche_Rastrigin_swigregister(Bueche_Rastrigin)

def Bueche_Rastrigin_createInstance(instance_id=1, dimension=4):
    """
    createInstance(instance_id=1, dimension=4) -> Bueche_Rastrigin

    Parameters
    ----------
    instance_id: int
    dimension: int

    createInstance(instance_id=1) -> Bueche_Rastrigin

    Parameters
    ----------
    instance_id: int

    Bueche_Rastrigin_createInstance() -> Bueche_Rastrigin
    """
    return _IOHprofiler.Bueche_Rastrigin_createInstance(instance_id, dimension)

class Different_Powers(IOHprofiler_Problem_double):
    """Proxy of C++ Different_Powers class."""

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

    def __init__(self, instance_id=1, dimension=4):
        """
        __init__(self, instance_id=1, dimension=4) -> Different_Powers

        Parameters
        ----------
        instance_id: int
        dimension: int

        __init__(self, instance_id=1) -> Different_Powers

        Parameters
        ----------
        instance_id: int

        __init__(self) -> Different_Powers
        """
        this = _IOHprofiler.new_Different_Powers(instance_id, dimension)
        try:
            self.this.append(this)
        except __builtin__.Exception:
            self.this = this
    __swig_destroy__ = _IOHprofiler.delete_Different_Powers
    __del__ = lambda self: None

    def prepare_problem(self):
        """
        prepare_problem(self)

        Parameters
        ----------
        self: Different_Powers *

        """
        return _IOHprofiler.Different_Powers_prepare_problem(self)


    def internal_evaluate(self, x):
        """
        internal_evaluate(self, x) -> double

        Parameters
        ----------
        x: std::vector< double,std::allocator< double > > const &

        """
        return _IOHprofiler.Different_Powers_internal_evaluate(self, x)


    def createInstance(instance_id=1, dimension=4):
        """
        createInstance(instance_id=1, dimension=4) -> Different_Powers

        Parameters
        ----------
        instance_id: int
        dimension: int

        createInstance(instance_id=1) -> Different_Powers

        Parameters
        ----------
        instance_id: int

        createInstance() -> Different_Powers
        """
        return _IOHprofiler.Different_Powers_createInstance(instance_id, dimension)

    createInstance = staticmethod(createInstance)
Different_Powers_swigregister = _IOHprofiler.Different_Powers_swigregister
Different_Powers_swigregister(Different_Powers)

def Different_Powers_createInstance(instance_id=1, dimension=4):
    """
    createInstance(instance_id=1, dimension=4) -> Different_Powers

    Parameters
    ----------
    instance_id: int
    dimension: int

    createInstance(instance_id=1) -> Different_Powers

    Parameters
    ----------
    instance_id: int

    Different_Powers_createInstance() -> Different_Powers
    """
    return _IOHprofiler.Different_Powers_createInstance(instance_id, dimension)

class Discus(IOHprofiler_Problem_double):
    """Proxy of C++ Discus class."""

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

    def __init__(self, instance_id=1, dimension=4):
        """
        __init__(self, instance_id=1, dimension=4) -> Discus

        Parameters
        ----------
        instance_id: int
        dimension: int

        __init__(self, instance_id=1) -> Discus

        Parameters
        ----------
        instance_id: int

        __init__(self) -> Discus
        """
        this = _IOHprofiler.new_Discus(instance_id, dimension)
        try:
            self.this.append(this)
        except __builtin__.Exception:
            self.this = this
    __swig_destroy__ = _IOHprofiler.delete_Discus
    __del__ = lambda self: None

    def prepare_problem(self):
        """
        prepare_problem(self)

        Parameters
        ----------
        self: Discus *

        """
        return _IOHprofiler.Discus_prepare_problem(self)


    def internal_evaluate(self, x):
        """
        internal_evaluate(self, x) -> double

        Parameters
        ----------
        x: std::vector< double,std::allocator< double > > const &

        """
        return _IOHprofiler.Discus_internal_evaluate(self, x)


    def createInstance(instance_id=1, dimension=4):
        """
        createInstance(instance_id=1, dimension=4) -> Discus

        Parameters
        ----------
        instance_id: int
        dimension: int

        createInstance(instance_id=1) -> Discus

        Parameters
        ----------
        instance_id: int

        createInstance() -> Discus
        """
        return _IOHprofiler.Discus_createInstance(instance_id, dimension)

    createInstance = staticmethod(createInstance)
Discus_swigregister = _IOHprofiler.Discus_swigregister
Discus_swigregister(Discus)

def Discus_createInstance(instance_id=1, dimension=4):
    """
    createInstance(instance_id=1, dimension=4) -> Discus

    Parameters
    ----------
    instance_id: int
    dimension: int

    createInstance(instance_id=1) -> Discus

    Parameters
    ----------
    instance_id: int

    Discus_createInstance() -> Discus
    """
    return _IOHprofiler.Discus_createInstance(instance_id, dimension)

class Ellipsoid(IOHprofiler_Problem_double):
    """Proxy of C++ Ellipsoid class."""

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

    def __init__(self, instance_id=1, dimension=4):
        """
        __init__(self, instance_id=1, dimension=4) -> Ellipsoid

        Parameters
        ----------
        instance_id: int
        dimension: int

        __init__(self, instance_id=1) -> Ellipsoid

        Parameters
        ----------
        instance_id: int

        __init__(self) -> Ellipsoid
        """
        this = _IOHprofiler.new_Ellipsoid(instance_id, dimension)
        try:
            self.this.append(this)
        except __builtin__.Exception:
            self.this = this
    __swig_destroy__ = _IOHprofiler.delete_Ellipsoid
    __del__ = lambda self: None

    def prepare_problem(self):
        """
        prepare_problem(self)

        Parameters
        ----------
        self: Ellipsoid *

        """
        return _IOHprofiler.Ellipsoid_prepare_problem(self)


    def internal_evaluate(self, x):
        """
        internal_evaluate(self, x) -> double

        Parameters
        ----------
        x: std::vector< double,std::allocator< double > > const &

        """
        return _IOHprofiler.Ellipsoid_internal_evaluate(self, x)


    def createInstance(instance_id=1, dimension=4):
        """
        createInstance(instance_id=1, dimension=4) -> Ellipsoid

        Parameters
        ----------
        instance_id: int
        dimension: int

        createInstance(instance_id=1) -> Ellipsoid

        Parameters
        ----------
        instance_id: int

        createInstance() -> Ellipsoid
        """
        return _IOHprofiler.Ellipsoid_createInstance(instance_id, dimension)

    createInstance = staticmethod(createInstance)
Ellipsoid_swigregister = _IOHprofiler.Ellipsoid_swigregister
Ellipsoid_swigregister(Ellipsoid)

def Ellipsoid_createInstance(instance_id=1, dimension=4):
    """
    createInstance(instance_id=1, dimension=4) -> Ellipsoid

    Parameters
    ----------
    instance_id: int
    dimension: int

    createInstance(instance_id=1) -> Ellipsoid

    Parameters
    ----------
    instance_id: int

    Ellipsoid_createInstance() -> Ellipsoid
    """
    return _IOHprofiler.Ellipsoid_createInstance(instance_id, dimension)

class Ellipsoid_Rotated(IOHprofiler_Problem_double):
    """Proxy of C++ Ellipsoid_Rotated class."""

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

    def __init__(self, instance_id=1, dimension=4):
        """
        __init__(self, instance_id=1, dimension=4) -> Ellipsoid_Rotated

        Parameters
        ----------
        instance_id: int
        dimension: int

        __init__(self, instance_id=1) -> Ellipsoid_Rotated

        Parameters
        ----------
        instance_id: int

        __init__(self) -> Ellipsoid_Rotated
        """
        this = _IOHprofiler.new_Ellipsoid_Rotated(instance_id, dimension)
        try:
            self.this.append(this)
        except __builtin__.Exception:
            self.this = this
    __swig_destroy__ = _IOHprofiler.delete_Ellipsoid_Rotated
    __del__ = lambda self: None

    def prepare_problem(self):
        """
        prepare_problem(self)

        Parameters
        ----------
        self: Ellipsoid_Rotated *

        """
        return _IOHprofiler.Ellipsoid_Rotated_prepare_problem(self)


    def internal_evaluate(self, x):
        """
        internal_evaluate(self, x) -> double

        Parameters
        ----------
        x: std::vector< double,std::allocator< double > > const &

        """
        return _IOHprofiler.Ellipsoid_Rotated_internal_evaluate(self, x)


    def createInstance(instance_id=1, dimension=4):
        """
        createInstance(instance_id=1, dimension=4) -> Ellipsoid_Rotated

        Parameters
        ----------
        instance_id: int
        dimension: int

        createInstance(instance_id=1) -> Ellipsoid_Rotated

        Parameters
        ----------
        instance_id: int

        createInstance() -> Ellipsoid_Rotated
        """
        return _IOHprofiler.Ellipsoid_Rotated_createInstance(instance_id, dimension)

    createInstance = staticmethod(createInstance)
Ellipsoid_Rotated_swigregister = _IOHprofiler.Ellipsoid_Rotated_swigregister
Ellipsoid_Rotated_swigregister(Ellipsoid_Rotated)

def Ellipsoid_Rotated_createInstance(instance_id=1, dimension=4):
    """
    createInstance(instance_id=1, dimension=4) -> Ellipsoid_Rotated

    Parameters
    ----------
    instance_id: int
    dimension: int

    createInstance(instance_id=1) -> Ellipsoid_Rotated

    Parameters
    ----------
    instance_id: int

    Ellipsoid_Rotated_createInstance() -> Ellipsoid_Rotated
    """
    return _IOHprofiler.Ellipsoid_Rotated_createInstance(instance_id, dimension)

class F_GALLAGHER_PERMUTATION_T1(_object):
    """Proxy of C++ f_gallagher_permutation_t1 class."""

    __swig_setmethods__ = {}
    __setattr__ = lambda self, name, value: _swig_setattr(self, F_GALLAGHER_PERMUTATION_T1, name, value)
    __swig_getmethods__ = {}
    __getattr__ = lambda self, name: _swig_getattr(self, F_GALLAGHER_PERMUTATION_T1, name)
    __repr__ = _swig_repr
    __swig_setmethods__["value"] = _IOHprofiler.F_GALLAGHER_PERMUTATION_T1_value_set
    __swig_getmethods__["value"] = _IOHprofiler.F_GALLAGHER_PERMUTATION_T1_value_get
    if _newclass:
        value = _swig_property(_IOHprofiler.F_GALLAGHER_PERMUTATION_T1_value_get, _IOHprofiler.F_GALLAGHER_PERMUTATION_T1_value_set)
    __swig_setmethods__["index"] = _IOHprofiler.F_GALLAGHER_PERMUTATION_T1_index_set
    __swig_getmethods__["index"] = _IOHprofiler.F_GALLAGHER_PERMUTATION_T1_index_get
    if _newclass:
        index = _swig_property(_IOHprofiler.F_GALLAGHER_PERMUTATION_T1_index_get, _IOHprofiler.F_GALLAGHER_PERMUTATION_T1_index_set)

    def __init__(self):
        """__init__(self) -> F_GALLAGHER_PERMUTATION_T1"""
        this = _IOHprofiler.new_F_GALLAGHER_PERMUTATION_T1()
        try:
            self.this.append(this)
        except __builtin__.Exception:
            self.this = this
    __swig_destroy__ = _IOHprofiler.delete_F_GALLAGHER_PERMUTATION_T1
    __del__ = lambda self: None
F_GALLAGHER_PERMUTATION_T1_swigregister = _IOHprofiler.F_GALLAGHER_PERMUTATION_T1_swigregister
F_GALLAGHER_PERMUTATION_T1_swigregister(F_GALLAGHER_PERMUTATION_T1)


def f_gallagher_compare_doubles1(a, b):
    """
    f_gallagher_compare_doubles1(a, b) -> int

    Parameters
    ----------
    a: void const *
    b: void const *

    """
    return _IOHprofiler.f_gallagher_compare_doubles1(a, b)
class Gallagher101(IOHprofiler_Problem_double):
    """Proxy of C++ Gallagher101 class."""

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

    def __init__(self, instance_id=1, dimension=4):
        """
        __init__(self, instance_id=1, dimension=4) -> Gallagher101

        Parameters
        ----------
        instance_id: int
        dimension: int

        __init__(self, instance_id=1) -> Gallagher101

        Parameters
        ----------
        instance_id: int

        __init__(self) -> Gallagher101
        """
        this = _IOHprofiler.new_Gallagher101(instance_id, dimension)
        try:
            self.this.append(this)
        except __builtin__.Exception:
            self.this = this
    __swig_destroy__ = _IOHprofiler.delete_Gallagher101
    __del__ = lambda self: None
    __swig_setmethods__["xopt"] = _IOHprofiler.Gallagher101_xopt_set
    __swig_getmethods__["xopt"] = _IOHprofiler.Gallagher101_xopt_get
    if _newclass:
        xopt = _swig_property(_IOHprofiler.Gallagher101_xopt_get, _IOHprofiler.Gallagher101_xopt_set)
    __swig_getmethods__["number_of_peaks"] = _IOHprofiler.Gallagher101_number_of_peaks_get
    if _newclass:
        number_of_peaks = _swig_property(_IOHprofiler.Gallagher101_number_of_peaks_get)
    __swig_setmethods__["rotation"] = _IOHprofiler.Gallagher101_rotation_set
    __swig_getmethods__["rotation"] = _IOHprofiler.Gallagher101_rotation_get
    if _newclass:
        rotation = _swig_property(_IOHprofiler.Gallagher101_rotation_get, _IOHprofiler.Gallagher101_rotation_set)
    __swig_setmethods__["arr_scales"] = _IOHprofiler.Gallagher101_arr_scales_set
    __swig_getmethods__["arr_scales"] = _IOHprofiler.Gallagher101_arr_scales_get
    if _newclass:
        arr_scales = _swig_property(_IOHprofiler.Gallagher101_arr_scales_get, _IOHprofiler.Gallagher101_arr_scales_set)
    __swig_setmethods__["x_local"] = _IOHprofiler.Gallagher101_x_local_set
    __swig_getmethods__["x_local"] = _IOHprofiler.Gallagher101_x_local_get
    if _newclass:
        x_local = _swig_property(_IOHprofiler.Gallagher101_x_local_get, _IOHprofiler.Gallagher101_x_local_set)
    __swig_setmethods__["peak_values"] = _IOHprofiler.Gallagher101_peak_values_set
    __swig_getmethods__["peak_values"] = _IOHprofiler.Gallagher101_peak_values_get
    if _newclass:
        peak_values = _swig_property(_IOHprofiler.Gallagher101_peak_values_get, _IOHprofiler.Gallagher101_peak_values_set)

    def prepare_problem(self):
        """
        prepare_problem(self)

        Parameters
        ----------
        self: Gallagher101 *

        """
        return _IOHprofiler.Gallagher101_prepare_problem(self)


    def internal_evaluate(self, x):
        """
        internal_evaluate(self, x) -> double

        Parameters
        ----------
        x: std::vector< double,std::allocator< double > > const &

        """
        return _IOHprofiler.Gallagher101_internal_evaluate(self, x)


    def createInstance(instance_id=1, dimension=4):
        """
        createInstance(instance_id=1, dimension=4) -> Gallagher101

        Parameters
        ----------
        instance_id: int
        dimension: int

        createInstance(instance_id=1) -> Gallagher101

        Parameters
        ----------
        instance_id: int

        createInstance() -> Gallagher101
        """
        return _IOHprofiler.Gallagher101_createInstance(instance_id, dimension)

    createInstance = staticmethod(createInstance)
Gallagher101_swigregister = _IOHprofiler.Gallagher101_swigregister
Gallagher101_swigregister(Gallagher101)

def Gallagher101_createInstance(instance_id=1, dimension=4):
    """
    createInstance(instance_id=1, dimension=4) -> Gallagher101

    Parameters
    ----------
    instance_id: int
    dimension: int

    createInstance(instance_id=1) -> Gallagher101

    Parameters
    ----------
    instance_id: int

    Gallagher101_createInstance() -> Gallagher101
    """
    return _IOHprofiler.Gallagher101_createInstance(instance_id, dimension)

class F_GALLAGHER_PERMUTATION_T(_object):
    """Proxy of C++ f_gallagher_permutation_t class."""

    __swig_setmethods__ = {}
    __setattr__ = lambda self, name, value: _swig_setattr(self, F_GALLAGHER_PERMUTATION_T, name, value)
    __swig_getmethods__ = {}
    __getattr__ = lambda self, name: _swig_getattr(self, F_GALLAGHER_PERMUTATION_T, name)
    __repr__ = _swig_repr
    __swig_setmethods__["value"] = _IOHprofiler.F_GALLAGHER_PERMUTATION_T_value_set
    __swig_getmethods__["value"] = _IOHprofiler.F_GALLAGHER_PERMUTATION_T_value_get
    if _newclass:
        value = _swig_property(_IOHprofiler.F_GALLAGHER_PERMUTATION_T_value_get, _IOHprofiler.F_GALLAGHER_PERMUTATION_T_value_set)
    __swig_setmethods__["index"] = _IOHprofiler.F_GALLAGHER_PERMUTATION_T_index_set
    __swig_getmethods__["index"] = _IOHprofiler.F_GALLAGHER_PERMUTATION_T_index_get
    if _newclass:
        index = _swig_property(_IOHprofiler.F_GALLAGHER_PERMUTATION_T_index_get, _IOHprofiler.F_GALLAGHER_PERMUTATION_T_index_set)

    def __init__(self):
        """__init__(self) -> F_GALLAGHER_PERMUTATION_T"""
        this = _IOHprofiler.new_F_GALLAGHER_PERMUTATION_T()
        try:
            self.this.append(this)
        except __builtin__.Exception:
            self.this = this
    __swig_destroy__ = _IOHprofiler.delete_F_GALLAGHER_PERMUTATION_T
    __del__ = lambda self: None
F_GALLAGHER_PERMUTATION_T_swigregister = _IOHprofiler.F_GALLAGHER_PERMUTATION_T_swigregister
F_GALLAGHER_PERMUTATION_T_swigregister(F_GALLAGHER_PERMUTATION_T)


def f_gallagher_compare_doubles(a, b):
    """
    f_gallagher_compare_doubles(a, b) -> int

    Parameters
    ----------
    a: void const *
    b: void const *

    """
    return _IOHprofiler.f_gallagher_compare_doubles(a, b)
class Gallagher21(IOHprofiler_Problem_double):
    """Proxy of C++ Gallagher21 class."""

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

    def __init__(self, instance_id=1, dimension=4):
        """
        __init__(self, instance_id=1, dimension=4) -> Gallagher21

        Parameters
        ----------
        instance_id: int
        dimension: int

        __init__(self, instance_id=1) -> Gallagher21

        Parameters
        ----------
        instance_id: int

        __init__(self) -> Gallagher21
        """
        this = _IOHprofiler.new_Gallagher21(instance_id, dimension)
        try:
            self.this.append(this)
        except __builtin__.Exception:
            self.this = this
    __swig_destroy__ = _IOHprofiler.delete_Gallagher21
    __del__ = lambda self: None
    __swig_setmethods__["xopt"] = _IOHprofiler.Gallagher21_xopt_set
    __swig_getmethods__["xopt"] = _IOHprofiler.Gallagher21_xopt_get
    if _newclass:
        xopt = _swig_property(_IOHprofiler.Gallagher21_xopt_get, _IOHprofiler.Gallagher21_xopt_set)
    __swig_getmethods__["number_of_peaks"] = _IOHprofiler.Gallagher21_number_of_peaks_get
    if _newclass:
        number_of_peaks = _swig_property(_IOHprofiler.Gallagher21_number_of_peaks_get)
    __swig_setmethods__["rotation"] = _IOHprofiler.Gallagher21_rotation_set
    __swig_getmethods__["rotation"] = _IOHprofiler.Gallagher21_rotation_get
    if _newclass:
        rotation = _swig_property(_IOHprofiler.Gallagher21_rotation_get, _IOHprofiler.Gallagher21_rotation_set)
    __swig_setmethods__["arr_scales"] = _IOHprofiler.Gallagher21_arr_scales_set
    __swig_getmethods__["arr_scales"] = _IOHprofiler.Gallagher21_arr_scales_get
    if _newclass:
        arr_scales = _swig_property(_IOHprofiler.Gallagher21_arr_scales_get, _IOHprofiler.Gallagher21_arr_scales_set)
    __swig_setmethods__["x_local"] = _IOHprofiler.Gallagher21_x_local_set
    __swig_getmethods__["x_local"] = _IOHprofiler.Gallagher21_x_local_get
    if _newclass:
        x_local = _swig_property(_IOHprofiler.Gallagher21_x_local_get, _IOHprofiler.Gallagher21_x_local_set)
    __swig_setmethods__["peak_values"] = _IOHprofiler.Gallagher21_peak_values_set
    __swig_getmethods__["peak_values"] = _IOHprofiler.Gallagher21_peak_values_get
    if _newclass:
        peak_values = _swig_property(_IOHprofiler.Gallagher21_peak_values_get, _IOHprofiler.Gallagher21_peak_values_set)

    def prepare_problem(self):
        """
        prepare_problem(self)

        Parameters
        ----------
        self: Gallagher21 *

        """
        return _IOHprofiler.Gallagher21_prepare_problem(self)


    def internal_evaluate(self, x):
        """
        internal_evaluate(self, x) -> double

        Parameters
        ----------
        x: std::vector< double,std::allocator< double > > const &

        """
        return _IOHprofiler.Gallagher21_internal_evaluate(self, x)


    def createInstance(instance_id=1, dimension=4):
        """
        createInstance(instance_id=1, dimension=4) -> Gallagher21

        Parameters
        ----------
        instance_id: int
        dimension: int

        createInstance(instance_id=1) -> Gallagher21

        Parameters
        ----------
        instance_id: int

        createInstance() -> Gallagher21
        """
        return _IOHprofiler.Gallagher21_createInstance(instance_id, dimension)

    createInstance = staticmethod(createInstance)
Gallagher21_swigregister = _IOHprofiler.Gallagher21_swigregister
Gallagher21_swigregister(Gallagher21)

def Gallagher21_createInstance(instance_id=1, dimension=4):
    """
    createInstance(instance_id=1, dimension=4) -> Gallagher21

    Parameters
    ----------
    instance_id: int
    dimension: int

    createInstance(instance_id=1) -> Gallagher21

    Parameters
    ----------
    instance_id: int

    Gallagher21_createInstance() -> Gallagher21
    """
    return _IOHprofiler.Gallagher21_createInstance(instance_id, dimension)

class Griewank_RosenBrock(IOHprofiler_Problem_double):
    """Proxy of C++ Griewank_RosenBrock class."""

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

    def __init__(self, instance_id=1, dimension=4):
        """
        __init__(self, instance_id=1, dimension=4) -> Griewank_RosenBrock

        Parameters
        ----------
        instance_id: int
        dimension: int

        __init__(self, instance_id=1) -> Griewank_RosenBrock

        Parameters
        ----------
        instance_id: int

        __init__(self) -> Griewank_RosenBrock
        """
        this = _IOHprofiler.new_Griewank_RosenBrock(instance_id, dimension)
        try:
            self.this.append(this)
        except __builtin__.Exception:
            self.this = this
    __swig_destroy__ = _IOHprofiler.delete_Griewank_RosenBrock
    __del__ = lambda self: None
    __swig_setmethods__["scales"] = _IOHprofiler.Griewank_RosenBrock_scales_set
    __swig_getmethods__["scales"] = _IOHprofiler.Griewank_RosenBrock_scales_get
    if _newclass:
        scales = _swig_property(_IOHprofiler.Griewank_RosenBrock_scales_get, _IOHprofiler.Griewank_RosenBrock_scales_set)

    def prepare_problem(self):
        """
        prepare_problem(self)

        Parameters
        ----------
        self: Griewank_RosenBrock *

        """
        return _IOHprofiler.Griewank_RosenBrock_prepare_problem(self)


    def internal_evaluate(self, x):
        """
        internal_evaluate(self, x) -> double

        Parameters
        ----------
        x: std::vector< double,std::allocator< double > > const &

        """
        return _IOHprofiler.Griewank_RosenBrock_internal_evaluate(self, x)


    def createInstance(instance_id=1, dimension=4):
        """
        createInstance(instance_id=1, dimension=4) -> Griewank_RosenBrock

        Parameters
        ----------
        instance_id: int
        dimension: int

        createInstance(instance_id=1) -> Griewank_RosenBrock

        Parameters
        ----------
        instance_id: int

        createInstance() -> Griewank_RosenBrock
        """
        return _IOHprofiler.Griewank_RosenBrock_createInstance(instance_id, dimension)

    createInstance = staticmethod(createInstance)
Griewank_RosenBrock_swigregister = _IOHprofiler.Griewank_RosenBrock_swigregister
Griewank_RosenBrock_swigregister(Griewank_RosenBrock)

def Griewank_RosenBrock_createInstance(instance_id=1, dimension=4):
    """
    createInstance(instance_id=1, dimension=4) -> Griewank_RosenBrock

    Parameters
    ----------
    instance_id: int
    dimension: int

    createInstance(instance_id=1) -> Griewank_RosenBrock

    Parameters
    ----------
    instance_id: int

    Griewank_RosenBrock_createInstance() -> Griewank_RosenBrock
    """
    return _IOHprofiler.Griewank_RosenBrock_createInstance(instance_id, dimension)

class Rastrigin(IOHprofiler_Problem_double):
    """Proxy of C++ Rastrigin class."""

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

    def __init__(self, instance_id=1, dimension=4):
        """
        __init__(self, instance_id=1, dimension=4) -> Rastrigin

        Parameters
        ----------
        instance_id: int
        dimension: int

        __init__(self, instance_id=1) -> Rastrigin

        Parameters
        ----------
        instance_id: int

        __init__(self) -> Rastrigin
        """
        this = _IOHprofiler.new_Rastrigin(instance_id, dimension)
        try:
            self.this.append(this)
        except __builtin__.Exception:
            self.this = this
    __swig_destroy__ = _IOHprofiler.delete_Rastrigin
    __del__ = lambda self: None

    def prepare_problem(self):
        """
        prepare_problem(self)

        Parameters
        ----------
        self: Rastrigin *

        """
        return _IOHprofiler.Rastrigin_prepare_problem(self)


    def internal_evaluate(self, x):
        """
        internal_evaluate(self, x) -> double

        Parameters
        ----------
        x: std::vector< double,std::allocator< double > > const &

        """
        return _IOHprofiler.Rastrigin_internal_evaluate(self, x)


    def createInstance(instance_id=1, dimension=4):
        """
        createInstance(instance_id=1, dimension=4) -> Rastrigin

        Parameters
        ----------
        instance_id: int
        dimension: int

        createInstance(instance_id=1) -> Rastrigin

        Parameters
        ----------
        instance_id: int

        createInstance() -> Rastrigin
        """
        return _IOHprofiler.Rastrigin_createInstance(instance_id, dimension)

    createInstance = staticmethod(createInstance)
Rastrigin_swigregister = _IOHprofiler.Rastrigin_swigregister
Rastrigin_swigregister(Rastrigin)

def Rastrigin_createInstance(instance_id=1, dimension=4):
    """
    createInstance(instance_id=1, dimension=4) -> Rastrigin

    Parameters
    ----------
    instance_id: int
    dimension: int

    createInstance(instance_id=1) -> Rastrigin

    Parameters
    ----------
    instance_id: int

    Rastrigin_createInstance() -> Rastrigin
    """
    return _IOHprofiler.Rastrigin_createInstance(instance_id, dimension)

class Rastrigin_Rotated(IOHprofiler_Problem_double):
    """Proxy of C++ Rastrigin_Rotated class."""

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

    def __init__(self, instance_id=1, dimension=4):
        """
        __init__(self, instance_id=1, dimension=4) -> Rastrigin_Rotated

        Parameters
        ----------
        instance_id: int
        dimension: int

        __init__(self, instance_id=1) -> Rastrigin_Rotated

        Parameters
        ----------
        instance_id: int

        __init__(self) -> Rastrigin_Rotated
        """
        this = _IOHprofiler.new_Rastrigin_Rotated(instance_id, dimension)
        try:
            self.this.append(this)
        except __builtin__.Exception:
            self.this = this
    __swig_destroy__ = _IOHprofiler.delete_Rastrigin_Rotated
    __del__ = lambda self: None

    def prepare_problem(self):
        """
        prepare_problem(self)

        Parameters
        ----------
        self: Rastrigin_Rotated *

        """
        return _IOHprofiler.Rastrigin_Rotated_prepare_problem(self)


    def internal_evaluate(self, x):
        """
        internal_evaluate(self, x) -> double

        Parameters
        ----------
        x: std::vector< double,std::allocator< double > > const &

        """
        return _IOHprofiler.Rastrigin_Rotated_internal_evaluate(self, x)


    def createInstance(instance_id=1, dimension=4):
        """
        createInstance(instance_id=1, dimension=4) -> Rastrigin_Rotated

        Parameters
        ----------
        instance_id: int
        dimension: int

        createInstance(instance_id=1) -> Rastrigin_Rotated

        Parameters
        ----------
        instance_id: int

        createInstance() -> Rastrigin_Rotated
        """
        return _IOHprofiler.Rastrigin_Rotated_createInstance(instance_id, dimension)

    createInstance = staticmethod(createInstance)
Rastrigin_Rotated_swigregister = _IOHprofiler.Rastrigin_Rotated_swigregister
Rastrigin_Rotated_swigregister(Rastrigin_Rotated)

def Rastrigin_Rotated_createInstance(instance_id=1, dimension=4):
    """
    createInstance(instance_id=1, dimension=4) -> Rastrigin_Rotated

    Parameters
    ----------
    instance_id: int
    dimension: int

    createInstance(instance_id=1) -> Rastrigin_Rotated

    Parameters
    ----------
    instance_id: int

    Rastrigin_Rotated_createInstance() -> Rastrigin_Rotated
    """
    return _IOHprofiler.Rastrigin_Rotated_createInstance(instance_id, dimension)

class Rosenbrock(IOHprofiler_Problem_double):
    """Proxy of C++ Rosenbrock class."""

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

    def __init__(self, instance_id=1, dimension=4):
        """
        __init__(self, instance_id=1, dimension=4) -> Rosenbrock

        Parameters
        ----------
        instance_id: int
        dimension: int

        __init__(self, instance_id=1) -> Rosenbrock

        Parameters
        ----------
        instance_id: int

        __init__(self) -> Rosenbrock
        """
        this = _IOHprofiler.new_Rosenbrock(instance_id, dimension)
        try:
            self.this.append(this)
        except __builtin__.Exception:
            self.this = this
    __swig_destroy__ = _IOHprofiler.delete_Rosenbrock
    __del__ = lambda self: None

    def prepare_problem(self):
        """
        prepare_problem(self)

        Parameters
        ----------
        self: Rosenbrock *

        """
        return _IOHprofiler.Rosenbrock_prepare_problem(self)


    def internal_evaluate(self, x):
        """
        internal_evaluate(self, x) -> double

        Parameters
        ----------
        x: std::vector< double,std::allocator< double > > const &

        """
        return _IOHprofiler.Rosenbrock_internal_evaluate(self, x)


    def createInstance(instance_id=1, dimension=4):
        """
        createInstance(instance_id=1, dimension=4) -> Rosenbrock

        Parameters
        ----------
        instance_id: int
        dimension: int

        createInstance(instance_id=1) -> Rosenbrock

        Parameters
        ----------
        instance_id: int

        createInstance() -> Rosenbrock
        """
        return _IOHprofiler.Rosenbrock_createInstance(instance_id, dimension)

    createInstance = staticmethod(createInstance)
Rosenbrock_swigregister = _IOHprofiler.Rosenbrock_swigregister
Rosenbrock_swigregister(Rosenbrock)

def Rosenbrock_createInstance(instance_id=1, dimension=4):
    """
    createInstance(instance_id=1, dimension=4) -> Rosenbrock

    Parameters
    ----------
    instance_id: int
    dimension: int

    createInstance(instance_id=1) -> Rosenbrock

    Parameters
    ----------
    instance_id: int

    Rosenbrock_createInstance() -> Rosenbrock
    """
    return _IOHprofiler.Rosenbrock_createInstance(instance_id, dimension)

class Rosenbrock_Rotated(IOHprofiler_Problem_double):
    """Proxy of C++ Rosenbrock_Rotated class."""

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

    def __init__(self, instance_id=1, dimension=4):
        """
        __init__(self, instance_id=1, dimension=4) -> Rosenbrock_Rotated

        Parameters
        ----------
        instance_id: int
        dimension: int

        __init__(self, instance_id=1) -> Rosenbrock_Rotated

        Parameters
        ----------
        instance_id: int

        __init__(self) -> Rosenbrock_Rotated
        """
        this = _IOHprofiler.new_Rosenbrock_Rotated(instance_id, dimension)
        try:
            self.this.append(this)
        except __builtin__.Exception:
            self.this = this
    __swig_destroy__ = _IOHprofiler.delete_Rosenbrock_Rotated
    __del__ = lambda self: None

    def prepare_problem(self):
        """
        prepare_problem(self)

        Parameters
        ----------
        self: Rosenbrock_Rotated *

        """
        return _IOHprofiler.Rosenbrock_Rotated_prepare_problem(self)


    def internal_evaluate(self, x):
        """
        internal_evaluate(self, x) -> double

        Parameters
        ----------
        x: std::vector< double,std::allocator< double > > const &

        """
        return _IOHprofiler.Rosenbrock_Rotated_internal_evaluate(self, x)


    def createInstance(instance_id=1, dimension=4):
        """
        createInstance(instance_id=1, dimension=4) -> Rosenbrock_Rotated

        Parameters
        ----------
        instance_id: int
        dimension: int

        createInstance(instance_id=1) -> Rosenbrock_Rotated

        Parameters
        ----------
        instance_id: int

        createInstance() -> Rosenbrock_Rotated
        """
        return _IOHprofiler.Rosenbrock_Rotated_createInstance(instance_id, dimension)

    createInstance = staticmethod(createInstance)
Rosenbrock_Rotated_swigregister = _IOHprofiler.Rosenbrock_Rotated_swigregister
Rosenbrock_Rotated_swigregister(Rosenbrock_Rotated)

def Rosenbrock_Rotated_createInstance(instance_id=1, dimension=4):
    """
    createInstance(instance_id=1, dimension=4) -> Rosenbrock_Rotated

    Parameters
    ----------
    instance_id: int
    dimension: int

    createInstance(instance_id=1) -> Rosenbrock_Rotated

    Parameters
    ----------
    instance_id: int

    Rosenbrock_Rotated_createInstance() -> Rosenbrock_Rotated
    """
    return _IOHprofiler.Rosenbrock_Rotated_createInstance(instance_id, dimension)

class Schaffers1000(IOHprofiler_Problem_double):
    """Proxy of C++ Schaffers1000 class."""

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

    def __init__(self, instance_id=1, dimension=4):
        """
        __init__(self, instance_id=1, dimension=4) -> Schaffers1000

        Parameters
        ----------
        instance_id: int
        dimension: int

        __init__(self, instance_id=1) -> Schaffers1000

        Parameters
        ----------
        instance_id: int

        __init__(self) -> Schaffers1000
        """
        this = _IOHprofiler.new_Schaffers1000(instance_id, dimension)
        try:
            self.this.append(this)
        except __builtin__.Exception:
            self.this = this
    __swig_destroy__ = _IOHprofiler.delete_Schaffers1000
    __del__ = lambda self: None
    __swig_getmethods__["conditioning"] = _IOHprofiler.Schaffers1000_conditioning_get
    if _newclass:
        conditioning = _swig_property(_IOHprofiler.Schaffers1000_conditioning_get)

    def prepare_problem(self):
        """
        prepare_problem(self)

        Parameters
        ----------
        self: Schaffers1000 *

        """
        return _IOHprofiler.Schaffers1000_prepare_problem(self)


    def internal_evaluate(self, x):
        """
        internal_evaluate(self, x) -> double

        Parameters
        ----------
        x: std::vector< double,std::allocator< double > > const &

        """
        return _IOHprofiler.Schaffers1000_internal_evaluate(self, x)


    def createInstance(instance_id=1, dimension=4):
        """
        createInstance(instance_id=1, dimension=4) -> Schaffers1000

        Parameters
        ----------
        instance_id: int
        dimension: int

        createInstance(instance_id=1) -> Schaffers1000

        Parameters
        ----------
        instance_id: int

        createInstance() -> Schaffers1000
        """
        return _IOHprofiler.Schaffers1000_createInstance(instance_id, dimension)

    createInstance = staticmethod(createInstance)
Schaffers1000_swigregister = _IOHprofiler.Schaffers1000_swigregister
Schaffers1000_swigregister(Schaffers1000)

def Schaffers1000_createInstance(instance_id=1, dimension=4):
    """
    createInstance(instance_id=1, dimension=4) -> Schaffers1000

    Parameters
    ----------
    instance_id: int
    dimension: int

    createInstance(instance_id=1) -> Schaffers1000

    Parameters
    ----------
    instance_id: int

    Schaffers1000_createInstance() -> Schaffers1000
    """
    return _IOHprofiler.Schaffers1000_createInstance(instance_id, dimension)

class Schaffers10(IOHprofiler_Problem_double):
    """Proxy of C++ Schaffers10 class."""

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

    def __init__(self, instance_id=1, dimension=4):
        """
        __init__(self, instance_id=1, dimension=4) -> Schaffers10

        Parameters
        ----------
        instance_id: int
        dimension: int

        __init__(self, instance_id=1) -> Schaffers10

        Parameters
        ----------
        instance_id: int

        __init__(self) -> Schaffers10
        """
        this = _IOHprofiler.new_Schaffers10(instance_id, dimension)
        try:
            self.this.append(this)
        except __builtin__.Exception:
            self.this = this
    __swig_destroy__ = _IOHprofiler.delete_Schaffers10
    __del__ = lambda self: None
    __swig_getmethods__["conditioning"] = _IOHprofiler.Schaffers10_conditioning_get
    if _newclass:
        conditioning = _swig_property(_IOHprofiler.Schaffers10_conditioning_get)

    def prepare_problem(self):
        """
        prepare_problem(self)

        Parameters
        ----------
        self: Schaffers10 *

        """
        return _IOHprofiler.Schaffers10_prepare_problem(self)


    def internal_evaluate(self, x):
        """
        internal_evaluate(self, x) -> double

        Parameters
        ----------
        x: std::vector< double,std::allocator< double > > const &

        """
        return _IOHprofiler.Schaffers10_internal_evaluate(self, x)


    def createInstance(instance_id=1, dimension=4):
        """
        createInstance(instance_id=1, dimension=4) -> Schaffers10

        Parameters
        ----------
        instance_id: int
        dimension: int

        createInstance(instance_id=1) -> Schaffers10

        Parameters
        ----------
        instance_id: int

        createInstance() -> Schaffers10
        """
        return _IOHprofiler.Schaffers10_createInstance(instance_id, dimension)

    createInstance = staticmethod(createInstance)
Schaffers10_swigregister = _IOHprofiler.Schaffers10_swigregister
Schaffers10_swigregister(Schaffers10)

def Schaffers10_createInstance(instance_id=1, dimension=4):
    """
    createInstance(instance_id=1, dimension=4) -> Schaffers10

    Parameters
    ----------
    instance_id: int
    dimension: int

    createInstance(instance_id=1) -> Schaffers10

    Parameters
    ----------
    instance_id: int

    Schaffers10_createInstance() -> Schaffers10
    """
    return _IOHprofiler.Schaffers10_createInstance(instance_id, dimension)

class Schwefel(IOHprofiler_Problem_double):
    """Proxy of C++ Schwefel class."""

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

    def __init__(self, instance_id=1, dimension=4):
        """
        __init__(self, instance_id=1, dimension=4) -> Schwefel

        Parameters
        ----------
        instance_id: int
        dimension: int

        __init__(self, instance_id=1) -> Schwefel

        Parameters
        ----------
        instance_id: int

        __init__(self) -> Schwefel
        """
        this = _IOHprofiler.new_Schwefel(instance_id, dimension)
        try:
            self.this.append(this)
        except __builtin__.Exception:
            self.this = this
    __swig_destroy__ = _IOHprofiler.delete_Schwefel
    __del__ = lambda self: None

    def prepare_problem(self):
        """
        prepare_problem(self)

        Parameters
        ----------
        self: Schwefel *

        """
        return _IOHprofiler.Schwefel_prepare_problem(self)


    def internal_evaluate(self, x):
        """
        internal_evaluate(self, x) -> double

        Parameters
        ----------
        x: std::vector< double,std::allocator< double > > const &

        """
        return _IOHprofiler.Schwefel_internal_evaluate(self, x)


    def createInstance(instance_id=1, dimension=4):
        """
        createInstance(instance_id=1, dimension=4) -> Schwefel

        Parameters
        ----------
        instance_id: int
        dimension: int

        createInstance(instance_id=1) -> Schwefel

        Parameters
        ----------
        instance_id: int

        createInstance() -> Schwefel
        """
        return _IOHprofiler.Schwefel_createInstance(instance_id, dimension)

    createInstance = staticmethod(createInstance)
Schwefel_swigregister = _IOHprofiler.Schwefel_swigregister
Schwefel_swigregister(Schwefel)

def Schwefel_createInstance(instance_id=1, dimension=4):
    """
    createInstance(instance_id=1, dimension=4) -> Schwefel

    Parameters
    ----------
    instance_id: int
    dimension: int

    createInstance(instance_id=1) -> Schwefel

    Parameters
    ----------
    instance_id: int

    Schwefel_createInstance() -> Schwefel
    """
    return _IOHprofiler.Schwefel_createInstance(instance_id, dimension)

class Sharp_Ridge(IOHprofiler_Problem_double):
    """Proxy of C++ Sharp_Ridge class."""

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

    def __init__(self, instance_id=1, dimension=4):
        """
        __init__(self, instance_id=1, dimension=4) -> Sharp_Ridge

        Parameters
        ----------
        instance_id: int
        dimension: int

        __init__(self, instance_id=1) -> Sharp_Ridge

        Parameters
        ----------
        instance_id: int

        __init__(self) -> Sharp_Ridge
        """
        this = _IOHprofiler.new_Sharp_Ridge(instance_id, dimension)
        try:
            self.this.append(this)
        except __builtin__.Exception:
            self.this = this
    __swig_destroy__ = _IOHprofiler.delete_Sharp_Ridge
    __del__ = lambda self: None

    def prepare_problem(self):
        """
        prepare_problem(self)

        Parameters
        ----------
        self: Sharp_Ridge *

        """
        return _IOHprofiler.Sharp_Ridge_prepare_problem(self)


    def internal_evaluate(self, x):
        """
        internal_evaluate(self, x) -> double

        Parameters
        ----------
        x: std::vector< double,std::allocator< double > > const &

        """
        return _IOHprofiler.Sharp_Ridge_internal_evaluate(self, x)


    def createInstance(instance_id=1, dimension=4):
        """
        createInstance(instance_id=1, dimension=4) -> Sharp_Ridge

        Parameters
        ----------
        instance_id: int
        dimension: int

        createInstance(instance_id=1) -> Sharp_Ridge

        Parameters
        ----------
        instance_id: int

        createInstance() -> Sharp_Ridge
        """
        return _IOHprofiler.Sharp_Ridge_createInstance(instance_id, dimension)

    createInstance = staticmethod(createInstance)
Sharp_Ridge_swigregister = _IOHprofiler.Sharp_Ridge_swigregister
Sharp_Ridge_swigregister(Sharp_Ridge)

def Sharp_Ridge_createInstance(instance_id=1, dimension=4):
    """
    createInstance(instance_id=1, dimension=4) -> Sharp_Ridge

    Parameters
    ----------
    instance_id: int
    dimension: int

    createInstance(instance_id=1) -> Sharp_Ridge

    Parameters
    ----------
    instance_id: int

    Sharp_Ridge_createInstance() -> Sharp_Ridge
    """
    return _IOHprofiler.Sharp_Ridge_createInstance(instance_id, dimension)

class Sphere(IOHprofiler_Problem_double):
    """Proxy of C++ Sphere class."""

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

    def __init__(self, instance_id=1, dimension=4):
        """
        __init__(self, instance_id=1, dimension=4) -> Sphere

        Parameters
        ----------
        instance_id: int
        dimension: int

        __init__(self, instance_id=1) -> Sphere

        Parameters
        ----------
        instance_id: int

        __init__(self) -> Sphere
        """
        this = _IOHprofiler.new_Sphere(instance_id, dimension)
        try:
            self.this.append(this)
        except __builtin__.Exception:
            self.this = this
    __swig_destroy__ = _IOHprofiler.delete_Sphere
    __del__ = lambda self: None

    def prepare_problem(self):
        """
        prepare_problem(self)

        Parameters
        ----------
        self: Sphere *

        """
        return _IOHprofiler.Sphere_prepare_problem(self)


    def internal_evaluate(self, x):
        """
        internal_evaluate(self, x) -> double

        Parameters
        ----------
        x: std::vector< double,std::allocator< double > > const &

        """
        return _IOHprofiler.Sphere_internal_evaluate(self, x)


    def createInstance(instance_id=1, dimension=4):
        """
        createInstance(instance_id=1, dimension=4) -> Sphere

        Parameters
        ----------
        instance_id: int
        dimension: int

        createInstance(instance_id=1) -> Sphere

        Parameters
        ----------
        instance_id: int

        createInstance() -> Sphere
        """
        return _IOHprofiler.Sphere_createInstance(instance_id, dimension)

    createInstance = staticmethod(createInstance)
Sphere_swigregister = _IOHprofiler.Sphere_swigregister
Sphere_swigregister(Sphere)

def Sphere_createInstance(instance_id=1, dimension=4):
    """
    createInstance(instance_id=1, dimension=4) -> Sphere

    Parameters
    ----------
    instance_id: int
    dimension: int

    createInstance(instance_id=1) -> Sphere

    Parameters
    ----------
    instance_id: int

    Sphere_createInstance() -> Sphere
    """
    return _IOHprofiler.Sphere_createInstance(instance_id, dimension)

class Step_Ellipsoid(IOHprofiler_Problem_double):
    """Proxy of C++ Step_Ellipsoid class."""

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

    def __init__(self, instance_id=1, dimension=4):
        """
        __init__(self, instance_id=1, dimension=4) -> Step_Ellipsoid

        Parameters
        ----------
        instance_id: int
        dimension: int

        __init__(self, instance_id=1) -> Step_Ellipsoid

        Parameters
        ----------
        instance_id: int

        __init__(self) -> Step_Ellipsoid
        """
        this = _IOHprofiler.new_Step_Ellipsoid(instance_id, dimension)
        try:
            self.this.append(this)
        except __builtin__.Exception:
            self.this = this
    __swig_destroy__ = _IOHprofiler.delete_Step_Ellipsoid
    __del__ = lambda self: None
    __swig_setmethods__["xopt"] = _IOHprofiler.Step_Ellipsoid_xopt_set
    __swig_getmethods__["xopt"] = _IOHprofiler.Step_Ellipsoid_xopt_get
    if _newclass:
        xopt = _swig_property(_IOHprofiler.Step_Ellipsoid_xopt_get, _IOHprofiler.Step_Ellipsoid_xopt_set)
    __swig_setmethods__["fopt"] = _IOHprofiler.Step_Ellipsoid_fopt_set
    __swig_getmethods__["fopt"] = _IOHprofiler.Step_Ellipsoid_fopt_get
    if _newclass:
        fopt = _swig_property(_IOHprofiler.Step_Ellipsoid_fopt_get, _IOHprofiler.Step_Ellipsoid_fopt_set)
    __swig_setmethods__["rot1"] = _IOHprofiler.Step_Ellipsoid_rot1_set
    __swig_getmethods__["rot1"] = _IOHprofiler.Step_Ellipsoid_rot1_get
    if _newclass:
        rot1 = _swig_property(_IOHprofiler.Step_Ellipsoid_rot1_get, _IOHprofiler.Step_Ellipsoid_rot1_set)
    __swig_setmethods__["rot2"] = _IOHprofiler.Step_Ellipsoid_rot2_set
    __swig_getmethods__["rot2"] = _IOHprofiler.Step_Ellipsoid_rot2_get
    if _newclass:
        rot2 = _swig_property(_IOHprofiler.Step_Ellipsoid_rot2_get, _IOHprofiler.Step_Ellipsoid_rot2_set)
    __swig_setmethods__["datax"] = _IOHprofiler.Step_Ellipsoid_datax_set
    __swig_getmethods__["datax"] = _IOHprofiler.Step_Ellipsoid_datax_get
    if _newclass:
        datax = _swig_property(_IOHprofiler.Step_Ellipsoid_datax_get, _IOHprofiler.Step_Ellipsoid_datax_set)
    __swig_setmethods__["dataxx"] = _IOHprofiler.Step_Ellipsoid_dataxx_set
    __swig_getmethods__["dataxx"] = _IOHprofiler.Step_Ellipsoid_dataxx_get
    if _newclass:
        dataxx = _swig_property(_IOHprofiler.Step_Ellipsoid_dataxx_get, _IOHprofiler.Step_Ellipsoid_dataxx_set)

    def prepare_problem(self):
        """
        prepare_problem(self)

        Parameters
        ----------
        self: Step_Ellipsoid *

        """
        return _IOHprofiler.Step_Ellipsoid_prepare_problem(self)


    def internal_evaluate(self, x):
        """
        internal_evaluate(self, x) -> double

        Parameters
        ----------
        x: std::vector< double,std::allocator< double > > const &

        """
        return _IOHprofiler.Step_Ellipsoid_internal_evaluate(self, x)


    def createInstance(instance_id=1, dimension=4):
        """
        createInstance(instance_id=1, dimension=4) -> Step_Ellipsoid

        Parameters
        ----------
        instance_id: int
        dimension: int

        createInstance(instance_id=1) -> Step_Ellipsoid

        Parameters
        ----------
        instance_id: int

        createInstance() -> Step_Ellipsoid
        """
        return _IOHprofiler.Step_Ellipsoid_createInstance(instance_id, dimension)

    createInstance = staticmethod(createInstance)
Step_Ellipsoid_swigregister = _IOHprofiler.Step_Ellipsoid_swigregister
Step_Ellipsoid_swigregister(Step_Ellipsoid)

def Step_Ellipsoid_createInstance(instance_id=1, dimension=4):
    """
    createInstance(instance_id=1, dimension=4) -> Step_Ellipsoid

    Parameters
    ----------
    instance_id: int
    dimension: int

    createInstance(instance_id=1) -> Step_Ellipsoid

    Parameters
    ----------
    instance_id: int

    Step_Ellipsoid_createInstance() -> Step_Ellipsoid
    """
    return _IOHprofiler.Step_Ellipsoid_createInstance(instance_id, dimension)

F_WEIERSTRASS_SUMMANDS = _IOHprofiler.F_WEIERSTRASS_SUMMANDS
class Weierstrass(IOHprofiler_Problem_double):
    """Proxy of C++ Weierstrass class."""

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

    def __init__(self, instance_id=1, dimension=4):
        """
        __init__(self, instance_id=1, dimension=4) -> Weierstrass

        Parameters
        ----------
        instance_id: int
        dimension: int

        __init__(self, instance_id=1) -> Weierstrass

        Parameters
        ----------
        instance_id: int

        __init__(self) -> Weierstrass
        """
        this = _IOHprofiler.new_Weierstrass(instance_id, dimension)
        try:
            self.this.append(this)
        except __builtin__.Exception:
            self.this = this
    __swig_destroy__ = _IOHprofiler.delete_Weierstrass
    __del__ = lambda self: None
    __swig_getmethods__["condition"] = _IOHprofiler.Weierstrass_condition_get
    if _newclass:
        condition = _swig_property(_IOHprofiler.Weierstrass_condition_get)
    __swig_setmethods__["f0"] = _IOHprofiler.Weierstrass_f0_set
    __swig_getmethods__["f0"] = _IOHprofiler.Weierstrass_f0_get
    if _newclass:
        f0 = _swig_property(_IOHprofiler.Weierstrass_f0_get, _IOHprofiler.Weierstrass_f0_set)
    __swig_setmethods__["ak"] = _IOHprofiler.Weierstrass_ak_set
    __swig_getmethods__["ak"] = _IOHprofiler.Weierstrass_ak_get
    if _newclass:
        ak = _swig_property(_IOHprofiler.Weierstrass_ak_get, _IOHprofiler.Weierstrass_ak_set)
    __swig_setmethods__["bk"] = _IOHprofiler.Weierstrass_bk_set
    __swig_getmethods__["bk"] = _IOHprofiler.Weierstrass_bk_get
    if _newclass:
        bk = _swig_property(_IOHprofiler.Weierstrass_bk_get, _IOHprofiler.Weierstrass_bk_set)

    def prepare_problem(self):
        """
        prepare_problem(self)

        Parameters
        ----------
        self: Weierstrass *

        """
        return _IOHprofiler.Weierstrass_prepare_problem(self)


    def internal_evaluate(self, x):
        """
        internal_evaluate(self, x) -> double

        Parameters
        ----------
        x: std::vector< double,std::allocator< double > > const &

        """
        return _IOHprofiler.Weierstrass_internal_evaluate(self, x)


    def createInstance(instance_id=1, dimension=4):
        """
        createInstance(instance_id=1, dimension=4) -> Weierstrass

        Parameters
        ----------
        instance_id: int
        dimension: int

        createInstance(instance_id=1) -> Weierstrass

        Parameters
        ----------
        instance_id: int

        createInstance() -> Weierstrass
        """
        return _IOHprofiler.Weierstrass_createInstance(instance_id, dimension)

    createInstance = staticmethod(createInstance)
Weierstrass_swigregister = _IOHprofiler.Weierstrass_swigregister
Weierstrass_swigregister(Weierstrass)

def Weierstrass_createInstance(instance_id=1, dimension=4):
    """
    createInstance(instance_id=1, dimension=4) -> Weierstrass

    Parameters
    ----------
    instance_id: int
    dimension: int

    createInstance(instance_id=1) -> Weierstrass

    Parameters
    ----------
    instance_id: int

    Weierstrass_createInstance() -> Weierstrass
    """
    return _IOHprofiler.Weierstrass_createInstance(instance_id, dimension)

class Linear_Slope(IOHprofiler_Problem_double):
    """Proxy of C++ Linear_Slope class."""

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

    def __init__(self, instance_id=1, dimension=4):
        """
        __init__(self, instance_id=1, dimension=4) -> Linear_Slope

        Parameters
        ----------
        instance_id: int
        dimension: int

        __init__(self, instance_id=1) -> Linear_Slope

        Parameters
        ----------
        instance_id: int

        __init__(self) -> Linear_Slope
        """
        this = _IOHprofiler.new_Linear_Slope(instance_id, dimension)
        try:
            self.this.append(this)
        except __builtin__.Exception:
            self.this = this
    __swig_destroy__ = _IOHprofiler.delete_Linear_Slope
    __del__ = lambda self: None

    def prepare_problem(self):
        """
        prepare_problem(self)

        Parameters
        ----------
        self: Linear_Slope *

        """
        return _IOHprofiler.Linear_Slope_prepare_problem(self)


    def internal_evaluate(self, x):
        """
        internal_evaluate(self, x) -> double

        Parameters
        ----------
        x: std::vector< double,std::allocator< double > > const &

        """
        return _IOHprofiler.Linear_Slope_internal_evaluate(self, x)


    def createInstance(instance_id=1, dimension=4):
        """
        createInstance(instance_id=1, dimension=4) -> Linear_Slope

        Parameters
        ----------
        instance_id: int
        dimension: int

        createInstance(instance_id=1) -> Linear_Slope

        Parameters
        ----------
        instance_id: int

        createInstance() -> Linear_Slope
        """
        return _IOHprofiler.Linear_Slope_createInstance(instance_id, dimension)

    createInstance = staticmethod(createInstance)
Linear_Slope_swigregister = _IOHprofiler.Linear_Slope_swigregister
Linear_Slope_swigregister(Linear_Slope)

def Linear_Slope_createInstance(instance_id=1, dimension=4):
    """
    createInstance(instance_id=1, dimension=4) -> Linear_Slope

    Parameters
    ----------
    instance_id: int
    dimension: int

    createInstance(instance_id=1) -> Linear_Slope

    Parameters
    ----------
    instance_id: int

    Linear_Slope_createInstance() -> Linear_Slope
    """
    return _IOHprofiler.Linear_Slope_createInstance(instance_id, dimension)

class Lunacek_Bi_Rastrigin(IOHprofiler_Problem_double):
    """Proxy of C++ Lunacek_Bi_Rastrigin class."""

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

    def __init__(self, instance_id=1, dimension=4):
        """
        __init__(self, instance_id=1, dimension=4) -> Lunacek_Bi_Rastrigin

        Parameters
        ----------
        instance_id: int
        dimension: int

        __init__(self, instance_id=1) -> Lunacek_Bi_Rastrigin

        Parameters
        ----------
        instance_id: int

        __init__(self) -> Lunacek_Bi_Rastrigin
        """
        this = _IOHprofiler.new_Lunacek_Bi_Rastrigin(instance_id, dimension)
        try:
            self.this.append(this)
        except __builtin__.Exception:
            self.this = this
    __swig_destroy__ = _IOHprofiler.delete_Lunacek_Bi_Rastrigin
    __del__ = lambda self: None

    def prepare_problem(self):
        """
        prepare_problem(self)

        Parameters
        ----------
        self: Lunacek_Bi_Rastrigin *

        """
        return _IOHprofiler.Lunacek_Bi_Rastrigin_prepare_problem(self)


    def internal_evaluate(self, x):
        """
        internal_evaluate(self, x) -> double

        Parameters
        ----------
        x: std::vector< double,std::allocator< double > > const &

        """
        return _IOHprofiler.Lunacek_Bi_Rastrigin_internal_evaluate(self, x)


    def createInstance(instance_id=1, dimension=4):
        """
        createInstance(instance_id=1, dimension=4) -> Lunacek_Bi_Rastrigin

        Parameters
        ----------
        instance_id: int
        dimension: int

        createInstance(instance_id=1) -> Lunacek_Bi_Rastrigin

        Parameters
        ----------
        instance_id: int

        createInstance() -> Lunacek_Bi_Rastrigin
        """
        return _IOHprofiler.Lunacek_Bi_Rastrigin_createInstance(instance_id, dimension)

    createInstance = staticmethod(createInstance)
Lunacek_Bi_Rastrigin_swigregister = _IOHprofiler.Lunacek_Bi_Rastrigin_swigregister
Lunacek_Bi_Rastrigin_swigregister(Lunacek_Bi_Rastrigin)

def Lunacek_Bi_Rastrigin_createInstance(instance_id=1, dimension=4):
    """
    createInstance(instance_id=1, dimension=4) -> Lunacek_Bi_Rastrigin

    Parameters
    ----------
    instance_id: int
    dimension: int

    createInstance(instance_id=1) -> Lunacek_Bi_Rastrigin

    Parameters
    ----------
    instance_id: int

    Lunacek_Bi_Rastrigin_createInstance() -> Lunacek_Bi_Rastrigin
    """
    return _IOHprofiler.Lunacek_Bi_Rastrigin_createInstance(instance_id, dimension)

class Katsuura(IOHprofiler_Problem_double):
    """Proxy of C++ Katsuura class."""

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

    def __init__(self, instance_id=1, dimension=4):
        """
        __init__(self, instance_id=1, dimension=4) -> Katsuura

        Parameters
        ----------
        instance_id: int
        dimension: int

        __init__(self, instance_id=1) -> Katsuura

        Parameters
        ----------
        instance_id: int

        __init__(self) -> Katsuura
        """
        this = _IOHprofiler.new_Katsuura(instance_id, dimension)
        try:
            self.this.append(this)
        except __builtin__.Exception:
            self.this = this
    __swig_destroy__ = _IOHprofiler.delete_Katsuura
    __del__ = lambda self: None

    def prepare_problem(self):
        """
        prepare_problem(self)

        Parameters
        ----------
        self: Katsuura *

        """
        return _IOHprofiler.Katsuura_prepare_problem(self)


    def internal_evaluate(self, x):
        """
        internal_evaluate(self, x) -> double

        Parameters
        ----------
        x: std::vector< double,std::allocator< double > > const &

        """
        return _IOHprofiler.Katsuura_internal_evaluate(self, x)


    def createInstance(instance_id=1, dimension=4):
        """
        createInstance(instance_id=1, dimension=4) -> Katsuura

        Parameters
        ----------
        instance_id: int
        dimension: int

        createInstance(instance_id=1) -> Katsuura

        Parameters
        ----------
        instance_id: int

        createInstance() -> Katsuura
        """
        return _IOHprofiler.Katsuura_createInstance(instance_id, dimension)

    createInstance = staticmethod(createInstance)
Katsuura_swigregister = _IOHprofiler.Katsuura_swigregister
Katsuura_swigregister(Katsuura)

def Katsuura_createInstance(instance_id=1, dimension=4):
    """
    createInstance(instance_id=1, dimension=4) -> Katsuura

    Parameters
    ----------
    instance_id: int
    dimension: int

    createInstance(instance_id=1) -> Katsuura

    Parameters
    ----------
    instance_id: int

    Katsuura_createInstance() -> Katsuura
    """
    return _IOHprofiler.Katsuura_createInstance(instance_id, dimension)

class Ising_Ring(IOHprofiler_Problem_int):
    """Proxy of C++ Ising_Ring class."""

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

    def __init__(self, instance_id, dimension):
        """
        __init__(self, instance_id, dimension) -> Ising_Ring

        Parameters
        ----------
        instance_id: int
        dimension: int

        """
        this = _IOHprofiler.new_Ising_Ring(instance_id, dimension)
        try:
            self.this.append(this)
        except __builtin__.Exception:
            self.this = this
    __swig_destroy__ = _IOHprofiler.delete_Ising_Ring
    __del__ = lambda self: None

    def modulo_ising_ring(self, x, N):
        """
        modulo_ising_ring(self, x, N) -> int

        Parameters
        ----------
        x: int
        N: int

        """
        return _IOHprofiler.Ising_Ring_modulo_ising_ring(self, x, N)


    def internal_evaluate(self, x):
        """
        internal_evaluate(self, x) -> double

        Parameters
        ----------
        x: std::vector< int,std::allocator< int > > const &

        """
        return _IOHprofiler.Ising_Ring_internal_evaluate(self, x)


    def createInstance(instance_id=1, dimension=4):
        """
        createInstance(instance_id=1, dimension=4) -> Ising_Ring

        Parameters
        ----------
        instance_id: int
        dimension: int

        createInstance(instance_id=1) -> Ising_Ring

        Parameters
        ----------
        instance_id: int

        createInstance() -> Ising_Ring
        """
        return _IOHprofiler.Ising_Ring_createInstance(instance_id, dimension)

    createInstance = staticmethod(createInstance)
Ising_Ring_swigregister = _IOHprofiler.Ising_Ring_swigregister
Ising_Ring_swigregister(Ising_Ring)

def Ising_Ring_createInstance(instance_id=1, dimension=4):
    """
    createInstance(instance_id=1, dimension=4) -> Ising_Ring

    Parameters
    ----------
    instance_id: int
    dimension: int

    createInstance(instance_id=1) -> Ising_Ring

    Parameters
    ----------
    instance_id: int

    Ising_Ring_createInstance() -> Ising_Ring
    """
    return _IOHprofiler.Ising_Ring_createInstance(instance_id, dimension)

class Ising_Torus(IOHprofiler_Problem_int):
    """Proxy of C++ Ising_Torus class."""

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

    def __init__(self, instance_id=1, dimension=4):
        """
        __init__(self, instance_id=1, dimension=4) -> Ising_Torus

        Parameters
        ----------
        instance_id: int
        dimension: int

        __init__(self, instance_id=1) -> Ising_Torus

        Parameters
        ----------
        instance_id: int

        __init__(self) -> Ising_Torus
        """
        this = _IOHprofiler.new_Ising_Torus(instance_id, dimension)
        try:
            self.this.append(this)
        except __builtin__.Exception:
            self.this = this
    __swig_destroy__ = _IOHprofiler.delete_Ising_Torus
    __del__ = lambda self: None

    def modulo_ising_torus(self, x, N):
        """
        modulo_ising_torus(self, x, N) -> int

        Parameters
        ----------
        x: int
        N: int

        """
        return _IOHprofiler.Ising_Torus_modulo_ising_torus(self, x, N)


    def internal_evaluate(self, x):
        """
        internal_evaluate(self, x) -> double

        Parameters
        ----------
        x: std::vector< int,std::allocator< int > > const &

        """
        return _IOHprofiler.Ising_Torus_internal_evaluate(self, x)


    def createInstance(instance_id=1, dimension=4):
        """
        createInstance(instance_id=1, dimension=4) -> Ising_Torus

        Parameters
        ----------
        instance_id: int
        dimension: int

        createInstance(instance_id=1) -> Ising_Torus

        Parameters
        ----------
        instance_id: int

        createInstance() -> Ising_Torus
        """
        return _IOHprofiler.Ising_Torus_createInstance(instance_id, dimension)

    createInstance = staticmethod(createInstance)
Ising_Torus_swigregister = _IOHprofiler.Ising_Torus_swigregister
Ising_Torus_swigregister(Ising_Torus)

def Ising_Torus_createInstance(instance_id=1, dimension=4):
    """
    createInstance(instance_id=1, dimension=4) -> Ising_Torus

    Parameters
    ----------
    instance_id: int
    dimension: int

    createInstance(instance_id=1) -> Ising_Torus

    Parameters
    ----------
    instance_id: int

    Ising_Torus_createInstance() -> Ising_Torus
    """
    return _IOHprofiler.Ising_Torus_createInstance(instance_id, dimension)

class Ising_Triangular(IOHprofiler_Problem_int):
    """Proxy of C++ Ising_Triangular class."""

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

    def __init__(self, instance_id=1, dimension=4):
        """
        __init__(self, instance_id=1, dimension=4) -> Ising_Triangular

        Parameters
        ----------
        instance_id: int
        dimension: int

        __init__(self, instance_id=1) -> Ising_Triangular

        Parameters
        ----------
        instance_id: int

        __init__(self) -> Ising_Triangular
        """
        this = _IOHprofiler.new_Ising_Triangular(instance_id, dimension)
        try:
            self.this.append(this)
        except __builtin__.Exception:
            self.this = this
    __swig_destroy__ = _IOHprofiler.delete_Ising_Triangular
    __del__ = lambda self: None

    def modulo_ising_triangular(self, x, N):
        """
        modulo_ising_triangular(self, x, N) -> int

        Parameters
        ----------
        x: int
        N: int

        """
        return _IOHprofiler.Ising_Triangular_modulo_ising_triangular(self, x, N)


    def internal_evaluate(self, x):
        """
        internal_evaluate(self, x) -> double

        Parameters
        ----------
        x: std::vector< int,std::allocator< int > > const &

        """
        return _IOHprofiler.Ising_Triangular_internal_evaluate(self, x)


    def createInstance(instance_id=1, dimension=4):
        """
        createInstance(instance_id=1, dimension=4) -> Ising_Triangular

        Parameters
        ----------
        instance_id: int
        dimension: int

        createInstance(instance_id=1) -> Ising_Triangular

        Parameters
        ----------
        instance_id: int

        createInstance() -> Ising_Triangular
        """
        return _IOHprofiler.Ising_Triangular_createInstance(instance_id, dimension)

    createInstance = staticmethod(createInstance)
Ising_Triangular_swigregister = _IOHprofiler.Ising_Triangular_swigregister
Ising_Triangular_swigregister(Ising_Triangular)

def Ising_Triangular_createInstance(instance_id=1, dimension=4):
    """
    createInstance(instance_id=1, dimension=4) -> Ising_Triangular

    Parameters
    ----------
    instance_id: int
    dimension: int

    createInstance(instance_id=1) -> Ising_Triangular

    Parameters
    ----------
    instance_id: int

    Ising_Triangular_createInstance() -> Ising_Triangular
    """
    return _IOHprofiler.Ising_Triangular_createInstance(instance_id, dimension)

class LABS(IOHprofiler_Problem_int):
    """Proxy of C++ LABS class."""

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

    def __init__(self, instance_id=1, dimension=4):
        """
        __init__(self, instance_id=1, dimension=4) -> LABS

        Parameters
        ----------
        instance_id: int
        dimension: int

        __init__(self, instance_id=1) -> LABS

        Parameters
        ----------
        instance_id: int

        __init__(self) -> LABS
        """
        this = _IOHprofiler.new_LABS(instance_id, dimension)
        try:
            self.this.append(this)
        except __builtin__.Exception:
            self.this = this
    __swig_destroy__ = _IOHprofiler.delete_LABS
    __del__ = lambda self: None

    def correlation(self, x, n, k):
        """
        correlation(self, x, n, k) -> double

        Parameters
        ----------
        x: std::vector< int,std::allocator< int > > const
        n: int const
        k: int

        """
        return _IOHprofiler.LABS_correlation(self, x, n, k)


    def internal_evaluate(self, x):
        """
        internal_evaluate(self, x) -> double

        Parameters
        ----------
        x: std::vector< int,std::allocator< int > > const &

        """
        return _IOHprofiler.LABS_internal_evaluate(self, x)


    def createInstance(instance_id=1, dimension=4):
        """
        createInstance(instance_id=1, dimension=4) -> LABS

        Parameters
        ----------
        instance_id: int
        dimension: int

        createInstance(instance_id=1) -> LABS

        Parameters
        ----------
        instance_id: int

        createInstance() -> LABS
        """
        return _IOHprofiler.LABS_createInstance(instance_id, dimension)

    createInstance = staticmethod(createInstance)
LABS_swigregister = _IOHprofiler.LABS_swigregister
LABS_swigregister(LABS)

def LABS_createInstance(instance_id=1, dimension=4):
    """
    createInstance(instance_id=1, dimension=4) -> LABS

    Parameters
    ----------
    instance_id: int
    dimension: int

    createInstance(instance_id=1) -> LABS

    Parameters
    ----------
    instance_id: int

    LABS_createInstance() -> LABS
    """
    return _IOHprofiler.LABS_createInstance(instance_id, dimension)

class LeadingOnes_Dummy1(IOHprofiler_Problem_int):
    """Proxy of C++ LeadingOnes_Dummy1 class."""

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

    def __init__(self, instance_id=1, dimension=4):
        """
        __init__(self, instance_id=1, dimension=4) -> LeadingOnes_Dummy1

        Parameters
        ----------
        instance_id: int
        dimension: int

        __init__(self, instance_id=1) -> LeadingOnes_Dummy1

        Parameters
        ----------
        instance_id: int

        __init__(self) -> LeadingOnes_Dummy1
        """
        this = _IOHprofiler.new_LeadingOnes_Dummy1(instance_id, dimension)
        try:
            self.this.append(this)
        except __builtin__.Exception:
            self.this = this
    __swig_destroy__ = _IOHprofiler.delete_LeadingOnes_Dummy1
    __del__ = lambda self: None
    __swig_setmethods__["info"] = _IOHprofiler.LeadingOnes_Dummy1_info_set
    __swig_getmethods__["info"] = _IOHprofiler.LeadingOnes_Dummy1_info_get
    if _newclass:
        info = _swig_property(_IOHprofiler.LeadingOnes_Dummy1_info_get, _IOHprofiler.LeadingOnes_Dummy1_info_set)

    def prepare_problem(self):
        """
        prepare_problem(self)

        Parameters
        ----------
        self: LeadingOnes_Dummy1 *

        """
        return _IOHprofiler.LeadingOnes_Dummy1_prepare_problem(self)


    def internal_evaluate(self, x):
        """
        internal_evaluate(self, x) -> double

        Parameters
        ----------
        x: std::vector< int,std::allocator< int > > const &

        """
        return _IOHprofiler.LeadingOnes_Dummy1_internal_evaluate(self, x)


    def createInstance(instance_id=1, dimension=4):
        """
        createInstance(instance_id=1, dimension=4) -> LeadingOnes_Dummy1

        Parameters
        ----------
        instance_id: int
        dimension: int

        createInstance(instance_id=1) -> LeadingOnes_Dummy1

        Parameters
        ----------
        instance_id: int

        createInstance() -> LeadingOnes_Dummy1
        """
        return _IOHprofiler.LeadingOnes_Dummy1_createInstance(instance_id, dimension)

    createInstance = staticmethod(createInstance)
LeadingOnes_Dummy1_swigregister = _IOHprofiler.LeadingOnes_Dummy1_swigregister
LeadingOnes_Dummy1_swigregister(LeadingOnes_Dummy1)

def LeadingOnes_Dummy1_createInstance(instance_id=1, dimension=4):
    """
    createInstance(instance_id=1, dimension=4) -> LeadingOnes_Dummy1

    Parameters
    ----------
    instance_id: int
    dimension: int

    createInstance(instance_id=1) -> LeadingOnes_Dummy1

    Parameters
    ----------
    instance_id: int

    LeadingOnes_Dummy1_createInstance() -> LeadingOnes_Dummy1
    """
    return _IOHprofiler.LeadingOnes_Dummy1_createInstance(instance_id, dimension)

class LeadingOnes_Dummy2(IOHprofiler_Problem_int):
    """Proxy of C++ LeadingOnes_Dummy2 class."""

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

    def __init__(self, instance_id=1, dimension=4):
        """
        __init__(self, instance_id=1, dimension=4) -> LeadingOnes_Dummy2

        Parameters
        ----------
        instance_id: int
        dimension: int

        __init__(self, instance_id=1) -> LeadingOnes_Dummy2

        Parameters
        ----------
        instance_id: int

        __init__(self) -> LeadingOnes_Dummy2
        """
        this = _IOHprofiler.new_LeadingOnes_Dummy2(instance_id, dimension)
        try:
            self.this.append(this)
        except __builtin__.Exception:
            self.this = this
    __swig_destroy__ = _IOHprofiler.delete_LeadingOnes_Dummy2
    __del__ = lambda self: None
    __swig_setmethods__["info"] = _IOHprofiler.LeadingOnes_Dummy2_info_set
    __swig_getmethods__["info"] = _IOHprofiler.LeadingOnes_Dummy2_info_get
    if _newclass:
        info = _swig_property(_IOHprofiler.LeadingOnes_Dummy2_info_get, _IOHprofiler.LeadingOnes_Dummy2_info_set)

    def prepare_problem(self):
        """
        prepare_problem(self)

        Parameters
        ----------
        self: LeadingOnes_Dummy2 *

        """
        return _IOHprofiler.LeadingOnes_Dummy2_prepare_problem(self)


    def internal_evaluate(self, x):
        """
        internal_evaluate(self, x) -> double

        Parameters
        ----------
        x: std::vector< int,std::allocator< int > > const &

        """
        return _IOHprofiler.LeadingOnes_Dummy2_internal_evaluate(self, x)


    def createInstance(instance_id=1, dimension=4):
        """
        createInstance(instance_id=1, dimension=4) -> LeadingOnes_Dummy2

        Parameters
        ----------
        instance_id: int
        dimension: int

        createInstance(instance_id=1) -> LeadingOnes_Dummy2

        Parameters
        ----------
        instance_id: int

        createInstance() -> LeadingOnes_Dummy2
        """
        return _IOHprofiler.LeadingOnes_Dummy2_createInstance(instance_id, dimension)

    createInstance = staticmethod(createInstance)
LeadingOnes_Dummy2_swigregister = _IOHprofiler.LeadingOnes_Dummy2_swigregister
LeadingOnes_Dummy2_swigregister(LeadingOnes_Dummy2)

def LeadingOnes_Dummy2_createInstance(instance_id=1, dimension=4):
    """
    createInstance(instance_id=1, dimension=4) -> LeadingOnes_Dummy2

    Parameters
    ----------
    instance_id: int
    dimension: int

    createInstance(instance_id=1) -> LeadingOnes_Dummy2

    Parameters
    ----------
    instance_id: int

    LeadingOnes_Dummy2_createInstance() -> LeadingOnes_Dummy2
    """
    return _IOHprofiler.LeadingOnes_Dummy2_createInstance(instance_id, dimension)

class LeadingOnes_Epistasis(IOHprofiler_Problem_int):
    """Proxy of C++ LeadingOnes_Epistasis class."""

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

    def __init__(self, instance_id=1, dimension=4):
        """
        __init__(self, instance_id=1, dimension=4) -> LeadingOnes_Epistasis

        Parameters
        ----------
        instance_id: int
        dimension: int

        __init__(self, instance_id=1) -> LeadingOnes_Epistasis

        Parameters
        ----------
        instance_id: int

        __init__(self) -> LeadingOnes_Epistasis
        """
        this = _IOHprofiler.new_LeadingOnes_Epistasis(instance_id, dimension)
        try:
            self.this.append(this)
        except __builtin__.Exception:
            self.this = this
    __swig_destroy__ = _IOHprofiler.delete_LeadingOnes_Epistasis
    __del__ = lambda self: None

    def customize_optimal(self):
        """
        customize_optimal(self)

        Parameters
        ----------
        self: LeadingOnes_Epistasis *

        """
        return _IOHprofiler.LeadingOnes_Epistasis_customize_optimal(self)


    def internal_evaluate(self, x):
        """
        internal_evaluate(self, x) -> double

        Parameters
        ----------
        x: std::vector< int,std::allocator< int > > const &

        """
        return _IOHprofiler.LeadingOnes_Epistasis_internal_evaluate(self, x)


    def createInstance(instance_id=1, dimension=4):
        """
        createInstance(instance_id=1, dimension=4) -> LeadingOnes_Epistasis

        Parameters
        ----------
        instance_id: int
        dimension: int

        createInstance(instance_id=1) -> LeadingOnes_Epistasis

        Parameters
        ----------
        instance_id: int

        createInstance() -> LeadingOnes_Epistasis
        """
        return _IOHprofiler.LeadingOnes_Epistasis_createInstance(instance_id, dimension)

    createInstance = staticmethod(createInstance)
LeadingOnes_Epistasis_swigregister = _IOHprofiler.LeadingOnes_Epistasis_swigregister
LeadingOnes_Epistasis_swigregister(LeadingOnes_Epistasis)

def LeadingOnes_Epistasis_createInstance(instance_id=1, dimension=4):
    """
    createInstance(instance_id=1, dimension=4) -> LeadingOnes_Epistasis

    Parameters
    ----------
    instance_id: int
    dimension: int

    createInstance(instance_id=1) -> LeadingOnes_Epistasis

    Parameters
    ----------
    instance_id: int

    LeadingOnes_Epistasis_createInstance() -> LeadingOnes_Epistasis
    """
    return _IOHprofiler.LeadingOnes_Epistasis_createInstance(instance_id, dimension)

class LeadingOnes(IOHprofiler_Problem_int):
    """Proxy of C++ LeadingOnes class."""

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

    def __init__(self, instance_id=1, dimension=4):
        """
        __init__(self, instance_id=1, dimension=4) -> LeadingOnes

        Parameters
        ----------
        instance_id: int
        dimension: int

        __init__(self, instance_id=1) -> LeadingOnes

        Parameters
        ----------
        instance_id: int

        __init__(self) -> LeadingOnes
        """
        this = _IOHprofiler.new_LeadingOnes(instance_id, dimension)
        try:
            self.this.append(this)
        except __builtin__.Exception:
            self.this = this
    __swig_destroy__ = _IOHprofiler.delete_LeadingOnes
    __del__ = lambda self: None

    def internal_evaluate(self, x):
        """
        internal_evaluate(self, x) -> double

        Parameters
        ----------
        x: std::vector< int,std::allocator< int > > const &

        """
        return _IOHprofiler.LeadingOnes_internal_evaluate(self, x)


    def createInstance(instance_id=1, dimension=4):
        """
        createInstance(instance_id=1, dimension=4) -> LeadingOnes

        Parameters
        ----------
        instance_id: int
        dimension: int

        createInstance(instance_id=1) -> LeadingOnes

        Parameters
        ----------
        instance_id: int

        createInstance() -> LeadingOnes
        """
        return _IOHprofiler.LeadingOnes_createInstance(instance_id, dimension)

    createInstance = staticmethod(createInstance)
LeadingOnes_swigregister = _IOHprofiler.LeadingOnes_swigregister
LeadingOnes_swigregister(LeadingOnes)

def LeadingOnes_createInstance(instance_id=1, dimension=4):
    """
    createInstance(instance_id=1, dimension=4) -> LeadingOnes

    Parameters
    ----------
    instance_id: int
    dimension: int

    createInstance(instance_id=1) -> LeadingOnes

    Parameters
    ----------
    instance_id: int

    LeadingOnes_createInstance() -> LeadingOnes
    """
    return _IOHprofiler.LeadingOnes_createInstance(instance_id, dimension)

class LeadingOnes_Neutrality(IOHprofiler_Problem_int):
    """Proxy of C++ LeadingOnes_Neutrality class."""

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

    def __init__(self, instance_id=1, dimension=4):
        """
        __init__(self, instance_id=1, dimension=4) -> LeadingOnes_Neutrality

        Parameters
        ----------
        instance_id: int
        dimension: int

        __init__(self, instance_id=1) -> LeadingOnes_Neutrality

        Parameters
        ----------
        instance_id: int

        __init__(self) -> LeadingOnes_Neutrality
        """
        this = _IOHprofiler.new_LeadingOnes_Neutrality(instance_id, dimension)
        try:
            self.this.append(this)
        except __builtin__.Exception:
            self.this = this
    __swig_destroy__ = _IOHprofiler.delete_LeadingOnes_Neutrality
    __del__ = lambda self: None

    def internal_evaluate(self, x):
        """
        internal_evaluate(self, x) -> double

        Parameters
        ----------
        x: std::vector< int,std::allocator< int > > const &

        """
        return _IOHprofiler.LeadingOnes_Neutrality_internal_evaluate(self, x)


    def createInstance(instance_id=1, dimension=4):
        """
        createInstance(instance_id=1, dimension=4) -> LeadingOnes_Neutrality

        Parameters
        ----------
        instance_id: int
        dimension: int

        createInstance(instance_id=1) -> LeadingOnes_Neutrality

        Parameters
        ----------
        instance_id: int

        createInstance() -> LeadingOnes_Neutrality
        """
        return _IOHprofiler.LeadingOnes_Neutrality_createInstance(instance_id, dimension)

    createInstance = staticmethod(createInstance)
LeadingOnes_Neutrality_swigregister = _IOHprofiler.LeadingOnes_Neutrality_swigregister
LeadingOnes_Neutrality_swigregister(LeadingOnes_Neutrality)

def LeadingOnes_Neutrality_createInstance(instance_id=1, dimension=4):
    """
    createInstance(instance_id=1, dimension=4) -> LeadingOnes_Neutrality

    Parameters
    ----------
    instance_id: int
    dimension: int

    createInstance(instance_id=1) -> LeadingOnes_Neutrality

    Parameters
    ----------
    instance_id: int

    LeadingOnes_Neutrality_createInstance() -> LeadingOnes_Neutrality
    """
    return _IOHprofiler.LeadingOnes_Neutrality_createInstance(instance_id, dimension)

class LeadingOnes_Ruggedness1(IOHprofiler_Problem_int):
    """Proxy of C++ LeadingOnes_Ruggedness1 class."""

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

    def __init__(self, instance_id=1, dimension=4):
        """
        __init__(self, instance_id=1, dimension=4) -> LeadingOnes_Ruggedness1

        Parameters
        ----------
        instance_id: int
        dimension: int

        __init__(self, instance_id=1) -> LeadingOnes_Ruggedness1

        Parameters
        ----------
        instance_id: int

        __init__(self) -> LeadingOnes_Ruggedness1
        """
        this = _IOHprofiler.new_LeadingOnes_Ruggedness1(instance_id, dimension)
        try:
            self.this.append(this)
        except __builtin__.Exception:
            self.this = this
    __swig_destroy__ = _IOHprofiler.delete_LeadingOnes_Ruggedness1
    __del__ = lambda self: None

    def internal_evaluate(self, x):
        """
        internal_evaluate(self, x) -> double

        Parameters
        ----------
        x: std::vector< int,std::allocator< int > > const &

        """
        return _IOHprofiler.LeadingOnes_Ruggedness1_internal_evaluate(self, x)


    def createInstance(instance_id=1, dimension=4):
        """
        createInstance(instance_id=1, dimension=4) -> LeadingOnes_Ruggedness1

        Parameters
        ----------
        instance_id: int
        dimension: int

        createInstance(instance_id=1) -> LeadingOnes_Ruggedness1

        Parameters
        ----------
        instance_id: int

        createInstance() -> LeadingOnes_Ruggedness1
        """
        return _IOHprofiler.LeadingOnes_Ruggedness1_createInstance(instance_id, dimension)

    createInstance = staticmethod(createInstance)
LeadingOnes_Ruggedness1_swigregister = _IOHprofiler.LeadingOnes_Ruggedness1_swigregister
LeadingOnes_Ruggedness1_swigregister(LeadingOnes_Ruggedness1)

def LeadingOnes_Ruggedness1_createInstance(instance_id=1, dimension=4):
    """
    createInstance(instance_id=1, dimension=4) -> LeadingOnes_Ruggedness1

    Parameters
    ----------
    instance_id: int
    dimension: int

    createInstance(instance_id=1) -> LeadingOnes_Ruggedness1

    Parameters
    ----------
    instance_id: int

    LeadingOnes_Ruggedness1_createInstance() -> LeadingOnes_Ruggedness1
    """
    return _IOHprofiler.LeadingOnes_Ruggedness1_createInstance(instance_id, dimension)

class LeadingOnes_Ruggedness2(IOHprofiler_Problem_int):
    """Proxy of C++ LeadingOnes_Ruggedness2 class."""

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

    def __init__(self, instance_id=1, dimension=4):
        """
        __init__(self, instance_id=1, dimension=4) -> LeadingOnes_Ruggedness2

        Parameters
        ----------
        instance_id: int
        dimension: int

        __init__(self, instance_id=1) -> LeadingOnes_Ruggedness2

        Parameters
        ----------
        instance_id: int

        __init__(self) -> LeadingOnes_Ruggedness2
        """
        this = _IOHprofiler.new_LeadingOnes_Ruggedness2(instance_id, dimension)
        try:
            self.this.append(this)
        except __builtin__.Exception:
            self.this = this
    __swig_destroy__ = _IOHprofiler.delete_LeadingOnes_Ruggedness2
    __del__ = lambda self: None

    def internal_evaluate(self, x):
        """
        internal_evaluate(self, x) -> double

        Parameters
        ----------
        x: std::vector< int,std::allocator< int > > const &

        """
        return _IOHprofiler.LeadingOnes_Ruggedness2_internal_evaluate(self, x)


    def createInstance(instance_id=1, dimension=4):
        """
        createInstance(instance_id=1, dimension=4) -> LeadingOnes_Ruggedness2

        Parameters
        ----------
        instance_id: int
        dimension: int

        createInstance(instance_id=1) -> LeadingOnes_Ruggedness2

        Parameters
        ----------
        instance_id: int

        createInstance() -> LeadingOnes_Ruggedness2
        """
        return _IOHprofiler.LeadingOnes_Ruggedness2_createInstance(instance_id, dimension)

    createInstance = staticmethod(createInstance)
LeadingOnes_Ruggedness2_swigregister = _IOHprofiler.LeadingOnes_Ruggedness2_swigregister
LeadingOnes_Ruggedness2_swigregister(LeadingOnes_Ruggedness2)

def LeadingOnes_Ruggedness2_createInstance(instance_id=1, dimension=4):
    """
    createInstance(instance_id=1, dimension=4) -> LeadingOnes_Ruggedness2

    Parameters
    ----------
    instance_id: int
    dimension: int

    createInstance(instance_id=1) -> LeadingOnes_Ruggedness2

    Parameters
    ----------
    instance_id: int

    LeadingOnes_Ruggedness2_createInstance() -> LeadingOnes_Ruggedness2
    """
    return _IOHprofiler.LeadingOnes_Ruggedness2_createInstance(instance_id, dimension)

class LeadingOnes_Ruggedness3(IOHprofiler_Problem_int):
    """Proxy of C++ LeadingOnes_Ruggedness3 class."""

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

    def __init__(self, instance_id=1, dimension=4):
        """
        __init__(self, instance_id=1, dimension=4) -> LeadingOnes_Ruggedness3

        Parameters
        ----------
        instance_id: int
        dimension: int

        __init__(self, instance_id=1) -> LeadingOnes_Ruggedness3

        Parameters
        ----------
        instance_id: int

        __init__(self) -> LeadingOnes_Ruggedness3
        """
        this = _IOHprofiler.new_LeadingOnes_Ruggedness3(instance_id, dimension)
        try:
            self.this.append(this)
        except __builtin__.Exception:
            self.this = this
    __swig_destroy__ = _IOHprofiler.delete_LeadingOnes_Ruggedness3
    __del__ = lambda self: None

    def Initilize_problem(self, dimension):
        """
        Initilize_problem(self, dimension)

        Parameters
        ----------
        dimension: int

        """
        return _IOHprofiler.LeadingOnes_Ruggedness3_Initilize_problem(self, dimension)

    __swig_setmethods__["info"] = _IOHprofiler.LeadingOnes_Ruggedness3_info_set
    __swig_getmethods__["info"] = _IOHprofiler.LeadingOnes_Ruggedness3_info_get
    if _newclass:
        info = _swig_property(_IOHprofiler.LeadingOnes_Ruggedness3_info_get, _IOHprofiler.LeadingOnes_Ruggedness3_info_set)

    def prepare_problem(self):
        """
        prepare_problem(self)

        Parameters
        ----------
        self: LeadingOnes_Ruggedness3 *

        """
        return _IOHprofiler.LeadingOnes_Ruggedness3_prepare_problem(self)


    def internal_evaluate(self, x):
        """
        internal_evaluate(self, x) -> double

        Parameters
        ----------
        x: std::vector< int,std::allocator< int > > const &

        """
        return _IOHprofiler.LeadingOnes_Ruggedness3_internal_evaluate(self, x)


    def createInstance(instance_id=1, dimension=4):
        """
        createInstance(instance_id=1, dimension=4) -> LeadingOnes_Ruggedness3

        Parameters
        ----------
        instance_id: int
        dimension: int

        createInstance(instance_id=1) -> LeadingOnes_Ruggedness3

        Parameters
        ----------
        instance_id: int

        createInstance() -> LeadingOnes_Ruggedness3
        """
        return _IOHprofiler.LeadingOnes_Ruggedness3_createInstance(instance_id, dimension)

    createInstance = staticmethod(createInstance)
LeadingOnes_Ruggedness3_swigregister = _IOHprofiler.LeadingOnes_Ruggedness3_swigregister
LeadingOnes_Ruggedness3_swigregister(LeadingOnes_Ruggedness3)

def LeadingOnes_Ruggedness3_createInstance(instance_id=1, dimension=4):
    """
    createInstance(instance_id=1, dimension=4) -> LeadingOnes_Ruggedness3

    Parameters
    ----------
    instance_id: int
    dimension: int

    createInstance(instance_id=1) -> LeadingOnes_Ruggedness3

    Parameters
    ----------
    instance_id: int

    LeadingOnes_Ruggedness3_createInstance() -> LeadingOnes_Ruggedness3
    """
    return _IOHprofiler.LeadingOnes_Ruggedness3_createInstance(instance_id, dimension)

class Linear(IOHprofiler_Problem_int):
    """Proxy of C++ Linear class."""

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

    def __init__(self, instance_id=1, dimension=4):
        """
        __init__(self, instance_id=1, dimension=4) -> Linear

        Parameters
        ----------
        instance_id: int
        dimension: int

        __init__(self, instance_id=1) -> Linear

        Parameters
        ----------
        instance_id: int

        __init__(self) -> Linear
        """
        this = _IOHprofiler.new_Linear(instance_id, dimension)
        try:
            self.this.append(this)
        except __builtin__.Exception:
            self.this = this
    __swig_destroy__ = _IOHprofiler.delete_Linear
    __del__ = lambda self: None

    def Initilize_problem(self, dimension):
        """
        Initilize_problem(self, dimension)

        Parameters
        ----------
        dimension: int

        """
        return _IOHprofiler.Linear_Initilize_problem(self, dimension)


    def internal_evaluate(self, x):
        """
        internal_evaluate(self, x) -> double

        Parameters
        ----------
        x: std::vector< int,std::allocator< int > > const &

        """
        return _IOHprofiler.Linear_internal_evaluate(self, x)


    def createInstance(instance_id=1, dimension=4):
        """
        createInstance(instance_id=1, dimension=4) -> Linear

        Parameters
        ----------
        instance_id: int
        dimension: int

        createInstance(instance_id=1) -> Linear

        Parameters
        ----------
        instance_id: int

        createInstance() -> Linear
        """
        return _IOHprofiler.Linear_createInstance(instance_id, dimension)

    createInstance = staticmethod(createInstance)
Linear_swigregister = _IOHprofiler.Linear_swigregister
Linear_swigregister(Linear)

def Linear_createInstance(instance_id=1, dimension=4):
    """
    createInstance(instance_id=1, dimension=4) -> Linear

    Parameters
    ----------
    instance_id: int
    dimension: int

    createInstance(instance_id=1) -> Linear

    Parameters
    ----------
    instance_id: int

    Linear_createInstance() -> Linear
    """
    return _IOHprofiler.Linear_createInstance(instance_id, dimension)

class MIS(IOHprofiler_Problem_int):
    """Proxy of C++ MIS class."""

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

    def __init__(self, instance_id=1, dimension=4):
        """
        __init__(self, instance_id=1, dimension=4) -> MIS

        Parameters
        ----------
        instance_id: int
        dimension: int

        __init__(self, instance_id=1) -> MIS

        Parameters
        ----------
        instance_id: int

        __init__(self) -> MIS
        """
        this = _IOHprofiler.new_MIS(instance_id, dimension)
        try:
            self.this.append(this)
        except __builtin__.Exception:
            self.this = this
    __swig_destroy__ = _IOHprofiler.delete_MIS
    __del__ = lambda self: None

    def isEdge(self, i, j, problem_size):
        """
        isEdge(self, i, j, problem_size) -> int

        Parameters
        ----------
        i: int
        j: int
        problem_size: size_t

        """
        return _IOHprofiler.MIS_isEdge(self, i, j, problem_size)


    def internal_evaluate(self, x):
        """
        internal_evaluate(self, x) -> double

        Parameters
        ----------
        x: std::vector< int,std::allocator< int > > const &

        """
        return _IOHprofiler.MIS_internal_evaluate(self, x)


    def createInstance(instance_id=1, dimension=4):
        """
        createInstance(instance_id=1, dimension=4) -> MIS

        Parameters
        ----------
        instance_id: int
        dimension: int

        createInstance(instance_id=1) -> MIS

        Parameters
        ----------
        instance_id: int

        createInstance() -> MIS
        """
        return _IOHprofiler.MIS_createInstance(instance_id, dimension)

    createInstance = staticmethod(createInstance)
MIS_swigregister = _IOHprofiler.MIS_swigregister
MIS_swigregister(MIS)

def MIS_createInstance(instance_id=1, dimension=4):
    """
    createInstance(instance_id=1, dimension=4) -> MIS

    Parameters
    ----------
    instance_id: int
    dimension: int

    createInstance(instance_id=1) -> MIS

    Parameters
    ----------
    instance_id: int

    MIS_createInstance() -> MIS
    """
    return _IOHprofiler.MIS_createInstance(instance_id, dimension)

class NQueens(IOHprofiler_Problem_int):
    """Proxy of C++ NQueens class."""

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

    def __init__(self, instance_id=1, dimension=4):
        """
        __init__(self, instance_id=1, dimension=4) -> NQueens

        Parameters
        ----------
        instance_id: int
        dimension: int

        __init__(self, instance_id=1) -> NQueens

        Parameters
        ----------
        instance_id: int

        __init__(self) -> NQueens
        """
        this = _IOHprofiler.new_NQueens(instance_id, dimension)
        try:
            self.this.append(this)
        except __builtin__.Exception:
            self.this = this
    __swig_destroy__ = _IOHprofiler.delete_NQueens
    __del__ = lambda self: None

    def customize_optimal(self):
        """
        customize_optimal(self)

        Parameters
        ----------
        self: NQueens *

        """
        return _IOHprofiler.NQueens_customize_optimal(self)


    def _max(self, element1, element2):
        """
        _max(self, element1, element2) -> double

        Parameters
        ----------
        element1: double
        element2: double

        """
        return _IOHprofiler.NQueens__max(self, element1, element2)


    def internal_evaluate(self, x):
        """
        internal_evaluate(self, x) -> double

        Parameters
        ----------
        x: std::vector< int,std::allocator< int > > const &

        """
        return _IOHprofiler.NQueens_internal_evaluate(self, x)


    def createInstance(instance_id=1, dimension=4):
        """
        createInstance(instance_id=1, dimension=4) -> NQueens

        Parameters
        ----------
        instance_id: int
        dimension: int

        createInstance(instance_id=1) -> NQueens

        Parameters
        ----------
        instance_id: int

        createInstance() -> NQueens
        """
        return _IOHprofiler.NQueens_createInstance(instance_id, dimension)

    createInstance = staticmethod(createInstance)
NQueens_swigregister = _IOHprofiler.NQueens_swigregister
NQueens_swigregister(NQueens)

def NQueens_createInstance(instance_id=1, dimension=4):
    """
    createInstance(instance_id=1, dimension=4) -> NQueens

    Parameters
    ----------
    instance_id: int
    dimension: int

    createInstance(instance_id=1) -> NQueens

    Parameters
    ----------
    instance_id: int

    NQueens_createInstance() -> NQueens
    """
    return _IOHprofiler.NQueens_createInstance(instance_id, dimension)

class OneMax_Dummy1(IOHprofiler_Problem_int):
    """Proxy of C++ OneMax_Dummy1 class."""

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

    def __init__(self, instance_id=1, dimension=4):
        """
        __init__(self, instance_id=1, dimension=4) -> OneMax_Dummy1

        Parameters
        ----------
        instance_id: int
        dimension: int

        __init__(self, instance_id=1) -> OneMax_Dummy1

        Parameters
        ----------
        instance_id: int

        __init__(self) -> OneMax_Dummy1
        """
        this = _IOHprofiler.new_OneMax_Dummy1(instance_id, dimension)
        try:
            self.this.append(this)
        except __builtin__.Exception:
            self.this = this
    __swig_destroy__ = _IOHprofiler.delete_OneMax_Dummy1
    __del__ = lambda self: None
    __swig_setmethods__["info"] = _IOHprofiler.OneMax_Dummy1_info_set
    __swig_getmethods__["info"] = _IOHprofiler.OneMax_Dummy1_info_get
    if _newclass:
        info = _swig_property(_IOHprofiler.OneMax_Dummy1_info_get, _IOHprofiler.OneMax_Dummy1_info_set)

    def prepare_problem(self):
        """
        prepare_problem(self)

        Parameters
        ----------
        self: OneMax_Dummy1 *

        """
        return _IOHprofiler.OneMax_Dummy1_prepare_problem(self)


    def internal_evaluate(self, x):
        """
        internal_evaluate(self, x) -> double

        Parameters
        ----------
        x: std::vector< int,std::allocator< int > > const &

        """
        return _IOHprofiler.OneMax_Dummy1_internal_evaluate(self, x)


    def createInstance(instance_id=1, dimension=4):
        """
        createInstance(instance_id=1, dimension=4) -> OneMax_Dummy1

        Parameters
        ----------
        instance_id: int
        dimension: int

        createInstance(instance_id=1) -> OneMax_Dummy1

        Parameters
        ----------
        instance_id: int

        createInstance() -> OneMax_Dummy1
        """
        return _IOHprofiler.OneMax_Dummy1_createInstance(instance_id, dimension)

    createInstance = staticmethod(createInstance)
OneMax_Dummy1_swigregister = _IOHprofiler.OneMax_Dummy1_swigregister
OneMax_Dummy1_swigregister(OneMax_Dummy1)

def OneMax_Dummy1_createInstance(instance_id=1, dimension=4):
    """
    createInstance(instance_id=1, dimension=4) -> OneMax_Dummy1

    Parameters
    ----------
    instance_id: int
    dimension: int

    createInstance(instance_id=1) -> OneMax_Dummy1

    Parameters
    ----------
    instance_id: int

    OneMax_Dummy1_createInstance() -> OneMax_Dummy1
    """
    return _IOHprofiler.OneMax_Dummy1_createInstance(instance_id, dimension)

class OneMax_Dummy2(IOHprofiler_Problem_int):
    """Proxy of C++ OneMax_Dummy2 class."""

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

    def __init__(self, instance_id=1, dimension=4):
        """
        __init__(self, instance_id=1, dimension=4) -> OneMax_Dummy2

        Parameters
        ----------
        instance_id: int
        dimension: int

        __init__(self, instance_id=1) -> OneMax_Dummy2

        Parameters
        ----------
        instance_id: int

        __init__(self) -> OneMax_Dummy2
        """
        this = _IOHprofiler.new_OneMax_Dummy2(instance_id, dimension)
        try:
            self.this.append(this)
        except __builtin__.Exception:
            self.this = this
    __swig_destroy__ = _IOHprofiler.delete_OneMax_Dummy2
    __del__ = lambda self: None
    __swig_setmethods__["info"] = _IOHprofiler.OneMax_Dummy2_info_set
    __swig_getmethods__["info"] = _IOHprofiler.OneMax_Dummy2_info_get
    if _newclass:
        info = _swig_property(_IOHprofiler.OneMax_Dummy2_info_get, _IOHprofiler.OneMax_Dummy2_info_set)

    def prepare_problem(self):
        """
        prepare_problem(self)

        Parameters
        ----------
        self: OneMax_Dummy2 *

        """
        return _IOHprofiler.OneMax_Dummy2_prepare_problem(self)


    def internal_evaluate(self, x):
        """
        internal_evaluate(self, x) -> double

        Parameters
        ----------
        x: std::vector< int,std::allocator< int > > const &

        """
        return _IOHprofiler.OneMax_Dummy2_internal_evaluate(self, x)


    def createInstance(instance_id=1, dimension=4):
        """
        createInstance(instance_id=1, dimension=4) -> OneMax_Dummy2

        Parameters
        ----------
        instance_id: int
        dimension: int

        createInstance(instance_id=1) -> OneMax_Dummy2

        Parameters
        ----------
        instance_id: int

        createInstance() -> OneMax_Dummy2
        """
        return _IOHprofiler.OneMax_Dummy2_createInstance(instance_id, dimension)

    createInstance = staticmethod(createInstance)
OneMax_Dummy2_swigregister = _IOHprofiler.OneMax_Dummy2_swigregister
OneMax_Dummy2_swigregister(OneMax_Dummy2)

def OneMax_Dummy2_createInstance(instance_id=1, dimension=4):
    """
    createInstance(instance_id=1, dimension=4) -> OneMax_Dummy2

    Parameters
    ----------
    instance_id: int
    dimension: int

    createInstance(instance_id=1) -> OneMax_Dummy2

    Parameters
    ----------
    instance_id: int

    OneMax_Dummy2_createInstance() -> OneMax_Dummy2
    """
    return _IOHprofiler.OneMax_Dummy2_createInstance(instance_id, dimension)

class OneMax_Epistasis(IOHprofiler_Problem_int):
    """Proxy of C++ OneMax_Epistasis class."""

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

    def __init__(self, instance_id=1, dimension=4):
        """
        __init__(self, instance_id=1, dimension=4) -> OneMax_Epistasis

        Parameters
        ----------
        instance_id: int
        dimension: int

        __init__(self, instance_id=1) -> OneMax_Epistasis

        Parameters
        ----------
        instance_id: int

        __init__(self) -> OneMax_Epistasis
        """
        this = _IOHprofiler.new_OneMax_Epistasis(instance_id, dimension)
        try:
            self.this.append(this)
        except __builtin__.Exception:
            self.this = this
    __swig_destroy__ = _IOHprofiler.delete_OneMax_Epistasis
    __del__ = lambda self: None

    def customize_optimal(self):
        """
        customize_optimal(self)

        Parameters
        ----------
        self: OneMax_Epistasis *

        """
        return _IOHprofiler.OneMax_Epistasis_customize_optimal(self)


    def internal_evaluate(self, x):
        """
        internal_evaluate(self, x) -> double

        Parameters
        ----------
        x: std::vector< int,std::allocator< int > > const &

        """
        return _IOHprofiler.OneMax_Epistasis_internal_evaluate(self, x)


    def createInstance(instance_id=1, dimension=4):
        """
        createInstance(instance_id=1, dimension=4) -> OneMax_Epistasis

        Parameters
        ----------
        instance_id: int
        dimension: int

        createInstance(instance_id=1) -> OneMax_Epistasis

        Parameters
        ----------
        instance_id: int

        createInstance() -> OneMax_Epistasis
        """
        return _IOHprofiler.OneMax_Epistasis_createInstance(instance_id, dimension)

    createInstance = staticmethod(createInstance)
OneMax_Epistasis_swigregister = _IOHprofiler.OneMax_Epistasis_swigregister
OneMax_Epistasis_swigregister(OneMax_Epistasis)

def OneMax_Epistasis_createInstance(instance_id=1, dimension=4):
    """
    createInstance(instance_id=1, dimension=4) -> OneMax_Epistasis

    Parameters
    ----------
    instance_id: int
    dimension: int

    createInstance(instance_id=1) -> OneMax_Epistasis

    Parameters
    ----------
    instance_id: int

    OneMax_Epistasis_createInstance() -> OneMax_Epistasis
    """
    return _IOHprofiler.OneMax_Epistasis_createInstance(instance_id, dimension)

class OneMax(IOHprofiler_Problem_int):
    """Proxy of C++ OneMax class."""

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

    def __init__(self, instance_id=1, dimension=4):
        """
        __init__(self, instance_id=1, dimension=4) -> OneMax

        Parameters
        ----------
        instance_id: int
        dimension: int

        __init__(self, instance_id=1) -> OneMax

        Parameters
        ----------
        instance_id: int

        __init__(self) -> OneMax
        """
        this = _IOHprofiler.new_OneMax(instance_id, dimension)
        try:
            self.this.append(this)
        except __builtin__.Exception:
            self.this = this
    __swig_destroy__ = _IOHprofiler.delete_OneMax
    __del__ = lambda self: None

    def internal_evaluate(self, x):
        """
        internal_evaluate(self, x) -> double

        Parameters
        ----------
        x: std::vector< int,std::allocator< int > > const &

        """
        return _IOHprofiler.OneMax_internal_evaluate(self, x)


    def createInstance(instance_id=1, dimension=4):
        """
        createInstance(instance_id=1, dimension=4) -> OneMax

        Parameters
        ----------
        instance_id: int
        dimension: int

        createInstance(instance_id=1) -> OneMax

        Parameters
        ----------
        instance_id: int

        createInstance() -> OneMax
        """
        return _IOHprofiler.OneMax_createInstance(instance_id, dimension)

    createInstance = staticmethod(createInstance)
OneMax_swigregister = _IOHprofiler.OneMax_swigregister
OneMax_swigregister(OneMax)

def OneMax_createInstance(instance_id=1, dimension=4):
    """
    createInstance(instance_id=1, dimension=4) -> OneMax

    Parameters
    ----------
    instance_id: int
    dimension: int

    createInstance(instance_id=1) -> OneMax

    Parameters
    ----------
    instance_id: int

    OneMax_createInstance() -> OneMax
    """
    return _IOHprofiler.OneMax_createInstance(instance_id, dimension)

class OneMax_Neutrality(IOHprofiler_Problem_int):
    """Proxy of C++ OneMax_Neutrality class."""

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

    def __init__(self, instance_id=1, dimension=4):
        """
        __init__(self, instance_id=1, dimension=4) -> OneMax_Neutrality

        Parameters
        ----------
        instance_id: int
        dimension: int

        __init__(self, instance_id=1) -> OneMax_Neutrality

        Parameters
        ----------
        instance_id: int

        __init__(self) -> OneMax_Neutrality
        """
        this = _IOHprofiler.new_OneMax_Neutrality(instance_id, dimension)
        try:
            self.this.append(this)
        except __builtin__.Exception:
            self.this = this
    __swig_destroy__ = _IOHprofiler.delete_OneMax_Neutrality
    __del__ = lambda self: None

    def internal_evaluate(self, x):
        """
        internal_evaluate(self, x) -> double

        Parameters
        ----------
        x: std::vector< int,std::allocator< int > > const &

        """
        return _IOHprofiler.OneMax_Neutrality_internal_evaluate(self, x)


    def createInstance(instance_id=1, dimension=4):
        """
        createInstance(instance_id=1, dimension=4) -> OneMax_Neutrality

        Parameters
        ----------
        instance_id: int
        dimension: int

        createInstance(instance_id=1) -> OneMax_Neutrality

        Parameters
        ----------
        instance_id: int

        createInstance() -> OneMax_Neutrality
        """
        return _IOHprofiler.OneMax_Neutrality_createInstance(instance_id, dimension)

    createInstance = staticmethod(createInstance)
OneMax_Neutrality_swigregister = _IOHprofiler.OneMax_Neutrality_swigregister
OneMax_Neutrality_swigregister(OneMax_Neutrality)

def OneMax_Neutrality_createInstance(instance_id=1, dimension=4):
    """
    createInstance(instance_id=1, dimension=4) -> OneMax_Neutrality

    Parameters
    ----------
    instance_id: int
    dimension: int

    createInstance(instance_id=1) -> OneMax_Neutrality

    Parameters
    ----------
    instance_id: int

    OneMax_Neutrality_createInstance() -> OneMax_Neutrality
    """
    return _IOHprofiler.OneMax_Neutrality_createInstance(instance_id, dimension)

class OneMax_Ruggedness1(IOHprofiler_Problem_int):
    """Proxy of C++ OneMax_Ruggedness1 class."""

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

    def __init__(self, instance_id=1, dimension=4):
        """
        __init__(self, instance_id=1, dimension=4) -> OneMax_Ruggedness1

        Parameters
        ----------
        instance_id: int
        dimension: int

        __init__(self, instance_id=1) -> OneMax_Ruggedness1

        Parameters
        ----------
        instance_id: int

        __init__(self) -> OneMax_Ruggedness1
        """
        this = _IOHprofiler.new_OneMax_Ruggedness1(instance_id, dimension)
        try:
            self.this.append(this)
        except __builtin__.Exception:
            self.this = this
    __swig_destroy__ = _IOHprofiler.delete_OneMax_Ruggedness1
    __del__ = lambda self: None

    def internal_evaluate(self, x):
        """
        internal_evaluate(self, x) -> double

        Parameters
        ----------
        x: std::vector< int,std::allocator< int > > const &

        """
        return _IOHprofiler.OneMax_Ruggedness1_internal_evaluate(self, x)


    def createInstance(instance_id=1, dimension=4):
        """
        createInstance(instance_id=1, dimension=4) -> OneMax_Ruggedness1

        Parameters
        ----------
        instance_id: int
        dimension: int

        createInstance(instance_id=1) -> OneMax_Ruggedness1

        Parameters
        ----------
        instance_id: int

        createInstance() -> OneMax_Ruggedness1
        """
        return _IOHprofiler.OneMax_Ruggedness1_createInstance(instance_id, dimension)

    createInstance = staticmethod(createInstance)
OneMax_Ruggedness1_swigregister = _IOHprofiler.OneMax_Ruggedness1_swigregister
OneMax_Ruggedness1_swigregister(OneMax_Ruggedness1)

def OneMax_Ruggedness1_createInstance(instance_id=1, dimension=4):
    """
    createInstance(instance_id=1, dimension=4) -> OneMax_Ruggedness1

    Parameters
    ----------
    instance_id: int
    dimension: int

    createInstance(instance_id=1) -> OneMax_Ruggedness1

    Parameters
    ----------
    instance_id: int

    OneMax_Ruggedness1_createInstance() -> OneMax_Ruggedness1
    """
    return _IOHprofiler.OneMax_Ruggedness1_createInstance(instance_id, dimension)

class OneMax_Ruggedness2(IOHprofiler_Problem_int):
    """Proxy of C++ OneMax_Ruggedness2 class."""

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

    def __init__(self, instance_id=1, dimension=4):
        """
        __init__(self, instance_id=1, dimension=4) -> OneMax_Ruggedness2

        Parameters
        ----------
        instance_id: int
        dimension: int

        __init__(self, instance_id=1) -> OneMax_Ruggedness2

        Parameters
        ----------
        instance_id: int

        __init__(self) -> OneMax_Ruggedness2
        """
        this = _IOHprofiler.new_OneMax_Ruggedness2(instance_id, dimension)
        try:
            self.this.append(this)
        except __builtin__.Exception:
            self.this = this
    __swig_destroy__ = _IOHprofiler.delete_OneMax_Ruggedness2
    __del__ = lambda self: None

    def internal_evaluate(self, x):
        """
        internal_evaluate(self, x) -> double

        Parameters
        ----------
        x: std::vector< int,std::allocator< int > > const &

        """
        return _IOHprofiler.OneMax_Ruggedness2_internal_evaluate(self, x)


    def createInstance(instance_id=1, dimension=4):
        """
        createInstance(instance_id=1, dimension=4) -> OneMax_Ruggedness2

        Parameters
        ----------
        instance_id: int
        dimension: int

        createInstance(instance_id=1) -> OneMax_Ruggedness2

        Parameters
        ----------
        instance_id: int

        createInstance() -> OneMax_Ruggedness2
        """
        return _IOHprofiler.OneMax_Ruggedness2_createInstance(instance_id, dimension)

    createInstance = staticmethod(createInstance)
OneMax_Ruggedness2_swigregister = _IOHprofiler.OneMax_Ruggedness2_swigregister
OneMax_Ruggedness2_swigregister(OneMax_Ruggedness2)

def OneMax_Ruggedness2_createInstance(instance_id=1, dimension=4):
    """
    createInstance(instance_id=1, dimension=4) -> OneMax_Ruggedness2

    Parameters
    ----------
    instance_id: int
    dimension: int

    createInstance(instance_id=1) -> OneMax_Ruggedness2

    Parameters
    ----------
    instance_id: int

    OneMax_Ruggedness2_createInstance() -> OneMax_Ruggedness2
    """
    return _IOHprofiler.OneMax_Ruggedness2_createInstance(instance_id, dimension)

class OneMax_Ruggedness3(IOHprofiler_Problem_int):
    """Proxy of C++ OneMax_Ruggedness3 class."""

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

    def __init__(self, instance_id=1, dimension=4):
        """
        __init__(self, instance_id=1, dimension=4) -> OneMax_Ruggedness3

        Parameters
        ----------
        instance_id: int
        dimension: int

        __init__(self, instance_id=1) -> OneMax_Ruggedness3

        Parameters
        ----------
        instance_id: int

        __init__(self) -> OneMax_Ruggedness3
        """
        this = _IOHprofiler.new_OneMax_Ruggedness3(instance_id, dimension)
        try:
            self.this.append(this)
        except __builtin__.Exception:
            self.this = this
    __swig_destroy__ = _IOHprofiler.delete_OneMax_Ruggedness3
    __del__ = lambda self: None
    __swig_setmethods__["info"] = _IOHprofiler.OneMax_Ruggedness3_info_set
    __swig_getmethods__["info"] = _IOHprofiler.OneMax_Ruggedness3_info_get
    if _newclass:
        info = _swig_property(_IOHprofiler.OneMax_Ruggedness3_info_get, _IOHprofiler.OneMax_Ruggedness3_info_set)

    def prepare_problem(self):
        """
        prepare_problem(self)

        Parameters
        ----------
        self: OneMax_Ruggedness3 *

        """
        return _IOHprofiler.OneMax_Ruggedness3_prepare_problem(self)


    def internal_evaluate(self, x):
        """
        internal_evaluate(self, x) -> double

        Parameters
        ----------
        x: std::vector< int,std::allocator< int > > const &

        """
        return _IOHprofiler.OneMax_Ruggedness3_internal_evaluate(self, x)


    def createInstance(instance_id=1, dimension=4):
        """
        createInstance(instance_id=1, dimension=4) -> OneMax_Ruggedness3

        Parameters
        ----------
        instance_id: int
        dimension: int

        createInstance(instance_id=1) -> OneMax_Ruggedness3

        Parameters
        ----------
        instance_id: int

        createInstance() -> OneMax_Ruggedness3
        """
        return _IOHprofiler.OneMax_Ruggedness3_createInstance(instance_id, dimension)

    createInstance = staticmethod(createInstance)
OneMax_Ruggedness3_swigregister = _IOHprofiler.OneMax_Ruggedness3_swigregister
OneMax_Ruggedness3_swigregister(OneMax_Ruggedness3)

def OneMax_Ruggedness3_createInstance(instance_id=1, dimension=4):
    """
    createInstance(instance_id=1, dimension=4) -> OneMax_Ruggedness3

    Parameters
    ----------
    instance_id: int
    dimension: int

    createInstance(instance_id=1) -> OneMax_Ruggedness3

    Parameters
    ----------
    instance_id: int

    OneMax_Ruggedness3_createInstance() -> OneMax_Ruggedness3
    """
    return _IOHprofiler.OneMax_Ruggedness3_createInstance(instance_id, dimension)

class W_Model_OneMax(IOHprofiler_Problem_int):
    """Proxy of C++ W_Model_OneMax class."""

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

    def __init__(self, instance_id=1, dimension=4):
        """
        __init__(self, instance_id=1, dimension=4) -> W_Model_OneMax

        Parameters
        ----------
        instance_id: int
        dimension: int

        __init__(self, instance_id=1) -> W_Model_OneMax

        Parameters
        ----------
        instance_id: int

        __init__(self) -> W_Model_OneMax
        """
        this = _IOHprofiler.new_W_Model_OneMax(instance_id, dimension)
        try:
            self.this.append(this)
        except __builtin__.Exception:
            self.this = this
    __swig_destroy__ = _IOHprofiler.delete_W_Model_OneMax
    __del__ = lambda self: None
    __swig_setmethods__["dummy_info"] = _IOHprofiler.W_Model_OneMax_dummy_info_set
    __swig_getmethods__["dummy_info"] = _IOHprofiler.W_Model_OneMax_dummy_info_get
    if _newclass:
        dummy_info = _swig_property(_IOHprofiler.W_Model_OneMax_dummy_info_get, _IOHprofiler.W_Model_OneMax_dummy_info_set)
    __swig_setmethods__["dummy_para"] = _IOHprofiler.W_Model_OneMax_dummy_para_set
    __swig_getmethods__["dummy_para"] = _IOHprofiler.W_Model_OneMax_dummy_para_get
    if _newclass:
        dummy_para = _swig_property(_IOHprofiler.W_Model_OneMax_dummy_para_get, _IOHprofiler.W_Model_OneMax_dummy_para_set)
    __swig_setmethods__["epistasis_para"] = _IOHprofiler.W_Model_OneMax_epistasis_para_set
    __swig_getmethods__["epistasis_para"] = _IOHprofiler.W_Model_OneMax_epistasis_para_get
    if _newclass:
        epistasis_para = _swig_property(_IOHprofiler.W_Model_OneMax_epistasis_para_get, _IOHprofiler.W_Model_OneMax_epistasis_para_set)
    __swig_setmethods__["neutrality_para"] = _IOHprofiler.W_Model_OneMax_neutrality_para_set
    __swig_getmethods__["neutrality_para"] = _IOHprofiler.W_Model_OneMax_neutrality_para_get
    if _newclass:
        neutrality_para = _swig_property(_IOHprofiler.W_Model_OneMax_neutrality_para_get, _IOHprofiler.W_Model_OneMax_neutrality_para_set)
    __swig_setmethods__["ruggedness_para"] = _IOHprofiler.W_Model_OneMax_ruggedness_para_set
    __swig_getmethods__["ruggedness_para"] = _IOHprofiler.W_Model_OneMax_ruggedness_para_get
    if _newclass:
        ruggedness_para = _swig_property(_IOHprofiler.W_Model_OneMax_ruggedness_para_get, _IOHprofiler.W_Model_OneMax_ruggedness_para_set)
    __swig_setmethods__["ruggedness_info"] = _IOHprofiler.W_Model_OneMax_ruggedness_info_set
    __swig_getmethods__["ruggedness_info"] = _IOHprofiler.W_Model_OneMax_ruggedness_info_get
    if _newclass:
        ruggedness_info = _swig_property(_IOHprofiler.W_Model_OneMax_ruggedness_info_get, _IOHprofiler.W_Model_OneMax_ruggedness_info_set)
    __swig_setmethods__["temp_dimension"] = _IOHprofiler.W_Model_OneMax_temp_dimension_set
    __swig_getmethods__["temp_dimension"] = _IOHprofiler.W_Model_OneMax_temp_dimension_get
    if _newclass:
        temp_dimension = _swig_property(_IOHprofiler.W_Model_OneMax_temp_dimension_get, _IOHprofiler.W_Model_OneMax_temp_dimension_set)

    def prepare_problem(self):
        """
        prepare_problem(self)

        Parameters
        ----------
        self: W_Model_OneMax *

        """
        return _IOHprofiler.W_Model_OneMax_prepare_problem(self)


    def customize_optimal(self):
        """
        customize_optimal(self)

        Parameters
        ----------
        self: W_Model_OneMax *

        """
        return _IOHprofiler.W_Model_OneMax_customize_optimal(self)


    def set_w_setting(self, dummy_para, epistasis_para, neutrality_para, ruggedness_para):
        """
        set_w_setting(self, dummy_para, epistasis_para, neutrality_para, ruggedness_para)

        Parameters
        ----------
        dummy_para: double const
        epistasis_para: int const
        neutrality_para: int const
        ruggedness_para: int const

        """
        return _IOHprofiler.W_Model_OneMax_set_w_setting(self, dummy_para, epistasis_para, neutrality_para, ruggedness_para)


    def internal_evaluate(self, x):
        """
        internal_evaluate(self, x) -> double

        Parameters
        ----------
        x: std::vector< int,std::allocator< int > > const &

        """
        return _IOHprofiler.W_Model_OneMax_internal_evaluate(self, x)


    def createInstance(instance_id=1, dimension=4):
        """
        createInstance(instance_id=1, dimension=4) -> W_Model_OneMax

        Parameters
        ----------
        instance_id: int
        dimension: int

        createInstance(instance_id=1) -> W_Model_OneMax

        Parameters
        ----------
        instance_id: int

        createInstance() -> W_Model_OneMax
        """
        return _IOHprofiler.W_Model_OneMax_createInstance(instance_id, dimension)

    createInstance = staticmethod(createInstance)
W_Model_OneMax_swigregister = _IOHprofiler.W_Model_OneMax_swigregister
W_Model_OneMax_swigregister(W_Model_OneMax)

def W_Model_OneMax_createInstance(instance_id=1, dimension=4):
    """
    createInstance(instance_id=1, dimension=4) -> W_Model_OneMax

    Parameters
    ----------
    instance_id: int
    dimension: int

    createInstance(instance_id=1) -> W_Model_OneMax

    Parameters
    ----------
    instance_id: int

    W_Model_OneMax_createInstance() -> W_Model_OneMax
    """
    return _IOHprofiler.W_Model_OneMax_createInstance(instance_id, dimension)

class W_Model_LeadingOnes(IOHprofiler_Problem_int):
    """Proxy of C++ W_Model_LeadingOnes class."""

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

    def __init__(self, instance_id=1, dimension=4):
        """
        __init__(self, instance_id=1, dimension=4) -> W_Model_LeadingOnes

        Parameters
        ----------
        instance_id: int
        dimension: int

        __init__(self, instance_id=1) -> W_Model_LeadingOnes

        Parameters
        ----------
        instance_id: int

        __init__(self) -> W_Model_LeadingOnes
        """
        this = _IOHprofiler.new_W_Model_LeadingOnes(instance_id, dimension)
        try:
            self.this.append(this)
        except __builtin__.Exception:
            self.this = this
    __swig_destroy__ = _IOHprofiler.delete_W_Model_LeadingOnes
    __del__ = lambda self: None
    __swig_setmethods__["dummy_info"] = _IOHprofiler.W_Model_LeadingOnes_dummy_info_set
    __swig_getmethods__["dummy_info"] = _IOHprofiler.W_Model_LeadingOnes_dummy_info_get
    if _newclass:
        dummy_info = _swig_property(_IOHprofiler.W_Model_LeadingOnes_dummy_info_get, _IOHprofiler.W_Model_LeadingOnes_dummy_info_set)
    __swig_setmethods__["dummy_para"] = _IOHprofiler.W_Model_LeadingOnes_dummy_para_set
    __swig_getmethods__["dummy_para"] = _IOHprofiler.W_Model_LeadingOnes_dummy_para_get
    if _newclass:
        dummy_para = _swig_property(_IOHprofiler.W_Model_LeadingOnes_dummy_para_get, _IOHprofiler.W_Model_LeadingOnes_dummy_para_set)
    __swig_setmethods__["epistasis_para"] = _IOHprofiler.W_Model_LeadingOnes_epistasis_para_set
    __swig_getmethods__["epistasis_para"] = _IOHprofiler.W_Model_LeadingOnes_epistasis_para_get
    if _newclass:
        epistasis_para = _swig_property(_IOHprofiler.W_Model_LeadingOnes_epistasis_para_get, _IOHprofiler.W_Model_LeadingOnes_epistasis_para_set)
    __swig_setmethods__["neutrality_para"] = _IOHprofiler.W_Model_LeadingOnes_neutrality_para_set
    __swig_getmethods__["neutrality_para"] = _IOHprofiler.W_Model_LeadingOnes_neutrality_para_get
    if _newclass:
        neutrality_para = _swig_property(_IOHprofiler.W_Model_LeadingOnes_neutrality_para_get, _IOHprofiler.W_Model_LeadingOnes_neutrality_para_set)
    __swig_setmethods__["ruggedness_para"] = _IOHprofiler.W_Model_LeadingOnes_ruggedness_para_set
    __swig_getmethods__["ruggedness_para"] = _IOHprofiler.W_Model_LeadingOnes_ruggedness_para_get
    if _newclass:
        ruggedness_para = _swig_property(_IOHprofiler.W_Model_LeadingOnes_ruggedness_para_get, _IOHprofiler.W_Model_LeadingOnes_ruggedness_para_set)
    __swig_setmethods__["ruggedness_info"] = _IOHprofiler.W_Model_LeadingOnes_ruggedness_info_set
    __swig_getmethods__["ruggedness_info"] = _IOHprofiler.W_Model_LeadingOnes_ruggedness_info_get
    if _newclass:
        ruggedness_info = _swig_property(_IOHprofiler.W_Model_LeadingOnes_ruggedness_info_get, _IOHprofiler.W_Model_LeadingOnes_ruggedness_info_set)
    __swig_setmethods__["temp_dimension"] = _IOHprofiler.W_Model_LeadingOnes_temp_dimension_set
    __swig_getmethods__["temp_dimension"] = _IOHprofiler.W_Model_LeadingOnes_temp_dimension_get
    if _newclass:
        temp_dimension = _swig_property(_IOHprofiler.W_Model_LeadingOnes_temp_dimension_get, _IOHprofiler.W_Model_LeadingOnes_temp_dimension_set)

    def prepare_problem(self):
        """
        prepare_problem(self)

        Parameters
        ----------
        self: W_Model_LeadingOnes *

        """
        return _IOHprofiler.W_Model_LeadingOnes_prepare_problem(self)


    def customize_optimal(self):
        """
        customize_optimal(self)

        Parameters
        ----------
        self: W_Model_LeadingOnes *

        """
        return _IOHprofiler.W_Model_LeadingOnes_customize_optimal(self)


    def set_w_setting(self, dummy_para, epistasis_para, neutrality_para, ruggedness_para):
        """
        set_w_setting(self, dummy_para, epistasis_para, neutrality_para, ruggedness_para)

        Parameters
        ----------
        dummy_para: double const
        epistasis_para: int const
        neutrality_para: int const
        ruggedness_para: int const

        """
        return _IOHprofiler.W_Model_LeadingOnes_set_w_setting(self, dummy_para, epistasis_para, neutrality_para, ruggedness_para)


    def internal_evaluate(self, x):
        """
        internal_evaluate(self, x) -> double

        Parameters
        ----------
        x: std::vector< int,std::allocator< int > > const &

        """
        return _IOHprofiler.W_Model_LeadingOnes_internal_evaluate(self, x)


    def createInstance(instance_id=1, dimension=4):
        """
        createInstance(instance_id=1, dimension=4) -> W_Model_LeadingOnes

        Parameters
        ----------
        instance_id: int
        dimension: int

        createInstance(instance_id=1) -> W_Model_LeadingOnes

        Parameters
        ----------
        instance_id: int

        createInstance() -> W_Model_LeadingOnes
        """
        return _IOHprofiler.W_Model_LeadingOnes_createInstance(instance_id, dimension)

    createInstance = staticmethod(createInstance)
W_Model_LeadingOnes_swigregister = _IOHprofiler.W_Model_LeadingOnes_swigregister
W_Model_LeadingOnes_swigregister(W_Model_LeadingOnes)

def W_Model_LeadingOnes_createInstance(instance_id=1, dimension=4):
    """
    createInstance(instance_id=1, dimension=4) -> W_Model_LeadingOnes

    Parameters
    ----------
    instance_id: int
    dimension: int

    createInstance(instance_id=1) -> W_Model_LeadingOnes

    Parameters
    ----------
    instance_id: int

    W_Model_LeadingOnes_createInstance() -> W_Model_LeadingOnes
    """
    return _IOHprofiler.W_Model_LeadingOnes_createInstance(instance_id, dimension)

class genericGenerator_int_problem(_object):
    """Proxy of C++ genericGenerator<(IOHprofiler_problem<(int)>)> class."""

    __swig_setmethods__ = {}
    __setattr__ = lambda self, name, value: _swig_setattr(self, genericGenerator_int_problem, name, value)
    __swig_getmethods__ = {}
    __getattr__ = lambda self, name: _swig_getattr(self, genericGenerator_int_problem, name)

    def __init__(self, *args, **kwargs):
        raise AttributeError("No constructor defined")
    __repr__ = _swig_repr

    def instance():
        """instance() -> genericGenerator_int_problem"""
        return _IOHprofiler.genericGenerator_int_problem_instance()

    instance = staticmethod(instance)

    def regCreateFn(self, arg2, arg3):
        """
        regCreateFn(self, arg2, arg3)

        Parameters
        ----------
        arg2: std::string
        arg3: std::shared_ptr< IOHprofiler_problem< int > > (*)()

        """
        return _IOHprofiler.genericGenerator_int_problem_regCreateFn(self, arg2, arg3)


    def create(self, className):
        """
        create(self, className) -> std::shared_ptr< IOHprofiler_problem< int > >

        Parameters
        ----------
        className: std::string

        """
        return _IOHprofiler.genericGenerator_int_problem_create(self, className)

    __swig_destroy__ = _IOHprofiler.delete_genericGenerator_int_problem
    __del__ = lambda self: None
genericGenerator_int_problem_swigregister = _IOHprofiler.genericGenerator_int_problem_swigregister
genericGenerator_int_problem_swigregister(genericGenerator_int_problem)

def genericGenerator_int_problem_instance():
    """genericGenerator_int_problem_instance() -> genericGenerator_int_problem"""
    return _IOHprofiler.genericGenerator_int_problem_instance()

class genericGenerator_double_problem(_object):
    """Proxy of C++ genericGenerator<(IOHprofiler_problem<(double)>)> class."""

    __swig_setmethods__ = {}
    __setattr__ = lambda self, name, value: _swig_setattr(self, genericGenerator_double_problem, name, value)
    __swig_getmethods__ = {}
    __getattr__ = lambda self, name: _swig_getattr(self, genericGenerator_double_problem, name)

    def __init__(self, *args, **kwargs):
        raise AttributeError("No constructor defined")
    __repr__ = _swig_repr

    def instance():
        """instance() -> genericGenerator_double_problem"""
        return _IOHprofiler.genericGenerator_double_problem_instance()

    instance = staticmethod(instance)

    def regCreateFn(self, arg2, arg3):
        """
        regCreateFn(self, arg2, arg3)

        Parameters
        ----------
        arg2: std::string
        arg3: std::shared_ptr< IOHprofiler_problem< double > > (*)()

        """
        return _IOHprofiler.genericGenerator_double_problem_regCreateFn(self, arg2, arg3)


    def create(self, className):
        """
        create(self, className) -> std::shared_ptr< IOHprofiler_problem< double > >

        Parameters
        ----------
        className: std::string

        """
        return _IOHprofiler.genericGenerator_double_problem_create(self, className)

    __swig_destroy__ = _IOHprofiler.delete_genericGenerator_double_problem
    __del__ = lambda self: None
genericGenerator_double_problem_swigregister = _IOHprofiler.genericGenerator_double_problem_swigregister
genericGenerator_double_problem_swigregister(genericGenerator_double_problem)

def genericGenerator_double_problem_instance():
    """genericGenerator_double_problem_instance() -> genericGenerator_double_problem"""
    return _IOHprofiler.genericGenerator_double_problem_instance()

class IOHprofiler_suite_int(IOHprofiler_Problem_int, intProblemPtr):
    """Proxy of C++ IOHprofiler_suite<(int)> class."""

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

    def __init__(self, *args):
        """
        __init__(self, problem_id, instance_id, dimension) -> IOHprofiler_suite_int

        Parameters
        ----------
        problem_id: std::vector< int,std::allocator< int > >
        instance_id: std::vector< int,std::allocator< int > >
        dimension: std::vector< int,std::allocator< int > >

        __init__(self, problem_id, instance_id) -> IOHprofiler_suite_int

        Parameters
        ----------
        problem_id: std::vector< int,std::allocator< int > >
        instance_id: std::vector< int,std::allocator< int > >

        __init__(self, problem_id) -> IOHprofiler_suite_int

        Parameters
        ----------
        problem_id: std::vector< int,std::allocator< int > >

        __init__(self) -> IOHprofiler_suite_int
        """
        this = _IOHprofiler.new_IOHprofiler_suite_int(*args)
        try:
            self.this.append(this)
        except __builtin__.Exception:
            self.this = this
    __swig_destroy__ = _IOHprofiler.delete_IOHprofiler_suite_int
    __del__ = lambda self: None

    def registerInSuite(self):
        """
        registerInSuite(self)

        Parameters
        ----------
        self: IOHprofiler_suite< int > *

        """
        return _IOHprofiler.IOHprofiler_suite_int_registerInSuite(self)


    def loadProblem(self):
        """
        loadProblem(self)

        Parameters
        ----------
        self: IOHprofiler_suite< int > *

        """
        return _IOHprofiler.IOHprofiler_suite_int_loadProblem(self)


    def get_next_problem(self):
        """
        get_next_problem(self) -> IOHprofiler_suite< int >::Problem_ptr

        Parameters
        ----------
        self: IOHprofiler_suite< int > *

        """
        return _IOHprofiler.IOHprofiler_suite_int_get_next_problem(self)


    def get_current_problem(self):
        """
        get_current_problem(self) -> IOHprofiler_suite< int >::Problem_ptr

        Parameters
        ----------
        self: IOHprofiler_suite< int > *

        """
        return _IOHprofiler.IOHprofiler_suite_int_get_current_problem(self)


    def get_problem(self, *args):
        """
        get_problem(self, problem_name, instance, dimension) -> IOHprofiler_suite< int >::Problem_ptr

        Parameters
        ----------
        problem_name: std::string
        instance: int
        dimension: int

        get_problem(self, problem_id, instance, dimension) -> IOHprofiler_suite< int >::Problem_ptr

        Parameters
        ----------
        problem_id: int
        instance: int
        dimension: int

        """
        return _IOHprofiler.IOHprofiler_suite_int_get_problem(self, *args)


    def IOHprofiler_suite_get_number_of_problems(self):
        """
        IOHprofiler_suite_get_number_of_problems(self) -> int

        Parameters
        ----------
        self: IOHprofiler_suite< int > const *

        """
        return _IOHprofiler.IOHprofiler_suite_int_IOHprofiler_suite_get_number_of_problems(self)


    def IOHprofiler_suite_get_number_of_instances(self):
        """
        IOHprofiler_suite_get_number_of_instances(self) -> int

        Parameters
        ----------
        self: IOHprofiler_suite< int > const *

        """
        return _IOHprofiler.IOHprofiler_suite_int_IOHprofiler_suite_get_number_of_instances(self)


    def IOHprofiler_suite_get_number_of_dimensions(self):
        """
        IOHprofiler_suite_get_number_of_dimensions(self) -> int

        Parameters
        ----------
        self: IOHprofiler_suite< int > const *

        """
        return _IOHprofiler.IOHprofiler_suite_int_IOHprofiler_suite_get_number_of_dimensions(self)


    def IOHprofiler_suite_get_problem_id(self):
        """
        IOHprofiler_suite_get_problem_id(self) -> intvec

        Parameters
        ----------
        self: IOHprofiler_suite< int > const *

        """
        return _IOHprofiler.IOHprofiler_suite_int_IOHprofiler_suite_get_problem_id(self)


    def IOHprofiler_suite_get_problem_name(self):
        """
        IOHprofiler_suite_get_problem_name(self) -> std::map< int,std::string,std::less< int >,std::allocator< std::pair< int const,std::string > > >

        Parameters
        ----------
        self: IOHprofiler_suite< int > const *

        """
        return _IOHprofiler.IOHprofiler_suite_int_IOHprofiler_suite_get_problem_name(self)


    def IOHprofiler_suite_get_problems(self):
        """
        IOHprofiler_suite_get_problems(self) -> std::map< std::string,int,std::less< std::string >,std::allocator< std::pair< std::string const,int > > >

        Parameters
        ----------
        self: IOHprofiler_suite< int > const *

        """
        return _IOHprofiler.IOHprofiler_suite_int_IOHprofiler_suite_get_problems(self)


    def IOHprofiler_suite_get_instance_id(self):
        """
        IOHprofiler_suite_get_instance_id(self) -> intvec

        Parameters
        ----------
        self: IOHprofiler_suite< int > const *

        """
        return _IOHprofiler.IOHprofiler_suite_int_IOHprofiler_suite_get_instance_id(self)


    def IOHprofiler_suite_get_dimension(self):
        """
        IOHprofiler_suite_get_dimension(self) -> intvec

        Parameters
        ----------
        self: IOHprofiler_suite< int > const *

        """
        return _IOHprofiler.IOHprofiler_suite_int_IOHprofiler_suite_get_dimension(self)


    def IOHprofiler_suite_get_suite_name(self):
        """
        IOHprofiler_suite_get_suite_name(self) -> std::string

        Parameters
        ----------
        self: IOHprofiler_suite< int > const *

        """
        return _IOHprofiler.IOHprofiler_suite_int_IOHprofiler_suite_get_suite_name(self)


    def IOHprofiler_set_suite_problem_id(self, problem_id):
        """
        IOHprofiler_set_suite_problem_id(self, problem_id)

        Parameters
        ----------
        problem_id: std::vector< int,std::allocator< int > > const &

        """
        return _IOHprofiler.IOHprofiler_suite_int_IOHprofiler_set_suite_problem_id(self, problem_id)


    def IOHprofiler_set_suite_instance_id(self, instance_id):
        """
        IOHprofiler_set_suite_instance_id(self, instance_id)

        Parameters
        ----------
        instance_id: std::vector< int,std::allocator< int > > const &

        """
        return _IOHprofiler.IOHprofiler_suite_int_IOHprofiler_set_suite_instance_id(self, instance_id)


    def IOHprofiler_set_suite_dimension(self, dimension):
        """
        IOHprofiler_set_suite_dimension(self, dimension)

        Parameters
        ----------
        dimension: std::vector< int,std::allocator< int > > const &

        """
        return _IOHprofiler.IOHprofiler_suite_int_IOHprofiler_set_suite_dimension(self, dimension)


    def IOHprofiler_set_suite_name(self, suite_name):
        """
        IOHprofiler_set_suite_name(self, suite_name)

        Parameters
        ----------
        suite_name: std::string const

        """
        return _IOHprofiler.IOHprofiler_suite_int_IOHprofiler_set_suite_name(self, suite_name)


    def mapIDTOName(self, id, name):
        """
        mapIDTOName(self, id, name)

        Parameters
        ----------
        id: int const
        name: std::string const

        """
        return _IOHprofiler.IOHprofiler_suite_int_mapIDTOName(self, id, name)

IOHprofiler_suite_int_swigregister = _IOHprofiler.IOHprofiler_suite_int_swigregister
IOHprofiler_suite_int_swigregister(IOHprofiler_suite_int)

class IOHprofiler_suite_double(IOHprofiler_Problem_double, doubleProblemPtr):
    """Proxy of C++ IOHprofiler_suite<(double)> class."""

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

    def __init__(self, *args):
        """
        __init__(self, problem_id, instance_id, dimension) -> IOHprofiler_suite_double

        Parameters
        ----------
        problem_id: std::vector< int,std::allocator< int > >
        instance_id: std::vector< int,std::allocator< int > >
        dimension: std::vector< int,std::allocator< int > >

        __init__(self, problem_id, instance_id) -> IOHprofiler_suite_double

        Parameters
        ----------
        problem_id: std::vector< int,std::allocator< int > >
        instance_id: std::vector< int,std::allocator< int > >

        __init__(self, problem_id) -> IOHprofiler_suite_double

        Parameters
        ----------
        problem_id: std::vector< int,std::allocator< int > >

        __init__(self) -> IOHprofiler_suite_double
        """
        this = _IOHprofiler.new_IOHprofiler_suite_double(*args)
        try:
            self.this.append(this)
        except __builtin__.Exception:
            self.this = this
    __swig_destroy__ = _IOHprofiler.delete_IOHprofiler_suite_double
    __del__ = lambda self: None

    def registerInSuite(self):
        """
        registerInSuite(self)

        Parameters
        ----------
        self: IOHprofiler_suite< double > *

        """
        return _IOHprofiler.IOHprofiler_suite_double_registerInSuite(self)


    def loadProblem(self):
        """
        loadProblem(self)

        Parameters
        ----------
        self: IOHprofiler_suite< double > *

        """
        return _IOHprofiler.IOHprofiler_suite_double_loadProblem(self)


    def get_next_problem(self):
        """
        get_next_problem(self) -> IOHprofiler_suite< double >::Problem_ptr

        Parameters
        ----------
        self: IOHprofiler_suite< double > *

        """
        return _IOHprofiler.IOHprofiler_suite_double_get_next_problem(self)


    def get_current_problem(self):
        """
        get_current_problem(self) -> IOHprofiler_suite< double >::Problem_ptr

        Parameters
        ----------
        self: IOHprofiler_suite< double > *

        """
        return _IOHprofiler.IOHprofiler_suite_double_get_current_problem(self)


    def get_problem(self, *args):
        """
        get_problem(self, problem_name, instance, dimension) -> IOHprofiler_suite< double >::Problem_ptr

        Parameters
        ----------
        problem_name: std::string
        instance: int
        dimension: int

        get_problem(self, problem_id, instance, dimension) -> IOHprofiler_suite< double >::Problem_ptr

        Parameters
        ----------
        problem_id: int
        instance: int
        dimension: int

        """
        return _IOHprofiler.IOHprofiler_suite_double_get_problem(self, *args)


    def IOHprofiler_suite_get_number_of_problems(self):
        """
        IOHprofiler_suite_get_number_of_problems(self) -> int

        Parameters
        ----------
        self: IOHprofiler_suite< double > const *

        """
        return _IOHprofiler.IOHprofiler_suite_double_IOHprofiler_suite_get_number_of_problems(self)


    def IOHprofiler_suite_get_number_of_instances(self):
        """
        IOHprofiler_suite_get_number_of_instances(self) -> int

        Parameters
        ----------
        self: IOHprofiler_suite< double > const *

        """
        return _IOHprofiler.IOHprofiler_suite_double_IOHprofiler_suite_get_number_of_instances(self)


    def IOHprofiler_suite_get_number_of_dimensions(self):
        """
        IOHprofiler_suite_get_number_of_dimensions(self) -> int

        Parameters
        ----------
        self: IOHprofiler_suite< double > const *

        """
        return _IOHprofiler.IOHprofiler_suite_double_IOHprofiler_suite_get_number_of_dimensions(self)


    def IOHprofiler_suite_get_problem_id(self):
        """
        IOHprofiler_suite_get_problem_id(self) -> intvec

        Parameters
        ----------
        self: IOHprofiler_suite< double > const *

        """
        return _IOHprofiler.IOHprofiler_suite_double_IOHprofiler_suite_get_problem_id(self)


    def IOHprofiler_suite_get_problem_name(self):
        """
        IOHprofiler_suite_get_problem_name(self) -> std::map< int,std::string,std::less< int >,std::allocator< std::pair< int const,std::string > > >

        Parameters
        ----------
        self: IOHprofiler_suite< double > const *

        """
        return _IOHprofiler.IOHprofiler_suite_double_IOHprofiler_suite_get_problem_name(self)


    def IOHprofiler_suite_get_problems(self):
        """
        IOHprofiler_suite_get_problems(self) -> std::map< std::string,int,std::less< std::string >,std::allocator< std::pair< std::string const,int > > >

        Parameters
        ----------
        self: IOHprofiler_suite< double > const *

        """
        return _IOHprofiler.IOHprofiler_suite_double_IOHprofiler_suite_get_problems(self)


    def IOHprofiler_suite_get_instance_id(self):
        """
        IOHprofiler_suite_get_instance_id(self) -> intvec

        Parameters
        ----------
        self: IOHprofiler_suite< double > const *

        """
        return _IOHprofiler.IOHprofiler_suite_double_IOHprofiler_suite_get_instance_id(self)


    def IOHprofiler_suite_get_dimension(self):
        """
        IOHprofiler_suite_get_dimension(self) -> intvec

        Parameters
        ----------
        self: IOHprofiler_suite< double > const *

        """
        return _IOHprofiler.IOHprofiler_suite_double_IOHprofiler_suite_get_dimension(self)


    def IOHprofiler_suite_get_suite_name(self):
        """
        IOHprofiler_suite_get_suite_name(self) -> std::string

        Parameters
        ----------
        self: IOHprofiler_suite< double > const *

        """
        return _IOHprofiler.IOHprofiler_suite_double_IOHprofiler_suite_get_suite_name(self)


    def IOHprofiler_set_suite_problem_id(self, problem_id):
        """
        IOHprofiler_set_suite_problem_id(self, problem_id)

        Parameters
        ----------
        problem_id: std::vector< int,std::allocator< int > > const &

        """
        return _IOHprofiler.IOHprofiler_suite_double_IOHprofiler_set_suite_problem_id(self, problem_id)


    def IOHprofiler_set_suite_instance_id(self, instance_id):
        """
        IOHprofiler_set_suite_instance_id(self, instance_id)

        Parameters
        ----------
        instance_id: std::vector< int,std::allocator< int > > const &

        """
        return _IOHprofiler.IOHprofiler_suite_double_IOHprofiler_set_suite_instance_id(self, instance_id)


    def IOHprofiler_set_suite_dimension(self, dimension):
        """
        IOHprofiler_set_suite_dimension(self, dimension)

        Parameters
        ----------
        dimension: std::vector< int,std::allocator< int > > const &

        """
        return _IOHprofiler.IOHprofiler_suite_double_IOHprofiler_set_suite_dimension(self, dimension)


    def IOHprofiler_set_suite_name(self, suite_name):
        """
        IOHprofiler_set_suite_name(self, suite_name)

        Parameters
        ----------
        suite_name: std::string const

        """
        return _IOHprofiler.IOHprofiler_suite_double_IOHprofiler_set_suite_name(self, suite_name)


    def mapIDTOName(self, id, name):
        """
        mapIDTOName(self, id, name)

        Parameters
        ----------
        id: int const
        name: std::string const

        """
        return _IOHprofiler.IOHprofiler_suite_double_mapIDTOName(self, id, name)

IOHprofiler_suite_double_swigregister = _IOHprofiler.IOHprofiler_suite_double_swigregister
IOHprofiler_suite_double_swigregister(IOHprofiler_suite_double)

class BBOB_suite(IOHprofiler_suite_double):
    """Proxy of C++ BBOB_suite class."""

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

    def __init__(self, *args):
        """
        __init__(self) -> BBOB_suite
        __init__(self, problem_id, instance_id, dimension) -> BBOB_suite

        Parameters
        ----------
        problem_id: std::vector< int,std::allocator< int > >
        instance_id: std::vector< int,std::allocator< int > >
        dimension: std::vector< int,std::allocator< int > >

        """
        this = _IOHprofiler.new_BBOB_suite(*args)
        try:
            self.this.append(this)
        except __builtin__.Exception:
            self.this = this

    def registerProblem(self):
        """
        registerProblem(self)

        Parameters
        ----------
        self: BBOB_suite *

        """
        return _IOHprofiler.BBOB_suite_registerProblem(self)


    def createInstance(*args):
        """
        createInstance() -> BBOB_suite
        createInstance(problem_id, instance_id, dimension) -> BBOB_suite

        Parameters
        ----------
        problem_id: std::vector< int,std::allocator< int > >
        instance_id: std::vector< int,std::allocator< int > >
        dimension: std::vector< int,std::allocator< int > >

        """
        return _IOHprofiler.BBOB_suite_createInstance(*args)

    createInstance = staticmethod(createInstance)
    __swig_destroy__ = _IOHprofiler.delete_BBOB_suite
    __del__ = lambda self: None
BBOB_suite_swigregister = _IOHprofiler.BBOB_suite_swigregister
BBOB_suite_swigregister(BBOB_suite)

def BBOB_suite_createInstance(*args):
    """
    createInstance() -> BBOB_suite
    BBOB_suite_createInstance(problem_id, instance_id, dimension) -> BBOB_suite

    Parameters
    ----------
    problem_id: std::vector< int,std::allocator< int > >
    instance_id: std::vector< int,std::allocator< int > >
    dimension: std::vector< int,std::allocator< int > >

    """
    return _IOHprofiler.BBOB_suite_createInstance(*args)

class PBO_suite(IOHprofiler_suite_int):
    """Proxy of C++ PBO_suite class."""

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

    def __init__(self, *args):
        """
        __init__(self) -> PBO_suite
        __init__(self, problem_id, instance_id, dimension) -> PBO_suite

        Parameters
        ----------
        problem_id: std::vector< int,std::allocator< int > >
        instance_id: std::vector< int,std::allocator< int > >
        dimension: std::vector< int,std::allocator< int > >

        """
        this = _IOHprofiler.new_PBO_suite(*args)
        try:
            self.this.append(this)
        except __builtin__.Exception:
            self.this = this

    def registerProblem(self):
        """
        registerProblem(self)

        Parameters
        ----------
        self: PBO_suite *

        """
        return _IOHprofiler.PBO_suite_registerProblem(self)


    def createInstance(*args):
        """
        createInstance() -> PBO_suite
        createInstance(problem_id, instance_id, dimension) -> PBO_suite

        Parameters
        ----------
        problem_id: std::vector< int,std::allocator< int > >
        instance_id: std::vector< int,std::allocator< int > >
        dimension: std::vector< int,std::allocator< int > >

        """
        return _IOHprofiler.PBO_suite_createInstance(*args)

    createInstance = staticmethod(createInstance)
    __swig_destroy__ = _IOHprofiler.delete_PBO_suite
    __del__ = lambda self: None
PBO_suite_swigregister = _IOHprofiler.PBO_suite_swigregister
PBO_suite_swigregister(PBO_suite)

def PBO_suite_createInstance(*args):
    """
    createInstance() -> PBO_suite
    PBO_suite_createInstance(problem_id, instance_id, dimension) -> PBO_suite

    Parameters
    ----------
    problem_id: std::vector< int,std::allocator< int > >
    instance_id: std::vector< int,std::allocator< int > >
    dimension: std::vector< int,std::allocator< int > >

    """
    return _IOHprofiler.PBO_suite_createInstance(*args)

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


