python3-openturns 1.5-7build2 / usr / lib / python3 / dist-packages / openturns / optim.py

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




"""
Optimization routines.
"""


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

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

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

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

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


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

GCC_VERSION = _optim.GCC_VERSION
class TestFailed:
    """TestFailed is used to raise an uniform exception in tests."""

    __type = "TestFailed"

    def __init__(self, reason=""):
        self.reason = reason

    def type(self):
        return TestFailed.__type

    def what(self):
        return self.reason

    def __str__(self):
        return TestFailed.__type + ": " + self.reason

    def __lshift__(self, ch):
        self.reason += ch
        return self

import openturns.common
import openturns.wrapper
import openturns.typ
import openturns.statistics
import openturns.graph
import openturns.func
import openturns.geom
import openturns.diff
class BoundConstrainedAlgorithmImplementationResult(openturns.common.PersistentObject):
    __swig_setmethods__ = {}
    for _s in [openturns.common.PersistentObject]: __swig_setmethods__.update(getattr(_s,'__swig_setmethods__',{}))
    __setattr__ = lambda self, name, value: _swig_setattr(self, BoundConstrainedAlgorithmImplementationResult, name, value)
    __swig_getmethods__ = {}
    for _s in [openturns.common.PersistentObject]: __swig_getmethods__.update(getattr(_s,'__swig_getmethods__',{}))
    __getattr__ = lambda self, name: _swig_getattr(self, BoundConstrainedAlgorithmImplementationResult, name)
    def getClassName(self):
        """
        Accessor to the object's name.

        Returns
        -------
        class_name : str
            The object class name (`object.__class__.__name__`).
        """
        return _optim.BoundConstrainedAlgorithmImplementationResult_getClassName(self)

    MINIMIZATION = _optim.BoundConstrainedAlgorithmImplementationResult_MINIMIZATION
    MAXIMIZATION = _optim.BoundConstrainedAlgorithmImplementationResult_MAXIMIZATION
    def getOptimizer(self): return _optim.BoundConstrainedAlgorithmImplementationResult_getOptimizer(self)
    def getOptimalValue(self): return _optim.BoundConstrainedAlgorithmImplementationResult_getOptimalValue(self)
    def getOptimizationProblem(self): return _optim.BoundConstrainedAlgorithmImplementationResult_getOptimizationProblem(self)
    def getEvaluationsNumber(self): return _optim.BoundConstrainedAlgorithmImplementationResult_getEvaluationsNumber(self)
    def getAbsoluteError(self): return _optim.BoundConstrainedAlgorithmImplementationResult_getAbsoluteError(self)
    def getRelativeError(self): return _optim.BoundConstrainedAlgorithmImplementationResult_getRelativeError(self)
    def getObjectiveError(self): return _optim.BoundConstrainedAlgorithmImplementationResult_getObjectiveError(self)
    def getConstraintError(self): return _optim.BoundConstrainedAlgorithmImplementationResult_getConstraintError(self)
    def __repr__(self): return _optim.BoundConstrainedAlgorithmImplementationResult___repr__(self)
    def __init__(self, *args): 
        this = _optim.new_BoundConstrainedAlgorithmImplementationResult(*args)
        try: self.this.append(this)
        except: self.this = this
    __swig_destroy__ = _optim.delete_BoundConstrainedAlgorithmImplementationResult
    __del__ = lambda self : None;
BoundConstrainedAlgorithmImplementationResult_swigregister = _optim.BoundConstrainedAlgorithmImplementationResult_swigregister
BoundConstrainedAlgorithmImplementationResult_swigregister(BoundConstrainedAlgorithmImplementationResult)

class BoundConstrainedAlgorithmImplementation(openturns.common.PersistentObject):
    __swig_setmethods__ = {}
    for _s in [openturns.common.PersistentObject]: __swig_setmethods__.update(getattr(_s,'__swig_setmethods__',{}))
    __setattr__ = lambda self, name, value: _swig_setattr(self, BoundConstrainedAlgorithmImplementation, name, value)
    __swig_getmethods__ = {}
    for _s in [openturns.common.PersistentObject]: __swig_getmethods__.update(getattr(_s,'__swig_getmethods__',{}))
    __getattr__ = lambda self, name: _swig_getattr(self, BoundConstrainedAlgorithmImplementation, name)
    def getClassName(self):
        """
        Accessor to the object's name.

        Returns
        -------
        class_name : str
            The object class name (`object.__class__.__name__`).
        """
        return _optim.BoundConstrainedAlgorithmImplementation_getClassName(self)

    def run(self): return _optim.BoundConstrainedAlgorithmImplementation_run(self)
    def getStartingPoint(self): return _optim.BoundConstrainedAlgorithmImplementation_getStartingPoint(self)
    def setStartingPoint(self, *args): return _optim.BoundConstrainedAlgorithmImplementation_setStartingPoint(self, *args)
    def getObjectiveFunction(self): return _optim.BoundConstrainedAlgorithmImplementation_getObjectiveFunction(self)
    def setObjectiveFunction(self, *args): return _optim.BoundConstrainedAlgorithmImplementation_setObjectiveFunction(self, *args)
    def getBoundConstraints(self): return _optim.BoundConstrainedAlgorithmImplementation_getBoundConstraints(self)
    def setBoundConstraints(self, *args): return _optim.BoundConstrainedAlgorithmImplementation_setBoundConstraints(self, *args)
    def getOptimizationProblem(self): return _optim.BoundConstrainedAlgorithmImplementation_getOptimizationProblem(self)
    def setOptimizationProblem(self, *args): return _optim.BoundConstrainedAlgorithmImplementation_setOptimizationProblem(self, *args)
    def getResult(self): return _optim.BoundConstrainedAlgorithmImplementation_getResult(self)
    def setResult(self, *args): return _optim.BoundConstrainedAlgorithmImplementation_setResult(self, *args)
    def getMaximumEvaluationsNumber(self): return _optim.BoundConstrainedAlgorithmImplementation_getMaximumEvaluationsNumber(self)
    def setMaximumEvaluationsNumber(self, *args): return _optim.BoundConstrainedAlgorithmImplementation_setMaximumEvaluationsNumber(self, *args)
    def getMaximumAbsoluteError(self): return _optim.BoundConstrainedAlgorithmImplementation_getMaximumAbsoluteError(self)
    def setMaximumAbsoluteError(self, *args): return _optim.BoundConstrainedAlgorithmImplementation_setMaximumAbsoluteError(self, *args)
    def getMaximumRelativeError(self): return _optim.BoundConstrainedAlgorithmImplementation_getMaximumRelativeError(self)
    def setMaximumRelativeError(self, *args): return _optim.BoundConstrainedAlgorithmImplementation_setMaximumRelativeError(self, *args)
    def getMaximumObjectiveError(self): return _optim.BoundConstrainedAlgorithmImplementation_getMaximumObjectiveError(self)
    def setMaximumObjectiveError(self, *args): return _optim.BoundConstrainedAlgorithmImplementation_setMaximumObjectiveError(self, *args)
    def getMaximumConstraintError(self): return _optim.BoundConstrainedAlgorithmImplementation_getMaximumConstraintError(self)
    def setMaximumConstraintError(self, *args): return _optim.BoundConstrainedAlgorithmImplementation_setMaximumConstraintError(self, *args)
    def __repr__(self): return _optim.BoundConstrainedAlgorithmImplementation___repr__(self)
    def getVerbose(self): return _optim.BoundConstrainedAlgorithmImplementation_getVerbose(self)
    def setVerbose(self, *args): return _optim.BoundConstrainedAlgorithmImplementation_setVerbose(self, *args)
    def __init__(self, *args): 
        this = _optim.new_BoundConstrainedAlgorithmImplementation(*args)
        try: self.this.append(this)
        except: self.this = this
    __swig_destroy__ = _optim.delete_BoundConstrainedAlgorithmImplementation
    __del__ = lambda self : None;
BoundConstrainedAlgorithmImplementation_swigregister = _optim.BoundConstrainedAlgorithmImplementation_swigregister
BoundConstrainedAlgorithmImplementation_swigregister(BoundConstrainedAlgorithmImplementation)

class BoundConstrainedAlgorithmImplementationTypedInterfaceObject(openturns.common.InterfaceObject):
    __swig_setmethods__ = {}
    for _s in [openturns.common.InterfaceObject]: __swig_setmethods__.update(getattr(_s,'__swig_setmethods__',{}))
    __setattr__ = lambda self, name, value: _swig_setattr(self, BoundConstrainedAlgorithmImplementationTypedInterfaceObject, name, value)
    __swig_getmethods__ = {}
    for _s in [openturns.common.InterfaceObject]: __swig_getmethods__.update(getattr(_s,'__swig_getmethods__',{}))
    __getattr__ = lambda self, name: _swig_getattr(self, BoundConstrainedAlgorithmImplementationTypedInterfaceObject, name)
    __repr__ = _swig_repr
    def __init__(self, *args): 
        this = _optim.new_BoundConstrainedAlgorithmImplementationTypedInterfaceObject(*args)
        try: self.this.append(this)
        except: self.this = this
    def getImplementation(self, *args):
        """
        Accessor to the underlying implementation.

        Returns
        -------
        impl : Implementation
            The implementation class.
        """
        return _optim.BoundConstrainedAlgorithmImplementationTypedInterfaceObject_getImplementation(self, *args)

    def setName(self, *args):
        """
        Accessor to the object's name.

        Parameters
        ----------
        name : string
            The name of the object.
        """
        return _optim.BoundConstrainedAlgorithmImplementationTypedInterfaceObject_setName(self, *args)

    def getName(self):
        """
        Accessor to the object's name.

        Returns
        -------
        name : string
            The name of the object.
        """
        return _optim.BoundConstrainedAlgorithmImplementationTypedInterfaceObject_getName(self)

    def __eq__(self, *args): return _optim.BoundConstrainedAlgorithmImplementationTypedInterfaceObject___eq__(self, *args)
    __swig_destroy__ = _optim.delete_BoundConstrainedAlgorithmImplementationTypedInterfaceObject
    __del__ = lambda self : None;
BoundConstrainedAlgorithmImplementationTypedInterfaceObject_swigregister = _optim.BoundConstrainedAlgorithmImplementationTypedInterfaceObject_swigregister
BoundConstrainedAlgorithmImplementationTypedInterfaceObject_swigregister(BoundConstrainedAlgorithmImplementationTypedInterfaceObject)

class BoundConstrainedAlgorithm(BoundConstrainedAlgorithmImplementationTypedInterfaceObject):
    __swig_setmethods__ = {}
    for _s in [BoundConstrainedAlgorithmImplementationTypedInterfaceObject]: __swig_setmethods__.update(getattr(_s,'__swig_setmethods__',{}))
    __setattr__ = lambda self, name, value: _swig_setattr(self, BoundConstrainedAlgorithm, name, value)
    __swig_getmethods__ = {}
    for _s in [BoundConstrainedAlgorithmImplementationTypedInterfaceObject]: __swig_getmethods__.update(getattr(_s,'__swig_getmethods__',{}))
    __getattr__ = lambda self, name: _swig_getattr(self, BoundConstrainedAlgorithm, name)
    def getClassName(self):
        """
        Accessor to the object's name.

        Returns
        -------
        class_name : str
            The object class name (`object.__class__.__name__`).
        """
        return _optim.BoundConstrainedAlgorithm_getClassName(self)

    def run(self): return _optim.BoundConstrainedAlgorithm_run(self)
    def getStartingPoint(self): return _optim.BoundConstrainedAlgorithm_getStartingPoint(self)
    def setStartingPoint(self, *args): return _optim.BoundConstrainedAlgorithm_setStartingPoint(self, *args)
    def getObjectiveFunction(self): return _optim.BoundConstrainedAlgorithm_getObjectiveFunction(self)
    def setObjectiveFunction(self, *args): return _optim.BoundConstrainedAlgorithm_setObjectiveFunction(self, *args)
    def getBoundConstraints(self): return _optim.BoundConstrainedAlgorithm_getBoundConstraints(self)
    def setBoundConstraints(self, *args): return _optim.BoundConstrainedAlgorithm_setBoundConstraints(self, *args)
    def getOptimizationProblem(self): return _optim.BoundConstrainedAlgorithm_getOptimizationProblem(self)
    def setOptimizationProblem(self, *args): return _optim.BoundConstrainedAlgorithm_setOptimizationProblem(self, *args)
    def getResult(self): return _optim.BoundConstrainedAlgorithm_getResult(self)
    def setResult(self, *args): return _optim.BoundConstrainedAlgorithm_setResult(self, *args)
    def getMaximumEvaluationsNumber(self): return _optim.BoundConstrainedAlgorithm_getMaximumEvaluationsNumber(self)
    def setMaximumEvaluationsNumber(self, *args): return _optim.BoundConstrainedAlgorithm_setMaximumEvaluationsNumber(self, *args)
    def getMaximumAbsoluteError(self): return _optim.BoundConstrainedAlgorithm_getMaximumAbsoluteError(self)
    def setMaximumAbsoluteError(self, *args): return _optim.BoundConstrainedAlgorithm_setMaximumAbsoluteError(self, *args)
    def getMaximumRelativeError(self): return _optim.BoundConstrainedAlgorithm_getMaximumRelativeError(self)
    def setMaximumRelativeError(self, *args): return _optim.BoundConstrainedAlgorithm_setMaximumRelativeError(self, *args)
    def getMaximumObjectiveError(self): return _optim.BoundConstrainedAlgorithm_getMaximumObjectiveError(self)
    def setMaximumObjectiveError(self, *args): return _optim.BoundConstrainedAlgorithm_setMaximumObjectiveError(self, *args)
    def getMaximumConstraintError(self): return _optim.BoundConstrainedAlgorithm_getMaximumConstraintError(self)
    def setMaximumConstraintError(self, *args): return _optim.BoundConstrainedAlgorithm_setMaximumConstraintError(self, *args)
    def __repr__(self): return _optim.BoundConstrainedAlgorithm___repr__(self)
    def getVerbose(self): return _optim.BoundConstrainedAlgorithm_getVerbose(self)
    def setVerbose(self, *args): return _optim.BoundConstrainedAlgorithm_setVerbose(self, *args)
    def __init__(self, *args): 
        this = _optim.new_BoundConstrainedAlgorithm(*args)
        try: self.this.append(this)
        except: self.this = this
    __swig_destroy__ = _optim.delete_BoundConstrainedAlgorithm
    __del__ = lambda self : None;
BoundConstrainedAlgorithm_swigregister = _optim.BoundConstrainedAlgorithm_swigregister
BoundConstrainedAlgorithm_swigregister(BoundConstrainedAlgorithm)

class NearestPointAlgorithmImplementationResult(openturns.common.PersistentObject):
    __swig_setmethods__ = {}
    for _s in [openturns.common.PersistentObject]: __swig_setmethods__.update(getattr(_s,'__swig_setmethods__',{}))
    __setattr__ = lambda self, name, value: _swig_setattr(self, NearestPointAlgorithmImplementationResult, name, value)
    __swig_getmethods__ = {}
    for _s in [openturns.common.PersistentObject]: __swig_getmethods__.update(getattr(_s,'__swig_getmethods__',{}))
    __getattr__ = lambda self, name: _swig_getattr(self, NearestPointAlgorithmImplementationResult, name)
    def getClassName(self):
        """
        Accessor to the object's name.

        Returns
        -------
        class_name : str
            The object class name (`object.__class__.__name__`).
        """
        return _optim.NearestPointAlgorithmImplementationResult_getClassName(self)

    def getMinimizer(self): return _optim.NearestPointAlgorithmImplementationResult_getMinimizer(self)
    def getIterationsNumber(self): return _optim.NearestPointAlgorithmImplementationResult_getIterationsNumber(self)
    def getAbsoluteError(self): return _optim.NearestPointAlgorithmImplementationResult_getAbsoluteError(self)
    def getAbsoluteErrorHistory(self): return _optim.NearestPointAlgorithmImplementationResult_getAbsoluteErrorHistory(self)
    def getRelativeError(self): return _optim.NearestPointAlgorithmImplementationResult_getRelativeError(self)
    def getRelativeErrorHistory(self): return _optim.NearestPointAlgorithmImplementationResult_getRelativeErrorHistory(self)
    def getResidualError(self): return _optim.NearestPointAlgorithmImplementationResult_getResidualError(self)
    def getResidualErrorHistory(self): return _optim.NearestPointAlgorithmImplementationResult_getResidualErrorHistory(self)
    def getConstraintError(self): return _optim.NearestPointAlgorithmImplementationResult_getConstraintError(self)
    def getConstraintErrorHistory(self): return _optim.NearestPointAlgorithmImplementationResult_getConstraintErrorHistory(self)
    def getInputSample(self): return _optim.NearestPointAlgorithmImplementationResult_getInputSample(self)
    def getOutputSample(self): return _optim.NearestPointAlgorithmImplementationResult_getOutputSample(self)
    def __repr__(self): return _optim.NearestPointAlgorithmImplementationResult___repr__(self)
    def update(self, *args): return _optim.NearestPointAlgorithmImplementationResult_update(self, *args)
    def store(self, *args): return _optim.NearestPointAlgorithmImplementationResult_store(self, *args)
    def drawErrorHistory(self): return _optim.NearestPointAlgorithmImplementationResult_drawErrorHistory(self)
    def __init__(self, *args): 
        this = _optim.new_NearestPointAlgorithmImplementationResult(*args)
        try: self.this.append(this)
        except: self.this = this
    __swig_destroy__ = _optim.delete_NearestPointAlgorithmImplementationResult
    __del__ = lambda self : None;
NearestPointAlgorithmImplementationResult_swigregister = _optim.NearestPointAlgorithmImplementationResult_swigregister
NearestPointAlgorithmImplementationResult_swigregister(NearestPointAlgorithmImplementationResult)

class NearestPointAlgorithmImplementation(openturns.common.PersistentObject):
    __swig_setmethods__ = {}
    for _s in [openturns.common.PersistentObject]: __swig_setmethods__.update(getattr(_s,'__swig_setmethods__',{}))
    __setattr__ = lambda self, name, value: _swig_setattr(self, NearestPointAlgorithmImplementation, name, value)
    __swig_getmethods__ = {}
    for _s in [openturns.common.PersistentObject]: __swig_getmethods__.update(getattr(_s,'__swig_getmethods__',{}))
    __getattr__ = lambda self, name: _swig_getattr(self, NearestPointAlgorithmImplementation, name)
    def getClassName(self):
        """
        Accessor to the object's name.

        Returns
        -------
        class_name : str
            The object class name (`object.__class__.__name__`).
        """
        return _optim.NearestPointAlgorithmImplementation_getClassName(self)

    def run(self): return _optim.NearestPointAlgorithmImplementation_run(self)
    def getStartingPoint(self): return _optim.NearestPointAlgorithmImplementation_getStartingPoint(self)
    def setStartingPoint(self, *args): return _optim.NearestPointAlgorithmImplementation_setStartingPoint(self, *args)
    def getLevelFunction(self): return _optim.NearestPointAlgorithmImplementation_getLevelFunction(self)
    def setLevelFunction(self, *args): return _optim.NearestPointAlgorithmImplementation_setLevelFunction(self, *args)
    def getLevelValue(self): return _optim.NearestPointAlgorithmImplementation_getLevelValue(self)
    def setLevelValue(self, *args): return _optim.NearestPointAlgorithmImplementation_setLevelValue(self, *args)
    def getResult(self): return _optim.NearestPointAlgorithmImplementation_getResult(self)
    def setResult(self, *args): return _optim.NearestPointAlgorithmImplementation_setResult(self, *args)
    def getMaximumIterationsNumber(self): return _optim.NearestPointAlgorithmImplementation_getMaximumIterationsNumber(self)
    def setMaximumIterationsNumber(self, *args): return _optim.NearestPointAlgorithmImplementation_setMaximumIterationsNumber(self, *args)
    def getMaximumAbsoluteError(self): return _optim.NearestPointAlgorithmImplementation_getMaximumAbsoluteError(self)
    def setMaximumAbsoluteError(self, *args): return _optim.NearestPointAlgorithmImplementation_setMaximumAbsoluteError(self, *args)
    def getMaximumRelativeError(self): return _optim.NearestPointAlgorithmImplementation_getMaximumRelativeError(self)
    def setMaximumRelativeError(self, *args): return _optim.NearestPointAlgorithmImplementation_setMaximumRelativeError(self, *args)
    def getMaximumResidualError(self): return _optim.NearestPointAlgorithmImplementation_getMaximumResidualError(self)
    def setMaximumResidualError(self, *args): return _optim.NearestPointAlgorithmImplementation_setMaximumResidualError(self, *args)
    def getMaximumConstraintError(self): return _optim.NearestPointAlgorithmImplementation_getMaximumConstraintError(self)
    def setMaximumConstraintError(self, *args): return _optim.NearestPointAlgorithmImplementation_setMaximumConstraintError(self, *args)
    def __repr__(self): return _optim.NearestPointAlgorithmImplementation___repr__(self)
    def getVerbose(self): return _optim.NearestPointAlgorithmImplementation_getVerbose(self)
    def setVerbose(self, *args): return _optim.NearestPointAlgorithmImplementation_setVerbose(self, *args)
    def __init__(self, *args): 
        this = _optim.new_NearestPointAlgorithmImplementation(*args)
        try: self.this.append(this)
        except: self.this = this
    __swig_destroy__ = _optim.delete_NearestPointAlgorithmImplementation
    __del__ = lambda self : None;
NearestPointAlgorithmImplementation_swigregister = _optim.NearestPointAlgorithmImplementation_swigregister
NearestPointAlgorithmImplementation_swigregister(NearestPointAlgorithmImplementation)

class NearestPointAlgorithmImplementationTypedInterfaceObject(openturns.common.InterfaceObject):
    __swig_setmethods__ = {}
    for _s in [openturns.common.InterfaceObject]: __swig_setmethods__.update(getattr(_s,'__swig_setmethods__',{}))
    __setattr__ = lambda self, name, value: _swig_setattr(self, NearestPointAlgorithmImplementationTypedInterfaceObject, name, value)
    __swig_getmethods__ = {}
    for _s in [openturns.common.InterfaceObject]: __swig_getmethods__.update(getattr(_s,'__swig_getmethods__',{}))
    __getattr__ = lambda self, name: _swig_getattr(self, NearestPointAlgorithmImplementationTypedInterfaceObject, name)
    __repr__ = _swig_repr
    def __init__(self, *args): 
        this = _optim.new_NearestPointAlgorithmImplementationTypedInterfaceObject(*args)
        try: self.this.append(this)
        except: self.this = this
    def getImplementation(self, *args):
        """
        Accessor to the underlying implementation.

        Returns
        -------
        impl : Implementation
            The implementation class.
        """
        return _optim.NearestPointAlgorithmImplementationTypedInterfaceObject_getImplementation(self, *args)

    def setName(self, *args):
        """
        Accessor to the object's name.

        Parameters
        ----------
        name : string
            The name of the object.
        """
        return _optim.NearestPointAlgorithmImplementationTypedInterfaceObject_setName(self, *args)

    def getName(self):
        """
        Accessor to the object's name.

        Returns
        -------
        name : string
            The name of the object.
        """
        return _optim.NearestPointAlgorithmImplementationTypedInterfaceObject_getName(self)

    def __eq__(self, *args): return _optim.NearestPointAlgorithmImplementationTypedInterfaceObject___eq__(self, *args)
    __swig_destroy__ = _optim.delete_NearestPointAlgorithmImplementationTypedInterfaceObject
    __del__ = lambda self : None;
NearestPointAlgorithmImplementationTypedInterfaceObject_swigregister = _optim.NearestPointAlgorithmImplementationTypedInterfaceObject_swigregister
NearestPointAlgorithmImplementationTypedInterfaceObject_swigregister(NearestPointAlgorithmImplementationTypedInterfaceObject)

class NearestPointAlgorithm(NearestPointAlgorithmImplementationTypedInterfaceObject):
    __swig_setmethods__ = {}
    for _s in [NearestPointAlgorithmImplementationTypedInterfaceObject]: __swig_setmethods__.update(getattr(_s,'__swig_setmethods__',{}))
    __setattr__ = lambda self, name, value: _swig_setattr(self, NearestPointAlgorithm, name, value)
    __swig_getmethods__ = {}
    for _s in [NearestPointAlgorithmImplementationTypedInterfaceObject]: __swig_getmethods__.update(getattr(_s,'__swig_getmethods__',{}))
    __getattr__ = lambda self, name: _swig_getattr(self, NearestPointAlgorithm, name)
    def getClassName(self):
        """
        Accessor to the object's name.

        Returns
        -------
        class_name : str
            The object class name (`object.__class__.__name__`).
        """
        return _optim.NearestPointAlgorithm_getClassName(self)

    def run(self): return _optim.NearestPointAlgorithm_run(self)
    def getStartingPoint(self): return _optim.NearestPointAlgorithm_getStartingPoint(self)
    def setStartingPoint(self, *args): return _optim.NearestPointAlgorithm_setStartingPoint(self, *args)
    def getLevelFunction(self): return _optim.NearestPointAlgorithm_getLevelFunction(self)
    def setLevelFunction(self, *args): return _optim.NearestPointAlgorithm_setLevelFunction(self, *args)
    def getLevelValue(self): return _optim.NearestPointAlgorithm_getLevelValue(self)
    def setLevelValue(self, *args): return _optim.NearestPointAlgorithm_setLevelValue(self, *args)
    def getResult(self): return _optim.NearestPointAlgorithm_getResult(self)
    def setResult(self, *args): return _optim.NearestPointAlgorithm_setResult(self, *args)
    def getMaximumIterationsNumber(self): return _optim.NearestPointAlgorithm_getMaximumIterationsNumber(self)
    def setMaximumIterationsNumber(self, *args): return _optim.NearestPointAlgorithm_setMaximumIterationsNumber(self, *args)
    def getMaximumAbsoluteError(self): return _optim.NearestPointAlgorithm_getMaximumAbsoluteError(self)
    def setMaximumAbsoluteError(self, *args): return _optim.NearestPointAlgorithm_setMaximumAbsoluteError(self, *args)
    def getMaximumRelativeError(self): return _optim.NearestPointAlgorithm_getMaximumRelativeError(self)
    def setMaximumRelativeError(self, *args): return _optim.NearestPointAlgorithm_setMaximumRelativeError(self, *args)
    def getMaximumResidualError(self): return _optim.NearestPointAlgorithm_getMaximumResidualError(self)
    def setMaximumResidualError(self, *args): return _optim.NearestPointAlgorithm_setMaximumResidualError(self, *args)
    def getMaximumConstraintError(self): return _optim.NearestPointAlgorithm_getMaximumConstraintError(self)
    def setMaximumConstraintError(self, *args): return _optim.NearestPointAlgorithm_setMaximumConstraintError(self, *args)
    def __repr__(self): return _optim.NearestPointAlgorithm___repr__(self)
    def __str__(self, offset=""): return _optim.NearestPointAlgorithm___str__(self, offset)
    def getVerbose(self): return _optim.NearestPointAlgorithm_getVerbose(self)
    def setVerbose(self, *args): return _optim.NearestPointAlgorithm_setVerbose(self, *args)
    def __init__(self, *args): 
        this = _optim.new_NearestPointAlgorithm(*args)
        try: self.this.append(this)
        except: self.this = this
    __swig_destroy__ = _optim.delete_NearestPointAlgorithm
    __del__ = lambda self : None;
NearestPointAlgorithm_swigregister = _optim.NearestPointAlgorithm_swigregister
NearestPointAlgorithm_swigregister(NearestPointAlgorithm)

class NearestPointCheckerResult(openturns.common.PersistentObject):
    __swig_setmethods__ = {}
    for _s in [openturns.common.PersistentObject]: __swig_setmethods__.update(getattr(_s,'__swig_setmethods__',{}))
    __setattr__ = lambda self, name, value: _swig_setattr(self, NearestPointCheckerResult, name, value)
    __swig_getmethods__ = {}
    for _s in [openturns.common.PersistentObject]: __swig_getmethods__.update(getattr(_s,'__swig_getmethods__',{}))
    __getattr__ = lambda self, name: _swig_getattr(self, NearestPointCheckerResult, name)
    def getClassName(self):
        """
        Accessor to the object's name.

        Returns
        -------
        class_name : str
            The object class name (`object.__class__.__name__`).
        """
        return _optim.NearestPointCheckerResult_getClassName(self)

    def getVerifyingConstraintPoints(self): return _optim.NearestPointCheckerResult_getVerifyingConstraintPoints(self)
    def getVerifyingConstraintValues(self): return _optim.NearestPointCheckerResult_getVerifyingConstraintValues(self)
    def getViolatingConstraintPoints(self): return _optim.NearestPointCheckerResult_getViolatingConstraintPoints(self)
    def getViolatingConstraintValues(self): return _optim.NearestPointCheckerResult_getViolatingConstraintValues(self)
    def setVerifyingConstraintPoints(self, *args): return _optim.NearestPointCheckerResult_setVerifyingConstraintPoints(self, *args)
    def setVerifyingConstraintValues(self, *args): return _optim.NearestPointCheckerResult_setVerifyingConstraintValues(self, *args)
    def setViolatingConstraintPoints(self, *args): return _optim.NearestPointCheckerResult_setViolatingConstraintPoints(self, *args)
    def setViolatingConstraintValues(self, *args): return _optim.NearestPointCheckerResult_setViolatingConstraintValues(self, *args)
    def __repr__(self): return _optim.NearestPointCheckerResult___repr__(self)
    def __init__(self, *args): 
        this = _optim.new_NearestPointCheckerResult(*args)
        try: self.this.append(this)
        except: self.this = this
    __swig_destroy__ = _optim.delete_NearestPointCheckerResult
    __del__ = lambda self : None;
NearestPointCheckerResult_swigregister = _optim.NearestPointCheckerResult_swigregister
NearestPointCheckerResult_swigregister(NearestPointCheckerResult)

class NearestPointChecker(openturns.common.PersistentObject):
    __swig_setmethods__ = {}
    for _s in [openturns.common.PersistentObject]: __swig_setmethods__.update(getattr(_s,'__swig_setmethods__',{}))
    __setattr__ = lambda self, name, value: _swig_setattr(self, NearestPointChecker, name, value)
    __swig_getmethods__ = {}
    for _s in [openturns.common.PersistentObject]: __swig_getmethods__.update(getattr(_s,'__swig_getmethods__',{}))
    __getattr__ = lambda self, name: _swig_getattr(self, NearestPointChecker, name)
    def getClassName(self):
        """
        Accessor to the object's name.

        Returns
        -------
        class_name : str
            The object class name (`object.__class__.__name__`).
        """
        return _optim.NearestPointChecker_getClassName(self)

    def setLevelFunction(self, *args): return _optim.NearestPointChecker_setLevelFunction(self, *args)
    def getLevelFunction(self): return _optim.NearestPointChecker_getLevelFunction(self)
    def setResult(self, *args): return _optim.NearestPointChecker_setResult(self, *args)
    def getResult(self): return _optim.NearestPointChecker_getResult(self)
    def setComparisonOperator(self, *args): return _optim.NearestPointChecker_setComparisonOperator(self, *args)
    def getComparisonOperator(self): return _optim.NearestPointChecker_getComparisonOperator(self)
    def setThreshold(self, *args): return _optim.NearestPointChecker_setThreshold(self, *args)
    def getThreshold(self): return _optim.NearestPointChecker_getThreshold(self)
    def setSample(self, *args): return _optim.NearestPointChecker_setSample(self, *args)
    def getSample(self): return _optim.NearestPointChecker_getSample(self)
    def run(self): return _optim.NearestPointChecker_run(self)
    def __repr__(self): return _optim.NearestPointChecker___repr__(self)
    def __init__(self, *args): 
        this = _optim.new_NearestPointChecker(*args)
        try: self.this.append(this)
        except: self.this = this
    __swig_destroy__ = _optim.delete_NearestPointChecker
    __del__ = lambda self : None;
NearestPointChecker_swigregister = _optim.NearestPointChecker_swigregister
NearestPointChecker_swigregister(NearestPointChecker)

class AbdoRackwitzSpecificParameters(openturns.common.PersistentObject):
    __swig_setmethods__ = {}
    for _s in [openturns.common.PersistentObject]: __swig_setmethods__.update(getattr(_s,'__swig_setmethods__',{}))
    __setattr__ = lambda self, name, value: _swig_setattr(self, AbdoRackwitzSpecificParameters, name, value)
    __swig_getmethods__ = {}
    for _s in [openturns.common.PersistentObject]: __swig_getmethods__.update(getattr(_s,'__swig_getmethods__',{}))
    __getattr__ = lambda self, name: _swig_getattr(self, AbdoRackwitzSpecificParameters, name)
    def getClassName(self):
        """
        Accessor to the object's name.

        Returns
        -------
        class_name : str
            The object class name (`object.__class__.__name__`).
        """
        return _optim.AbdoRackwitzSpecificParameters_getClassName(self)

    def getTau(self): return _optim.AbdoRackwitzSpecificParameters_getTau(self)
    def setTau(self, *args): return _optim.AbdoRackwitzSpecificParameters_setTau(self, *args)
    def getOmega(self): return _optim.AbdoRackwitzSpecificParameters_getOmega(self)
    def setOmega(self, *args): return _optim.AbdoRackwitzSpecificParameters_setOmega(self, *args)
    def getSmooth(self): return _optim.AbdoRackwitzSpecificParameters_getSmooth(self)
    def setSmooth(self, *args): return _optim.AbdoRackwitzSpecificParameters_setSmooth(self, *args)
    def __repr__(self): return _optim.AbdoRackwitzSpecificParameters___repr__(self)
    def __init__(self, *args): 
        this = _optim.new_AbdoRackwitzSpecificParameters(*args)
        try: self.this.append(this)
        except: self.this = this
    __swig_destroy__ = _optim.delete_AbdoRackwitzSpecificParameters
    __del__ = lambda self : None;
AbdoRackwitzSpecificParameters_swigregister = _optim.AbdoRackwitzSpecificParameters_swigregister
AbdoRackwitzSpecificParameters_swigregister(AbdoRackwitzSpecificParameters)

class AbdoRackwitz(NearestPointAlgorithmImplementation):
    __swig_setmethods__ = {}
    for _s in [NearestPointAlgorithmImplementation]: __swig_setmethods__.update(getattr(_s,'__swig_setmethods__',{}))
    __setattr__ = lambda self, name, value: _swig_setattr(self, AbdoRackwitz, name, value)
    __swig_getmethods__ = {}
    for _s in [NearestPointAlgorithmImplementation]: __swig_getmethods__.update(getattr(_s,'__swig_getmethods__',{}))
    __getattr__ = lambda self, name: _swig_getattr(self, AbdoRackwitz, name)
    def getClassName(self):
        """
        Accessor to the object's name.

        Returns
        -------
        class_name : str
            The object class name (`object.__class__.__name__`).
        """
        return _optim.AbdoRackwitz_getClassName(self)

    def run(self): return _optim.AbdoRackwitz_run(self)
    def getSpecificParameters(self): return _optim.AbdoRackwitz_getSpecificParameters(self)
    def setSpecificParameters(self, *args): return _optim.AbdoRackwitz_setSpecificParameters(self, *args)
    def __repr__(self): return _optim.AbdoRackwitz___repr__(self)
    def __init__(self, *args): 
        this = _optim.new_AbdoRackwitz(*args)
        try: self.this.append(this)
        except: self.this = this
    __swig_destroy__ = _optim.delete_AbdoRackwitz
    __del__ = lambda self : None;
AbdoRackwitz_swigregister = _optim.AbdoRackwitz_swigregister
AbdoRackwitz_swigregister(AbdoRackwitz)

class CobylaSpecificParameters(openturns.common.PersistentObject):
    __swig_setmethods__ = {}
    for _s in [openturns.common.PersistentObject]: __swig_setmethods__.update(getattr(_s,'__swig_setmethods__',{}))
    __setattr__ = lambda self, name, value: _swig_setattr(self, CobylaSpecificParameters, name, value)
    __swig_getmethods__ = {}
    for _s in [openturns.common.PersistentObject]: __swig_getmethods__.update(getattr(_s,'__swig_getmethods__',{}))
    __getattr__ = lambda self, name: _swig_getattr(self, CobylaSpecificParameters, name)
    def getClassName(self):
        """
        Accessor to the object's name.

        Returns
        -------
        class_name : str
            The object class name (`object.__class__.__name__`).
        """
        return _optim.CobylaSpecificParameters_getClassName(self)

    def getRhoBeg(self): return _optim.CobylaSpecificParameters_getRhoBeg(self)
    def setRhoBeg(self, *args): return _optim.CobylaSpecificParameters_setRhoBeg(self, *args)
    def __repr__(self): return _optim.CobylaSpecificParameters___repr__(self)
    def __init__(self, *args): 
        this = _optim.new_CobylaSpecificParameters(*args)
        try: self.this.append(this)
        except: self.this = this
    __swig_destroy__ = _optim.delete_CobylaSpecificParameters
    __del__ = lambda self : None;
CobylaSpecificParameters_swigregister = _optim.CobylaSpecificParameters_swigregister
CobylaSpecificParameters_swigregister(CobylaSpecificParameters)

class Cobyla(NearestPointAlgorithmImplementation):
    __swig_setmethods__ = {}
    for _s in [NearestPointAlgorithmImplementation]: __swig_setmethods__.update(getattr(_s,'__swig_setmethods__',{}))
    __setattr__ = lambda self, name, value: _swig_setattr(self, Cobyla, name, value)
    __swig_getmethods__ = {}
    for _s in [NearestPointAlgorithmImplementation]: __swig_getmethods__.update(getattr(_s,'__swig_getmethods__',{}))
    __getattr__ = lambda self, name: _swig_getattr(self, Cobyla, name)
    def getClassName(self):
        """
        Accessor to the object's name.

        Returns
        -------
        class_name : str
            The object class name (`object.__class__.__name__`).
        """
        return _optim.Cobyla_getClassName(self)

    def run(self): return _optim.Cobyla_run(self)
    def getSpecificParameters(self): return _optim.Cobyla_getSpecificParameters(self)
    def setSpecificParameters(self, *args): return _optim.Cobyla_setSpecificParameters(self, *args)
    def __repr__(self): return _optim.Cobyla___repr__(self)
    def __init__(self, *args): 
        this = _optim.new_Cobyla(*args)
        try: self.this.append(this)
        except: self.this = this
    __swig_destroy__ = _optim.delete_Cobyla
    __del__ = lambda self : None;
Cobyla_swigregister = _optim.Cobyla_swigregister
Cobyla_swigregister(Cobyla)

class TNCSpecificParameters(openturns.common.PersistentObject):
    __swig_setmethods__ = {}
    for _s in [openturns.common.PersistentObject]: __swig_setmethods__.update(getattr(_s,'__swig_setmethods__',{}))
    __setattr__ = lambda self, name, value: _swig_setattr(self, TNCSpecificParameters, name, value)
    __swig_getmethods__ = {}
    for _s in [openturns.common.PersistentObject]: __swig_getmethods__.update(getattr(_s,'__swig_getmethods__',{}))
    __getattr__ = lambda self, name: _swig_getattr(self, TNCSpecificParameters, name)
    def getClassName(self):
        """
        Accessor to the object's name.

        Returns
        -------
        class_name : str
            The object class name (`object.__class__.__name__`).
        """
        return _optim.TNCSpecificParameters_getClassName(self)

    def getScale(self): return _optim.TNCSpecificParameters_getScale(self)
    def setScale(self, *args): return _optim.TNCSpecificParameters_setScale(self, *args)
    def getOffset(self): return _optim.TNCSpecificParameters_getOffset(self)
    def setOffset(self, *args): return _optim.TNCSpecificParameters_setOffset(self, *args)
    def getMaxCGit(self): return _optim.TNCSpecificParameters_getMaxCGit(self)
    def setMaxCGit(self, *args): return _optim.TNCSpecificParameters_setMaxCGit(self, *args)
    def getEta(self): return _optim.TNCSpecificParameters_getEta(self)
    def setEta(self, *args): return _optim.TNCSpecificParameters_setEta(self, *args)
    def getStepmx(self): return _optim.TNCSpecificParameters_getStepmx(self)
    def setStepmx(self, *args): return _optim.TNCSpecificParameters_setStepmx(self, *args)
    def getAccuracy(self): return _optim.TNCSpecificParameters_getAccuracy(self)
    def setAccuracy(self, *args): return _optim.TNCSpecificParameters_setAccuracy(self, *args)
    def getFmin(self): return _optim.TNCSpecificParameters_getFmin(self)
    def setFmin(self, *args): return _optim.TNCSpecificParameters_setFmin(self, *args)
    def getRescale(self): return _optim.TNCSpecificParameters_getRescale(self)
    def setRescale(self, *args): return _optim.TNCSpecificParameters_setRescale(self, *args)
    def __repr__(self): return _optim.TNCSpecificParameters___repr__(self)
    def __init__(self, *args): 
        this = _optim.new_TNCSpecificParameters(*args)
        try: self.this.append(this)
        except: self.this = this
    __swig_destroy__ = _optim.delete_TNCSpecificParameters
    __del__ = lambda self : None;
TNCSpecificParameters_swigregister = _optim.TNCSpecificParameters_swigregister
TNCSpecificParameters_swigregister(TNCSpecificParameters)

class TNC(BoundConstrainedAlgorithmImplementation):
    __swig_setmethods__ = {}
    for _s in [BoundConstrainedAlgorithmImplementation]: __swig_setmethods__.update(getattr(_s,'__swig_setmethods__',{}))
    __setattr__ = lambda self, name, value: _swig_setattr(self, TNC, name, value)
    __swig_getmethods__ = {}
    for _s in [BoundConstrainedAlgorithmImplementation]: __swig_getmethods__.update(getattr(_s,'__swig_getmethods__',{}))
    __getattr__ = lambda self, name: _swig_getattr(self, TNC, name)
    def getClassName(self):
        """
        Accessor to the object's name.

        Returns
        -------
        class_name : str
            The object class name (`object.__class__.__name__`).
        """
        return _optim.TNC_getClassName(self)

    def run(self): return _optim.TNC_run(self)
    def getSpecificParameters(self): return _optim.TNC_getSpecificParameters(self)
    def setSpecificParameters(self, *args): return _optim.TNC_setSpecificParameters(self, *args)
    def __repr__(self): return _optim.TNC___repr__(self)
    def __init__(self, *args): 
        this = _optim.new_TNC(*args)
        try: self.this.append(this)
        except: self.this = this
    __swig_destroy__ = _optim.delete_TNC
    __del__ = lambda self : None;
TNC_swigregister = _optim.TNC_swigregister
TNC_swigregister(TNC)

class SQPSpecificParameters(openturns.common.PersistentObject):
    __swig_setmethods__ = {}
    for _s in [openturns.common.PersistentObject]: __swig_setmethods__.update(getattr(_s,'__swig_setmethods__',{}))
    __setattr__ = lambda self, name, value: _swig_setattr(self, SQPSpecificParameters, name, value)
    __swig_getmethods__ = {}
    for _s in [openturns.common.PersistentObject]: __swig_getmethods__.update(getattr(_s,'__swig_getmethods__',{}))
    __getattr__ = lambda self, name: _swig_getattr(self, SQPSpecificParameters, name)
    def getClassName(self):
        """
        Accessor to the object's name.

        Returns
        -------
        class_name : str
            The object class name (`object.__class__.__name__`).
        """
        return _optim.SQPSpecificParameters_getClassName(self)

    def getTau(self): return _optim.SQPSpecificParameters_getTau(self)
    def setTau(self, *args): return _optim.SQPSpecificParameters_setTau(self, *args)
    def getOmega(self): return _optim.SQPSpecificParameters_getOmega(self)
    def setOmega(self, *args): return _optim.SQPSpecificParameters_setOmega(self, *args)
    def getSmooth(self): return _optim.SQPSpecificParameters_getSmooth(self)
    def setSmooth(self, *args): return _optim.SQPSpecificParameters_setSmooth(self, *args)
    def __repr__(self): return _optim.SQPSpecificParameters___repr__(self)
    def __init__(self, *args): 
        this = _optim.new_SQPSpecificParameters(*args)
        try: self.this.append(this)
        except: self.this = this
    __swig_destroy__ = _optim.delete_SQPSpecificParameters
    __del__ = lambda self : None;
SQPSpecificParameters_swigregister = _optim.SQPSpecificParameters_swigregister
SQPSpecificParameters_swigregister(SQPSpecificParameters)

class SQP(NearestPointAlgorithmImplementation):
    __swig_setmethods__ = {}
    for _s in [NearestPointAlgorithmImplementation]: __swig_setmethods__.update(getattr(_s,'__swig_setmethods__',{}))
    __setattr__ = lambda self, name, value: _swig_setattr(self, SQP, name, value)
    __swig_getmethods__ = {}
    for _s in [NearestPointAlgorithmImplementation]: __swig_getmethods__.update(getattr(_s,'__swig_getmethods__',{}))
    __getattr__ = lambda self, name: _swig_getattr(self, SQP, name)
    def getClassName(self):
        """
        Accessor to the object's name.

        Returns
        -------
        class_name : str
            The object class name (`object.__class__.__name__`).
        """
        return _optim.SQP_getClassName(self)

    def run(self): return _optim.SQP_run(self)
    def getSpecificParameters(self): return _optim.SQP_getSpecificParameters(self)
    def setSpecificParameters(self, *args): return _optim.SQP_setSpecificParameters(self, *args)
    def __repr__(self): return _optim.SQP___repr__(self)
    def __init__(self, *args): 
        this = _optim.new_SQP(*args)
        try: self.this.append(this)
        except: self.this = this
    __swig_destroy__ = _optim.delete_SQP
    __del__ = lambda self : None;
SQP_swigregister = _optim.SQP_swigregister
SQP_swigregister(SQP)

class NearestPointAlgorithmImplementationPointer(_object):
    __swig_setmethods__ = {}
    __setattr__ = lambda self, name, value: _swig_setattr(self, NearestPointAlgorithmImplementationPointer, name, value)
    __swig_getmethods__ = {}
    __getattr__ = lambda self, name: _swig_getattr(self, NearestPointAlgorithmImplementationPointer, name)
    __swig_setmethods__["ptr_"] = _optim.NearestPointAlgorithmImplementationPointer_ptr__set
    __swig_getmethods__["ptr_"] = _optim.NearestPointAlgorithmImplementationPointer_ptr__get
    if _newclass:ptr_ = _swig_property(_optim.NearestPointAlgorithmImplementationPointer_ptr__get, _optim.NearestPointAlgorithmImplementationPointer_ptr__set)
    def __init__(self, *args): 
        this = _optim.new_NearestPointAlgorithmImplementationPointer(*args)
        try: self.this.append(this)
        except: self.this = this
    __swig_destroy__ = _optim.delete_NearestPointAlgorithmImplementationPointer
    __del__ = lambda self : None;
    def reset(self): return _optim.NearestPointAlgorithmImplementationPointer_reset(self)
    def __ref__(self, *args): return _optim.NearestPointAlgorithmImplementationPointer___ref__(self, *args)
    def __deref__(self): return _optim.NearestPointAlgorithmImplementationPointer___deref__(self)
    def isNull(self): return _optim.NearestPointAlgorithmImplementationPointer_isNull(self)
    def __nonzero__(self):
        return _optim.NearestPointAlgorithmImplementationPointer___nonzero__(self)
    __bool__ = __nonzero__


    def get(self): return _optim.NearestPointAlgorithmImplementationPointer_get(self)
    def getImplementation(self): return _optim.NearestPointAlgorithmImplementationPointer_getImplementation(self)
    def unique(self): return _optim.NearestPointAlgorithmImplementationPointer_unique(self)
    def use_count(self): return _optim.NearestPointAlgorithmImplementationPointer_use_count(self)
    def swap(self, *args): return _optim.NearestPointAlgorithmImplementationPointer_swap(self, *args)
    def getClassName(self):
        """
        Accessor to the object's name.

        Returns
        -------
        class_name : str
            The object class name (`object.__class__.__name__`).
        """
        return _optim.NearestPointAlgorithmImplementationPointer_getClassName(self)

    def run(self): return _optim.NearestPointAlgorithmImplementationPointer_run(self)
    def getStartingPoint(self): return _optim.NearestPointAlgorithmImplementationPointer_getStartingPoint(self)
    def setStartingPoint(self, *args): return _optim.NearestPointAlgorithmImplementationPointer_setStartingPoint(self, *args)
    def getLevelFunction(self): return _optim.NearestPointAlgorithmImplementationPointer_getLevelFunction(self)
    def setLevelFunction(self, *args): return _optim.NearestPointAlgorithmImplementationPointer_setLevelFunction(self, *args)
    def getLevelValue(self): return _optim.NearestPointAlgorithmImplementationPointer_getLevelValue(self)
    def setLevelValue(self, *args): return _optim.NearestPointAlgorithmImplementationPointer_setLevelValue(self, *args)
    def getResult(self): return _optim.NearestPointAlgorithmImplementationPointer_getResult(self)
    def setResult(self, *args): return _optim.NearestPointAlgorithmImplementationPointer_setResult(self, *args)
    def getMaximumIterationsNumber(self): return _optim.NearestPointAlgorithmImplementationPointer_getMaximumIterationsNumber(self)
    def setMaximumIterationsNumber(self, *args): return _optim.NearestPointAlgorithmImplementationPointer_setMaximumIterationsNumber(self, *args)
    def getMaximumAbsoluteError(self): return _optim.NearestPointAlgorithmImplementationPointer_getMaximumAbsoluteError(self)
    def setMaximumAbsoluteError(self, *args): return _optim.NearestPointAlgorithmImplementationPointer_setMaximumAbsoluteError(self, *args)
    def getMaximumRelativeError(self): return _optim.NearestPointAlgorithmImplementationPointer_getMaximumRelativeError(self)
    def setMaximumRelativeError(self, *args): return _optim.NearestPointAlgorithmImplementationPointer_setMaximumRelativeError(self, *args)
    def getMaximumResidualError(self): return _optim.NearestPointAlgorithmImplementationPointer_getMaximumResidualError(self)
    def setMaximumResidualError(self, *args): return _optim.NearestPointAlgorithmImplementationPointer_setMaximumResidualError(self, *args)
    def getMaximumConstraintError(self): return _optim.NearestPointAlgorithmImplementationPointer_getMaximumConstraintError(self)
    def setMaximumConstraintError(self, *args): return _optim.NearestPointAlgorithmImplementationPointer_setMaximumConstraintError(self, *args)
    def __repr__(self): return _optim.NearestPointAlgorithmImplementationPointer___repr__(self)
    def getVerbose(self): return _optim.NearestPointAlgorithmImplementationPointer_getVerbose(self)
    def setVerbose(self, *args): return _optim.NearestPointAlgorithmImplementationPointer_setVerbose(self, *args)
    def __eq__(self, *args): return _optim.NearestPointAlgorithmImplementationPointer___eq__(self, *args)
    def __ne__(self, *args): return _optim.NearestPointAlgorithmImplementationPointer___ne__(self, *args)
    def __str__(self, offset=""): return _optim.NearestPointAlgorithmImplementationPointer___str__(self, offset)
    def getId(self):
        """
        Accessor to the object's id.

        Returns
        -------
        id : int
           Internal unique identifier.
        """
        return _optim.NearestPointAlgorithmImplementationPointer_getId(self)

    def setShadowedId(self, *args):
        """
        Accessor to the object's shadowed id.

        Parameters
        ----------
        id : int
            Internal unique identifier.
        """
        return _optim.NearestPointAlgorithmImplementationPointer_setShadowedId(self, *args)

    def getShadowedId(self):
        """
        Accessor to the object's shadowed id.

        Returns
        -------
        id : int
            Internal unique identifier.
        """
        return _optim.NearestPointAlgorithmImplementationPointer_getShadowedId(self)

    def setVisibility(self, *args):
        """
        Accessor to the object's visibility state.

        Parameters
        ----------
        visible : bool
            Visibility flag.
        """
        return _optim.NearestPointAlgorithmImplementationPointer_setVisibility(self, *args)

    def getVisibility(self):
        """
        Accessor to the object's visibility state.

        Returns
        -------
        visible : bool
            Visibility flag.
        """
        return _optim.NearestPointAlgorithmImplementationPointer_getVisibility(self)

    def hasName(self):
        """
        Test if the object is named.

        Returns
        -------
        hasName : bool
            True if the name is not empty.
        """
        return _optim.NearestPointAlgorithmImplementationPointer_hasName(self)

    def hasVisibleName(self):
        """
        Test if the object has a distinghishable name.

        Returns
        -------
        hasVisibleName : bool
            True if the name is not empty and not the default one.
        """
        return _optim.NearestPointAlgorithmImplementationPointer_hasVisibleName(self)

    def getName(self):
        """
        Accessor to the object's name.

        Returns
        -------
        name : string
            The name of the object.
        """
        return _optim.NearestPointAlgorithmImplementationPointer_getName(self)

    def setName(self, *args):
        """
        Accessor to the object's name.

        Parameters
        ----------
        name : string
            The name of the object.
        """
        return _optim.NearestPointAlgorithmImplementationPointer_setName(self, *args)

NearestPointAlgorithmImplementationPointer_swigregister = _optim.NearestPointAlgorithmImplementationPointer_swigregister
NearestPointAlgorithmImplementationPointer_swigregister(NearestPointAlgorithmImplementationPointer)

class SolverImplementationPointer(_object):
    __swig_setmethods__ = {}
    __setattr__ = lambda self, name, value: _swig_setattr(self, SolverImplementationPointer, name, value)
    __swig_getmethods__ = {}
    __getattr__ = lambda self, name: _swig_getattr(self, SolverImplementationPointer, name)
    __repr__ = _swig_repr
    __swig_setmethods__["ptr_"] = _optim.SolverImplementationPointer_ptr__set
    __swig_getmethods__["ptr_"] = _optim.SolverImplementationPointer_ptr__get
    if _newclass:ptr_ = _swig_property(_optim.SolverImplementationPointer_ptr__get, _optim.SolverImplementationPointer_ptr__set)
    def __init__(self, *args): 
        this = _optim.new_SolverImplementationPointer(*args)
        try: self.this.append(this)
        except: self.this = this
    __swig_destroy__ = _optim.delete_SolverImplementationPointer
    __del__ = lambda self : None;
    def reset(self): return _optim.SolverImplementationPointer_reset(self)
    def __ref__(self, *args): return _optim.SolverImplementationPointer___ref__(self, *args)
    def __deref__(self): return _optim.SolverImplementationPointer___deref__(self)
    def isNull(self): return _optim.SolverImplementationPointer_isNull(self)
    def __nonzero__(self):
        return _optim.SolverImplementationPointer___nonzero__(self)
    __bool__ = __nonzero__


    def get(self): return _optim.SolverImplementationPointer_get(self)
    def getImplementation(self): return _optim.SolverImplementationPointer_getImplementation(self)
    def unique(self): return _optim.SolverImplementationPointer_unique(self)
    def use_count(self): return _optim.SolverImplementationPointer_use_count(self)
    def swap(self, *args): return _optim.SolverImplementationPointer_swap(self, *args)
SolverImplementationPointer_swigregister = _optim.SolverImplementationPointer_swigregister
SolverImplementationPointer_swigregister(SolverImplementationPointer)

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