/usr/share/pyshared/openturns/optim.py

# This file was automatically generated by SWIG (http://www.swig.org).
# Version 2.0.10
#
# 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):
    """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__ = _optim.delete_SwigPyIterator
    __del__ = lambda self : None;
    def value(self):
        """value(SwigPyIterator self) -> PyObject *"""
        return _optim.SwigPyIterator_value(self)

    def incr(self, n=1):
        """
        incr(SwigPyIterator self, size_t n=1) -> SwigPyIterator
        incr(SwigPyIterator self) -> SwigPyIterator
        """
        return _optim.SwigPyIterator_incr(self, n)

    def decr(self, n=1):
        """
        decr(SwigPyIterator self, size_t n=1) -> SwigPyIterator
        decr(SwigPyIterator self) -> SwigPyIterator
        """
        return _optim.SwigPyIterator_decr(self, n)

    def distance(self, *args):
        """distance(SwigPyIterator self, SwigPyIterator x) -> ptrdiff_t"""
        return _optim.SwigPyIterator_distance(self, *args)

    def equal(self, *args):
        """equal(SwigPyIterator self, SwigPyIterator x) -> bool"""
        return _optim.SwigPyIterator_equal(self, *args)

    def copy(self):
        """copy(SwigPyIterator self) -> SwigPyIterator"""
        return _optim.SwigPyIterator_copy(self)

    def next(self):
        """next(SwigPyIterator self) -> PyObject *"""
        return _optim.SwigPyIterator_next(self)

    def __next__(self):
        """__next__(SwigPyIterator self) -> PyObject *"""
        return _optim.SwigPyIterator___next__(self)

    def previous(self):
        """previous(SwigPyIterator self) -> PyObject *"""
        return _optim.SwigPyIterator_previous(self)

    def advance(self, *args):
        """advance(SwigPyIterator self, ptrdiff_t n) -> SwigPyIterator"""
        return _optim.SwigPyIterator_advance(self, *args)

    def __eq__(self, *args):
        """__eq__(SwigPyIterator self, SwigPyIterator x) -> bool"""
        return _optim.SwigPyIterator___eq__(self, *args)

    def __ne__(self, *args):
        """__ne__(SwigPyIterator self, SwigPyIterator x) -> bool"""
        return _optim.SwigPyIterator___ne__(self, *args)

    def __iadd__(self, *args):
        """__iadd__(SwigPyIterator self, ptrdiff_t n) -> SwigPyIterator"""
        return _optim.SwigPyIterator___iadd__(self, *args)

    def __isub__(self, *args):
        """__isub__(SwigPyIterator self, ptrdiff_t n) -> SwigPyIterator"""
        return _optim.SwigPyIterator___isub__(self, *args)

    def __add__(self, *args):
        """__add__(SwigPyIterator self, ptrdiff_t n) -> SwigPyIterator"""
        return _optim.SwigPyIterator___add__(self, *args)

    def __sub__(self, *args):
        """
        __sub__(SwigPyIterator self, ptrdiff_t n) -> SwigPyIterator
        __sub__(SwigPyIterator self, SwigPyIterator x) -> ptrdiff_t
        """
        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):
    """Proxy of C++ OT::BoundConstrainedAlgorithmImplementationResult class"""
    __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():
        """GetClassName() -> OT::String"""
        return _optim.BoundConstrainedAlgorithmImplementationResult_GetClassName()

    if _newclass:GetClassName = staticmethod(GetClassName)
    __swig_getmethods__["GetClassName"] = lambda x: GetClassName
    def getClassName(self):
        """getClassName(BoundConstrainedAlgorithmImplementationResult self) -> OT::String"""
        return _optim.BoundConstrainedAlgorithmImplementationResult_getClassName(self)

    MINIMIZATION = _optim.BoundConstrainedAlgorithmImplementationResult_MINIMIZATION
    MAXIMIZATION = _optim.BoundConstrainedAlgorithmImplementationResult_MAXIMIZATION
    def getOptimizer(self):
        """getOptimizer(BoundConstrainedAlgorithmImplementationResult self) -> NumericalPoint"""
        return _optim.BoundConstrainedAlgorithmImplementationResult_getOptimizer(self)

    def getOptimalValue(self):
        """getOptimalValue(BoundConstrainedAlgorithmImplementationResult self) -> OT::NumericalScalar"""
        return _optim.BoundConstrainedAlgorithmImplementationResult_getOptimalValue(self)

    def getOptimizationProblem(self):
        """getOptimizationProblem(BoundConstrainedAlgorithmImplementationResult self) -> OT::BoundConstrainedAlgorithmImplementationResult::OptimizationProblem"""
        return _optim.BoundConstrainedAlgorithmImplementationResult_getOptimizationProblem(self)

    def getEvaluationsNumber(self):
        """getEvaluationsNumber(BoundConstrainedAlgorithmImplementationResult self) -> OT::UnsignedLong"""
        return _optim.BoundConstrainedAlgorithmImplementationResult_getEvaluationsNumber(self)

    def getAbsoluteError(self):
        """getAbsoluteError(BoundConstrainedAlgorithmImplementationResult self) -> OT::NumericalScalar"""
        return _optim.BoundConstrainedAlgorithmImplementationResult_getAbsoluteError(self)

    def getRelativeError(self):
        """getRelativeError(BoundConstrainedAlgorithmImplementationResult self) -> OT::NumericalScalar"""
        return _optim.BoundConstrainedAlgorithmImplementationResult_getRelativeError(self)

    def getObjectiveError(self):
        """getObjectiveError(BoundConstrainedAlgorithmImplementationResult self) -> OT::NumericalScalar"""
        return _optim.BoundConstrainedAlgorithmImplementationResult_getObjectiveError(self)

    def getConstraintError(self):
        """getConstraintError(BoundConstrainedAlgorithmImplementationResult self) -> OT::NumericalScalar"""
        return _optim.BoundConstrainedAlgorithmImplementationResult_getConstraintError(self)

    def __repr__(self):
        """__repr__(BoundConstrainedAlgorithmImplementationResult self) -> OT::String"""
        return _optim.BoundConstrainedAlgorithmImplementationResult___repr__(self)

    def __init__(self, *args): 
        """
        __init__(OT::BoundConstrainedAlgorithmImplementationResult self) -> BoundConstrainedAlgorithmImplementationResult
        __init__(OT::BoundConstrainedAlgorithmImplementationResult self, NumericalPoint optimizer, OT::NumericalScalar const optimalValue, OT::BoundConstrainedAlgorithmImplementationResult::OptimizationProblem const optimization, 
            OT::UnsignedLong const evaluationsNumber, 
            OT::NumericalScalar const absoluteError, 
            OT::NumericalScalar const relativeError, OT::NumericalScalar const objectiveError, 
            OT::NumericalScalar const constraintError) -> BoundConstrainedAlgorithmImplementationResult
        __init__(OT::BoundConstrainedAlgorithmImplementationResult self, BoundConstrainedAlgorithmImplementationResult other) -> BoundConstrainedAlgorithmImplementationResult
        """
        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)

def BoundConstrainedAlgorithmImplementationResult_GetClassName():
  """BoundConstrainedAlgorithmImplementationResult_GetClassName() -> OT::String"""
  return _optim.BoundConstrainedAlgorithmImplementationResult_GetClassName()

class BoundConstrainedAlgorithmImplementation(openturns.common.PersistentObject,openturns.common.Threadable):
    """Proxy of C++ OT::BoundConstrainedAlgorithmImplementation class"""
    __swig_setmethods__ = {}
    for _s in [openturns.common.PersistentObject,openturns.common.Threadable]: __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,openturns.common.Threadable]: __swig_getmethods__.update(getattr(_s,'__swig_getmethods__',{}))
    __getattr__ = lambda self, name: _swig_getattr(self, BoundConstrainedAlgorithmImplementation, name)
    def GetClassName():
        """GetClassName() -> OT::String"""
        return _optim.BoundConstrainedAlgorithmImplementation_GetClassName()

    if _newclass:GetClassName = staticmethod(GetClassName)
    __swig_getmethods__["GetClassName"] = lambda x: GetClassName
    def getClassName(self):
        """getClassName(BoundConstrainedAlgorithmImplementation self) -> OT::String"""
        return _optim.BoundConstrainedAlgorithmImplementation_getClassName(self)

    def run(self):
        """run(BoundConstrainedAlgorithmImplementation self)"""
        return _optim.BoundConstrainedAlgorithmImplementation_run(self)

    def getStartingPoint(self):
        """getStartingPoint(BoundConstrainedAlgorithmImplementation self) -> NumericalPoint"""
        return _optim.BoundConstrainedAlgorithmImplementation_getStartingPoint(self)

    def setStartingPoint(self, *args):
        """setStartingPoint(BoundConstrainedAlgorithmImplementation self, NumericalPoint startingPoint)"""
        return _optim.BoundConstrainedAlgorithmImplementation_setStartingPoint(self, *args)

    def getObjectiveFunction(self):
        """getObjectiveFunction(BoundConstrainedAlgorithmImplementation self) -> NumericalMathFunction"""
        return _optim.BoundConstrainedAlgorithmImplementation_getObjectiveFunction(self)

    def setObjectiveFunction(self, *args):
        """setObjectiveFunction(BoundConstrainedAlgorithmImplementation self, NumericalMathFunction objectiveFunction)"""
        return _optim.BoundConstrainedAlgorithmImplementation_setObjectiveFunction(self, *args)

    def getBoundConstraints(self):
        """getBoundConstraints(BoundConstrainedAlgorithmImplementation self) -> Interval"""
        return _optim.BoundConstrainedAlgorithmImplementation_getBoundConstraints(self)

    def setBoundConstraints(self, *args):
        """setBoundConstraints(BoundConstrainedAlgorithmImplementation self, Interval boundConstraints)"""
        return _optim.BoundConstrainedAlgorithmImplementation_setBoundConstraints(self, *args)

    def getOptimizationProblem(self):
        """getOptimizationProblem(BoundConstrainedAlgorithmImplementation self) -> OT::BoundConstrainedAlgorithmImplementation::OptimizationProblem"""
        return _optim.BoundConstrainedAlgorithmImplementation_getOptimizationProblem(self)

    def setOptimizationProblem(self, *args):
        """setOptimizationProblem(BoundConstrainedAlgorithmImplementation self, OT::BoundConstrainedAlgorithmImplementation::OptimizationProblem const optimization)"""
        return _optim.BoundConstrainedAlgorithmImplementation_setOptimizationProblem(self, *args)

    def getResult(self):
        """getResult(BoundConstrainedAlgorithmImplementation self) -> BoundConstrainedAlgorithmImplementationResult"""
        return _optim.BoundConstrainedAlgorithmImplementation_getResult(self)

    def setResult(self, *args):
        """setResult(BoundConstrainedAlgorithmImplementation self, BoundConstrainedAlgorithmImplementationResult result)"""
        return _optim.BoundConstrainedAlgorithmImplementation_setResult(self, *args)

    def getMaximumEvaluationsNumber(self):
        """getMaximumEvaluationsNumber(BoundConstrainedAlgorithmImplementation self) -> OT::UnsignedLong"""
        return _optim.BoundConstrainedAlgorithmImplementation_getMaximumEvaluationsNumber(self)

    def setMaximumEvaluationsNumber(self, *args):
        """setMaximumEvaluationsNumber(BoundConstrainedAlgorithmImplementation self, OT::UnsignedLong const maximumEvaluationsNumber)"""
        return _optim.BoundConstrainedAlgorithmImplementation_setMaximumEvaluationsNumber(self, *args)

    def getMaximumAbsoluteError(self):
        """getMaximumAbsoluteError(BoundConstrainedAlgorithmImplementation self) -> OT::NumericalScalar"""
        return _optim.BoundConstrainedAlgorithmImplementation_getMaximumAbsoluteError(self)

    def setMaximumAbsoluteError(self, *args):
        """setMaximumAbsoluteError(BoundConstrainedAlgorithmImplementation self, OT::NumericalScalar const maximumAbsoluteError)"""
        return _optim.BoundConstrainedAlgorithmImplementation_setMaximumAbsoluteError(self, *args)

    def getMaximumRelativeError(self):
        """getMaximumRelativeError(BoundConstrainedAlgorithmImplementation self) -> OT::NumericalScalar"""
        return _optim.BoundConstrainedAlgorithmImplementation_getMaximumRelativeError(self)

    def setMaximumRelativeError(self, *args):
        """setMaximumRelativeError(BoundConstrainedAlgorithmImplementation self, OT::NumericalScalar const maximumRelativeError)"""
        return _optim.BoundConstrainedAlgorithmImplementation_setMaximumRelativeError(self, *args)

    def getMaximumObjectiveError(self):
        """getMaximumObjectiveError(BoundConstrainedAlgorithmImplementation self) -> OT::NumericalScalar"""
        return _optim.BoundConstrainedAlgorithmImplementation_getMaximumObjectiveError(self)

    def setMaximumObjectiveError(self, *args):
        """setMaximumObjectiveError(BoundConstrainedAlgorithmImplementation self, OT::NumericalScalar const maximumObjectiveError)"""
        return _optim.BoundConstrainedAlgorithmImplementation_setMaximumObjectiveError(self, *args)

    def getMaximumConstraintError(self):
        """getMaximumConstraintError(BoundConstrainedAlgorithmImplementation self) -> OT::NumericalScalar"""
        return _optim.BoundConstrainedAlgorithmImplementation_getMaximumConstraintError(self)

    def setMaximumConstraintError(self, *args):
        """setMaximumConstraintError(BoundConstrainedAlgorithmImplementation self, OT::NumericalScalar const maximumConstraintError)"""
        return _optim.BoundConstrainedAlgorithmImplementation_setMaximumConstraintError(self, *args)

    def __repr__(self):
        """__repr__(BoundConstrainedAlgorithmImplementation self) -> OT::String"""
        return _optim.BoundConstrainedAlgorithmImplementation___repr__(self)

    def getVerbose(self):
        """getVerbose(BoundConstrainedAlgorithmImplementation self) -> OT::Bool"""
        return _optim.BoundConstrainedAlgorithmImplementation_getVerbose(self)

    def setVerbose(self, *args):
        """setVerbose(BoundConstrainedAlgorithmImplementation self, OT::Bool const verbose)"""
        return _optim.BoundConstrainedAlgorithmImplementation_setVerbose(self, *args)

    def __init__(self, *args): 
        """
        __init__(OT::BoundConstrainedAlgorithmImplementation self) -> BoundConstrainedAlgorithmImplementation
        __init__(OT::BoundConstrainedAlgorithmImplementation self, NumericalMathFunction objectiveFunction, OT::Bool const verbose=True) -> BoundConstrainedAlgorithmImplementation
        __init__(OT::BoundConstrainedAlgorithmImplementation self, NumericalMathFunction objectiveFunction) -> BoundConstrainedAlgorithmImplementation
        __init__(OT::BoundConstrainedAlgorithmImplementation self, NumericalMathFunction objectiveFunction, Interval boundConstraints, NumericalPoint startingPoint, 
            OT::BoundConstrainedAlgorithmImplementation::OptimizationProblem const optimization=MINIMIZATION, 
            OT::Bool const verbose=True) -> BoundConstrainedAlgorithmImplementation
        __init__(OT::BoundConstrainedAlgorithmImplementation self, NumericalMathFunction objectiveFunction, Interval boundConstraints, NumericalPoint startingPoint, 
            OT::BoundConstrainedAlgorithmImplementation::OptimizationProblem const optimization=MINIMIZATION) -> BoundConstrainedAlgorithmImplementation
        __init__(OT::BoundConstrainedAlgorithmImplementation self, NumericalMathFunction objectiveFunction, Interval boundConstraints, NumericalPoint startingPoint) -> BoundConstrainedAlgorithmImplementation
        __init__(OT::BoundConstrainedAlgorithmImplementation self, BoundConstrainedAlgorithmImplementation other) -> BoundConstrainedAlgorithmImplementation
        """
        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)

def BoundConstrainedAlgorithmImplementation_GetClassName():
  """BoundConstrainedAlgorithmImplementation_GetClassName() -> OT::String"""
  return _optim.BoundConstrainedAlgorithmImplementation_GetClassName()

class BoundConstrainedAlgorithmImplementationTypedInterfaceObject(openturns.common.InterfaceObject):
    """Proxy of C++ OT::TypedInterfaceObject<(OT::BoundConstrainedAlgorithmImplementation)> class"""
    __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): 
        """
        __init__(OT::TypedInterfaceObject<(OT::BoundConstrainedAlgorithmImplementation)> self) -> BoundConstrainedAlgorithmImplementationTypedInterfaceObject
        __init__(OT::TypedInterfaceObject<(OT::BoundConstrainedAlgorithmImplementation)> self, OT::TypedInterfaceObject< OT::BoundConstrainedAlgorithmImplementation >::Implementation const & impl) -> BoundConstrainedAlgorithmImplementationTypedInterfaceObject
        """
        this = _optim.new_BoundConstrainedAlgorithmImplementationTypedInterfaceObject(*args)
        try: self.this.append(this)
        except: self.this = this
    def getImplementation(self, *args):
        """
        getImplementation(BoundConstrainedAlgorithmImplementationTypedInterfaceObject self) -> OT::TypedInterfaceObject< OT::BoundConstrainedAlgorithmImplementation >::Implementation
        getImplementation(BoundConstrainedAlgorithmImplementationTypedInterfaceObject self) -> OT::TypedInterfaceObject< OT::BoundConstrainedAlgorithmImplementation >::Implementation const &
        """
        return _optim.BoundConstrainedAlgorithmImplementationTypedInterfaceObject_getImplementation(self, *args)

    def getImplementationAsPersistentObject(self):
        """getImplementationAsPersistentObject(BoundConstrainedAlgorithmImplementationTypedInterfaceObject self) -> PersistentObjectPointer"""
        return _optim.BoundConstrainedAlgorithmImplementationTypedInterfaceObject_getImplementationAsPersistentObject(self)

    def setImplementationAsPersistentObject(self, *args):
        """setImplementationAsPersistentObject(BoundConstrainedAlgorithmImplementationTypedInterfaceObject self, PersistentObjectPointer obj)"""
        return _optim.BoundConstrainedAlgorithmImplementationTypedInterfaceObject_setImplementationAsPersistentObject(self, *args)

    def swap(self, *args):
        """swap(BoundConstrainedAlgorithmImplementationTypedInterfaceObject self, BoundConstrainedAlgorithmImplementationTypedInterfaceObject other)"""
        return _optim.BoundConstrainedAlgorithmImplementationTypedInterfaceObject_swap(self, *args)

    def setName(self, *args):
        """setName(BoundConstrainedAlgorithmImplementationTypedInterfaceObject self, OT::String const & name)"""
        return _optim.BoundConstrainedAlgorithmImplementationTypedInterfaceObject_setName(self, *args)

    def getName(self):
        """getName(BoundConstrainedAlgorithmImplementationTypedInterfaceObject self) -> OT::String"""
        return _optim.BoundConstrainedAlgorithmImplementationTypedInterfaceObject_getName(self)

    def __eq__(self, *args):
        """__eq__(BoundConstrainedAlgorithmImplementationTypedInterfaceObject self, BoundConstrainedAlgorithmImplementationTypedInterfaceObject other) -> OT::Bool"""
        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):
    """Proxy of C++ OT::BoundConstrainedAlgorithm class"""
    __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():
        """GetClassName() -> OT::String"""
        return _optim.BoundConstrainedAlgorithm_GetClassName()

    if _newclass:GetClassName = staticmethod(GetClassName)
    __swig_getmethods__["GetClassName"] = lambda x: GetClassName
    def getClassName(self):
        """getClassName(BoundConstrainedAlgorithm self) -> OT::String"""
        return _optim.BoundConstrainedAlgorithm_getClassName(self)

    def run(self):
        """run(BoundConstrainedAlgorithm self)"""
        return _optim.BoundConstrainedAlgorithm_run(self)

    def getStartingPoint(self):
        """getStartingPoint(BoundConstrainedAlgorithm self) -> NumericalPoint"""
        return _optim.BoundConstrainedAlgorithm_getStartingPoint(self)

    def setStartingPoint(self, *args):
        """setStartingPoint(BoundConstrainedAlgorithm self, NumericalPoint startingPoint)"""
        return _optim.BoundConstrainedAlgorithm_setStartingPoint(self, *args)

    def getObjectiveFunction(self):
        """getObjectiveFunction(BoundConstrainedAlgorithm self) -> NumericalMathFunction"""
        return _optim.BoundConstrainedAlgorithm_getObjectiveFunction(self)

    def setObjectiveFunction(self, *args):
        """setObjectiveFunction(BoundConstrainedAlgorithm self, NumericalMathFunction objectiveFunction)"""
        return _optim.BoundConstrainedAlgorithm_setObjectiveFunction(self, *args)

    def getBoundConstraints(self):
        """getBoundConstraints(BoundConstrainedAlgorithm self) -> Interval"""
        return _optim.BoundConstrainedAlgorithm_getBoundConstraints(self)

    def setBoundConstraints(self, *args):
        """setBoundConstraints(BoundConstrainedAlgorithm self, Interval boundConstraints)"""
        return _optim.BoundConstrainedAlgorithm_setBoundConstraints(self, *args)

    def getOptimizationProblem(self):
        """getOptimizationProblem(BoundConstrainedAlgorithm self) -> OT::BoundConstrainedAlgorithm::OptimizationProblem"""
        return _optim.BoundConstrainedAlgorithm_getOptimizationProblem(self)

    def setOptimizationProblem(self, *args):
        """setOptimizationProblem(BoundConstrainedAlgorithm self, OT::BoundConstrainedAlgorithm::OptimizationProblem const optimization)"""
        return _optim.BoundConstrainedAlgorithm_setOptimizationProblem(self, *args)

    def getResult(self):
        """getResult(BoundConstrainedAlgorithm self) -> BoundConstrainedAlgorithmImplementationResult"""
        return _optim.BoundConstrainedAlgorithm_getResult(self)

    def setResult(self, *args):
        """setResult(BoundConstrainedAlgorithm self, BoundConstrainedAlgorithmImplementationResult result)"""
        return _optim.BoundConstrainedAlgorithm_setResult(self, *args)

    def getMaximumEvaluationsNumber(self):
        """getMaximumEvaluationsNumber(BoundConstrainedAlgorithm self) -> OT::UnsignedLong"""
        return _optim.BoundConstrainedAlgorithm_getMaximumEvaluationsNumber(self)

    def setMaximumEvaluationsNumber(self, *args):
        """setMaximumEvaluationsNumber(BoundConstrainedAlgorithm self, OT::UnsignedLong const maximumEvaluationsNumber)"""
        return _optim.BoundConstrainedAlgorithm_setMaximumEvaluationsNumber(self, *args)

    def getMaximumAbsoluteError(self):
        """getMaximumAbsoluteError(BoundConstrainedAlgorithm self) -> OT::NumericalScalar"""
        return _optim.BoundConstrainedAlgorithm_getMaximumAbsoluteError(self)

    def setMaximumAbsoluteError(self, *args):
        """setMaximumAbsoluteError(BoundConstrainedAlgorithm self, OT::NumericalScalar const maximumAbsoluteError)"""
        return _optim.BoundConstrainedAlgorithm_setMaximumAbsoluteError(self, *args)

    def getMaximumRelativeError(self):
        """getMaximumRelativeError(BoundConstrainedAlgorithm self) -> OT::NumericalScalar"""
        return _optim.BoundConstrainedAlgorithm_getMaximumRelativeError(self)

    def setMaximumRelativeError(self, *args):
        """setMaximumRelativeError(BoundConstrainedAlgorithm self, OT::NumericalScalar const maximumRelativeError)"""
        return _optim.BoundConstrainedAlgorithm_setMaximumRelativeError(self, *args)

    def getMaximumObjectiveError(self):
        """getMaximumObjectiveError(BoundConstrainedAlgorithm self) -> OT::NumericalScalar"""
        return _optim.BoundConstrainedAlgorithm_getMaximumObjectiveError(self)

    def setMaximumObjectiveError(self, *args):
        """setMaximumObjectiveError(BoundConstrainedAlgorithm self, OT::NumericalScalar const maximumObjectiveError)"""
        return _optim.BoundConstrainedAlgorithm_setMaximumObjectiveError(self, *args)

    def getMaximumConstraintError(self):
        """getMaximumConstraintError(BoundConstrainedAlgorithm self) -> OT::NumericalScalar"""
        return _optim.BoundConstrainedAlgorithm_getMaximumConstraintError(self)

    def setMaximumConstraintError(self, *args):
        """setMaximumConstraintError(BoundConstrainedAlgorithm self, OT::NumericalScalar const maximumConstraintError)"""
        return _optim.BoundConstrainedAlgorithm_setMaximumConstraintError(self, *args)

    def __repr__(self):
        """__repr__(BoundConstrainedAlgorithm self) -> OT::String"""
        return _optim.BoundConstrainedAlgorithm___repr__(self)

    def getVerbose(self):
        """getVerbose(BoundConstrainedAlgorithm self) -> OT::Bool"""
        return _optim.BoundConstrainedAlgorithm_getVerbose(self)

    def setVerbose(self, *args):
        """setVerbose(BoundConstrainedAlgorithm self, OT::Bool const verbose)"""
        return _optim.BoundConstrainedAlgorithm_setVerbose(self, *args)

    def __init__(self, *args): 
        """
        __init__(OT::BoundConstrainedAlgorithm self) -> BoundConstrainedAlgorithm
        __init__(OT::BoundConstrainedAlgorithm self, BoundConstrainedAlgorithmImplementation implementationconst) -> BoundConstrainedAlgorithm
        __init__(OT::BoundConstrainedAlgorithm self, OT::BoundConstrainedAlgorithm::Implementation const & p_implementation) -> BoundConstrainedAlgorithm
        __init__(OT::BoundConstrainedAlgorithm self, NumericalMathFunction objectiveFunction, OT::Bool const verbose=False) -> BoundConstrainedAlgorithm
        __init__(OT::BoundConstrainedAlgorithm self, NumericalMathFunction objectiveFunction) -> BoundConstrainedAlgorithm
        __init__(OT::BoundConstrainedAlgorithm self, NumericalMathFunction objectiveFunction, Interval boundConstraints, NumericalPoint startingPoint, 
            OT::BoundConstrainedAlgorithm::OptimizationProblem const optimization=MINIMIZATION, 
            OT::Bool const verbose=False) -> BoundConstrainedAlgorithm
        __init__(OT::BoundConstrainedAlgorithm self, NumericalMathFunction objectiveFunction, Interval boundConstraints, NumericalPoint startingPoint, 
            OT::BoundConstrainedAlgorithm::OptimizationProblem const optimization=MINIMIZATION) -> BoundConstrainedAlgorithm
        __init__(OT::BoundConstrainedAlgorithm self, NumericalMathFunction objectiveFunction, Interval boundConstraints, NumericalPoint startingPoint) -> BoundConstrainedAlgorithm
        __init__(OT::BoundConstrainedAlgorithm self, BoundConstrainedAlgorithm other) -> BoundConstrainedAlgorithm
        """
        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)

def BoundConstrainedAlgorithm_GetClassName():
  """BoundConstrainedAlgorithm_GetClassName() -> OT::String"""
  return _optim.BoundConstrainedAlgorithm_GetClassName()

class NearestPointAlgorithmImplementationResult(openturns.common.PersistentObject):
    """Proxy of C++ OT::NearestPointAlgorithmImplementationResult class"""
    __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():
        """GetClassName() -> OT::String"""
        return _optim.NearestPointAlgorithmImplementationResult_GetClassName()

    if _newclass:GetClassName = staticmethod(GetClassName)
    __swig_getmethods__["GetClassName"] = lambda x: GetClassName
    def getClassName(self):
        """getClassName(NearestPointAlgorithmImplementationResult self) -> OT::String"""
        return _optim.NearestPointAlgorithmImplementationResult_getClassName(self)

    def getMinimizer(self):
        """getMinimizer(NearestPointAlgorithmImplementationResult self) -> NumericalPoint"""
        return _optim.NearestPointAlgorithmImplementationResult_getMinimizer(self)

    def getIterationsNumber(self):
        """getIterationsNumber(NearestPointAlgorithmImplementationResult self) -> OT::UnsignedLong"""
        return _optim.NearestPointAlgorithmImplementationResult_getIterationsNumber(self)

    def getAbsoluteError(self):
        """getAbsoluteError(NearestPointAlgorithmImplementationResult self) -> OT::NumericalScalar"""
        return _optim.NearestPointAlgorithmImplementationResult_getAbsoluteError(self)

    def getAbsoluteErrorHistory(self):
        """getAbsoluteErrorHistory(NearestPointAlgorithmImplementationResult self) -> NumericalSample"""
        return _optim.NearestPointAlgorithmImplementationResult_getAbsoluteErrorHistory(self)

    def getRelativeError(self):
        """getRelativeError(NearestPointAlgorithmImplementationResult self) -> OT::NumericalScalar"""
        return _optim.NearestPointAlgorithmImplementationResult_getRelativeError(self)

    def getRelativeErrorHistory(self):
        """getRelativeErrorHistory(NearestPointAlgorithmImplementationResult self) -> NumericalSample"""
        return _optim.NearestPointAlgorithmImplementationResult_getRelativeErrorHistory(self)

    def getResidualError(self):
        """getResidualError(NearestPointAlgorithmImplementationResult self) -> OT::NumericalScalar"""
        return _optim.NearestPointAlgorithmImplementationResult_getResidualError(self)

    def getResidualErrorHistory(self):
        """getResidualErrorHistory(NearestPointAlgorithmImplementationResult self) -> NumericalSample"""
        return _optim.NearestPointAlgorithmImplementationResult_getResidualErrorHistory(self)

    def getConstraintError(self):
        """getConstraintError(NearestPointAlgorithmImplementationResult self) -> OT::NumericalScalar"""
        return _optim.NearestPointAlgorithmImplementationResult_getConstraintError(self)

    def getConstraintErrorHistory(self):
        """getConstraintErrorHistory(NearestPointAlgorithmImplementationResult self) -> NumericalSample"""
        return _optim.NearestPointAlgorithmImplementationResult_getConstraintErrorHistory(self)

    def getInputSample(self):
        """getInputSample(NearestPointAlgorithmImplementationResult self) -> NumericalSample"""
        return _optim.NearestPointAlgorithmImplementationResult_getInputSample(self)

    def getOutputSample(self):
        """getOutputSample(NearestPointAlgorithmImplementationResult self) -> NumericalSample"""
        return _optim.NearestPointAlgorithmImplementationResult_getOutputSample(self)

    def __repr__(self):
        """__repr__(NearestPointAlgorithmImplementationResult self) -> OT::String"""
        return _optim.NearestPointAlgorithmImplementationResult___repr__(self)

    def update(self, *args):
        """update(NearestPointAlgorithmImplementationResult self, NumericalPoint minimizer, OT::UnsignedLong iterationNumber)"""
        return _optim.NearestPointAlgorithmImplementationResult_update(self, *args)

    def store(self, *args):
        """
        store(NearestPointAlgorithmImplementationResult self, NumericalPoint inP, NumericalPoint outP, OT::NumericalScalar const absoluteError, 
            OT::NumericalScalar const relativeError, OT::NumericalScalar const residualError, 
            OT::NumericalScalar const constraintError)
        """
        return _optim.NearestPointAlgorithmImplementationResult_store(self, *args)

    def getErrorHistory(self):
        """getErrorHistory(NearestPointAlgorithmImplementationResult self) -> Graph"""
        return _optim.NearestPointAlgorithmImplementationResult_getErrorHistory(self)

    def __init__(self, *args): 
        """
        __init__(OT::NearestPointAlgorithmImplementationResult self) -> NearestPointAlgorithmImplementationResult
        __init__(OT::NearestPointAlgorithmImplementationResult self, NumericalPoint minimizer, OT::UnsignedLong const iterationsNumber, OT::NumericalScalar const absoluteError, 
            OT::NumericalScalar const relativeError, OT::NumericalScalar const residualError, 
            OT::NumericalScalar const constraintError) -> NearestPointAlgorithmImplementationResult
        __init__(OT::NearestPointAlgorithmImplementationResult self, NearestPointAlgorithmImplementationResult other) -> NearestPointAlgorithmImplementationResult
        """
        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)

def NearestPointAlgorithmImplementationResult_GetClassName():
  """NearestPointAlgorithmImplementationResult_GetClassName() -> OT::String"""
  return _optim.NearestPointAlgorithmImplementationResult_GetClassName()

class NearestPointAlgorithmImplementation(openturns.common.PersistentObject,openturns.common.Threadable):
    """Proxy of C++ OT::NearestPointAlgorithmImplementation class"""
    __swig_setmethods__ = {}
    for _s in [openturns.common.PersistentObject,openturns.common.Threadable]: __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,openturns.common.Threadable]: __swig_getmethods__.update(getattr(_s,'__swig_getmethods__',{}))
    __getattr__ = lambda self, name: _swig_getattr(self, NearestPointAlgorithmImplementation, name)
    def GetClassName():
        """GetClassName() -> OT::String"""
        return _optim.NearestPointAlgorithmImplementation_GetClassName()

    if _newclass:GetClassName = staticmethod(GetClassName)
    __swig_getmethods__["GetClassName"] = lambda x: GetClassName
    def getClassName(self):
        """getClassName(NearestPointAlgorithmImplementation self) -> OT::String"""
        return _optim.NearestPointAlgorithmImplementation_getClassName(self)

    def run(self):
        """run(NearestPointAlgorithmImplementation self)"""
        return _optim.NearestPointAlgorithmImplementation_run(self)

    def getStartingPoint(self):
        """getStartingPoint(NearestPointAlgorithmImplementation self) -> NumericalPoint"""
        return _optim.NearestPointAlgorithmImplementation_getStartingPoint(self)

    def setStartingPoint(self, *args):
        """setStartingPoint(NearestPointAlgorithmImplementation self, NumericalPoint startingPoint)"""
        return _optim.NearestPointAlgorithmImplementation_setStartingPoint(self, *args)

    def getLevelFunction(self):
        """getLevelFunction(NearestPointAlgorithmImplementation self) -> NumericalMathFunction"""
        return _optim.NearestPointAlgorithmImplementation_getLevelFunction(self)

    def setLevelFunction(self, *args):
        """setLevelFunction(NearestPointAlgorithmImplementation self, NumericalMathFunction levelFunction)"""
        return _optim.NearestPointAlgorithmImplementation_setLevelFunction(self, *args)

    def getLevelValue(self):
        """getLevelValue(NearestPointAlgorithmImplementation self) -> OT::NumericalScalar"""
        return _optim.NearestPointAlgorithmImplementation_getLevelValue(self)

    def setLevelValue(self, *args):
        """setLevelValue(NearestPointAlgorithmImplementation self, OT::NumericalScalar const levelValue)"""
        return _optim.NearestPointAlgorithmImplementation_setLevelValue(self, *args)

    def getResult(self):
        """getResult(NearestPointAlgorithmImplementation self) -> NearestPointAlgorithmImplementationResult"""
        return _optim.NearestPointAlgorithmImplementation_getResult(self)

    def setResult(self, *args):
        """setResult(NearestPointAlgorithmImplementation self, NearestPointAlgorithmImplementationResult result)"""
        return _optim.NearestPointAlgorithmImplementation_setResult(self, *args)

    def getMaximumIterationsNumber(self):
        """getMaximumIterationsNumber(NearestPointAlgorithmImplementation self) -> OT::UnsignedLong"""
        return _optim.NearestPointAlgorithmImplementation_getMaximumIterationsNumber(self)

    def setMaximumIterationsNumber(self, *args):
        """setMaximumIterationsNumber(NearestPointAlgorithmImplementation self, OT::UnsignedLong const maximumIterationsNumber)"""
        return _optim.NearestPointAlgorithmImplementation_setMaximumIterationsNumber(self, *args)

    def getMaximumAbsoluteError(self):
        """getMaximumAbsoluteError(NearestPointAlgorithmImplementation self) -> OT::NumericalScalar"""
        return _optim.NearestPointAlgorithmImplementation_getMaximumAbsoluteError(self)

    def setMaximumAbsoluteError(self, *args):
        """setMaximumAbsoluteError(NearestPointAlgorithmImplementation self, OT::NumericalScalar const maximumAbsoluteError)"""
        return _optim.NearestPointAlgorithmImplementation_setMaximumAbsoluteError(self, *args)

    def getMaximumRelativeError(self):
        """getMaximumRelativeError(NearestPointAlgorithmImplementation self) -> OT::NumericalScalar"""
        return _optim.NearestPointAlgorithmImplementation_getMaximumRelativeError(self)

    def setMaximumRelativeError(self, *args):
        """setMaximumRelativeError(NearestPointAlgorithmImplementation self, OT::NumericalScalar const maximumRelativeError)"""
        return _optim.NearestPointAlgorithmImplementation_setMaximumRelativeError(self, *args)

    def getMaximumResidualError(self):
        """getMaximumResidualError(NearestPointAlgorithmImplementation self) -> OT::NumericalScalar"""
        return _optim.NearestPointAlgorithmImplementation_getMaximumResidualError(self)

    def setMaximumResidualError(self, *args):
        """setMaximumResidualError(NearestPointAlgorithmImplementation self, OT::NumericalScalar const maximumResidualError)"""
        return _optim.NearestPointAlgorithmImplementation_setMaximumResidualError(self, *args)

    def getMaximumConstraintError(self):
        """getMaximumConstraintError(NearestPointAlgorithmImplementation self) -> OT::NumericalScalar"""
        return _optim.NearestPointAlgorithmImplementation_getMaximumConstraintError(self)

    def setMaximumConstraintError(self, *args):
        """setMaximumConstraintError(NearestPointAlgorithmImplementation self, OT::NumericalScalar const maximumConstraintError)"""
        return _optim.NearestPointAlgorithmImplementation_setMaximumConstraintError(self, *args)

    def __repr__(self):
        """__repr__(NearestPointAlgorithmImplementation self) -> OT::String"""
        return _optim.NearestPointAlgorithmImplementation___repr__(self)

    def getVerbose(self):
        """getVerbose(NearestPointAlgorithmImplementation self) -> OT::Bool"""
        return _optim.NearestPointAlgorithmImplementation_getVerbose(self)

    def setVerbose(self, *args):
        """setVerbose(NearestPointAlgorithmImplementation self, OT::Bool const verbose)"""
        return _optim.NearestPointAlgorithmImplementation_setVerbose(self, *args)

    def __init__(self, *args): 
        """
        __init__(OT::NearestPointAlgorithmImplementation self) -> NearestPointAlgorithmImplementation
        __init__(OT::NearestPointAlgorithmImplementation self, NumericalMathFunction levelFunction, OT::Bool const verbose=False) -> NearestPointAlgorithmImplementation
        __init__(OT::NearestPointAlgorithmImplementation self, NumericalMathFunction levelFunction) -> NearestPointAlgorithmImplementation
        __init__(OT::NearestPointAlgorithmImplementation self, NearestPointAlgorithmImplementation other) -> NearestPointAlgorithmImplementation
        """
        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)

def NearestPointAlgorithmImplementation_GetClassName():
  """NearestPointAlgorithmImplementation_GetClassName() -> OT::String"""
  return _optim.NearestPointAlgorithmImplementation_GetClassName()

class NearestPointAlgorithmImplementationTypedInterfaceObject(openturns.common.InterfaceObject):
    """Proxy of C++ OT::TypedInterfaceObject<(OT::NearestPointAlgorithmImplementation)> class"""
    __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): 
        """
        __init__(OT::TypedInterfaceObject<(OT::NearestPointAlgorithmImplementation)> self) -> NearestPointAlgorithmImplementationTypedInterfaceObject
        __init__(OT::TypedInterfaceObject<(OT::NearestPointAlgorithmImplementation)> self, NearestPointAlgorithmImplementationPointer impl) -> NearestPointAlgorithmImplementationTypedInterfaceObject
        """
        this = _optim.new_NearestPointAlgorithmImplementationTypedInterfaceObject(*args)
        try: self.this.append(this)
        except: self.this = this
    def getImplementation(self, *args):
        """
        getImplementation(NearestPointAlgorithmImplementationTypedInterfaceObject self) -> NearestPointAlgorithmImplementationPointer
        getImplementation(NearestPointAlgorithmImplementationTypedInterfaceObject self) -> NearestPointAlgorithmImplementationPointer
        """
        return _optim.NearestPointAlgorithmImplementationTypedInterfaceObject_getImplementation(self, *args)

    def getImplementationAsPersistentObject(self):
        """getImplementationAsPersistentObject(NearestPointAlgorithmImplementationTypedInterfaceObject self) -> PersistentObjectPointer"""
        return _optim.NearestPointAlgorithmImplementationTypedInterfaceObject_getImplementationAsPersistentObject(self)

    def setImplementationAsPersistentObject(self, *args):
        """setImplementationAsPersistentObject(NearestPointAlgorithmImplementationTypedInterfaceObject self, PersistentObjectPointer obj)"""
        return _optim.NearestPointAlgorithmImplementationTypedInterfaceObject_setImplementationAsPersistentObject(self, *args)

    def swap(self, *args):
        """swap(NearestPointAlgorithmImplementationTypedInterfaceObject self, NearestPointAlgorithmImplementationTypedInterfaceObject other)"""
        return _optim.NearestPointAlgorithmImplementationTypedInterfaceObject_swap(self, *args)

    def setName(self, *args):
        """setName(NearestPointAlgorithmImplementationTypedInterfaceObject self, OT::String const & name)"""
        return _optim.NearestPointAlgorithmImplementationTypedInterfaceObject_setName(self, *args)

    def getName(self):
        """getName(NearestPointAlgorithmImplementationTypedInterfaceObject self) -> OT::String"""
        return _optim.NearestPointAlgorithmImplementationTypedInterfaceObject_getName(self)

    def __eq__(self, *args):
        """__eq__(NearestPointAlgorithmImplementationTypedInterfaceObject self, NearestPointAlgorithmImplementationTypedInterfaceObject other) -> OT::Bool"""
        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):
    """Proxy of C++ OT::NearestPointAlgorithm class"""
    __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():
        """GetClassName() -> OT::String"""
        return _optim.NearestPointAlgorithm_GetClassName()

    if _newclass:GetClassName = staticmethod(GetClassName)
    __swig_getmethods__["GetClassName"] = lambda x: GetClassName
    def getClassName(self):
        """getClassName(NearestPointAlgorithm self) -> OT::String"""
        return _optim.NearestPointAlgorithm_getClassName(self)

    def run(self):
        """run(NearestPointAlgorithm self)"""
        return _optim.NearestPointAlgorithm_run(self)

    def getStartingPoint(self):
        """getStartingPoint(NearestPointAlgorithm self) -> NumericalPoint"""
        return _optim.NearestPointAlgorithm_getStartingPoint(self)

    def setStartingPoint(self, *args):
        """setStartingPoint(NearestPointAlgorithm self, NumericalPoint startingPoint)"""
        return _optim.NearestPointAlgorithm_setStartingPoint(self, *args)

    def getLevelFunction(self):
        """getLevelFunction(NearestPointAlgorithm self) -> NumericalMathFunction"""
        return _optim.NearestPointAlgorithm_getLevelFunction(self)

    def setLevelFunction(self, *args):
        """setLevelFunction(NearestPointAlgorithm self, NumericalMathFunction levelFunction)"""
        return _optim.NearestPointAlgorithm_setLevelFunction(self, *args)

    def getLevelValue(self):
        """getLevelValue(NearestPointAlgorithm self) -> OT::NumericalScalar"""
        return _optim.NearestPointAlgorithm_getLevelValue(self)

    def setLevelValue(self, *args):
        """setLevelValue(NearestPointAlgorithm self, OT::NumericalScalar const levelValue)"""
        return _optim.NearestPointAlgorithm_setLevelValue(self, *args)

    def getResult(self):
        """getResult(NearestPointAlgorithm self) -> NearestPointAlgorithmImplementationResult"""
        return _optim.NearestPointAlgorithm_getResult(self)

    def setResult(self, *args):
        """setResult(NearestPointAlgorithm self, NearestPointAlgorithmImplementationResult result)"""
        return _optim.NearestPointAlgorithm_setResult(self, *args)

    def getMaximumIterationsNumber(self):
        """getMaximumIterationsNumber(NearestPointAlgorithm self) -> OT::UnsignedLong"""
        return _optim.NearestPointAlgorithm_getMaximumIterationsNumber(self)

    def setMaximumIterationsNumber(self, *args):
        """setMaximumIterationsNumber(NearestPointAlgorithm self, OT::UnsignedLong const maximumIterationsNumber)"""
        return _optim.NearestPointAlgorithm_setMaximumIterationsNumber(self, *args)

    def getMaximumAbsoluteError(self):
        """getMaximumAbsoluteError(NearestPointAlgorithm self) -> OT::NumericalScalar"""
        return _optim.NearestPointAlgorithm_getMaximumAbsoluteError(self)

    def setMaximumAbsoluteError(self, *args):
        """setMaximumAbsoluteError(NearestPointAlgorithm self, OT::NumericalScalar const maximumAbsoluteError)"""
        return _optim.NearestPointAlgorithm_setMaximumAbsoluteError(self, *args)

    def getMaximumRelativeError(self):
        """getMaximumRelativeError(NearestPointAlgorithm self) -> OT::NumericalScalar"""
        return _optim.NearestPointAlgorithm_getMaximumRelativeError(self)

    def setMaximumRelativeError(self, *args):
        """setMaximumRelativeError(NearestPointAlgorithm self, OT::NumericalScalar const maximumRelativeError)"""
        return _optim.NearestPointAlgorithm_setMaximumRelativeError(self, *args)

    def getMaximumResidualError(self):
        """getMaximumResidualError(NearestPointAlgorithm self) -> OT::NumericalScalar"""
        return _optim.NearestPointAlgorithm_getMaximumResidualError(self)

    def setMaximumResidualError(self, *args):
        """setMaximumResidualError(NearestPointAlgorithm self, OT::NumericalScalar const maximumResidualError)"""
        return _optim.NearestPointAlgorithm_setMaximumResidualError(self, *args)

    def getMaximumConstraintError(self):
        """getMaximumConstraintError(NearestPointAlgorithm self) -> OT::NumericalScalar"""
        return _optim.NearestPointAlgorithm_getMaximumConstraintError(self)

    def setMaximumConstraintError(self, *args):
        """setMaximumConstraintError(NearestPointAlgorithm self, OT::NumericalScalar const maximumConstraintError)"""
        return _optim.NearestPointAlgorithm_setMaximumConstraintError(self, *args)

    def __repr__(self):
        """__repr__(NearestPointAlgorithm self) -> OT::String"""
        return _optim.NearestPointAlgorithm___repr__(self)

    def __str__(self, offset=""):
        """
        __str__(NearestPointAlgorithm self, OT::String const & offset="") -> OT::String
        __str__(NearestPointAlgorithm self) -> OT::String
        """
        return _optim.NearestPointAlgorithm___str__(self, offset)

    def getVerbose(self):
        """getVerbose(NearestPointAlgorithm self) -> OT::Bool"""
        return _optim.NearestPointAlgorithm_getVerbose(self)

    def setVerbose(self, *args):
        """setVerbose(NearestPointAlgorithm self, OT::Bool const verbose)"""
        return _optim.NearestPointAlgorithm_setVerbose(self, *args)

    def __init__(self, *args): 
        """
        __init__(OT::NearestPointAlgorithm self) -> NearestPointAlgorithm
        __init__(OT::NearestPointAlgorithm self, NearestPointAlgorithmImplementation implementation) -> NearestPointAlgorithm
        __init__(OT::NearestPointAlgorithm self, NearestPointAlgorithmImplementationPointer p_implementation) -> NearestPointAlgorithm
        __init__(OT::NearestPointAlgorithm self, NumericalMathFunction levelFunction) -> NearestPointAlgorithm
        __init__(OT::NearestPointAlgorithm self, NearestPointAlgorithm other) -> NearestPointAlgorithm
        """
        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)

def NearestPointAlgorithm_GetClassName():
  """NearestPointAlgorithm_GetClassName() -> OT::String"""
  return _optim.NearestPointAlgorithm_GetClassName()

class NearestPointCheckerResult(openturns.common.PersistentObject):
    """Proxy of C++ OT::NearestPointCheckerResult class"""
    __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():
        """GetClassName() -> OT::String"""
        return _optim.NearestPointCheckerResult_GetClassName()

    if _newclass:GetClassName = staticmethod(GetClassName)
    __swig_getmethods__["GetClassName"] = lambda x: GetClassName
    def getClassName(self):
        """getClassName(NearestPointCheckerResult self) -> OT::String"""
        return _optim.NearestPointCheckerResult_getClassName(self)

    def getVerifyingConstraintPoints(self):
        """getVerifyingConstraintPoints(NearestPointCheckerResult self) -> NumericalSample"""
        return _optim.NearestPointCheckerResult_getVerifyingConstraintPoints(self)

    def getVerifyingConstraintValues(self):
        """getVerifyingConstraintValues(NearestPointCheckerResult self) -> NumericalSample"""
        return _optim.NearestPointCheckerResult_getVerifyingConstraintValues(self)

    def getViolatingConstraintPoints(self):
        """getViolatingConstraintPoints(NearestPointCheckerResult self) -> NumericalSample"""
        return _optim.NearestPointCheckerResult_getViolatingConstraintPoints(self)

    def getViolatingConstraintValues(self):
        """getViolatingConstraintValues(NearestPointCheckerResult self) -> NumericalSample"""
        return _optim.NearestPointCheckerResult_getViolatingConstraintValues(self)

    def setVerifyingConstraintPoints(self, *args):
        """setVerifyingConstraintPoints(NearestPointCheckerResult self, NumericalSample verifyingConstraintPoints)"""
        return _optim.NearestPointCheckerResult_setVerifyingConstraintPoints(self, *args)

    def setVerifyingConstraintValues(self, *args):
        """setVerifyingConstraintValues(NearestPointCheckerResult self, NumericalSample verifyingConstraintValues)"""
        return _optim.NearestPointCheckerResult_setVerifyingConstraintValues(self, *args)

    def setViolatingConstraintPoints(self, *args):
        """setViolatingConstraintPoints(NearestPointCheckerResult self, NumericalSample violatingConstraintPoints)"""
        return _optim.NearestPointCheckerResult_setViolatingConstraintPoints(self, *args)

    def setViolatingConstraintValues(self, *args):
        """setViolatingConstraintValues(NearestPointCheckerResult self, NumericalSample violatingConstraintValues)"""
        return _optim.NearestPointCheckerResult_setViolatingConstraintValues(self, *args)

    def __repr__(self):
        """__repr__(NearestPointCheckerResult self) -> OT::String"""
        return _optim.NearestPointCheckerResult___repr__(self)

    def __init__(self, *args): 
        """
        __init__(OT::NearestPointCheckerResult self) -> NearestPointCheckerResult
        __init__(OT::NearestPointCheckerResult self, NumericalSample verifyingConstraintPoints, NumericalSample verifyingConstraintValues, 
            NumericalSample violatingConstraintPoints, NumericalSample violatingConstraintValues) -> NearestPointCheckerResult
        __init__(OT::NearestPointCheckerResult self, NearestPointCheckerResult other) -> NearestPointCheckerResult
        """
        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)

def NearestPointCheckerResult_GetClassName():
  """NearestPointCheckerResult_GetClassName() -> OT::String"""
  return _optim.NearestPointCheckerResult_GetClassName()

class NearestPointChecker(openturns.common.PersistentObject,openturns.common.Threadable):
    """Proxy of C++ OT::NearestPointChecker class"""
    __swig_setmethods__ = {}
    for _s in [openturns.common.PersistentObject,openturns.common.Threadable]: __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,openturns.common.Threadable]: __swig_getmethods__.update(getattr(_s,'__swig_getmethods__',{}))
    __getattr__ = lambda self, name: _swig_getattr(self, NearestPointChecker, name)
    def GetClassName():
        """GetClassName() -> OT::String"""
        return _optim.NearestPointChecker_GetClassName()

    if _newclass:GetClassName = staticmethod(GetClassName)
    __swig_getmethods__["GetClassName"] = lambda x: GetClassName
    def getClassName(self):
        """getClassName(NearestPointChecker self) -> OT::String"""
        return _optim.NearestPointChecker_getClassName(self)

    def setLevelFunction(self, *args):
        """setLevelFunction(NearestPointChecker self, NumericalMathFunction levelFunction)"""
        return _optim.NearestPointChecker_setLevelFunction(self, *args)

    def getLevelFunction(self):
        """getLevelFunction(NearestPointChecker self) -> NumericalMathFunction"""
        return _optim.NearestPointChecker_getLevelFunction(self)

    def setResult(self, *args):
        """setResult(NearestPointChecker self, NearestPointCheckerResult result)"""
        return _optim.NearestPointChecker_setResult(self, *args)

    def getResult(self):
        """getResult(NearestPointChecker self) -> NearestPointCheckerResult"""
        return _optim.NearestPointChecker_getResult(self)

    def setComparisonOperator(self, *args):
        """setComparisonOperator(NearestPointChecker self, ComparisonOperator comparisonOperator)"""
        return _optim.NearestPointChecker_setComparisonOperator(self, *args)

    def getComparisonOperator(self):
        """getComparisonOperator(NearestPointChecker self) -> ComparisonOperator"""
        return _optim.NearestPointChecker_getComparisonOperator(self)

    def setThreshold(self, *args):
        """setThreshold(NearestPointChecker self, OT::NumericalScalar const threshold)"""
        return _optim.NearestPointChecker_setThreshold(self, *args)

    def getThreshold(self):
        """getThreshold(NearestPointChecker self) -> OT::NumericalScalar"""
        return _optim.NearestPointChecker_getThreshold(self)

    def setSample(self, *args):
        """setSample(NearestPointChecker self, NumericalSample sample)"""
        return _optim.NearestPointChecker_setSample(self, *args)

    def getSample(self):
        """getSample(NearestPointChecker self) -> NumericalSample"""
        return _optim.NearestPointChecker_getSample(self)

    def run(self):
        """run(NearestPointChecker self)"""
        return _optim.NearestPointChecker_run(self)

    def __repr__(self):
        """__repr__(NearestPointChecker self) -> OT::String"""
        return _optim.NearestPointChecker___repr__(self)

    def __init__(self, *args): 
        """
        __init__(OT::NearestPointChecker self, NumericalMathFunction levelFunction, ComparisonOperator comparisonOperator, OT::NumericalScalar const threshold, 
            NumericalSample sample) -> NearestPointChecker
        __init__(OT::NearestPointChecker self, NearestPointChecker other) -> NearestPointChecker
        """
        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)

def NearestPointChecker_GetClassName():
  """NearestPointChecker_GetClassName() -> OT::String"""
  return _optim.NearestPointChecker_GetClassName()

class AbdoRackwitzSpecificParameters(openturns.common.PersistentObject):
    """Proxy of C++ OT::AbdoRackwitzSpecificParameters class"""
    __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():
        """GetClassName() -> OT::String"""
        return _optim.AbdoRackwitzSpecificParameters_GetClassName()

    if _newclass:GetClassName = staticmethod(GetClassName)
    __swig_getmethods__["GetClassName"] = lambda x: GetClassName
    def getClassName(self):
        """getClassName(AbdoRackwitzSpecificParameters self) -> OT::String"""
        return _optim.AbdoRackwitzSpecificParameters_getClassName(self)

    def getTau(self):
        """getTau(AbdoRackwitzSpecificParameters self) -> OT::NumericalScalar"""
        return _optim.AbdoRackwitzSpecificParameters_getTau(self)

    def setTau(self, *args):
        """setTau(AbdoRackwitzSpecificParameters self, OT::NumericalScalar const tau)"""
        return _optim.AbdoRackwitzSpecificParameters_setTau(self, *args)

    def getOmega(self):
        """getOmega(AbdoRackwitzSpecificParameters self) -> OT::NumericalScalar"""
        return _optim.AbdoRackwitzSpecificParameters_getOmega(self)

    def setOmega(self, *args):
        """setOmega(AbdoRackwitzSpecificParameters self, OT::NumericalScalar const tau)"""
        return _optim.AbdoRackwitzSpecificParameters_setOmega(self, *args)

    def getSmooth(self):
        """getSmooth(AbdoRackwitzSpecificParameters self) -> OT::NumericalScalar"""
        return _optim.AbdoRackwitzSpecificParameters_getSmooth(self)

    def setSmooth(self, *args):
        """setSmooth(AbdoRackwitzSpecificParameters self, OT::NumericalScalar const tau)"""
        return _optim.AbdoRackwitzSpecificParameters_setSmooth(self, *args)

    def __repr__(self):
        """__repr__(AbdoRackwitzSpecificParameters self) -> OT::String"""
        return _optim.AbdoRackwitzSpecificParameters___repr__(self)

    def __init__(self, *args): 
        """
        __init__(OT::AbdoRackwitzSpecificParameters self) -> AbdoRackwitzSpecificParameters
        __init__(OT::AbdoRackwitzSpecificParameters self, OT::NumericalScalar const tau, OT::NumericalScalar const omega, OT::NumericalScalar const smooth) -> AbdoRackwitzSpecificParameters
        __init__(OT::AbdoRackwitzSpecificParameters self, AbdoRackwitzSpecificParameters other) -> AbdoRackwitzSpecificParameters
        """
        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)

def AbdoRackwitzSpecificParameters_GetClassName():
  """AbdoRackwitzSpecificParameters_GetClassName() -> OT::String"""
  return _optim.AbdoRackwitzSpecificParameters_GetClassName()

class AbdoRackwitz(NearestPointAlgorithmImplementation):
    """Proxy of C++ OT::AbdoRackwitz class"""
    __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():
        """GetClassName() -> OT::String"""
        return _optim.AbdoRackwitz_GetClassName()

    if _newclass:GetClassName = staticmethod(GetClassName)
    __swig_getmethods__["GetClassName"] = lambda x: GetClassName
    def getClassName(self):
        """getClassName(AbdoRackwitz self) -> OT::String"""
        return _optim.AbdoRackwitz_getClassName(self)

    def run(self):
        """run(AbdoRackwitz self)"""
        return _optim.AbdoRackwitz_run(self)

    def getSpecificParameters(self):
        """getSpecificParameters(AbdoRackwitz self) -> AbdoRackwitzSpecificParameters"""
        return _optim.AbdoRackwitz_getSpecificParameters(self)

    def setSpecificParameters(self, *args):
        """setSpecificParameters(AbdoRackwitz self, AbdoRackwitzSpecificParameters specificParameters)"""
        return _optim.AbdoRackwitz_setSpecificParameters(self, *args)

    def __repr__(self):
        """__repr__(AbdoRackwitz self) -> OT::String"""
        return _optim.AbdoRackwitz___repr__(self)

    def __init__(self, *args): 
        """
        __init__(OT::AbdoRackwitz self) -> AbdoRackwitz
        __init__(OT::AbdoRackwitz self, AbdoRackwitzSpecificParameters specificParameters, NumericalMathFunction levelFunction) -> AbdoRackwitz
        __init__(OT::AbdoRackwitz self, AbdoRackwitz other) -> AbdoRackwitz
        """
        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)

def AbdoRackwitz_GetClassName():
  """AbdoRackwitz_GetClassName() -> OT::String"""
  return _optim.AbdoRackwitz_GetClassName()

class CobylaSpecificParameters(openturns.common.PersistentObject):
    """Proxy of C++ OT::CobylaSpecificParameters class"""
    __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():
        """GetClassName() -> OT::String"""
        return _optim.CobylaSpecificParameters_GetClassName()

    if _newclass:GetClassName = staticmethod(GetClassName)
    __swig_getmethods__["GetClassName"] = lambda x: GetClassName
    def getClassName(self):
        """getClassName(CobylaSpecificParameters self) -> OT::String"""
        return _optim.CobylaSpecificParameters_getClassName(self)

    def getRhoBeg(self):
        """getRhoBeg(CobylaSpecificParameters self) -> OT::NumericalScalar"""
        return _optim.CobylaSpecificParameters_getRhoBeg(self)

    def setRhoBeg(self, *args):
        """setRhoBeg(CobylaSpecificParameters self, OT::NumericalScalar const rhoBeg)"""
        return _optim.CobylaSpecificParameters_setRhoBeg(self, *args)

    def __repr__(self):
        """__repr__(CobylaSpecificParameters self) -> OT::String"""
        return _optim.CobylaSpecificParameters___repr__(self)

    def __init__(self, *args): 
        """
        __init__(OT::CobylaSpecificParameters self) -> CobylaSpecificParameters
        __init__(OT::CobylaSpecificParameters self, OT::NumericalScalar const rhoBeg) -> CobylaSpecificParameters
        __init__(OT::CobylaSpecificParameters self, CobylaSpecificParameters other) -> CobylaSpecificParameters
        """
        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)

def CobylaSpecificParameters_GetClassName():
  """CobylaSpecificParameters_GetClassName() -> OT::String"""
  return _optim.CobylaSpecificParameters_GetClassName()

class Cobyla(NearestPointAlgorithmImplementation):
    """Proxy of C++ OT::Cobyla class"""
    __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():
        """GetClassName() -> OT::String"""
        return _optim.Cobyla_GetClassName()

    if _newclass:GetClassName = staticmethod(GetClassName)
    __swig_getmethods__["GetClassName"] = lambda x: GetClassName
    def getClassName(self):
        """getClassName(Cobyla self) -> OT::String"""
        return _optim.Cobyla_getClassName(self)

    def run(self):
        """run(Cobyla self)"""
        return _optim.Cobyla_run(self)

    def getSpecificParameters(self):
        """getSpecificParameters(Cobyla self) -> CobylaSpecificParameters"""
        return _optim.Cobyla_getSpecificParameters(self)

    def setSpecificParameters(self, *args):
        """setSpecificParameters(Cobyla self, CobylaSpecificParameters specificParameters)"""
        return _optim.Cobyla_setSpecificParameters(self, *args)

    def __repr__(self):
        """__repr__(Cobyla self) -> OT::String"""
        return _optim.Cobyla___repr__(self)

    def __init__(self, *args): 
        """
        __init__(OT::Cobyla self) -> Cobyla
        __init__(OT::Cobyla self, NumericalMathFunction levelFunction, OT::Bool const verbose=False) -> Cobyla
        __init__(OT::Cobyla self, NumericalMathFunction levelFunction) -> Cobyla
        __init__(OT::Cobyla self, CobylaSpecificParameters specificParameters, NumericalMathFunction levelFunction, 
            OT::Bool const verbose=False) -> Cobyla
        __init__(OT::Cobyla self, CobylaSpecificParameters specificParameters, NumericalMathFunction levelFunction) -> Cobyla
        __init__(OT::Cobyla self, Cobyla other) -> Cobyla
        """
        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)

def Cobyla_GetClassName():
  """Cobyla_GetClassName() -> OT::String"""
  return _optim.Cobyla_GetClassName()

class TNCSpecificParameters(openturns.common.PersistentObject):
    """Proxy of C++ OT::TNCSpecificParameters class"""
    __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():
        """GetClassName() -> OT::String"""
        return _optim.TNCSpecificParameters_GetClassName()

    if _newclass:GetClassName = staticmethod(GetClassName)
    __swig_getmethods__["GetClassName"] = lambda x: GetClassName
    def getClassName(self):
        """getClassName(TNCSpecificParameters self) -> OT::String"""
        return _optim.TNCSpecificParameters_getClassName(self)

    def getScale(self):
        """getScale(TNCSpecificParameters self) -> NumericalPoint"""
        return _optim.TNCSpecificParameters_getScale(self)

    def setScale(self, *args):
        """setScale(TNCSpecificParameters self, NumericalPoint scale)"""
        return _optim.TNCSpecificParameters_setScale(self, *args)

    def getOffset(self):
        """getOffset(TNCSpecificParameters self) -> NumericalPoint"""
        return _optim.TNCSpecificParameters_getOffset(self)

    def setOffset(self, *args):
        """setOffset(TNCSpecificParameters self, NumericalPoint offset)"""
        return _optim.TNCSpecificParameters_setOffset(self, *args)

    def getMaxCGit(self):
        """getMaxCGit(TNCSpecificParameters self) -> OT::UnsignedLong"""
        return _optim.TNCSpecificParameters_getMaxCGit(self)

    def setMaxCGit(self, *args):
        """setMaxCGit(TNCSpecificParameters self, OT::UnsignedLong const maxCGit)"""
        return _optim.TNCSpecificParameters_setMaxCGit(self, *args)

    def getEta(self):
        """getEta(TNCSpecificParameters self) -> OT::NumericalScalar"""
        return _optim.TNCSpecificParameters_getEta(self)

    def setEta(self, *args):
        """setEta(TNCSpecificParameters self, OT::NumericalScalar const eta)"""
        return _optim.TNCSpecificParameters_setEta(self, *args)

    def getStepmx(self):
        """getStepmx(TNCSpecificParameters self) -> OT::NumericalScalar"""
        return _optim.TNCSpecificParameters_getStepmx(self)

    def setStepmx(self, *args):
        """setStepmx(TNCSpecificParameters self, OT::NumericalScalar const stepmx)"""
        return _optim.TNCSpecificParameters_setStepmx(self, *args)

    def getAccuracy(self):
        """getAccuracy(TNCSpecificParameters self) -> OT::NumericalScalar"""
        return _optim.TNCSpecificParameters_getAccuracy(self)

    def setAccuracy(self, *args):
        """setAccuracy(TNCSpecificParameters self, OT::NumericalScalar const accuracy)"""
        return _optim.TNCSpecificParameters_setAccuracy(self, *args)

    def getFmin(self):
        """getFmin(TNCSpecificParameters self) -> OT::NumericalScalar"""
        return _optim.TNCSpecificParameters_getFmin(self)

    def setFmin(self, *args):
        """setFmin(TNCSpecificParameters self, OT::NumericalScalar const fmin)"""
        return _optim.TNCSpecificParameters_setFmin(self, *args)

    def getRescale(self):
        """getRescale(TNCSpecificParameters self) -> OT::NumericalScalar"""
        return _optim.TNCSpecificParameters_getRescale(self)

    def setRescale(self, *args):
        """setRescale(TNCSpecificParameters self, OT::NumericalScalar const rescale)"""
        return _optim.TNCSpecificParameters_setRescale(self, *args)

    def __repr__(self):
        """__repr__(TNCSpecificParameters self) -> OT::String"""
        return _optim.TNCSpecificParameters___repr__(self)

    def __init__(self, *args): 
        """
        __init__(OT::TNCSpecificParameters self) -> TNCSpecificParameters
        __init__(OT::TNCSpecificParameters self, NumericalPoint scale, NumericalPoint offset, OT::UnsignedLong const maxCGit, OT::NumericalScalar const eta, 
            OT::NumericalScalar const stepmx, OT::NumericalScalar const accuracy, 
            OT::NumericalScalar const fmin, OT::NumericalScalar const rescale) -> TNCSpecificParameters
        __init__(OT::TNCSpecificParameters self, TNCSpecificParameters other) -> TNCSpecificParameters
        """
        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)

def TNCSpecificParameters_GetClassName():
  """TNCSpecificParameters_GetClassName() -> OT::String"""
  return _optim.TNCSpecificParameters_GetClassName()

class TNC(BoundConstrainedAlgorithmImplementation):
    """Proxy of C++ OT::TNC class"""
    __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():
        """GetClassName() -> OT::String"""
        return _optim.TNC_GetClassName()

    if _newclass:GetClassName = staticmethod(GetClassName)
    __swig_getmethods__["GetClassName"] = lambda x: GetClassName
    def getClassName(self):
        """getClassName(TNC self) -> OT::String"""
        return _optim.TNC_getClassName(self)

    def run(self):
        """run(TNC self)"""
        return _optim.TNC_run(self)

    def getSpecificParameters(self):
        """getSpecificParameters(TNC self) -> TNCSpecificParameters"""
        return _optim.TNC_getSpecificParameters(self)

    def setSpecificParameters(self, *args):
        """setSpecificParameters(TNC self, TNCSpecificParameters specificParameters)"""
        return _optim.TNC_setSpecificParameters(self, *args)

    def __repr__(self):
        """__repr__(TNC self) -> OT::String"""
        return _optim.TNC___repr__(self)

    def __init__(self, *args): 
        """
        __init__(OT::TNC self) -> TNC
        __init__(OT::TNC self, NumericalMathFunction objectiveFunction, OT::Bool const verbose=False) -> TNC
        __init__(OT::TNC self, NumericalMathFunction objectiveFunction) -> TNC
        __init__(OT::TNC self, TNCSpecificParameters parameters, NumericalMathFunction objectiveFunction, Interval boundConstraints, 
            NumericalPoint startingPoint, OT::BoundConstrainedAlgorithmImplementation::OptimizationProblem const optimization=Result::MINIMIZATION, 
            OT::Bool const verbose=False) -> TNC
        __init__(OT::TNC self, TNCSpecificParameters parameters, NumericalMathFunction objectiveFunction, Interval boundConstraints, 
            NumericalPoint startingPoint, OT::BoundConstrainedAlgorithmImplementation::OptimizationProblem const optimization=Result::MINIMIZATION) -> TNC
        __init__(OT::TNC self, TNCSpecificParameters parameters, NumericalMathFunction objectiveFunction, Interval boundConstraints, 
            NumericalPoint startingPoint) -> TNC
        __init__(OT::TNC self, TNC other) -> TNC
        """
        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)

def TNC_GetClassName():
  """TNC_GetClassName() -> OT::String"""
  return _optim.TNC_GetClassName()

class SQPSpecificParameters(openturns.common.PersistentObject):
    """Proxy of C++ OT::SQPSpecificParameters class"""
    __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():
        """GetClassName() -> OT::String"""
        return _optim.SQPSpecificParameters_GetClassName()

    if _newclass:GetClassName = staticmethod(GetClassName)
    __swig_getmethods__["GetClassName"] = lambda x: GetClassName
    def getClassName(self):
        """getClassName(SQPSpecificParameters self) -> OT::String"""
        return _optim.SQPSpecificParameters_getClassName(self)

    def getTau(self):
        """getTau(SQPSpecificParameters self) -> OT::NumericalScalar"""
        return _optim.SQPSpecificParameters_getTau(self)

    def setTau(self, *args):
        """setTau(SQPSpecificParameters self, OT::NumericalScalar const tau)"""
        return _optim.SQPSpecificParameters_setTau(self, *args)

    def getOmega(self):
        """getOmega(SQPSpecificParameters self) -> OT::NumericalScalar"""
        return _optim.SQPSpecificParameters_getOmega(self)

    def setOmega(self, *args):
        """setOmega(SQPSpecificParameters self, OT::NumericalScalar const tau)"""
        return _optim.SQPSpecificParameters_setOmega(self, *args)

    def getSmooth(self):
        """getSmooth(SQPSpecificParameters self) -> OT::NumericalScalar"""
        return _optim.SQPSpecificParameters_getSmooth(self)

    def setSmooth(self, *args):
        """setSmooth(SQPSpecificParameters self, OT::NumericalScalar const tau)"""
        return _optim.SQPSpecificParameters_setSmooth(self, *args)

    def __repr__(self):
        """__repr__(SQPSpecificParameters self) -> OT::String"""
        return _optim.SQPSpecificParameters___repr__(self)

    def __init__(self, *args): 
        """
        __init__(OT::SQPSpecificParameters self) -> SQPSpecificParameters
        __init__(OT::SQPSpecificParameters self, OT::NumericalScalar const tau, OT::NumericalScalar const omega, OT::NumericalScalar const smooth) -> SQPSpecificParameters
        __init__(OT::SQPSpecificParameters self, SQPSpecificParameters other) -> SQPSpecificParameters
        """
        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)

def SQPSpecificParameters_GetClassName():
  """SQPSpecificParameters_GetClassName() -> OT::String"""
  return _optim.SQPSpecificParameters_GetClassName()

class SQP(NearestPointAlgorithmImplementation):
    """Proxy of C++ OT::SQP class"""
    __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():
        """GetClassName() -> OT::String"""
        return _optim.SQP_GetClassName()

    if _newclass:GetClassName = staticmethod(GetClassName)
    __swig_getmethods__["GetClassName"] = lambda x: GetClassName
    def getClassName(self):
        """getClassName(SQP self) -> OT::String"""
        return _optim.SQP_getClassName(self)

    def run(self):
        """run(SQP self)"""
        return _optim.SQP_run(self)

    def getSpecificParameters(self):
        """getSpecificParameters(SQP self) -> SQPSpecificParameters"""
        return _optim.SQP_getSpecificParameters(self)

    def setSpecificParameters(self, *args):
        """setSpecificParameters(SQP self, SQPSpecificParameters specificParameters)"""
        return _optim.SQP_setSpecificParameters(self, *args)

    def __repr__(self):
        """__repr__(SQP self) -> OT::String"""
        return _optim.SQP___repr__(self)

    def __init__(self, *args): 
        """
        __init__(OT::SQP self) -> SQP
        __init__(OT::SQP self, SQPSpecificParameters specificParameters, NumericalMathFunction levelFunction, OT::Bool const verbose=False) -> SQP
        __init__(OT::SQP self, SQPSpecificParameters specificParameters, NumericalMathFunction levelFunction) -> SQP
        __init__(OT::SQP self, SQP other) -> SQP
        """
        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)

def SQP_GetClassName():
  """SQP_GetClassName() -> OT::String"""
  return _optim.SQP_GetClassName()

class NearestPointAlgorithmImplementationPointer(_object):
    """Proxy of C++ OT::Pointer<(OT::NearestPointAlgorithmImplementation)> class"""
    __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): 
        """
        __init__(OT::Pointer<(OT::NearestPointAlgorithmImplementation)> self) -> NearestPointAlgorithmImplementationPointer
        __init__(OT::Pointer<(OT::NearestPointAlgorithmImplementation)> self, NearestPointAlgorithmImplementation ptr) -> NearestPointAlgorithmImplementationPointer
        """
        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):
        """reset(NearestPointAlgorithmImplementationPointer self)"""
        return _optim.NearestPointAlgorithmImplementationPointer_reset(self)

    def __ref__(self, *args):
        """
        __ref__(NearestPointAlgorithmImplementationPointer self) -> NearestPointAlgorithmImplementation
        __ref__(NearestPointAlgorithmImplementationPointer self) -> NearestPointAlgorithmImplementation
        """
        return _optim.NearestPointAlgorithmImplementationPointer___ref__(self, *args)

    def __deref__(self):
        """__deref__(NearestPointAlgorithmImplementationPointer self) -> NearestPointAlgorithmImplementation"""
        return _optim.NearestPointAlgorithmImplementationPointer___deref__(self)

    def isNull(self):
        """isNull(NearestPointAlgorithmImplementationPointer self) -> OT::Bool"""
        return _optim.NearestPointAlgorithmImplementationPointer_isNull(self)

    def __nonzero__(self):
        return _optim.NearestPointAlgorithmImplementationPointer___nonzero__(self)
    __bool__ = __nonzero__


    def get(self):
        """get(NearestPointAlgorithmImplementationPointer self) -> NearestPointAlgorithmImplementation"""
        return _optim.NearestPointAlgorithmImplementationPointer_get(self)

    def getImplementation(self):
        """getImplementation(NearestPointAlgorithmImplementationPointer self) -> OT::Pointer< OT::NearestPointAlgorithmImplementation >::pointer_type const &"""
        return _optim.NearestPointAlgorithmImplementationPointer_getImplementation(self)

    def unique(self):
        """unique(NearestPointAlgorithmImplementationPointer self) -> OT::Bool"""
        return _optim.NearestPointAlgorithmImplementationPointer_unique(self)

    def use_count(self):
        """use_count(NearestPointAlgorithmImplementationPointer self) -> OT::UnsignedLong"""
        return _optim.NearestPointAlgorithmImplementationPointer_use_count(self)

    def swap(self, *args):
        """swap(NearestPointAlgorithmImplementationPointer self, NearestPointAlgorithmImplementationPointer other)"""
        return _optim.NearestPointAlgorithmImplementationPointer_swap(self, *args)

    def GetClassName(self):
        """GetClassName(NearestPointAlgorithmImplementationPointer self) -> OT::String"""
        return _optim.NearestPointAlgorithmImplementationPointer_GetClassName(self)

    def getClassName(self):
        """getClassName(NearestPointAlgorithmImplementationPointer self) -> OT::String"""
        return _optim.NearestPointAlgorithmImplementationPointer_getClassName(self)

    def run(self):
        """run(NearestPointAlgorithmImplementationPointer self)"""
        return _optim.NearestPointAlgorithmImplementationPointer_run(self)

    def getStartingPoint(self):
        """getStartingPoint(NearestPointAlgorithmImplementationPointer self) -> NumericalPoint"""
        return _optim.NearestPointAlgorithmImplementationPointer_getStartingPoint(self)

    def setStartingPoint(self, *args):
        """setStartingPoint(NearestPointAlgorithmImplementationPointer self, NumericalPoint startingPoint)"""
        return _optim.NearestPointAlgorithmImplementationPointer_setStartingPoint(self, *args)

    def getLevelFunction(self):
        """getLevelFunction(NearestPointAlgorithmImplementationPointer self) -> NumericalMathFunction"""
        return _optim.NearestPointAlgorithmImplementationPointer_getLevelFunction(self)

    def setLevelFunction(self, *args):
        """setLevelFunction(NearestPointAlgorithmImplementationPointer self, NumericalMathFunction levelFunction)"""
        return _optim.NearestPointAlgorithmImplementationPointer_setLevelFunction(self, *args)

    def getLevelValue(self):
        """getLevelValue(NearestPointAlgorithmImplementationPointer self) -> OT::NumericalScalar"""
        return _optim.NearestPointAlgorithmImplementationPointer_getLevelValue(self)

    def setLevelValue(self, *args):
        """setLevelValue(NearestPointAlgorithmImplementationPointer self, OT::NumericalScalar const levelValue)"""
        return _optim.NearestPointAlgorithmImplementationPointer_setLevelValue(self, *args)

    def getResult(self):
        """getResult(NearestPointAlgorithmImplementationPointer self) -> NearestPointAlgorithmImplementationResult"""
        return _optim.NearestPointAlgorithmImplementationPointer_getResult(self)

    def setResult(self, *args):
        """setResult(NearestPointAlgorithmImplementationPointer self, NearestPointAlgorithmImplementationResult result)"""
        return _optim.NearestPointAlgorithmImplementationPointer_setResult(self, *args)

    def getMaximumIterationsNumber(self):
        """getMaximumIterationsNumber(NearestPointAlgorithmImplementationPointer self) -> OT::UnsignedLong"""
        return _optim.NearestPointAlgorithmImplementationPointer_getMaximumIterationsNumber(self)

    def setMaximumIterationsNumber(self, *args):
        """setMaximumIterationsNumber(NearestPointAlgorithmImplementationPointer self, OT::UnsignedLong const maximumIterationsNumber)"""
        return _optim.NearestPointAlgorithmImplementationPointer_setMaximumIterationsNumber(self, *args)

    def getMaximumAbsoluteError(self):
        """getMaximumAbsoluteError(NearestPointAlgorithmImplementationPointer self) -> OT::NumericalScalar"""
        return _optim.NearestPointAlgorithmImplementationPointer_getMaximumAbsoluteError(self)

    def setMaximumAbsoluteError(self, *args):
        """setMaximumAbsoluteError(NearestPointAlgorithmImplementationPointer self, OT::NumericalScalar const maximumAbsoluteError)"""
        return _optim.NearestPointAlgorithmImplementationPointer_setMaximumAbsoluteError(self, *args)

    def getMaximumRelativeError(self):
        """getMaximumRelativeError(NearestPointAlgorithmImplementationPointer self) -> OT::NumericalScalar"""
        return _optim.NearestPointAlgorithmImplementationPointer_getMaximumRelativeError(self)

    def setMaximumRelativeError(self, *args):
        """setMaximumRelativeError(NearestPointAlgorithmImplementationPointer self, OT::NumericalScalar const maximumRelativeError)"""
        return _optim.NearestPointAlgorithmImplementationPointer_setMaximumRelativeError(self, *args)

    def getMaximumResidualError(self):
        """getMaximumResidualError(NearestPointAlgorithmImplementationPointer self) -> OT::NumericalScalar"""
        return _optim.NearestPointAlgorithmImplementationPointer_getMaximumResidualError(self)

    def setMaximumResidualError(self, *args):
        """setMaximumResidualError(NearestPointAlgorithmImplementationPointer self, OT::NumericalScalar const maximumResidualError)"""
        return _optim.NearestPointAlgorithmImplementationPointer_setMaximumResidualError(self, *args)

    def getMaximumConstraintError(self):
        """getMaximumConstraintError(NearestPointAlgorithmImplementationPointer self) -> OT::NumericalScalar"""
        return _optim.NearestPointAlgorithmImplementationPointer_getMaximumConstraintError(self)

    def setMaximumConstraintError(self, *args):
        """setMaximumConstraintError(NearestPointAlgorithmImplementationPointer self, OT::NumericalScalar const maximumConstraintError)"""
        return _optim.NearestPointAlgorithmImplementationPointer_setMaximumConstraintError(self, *args)

    def __repr__(self):
        """__repr__(NearestPointAlgorithmImplementationPointer self) -> OT::String"""
        return _optim.NearestPointAlgorithmImplementationPointer___repr__(self)

    def getVerbose(self):
        """getVerbose(NearestPointAlgorithmImplementationPointer self) -> OT::Bool"""
        return _optim.NearestPointAlgorithmImplementationPointer_getVerbose(self)

    def setVerbose(self, *args):
        """setVerbose(NearestPointAlgorithmImplementationPointer self, OT::Bool const verbose)"""
        return _optim.NearestPointAlgorithmImplementationPointer_setVerbose(self, *args)

    def __eq__(self, *args):
        """__eq__(NearestPointAlgorithmImplementationPointer self, PersistentObject other) -> OT::Bool"""
        return _optim.NearestPointAlgorithmImplementationPointer___eq__(self, *args)

    def Is(self, *args):
        """Is(NearestPointAlgorithmImplementationPointer self, PersistentObject other) -> OT::Bool"""
        return _optim.NearestPointAlgorithmImplementationPointer_Is(self, *args)

    def __str__(self, offset=""):
        """
        __str__(NearestPointAlgorithmImplementationPointer self, OT::String const & offset="") -> OT::String
        __str__(NearestPointAlgorithmImplementationPointer self) -> OT::String
        """
        return _optim.NearestPointAlgorithmImplementationPointer___str__(self, offset)

    def getId(self):
        """getId(NearestPointAlgorithmImplementationPointer self) -> OT::Id"""
        return _optim.NearestPointAlgorithmImplementationPointer_getId(self)

    def setShadowedId(self, *args):
        """setShadowedId(NearestPointAlgorithmImplementationPointer self, OT::Id id)"""
        return _optim.NearestPointAlgorithmImplementationPointer_setShadowedId(self, *args)

    def getShadowedId(self):
        """getShadowedId(NearestPointAlgorithmImplementationPointer self) -> OT::Id"""
        return _optim.NearestPointAlgorithmImplementationPointer_getShadowedId(self)

    def setVisibility(self, *args):
        """setVisibility(NearestPointAlgorithmImplementationPointer self, OT::Bool visible)"""
        return _optim.NearestPointAlgorithmImplementationPointer_setVisibility(self, *args)

    def getVisibility(self):
        """getVisibility(NearestPointAlgorithmImplementationPointer self) -> OT::Bool"""
        return _optim.NearestPointAlgorithmImplementationPointer_getVisibility(self)

    def hasName(self):
        """hasName(NearestPointAlgorithmImplementationPointer self) -> OT::Bool"""
        return _optim.NearestPointAlgorithmImplementationPointer_hasName(self)

    def hasVisibleName(self):
        """hasVisibleName(NearestPointAlgorithmImplementationPointer self) -> OT::Bool"""
        return _optim.NearestPointAlgorithmImplementationPointer_hasVisibleName(self)

    def getName(self):
        """getName(NearestPointAlgorithmImplementationPointer self) -> OT::String"""
        return _optim.NearestPointAlgorithmImplementationPointer_getName(self)

    def setName(self, *args):
        """setName(NearestPointAlgorithmImplementationPointer self, OT::String const & name)"""
        return _optim.NearestPointAlgorithmImplementationPointer_setName(self, *args)

NearestPointAlgorithmImplementationPointer_swigregister = _optim.NearestPointAlgorithmImplementationPointer_swigregister
NearestPointAlgorithmImplementationPointer_swigregister(NearestPointAlgorithmImplementationPointer)

class SolverImplementationPointer(_object):
    """Proxy of C++ OT::Pointer<(OT::SolverImplementation)> class"""
    __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): 
        """
        __init__(OT::Pointer<(OT::SolverImplementation)> self) -> SolverImplementationPointer
        __init__(OT::Pointer<(OT::SolverImplementation)> self, OT::SolverImplementation * ptr) -> SolverImplementationPointer
        """
        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):
        """reset(SolverImplementationPointer self)"""
        return _optim.SolverImplementationPointer_reset(self)

    def __ref__(self, *args):
        """
        __ref__(SolverImplementationPointer self) -> OT::SolverImplementation const
        __ref__(SolverImplementationPointer self) -> OT::SolverImplementation &
        """
        return _optim.SolverImplementationPointer___ref__(self, *args)

    def __deref__(self):
        """__deref__(SolverImplementationPointer self) -> OT::SolverImplementation *"""
        return _optim.SolverImplementationPointer___deref__(self)

    def isNull(self):
        """isNull(SolverImplementationPointer self) -> OT::Bool"""
        return _optim.SolverImplementationPointer_isNull(self)

    def __nonzero__(self):
        return _optim.SolverImplementationPointer___nonzero__(self)
    __bool__ = __nonzero__


    def get(self):
        """get(SolverImplementationPointer self) -> OT::SolverImplementation *"""
        return _optim.SolverImplementationPointer_get(self)

    def getImplementation(self):
        """getImplementation(SolverImplementationPointer self) -> OT::Pointer< OT::SolverImplementation >::pointer_type const &"""
        return _optim.SolverImplementationPointer_getImplementation(self)

    def unique(self):
        """unique(SolverImplementationPointer self) -> OT::Bool"""
        return _optim.SolverImplementationPointer_unique(self)

    def use_count(self):
        """use_count(SolverImplementationPointer self) -> OT::UnsignedLong"""
        return _optim.SolverImplementationPointer_use_count(self)

    def swap(self, *args):
        """swap(SolverImplementationPointer self, SolverImplementationPointer other)"""
        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.
python-openturns 1.2-2 / usr / share / pyshared / openturns / optim.py
