python-openturns 1.2-2 / usr / share / pyshared / openturns / func.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.


"""
Function primitives.
"""


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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

    def __sub__(self, *args):
        """
        __sub__(SwigPyIterator self, ptrdiff_t n) -> SwigPyIterator
        __sub__(SwigPyIterator self, SwigPyIterator x) -> ptrdiff_t
        """
        return _func.SwigPyIterator___sub__(self, *args)

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

GCC_VERSION = _func.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.geom
import openturns.graph
class TimeSeriesImplementationTypedInterfaceObject(openturns.common.InterfaceObject):
    """Proxy of C++ OT::TypedInterfaceObject<(OT::TimeSeriesImplementation)> class"""
    __swig_setmethods__ = {}
    for _s in [openturns.common.InterfaceObject]: __swig_setmethods__.update(getattr(_s,'__swig_setmethods__',{}))
    __setattr__ = lambda self, name, value: _swig_setattr(self, TimeSeriesImplementationTypedInterfaceObject, name, value)
    __swig_getmethods__ = {}
    for _s in [openturns.common.InterfaceObject]: __swig_getmethods__.update(getattr(_s,'__swig_getmethods__',{}))
    __getattr__ = lambda self, name: _swig_getattr(self, TimeSeriesImplementationTypedInterfaceObject, name)
    __repr__ = _swig_repr
    def __init__(self, *args): 
        """
        __init__(OT::TypedInterfaceObject<(OT::TimeSeriesImplementation)> self) -> TimeSeriesImplementationTypedInterfaceObject
        __init__(OT::TypedInterfaceObject<(OT::TimeSeriesImplementation)> self, OT::TypedInterfaceObject< OT::TimeSeriesImplementation >::Implementation const & impl) -> TimeSeriesImplementationTypedInterfaceObject
        """
        this = _func.new_TimeSeriesImplementationTypedInterfaceObject(*args)
        try: self.this.append(this)
        except: self.this = this
    def getImplementation(self, *args):
        """
        getImplementation(TimeSeriesImplementationTypedInterfaceObject self) -> OT::TypedInterfaceObject< OT::TimeSeriesImplementation >::Implementation
        getImplementation(TimeSeriesImplementationTypedInterfaceObject self) -> OT::TypedInterfaceObject< OT::TimeSeriesImplementation >::Implementation const &
        """
        return _func.TimeSeriesImplementationTypedInterfaceObject_getImplementation(self, *args)

    def getImplementationAsPersistentObject(self):
        """getImplementationAsPersistentObject(TimeSeriesImplementationTypedInterfaceObject self) -> PersistentObjectPointer"""
        return _func.TimeSeriesImplementationTypedInterfaceObject_getImplementationAsPersistentObject(self)

    def setImplementationAsPersistentObject(self, *args):
        """setImplementationAsPersistentObject(TimeSeriesImplementationTypedInterfaceObject self, PersistentObjectPointer obj)"""
        return _func.TimeSeriesImplementationTypedInterfaceObject_setImplementationAsPersistentObject(self, *args)

    def swap(self, *args):
        """swap(TimeSeriesImplementationTypedInterfaceObject self, TimeSeriesImplementationTypedInterfaceObject other)"""
        return _func.TimeSeriesImplementationTypedInterfaceObject_swap(self, *args)

    def setName(self, *args):
        """setName(TimeSeriesImplementationTypedInterfaceObject self, OT::String const & name)"""
        return _func.TimeSeriesImplementationTypedInterfaceObject_setName(self, *args)

    def getName(self):
        """getName(TimeSeriesImplementationTypedInterfaceObject self) -> OT::String"""
        return _func.TimeSeriesImplementationTypedInterfaceObject_getName(self)

    def __eq__(self, *args):
        """__eq__(TimeSeriesImplementationTypedInterfaceObject self, TimeSeriesImplementationTypedInterfaceObject other) -> OT::Bool"""
        return _func.TimeSeriesImplementationTypedInterfaceObject___eq__(self, *args)

    __swig_destroy__ = _func.delete_TimeSeriesImplementationTypedInterfaceObject
    __del__ = lambda self : None;
TimeSeriesImplementationTypedInterfaceObject_swigregister = _func.TimeSeriesImplementationTypedInterfaceObject_swigregister
TimeSeriesImplementationTypedInterfaceObject_swigregister(TimeSeriesImplementationTypedInterfaceObject)

OT_TYPECHECK_TIMESERIES = _func.OT_TYPECHECK_TIMESERIES
class RegularGrid(openturns.common.PersistentObject):
    """Proxy of C++ OT::RegularGrid class"""
    __swig_setmethods__ = {}
    for _s in [openturns.common.PersistentObject]: __swig_setmethods__.update(getattr(_s,'__swig_setmethods__',{}))
    __setattr__ = lambda self, name, value: _swig_setattr(self, RegularGrid, name, value)
    __swig_getmethods__ = {}
    for _s in [openturns.common.PersistentObject]: __swig_getmethods__.update(getattr(_s,'__swig_getmethods__',{}))
    __getattr__ = lambda self, name: _swig_getattr(self, RegularGrid, name)
    def GetClassName():
        """GetClassName() -> OT::String"""
        return _func.RegularGrid_GetClassName()

    if _newclass:GetClassName = staticmethod(GetClassName)
    __swig_getmethods__["GetClassName"] = lambda x: GetClassName
    def getClassName(self):
        """getClassName(RegularGrid self) -> OT::String"""
        return _func.RegularGrid_getClassName(self)

    __swig_setmethods__["start_"] = _func.RegularGrid_start__set
    __swig_getmethods__["start_"] = _func.RegularGrid_start__get
    if _newclass:start_ = _swig_property(_func.RegularGrid_start__get, _func.RegularGrid_start__set)
    __swig_setmethods__["step_"] = _func.RegularGrid_step__set
    __swig_getmethods__["step_"] = _func.RegularGrid_step__get
    if _newclass:step_ = _swig_property(_func.RegularGrid_step__get, _func.RegularGrid_step__set)
    __swig_setmethods__["n_"] = _func.RegularGrid_n__set
    __swig_getmethods__["n_"] = _func.RegularGrid_n__get
    if _newclass:n_ = _swig_property(_func.RegularGrid_n__get, _func.RegularGrid_n__set)
    def __eq__(self, *args):
        """__eq__(RegularGrid self, RegularGrid rhs) -> OT::Bool"""
        return _func.RegularGrid___eq__(self, *args)

    def getStart(self):
        """getStart(RegularGrid self) -> OT::NumericalScalar"""
        return _func.RegularGrid_getStart(self)

    def getEnd(self):
        """getEnd(RegularGrid self) -> OT::NumericalScalar"""
        return _func.RegularGrid_getEnd(self)

    def getStep(self):
        """getStep(RegularGrid self) -> OT::NumericalScalar"""
        return _func.RegularGrid_getStep(self)

    def getN(self):
        """getN(RegularGrid self) -> OT::UnsignedLong"""
        return _func.RegularGrid_getN(self)

    def getValue(self, *args):
        """getValue(RegularGrid self, OT::UnsignedLong const i) -> OT::NumericalScalar"""
        return _func.RegularGrid_getValue(self, *args)

    def getValues(self):
        """getValues(RegularGrid self) -> NumericalPoint"""
        return _func.RegularGrid_getValues(self)

    def follows(self, *args):
        """follows(RegularGrid self, RegularGrid starter) -> OT::Bool"""
        return _func.RegularGrid_follows(self, *args)

    def __repr__(self):
        """__repr__(RegularGrid self) -> OT::String"""
        return _func.RegularGrid___repr__(self)

    def __str__(self, offset=""):
        """
        __str__(RegularGrid self, OT::String const & offset="") -> OT::String
        __str__(RegularGrid self) -> OT::String
        """
        return _func.RegularGrid___str__(self, offset)

    def __init__(self, *args): 
        """
        __init__(OT::RegularGrid self) -> RegularGrid
        __init__(OT::RegularGrid self, OT::NumericalScalar const start, OT::NumericalScalar const step, OT::UnsignedLong const n) -> RegularGrid
        __init__(OT::RegularGrid self, RegularGrid other) -> RegularGrid
        """
        this = _func.new_RegularGrid(*args)
        try: self.this.append(this)
        except: self.this = this
    __swig_destroy__ = _func.delete_RegularGrid
    __del__ = lambda self : None;
RegularGrid_swigregister = _func.RegularGrid_swigregister
RegularGrid_swigregister(RegularGrid)

def RegularGrid_GetClassName():
  """RegularGrid_GetClassName() -> OT::String"""
  return _func.RegularGrid_GetClassName()

class TimeSeriesImplementation(openturns.common.PersistentObject):
    """Proxy of C++ OT::TimeSeriesImplementation class"""
    __swig_setmethods__ = {}
    for _s in [openturns.common.PersistentObject]: __swig_setmethods__.update(getattr(_s,'__swig_setmethods__',{}))
    __setattr__ = lambda self, name, value: _swig_setattr(self, TimeSeriesImplementation, name, value)
    __swig_getmethods__ = {}
    for _s in [openturns.common.PersistentObject]: __swig_getmethods__.update(getattr(_s,'__swig_getmethods__',{}))
    __getattr__ = lambda self, name: _swig_getattr(self, TimeSeriesImplementation, name)
    def GetClassName():
        """GetClassName() -> OT::String"""
        return _func.TimeSeriesImplementation_GetClassName()

    if _newclass:GetClassName = staticmethod(GetClassName)
    __swig_getmethods__["GetClassName"] = lambda x: GetClassName
    def getClassName(self):
        """getClassName(TimeSeriesImplementation self) -> OT::String"""
        return _func.TimeSeriesImplementation_getClassName(self)

    def __init__(self, *args): 
        """
        __init__(OT::TimeSeriesImplementation self, OT::UnsignedLong const n, OT::UnsignedLong const dim) -> TimeSeriesImplementation
        __init__(OT::TimeSeriesImplementation self, RegularGrid tg, OT::UnsignedLong const dim) -> TimeSeriesImplementation
        __init__(OT::TimeSeriesImplementation self, RegularGrid tg, NumericalSample sample) -> TimeSeriesImplementation
        """
        this = _func.new_TimeSeriesImplementation(*args)
        try: self.this.append(this)
        except: self.this = this
    def getValueAtIndex(self, *args):
        """
        getValueAtIndex(TimeSeriesImplementation self, OT::UnsignedLong const index) -> NumericalPoint
        getValueAtIndex(TimeSeriesImplementation self, OT::UnsignedLong const index) -> NumericalPoint
        """
        return _func.TimeSeriesImplementation_getValueAtIndex(self, *args)

    def setValueAtIndex(self, *args):
        """setValueAtIndex(TimeSeriesImplementation self, OT::UnsignedLong const index, NumericalPoint val)"""
        return _func.TimeSeriesImplementation_setValueAtIndex(self, *args)

    def getValueAtNearestTime(self, *args):
        """
        getValueAtNearestTime(TimeSeriesImplementation self, OT::NumericalScalar const timestamp) -> NumericalPoint
        getValueAtNearestTime(TimeSeriesImplementation self, OT::NumericalScalar const timestamp) -> NumericalPoint
        """
        return _func.TimeSeriesImplementation_getValueAtNearestTime(self, *args)

    def setValueAtNearestTime(self, *args):
        """setValueAtNearestTime(TimeSeriesImplementation self, OT::NumericalScalar const timestamp, NumericalPoint val)"""
        return _func.TimeSeriesImplementation_setValueAtNearestTime(self, *args)

    def setDescription(self, *args):
        """setDescription(TimeSeriesImplementation self, Description description)"""
        return _func.TimeSeriesImplementation_setDescription(self, *args)

    def getDescription(self):
        """getDescription(TimeSeriesImplementation self) -> Description"""
        return _func.TimeSeriesImplementation_getDescription(self)

    def getTimeGrid(self):
        """getTimeGrid(TimeSeriesImplementation self) -> RegularGrid"""
        return _func.TimeSeriesImplementation_getTimeGrid(self)

    def __repr__(self):
        """__repr__(TimeSeriesImplementation self) -> OT::String"""
        return _func.TimeSeriesImplementation___repr__(self)

    def __str__(self, offset=""):
        """
        __str__(TimeSeriesImplementation self, OT::String const & offset="") -> OT::String
        __str__(TimeSeriesImplementation self) -> OT::String
        """
        return _func.TimeSeriesImplementation___str__(self, offset)

    def __eq__(self, *args):
        """__eq__(TimeSeriesImplementation self, TimeSeriesImplementation rhs) -> OT::Bool"""
        return _func.TimeSeriesImplementation___eq__(self, *args)

    def contains(self, *args):
        """contains(TimeSeriesImplementation self, NumericalPoint val) -> OT::Bool"""
        return _func.TimeSeriesImplementation_contains(self, *args)

    def getSize(self):
        """getSize(TimeSeriesImplementation self) -> OT::UnsignedLong"""
        return _func.TimeSeriesImplementation_getSize(self)

    def getDimension(self):
        """getDimension(TimeSeriesImplementation self) -> OT::UnsignedLong"""
        return _func.TimeSeriesImplementation_getDimension(self)

    def add(self, *args):
        """
        add(TimeSeriesImplementation self, NumericalPoint point) -> TimeSeriesImplementation
        add(TimeSeriesImplementation self, NumericalSample sample) -> TimeSeriesImplementation
        add(TimeSeriesImplementation self, TimeSeriesImplementation continuer) -> TimeSeriesImplementation
        """
        return _func.TimeSeriesImplementation_add(self, *args)

    def getSample(self):
        """getSample(TimeSeriesImplementation self) -> NumericalSample"""
        return _func.TimeSeriesImplementation_getSample(self)

    def asSample(self):
        """asSample(TimeSeriesImplementation self) -> NumericalSample"""
        return _func.TimeSeriesImplementation_asSample(self)

    def getTemporalMean(self):
        """getTemporalMean(TimeSeriesImplementation self) -> NumericalPoint"""
        return _func.TimeSeriesImplementation_getTemporalMean(self)

    def drawMarginal(self, index=0):
        """
        drawMarginal(TimeSeriesImplementation self, OT::UnsignedLong const index=0) -> Graph
        drawMarginal(TimeSeriesImplementation self) -> Graph
        """
        return _func.TimeSeriesImplementation_drawMarginal(self, index)

    __swig_destroy__ = _func.delete_TimeSeriesImplementation
    __del__ = lambda self : None;
TimeSeriesImplementation_swigregister = _func.TimeSeriesImplementation_swigregister
TimeSeriesImplementation_swigregister(TimeSeriesImplementation)

def TimeSeriesImplementation_GetClassName():
  """TimeSeriesImplementation_GetClassName() -> OT::String"""
  return _func.TimeSeriesImplementation_GetClassName()


def __eq__(*args):
  """
    __eq__(NumericalSampleImplementation lhs, NumericalSampleImplementation rhs) -> OT::Bool
    __eq__(TimeSeriesImplementation lhs, TimeSeriesImplementation rhs) -> OT::Bool
    """
  return _func.__eq__(*args)
class TimeSeries(TimeSeriesImplementationTypedInterfaceObject):
    """Proxy of C++ OT::TimeSeries class"""
    __swig_setmethods__ = {}
    for _s in [TimeSeriesImplementationTypedInterfaceObject]: __swig_setmethods__.update(getattr(_s,'__swig_setmethods__',{}))
    __setattr__ = lambda self, name, value: _swig_setattr(self, TimeSeries, name, value)
    __swig_getmethods__ = {}
    for _s in [TimeSeriesImplementationTypedInterfaceObject]: __swig_getmethods__.update(getattr(_s,'__swig_getmethods__',{}))
    __getattr__ = lambda self, name: _swig_getattr(self, TimeSeries, name)
    def GetClassName():
        """GetClassName() -> OT::String"""
        return _func.TimeSeries_GetClassName()

    if _newclass:GetClassName = staticmethod(GetClassName)
    __swig_getmethods__["GetClassName"] = lambda x: GetClassName
    def getClassName(self):
        """getClassName(TimeSeries self) -> OT::String"""
        return _func.TimeSeries_getClassName(self)

    def __eq__(self, *args):
        """__eq__(TimeSeries self, TimeSeries other) -> OT::Bool"""
        return _func.TimeSeries___eq__(self, *args)

    def getValueAtIndex(self, *args):
        """
        getValueAtIndex(TimeSeries self, OT::UnsignedLong const index) -> NumericalPoint
        getValueAtIndex(TimeSeries self, OT::UnsignedLong const index) -> NumericalPoint
        """
        return _func.TimeSeries_getValueAtIndex(self, *args)

    def setValueAtIndex(self, *args):
        """setValueAtIndex(TimeSeries self, OT::UnsignedLong const index, NumericalPoint val)"""
        return _func.TimeSeries_setValueAtIndex(self, *args)

    def getValueAtNearestTime(self, *args):
        """
        getValueAtNearestTime(TimeSeries self, OT::NumericalScalar const timestamp) -> NumericalPoint
        getValueAtNearestTime(TimeSeries self, OT::NumericalScalar const timestamp) -> NumericalPoint
        """
        return _func.TimeSeries_getValueAtNearestTime(self, *args)

    def setValueAtNearestTime(self, *args):
        """setValueAtNearestTime(TimeSeries self, OT::NumericalScalar const timestamp, NumericalPoint val)"""
        return _func.TimeSeries_setValueAtNearestTime(self, *args)

    def getTimeGrid(self):
        """getTimeGrid(TimeSeries self) -> RegularGrid"""
        return _func.TimeSeries_getTimeGrid(self)

    def __len__(self):
        """__len__(TimeSeries self) -> OT::UnsignedLong"""
        return _func.TimeSeries___len__(self)

    def __contains__(self, *args):
        """__contains__(TimeSeries self, NumericalPoint val) -> OT::Bool"""
        return _func.TimeSeries___contains__(self, *args)

    def erase(self, *args):
        """
        erase(TimeSeries self, OT::UnsignedLong const first, OT::UnsignedLong const last)
        erase(TimeSeries self, OT::UnsignedLong const index)
        """
        return _func.TimeSeries_erase(self, *args)

    def clear(self):
        """clear(TimeSeries self)"""
        return _func.TimeSeries_clear(self)

    def __repr__(self):
        """__repr__(TimeSeries self) -> OT::String"""
        return _func.TimeSeries___repr__(self)

    def __str__(self, offset=""):
        """
        __str__(TimeSeries self, OT::String const & offset="") -> OT::String
        __str__(TimeSeries self) -> OT::String
        """
        return _func.TimeSeries___str__(self, offset)

    def setDescription(self, *args):
        """setDescription(TimeSeries self, Description description)"""
        return _func.TimeSeries_setDescription(self, *args)

    def getDescription(self):
        """getDescription(TimeSeries self) -> Description"""
        return _func.TimeSeries_getDescription(self)

    def getDimension(self):
        """getDimension(TimeSeries self) -> OT::UnsignedLong"""
        return _func.TimeSeries_getDimension(self)

    def getSize(self):
        """getSize(TimeSeries self) -> OT::UnsignedLong"""
        return _func.TimeSeries_getSize(self)

    def add(self, *args):
        """
        add(TimeSeries self, NumericalPoint point)
        add(TimeSeries self, NumericalSample sample)
        add(TimeSeries self, TimeSeries continuer)
        """
        return _func.TimeSeries_add(self, *args)

    def getSample(self):
        """getSample(TimeSeries self) -> NumericalSample"""
        return _func.TimeSeries_getSample(self)

    def getTemporalMean(self):
        """getTemporalMean(TimeSeries self) -> NumericalPoint"""
        return _func.TimeSeries_getTemporalMean(self)

    def drawMarginal(self, index=0):
        """
        drawMarginal(TimeSeries self, OT::UnsignedLong const index=0) -> Graph
        drawMarginal(TimeSeries self) -> Graph
        """
        return _func.TimeSeries_drawMarginal(self, index)

    def __getitem__(self, *args):
        """
        __getitem__(TimeSeries self, OT::UnsignedLong const index) -> NumericalPoint
        __getitem__(TimeSeries self, PyObject * args) -> OT::NumericalScalar
        """
        return _func.TimeSeries___getitem__(self, *args)

    def __setitem__(self, *args):
        """
        __setitem__(TimeSeries self, OT::UnsignedLong const index, NumericalPoint val)
        __setitem__(TimeSeries self, PyObject * args, OT::NumericalScalar val)
        """
        return _func.TimeSeries___setitem__(self, *args)

    def __init__(self, *args): 
        """
        __init__(OT::TimeSeries self) -> TimeSeries
        __init__(OT::TimeSeries self, OT::UnsignedLong const size, OT::UnsignedLong const dim) -> TimeSeries
        __init__(OT::TimeSeries self, RegularGrid tg, OT::UnsignedLong const dim) -> TimeSeries
        __init__(OT::TimeSeries self, RegularGrid tg, NumericalSample sample) -> TimeSeries
        __init__(OT::TimeSeries self, TimeSeriesImplementation implementation) -> TimeSeries
        __init__(OT::TimeSeries self, PyObject * pyObj) -> TimeSeries
        __init__(OT::TimeSeries self, TimeSeries other) -> TimeSeries
        """
        this = _func.new_TimeSeries(*args)
        try: self.this.append(this)
        except: self.this = this
    __swig_destroy__ = _func.delete_TimeSeries
    __del__ = lambda self : None;
TimeSeries_swigregister = _func.TimeSeries_swigregister
TimeSeries_swigregister(TimeSeries)

def TimeSeries_GetClassName():
  """TimeSeries_GetClassName() -> OT::String"""
  return _func.TimeSeries_GetClassName()

class TimeSeriesCollection(_object):
    """Proxy of C++ OT::Collection<(OT::TimeSeries)> class"""
    __swig_setmethods__ = {}
    __setattr__ = lambda self, name, value: _swig_setattr(self, TimeSeriesCollection, name, value)
    __swig_getmethods__ = {}
    __getattr__ = lambda self, name: _swig_getattr(self, TimeSeriesCollection, name)
    __swig_destroy__ = _func.delete_TimeSeriesCollection
    __del__ = lambda self : None;
    def clear(self):
        """clear(TimeSeriesCollection self)"""
        return _func.TimeSeriesCollection_clear(self)

    def __len__(self):
        """__len__(TimeSeriesCollection self) -> OT::UnsignedLong"""
        return _func.TimeSeriesCollection___len__(self)

    def __eq__(self, *args):
        """__eq__(TimeSeriesCollection self, TimeSeriesCollection rhs) -> OT::Bool"""
        return _func.TimeSeriesCollection___eq__(self, *args)

    def __contains__(self, *args):
        """__contains__(TimeSeriesCollection self, TimeSeries val) -> OT::Bool"""
        return _func.TimeSeriesCollection___contains__(self, *args)

    def __getitem__(self, *args):
        """__getitem__(TimeSeriesCollection self, OT::UnsignedLong const i) -> TimeSeries"""
        return _func.TimeSeriesCollection___getitem__(self, *args)

    def __setitem__(self, *args):
        """__setitem__(TimeSeriesCollection self, OT::UnsignedLong const i, TimeSeries val)"""
        return _func.TimeSeriesCollection___setitem__(self, *args)

    def __delitem__(self, *args):
        """__delitem__(TimeSeriesCollection self, OT::UnsignedLong const i)"""
        return _func.TimeSeriesCollection___delitem__(self, *args)

    def at(self, *args):
        """
        at(TimeSeriesCollection self, OT::UnsignedLong const i) -> TimeSeries
        at(TimeSeriesCollection self, OT::UnsignedLong const i) -> TimeSeries
        """
        return _func.TimeSeriesCollection_at(self, *args)

    def add(self, *args):
        """
        add(TimeSeriesCollection self, TimeSeries elt)
        add(TimeSeriesCollection self, TimeSeriesCollection coll)
        """
        return _func.TimeSeriesCollection_add(self, *args)

    def getSize(self):
        """getSize(TimeSeriesCollection self) -> OT::UnsignedLong"""
        return _func.TimeSeriesCollection_getSize(self)

    def resize(self, *args):
        """resize(TimeSeriesCollection self, OT::UnsignedLong const newSize)"""
        return _func.TimeSeriesCollection_resize(self, *args)

    def isEmpty(self):
        """isEmpty(TimeSeriesCollection self) -> OT::Bool"""
        return _func.TimeSeriesCollection_isEmpty(self)

    def __repr__(self):
        """__repr__(TimeSeriesCollection self) -> OT::String"""
        return _func.TimeSeriesCollection___repr__(self)

    def __str__(self, offset=""):
        """
        __str__(TimeSeriesCollection self, OT::String const & offset="") -> OT::String
        __str__(TimeSeriesCollection self) -> OT::String
        """
        return _func.TimeSeriesCollection___str__(self, offset)

    def __init__(self, *args): 
        """
        __init__(OT::Collection<(OT::TimeSeries)> self) -> TimeSeriesCollection
        __init__(OT::Collection<(OT::TimeSeries)> self, OT::UnsignedLong const size) -> TimeSeriesCollection
        __init__(OT::Collection<(OT::TimeSeries)> self, OT::UnsignedLong const size, TimeSeries value) -> TimeSeriesCollection
        __init__(OT::Collection<(OT::TimeSeries)> self, PyObject * pyObj) -> TimeSeriesCollection
        __init__(OT::Collection<(OT::TimeSeries)> self, TimeSeriesCollection other) -> TimeSeriesCollection
        """
        this = _func.new_TimeSeriesCollection(*args)
        try: self.this.append(this)
        except: self.this = this
TimeSeriesCollection_swigregister = _func.TimeSeriesCollection_swigregister
TimeSeriesCollection_swigregister(TimeSeriesCollection)

class TimeSeriesPersistentCollection(openturns.common.PersistentObject,TimeSeriesCollection):
    """Proxy of C++ OT::PersistentCollection<(OT::TimeSeries)> class"""
    __swig_setmethods__ = {}
    for _s in [openturns.common.PersistentObject,TimeSeriesCollection]: __swig_setmethods__.update(getattr(_s,'__swig_setmethods__',{}))
    __setattr__ = lambda self, name, value: _swig_setattr(self, TimeSeriesPersistentCollection, name, value)
    __swig_getmethods__ = {}
    for _s in [openturns.common.PersistentObject,TimeSeriesCollection]: __swig_getmethods__.update(getattr(_s,'__swig_getmethods__',{}))
    __getattr__ = lambda self, name: _swig_getattr(self, TimeSeriesPersistentCollection, name)
    def GetClassName():
        """GetClassName() -> OT::String"""
        return _func.TimeSeriesPersistentCollection_GetClassName()

    if _newclass:GetClassName = staticmethod(GetClassName)
    __swig_getmethods__["GetClassName"] = lambda x: GetClassName
    def getClassName(self):
        """getClassName(TimeSeriesPersistentCollection self) -> OT::String"""
        return _func.TimeSeriesPersistentCollection_getClassName(self)

    def __init__(self, *args): 
        """
        __init__(OT::PersistentCollection<(OT::TimeSeries)> self) -> TimeSeriesPersistentCollection
        __init__(OT::PersistentCollection<(OT::TimeSeries)> self, TimeSeriesCollection collection) -> TimeSeriesPersistentCollection
        __init__(OT::PersistentCollection<(OT::TimeSeries)> self, OT::UnsignedLong const size) -> TimeSeriesPersistentCollection
        __init__(OT::PersistentCollection<(OT::TimeSeries)> self, OT::UnsignedLong const size, TimeSeries value) -> TimeSeriesPersistentCollection
        """
        this = _func.new_TimeSeriesPersistentCollection(*args)
        try: self.this.append(this)
        except: self.this = this
    def __repr__(self):
        """__repr__(TimeSeriesPersistentCollection self) -> OT::String"""
        return _func.TimeSeriesPersistentCollection___repr__(self)

    def __str__(self, offset=""):
        """
        __str__(TimeSeriesPersistentCollection self, OT::String const & offset="") -> OT::String
        __str__(TimeSeriesPersistentCollection self) -> OT::String
        """
        return _func.TimeSeriesPersistentCollection___str__(self, offset)

    __swig_destroy__ = _func.delete_TimeSeriesPersistentCollection
    __del__ = lambda self : None;
TimeSeriesPersistentCollection_swigregister = _func.TimeSeriesPersistentCollection_swigregister
TimeSeriesPersistentCollection_swigregister(TimeSeriesPersistentCollection)

def TimeSeriesPersistentCollection_GetClassName():
  """TimeSeriesPersistentCollection_GetClassName() -> OT::String"""
  return _func.TimeSeriesPersistentCollection_GetClassName()

class ProcessSample(openturns.common.PersistentObject):
    """Proxy of C++ OT::ProcessSample class"""
    __swig_setmethods__ = {}
    for _s in [openturns.common.PersistentObject]: __swig_setmethods__.update(getattr(_s,'__swig_setmethods__',{}))
    __setattr__ = lambda self, name, value: _swig_setattr(self, ProcessSample, name, value)
    __swig_getmethods__ = {}
    for _s in [openturns.common.PersistentObject]: __swig_getmethods__.update(getattr(_s,'__swig_getmethods__',{}))
    __getattr__ = lambda self, name: _swig_getattr(self, ProcessSample, name)
    def GetClassName():
        """GetClassName() -> OT::String"""
        return _func.ProcessSample_GetClassName()

    if _newclass:GetClassName = staticmethod(GetClassName)
    __swig_getmethods__["GetClassName"] = lambda x: GetClassName
    def getClassName(self):
        """getClassName(ProcessSample self) -> OT::String"""
        return _func.ProcessSample_getClassName(self)

    def add(self, *args):
        """add(ProcessSample self, TimeSeries timeSeries)"""
        return _func.ProcessSample_add(self, *args)

    def __getitem__(self, *args):
        """__getitem__(ProcessSample self, OT::UnsignedLong const i) -> TimeSeries"""
        return _func.ProcessSample___getitem__(self, *args)

    def __setitem__(self, *args):
        """__setitem__(ProcessSample self, OT::UnsignedLong const i, TimeSeries timeSeries)"""
        return _func.ProcessSample___setitem__(self, *args)

    def __repr__(self):
        """__repr__(ProcessSample self) -> OT::String"""
        return _func.ProcessSample___repr__(self)

    def __str__(self, offset=""):
        """
        __str__(ProcessSample self, OT::String const & offset="") -> OT::String
        __str__(ProcessSample self) -> OT::String
        """
        return _func.ProcessSample___str__(self, offset)

    def getTimeGrid(self):
        """getTimeGrid(ProcessSample self) -> RegularGrid"""
        return _func.ProcessSample_getTimeGrid(self)

    def getSize(self):
        """getSize(ProcessSample self) -> OT::UnsignedLong"""
        return _func.ProcessSample_getSize(self)

    def getDimension(self):
        """getDimension(ProcessSample self) -> OT::UnsignedLong"""
        return _func.ProcessSample_getDimension(self)

    def computeMean(self):
        """computeMean(ProcessSample self) -> TimeSeries"""
        return _func.ProcessSample_computeMean(self)

    def computeTemporalMean(self):
        """computeTemporalMean(ProcessSample self) -> NumericalSample"""
        return _func.ProcessSample_computeTemporalMean(self)

    def computeQuantilePerComponent(self, *args):
        """computeQuantilePerComponent(ProcessSample self, OT::NumericalScalar const prob) -> TimeSeries"""
        return _func.ProcessSample_computeQuantilePerComponent(self, *args)

    def drawMarginal(self, index=0):
        """
        drawMarginal(ProcessSample self, OT::UnsignedLong const index=0) -> Graph
        drawMarginal(ProcessSample self) -> Graph
        """
        return _func.ProcessSample_drawMarginal(self, index)

    def __init__(self, *args): 
        """
        __init__(OT::ProcessSample self) -> ProcessSample
        __init__(OT::ProcessSample self, OT::UnsignedLong const size, TimeSeries timeSeries) -> ProcessSample
        __init__(OT::ProcessSample self, RegularGrid timeGrid, OT::UnsignedLong const size, OT::UnsignedLong const dimension) -> ProcessSample
        __init__(OT::ProcessSample self, TimeSeriesCollection collection) -> ProcessSample
        __init__(OT::ProcessSample self, PyObject * pyObj) -> ProcessSample
        __init__(OT::ProcessSample self, ProcessSample other) -> ProcessSample
        """
        this = _func.new_ProcessSample(*args)
        try: self.this.append(this)
        except: self.this = this
    __swig_destroy__ = _func.delete_ProcessSample
    __del__ = lambda self : None;
ProcessSample_swigregister = _func.ProcessSample_swigregister
ProcessSample_swigregister(ProcessSample)

def ProcessSample_GetClassName():
  """ProcessSample_GetClassName() -> OT::String"""
  return _func.ProcessSample_GetClassName()

class SpecFunc(_object):
    """Proxy of C++ OT::SpecFunc class"""
    __swig_setmethods__ = {}
    __setattr__ = lambda self, name, value: _swig_setattr(self, SpecFunc, name, value)
    __swig_getmethods__ = {}
    __getattr__ = lambda self, name: _swig_getattr(self, SpecFunc, name)
    __repr__ = _swig_repr
    def BesselI0(*args):
        """BesselI0(OT::NumericalScalar const x) -> OT::NumericalScalar"""
        return _func.SpecFunc_BesselI0(*args)

    if _newclass:BesselI0 = staticmethod(BesselI0)
    __swig_getmethods__["BesselI0"] = lambda x: BesselI0
    def LogBesselI0(*args):
        """LogBesselI0(OT::NumericalScalar const x) -> OT::NumericalScalar"""
        return _func.SpecFunc_LogBesselI0(*args)

    if _newclass:LogBesselI0 = staticmethod(LogBesselI0)
    __swig_getmethods__["LogBesselI0"] = lambda x: LogBesselI0
    def BesselI1(*args):
        """BesselI1(OT::NumericalScalar const x) -> OT::NumericalScalar"""
        return _func.SpecFunc_BesselI1(*args)

    if _newclass:BesselI1 = staticmethod(BesselI1)
    __swig_getmethods__["BesselI1"] = lambda x: BesselI1
    def LogBesselI1(*args):
        """LogBesselI1(OT::NumericalScalar const x) -> OT::NumericalScalar"""
        return _func.SpecFunc_LogBesselI1(*args)

    if _newclass:LogBesselI1 = staticmethod(LogBesselI1)
    __swig_getmethods__["LogBesselI1"] = lambda x: LogBesselI1
    def Beta(*args):
        """Beta(OT::NumericalScalar const a, OT::NumericalScalar const b) -> OT::NumericalScalar"""
        return _func.SpecFunc_Beta(*args)

    if _newclass:Beta = staticmethod(Beta)
    __swig_getmethods__["Beta"] = lambda x: Beta
    def BetaInc(*args):
        """BetaInc(OT::NumericalScalar const a, OT::NumericalScalar const b, OT::NumericalScalar const x) -> OT::NumericalScalar"""
        return _func.SpecFunc_BetaInc(*args)

    if _newclass:BetaInc = staticmethod(BetaInc)
    __swig_getmethods__["BetaInc"] = lambda x: BetaInc
    def BetaIncInv(*args):
        """BetaIncInv(OT::NumericalScalar const a, OT::NumericalScalar const b, OT::NumericalScalar const x) -> OT::NumericalScalar"""
        return _func.SpecFunc_BetaIncInv(*args)

    if _newclass:BetaIncInv = staticmethod(BetaIncInv)
    __swig_getmethods__["BetaIncInv"] = lambda x: BetaIncInv
    def BetaRatioInc(*args):
        """BetaRatioInc(OT::NumericalScalar const a, OT::NumericalScalar const b, OT::NumericalScalar const x) -> OT::NumericalScalar"""
        return _func.SpecFunc_BetaRatioInc(*args)

    if _newclass:BetaRatioInc = staticmethod(BetaRatioInc)
    __swig_getmethods__["BetaRatioInc"] = lambda x: BetaRatioInc
    def BetaRatioIncInv(*args):
        """BetaRatioIncInv(OT::NumericalScalar const a, OT::NumericalScalar const b, OT::NumericalScalar const x) -> OT::NumericalScalar"""
        return _func.SpecFunc_BetaRatioIncInv(*args)

    if _newclass:BetaRatioIncInv = staticmethod(BetaRatioIncInv)
    __swig_getmethods__["BetaRatioIncInv"] = lambda x: BetaRatioIncInv
    def LnBeta(*args):
        """LnBeta(OT::NumericalScalar const a, OT::NumericalScalar const b) -> OT::NumericalScalar"""
        return _func.SpecFunc_LnBeta(*args)

    if _newclass:LnBeta = staticmethod(LnBeta)
    __swig_getmethods__["LnBeta"] = lambda x: LnBeta
    def LogBeta(*args):
        """LogBeta(OT::NumericalScalar const a, OT::NumericalScalar const b) -> OT::NumericalScalar"""
        return _func.SpecFunc_LogBeta(*args)

    if _newclass:LogBeta = staticmethod(LogBeta)
    __swig_getmethods__["LogBeta"] = lambda x: LogBeta
    def Dawson(*args):
        """Dawson(OT::NumericalScalar const x) -> OT::NumericalScalar"""
        return _func.SpecFunc_Dawson(*args)

    if _newclass:Dawson = staticmethod(Dawson)
    __swig_getmethods__["Dawson"] = lambda x: Dawson
    def Debye(*args):
        """Debye(OT::NumericalScalar const x, OT::UnsignedLong const n) -> OT::NumericalScalar"""
        return _func.SpecFunc_Debye(*args)

    if _newclass:Debye = staticmethod(Debye)
    __swig_getmethods__["Debye"] = lambda x: Debye
    def Faddeeva(*args):
        """Faddeeva(OT::NumericalComplex const & z) -> OT::NumericalComplex"""
        return _func.SpecFunc_Faddeeva(*args)

    if _newclass:Faddeeva = staticmethod(Faddeeva)
    __swig_getmethods__["Faddeeva"] = lambda x: Faddeeva
    def Gamma(*args):
        """
        Gamma(OT::NumericalScalar const a) -> OT::NumericalScalar
        Gamma(OT::NumericalComplex const & a) -> OT::NumericalComplex
        """
        return _func.SpecFunc_Gamma(*args)

    if _newclass:Gamma = staticmethod(Gamma)
    __swig_getmethods__["Gamma"] = lambda x: Gamma
    def LnGamma(*args):
        """LnGamma(OT::NumericalScalar const a) -> OT::NumericalScalar"""
        return _func.SpecFunc_LnGamma(*args)

    if _newclass:LnGamma = staticmethod(LnGamma)
    __swig_getmethods__["LnGamma"] = lambda x: LnGamma
    def LogGamma(*args):
        """LogGamma(OT::NumericalScalar const a) -> OT::NumericalScalar"""
        return _func.SpecFunc_LogGamma(*args)

    if _newclass:LogGamma = staticmethod(LogGamma)
    __swig_getmethods__["LogGamma"] = lambda x: LogGamma
    def GammaInc(*args):
        """GammaInc(OT::NumericalScalar const a, OT::NumericalScalar const x) -> OT::NumericalScalar"""
        return _func.SpecFunc_GammaInc(*args)

    if _newclass:GammaInc = staticmethod(GammaInc)
    __swig_getmethods__["GammaInc"] = lambda x: GammaInc
    def GammaIncInv(*args):
        """GammaIncInv(OT::NumericalScalar const a, OT::NumericalScalar const x) -> OT::NumericalScalar"""
        return _func.SpecFunc_GammaIncInv(*args)

    if _newclass:GammaIncInv = staticmethod(GammaIncInv)
    __swig_getmethods__["GammaIncInv"] = lambda x: GammaIncInv
    def DiGamma(*args):
        """DiGamma(OT::NumericalScalar const x) -> OT::NumericalScalar"""
        return _func.SpecFunc_DiGamma(*args)

    if _newclass:DiGamma = staticmethod(DiGamma)
    __swig_getmethods__["DiGamma"] = lambda x: DiGamma
    def Psi(*args):
        """Psi(OT::NumericalScalar const x) -> OT::NumericalScalar"""
        return _func.SpecFunc_Psi(*args)

    if _newclass:Psi = staticmethod(Psi)
    __swig_getmethods__["Psi"] = lambda x: Psi
    def DiGammaInv(*args):
        """DiGammaInv(OT::NumericalScalar const a) -> OT::NumericalScalar"""
        return _func.SpecFunc_DiGammaInv(*args)

    if _newclass:DiGammaInv = staticmethod(DiGammaInv)
    __swig_getmethods__["DiGammaInv"] = lambda x: DiGammaInv
    def TriGamma(*args):
        """TriGamma(OT::NumericalScalar const x) -> OT::NumericalScalar"""
        return _func.SpecFunc_TriGamma(*args)

    if _newclass:TriGamma = staticmethod(TriGamma)
    __swig_getmethods__["TriGamma"] = lambda x: TriGamma
    def HyperGeom_1_1(*args):
        """
        HyperGeom_1_1(OT::NumericalScalar const p1, OT::NumericalScalar const q1, OT::NumericalScalar const x) -> OT::NumericalScalar
        HyperGeom_1_1(OT::NumericalScalar const p1, OT::NumericalScalar const q1, OT::NumericalComplex const & x) -> OT::NumericalComplex
        """
        return _func.SpecFunc_HyperGeom_1_1(*args)

    if _newclass:HyperGeom_1_1 = staticmethod(HyperGeom_1_1)
    __swig_getmethods__["HyperGeom_1_1"] = lambda x: HyperGeom_1_1
    def HyperGeom_2_1(*args):
        """
        HyperGeom_2_1(OT::NumericalScalar const p1, OT::NumericalScalar const p2, OT::NumericalScalar const q1, 
            OT::NumericalScalar const x) -> OT::NumericalScalar
        """
        return _func.SpecFunc_HyperGeom_2_1(*args)

    if _newclass:HyperGeom_2_1 = staticmethod(HyperGeom_2_1)
    __swig_getmethods__["HyperGeom_2_1"] = lambda x: HyperGeom_2_1
    def HyperGeom_2_2(*args):
        """
        HyperGeom_2_2(OT::NumericalScalar const p1, OT::NumericalScalar const p2, OT::NumericalScalar const q1, 
            OT::NumericalScalar const q2, OT::NumericalScalar const x) -> OT::NumericalScalar
        """
        return _func.SpecFunc_HyperGeom_2_2(*args)

    if _newclass:HyperGeom_2_2 = staticmethod(HyperGeom_2_2)
    __swig_getmethods__["HyperGeom_2_2"] = lambda x: HyperGeom_2_2
    def Erf(*args):
        """Erf(OT::NumericalScalar const x) -> OT::NumericalScalar"""
        return _func.SpecFunc_Erf(*args)

    if _newclass:Erf = staticmethod(Erf)
    __swig_getmethods__["Erf"] = lambda x: Erf
    def ErfC(*args):
        """ErfC(OT::NumericalScalar const x) -> OT::NumericalScalar"""
        return _func.SpecFunc_ErfC(*args)

    if _newclass:ErfC = staticmethod(ErfC)
    __swig_getmethods__["ErfC"] = lambda x: ErfC
    def ErfInv(*args):
        """ErfInv(OT::NumericalScalar const x) -> OT::NumericalScalar"""
        return _func.SpecFunc_ErfInv(*args)

    if _newclass:ErfInv = staticmethod(ErfInv)
    __swig_getmethods__["ErfInv"] = lambda x: ErfInv
    def LambertW(*args):
        """
        LambertW(OT::NumericalScalar const x, OT::Bool const principal=True) -> OT::NumericalScalar
        LambertW(OT::NumericalScalar const x) -> OT::NumericalScalar
        """
        return _func.SpecFunc_LambertW(*args)

    if _newclass:LambertW = staticmethod(LambertW)
    __swig_getmethods__["LambertW"] = lambda x: LambertW
    def NextPowerOfTwo(*args):
        """NextPowerOfTwo(OT::UnsignedLong const n) -> OT::UnsignedLong"""
        return _func.SpecFunc_NextPowerOfTwo(*args)

    if _newclass:NextPowerOfTwo = staticmethod(NextPowerOfTwo)
    __swig_getmethods__["NextPowerOfTwo"] = lambda x: NextPowerOfTwo
    def __init__(self, *args): 
        """__init__(OT::SpecFunc self, SpecFunc other) -> SpecFunc"""
        this = _func.new_SpecFunc(*args)
        try: self.this.append(this)
        except: self.this = this
    __swig_destroy__ = _func.delete_SpecFunc
    __del__ = lambda self : None;
SpecFunc_swigregister = _func.SpecFunc_swigregister
SpecFunc_swigregister(SpecFunc)
cvar = _func.cvar
SpecFunc.ISQRT2PI = _func.cvar.SpecFunc_ISQRT2PI
SpecFunc.EulerConstant = _func.cvar.SpecFunc_EulerConstant
SpecFunc.PI2_6 = _func.cvar.SpecFunc_PI2_6
SpecFunc.PI_SQRT6 = _func.cvar.SpecFunc_PI_SQRT6
SpecFunc.EULERSQRT6_PI = _func.cvar.SpecFunc_EULERSQRT6_PI
SpecFunc.PI2_3 = _func.cvar.SpecFunc_PI2_3
SpecFunc.SQRT3_PI = _func.cvar.SpecFunc_SQRT3_PI
SpecFunc.PI_SQRT3 = _func.cvar.SpecFunc_PI_SQRT3
SpecFunc.ZETA3 = _func.cvar.SpecFunc_ZETA3
SpecFunc.MinNumericalScalar = _func.cvar.SpecFunc_MinNumericalScalar
SpecFunc.LogMinNumericalScalar = _func.cvar.SpecFunc_LogMinNumericalScalar
SpecFunc.MaxNumericalScalar = _func.cvar.SpecFunc_MaxNumericalScalar
SpecFunc.LogMaxNumericalScalar = _func.cvar.SpecFunc_LogMaxNumericalScalar
SpecFunc.NumericalScalarEpsilon = _func.cvar.SpecFunc_NumericalScalarEpsilon

def SpecFunc_BesselI0(*args):
  """SpecFunc_BesselI0(OT::NumericalScalar const x) -> OT::NumericalScalar"""
  return _func.SpecFunc_BesselI0(*args)

def SpecFunc_LogBesselI0(*args):
  """SpecFunc_LogBesselI0(OT::NumericalScalar const x) -> OT::NumericalScalar"""
  return _func.SpecFunc_LogBesselI0(*args)

def SpecFunc_BesselI1(*args):
  """SpecFunc_BesselI1(OT::NumericalScalar const x) -> OT::NumericalScalar"""
  return _func.SpecFunc_BesselI1(*args)

def SpecFunc_LogBesselI1(*args):
  """SpecFunc_LogBesselI1(OT::NumericalScalar const x) -> OT::NumericalScalar"""
  return _func.SpecFunc_LogBesselI1(*args)

def SpecFunc_Beta(*args):
  """SpecFunc_Beta(OT::NumericalScalar const a, OT::NumericalScalar const b) -> OT::NumericalScalar"""
  return _func.SpecFunc_Beta(*args)

def SpecFunc_BetaInc(*args):
  """SpecFunc_BetaInc(OT::NumericalScalar const a, OT::NumericalScalar const b, OT::NumericalScalar const x) -> OT::NumericalScalar"""
  return _func.SpecFunc_BetaInc(*args)

def SpecFunc_BetaIncInv(*args):
  """SpecFunc_BetaIncInv(OT::NumericalScalar const a, OT::NumericalScalar const b, OT::NumericalScalar const x) -> OT::NumericalScalar"""
  return _func.SpecFunc_BetaIncInv(*args)

def SpecFunc_BetaRatioInc(*args):
  """SpecFunc_BetaRatioInc(OT::NumericalScalar const a, OT::NumericalScalar const b, OT::NumericalScalar const x) -> OT::NumericalScalar"""
  return _func.SpecFunc_BetaRatioInc(*args)

def SpecFunc_BetaRatioIncInv(*args):
  """SpecFunc_BetaRatioIncInv(OT::NumericalScalar const a, OT::NumericalScalar const b, OT::NumericalScalar const x) -> OT::NumericalScalar"""
  return _func.SpecFunc_BetaRatioIncInv(*args)

def SpecFunc_LnBeta(*args):
  """SpecFunc_LnBeta(OT::NumericalScalar const a, OT::NumericalScalar const b) -> OT::NumericalScalar"""
  return _func.SpecFunc_LnBeta(*args)

def SpecFunc_LogBeta(*args):
  """SpecFunc_LogBeta(OT::NumericalScalar const a, OT::NumericalScalar const b) -> OT::NumericalScalar"""
  return _func.SpecFunc_LogBeta(*args)

def SpecFunc_Dawson(*args):
  """SpecFunc_Dawson(OT::NumericalScalar const x) -> OT::NumericalScalar"""
  return _func.SpecFunc_Dawson(*args)

def SpecFunc_Debye(*args):
  """SpecFunc_Debye(OT::NumericalScalar const x, OT::UnsignedLong const n) -> OT::NumericalScalar"""
  return _func.SpecFunc_Debye(*args)

def SpecFunc_Faddeeva(*args):
  """SpecFunc_Faddeeva(OT::NumericalComplex const & z) -> OT::NumericalComplex"""
  return _func.SpecFunc_Faddeeva(*args)

def SpecFunc_Gamma(*args):
  """
    Gamma(OT::NumericalScalar const a) -> OT::NumericalScalar
    SpecFunc_Gamma(OT::NumericalComplex const & a) -> OT::NumericalComplex
    """
  return _func.SpecFunc_Gamma(*args)

def SpecFunc_LnGamma(*args):
  """SpecFunc_LnGamma(OT::NumericalScalar const a) -> OT::NumericalScalar"""
  return _func.SpecFunc_LnGamma(*args)

def SpecFunc_LogGamma(*args):
  """SpecFunc_LogGamma(OT::NumericalScalar const a) -> OT::NumericalScalar"""
  return _func.SpecFunc_LogGamma(*args)

def SpecFunc_GammaInc(*args):
  """SpecFunc_GammaInc(OT::NumericalScalar const a, OT::NumericalScalar const x) -> OT::NumericalScalar"""
  return _func.SpecFunc_GammaInc(*args)

def SpecFunc_GammaIncInv(*args):
  """SpecFunc_GammaIncInv(OT::NumericalScalar const a, OT::NumericalScalar const x) -> OT::NumericalScalar"""
  return _func.SpecFunc_GammaIncInv(*args)

def SpecFunc_DiGamma(*args):
  """SpecFunc_DiGamma(OT::NumericalScalar const x) -> OT::NumericalScalar"""
  return _func.SpecFunc_DiGamma(*args)

def SpecFunc_Psi(*args):
  """SpecFunc_Psi(OT::NumericalScalar const x) -> OT::NumericalScalar"""
  return _func.SpecFunc_Psi(*args)

def SpecFunc_DiGammaInv(*args):
  """SpecFunc_DiGammaInv(OT::NumericalScalar const a) -> OT::NumericalScalar"""
  return _func.SpecFunc_DiGammaInv(*args)

def SpecFunc_TriGamma(*args):
  """SpecFunc_TriGamma(OT::NumericalScalar const x) -> OT::NumericalScalar"""
  return _func.SpecFunc_TriGamma(*args)

def SpecFunc_HyperGeom_1_1(*args):
  """
    HyperGeom_1_1(OT::NumericalScalar const p1, OT::NumericalScalar const q1, OT::NumericalScalar const x) -> OT::NumericalScalar
    SpecFunc_HyperGeom_1_1(OT::NumericalScalar const p1, OT::NumericalScalar const q1, OT::NumericalComplex const & x) -> OT::NumericalComplex
    """
  return _func.SpecFunc_HyperGeom_1_1(*args)

def SpecFunc_HyperGeom_2_1(*args):
  """
    SpecFunc_HyperGeom_2_1(OT::NumericalScalar const p1, OT::NumericalScalar const p2, OT::NumericalScalar const q1, 
        OT::NumericalScalar const x) -> OT::NumericalScalar
    """
  return _func.SpecFunc_HyperGeom_2_1(*args)

def SpecFunc_HyperGeom_2_2(*args):
  """
    SpecFunc_HyperGeom_2_2(OT::NumericalScalar const p1, OT::NumericalScalar const p2, OT::NumericalScalar const q1, 
        OT::NumericalScalar const q2, OT::NumericalScalar const x) -> OT::NumericalScalar
    """
  return _func.SpecFunc_HyperGeom_2_2(*args)

def SpecFunc_Erf(*args):
  """SpecFunc_Erf(OT::NumericalScalar const x) -> OT::NumericalScalar"""
  return _func.SpecFunc_Erf(*args)

def SpecFunc_ErfC(*args):
  """SpecFunc_ErfC(OT::NumericalScalar const x) -> OT::NumericalScalar"""
  return _func.SpecFunc_ErfC(*args)

def SpecFunc_ErfInv(*args):
  """SpecFunc_ErfInv(OT::NumericalScalar const x) -> OT::NumericalScalar"""
  return _func.SpecFunc_ErfInv(*args)

def SpecFunc_LambertW(*args):
  """
    LambertW(OT::NumericalScalar const x, OT::Bool const principal=True) -> OT::NumericalScalar
    SpecFunc_LambertW(OT::NumericalScalar const x) -> OT::NumericalScalar
    """
  return _func.SpecFunc_LambertW(*args)

def SpecFunc_NextPowerOfTwo(*args):
  """SpecFunc_NextPowerOfTwo(OT::UnsignedLong const n) -> OT::UnsignedLong"""
  return _func.SpecFunc_NextPowerOfTwo(*args)

class NumericalMathEvaluationImplementation(openturns.common.PersistentObject):
    """Proxy of C++ OT::NumericalMathEvaluationImplementation class"""
    __swig_setmethods__ = {}
    for _s in [openturns.common.PersistentObject]: __swig_setmethods__.update(getattr(_s,'__swig_setmethods__',{}))
    __setattr__ = lambda self, name, value: _swig_setattr(self, NumericalMathEvaluationImplementation, name, value)
    __swig_getmethods__ = {}
    for _s in [openturns.common.PersistentObject]: __swig_getmethods__.update(getattr(_s,'__swig_getmethods__',{}))
    __getattr__ = lambda self, name: _swig_getattr(self, NumericalMathEvaluationImplementation, name)
    def GetClassName():
        """GetClassName() -> OT::String"""
        return _func.NumericalMathEvaluationImplementation_GetClassName()

    if _newclass:GetClassName = staticmethod(GetClassName)
    __swig_getmethods__["GetClassName"] = lambda x: GetClassName
    def getClassName(self):
        """getClassName(NumericalMathEvaluationImplementation self) -> OT::String"""
        return _func.NumericalMathEvaluationImplementation_getClassName(self)

    def __eq__(self, *args):
        """__eq__(NumericalMathEvaluationImplementation self, NumericalMathEvaluationImplementation other) -> OT::Bool"""
        return _func.NumericalMathEvaluationImplementation___eq__(self, *args)

    def __repr__(self):
        """__repr__(NumericalMathEvaluationImplementation self) -> OT::String"""
        return _func.NumericalMathEvaluationImplementation___repr__(self)

    def __str__(self, offset=""):
        """
        __str__(NumericalMathEvaluationImplementation self, OT::String const & offset="") -> OT::String
        __str__(NumericalMathEvaluationImplementation self) -> OT::String
        """
        return _func.NumericalMathEvaluationImplementation___str__(self, offset)

    def setDescription(self, *args):
        """setDescription(NumericalMathEvaluationImplementation self, Description description)"""
        return _func.NumericalMathEvaluationImplementation_setDescription(self, *args)

    def getDescription(self):
        """getDescription(NumericalMathEvaluationImplementation self) -> Description"""
        return _func.NumericalMathEvaluationImplementation_getDescription(self)

    def getInputDescription(self):
        """getInputDescription(NumericalMathEvaluationImplementation self) -> Description"""
        return _func.NumericalMathEvaluationImplementation_getInputDescription(self)

    def setInputDescription(self, *args):
        """setInputDescription(NumericalMathEvaluationImplementation self, Description inputDescription)"""
        return _func.NumericalMathEvaluationImplementation_setInputDescription(self, *args)

    def getOutputDescription(self):
        """getOutputDescription(NumericalMathEvaluationImplementation self) -> Description"""
        return _func.NumericalMathEvaluationImplementation_getOutputDescription(self)

    def setOutputDescription(self, *args):
        """setOutputDescription(NumericalMathEvaluationImplementation self, Description outputDescription)"""
        return _func.NumericalMathEvaluationImplementation_setOutputDescription(self, *args)

    def enableHistory(self):
        """enableHistory(NumericalMathEvaluationImplementation self)"""
        return _func.NumericalMathEvaluationImplementation_enableHistory(self)

    def disableHistory(self):
        """disableHistory(NumericalMathEvaluationImplementation self)"""
        return _func.NumericalMathEvaluationImplementation_disableHistory(self)

    def isHistoryEnabled(self):
        """isHistoryEnabled(NumericalMathEvaluationImplementation self) -> OT::Bool"""
        return _func.NumericalMathEvaluationImplementation_isHistoryEnabled(self)

    def clearHistory(self):
        """clearHistory(NumericalMathEvaluationImplementation self)"""
        return _func.NumericalMathEvaluationImplementation_clearHistory(self)

    def getInputHistory(self):
        """getInputHistory(NumericalMathEvaluationImplementation self) -> HistoryStrategy"""
        return _func.NumericalMathEvaluationImplementation_getInputHistory(self)

    def getOutputHistory(self):
        """getOutputHistory(NumericalMathEvaluationImplementation self) -> HistoryStrategy"""
        return _func.NumericalMathEvaluationImplementation_getOutputHistory(self)

    def enableCache(self):
        """enableCache(NumericalMathEvaluationImplementation self)"""
        return _func.NumericalMathEvaluationImplementation_enableCache(self)

    def disableCache(self):
        """disableCache(NumericalMathEvaluationImplementation self)"""
        return _func.NumericalMathEvaluationImplementation_disableCache(self)

    def isCacheEnabled(self):
        """isCacheEnabled(NumericalMathEvaluationImplementation self) -> OT::Bool"""
        return _func.NumericalMathEvaluationImplementation_isCacheEnabled(self)

    def getCacheHits(self):
        """getCacheHits(NumericalMathEvaluationImplementation self) -> OT::UnsignedLong"""
        return _func.NumericalMathEvaluationImplementation_getCacheHits(self)

    def addCacheContent(self, *args):
        """addCacheContent(NumericalMathEvaluationImplementation self, NumericalSample inSample, NumericalSample outSample)"""
        return _func.NumericalMathEvaluationImplementation_addCacheContent(self, *args)

    def getCacheInput(self):
        """getCacheInput(NumericalMathEvaluationImplementation self) -> NumericalSample"""
        return _func.NumericalMathEvaluationImplementation_getCacheInput(self)

    def getCacheOutput(self):
        """getCacheOutput(NumericalMathEvaluationImplementation self) -> NumericalSample"""
        return _func.NumericalMathEvaluationImplementation_getCacheOutput(self)

    def clearCache(self):
        """clearCache(NumericalMathEvaluationImplementation self)"""
        return _func.NumericalMathEvaluationImplementation_clearCache(self)

    def isActualImplementation(self):
        """isActualImplementation(NumericalMathEvaluationImplementation self) -> OT::Bool"""
        return _func.NumericalMathEvaluationImplementation_isActualImplementation(self)

    def __call__(self, *args):
        """
        __call__(NumericalMathEvaluationImplementation self, NumericalPoint inP) -> NumericalPoint
        __call__(NumericalMathEvaluationImplementation self, NumericalSample inSample) -> NumericalSample
        __call__(NumericalMathEvaluationImplementation self, TimeSeries inTimeSeries) -> TimeSeries
        """
        return _func.NumericalMathEvaluationImplementation___call__(self, *args)

    def getInputDimension(self):
        """getInputDimension(NumericalMathEvaluationImplementation self) -> OT::UnsignedLong"""
        return _func.NumericalMathEvaluationImplementation_getInputDimension(self)

    def getOutputDimension(self):
        """getOutputDimension(NumericalMathEvaluationImplementation self) -> OT::UnsignedLong"""
        return _func.NumericalMathEvaluationImplementation_getOutputDimension(self)

    def getMarginal(self, *args):
        """
        getMarginal(NumericalMathEvaluationImplementation self, OT::UnsignedLong const i) -> EvaluationImplementation
        getMarginal(NumericalMathEvaluationImplementation self, Indices indices) -> EvaluationImplementation
        """
        return _func.NumericalMathEvaluationImplementation_getMarginal(self, *args)

    def parametersGradient(self, *args):
        """parametersGradient(NumericalMathEvaluationImplementation self, NumericalPoint inP) -> Matrix"""
        return _func.NumericalMathEvaluationImplementation_parametersGradient(self, *args)

    def getParameters(self):
        """getParameters(NumericalMathEvaluationImplementation self) -> NumericalPointWithDescription"""
        return _func.NumericalMathEvaluationImplementation_getParameters(self)

    def setParameters(self, *args):
        """setParameters(NumericalMathEvaluationImplementation self, NumericalPointWithDescription parameters)"""
        return _func.NumericalMathEvaluationImplementation_setParameters(self, *args)

    def getCallsNumber(self):
        """getCallsNumber(NumericalMathEvaluationImplementation self) -> OT::UnsignedLong"""
        return _func.NumericalMathEvaluationImplementation_getCallsNumber(self)

    def draw(self, *args):
        """
        draw(NumericalMathEvaluationImplementation self, OT::UnsignedLong const inputMarginal, OT::UnsignedLong const outputMarginal, NumericalPoint centralPoint, 
            OT::NumericalScalar const xMin, OT::NumericalScalar const xMax, 
            OT::UnsignedLong const pointNumber=OT::ResourceMap::GetAsUnsignedLong("NumericalMathEvaluationImplementation-DefaultPointNumber")) -> Graph
        draw(NumericalMathEvaluationImplementation self, OT::UnsignedLong const inputMarginal, OT::UnsignedLong const outputMarginal, NumericalPoint centralPoint, 
            OT::NumericalScalar const xMin, OT::NumericalScalar const xMax) -> Graph
        draw(NumericalMathEvaluationImplementation self, OT::UnsignedLong const firstInputMarginal, OT::UnsignedLong const secondInputMarginal, 
            OT::UnsignedLong const outputMarginal, NumericalPoint centralPoint, NumericalPoint xMin, 
            NumericalPoint xMax, Indices pointNumber=OT::Indices(2, ResourceMap::GetAsUnsignedLong("NumericalMathEvaluationImplementation-DefaultPointNumber"))) -> Graph
        draw(NumericalMathEvaluationImplementation self, OT::UnsignedLong const firstInputMarginal, OT::UnsignedLong const secondInputMarginal, 
            OT::UnsignedLong const outputMarginal, NumericalPoint centralPoint, NumericalPoint xMin, 
            NumericalPoint xMax) -> Graph
        draw(NumericalMathEvaluationImplementation self, OT::NumericalScalar const xMin, OT::NumericalScalar const xMax, OT::UnsignedLong const pointNumber=OT::ResourceMap::GetAsUnsignedLong("NumericalMathEvaluationImplementation-DefaultPointNumber")) -> Graph
        draw(NumericalMathEvaluationImplementation self, OT::NumericalScalar const xMin, OT::NumericalScalar const xMax) -> Graph
        draw(NumericalMathEvaluationImplementation self, NumericalPoint xMin, NumericalPoint xMax, Indices pointNumber=OT::Indices(2, ResourceMap::GetAsUnsignedLong("NumericalMathEvaluationImplementation-DefaultPointNumber"))) -> Graph
        draw(NumericalMathEvaluationImplementation self, NumericalPoint xMin, NumericalPoint xMax) -> Graph
        """
        return _func.NumericalMathEvaluationImplementation_draw(self, *args)

    def __init__(self, *args): 
        """
        __init__(OT::NumericalMathEvaluationImplementation self) -> NumericalMathEvaluationImplementation
        __init__(OT::NumericalMathEvaluationImplementation self, NumericalMathEvaluationImplementation other) -> NumericalMathEvaluationImplementation
        """
        this = _func.new_NumericalMathEvaluationImplementation(*args)
        try: self.this.append(this)
        except: self.this = this
    __swig_destroy__ = _func.delete_NumericalMathEvaluationImplementation
    __del__ = lambda self : None;
NumericalMathEvaluationImplementation_swigregister = _func.NumericalMathEvaluationImplementation_swigregister
NumericalMathEvaluationImplementation_swigregister(NumericalMathEvaluationImplementation)

def NumericalMathEvaluationImplementation_GetClassName():
  """NumericalMathEvaluationImplementation_GetClassName() -> OT::String"""
  return _func.NumericalMathEvaluationImplementation_GetClassName()

class NumericalMathGradientImplementation(openturns.common.PersistentObject):
    """Proxy of C++ OT::NumericalMathGradientImplementation class"""
    __swig_setmethods__ = {}
    for _s in [openturns.common.PersistentObject]: __swig_setmethods__.update(getattr(_s,'__swig_setmethods__',{}))
    __setattr__ = lambda self, name, value: _swig_setattr(self, NumericalMathGradientImplementation, name, value)
    __swig_getmethods__ = {}
    for _s in [openturns.common.PersistentObject]: __swig_getmethods__.update(getattr(_s,'__swig_getmethods__',{}))
    __getattr__ = lambda self, name: _swig_getattr(self, NumericalMathGradientImplementation, name)
    def GetClassName():
        """GetClassName() -> OT::String"""
        return _func.NumericalMathGradientImplementation_GetClassName()

    if _newclass:GetClassName = staticmethod(GetClassName)
    __swig_getmethods__["GetClassName"] = lambda x: GetClassName
    def getClassName(self):
        """getClassName(NumericalMathGradientImplementation self) -> OT::String"""
        return _func.NumericalMathGradientImplementation_getClassName(self)

    def __eq__(self, *args):
        """__eq__(NumericalMathGradientImplementation self, NumericalMathGradientImplementation other) -> OT::Bool"""
        return _func.NumericalMathGradientImplementation___eq__(self, *args)

    def __repr__(self):
        """__repr__(NumericalMathGradientImplementation self) -> OT::String"""
        return _func.NumericalMathGradientImplementation___repr__(self)

    def __str__(self, offset=""):
        """
        __str__(NumericalMathGradientImplementation self, OT::String const & offset="") -> OT::String
        __str__(NumericalMathGradientImplementation self) -> OT::String
        """
        return _func.NumericalMathGradientImplementation___str__(self, offset)

    def setDescription(self, *args):
        """setDescription(NumericalMathGradientImplementation self, Description description)"""
        return _func.NumericalMathGradientImplementation_setDescription(self, *args)

    def getDescription(self):
        """getDescription(NumericalMathGradientImplementation self) -> Description"""
        return _func.NumericalMathGradientImplementation_getDescription(self)

    def getMarginal(self, *args):
        """
        getMarginal(NumericalMathGradientImplementation self, OT::UnsignedLong const i) -> GradientImplementation
        getMarginal(NumericalMathGradientImplementation self, Indices indices) -> GradientImplementation
        """
        return _func.NumericalMathGradientImplementation_getMarginal(self, *args)

    def isActualImplementation(self):
        """isActualImplementation(NumericalMathGradientImplementation self) -> OT::Bool"""
        return _func.NumericalMathGradientImplementation_isActualImplementation(self)

    def gradient(self, *args):
        """gradient(NumericalMathGradientImplementation self, NumericalPoint inP) -> Matrix"""
        return _func.NumericalMathGradientImplementation_gradient(self, *args)

    def getInputDimension(self):
        """getInputDimension(NumericalMathGradientImplementation self) -> OT::UnsignedLong"""
        return _func.NumericalMathGradientImplementation_getInputDimension(self)

    def getOutputDimension(self):
        """getOutputDimension(NumericalMathGradientImplementation self) -> OT::UnsignedLong"""
        return _func.NumericalMathGradientImplementation_getOutputDimension(self)

    def getCallsNumber(self):
        """getCallsNumber(NumericalMathGradientImplementation self) -> OT::UnsignedLong"""
        return _func.NumericalMathGradientImplementation_getCallsNumber(self)

    def __init__(self, *args): 
        """
        __init__(OT::NumericalMathGradientImplementation self) -> NumericalMathGradientImplementation
        __init__(OT::NumericalMathGradientImplementation self, NumericalMathGradientImplementation other) -> NumericalMathGradientImplementation
        """
        this = _func.new_NumericalMathGradientImplementation(*args)
        try: self.this.append(this)
        except: self.this = this
    __swig_destroy__ = _func.delete_NumericalMathGradientImplementation
    __del__ = lambda self : None;
NumericalMathGradientImplementation_swigregister = _func.NumericalMathGradientImplementation_swigregister
NumericalMathGradientImplementation_swigregister(NumericalMathGradientImplementation)

def NumericalMathGradientImplementation_GetClassName():
  """NumericalMathGradientImplementation_GetClassName() -> OT::String"""
  return _func.NumericalMathGradientImplementation_GetClassName()

class NumericalMathHessianImplementation(openturns.common.PersistentObject):
    """Proxy of C++ OT::NumericalMathHessianImplementation class"""
    __swig_setmethods__ = {}
    for _s in [openturns.common.PersistentObject]: __swig_setmethods__.update(getattr(_s,'__swig_setmethods__',{}))
    __setattr__ = lambda self, name, value: _swig_setattr(self, NumericalMathHessianImplementation, name, value)
    __swig_getmethods__ = {}
    for _s in [openturns.common.PersistentObject]: __swig_getmethods__.update(getattr(_s,'__swig_getmethods__',{}))
    __getattr__ = lambda self, name: _swig_getattr(self, NumericalMathHessianImplementation, name)
    def GetClassName():
        """GetClassName() -> OT::String"""
        return _func.NumericalMathHessianImplementation_GetClassName()

    if _newclass:GetClassName = staticmethod(GetClassName)
    __swig_getmethods__["GetClassName"] = lambda x: GetClassName
    def getClassName(self):
        """getClassName(NumericalMathHessianImplementation self) -> OT::String"""
        return _func.NumericalMathHessianImplementation_getClassName(self)

    def __eq__(self, *args):
        """__eq__(NumericalMathHessianImplementation self, NumericalMathHessianImplementation other) -> OT::Bool"""
        return _func.NumericalMathHessianImplementation___eq__(self, *args)

    def __repr__(self):
        """__repr__(NumericalMathHessianImplementation self) -> OT::String"""
        return _func.NumericalMathHessianImplementation___repr__(self)

    def __str__(self, offset=""):
        """
        __str__(NumericalMathHessianImplementation self, OT::String const & offset="") -> OT::String
        __str__(NumericalMathHessianImplementation self) -> OT::String
        """
        return _func.NumericalMathHessianImplementation___str__(self, offset)

    def setDescription(self, *args):
        """setDescription(NumericalMathHessianImplementation self, Description description)"""
        return _func.NumericalMathHessianImplementation_setDescription(self, *args)

    def getDescription(self):
        """getDescription(NumericalMathHessianImplementation self) -> Description"""
        return _func.NumericalMathHessianImplementation_getDescription(self)

    def isActualImplementation(self):
        """isActualImplementation(NumericalMathHessianImplementation self) -> OT::Bool"""
        return _func.NumericalMathHessianImplementation_isActualImplementation(self)

    def getMarginal(self, *args):
        """
        getMarginal(NumericalMathHessianImplementation self, OT::UnsignedLong const i) -> HessianImplementation
        getMarginal(NumericalMathHessianImplementation self, Indices indices) -> HessianImplementation
        """
        return _func.NumericalMathHessianImplementation_getMarginal(self, *args)

    def hessian(self, *args):
        """hessian(NumericalMathHessianImplementation self, NumericalPoint inP) -> SymmetricTensor"""
        return _func.NumericalMathHessianImplementation_hessian(self, *args)

    def getInputDimension(self):
        """getInputDimension(NumericalMathHessianImplementation self) -> OT::UnsignedLong"""
        return _func.NumericalMathHessianImplementation_getInputDimension(self)

    def getOutputDimension(self):
        """getOutputDimension(NumericalMathHessianImplementation self) -> OT::UnsignedLong"""
        return _func.NumericalMathHessianImplementation_getOutputDimension(self)

    def getCallsNumber(self):
        """getCallsNumber(NumericalMathHessianImplementation self) -> OT::UnsignedLong"""
        return _func.NumericalMathHessianImplementation_getCallsNumber(self)

    def __init__(self, *args): 
        """
        __init__(OT::NumericalMathHessianImplementation self) -> NumericalMathHessianImplementation
        __init__(OT::NumericalMathHessianImplementation self, NumericalMathHessianImplementation other) -> NumericalMathHessianImplementation
        """
        this = _func.new_NumericalMathHessianImplementation(*args)
        try: self.this.append(this)
        except: self.this = this
    __swig_destroy__ = _func.delete_NumericalMathHessianImplementation
    __del__ = lambda self : None;
NumericalMathHessianImplementation_swigregister = _func.NumericalMathHessianImplementation_swigregister
NumericalMathHessianImplementation_swigregister(NumericalMathHessianImplementation)

def NumericalMathHessianImplementation_GetClassName():
  """NumericalMathHessianImplementation_GetClassName() -> OT::String"""
  return _func.NumericalMathHessianImplementation_GetClassName()

class NoNumericalMathEvaluationImplementation(NumericalMathEvaluationImplementation):
    """Proxy of C++ OT::NoNumericalMathEvaluationImplementation class"""
    __swig_setmethods__ = {}
    for _s in [NumericalMathEvaluationImplementation]: __swig_setmethods__.update(getattr(_s,'__swig_setmethods__',{}))
    __setattr__ = lambda self, name, value: _swig_setattr(self, NoNumericalMathEvaluationImplementation, name, value)
    __swig_getmethods__ = {}
    for _s in [NumericalMathEvaluationImplementation]: __swig_getmethods__.update(getattr(_s,'__swig_getmethods__',{}))
    __getattr__ = lambda self, name: _swig_getattr(self, NoNumericalMathEvaluationImplementation, name)
    def GetClassName():
        """GetClassName() -> OT::String"""
        return _func.NoNumericalMathEvaluationImplementation_GetClassName()

    if _newclass:GetClassName = staticmethod(GetClassName)
    __swig_getmethods__["GetClassName"] = lambda x: GetClassName
    def getClassName(self):
        """getClassName(NoNumericalMathEvaluationImplementation self) -> OT::String"""
        return _func.NoNumericalMathEvaluationImplementation_getClassName(self)

    def __eq__(self, *args):
        """__eq__(NoNumericalMathEvaluationImplementation self, NoNumericalMathEvaluationImplementation other) -> OT::Bool"""
        return _func.NoNumericalMathEvaluationImplementation___eq__(self, *args)

    def __repr__(self):
        """__repr__(NoNumericalMathEvaluationImplementation self) -> OT::String"""
        return _func.NoNumericalMathEvaluationImplementation___repr__(self)

    def isActualImplementation(self):
        """isActualImplementation(NoNumericalMathEvaluationImplementation self) -> OT::Bool"""
        return _func.NoNumericalMathEvaluationImplementation_isActualImplementation(self)

    def __call__(self, *args):
        """__call__(NoNumericalMathEvaluationImplementation self, NumericalPoint inP) -> NumericalPoint"""
        return _func.NoNumericalMathEvaluationImplementation___call__(self, *args)

    def getInputDimension(self):
        """getInputDimension(NoNumericalMathEvaluationImplementation self) -> OT::UnsignedLong"""
        return _func.NoNumericalMathEvaluationImplementation_getInputDimension(self)

    def getOutputDimension(self):
        """getOutputDimension(NoNumericalMathEvaluationImplementation self) -> OT::UnsignedLong"""
        return _func.NoNumericalMathEvaluationImplementation_getOutputDimension(self)

    def __init__(self, *args): 
        """
        __init__(OT::NoNumericalMathEvaluationImplementation self) -> NoNumericalMathEvaluationImplementation
        __init__(OT::NoNumericalMathEvaluationImplementation self, NoNumericalMathEvaluationImplementation other) -> NoNumericalMathEvaluationImplementation
        """
        this = _func.new_NoNumericalMathEvaluationImplementation(*args)
        try: self.this.append(this)
        except: self.this = this
    __swig_destroy__ = _func.delete_NoNumericalMathEvaluationImplementation
    __del__ = lambda self : None;
NoNumericalMathEvaluationImplementation_swigregister = _func.NoNumericalMathEvaluationImplementation_swigregister
NoNumericalMathEvaluationImplementation_swigregister(NoNumericalMathEvaluationImplementation)

def NoNumericalMathEvaluationImplementation_GetClassName():
  """NoNumericalMathEvaluationImplementation_GetClassName() -> OT::String"""
  return _func.NoNumericalMathEvaluationImplementation_GetClassName()

class NoNumericalMathGradientImplementation(NumericalMathGradientImplementation):
    """Proxy of C++ OT::NoNumericalMathGradientImplementation class"""
    __swig_setmethods__ = {}
    for _s in [NumericalMathGradientImplementation]: __swig_setmethods__.update(getattr(_s,'__swig_setmethods__',{}))
    __setattr__ = lambda self, name, value: _swig_setattr(self, NoNumericalMathGradientImplementation, name, value)
    __swig_getmethods__ = {}
    for _s in [NumericalMathGradientImplementation]: __swig_getmethods__.update(getattr(_s,'__swig_getmethods__',{}))
    __getattr__ = lambda self, name: _swig_getattr(self, NoNumericalMathGradientImplementation, name)
    def GetClassName():
        """GetClassName() -> OT::String"""
        return _func.NoNumericalMathGradientImplementation_GetClassName()

    if _newclass:GetClassName = staticmethod(GetClassName)
    __swig_getmethods__["GetClassName"] = lambda x: GetClassName
    def getClassName(self):
        """getClassName(NoNumericalMathGradientImplementation self) -> OT::String"""
        return _func.NoNumericalMathGradientImplementation_getClassName(self)

    def __eq__(self, *args):
        """__eq__(NoNumericalMathGradientImplementation self, NoNumericalMathGradientImplementation other) -> OT::Bool"""
        return _func.NoNumericalMathGradientImplementation___eq__(self, *args)

    def __repr__(self):
        """__repr__(NoNumericalMathGradientImplementation self) -> OT::String"""
        return _func.NoNumericalMathGradientImplementation___repr__(self)

    def gradient(self, *args):
        """gradient(NoNumericalMathGradientImplementation self, NumericalPoint inP) -> Matrix"""
        return _func.NoNumericalMathGradientImplementation_gradient(self, *args)

    def getInputDimension(self):
        """getInputDimension(NoNumericalMathGradientImplementation self) -> OT::UnsignedLong"""
        return _func.NoNumericalMathGradientImplementation_getInputDimension(self)

    def getOutputDimension(self):
        """getOutputDimension(NoNumericalMathGradientImplementation self) -> OT::UnsignedLong"""
        return _func.NoNumericalMathGradientImplementation_getOutputDimension(self)

    def isActualImplementation(self):
        """isActualImplementation(NoNumericalMathGradientImplementation self) -> OT::Bool"""
        return _func.NoNumericalMathGradientImplementation_isActualImplementation(self)

    def __init__(self, *args): 
        """
        __init__(OT::NoNumericalMathGradientImplementation self) -> NoNumericalMathGradientImplementation
        __init__(OT::NoNumericalMathGradientImplementation self, NoNumericalMathGradientImplementation other) -> NoNumericalMathGradientImplementation
        """
        this = _func.new_NoNumericalMathGradientImplementation(*args)
        try: self.this.append(this)
        except: self.this = this
    __swig_destroy__ = _func.delete_NoNumericalMathGradientImplementation
    __del__ = lambda self : None;
NoNumericalMathGradientImplementation_swigregister = _func.NoNumericalMathGradientImplementation_swigregister
NoNumericalMathGradientImplementation_swigregister(NoNumericalMathGradientImplementation)

def NoNumericalMathGradientImplementation_GetClassName():
  """NoNumericalMathGradientImplementation_GetClassName() -> OT::String"""
  return _func.NoNumericalMathGradientImplementation_GetClassName()

class NoNumericalMathHessianImplementation(NumericalMathHessianImplementation):
    """Proxy of C++ OT::NoNumericalMathHessianImplementation class"""
    __swig_setmethods__ = {}
    for _s in [NumericalMathHessianImplementation]: __swig_setmethods__.update(getattr(_s,'__swig_setmethods__',{}))
    __setattr__ = lambda self, name, value: _swig_setattr(self, NoNumericalMathHessianImplementation, name, value)
    __swig_getmethods__ = {}
    for _s in [NumericalMathHessianImplementation]: __swig_getmethods__.update(getattr(_s,'__swig_getmethods__',{}))
    __getattr__ = lambda self, name: _swig_getattr(self, NoNumericalMathHessianImplementation, name)
    def GetClassName():
        """GetClassName() -> OT::String"""
        return _func.NoNumericalMathHessianImplementation_GetClassName()

    if _newclass:GetClassName = staticmethod(GetClassName)
    __swig_getmethods__["GetClassName"] = lambda x: GetClassName
    def getClassName(self):
        """getClassName(NoNumericalMathHessianImplementation self) -> OT::String"""
        return _func.NoNumericalMathHessianImplementation_getClassName(self)

    def __eq__(self, *args):
        """__eq__(NoNumericalMathHessianImplementation self, NoNumericalMathHessianImplementation other) -> OT::Bool"""
        return _func.NoNumericalMathHessianImplementation___eq__(self, *args)

    def __repr__(self):
        """__repr__(NoNumericalMathHessianImplementation self) -> OT::String"""
        return _func.NoNumericalMathHessianImplementation___repr__(self)

    def isActualImplementation(self):
        """isActualImplementation(NoNumericalMathHessianImplementation self) -> OT::Bool"""
        return _func.NoNumericalMathHessianImplementation_isActualImplementation(self)

    def hessian(self, *args):
        """hessian(NoNumericalMathHessianImplementation self, NumericalPoint inP) -> SymmetricTensor"""
        return _func.NoNumericalMathHessianImplementation_hessian(self, *args)

    def getInputDimension(self):
        """getInputDimension(NoNumericalMathHessianImplementation self) -> OT::UnsignedLong"""
        return _func.NoNumericalMathHessianImplementation_getInputDimension(self)

    def getOutputDimension(self):
        """getOutputDimension(NoNumericalMathHessianImplementation self) -> OT::UnsignedLong"""
        return _func.NoNumericalMathHessianImplementation_getOutputDimension(self)

    def __init__(self, *args): 
        """
        __init__(OT::NoNumericalMathHessianImplementation self) -> NoNumericalMathHessianImplementation
        __init__(OT::NoNumericalMathHessianImplementation self, NoNumericalMathHessianImplementation other) -> NoNumericalMathHessianImplementation
        """
        this = _func.new_NoNumericalMathHessianImplementation(*args)
        try: self.this.append(this)
        except: self.this = this
    __swig_destroy__ = _func.delete_NoNumericalMathHessianImplementation
    __del__ = lambda self : None;
NoNumericalMathHessianImplementation_swigregister = _func.NoNumericalMathHessianImplementation_swigregister
NoNumericalMathHessianImplementation_swigregister(NoNumericalMathHessianImplementation)

def NoNumericalMathHessianImplementation_GetClassName():
  """NoNumericalMathHessianImplementation_GetClassName() -> OT::String"""
  return _func.NoNumericalMathHessianImplementation_GetClassName()

class LinearNumericalMathEvaluationImplementation(NumericalMathEvaluationImplementation):
    """Proxy of C++ OT::LinearNumericalMathEvaluationImplementation class"""
    __swig_setmethods__ = {}
    for _s in [NumericalMathEvaluationImplementation]: __swig_setmethods__.update(getattr(_s,'__swig_setmethods__',{}))
    __setattr__ = lambda self, name, value: _swig_setattr(self, LinearNumericalMathEvaluationImplementation, name, value)
    __swig_getmethods__ = {}
    for _s in [NumericalMathEvaluationImplementation]: __swig_getmethods__.update(getattr(_s,'__swig_getmethods__',{}))
    __getattr__ = lambda self, name: _swig_getattr(self, LinearNumericalMathEvaluationImplementation, name)
    def GetClassName():
        """GetClassName() -> OT::String"""
        return _func.LinearNumericalMathEvaluationImplementation_GetClassName()

    if _newclass:GetClassName = staticmethod(GetClassName)
    __swig_getmethods__["GetClassName"] = lambda x: GetClassName
    def getClassName(self):
        """getClassName(LinearNumericalMathEvaluationImplementation self) -> OT::String"""
        return _func.LinearNumericalMathEvaluationImplementation_getClassName(self)

    def __eq__(self, *args):
        """__eq__(LinearNumericalMathEvaluationImplementation self, LinearNumericalMathEvaluationImplementation other) -> OT::Bool"""
        return _func.LinearNumericalMathEvaluationImplementation___eq__(self, *args)

    def __repr__(self):
        """__repr__(LinearNumericalMathEvaluationImplementation self) -> OT::String"""
        return _func.LinearNumericalMathEvaluationImplementation___repr__(self)

    def __call__(self, *args):
        """
        __call__(LinearNumericalMathEvaluationImplementation self, NumericalPoint inP) -> NumericalPoint
        __call__(LinearNumericalMathEvaluationImplementation self, NumericalSample inS) -> NumericalSample
        """
        return _func.LinearNumericalMathEvaluationImplementation___call__(self, *args)

    def getInputDimension(self):
        """getInputDimension(LinearNumericalMathEvaluationImplementation self) -> OT::UnsignedLong"""
        return _func.LinearNumericalMathEvaluationImplementation_getInputDimension(self)

    def getOutputDimension(self):
        """getOutputDimension(LinearNumericalMathEvaluationImplementation self) -> OT::UnsignedLong"""
        return _func.LinearNumericalMathEvaluationImplementation_getOutputDimension(self)

    def getCenter(self):
        """getCenter(LinearNumericalMathEvaluationImplementation self) -> NumericalPoint"""
        return _func.LinearNumericalMathEvaluationImplementation_getCenter(self)

    def getConstant(self):
        """getConstant(LinearNumericalMathEvaluationImplementation self) -> NumericalPoint"""
        return _func.LinearNumericalMathEvaluationImplementation_getConstant(self)

    def getLinear(self):
        """getLinear(LinearNumericalMathEvaluationImplementation self) -> Matrix"""
        return _func.LinearNumericalMathEvaluationImplementation_getLinear(self)

    def __init__(self, *args): 
        """
        __init__(OT::LinearNumericalMathEvaluationImplementation self) -> LinearNumericalMathEvaluationImplementation
        __init__(OT::LinearNumericalMathEvaluationImplementation self, NumericalPoint center, NumericalPoint constant, Matrix linear) -> LinearNumericalMathEvaluationImplementation
        __init__(OT::LinearNumericalMathEvaluationImplementation self, LinearNumericalMathEvaluationImplementation other) -> LinearNumericalMathEvaluationImplementation
        """
        this = _func.new_LinearNumericalMathEvaluationImplementation(*args)
        try: self.this.append(this)
        except: self.this = this
    __swig_destroy__ = _func.delete_LinearNumericalMathEvaluationImplementation
    __del__ = lambda self : None;
LinearNumericalMathEvaluationImplementation_swigregister = _func.LinearNumericalMathEvaluationImplementation_swigregister
LinearNumericalMathEvaluationImplementation_swigregister(LinearNumericalMathEvaluationImplementation)

def LinearNumericalMathEvaluationImplementation_GetClassName():
  """LinearNumericalMathEvaluationImplementation_GetClassName() -> OT::String"""
  return _func.LinearNumericalMathEvaluationImplementation_GetClassName()

class LinearNumericalMathGradientImplementation(NumericalMathGradientImplementation):
    """Proxy of C++ OT::LinearNumericalMathGradientImplementation class"""
    __swig_setmethods__ = {}
    for _s in [NumericalMathGradientImplementation]: __swig_setmethods__.update(getattr(_s,'__swig_setmethods__',{}))
    __setattr__ = lambda self, name, value: _swig_setattr(self, LinearNumericalMathGradientImplementation, name, value)
    __swig_getmethods__ = {}
    for _s in [NumericalMathGradientImplementation]: __swig_getmethods__.update(getattr(_s,'__swig_getmethods__',{}))
    __getattr__ = lambda self, name: _swig_getattr(self, LinearNumericalMathGradientImplementation, name)
    def GetClassName():
        """GetClassName() -> OT::String"""
        return _func.LinearNumericalMathGradientImplementation_GetClassName()

    if _newclass:GetClassName = staticmethod(GetClassName)
    __swig_getmethods__["GetClassName"] = lambda x: GetClassName
    def getClassName(self):
        """getClassName(LinearNumericalMathGradientImplementation self) -> OT::String"""
        return _func.LinearNumericalMathGradientImplementation_getClassName(self)

    def __eq__(self, *args):
        """__eq__(LinearNumericalMathGradientImplementation self, LinearNumericalMathGradientImplementation other) -> OT::Bool"""
        return _func.LinearNumericalMathGradientImplementation___eq__(self, *args)

    def __repr__(self):
        """__repr__(LinearNumericalMathGradientImplementation self) -> OT::String"""
        return _func.LinearNumericalMathGradientImplementation___repr__(self)

    def gradient(self, *args):
        """gradient(LinearNumericalMathGradientImplementation self, NumericalPoint inP) -> Matrix"""
        return _func.LinearNumericalMathGradientImplementation_gradient(self, *args)

    def getInputDimension(self):
        """getInputDimension(LinearNumericalMathGradientImplementation self) -> OT::UnsignedLong"""
        return _func.LinearNumericalMathGradientImplementation_getInputDimension(self)

    def getOutputDimension(self):
        """getOutputDimension(LinearNumericalMathGradientImplementation self) -> OT::UnsignedLong"""
        return _func.LinearNumericalMathGradientImplementation_getOutputDimension(self)

    def getCenter(self):
        """getCenter(LinearNumericalMathGradientImplementation self) -> NumericalPoint"""
        return _func.LinearNumericalMathGradientImplementation_getCenter(self)

    def getConstant(self):
        """getConstant(LinearNumericalMathGradientImplementation self) -> Matrix"""
        return _func.LinearNumericalMathGradientImplementation_getConstant(self)

    def getLinear(self):
        """getLinear(LinearNumericalMathGradientImplementation self) -> SymmetricTensor"""
        return _func.LinearNumericalMathGradientImplementation_getLinear(self)

    def __init__(self, *args): 
        """
        __init__(OT::LinearNumericalMathGradientImplementation self) -> LinearNumericalMathGradientImplementation
        __init__(OT::LinearNumericalMathGradientImplementation self, NumericalPoint center, Matrix constant, SymmetricTensor linear) -> LinearNumericalMathGradientImplementation
        __init__(OT::LinearNumericalMathGradientImplementation self, LinearNumericalMathGradientImplementation other) -> LinearNumericalMathGradientImplementation
        """
        this = _func.new_LinearNumericalMathGradientImplementation(*args)
        try: self.this.append(this)
        except: self.this = this
    __swig_destroy__ = _func.delete_LinearNumericalMathGradientImplementation
    __del__ = lambda self : None;
LinearNumericalMathGradientImplementation_swigregister = _func.LinearNumericalMathGradientImplementation_swigregister
LinearNumericalMathGradientImplementation_swigregister(LinearNumericalMathGradientImplementation)

def LinearNumericalMathGradientImplementation_GetClassName():
  """LinearNumericalMathGradientImplementation_GetClassName() -> OT::String"""
  return _func.LinearNumericalMathGradientImplementation_GetClassName()

class QuadraticNumericalMathEvaluationImplementation(NumericalMathEvaluationImplementation):
    """Proxy of C++ OT::QuadraticNumericalMathEvaluationImplementation class"""
    __swig_setmethods__ = {}
    for _s in [NumericalMathEvaluationImplementation]: __swig_setmethods__.update(getattr(_s,'__swig_setmethods__',{}))
    __setattr__ = lambda self, name, value: _swig_setattr(self, QuadraticNumericalMathEvaluationImplementation, name, value)
    __swig_getmethods__ = {}
    for _s in [NumericalMathEvaluationImplementation]: __swig_getmethods__.update(getattr(_s,'__swig_getmethods__',{}))
    __getattr__ = lambda self, name: _swig_getattr(self, QuadraticNumericalMathEvaluationImplementation, name)
    def GetClassName():
        """GetClassName() -> OT::String"""
        return _func.QuadraticNumericalMathEvaluationImplementation_GetClassName()

    if _newclass:GetClassName = staticmethod(GetClassName)
    __swig_getmethods__["GetClassName"] = lambda x: GetClassName
    def getClassName(self):
        """getClassName(QuadraticNumericalMathEvaluationImplementation self) -> OT::String"""
        return _func.QuadraticNumericalMathEvaluationImplementation_getClassName(self)

    def __eq__(self, *args):
        """__eq__(QuadraticNumericalMathEvaluationImplementation self, QuadraticNumericalMathEvaluationImplementation other) -> OT::Bool"""
        return _func.QuadraticNumericalMathEvaluationImplementation___eq__(self, *args)

    def __repr__(self):
        """__repr__(QuadraticNumericalMathEvaluationImplementation self) -> OT::String"""
        return _func.QuadraticNumericalMathEvaluationImplementation___repr__(self)

    def __call__(self, *args):
        """__call__(QuadraticNumericalMathEvaluationImplementation self, NumericalPoint inP) -> NumericalPoint"""
        return _func.QuadraticNumericalMathEvaluationImplementation___call__(self, *args)

    def getInputDimension(self):
        """getInputDimension(QuadraticNumericalMathEvaluationImplementation self) -> OT::UnsignedLong"""
        return _func.QuadraticNumericalMathEvaluationImplementation_getInputDimension(self)

    def getOutputDimension(self):
        """getOutputDimension(QuadraticNumericalMathEvaluationImplementation self) -> OT::UnsignedLong"""
        return _func.QuadraticNumericalMathEvaluationImplementation_getOutputDimension(self)

    def getCenter(self):
        """getCenter(QuadraticNumericalMathEvaluationImplementation self) -> NumericalPoint"""
        return _func.QuadraticNumericalMathEvaluationImplementation_getCenter(self)

    def getConstant(self):
        """getConstant(QuadraticNumericalMathEvaluationImplementation self) -> NumericalPoint"""
        return _func.QuadraticNumericalMathEvaluationImplementation_getConstant(self)

    def getLinear(self):
        """getLinear(QuadraticNumericalMathEvaluationImplementation self) -> Matrix"""
        return _func.QuadraticNumericalMathEvaluationImplementation_getLinear(self)

    def getQuadratic(self):
        """getQuadratic(QuadraticNumericalMathEvaluationImplementation self) -> SymmetricTensor"""
        return _func.QuadraticNumericalMathEvaluationImplementation_getQuadratic(self)

    def __init__(self, *args): 
        """
        __init__(OT::QuadraticNumericalMathEvaluationImplementation self) -> QuadraticNumericalMathEvaluationImplementation
        __init__(OT::QuadraticNumericalMathEvaluationImplementation self, NumericalPoint center, NumericalPoint constant, Matrix linear, SymmetricTensor quadratic) -> QuadraticNumericalMathEvaluationImplementation
        __init__(OT::QuadraticNumericalMathEvaluationImplementation self, QuadraticNumericalMathEvaluationImplementation other) -> QuadraticNumericalMathEvaluationImplementation
        """
        this = _func.new_QuadraticNumericalMathEvaluationImplementation(*args)
        try: self.this.append(this)
        except: self.this = this
    __swig_destroy__ = _func.delete_QuadraticNumericalMathEvaluationImplementation
    __del__ = lambda self : None;
QuadraticNumericalMathEvaluationImplementation_swigregister = _func.QuadraticNumericalMathEvaluationImplementation_swigregister
QuadraticNumericalMathEvaluationImplementation_swigregister(QuadraticNumericalMathEvaluationImplementation)

def QuadraticNumericalMathEvaluationImplementation_GetClassName():
  """QuadraticNumericalMathEvaluationImplementation_GetClassName() -> OT::String"""
  return _func.QuadraticNumericalMathEvaluationImplementation_GetClassName()

class ConstantNumericalMathGradientImplementation(NumericalMathGradientImplementation):
    """Proxy of C++ OT::ConstantNumericalMathGradientImplementation class"""
    __swig_setmethods__ = {}
    for _s in [NumericalMathGradientImplementation]: __swig_setmethods__.update(getattr(_s,'__swig_setmethods__',{}))
    __setattr__ = lambda self, name, value: _swig_setattr(self, ConstantNumericalMathGradientImplementation, name, value)
    __swig_getmethods__ = {}
    for _s in [NumericalMathGradientImplementation]: __swig_getmethods__.update(getattr(_s,'__swig_getmethods__',{}))
    __getattr__ = lambda self, name: _swig_getattr(self, ConstantNumericalMathGradientImplementation, name)
    def GetClassName():
        """GetClassName() -> OT::String"""
        return _func.ConstantNumericalMathGradientImplementation_GetClassName()

    if _newclass:GetClassName = staticmethod(GetClassName)
    __swig_getmethods__["GetClassName"] = lambda x: GetClassName
    def getClassName(self):
        """getClassName(ConstantNumericalMathGradientImplementation self) -> OT::String"""
        return _func.ConstantNumericalMathGradientImplementation_getClassName(self)

    def __eq__(self, *args):
        """__eq__(ConstantNumericalMathGradientImplementation self, ConstantNumericalMathGradientImplementation other) -> OT::Bool"""
        return _func.ConstantNumericalMathGradientImplementation___eq__(self, *args)

    def __repr__(self):
        """__repr__(ConstantNumericalMathGradientImplementation self) -> OT::String"""
        return _func.ConstantNumericalMathGradientImplementation___repr__(self)

    def __str__(self, offset=""):
        """
        __str__(ConstantNumericalMathGradientImplementation self, OT::String const & offset="") -> OT::String
        __str__(ConstantNumericalMathGradientImplementation self) -> OT::String
        """
        return _func.ConstantNumericalMathGradientImplementation___str__(self, offset)

    def gradient(self, *args):
        """gradient(ConstantNumericalMathGradientImplementation self, NumericalPoint inP) -> Matrix"""
        return _func.ConstantNumericalMathGradientImplementation_gradient(self, *args)

    def getInputDimension(self):
        """getInputDimension(ConstantNumericalMathGradientImplementation self) -> OT::UnsignedLong"""
        return _func.ConstantNumericalMathGradientImplementation_getInputDimension(self)

    def getOutputDimension(self):
        """getOutputDimension(ConstantNumericalMathGradientImplementation self) -> OT::UnsignedLong"""
        return _func.ConstantNumericalMathGradientImplementation_getOutputDimension(self)

    def getConstant(self):
        """getConstant(ConstantNumericalMathGradientImplementation self) -> Matrix"""
        return _func.ConstantNumericalMathGradientImplementation_getConstant(self)

    def __init__(self, *args): 
        """
        __init__(OT::ConstantNumericalMathGradientImplementation self) -> ConstantNumericalMathGradientImplementation
        __init__(OT::ConstantNumericalMathGradientImplementation self, Matrix constant) -> ConstantNumericalMathGradientImplementation
        __init__(OT::ConstantNumericalMathGradientImplementation self, ConstantNumericalMathGradientImplementation other) -> ConstantNumericalMathGradientImplementation
        """
        this = _func.new_ConstantNumericalMathGradientImplementation(*args)
        try: self.this.append(this)
        except: self.this = this
    __swig_destroy__ = _func.delete_ConstantNumericalMathGradientImplementation
    __del__ = lambda self : None;
ConstantNumericalMathGradientImplementation_swigregister = _func.ConstantNumericalMathGradientImplementation_swigregister
ConstantNumericalMathGradientImplementation_swigregister(ConstantNumericalMathGradientImplementation)

def ConstantNumericalMathGradientImplementation_GetClassName():
  """ConstantNumericalMathGradientImplementation_GetClassName() -> OT::String"""
  return _func.ConstantNumericalMathGradientImplementation_GetClassName()

class ConstantNumericalMathHessianImplementation(NumericalMathHessianImplementation):
    """Proxy of C++ OT::ConstantNumericalMathHessianImplementation class"""
    __swig_setmethods__ = {}
    for _s in [NumericalMathHessianImplementation]: __swig_setmethods__.update(getattr(_s,'__swig_setmethods__',{}))
    __setattr__ = lambda self, name, value: _swig_setattr(self, ConstantNumericalMathHessianImplementation, name, value)
    __swig_getmethods__ = {}
    for _s in [NumericalMathHessianImplementation]: __swig_getmethods__.update(getattr(_s,'__swig_getmethods__',{}))
    __getattr__ = lambda self, name: _swig_getattr(self, ConstantNumericalMathHessianImplementation, name)
    def GetClassName():
        """GetClassName() -> OT::String"""
        return _func.ConstantNumericalMathHessianImplementation_GetClassName()

    if _newclass:GetClassName = staticmethod(GetClassName)
    __swig_getmethods__["GetClassName"] = lambda x: GetClassName
    def getClassName(self):
        """getClassName(ConstantNumericalMathHessianImplementation self) -> OT::String"""
        return _func.ConstantNumericalMathHessianImplementation_getClassName(self)

    def __eq__(self, *args):
        """__eq__(ConstantNumericalMathHessianImplementation self, ConstantNumericalMathHessianImplementation other) -> OT::Bool"""
        return _func.ConstantNumericalMathHessianImplementation___eq__(self, *args)

    def __repr__(self):
        """__repr__(ConstantNumericalMathHessianImplementation self) -> OT::String"""
        return _func.ConstantNumericalMathHessianImplementation___repr__(self)

    def __str__(self, offset=""):
        """
        __str__(ConstantNumericalMathHessianImplementation self, OT::String const & offset="") -> OT::String
        __str__(ConstantNumericalMathHessianImplementation self) -> OT::String
        """
        return _func.ConstantNumericalMathHessianImplementation___str__(self, offset)

    def hessian(self, *args):
        """hessian(ConstantNumericalMathHessianImplementation self, NumericalPoint inP) -> SymmetricTensor"""
        return _func.ConstantNumericalMathHessianImplementation_hessian(self, *args)

    def getInputDimension(self):
        """getInputDimension(ConstantNumericalMathHessianImplementation self) -> OT::UnsignedLong"""
        return _func.ConstantNumericalMathHessianImplementation_getInputDimension(self)

    def getOutputDimension(self):
        """getOutputDimension(ConstantNumericalMathHessianImplementation self) -> OT::UnsignedLong"""
        return _func.ConstantNumericalMathHessianImplementation_getOutputDimension(self)

    def getConstant(self):
        """getConstant(ConstantNumericalMathHessianImplementation self) -> SymmetricTensor"""
        return _func.ConstantNumericalMathHessianImplementation_getConstant(self)

    def __init__(self, *args): 
        """
        __init__(OT::ConstantNumericalMathHessianImplementation self) -> ConstantNumericalMathHessianImplementation
        __init__(OT::ConstantNumericalMathHessianImplementation self, SymmetricTensor constant) -> ConstantNumericalMathHessianImplementation
        __init__(OT::ConstantNumericalMathHessianImplementation self, ConstantNumericalMathHessianImplementation other) -> ConstantNumericalMathHessianImplementation
        """
        this = _func.new_ConstantNumericalMathHessianImplementation(*args)
        try: self.this.append(this)
        except: self.this = this
    __swig_destroy__ = _func.delete_ConstantNumericalMathHessianImplementation
    __del__ = lambda self : None;
ConstantNumericalMathHessianImplementation_swigregister = _func.ConstantNumericalMathHessianImplementation_swigregister
ConstantNumericalMathHessianImplementation_swigregister(ConstantNumericalMathHessianImplementation)

def ConstantNumericalMathHessianImplementation_GetClassName():
  """ConstantNumericalMathHessianImplementation_GetClassName() -> OT::String"""
  return _func.ConstantNumericalMathHessianImplementation_GetClassName()

class ComputedNumericalMathEvaluationImplementation(NumericalMathEvaluationImplementation):
    """Proxy of C++ OT::ComputedNumericalMathEvaluationImplementation class"""
    __swig_setmethods__ = {}
    for _s in [NumericalMathEvaluationImplementation]: __swig_setmethods__.update(getattr(_s,'__swig_setmethods__',{}))
    __setattr__ = lambda self, name, value: _swig_setattr(self, ComputedNumericalMathEvaluationImplementation, name, value)
    __swig_getmethods__ = {}
    for _s in [NumericalMathEvaluationImplementation]: __swig_getmethods__.update(getattr(_s,'__swig_getmethods__',{}))
    __getattr__ = lambda self, name: _swig_getattr(self, ComputedNumericalMathEvaluationImplementation, name)
    def GetClassName():
        """GetClassName() -> OT::String"""
        return _func.ComputedNumericalMathEvaluationImplementation_GetClassName()

    if _newclass:GetClassName = staticmethod(GetClassName)
    __swig_getmethods__["GetClassName"] = lambda x: GetClassName
    def getClassName(self):
        """getClassName(ComputedNumericalMathEvaluationImplementation self) -> OT::String"""
        return _func.ComputedNumericalMathEvaluationImplementation_getClassName(self)

    def __init__(self, *args): 
        """
        __init__(OT::ComputedNumericalMathEvaluationImplementation self, OT::String const & name, WrapperFile file) -> ComputedNumericalMathEvaluationImplementation
        __init__(OT::ComputedNumericalMathEvaluationImplementation self, ComputedNumericalMathEvaluationImplementation other) -> ComputedNumericalMathEvaluationImplementation
        """
        this = _func.new_ComputedNumericalMathEvaluationImplementation(*args)
        try: self.this.append(this)
        except: self.this = this
    __swig_destroy__ = _func.delete_ComputedNumericalMathEvaluationImplementation
    __del__ = lambda self : None;
    def __eq__(self, *args):
        """__eq__(ComputedNumericalMathEvaluationImplementation self, ComputedNumericalMathEvaluationImplementation other) -> OT::Bool"""
        return _func.ComputedNumericalMathEvaluationImplementation___eq__(self, *args)

    def __repr__(self):
        """__repr__(ComputedNumericalMathEvaluationImplementation self) -> OT::String"""
        return _func.ComputedNumericalMathEvaluationImplementation___repr__(self)

    def __str__(self, offset=""):
        """
        __str__(ComputedNumericalMathEvaluationImplementation self, OT::String const & offset="") -> OT::String
        __str__(ComputedNumericalMathEvaluationImplementation self) -> OT::String
        """
        return _func.ComputedNumericalMathEvaluationImplementation___str__(self, offset)

    def __call__(self, *args):
        """
        __call__(ComputedNumericalMathEvaluationImplementation self, NumericalPoint inP) -> NumericalPoint
        __call__(ComputedNumericalMathEvaluationImplementation self, NumericalSample inS) -> NumericalSample
        """
        return _func.ComputedNumericalMathEvaluationImplementation___call__(self, *args)

    def getInputDimension(self):
        """getInputDimension(ComputedNumericalMathEvaluationImplementation self) -> OT::UnsignedLong"""
        return _func.ComputedNumericalMathEvaluationImplementation_getInputDimension(self)

    def getOutputDimension(self):
        """getOutputDimension(ComputedNumericalMathEvaluationImplementation self) -> OT::UnsignedLong"""
        return _func.ComputedNumericalMathEvaluationImplementation_getOutputDimension(self)

    def getDescription(self):
        """getDescription(ComputedNumericalMathEvaluationImplementation self) -> Description"""
        return _func.ComputedNumericalMathEvaluationImplementation_getDescription(self)

ComputedNumericalMathEvaluationImplementation_swigregister = _func.ComputedNumericalMathEvaluationImplementation_swigregister
ComputedNumericalMathEvaluationImplementation_swigregister(ComputedNumericalMathEvaluationImplementation)

def ComputedNumericalMathEvaluationImplementation_GetClassName():
  """ComputedNumericalMathEvaluationImplementation_GetClassName() -> OT::String"""
  return _func.ComputedNumericalMathEvaluationImplementation_GetClassName()

class ComputedNumericalMathGradientImplementation(NumericalMathGradientImplementation):
    """Proxy of C++ OT::ComputedNumericalMathGradientImplementation class"""
    __swig_setmethods__ = {}
    for _s in [NumericalMathGradientImplementation]: __swig_setmethods__.update(getattr(_s,'__swig_setmethods__',{}))
    __setattr__ = lambda self, name, value: _swig_setattr(self, ComputedNumericalMathGradientImplementation, name, value)
    __swig_getmethods__ = {}
    for _s in [NumericalMathGradientImplementation]: __swig_getmethods__.update(getattr(_s,'__swig_getmethods__',{}))
    __getattr__ = lambda self, name: _swig_getattr(self, ComputedNumericalMathGradientImplementation, name)
    def GetClassName():
        """GetClassName() -> OT::String"""
        return _func.ComputedNumericalMathGradientImplementation_GetClassName()

    if _newclass:GetClassName = staticmethod(GetClassName)
    __swig_getmethods__["GetClassName"] = lambda x: GetClassName
    def getClassName(self):
        """getClassName(ComputedNumericalMathGradientImplementation self) -> OT::String"""
        return _func.ComputedNumericalMathGradientImplementation_getClassName(self)

    def __init__(self, *args): 
        """
        __init__(OT::ComputedNumericalMathGradientImplementation self, OT::String const & name, WrapperFile file, void * p_state=None) -> ComputedNumericalMathGradientImplementation
        __init__(OT::ComputedNumericalMathGradientImplementation self, OT::String const & name, WrapperFile file) -> ComputedNumericalMathGradientImplementation
        __init__(OT::ComputedNumericalMathGradientImplementation self, ComputedNumericalMathGradientImplementation other) -> ComputedNumericalMathGradientImplementation
        """
        this = _func.new_ComputedNumericalMathGradientImplementation(*args)
        try: self.this.append(this)
        except: self.this = this
    __swig_destroy__ = _func.delete_ComputedNumericalMathGradientImplementation
    __del__ = lambda self : None;
    def __eq__(self, *args):
        """__eq__(ComputedNumericalMathGradientImplementation self, ComputedNumericalMathGradientImplementation other) -> OT::Bool"""
        return _func.ComputedNumericalMathGradientImplementation___eq__(self, *args)

    def __repr__(self):
        """__repr__(ComputedNumericalMathGradientImplementation self) -> OT::String"""
        return _func.ComputedNumericalMathGradientImplementation___repr__(self)

    def __str__(self, offset=""):
        """
        __str__(ComputedNumericalMathGradientImplementation self, OT::String const & offset="") -> OT::String
        __str__(ComputedNumericalMathGradientImplementation self) -> OT::String
        """
        return _func.ComputedNumericalMathGradientImplementation___str__(self, offset)

    def gradient(self, *args):
        """gradient(ComputedNumericalMathGradientImplementation self, NumericalPoint inP) -> Matrix"""
        return _func.ComputedNumericalMathGradientImplementation_gradient(self, *args)

    def getInputDimension(self):
        """getInputDimension(ComputedNumericalMathGradientImplementation self) -> OT::UnsignedLong"""
        return _func.ComputedNumericalMathGradientImplementation_getInputDimension(self)

    def getOutputDimension(self):
        """getOutputDimension(ComputedNumericalMathGradientImplementation self) -> OT::UnsignedLong"""
        return _func.ComputedNumericalMathGradientImplementation_getOutputDimension(self)

ComputedNumericalMathGradientImplementation_swigregister = _func.ComputedNumericalMathGradientImplementation_swigregister
ComputedNumericalMathGradientImplementation_swigregister(ComputedNumericalMathGradientImplementation)

def ComputedNumericalMathGradientImplementation_GetClassName():
  """ComputedNumericalMathGradientImplementation_GetClassName() -> OT::String"""
  return _func.ComputedNumericalMathGradientImplementation_GetClassName()

class ComputedNumericalMathHessianImplementation(NumericalMathHessianImplementation):
    """Proxy of C++ OT::ComputedNumericalMathHessianImplementation class"""
    __swig_setmethods__ = {}
    for _s in [NumericalMathHessianImplementation]: __swig_setmethods__.update(getattr(_s,'__swig_setmethods__',{}))
    __setattr__ = lambda self, name, value: _swig_setattr(self, ComputedNumericalMathHessianImplementation, name, value)
    __swig_getmethods__ = {}
    for _s in [NumericalMathHessianImplementation]: __swig_getmethods__.update(getattr(_s,'__swig_getmethods__',{}))
    __getattr__ = lambda self, name: _swig_getattr(self, ComputedNumericalMathHessianImplementation, name)
    def GetClassName():
        """GetClassName() -> OT::String"""
        return _func.ComputedNumericalMathHessianImplementation_GetClassName()

    if _newclass:GetClassName = staticmethod(GetClassName)
    __swig_getmethods__["GetClassName"] = lambda x: GetClassName
    def getClassName(self):
        """getClassName(ComputedNumericalMathHessianImplementation self) -> OT::String"""
        return _func.ComputedNumericalMathHessianImplementation_getClassName(self)

    def __init__(self, *args): 
        """
        __init__(OT::ComputedNumericalMathHessianImplementation self, OT::String const & name, WrapperFile file, void * p_state=None) -> ComputedNumericalMathHessianImplementation
        __init__(OT::ComputedNumericalMathHessianImplementation self, OT::String const & name, WrapperFile file) -> ComputedNumericalMathHessianImplementation
        __init__(OT::ComputedNumericalMathHessianImplementation self, ComputedNumericalMathHessianImplementation other) -> ComputedNumericalMathHessianImplementation
        """
        this = _func.new_ComputedNumericalMathHessianImplementation(*args)
        try: self.this.append(this)
        except: self.this = this
    __swig_destroy__ = _func.delete_ComputedNumericalMathHessianImplementation
    __del__ = lambda self : None;
    def __eq__(self, *args):
        """__eq__(ComputedNumericalMathHessianImplementation self, ComputedNumericalMathHessianImplementation other) -> OT::Bool"""
        return _func.ComputedNumericalMathHessianImplementation___eq__(self, *args)

    def __repr__(self):
        """__repr__(ComputedNumericalMathHessianImplementation self) -> OT::String"""
        return _func.ComputedNumericalMathHessianImplementation___repr__(self)

    def __str__(self, offset=""):
        """
        __str__(ComputedNumericalMathHessianImplementation self, OT::String const & offset="") -> OT::String
        __str__(ComputedNumericalMathHessianImplementation self) -> OT::String
        """
        return _func.ComputedNumericalMathHessianImplementation___str__(self, offset)

    def hessian(self, *args):
        """hessian(ComputedNumericalMathHessianImplementation self, NumericalPoint inP) -> SymmetricTensor"""
        return _func.ComputedNumericalMathHessianImplementation_hessian(self, *args)

    def getInputDimension(self):
        """getInputDimension(ComputedNumericalMathHessianImplementation self) -> OT::UnsignedLong"""
        return _func.ComputedNumericalMathHessianImplementation_getInputDimension(self)

    def getOutputDimension(self):
        """getOutputDimension(ComputedNumericalMathHessianImplementation self) -> OT::UnsignedLong"""
        return _func.ComputedNumericalMathHessianImplementation_getOutputDimension(self)

ComputedNumericalMathHessianImplementation_swigregister = _func.ComputedNumericalMathHessianImplementation_swigregister
ComputedNumericalMathHessianImplementation_swigregister(ComputedNumericalMathHessianImplementation)

def ComputedNumericalMathHessianImplementation_GetClassName():
  """ComputedNumericalMathHessianImplementation_GetClassName() -> OT::String"""
  return _func.ComputedNumericalMathHessianImplementation_GetClassName()

class ComposedNumericalMathEvaluationImplementation(NumericalMathEvaluationImplementation):
    """Proxy of C++ OT::ComposedNumericalMathEvaluationImplementation class"""
    __swig_setmethods__ = {}
    for _s in [NumericalMathEvaluationImplementation]: __swig_setmethods__.update(getattr(_s,'__swig_setmethods__',{}))
    __setattr__ = lambda self, name, value: _swig_setattr(self, ComposedNumericalMathEvaluationImplementation, name, value)
    __swig_getmethods__ = {}
    for _s in [NumericalMathEvaluationImplementation]: __swig_getmethods__.update(getattr(_s,'__swig_getmethods__',{}))
    __getattr__ = lambda self, name: _swig_getattr(self, ComposedNumericalMathEvaluationImplementation, name)
    def GetClassName():
        """GetClassName() -> OT::String"""
        return _func.ComposedNumericalMathEvaluationImplementation_GetClassName()

    if _newclass:GetClassName = staticmethod(GetClassName)
    __swig_getmethods__["GetClassName"] = lambda x: GetClassName
    def getClassName(self):
        """getClassName(ComposedNumericalMathEvaluationImplementation self) -> OT::String"""
        return _func.ComposedNumericalMathEvaluationImplementation_getClassName(self)

    def __eq__(self, *args):
        """__eq__(ComposedNumericalMathEvaluationImplementation self, ComposedNumericalMathEvaluationImplementation other) -> OT::Bool"""
        return _func.ComposedNumericalMathEvaluationImplementation___eq__(self, *args)

    def __repr__(self):
        """__repr__(ComposedNumericalMathEvaluationImplementation self) -> OT::String"""
        return _func.ComposedNumericalMathEvaluationImplementation___repr__(self)

    def __str__(self, offset=""):
        """
        __str__(ComposedNumericalMathEvaluationImplementation self, OT::String const & offset="") -> OT::String
        __str__(ComposedNumericalMathEvaluationImplementation self) -> OT::String
        """
        return _func.ComposedNumericalMathEvaluationImplementation___str__(self, offset)

    def __call__(self, *args):
        """
        __call__(ComposedNumericalMathEvaluationImplementation self, NumericalPoint inP) -> NumericalPoint
        __call__(ComposedNumericalMathEvaluationImplementation self, NumericalSample inS) -> NumericalSample
        """
        return _func.ComposedNumericalMathEvaluationImplementation___call__(self, *args)

    def getParameters(self):
        """getParameters(ComposedNumericalMathEvaluationImplementation self) -> NumericalPointWithDescription"""
        return _func.ComposedNumericalMathEvaluationImplementation_getParameters(self)

    def setParameters(self, *args):
        """setParameters(ComposedNumericalMathEvaluationImplementation self, NumericalPointWithDescription parameters)"""
        return _func.ComposedNumericalMathEvaluationImplementation_setParameters(self, *args)

    def getInputDimension(self):
        """getInputDimension(ComposedNumericalMathEvaluationImplementation self) -> OT::UnsignedLong"""
        return _func.ComposedNumericalMathEvaluationImplementation_getInputDimension(self)

    def getOutputDimension(self):
        """getOutputDimension(ComposedNumericalMathEvaluationImplementation self) -> OT::UnsignedLong"""
        return _func.ComposedNumericalMathEvaluationImplementation_getOutputDimension(self)

    def getMarginal(self, *args):
        """
        getMarginal(ComposedNumericalMathEvaluationImplementation self, OT::UnsignedLong const i) -> EvaluationImplementation
        getMarginal(ComposedNumericalMathEvaluationImplementation self, Indices indices) -> EvaluationImplementation
        """
        return _func.ComposedNumericalMathEvaluationImplementation_getMarginal(self, *args)

    def getLeftEvaluationImplementation(self):
        """getLeftEvaluationImplementation(ComposedNumericalMathEvaluationImplementation self) -> EvaluationImplementation"""
        return _func.ComposedNumericalMathEvaluationImplementation_getLeftEvaluationImplementation(self)

    def getRightEvaluationImplementation(self):
        """getRightEvaluationImplementation(ComposedNumericalMathEvaluationImplementation self) -> EvaluationImplementation"""
        return _func.ComposedNumericalMathEvaluationImplementation_getRightEvaluationImplementation(self)

    def __init__(self, *args): 
        """
        __init__(OT::ComposedNumericalMathEvaluationImplementation self, EvaluationImplementation p_leftFunction, EvaluationImplementation p_rightFunction) -> ComposedNumericalMathEvaluationImplementation
        __init__(OT::ComposedNumericalMathEvaluationImplementation self, ComposedNumericalMathEvaluationImplementation other) -> ComposedNumericalMathEvaluationImplementation
        """
        this = _func.new_ComposedNumericalMathEvaluationImplementation(*args)
        try: self.this.append(this)
        except: self.this = this
    __swig_destroy__ = _func.delete_ComposedNumericalMathEvaluationImplementation
    __del__ = lambda self : None;
ComposedNumericalMathEvaluationImplementation_swigregister = _func.ComposedNumericalMathEvaluationImplementation_swigregister
ComposedNumericalMathEvaluationImplementation_swigregister(ComposedNumericalMathEvaluationImplementation)

def ComposedNumericalMathEvaluationImplementation_GetClassName():
  """ComposedNumericalMathEvaluationImplementation_GetClassName() -> OT::String"""
  return _func.ComposedNumericalMathEvaluationImplementation_GetClassName()

class ComposedNumericalMathGradientImplementation(NumericalMathGradientImplementation):
    """Proxy of C++ OT::ComposedNumericalMathGradientImplementation class"""
    __swig_setmethods__ = {}
    for _s in [NumericalMathGradientImplementation]: __swig_setmethods__.update(getattr(_s,'__swig_setmethods__',{}))
    __setattr__ = lambda self, name, value: _swig_setattr(self, ComposedNumericalMathGradientImplementation, name, value)
    __swig_getmethods__ = {}
    for _s in [NumericalMathGradientImplementation]: __swig_getmethods__.update(getattr(_s,'__swig_getmethods__',{}))
    __getattr__ = lambda self, name: _swig_getattr(self, ComposedNumericalMathGradientImplementation, name)
    def GetClassName():
        """GetClassName() -> OT::String"""
        return _func.ComposedNumericalMathGradientImplementation_GetClassName()

    if _newclass:GetClassName = staticmethod(GetClassName)
    __swig_getmethods__["GetClassName"] = lambda x: GetClassName
    def getClassName(self):
        """getClassName(ComposedNumericalMathGradientImplementation self) -> OT::String"""
        return _func.ComposedNumericalMathGradientImplementation_getClassName(self)

    def __eq__(self, *args):
        """__eq__(ComposedNumericalMathGradientImplementation self, ComposedNumericalMathGradientImplementation other) -> OT::Bool"""
        return _func.ComposedNumericalMathGradientImplementation___eq__(self, *args)

    def __repr__(self):
        """__repr__(ComposedNumericalMathGradientImplementation self) -> OT::String"""
        return _func.ComposedNumericalMathGradientImplementation___repr__(self)

    def gradient(self, *args):
        """gradient(ComposedNumericalMathGradientImplementation self, NumericalPoint inP) -> Matrix"""
        return _func.ComposedNumericalMathGradientImplementation_gradient(self, *args)

    def getInputDimension(self):
        """getInputDimension(ComposedNumericalMathGradientImplementation self) -> OT::UnsignedLong"""
        return _func.ComposedNumericalMathGradientImplementation_getInputDimension(self)

    def getOutputDimension(self):
        """getOutputDimension(ComposedNumericalMathGradientImplementation self) -> OT::UnsignedLong"""
        return _func.ComposedNumericalMathGradientImplementation_getOutputDimension(self)

    def __init__(self, *args): 
        """
        __init__(OT::ComposedNumericalMathGradientImplementation self, GradientImplementation p_leftGradient, EvaluationImplementation p_rightFunction, 
            GradientImplementation p_rightGradient) -> ComposedNumericalMathGradientImplementation
        __init__(OT::ComposedNumericalMathGradientImplementation self, ComposedNumericalMathGradientImplementation other) -> ComposedNumericalMathGradientImplementation
        """
        this = _func.new_ComposedNumericalMathGradientImplementation(*args)
        try: self.this.append(this)
        except: self.this = this
    __swig_destroy__ = _func.delete_ComposedNumericalMathGradientImplementation
    __del__ = lambda self : None;
ComposedNumericalMathGradientImplementation_swigregister = _func.ComposedNumericalMathGradientImplementation_swigregister
ComposedNumericalMathGradientImplementation_swigregister(ComposedNumericalMathGradientImplementation)

def ComposedNumericalMathGradientImplementation_GetClassName():
  """ComposedNumericalMathGradientImplementation_GetClassName() -> OT::String"""
  return _func.ComposedNumericalMathGradientImplementation_GetClassName()

class ComposedNumericalMathHessianImplementation(NumericalMathHessianImplementation):
    """Proxy of C++ OT::ComposedNumericalMathHessianImplementation class"""
    __swig_setmethods__ = {}
    for _s in [NumericalMathHessianImplementation]: __swig_setmethods__.update(getattr(_s,'__swig_setmethods__',{}))
    __setattr__ = lambda self, name, value: _swig_setattr(self, ComposedNumericalMathHessianImplementation, name, value)
    __swig_getmethods__ = {}
    for _s in [NumericalMathHessianImplementation]: __swig_getmethods__.update(getattr(_s,'__swig_getmethods__',{}))
    __getattr__ = lambda self, name: _swig_getattr(self, ComposedNumericalMathHessianImplementation, name)
    def GetClassName():
        """GetClassName() -> OT::String"""
        return _func.ComposedNumericalMathHessianImplementation_GetClassName()

    if _newclass:GetClassName = staticmethod(GetClassName)
    __swig_getmethods__["GetClassName"] = lambda x: GetClassName
    def getClassName(self):
        """getClassName(ComposedNumericalMathHessianImplementation self) -> OT::String"""
        return _func.ComposedNumericalMathHessianImplementation_getClassName(self)

    def __eq__(self, *args):
        """__eq__(ComposedNumericalMathHessianImplementation self, ComposedNumericalMathHessianImplementation other) -> OT::Bool"""
        return _func.ComposedNumericalMathHessianImplementation___eq__(self, *args)

    def __repr__(self):
        """__repr__(ComposedNumericalMathHessianImplementation self) -> OT::String"""
        return _func.ComposedNumericalMathHessianImplementation___repr__(self)

    def hessian(self, *args):
        """hessian(ComposedNumericalMathHessianImplementation self, NumericalPoint inP) -> SymmetricTensor"""
        return _func.ComposedNumericalMathHessianImplementation_hessian(self, *args)

    def getInputDimension(self):
        """getInputDimension(ComposedNumericalMathHessianImplementation self) -> OT::UnsignedLong"""
        return _func.ComposedNumericalMathHessianImplementation_getInputDimension(self)

    def getOutputDimension(self):
        """getOutputDimension(ComposedNumericalMathHessianImplementation self) -> OT::UnsignedLong"""
        return _func.ComposedNumericalMathHessianImplementation_getOutputDimension(self)

    def __init__(self, *args): 
        """
        __init__(OT::ComposedNumericalMathHessianImplementation self, GradientImplementation p_leftGradient, HessianImplementation p_leftHessian, EvaluationImplementation p_rightFunction, 
            GradientImplementation p_rightGradient, 
            HessianImplementation p_rightHessian) -> ComposedNumericalMathHessianImplementation
        __init__(OT::ComposedNumericalMathHessianImplementation self, ComposedNumericalMathHessianImplementation other) -> ComposedNumericalMathHessianImplementation
        """
        this = _func.new_ComposedNumericalMathHessianImplementation(*args)
        try: self.this.append(this)
        except: self.this = this
    __swig_destroy__ = _func.delete_ComposedNumericalMathHessianImplementation
    __del__ = lambda self : None;
ComposedNumericalMathHessianImplementation_swigregister = _func.ComposedNumericalMathHessianImplementation_swigregister
ComposedNumericalMathHessianImplementation_swigregister(ComposedNumericalMathHessianImplementation)

def ComposedNumericalMathHessianImplementation_GetClassName():
  """ComposedNumericalMathHessianImplementation_GetClassName() -> OT::String"""
  return _func.ComposedNumericalMathHessianImplementation_GetClassName()

class ProductNumericalMathEvaluationImplementation(NumericalMathEvaluationImplementation):
    """Proxy of C++ OT::ProductNumericalMathEvaluationImplementation class"""
    __swig_setmethods__ = {}
    for _s in [NumericalMathEvaluationImplementation]: __swig_setmethods__.update(getattr(_s,'__swig_setmethods__',{}))
    __setattr__ = lambda self, name, value: _swig_setattr(self, ProductNumericalMathEvaluationImplementation, name, value)
    __swig_getmethods__ = {}
    for _s in [NumericalMathEvaluationImplementation]: __swig_getmethods__.update(getattr(_s,'__swig_getmethods__',{}))
    __getattr__ = lambda self, name: _swig_getattr(self, ProductNumericalMathEvaluationImplementation, name)
    def GetClassName():
        """GetClassName() -> OT::String"""
        return _func.ProductNumericalMathEvaluationImplementation_GetClassName()

    if _newclass:GetClassName = staticmethod(GetClassName)
    __swig_getmethods__["GetClassName"] = lambda x: GetClassName
    def getClassName(self):
        """getClassName(ProductNumericalMathEvaluationImplementation self) -> OT::String"""
        return _func.ProductNumericalMathEvaluationImplementation_getClassName(self)

    def __eq__(self, *args):
        """__eq__(ProductNumericalMathEvaluationImplementation self, ProductNumericalMathEvaluationImplementation other) -> OT::Bool"""
        return _func.ProductNumericalMathEvaluationImplementation___eq__(self, *args)

    def __repr__(self):
        """__repr__(ProductNumericalMathEvaluationImplementation self) -> OT::String"""
        return _func.ProductNumericalMathEvaluationImplementation___repr__(self)

    def __str__(self, offset=""):
        """
        __str__(ProductNumericalMathEvaluationImplementation self, OT::String const & offset="") -> OT::String
        __str__(ProductNumericalMathEvaluationImplementation self) -> OT::String
        """
        return _func.ProductNumericalMathEvaluationImplementation___str__(self, offset)

    def __call__(self, *args):
        """
        __call__(ProductNumericalMathEvaluationImplementation self, NumericalPoint inP) -> NumericalPoint
        __call__(ProductNumericalMathEvaluationImplementation self, NumericalSample inS) -> NumericalSample
        """
        return _func.ProductNumericalMathEvaluationImplementation___call__(self, *args)

    def getParameters(self):
        """getParameters(ProductNumericalMathEvaluationImplementation self) -> NumericalPointWithDescription"""
        return _func.ProductNumericalMathEvaluationImplementation_getParameters(self)

    def setParameters(self, *args):
        """setParameters(ProductNumericalMathEvaluationImplementation self, NumericalPointWithDescription parameters)"""
        return _func.ProductNumericalMathEvaluationImplementation_setParameters(self, *args)

    def getInputDimension(self):
        """getInputDimension(ProductNumericalMathEvaluationImplementation self) -> OT::UnsignedLong"""
        return _func.ProductNumericalMathEvaluationImplementation_getInputDimension(self)

    def getOutputDimension(self):
        """getOutputDimension(ProductNumericalMathEvaluationImplementation self) -> OT::UnsignedLong"""
        return _func.ProductNumericalMathEvaluationImplementation_getOutputDimension(self)

    def __init__(self, *args): 
        """
        __init__(OT::ProductNumericalMathEvaluationImplementation self, EvaluationImplementation p_leftEvaluation, EvaluationImplementation p_rightEvaluation) -> ProductNumericalMathEvaluationImplementation
        __init__(OT::ProductNumericalMathEvaluationImplementation self, ProductNumericalMathEvaluationImplementation other) -> ProductNumericalMathEvaluationImplementation
        """
        this = _func.new_ProductNumericalMathEvaluationImplementation(*args)
        try: self.this.append(this)
        except: self.this = this
    __swig_destroy__ = _func.delete_ProductNumericalMathEvaluationImplementation
    __del__ = lambda self : None;
ProductNumericalMathEvaluationImplementation_swigregister = _func.ProductNumericalMathEvaluationImplementation_swigregister
ProductNumericalMathEvaluationImplementation_swigregister(ProductNumericalMathEvaluationImplementation)

def ProductNumericalMathEvaluationImplementation_GetClassName():
  """ProductNumericalMathEvaluationImplementation_GetClassName() -> OT::String"""
  return _func.ProductNumericalMathEvaluationImplementation_GetClassName()

class ProductNumericalMathGradientImplementation(NumericalMathGradientImplementation):
    """Proxy of C++ OT::ProductNumericalMathGradientImplementation class"""
    __swig_setmethods__ = {}
    for _s in [NumericalMathGradientImplementation]: __swig_setmethods__.update(getattr(_s,'__swig_setmethods__',{}))
    __setattr__ = lambda self, name, value: _swig_setattr(self, ProductNumericalMathGradientImplementation, name, value)
    __swig_getmethods__ = {}
    for _s in [NumericalMathGradientImplementation]: __swig_getmethods__.update(getattr(_s,'__swig_getmethods__',{}))
    __getattr__ = lambda self, name: _swig_getattr(self, ProductNumericalMathGradientImplementation, name)
    def GetClassName():
        """GetClassName() -> OT::String"""
        return _func.ProductNumericalMathGradientImplementation_GetClassName()

    if _newclass:GetClassName = staticmethod(GetClassName)
    __swig_getmethods__["GetClassName"] = lambda x: GetClassName
    def getClassName(self):
        """getClassName(ProductNumericalMathGradientImplementation self) -> OT::String"""
        return _func.ProductNumericalMathGradientImplementation_getClassName(self)

    def __eq__(self, *args):
        """__eq__(ProductNumericalMathGradientImplementation self, ProductNumericalMathGradientImplementation other) -> OT::Bool"""
        return _func.ProductNumericalMathGradientImplementation___eq__(self, *args)

    def __repr__(self):
        """__repr__(ProductNumericalMathGradientImplementation self) -> OT::String"""
        return _func.ProductNumericalMathGradientImplementation___repr__(self)

    def gradient(self, *args):
        """gradient(ProductNumericalMathGradientImplementation self, NumericalPoint inP) -> Matrix"""
        return _func.ProductNumericalMathGradientImplementation_gradient(self, *args)

    def getInputDimension(self):
        """getInputDimension(ProductNumericalMathGradientImplementation self) -> OT::UnsignedLong"""
        return _func.ProductNumericalMathGradientImplementation_getInputDimension(self)

    def getOutputDimension(self):
        """getOutputDimension(ProductNumericalMathGradientImplementation self) -> OT::UnsignedLong"""
        return _func.ProductNumericalMathGradientImplementation_getOutputDimension(self)

    def __init__(self, *args): 
        """
        __init__(OT::ProductNumericalMathGradientImplementation self, EvaluationImplementation p_leftEvaluation, GradientImplementation p_leftGradient, 
            EvaluationImplementation p_rightEvaluation, GradientImplementation p_rightGradient) -> ProductNumericalMathGradientImplementation
        __init__(OT::ProductNumericalMathGradientImplementation self, ProductNumericalMathGradientImplementation other) -> ProductNumericalMathGradientImplementation
        """
        this = _func.new_ProductNumericalMathGradientImplementation(*args)
        try: self.this.append(this)
        except: self.this = this
    __swig_destroy__ = _func.delete_ProductNumericalMathGradientImplementation
    __del__ = lambda self : None;
ProductNumericalMathGradientImplementation_swigregister = _func.ProductNumericalMathGradientImplementation_swigregister
ProductNumericalMathGradientImplementation_swigregister(ProductNumericalMathGradientImplementation)

def ProductNumericalMathGradientImplementation_GetClassName():
  """ProductNumericalMathGradientImplementation_GetClassName() -> OT::String"""
  return _func.ProductNumericalMathGradientImplementation_GetClassName()

class ProductNumericalMathHessianImplementation(NumericalMathHessianImplementation):
    """Proxy of C++ OT::ProductNumericalMathHessianImplementation class"""
    __swig_setmethods__ = {}
    for _s in [NumericalMathHessianImplementation]: __swig_setmethods__.update(getattr(_s,'__swig_setmethods__',{}))
    __setattr__ = lambda self, name, value: _swig_setattr(self, ProductNumericalMathHessianImplementation, name, value)
    __swig_getmethods__ = {}
    for _s in [NumericalMathHessianImplementation]: __swig_getmethods__.update(getattr(_s,'__swig_getmethods__',{}))
    __getattr__ = lambda self, name: _swig_getattr(self, ProductNumericalMathHessianImplementation, name)
    def GetClassName():
        """GetClassName() -> OT::String"""
        return _func.ProductNumericalMathHessianImplementation_GetClassName()

    if _newclass:GetClassName = staticmethod(GetClassName)
    __swig_getmethods__["GetClassName"] = lambda x: GetClassName
    def getClassName(self):
        """getClassName(ProductNumericalMathHessianImplementation self) -> OT::String"""
        return _func.ProductNumericalMathHessianImplementation_getClassName(self)

    def __eq__(self, *args):
        """__eq__(ProductNumericalMathHessianImplementation self, ProductNumericalMathHessianImplementation other) -> OT::Bool"""
        return _func.ProductNumericalMathHessianImplementation___eq__(self, *args)

    def __repr__(self):
        """__repr__(ProductNumericalMathHessianImplementation self) -> OT::String"""
        return _func.ProductNumericalMathHessianImplementation___repr__(self)

    def hessian(self, *args):
        """hessian(ProductNumericalMathHessianImplementation self, NumericalPoint inP) -> SymmetricTensor"""
        return _func.ProductNumericalMathHessianImplementation_hessian(self, *args)

    def getInputDimension(self):
        """getInputDimension(ProductNumericalMathHessianImplementation self) -> OT::UnsignedLong"""
        return _func.ProductNumericalMathHessianImplementation_getInputDimension(self)

    def getOutputDimension(self):
        """getOutputDimension(ProductNumericalMathHessianImplementation self) -> OT::UnsignedLong"""
        return _func.ProductNumericalMathHessianImplementation_getOutputDimension(self)

    def __init__(self, *args): 
        """
        __init__(OT::ProductNumericalMathHessianImplementation self, EvaluationImplementation p_leftEvaluation, GradientImplementation p_leftGradient, 
            HessianImplementation p_leftHessian, EvaluationImplementation p_rightEvaluation, 
            GradientImplementation p_rightGradient, HessianImplementation p_rightHessian) -> ProductNumericalMathHessianImplementation
        __init__(OT::ProductNumericalMathHessianImplementation self, ProductNumericalMathHessianImplementation other) -> ProductNumericalMathHessianImplementation
        """
        this = _func.new_ProductNumericalMathHessianImplementation(*args)
        try: self.this.append(this)
        except: self.this = this
    __swig_destroy__ = _func.delete_ProductNumericalMathHessianImplementation
    __del__ = lambda self : None;
ProductNumericalMathHessianImplementation_swigregister = _func.ProductNumericalMathHessianImplementation_swigregister
ProductNumericalMathHessianImplementation_swigregister(ProductNumericalMathHessianImplementation)

def ProductNumericalMathHessianImplementation_GetClassName():
  """ProductNumericalMathHessianImplementation_GetClassName() -> OT::String"""
  return _func.ProductNumericalMathHessianImplementation_GetClassName()

class EvaluationImplementation(_object):
    """Proxy of C++ OT::Pointer<(OT::NumericalMathEvaluationImplementation)> class"""
    __swig_setmethods__ = {}
    __setattr__ = lambda self, name, value: _swig_setattr(self, EvaluationImplementation, name, value)
    __swig_getmethods__ = {}
    __getattr__ = lambda self, name: _swig_getattr(self, EvaluationImplementation, name)
    __swig_setmethods__["ptr_"] = _func.EvaluationImplementation_ptr__set
    __swig_getmethods__["ptr_"] = _func.EvaluationImplementation_ptr__get
    if _newclass:ptr_ = _swig_property(_func.EvaluationImplementation_ptr__get, _func.EvaluationImplementation_ptr__set)
    def __init__(self, *args): 
        """
        __init__(OT::Pointer<(OT::NumericalMathEvaluationImplementation)> self) -> EvaluationImplementation
        __init__(OT::Pointer<(OT::NumericalMathEvaluationImplementation)> self, NumericalMathEvaluationImplementation ptr) -> EvaluationImplementation
        """
        this = _func.new_EvaluationImplementation(*args)
        try: self.this.append(this)
        except: self.this = this
    __swig_destroy__ = _func.delete_EvaluationImplementation
    __del__ = lambda self : None;
    def reset(self):
        """reset(EvaluationImplementation self)"""
        return _func.EvaluationImplementation_reset(self)

    def __ref__(self, *args):
        """
        __ref__(EvaluationImplementation self) -> NumericalMathEvaluationImplementation
        __ref__(EvaluationImplementation self) -> NumericalMathEvaluationImplementation
        """
        return _func.EvaluationImplementation___ref__(self, *args)

    def __deref__(self):
        """__deref__(EvaluationImplementation self) -> NumericalMathEvaluationImplementation"""
        return _func.EvaluationImplementation___deref__(self)

    def isNull(self):
        """isNull(EvaluationImplementation self) -> OT::Bool"""
        return _func.EvaluationImplementation_isNull(self)

    def __nonzero__(self):
        return _func.EvaluationImplementation___nonzero__(self)
    __bool__ = __nonzero__


    def get(self):
        """get(EvaluationImplementation self) -> NumericalMathEvaluationImplementation"""
        return _func.EvaluationImplementation_get(self)

    def getImplementation(self):
        """getImplementation(EvaluationImplementation self) -> OT::Pointer< OT::NumericalMathEvaluationImplementation >::pointer_type const &"""
        return _func.EvaluationImplementation_getImplementation(self)

    def unique(self):
        """unique(EvaluationImplementation self) -> OT::Bool"""
        return _func.EvaluationImplementation_unique(self)

    def use_count(self):
        """use_count(EvaluationImplementation self) -> OT::UnsignedLong"""
        return _func.EvaluationImplementation_use_count(self)

    def swap(self, *args):
        """swap(EvaluationImplementation self, EvaluationImplementation other)"""
        return _func.EvaluationImplementation_swap(self, *args)

    def GetClassName(self):
        """GetClassName(EvaluationImplementation self) -> OT::String"""
        return _func.EvaluationImplementation_GetClassName(self)

    def getClassName(self):
        """getClassName(EvaluationImplementation self) -> OT::String"""
        return _func.EvaluationImplementation_getClassName(self)

    def __eq__(self, *args):
        """__eq__(EvaluationImplementation self, NumericalMathEvaluationImplementation other) -> OT::Bool"""
        return _func.EvaluationImplementation___eq__(self, *args)

    def __repr__(self):
        """__repr__(EvaluationImplementation self) -> OT::String"""
        return _func.EvaluationImplementation___repr__(self)

    def __str__(self, offset=""):
        """
        __str__(EvaluationImplementation self, OT::String const & offset="") -> OT::String
        __str__(EvaluationImplementation self) -> OT::String
        """
        return _func.EvaluationImplementation___str__(self, offset)

    def setDescription(self, *args):
        """setDescription(EvaluationImplementation self, Description description)"""
        return _func.EvaluationImplementation_setDescription(self, *args)

    def getDescription(self):
        """getDescription(EvaluationImplementation self) -> Description"""
        return _func.EvaluationImplementation_getDescription(self)

    def getInputDescription(self):
        """getInputDescription(EvaluationImplementation self) -> Description"""
        return _func.EvaluationImplementation_getInputDescription(self)

    def setInputDescription(self, *args):
        """setInputDescription(EvaluationImplementation self, Description inputDescription)"""
        return _func.EvaluationImplementation_setInputDescription(self, *args)

    def getOutputDescription(self):
        """getOutputDescription(EvaluationImplementation self) -> Description"""
        return _func.EvaluationImplementation_getOutputDescription(self)

    def setOutputDescription(self, *args):
        """setOutputDescription(EvaluationImplementation self, Description outputDescription)"""
        return _func.EvaluationImplementation_setOutputDescription(self, *args)

    def enableHistory(self):
        """enableHistory(EvaluationImplementation self)"""
        return _func.EvaluationImplementation_enableHistory(self)

    def disableHistory(self):
        """disableHistory(EvaluationImplementation self)"""
        return _func.EvaluationImplementation_disableHistory(self)

    def isHistoryEnabled(self):
        """isHistoryEnabled(EvaluationImplementation self) -> OT::Bool"""
        return _func.EvaluationImplementation_isHistoryEnabled(self)

    def clearHistory(self):
        """clearHistory(EvaluationImplementation self)"""
        return _func.EvaluationImplementation_clearHistory(self)

    def getInputHistory(self):
        """getInputHistory(EvaluationImplementation self) -> HistoryStrategy"""
        return _func.EvaluationImplementation_getInputHistory(self)

    def getOutputHistory(self):
        """getOutputHistory(EvaluationImplementation self) -> HistoryStrategy"""
        return _func.EvaluationImplementation_getOutputHistory(self)

    def enableCache(self):
        """enableCache(EvaluationImplementation self)"""
        return _func.EvaluationImplementation_enableCache(self)

    def disableCache(self):
        """disableCache(EvaluationImplementation self)"""
        return _func.EvaluationImplementation_disableCache(self)

    def isCacheEnabled(self):
        """isCacheEnabled(EvaluationImplementation self) -> OT::Bool"""
        return _func.EvaluationImplementation_isCacheEnabled(self)

    def getCacheHits(self):
        """getCacheHits(EvaluationImplementation self) -> OT::UnsignedLong"""
        return _func.EvaluationImplementation_getCacheHits(self)

    def addCacheContent(self, *args):
        """addCacheContent(EvaluationImplementation self, NumericalSample inSample, NumericalSample outSample)"""
        return _func.EvaluationImplementation_addCacheContent(self, *args)

    def getCacheInput(self):
        """getCacheInput(EvaluationImplementation self) -> NumericalSample"""
        return _func.EvaluationImplementation_getCacheInput(self)

    def getCacheOutput(self):
        """getCacheOutput(EvaluationImplementation self) -> NumericalSample"""
        return _func.EvaluationImplementation_getCacheOutput(self)

    def clearCache(self):
        """clearCache(EvaluationImplementation self)"""
        return _func.EvaluationImplementation_clearCache(self)

    def isActualImplementation(self):
        """isActualImplementation(EvaluationImplementation self) -> OT::Bool"""
        return _func.EvaluationImplementation_isActualImplementation(self)

    def __call__(self, *args):
        """
        __call__(EvaluationImplementation self, NumericalPoint inP) -> NumericalPoint
        __call__(EvaluationImplementation self, NumericalSample inSample) -> NumericalSample
        __call__(EvaluationImplementation self, TimeSeries inTimeSeries) -> TimeSeries
        """
        return _func.EvaluationImplementation___call__(self, *args)

    def getInputDimension(self):
        """getInputDimension(EvaluationImplementation self) -> OT::UnsignedLong"""
        return _func.EvaluationImplementation_getInputDimension(self)

    def getOutputDimension(self):
        """getOutputDimension(EvaluationImplementation self) -> OT::UnsignedLong"""
        return _func.EvaluationImplementation_getOutputDimension(self)

    def getMarginal(self, *args):
        """
        getMarginal(EvaluationImplementation self, OT::UnsignedLong const i) -> EvaluationImplementation
        getMarginal(EvaluationImplementation self, Indices indices) -> EvaluationImplementation
        """
        return _func.EvaluationImplementation_getMarginal(self, *args)

    def parametersGradient(self, *args):
        """parametersGradient(EvaluationImplementation self, NumericalPoint inP) -> Matrix"""
        return _func.EvaluationImplementation_parametersGradient(self, *args)

    def getParameters(self):
        """getParameters(EvaluationImplementation self) -> NumericalPointWithDescription"""
        return _func.EvaluationImplementation_getParameters(self)

    def setParameters(self, *args):
        """setParameters(EvaluationImplementation self, NumericalPointWithDescription parameters)"""
        return _func.EvaluationImplementation_setParameters(self, *args)

    def getCallsNumber(self):
        """getCallsNumber(EvaluationImplementation self) -> OT::UnsignedLong"""
        return _func.EvaluationImplementation_getCallsNumber(self)

    def draw(self, *args):
        """
        draw(EvaluationImplementation self, OT::UnsignedLong const inputMarginal, OT::UnsignedLong const outputMarginal, NumericalPoint centralPoint, 
            OT::NumericalScalar const xMin, OT::NumericalScalar const xMax, 
            OT::UnsignedLong const pointNumber=OT::ResourceMap::GetAsUnsignedLong("NumericalMathEvaluationImplementation-DefaultPointNumber")) -> Graph
        draw(EvaluationImplementation self, OT::UnsignedLong const inputMarginal, OT::UnsignedLong const outputMarginal, NumericalPoint centralPoint, 
            OT::NumericalScalar const xMin, OT::NumericalScalar const xMax) -> Graph
        draw(EvaluationImplementation self, OT::UnsignedLong const firstInputMarginal, OT::UnsignedLong const secondInputMarginal, 
            OT::UnsignedLong const outputMarginal, NumericalPoint centralPoint, NumericalPoint xMin, 
            NumericalPoint xMax, Indices pointNumber=OT::Indices(2, ResourceMap::GetAsUnsignedLong("NumericalMathEvaluationImplementation-DefaultPointNumber"))) -> Graph
        draw(EvaluationImplementation self, OT::UnsignedLong const firstInputMarginal, OT::UnsignedLong const secondInputMarginal, 
            OT::UnsignedLong const outputMarginal, NumericalPoint centralPoint, NumericalPoint xMin, 
            NumericalPoint xMax) -> Graph
        draw(EvaluationImplementation self, OT::NumericalScalar const xMin, OT::NumericalScalar const xMax, OT::UnsignedLong const pointNumber=OT::ResourceMap::GetAsUnsignedLong("NumericalMathEvaluationImplementation-DefaultPointNumber")) -> Graph
        draw(EvaluationImplementation self, OT::NumericalScalar const xMin, OT::NumericalScalar const xMax) -> Graph
        draw(EvaluationImplementation self, NumericalPoint xMin, NumericalPoint xMax, Indices pointNumber=OT::Indices(2, ResourceMap::GetAsUnsignedLong("NumericalMathEvaluationImplementation-DefaultPointNumber"))) -> Graph
        draw(EvaluationImplementation self, NumericalPoint xMin, NumericalPoint xMax) -> Graph
        """
        return _func.EvaluationImplementation_draw(self, *args)

    def Is(self, *args):
        """Is(EvaluationImplementation self, PersistentObject other) -> OT::Bool"""
        return _func.EvaluationImplementation_Is(self, *args)

    def getId(self):
        """getId(EvaluationImplementation self) -> OT::Id"""
        return _func.EvaluationImplementation_getId(self)

    def setShadowedId(self, *args):
        """setShadowedId(EvaluationImplementation self, OT::Id id)"""
        return _func.EvaluationImplementation_setShadowedId(self, *args)

    def getShadowedId(self):
        """getShadowedId(EvaluationImplementation self) -> OT::Id"""
        return _func.EvaluationImplementation_getShadowedId(self)

    def setVisibility(self, *args):
        """setVisibility(EvaluationImplementation self, OT::Bool visible)"""
        return _func.EvaluationImplementation_setVisibility(self, *args)

    def getVisibility(self):
        """getVisibility(EvaluationImplementation self) -> OT::Bool"""
        return _func.EvaluationImplementation_getVisibility(self)

    def hasName(self):
        """hasName(EvaluationImplementation self) -> OT::Bool"""
        return _func.EvaluationImplementation_hasName(self)

    def hasVisibleName(self):
        """hasVisibleName(EvaluationImplementation self) -> OT::Bool"""
        return _func.EvaluationImplementation_hasVisibleName(self)

    def getName(self):
        """getName(EvaluationImplementation self) -> OT::String"""
        return _func.EvaluationImplementation_getName(self)

    def setName(self, *args):
        """setName(EvaluationImplementation self, OT::String const & name)"""
        return _func.EvaluationImplementation_setName(self, *args)

EvaluationImplementation_swigregister = _func.EvaluationImplementation_swigregister
EvaluationImplementation_swigregister(EvaluationImplementation)

class GradientImplementation(_object):
    """Proxy of C++ OT::Pointer<(OT::NumericalMathGradientImplementation)> class"""
    __swig_setmethods__ = {}
    __setattr__ = lambda self, name, value: _swig_setattr(self, GradientImplementation, name, value)
    __swig_getmethods__ = {}
    __getattr__ = lambda self, name: _swig_getattr(self, GradientImplementation, name)
    __swig_setmethods__["ptr_"] = _func.GradientImplementation_ptr__set
    __swig_getmethods__["ptr_"] = _func.GradientImplementation_ptr__get
    if _newclass:ptr_ = _swig_property(_func.GradientImplementation_ptr__get, _func.GradientImplementation_ptr__set)
    def __init__(self, *args): 
        """
        __init__(OT::Pointer<(OT::NumericalMathGradientImplementation)> self) -> GradientImplementation
        __init__(OT::Pointer<(OT::NumericalMathGradientImplementation)> self, NumericalMathGradientImplementation ptr) -> GradientImplementation
        """
        this = _func.new_GradientImplementation(*args)
        try: self.this.append(this)
        except: self.this = this
    __swig_destroy__ = _func.delete_GradientImplementation
    __del__ = lambda self : None;
    def reset(self):
        """reset(GradientImplementation self)"""
        return _func.GradientImplementation_reset(self)

    def __ref__(self, *args):
        """
        __ref__(GradientImplementation self) -> NumericalMathGradientImplementation
        __ref__(GradientImplementation self) -> NumericalMathGradientImplementation
        """
        return _func.GradientImplementation___ref__(self, *args)

    def __deref__(self):
        """__deref__(GradientImplementation self) -> NumericalMathGradientImplementation"""
        return _func.GradientImplementation___deref__(self)

    def isNull(self):
        """isNull(GradientImplementation self) -> OT::Bool"""
        return _func.GradientImplementation_isNull(self)

    def __nonzero__(self):
        return _func.GradientImplementation___nonzero__(self)
    __bool__ = __nonzero__


    def get(self):
        """get(GradientImplementation self) -> NumericalMathGradientImplementation"""
        return _func.GradientImplementation_get(self)

    def getImplementation(self):
        """getImplementation(GradientImplementation self) -> OT::Pointer< OT::NumericalMathGradientImplementation >::pointer_type const &"""
        return _func.GradientImplementation_getImplementation(self)

    def unique(self):
        """unique(GradientImplementation self) -> OT::Bool"""
        return _func.GradientImplementation_unique(self)

    def use_count(self):
        """use_count(GradientImplementation self) -> OT::UnsignedLong"""
        return _func.GradientImplementation_use_count(self)

    def swap(self, *args):
        """swap(GradientImplementation self, GradientImplementation other)"""
        return _func.GradientImplementation_swap(self, *args)

    def GetClassName(self):
        """GetClassName(GradientImplementation self) -> OT::String"""
        return _func.GradientImplementation_GetClassName(self)

    def getClassName(self):
        """getClassName(GradientImplementation self) -> OT::String"""
        return _func.GradientImplementation_getClassName(self)

    def __eq__(self, *args):
        """__eq__(GradientImplementation self, NumericalMathGradientImplementation other) -> OT::Bool"""
        return _func.GradientImplementation___eq__(self, *args)

    def __repr__(self):
        """__repr__(GradientImplementation self) -> OT::String"""
        return _func.GradientImplementation___repr__(self)

    def __str__(self, offset=""):
        """
        __str__(GradientImplementation self, OT::String const & offset="") -> OT::String
        __str__(GradientImplementation self) -> OT::String
        """
        return _func.GradientImplementation___str__(self, offset)

    def setDescription(self, *args):
        """setDescription(GradientImplementation self, Description description)"""
        return _func.GradientImplementation_setDescription(self, *args)

    def getDescription(self):
        """getDescription(GradientImplementation self) -> Description"""
        return _func.GradientImplementation_getDescription(self)

    def getMarginal(self, *args):
        """
        getMarginal(GradientImplementation self, OT::UnsignedLong const i) -> GradientImplementation
        getMarginal(GradientImplementation self, Indices indices) -> GradientImplementation
        """
        return _func.GradientImplementation_getMarginal(self, *args)

    def isActualImplementation(self):
        """isActualImplementation(GradientImplementation self) -> OT::Bool"""
        return _func.GradientImplementation_isActualImplementation(self)

    def gradient(self, *args):
        """gradient(GradientImplementation self, NumericalPoint inP) -> Matrix"""
        return _func.GradientImplementation_gradient(self, *args)

    def getInputDimension(self):
        """getInputDimension(GradientImplementation self) -> OT::UnsignedLong"""
        return _func.GradientImplementation_getInputDimension(self)

    def getOutputDimension(self):
        """getOutputDimension(GradientImplementation self) -> OT::UnsignedLong"""
        return _func.GradientImplementation_getOutputDimension(self)

    def getCallsNumber(self):
        """getCallsNumber(GradientImplementation self) -> OT::UnsignedLong"""
        return _func.GradientImplementation_getCallsNumber(self)

    def Is(self, *args):
        """Is(GradientImplementation self, PersistentObject other) -> OT::Bool"""
        return _func.GradientImplementation_Is(self, *args)

    def getId(self):
        """getId(GradientImplementation self) -> OT::Id"""
        return _func.GradientImplementation_getId(self)

    def setShadowedId(self, *args):
        """setShadowedId(GradientImplementation self, OT::Id id)"""
        return _func.GradientImplementation_setShadowedId(self, *args)

    def getShadowedId(self):
        """getShadowedId(GradientImplementation self) -> OT::Id"""
        return _func.GradientImplementation_getShadowedId(self)

    def setVisibility(self, *args):
        """setVisibility(GradientImplementation self, OT::Bool visible)"""
        return _func.GradientImplementation_setVisibility(self, *args)

    def getVisibility(self):
        """getVisibility(GradientImplementation self) -> OT::Bool"""
        return _func.GradientImplementation_getVisibility(self)

    def hasName(self):
        """hasName(GradientImplementation self) -> OT::Bool"""
        return _func.GradientImplementation_hasName(self)

    def hasVisibleName(self):
        """hasVisibleName(GradientImplementation self) -> OT::Bool"""
        return _func.GradientImplementation_hasVisibleName(self)

    def getName(self):
        """getName(GradientImplementation self) -> OT::String"""
        return _func.GradientImplementation_getName(self)

    def setName(self, *args):
        """setName(GradientImplementation self, OT::String const & name)"""
        return _func.GradientImplementation_setName(self, *args)

GradientImplementation_swigregister = _func.GradientImplementation_swigregister
GradientImplementation_swigregister(GradientImplementation)

class HessianImplementation(_object):
    """Proxy of C++ OT::Pointer<(OT::NumericalMathHessianImplementation)> class"""
    __swig_setmethods__ = {}
    __setattr__ = lambda self, name, value: _swig_setattr(self, HessianImplementation, name, value)
    __swig_getmethods__ = {}
    __getattr__ = lambda self, name: _swig_getattr(self, HessianImplementation, name)
    __swig_setmethods__["ptr_"] = _func.HessianImplementation_ptr__set
    __swig_getmethods__["ptr_"] = _func.HessianImplementation_ptr__get
    if _newclass:ptr_ = _swig_property(_func.HessianImplementation_ptr__get, _func.HessianImplementation_ptr__set)
    def __init__(self, *args): 
        """
        __init__(OT::Pointer<(OT::NumericalMathHessianImplementation)> self) -> HessianImplementation
        __init__(OT::Pointer<(OT::NumericalMathHessianImplementation)> self, NumericalMathHessianImplementation ptr) -> HessianImplementation
        """
        this = _func.new_HessianImplementation(*args)
        try: self.this.append(this)
        except: self.this = this
    __swig_destroy__ = _func.delete_HessianImplementation
    __del__ = lambda self : None;
    def reset(self):
        """reset(HessianImplementation self)"""
        return _func.HessianImplementation_reset(self)

    def __ref__(self, *args):
        """
        __ref__(HessianImplementation self) -> NumericalMathHessianImplementation
        __ref__(HessianImplementation self) -> NumericalMathHessianImplementation
        """
        return _func.HessianImplementation___ref__(self, *args)

    def __deref__(self):
        """__deref__(HessianImplementation self) -> NumericalMathHessianImplementation"""
        return _func.HessianImplementation___deref__(self)

    def isNull(self):
        """isNull(HessianImplementation self) -> OT::Bool"""
        return _func.HessianImplementation_isNull(self)

    def __nonzero__(self):
        return _func.HessianImplementation___nonzero__(self)
    __bool__ = __nonzero__


    def get(self):
        """get(HessianImplementation self) -> NumericalMathHessianImplementation"""
        return _func.HessianImplementation_get(self)

    def getImplementation(self):
        """getImplementation(HessianImplementation self) -> OT::Pointer< OT::NumericalMathHessianImplementation >::pointer_type const &"""
        return _func.HessianImplementation_getImplementation(self)

    def unique(self):
        """unique(HessianImplementation self) -> OT::Bool"""
        return _func.HessianImplementation_unique(self)

    def use_count(self):
        """use_count(HessianImplementation self) -> OT::UnsignedLong"""
        return _func.HessianImplementation_use_count(self)

    def swap(self, *args):
        """swap(HessianImplementation self, HessianImplementation other)"""
        return _func.HessianImplementation_swap(self, *args)

    def GetClassName(self):
        """GetClassName(HessianImplementation self) -> OT::String"""
        return _func.HessianImplementation_GetClassName(self)

    def getClassName(self):
        """getClassName(HessianImplementation self) -> OT::String"""
        return _func.HessianImplementation_getClassName(self)

    def __eq__(self, *args):
        """__eq__(HessianImplementation self, NumericalMathHessianImplementation other) -> OT::Bool"""
        return _func.HessianImplementation___eq__(self, *args)

    def __repr__(self):
        """__repr__(HessianImplementation self) -> OT::String"""
        return _func.HessianImplementation___repr__(self)

    def __str__(self, offset=""):
        """
        __str__(HessianImplementation self, OT::String const & offset="") -> OT::String
        __str__(HessianImplementation self) -> OT::String
        """
        return _func.HessianImplementation___str__(self, offset)

    def setDescription(self, *args):
        """setDescription(HessianImplementation self, Description description)"""
        return _func.HessianImplementation_setDescription(self, *args)

    def getDescription(self):
        """getDescription(HessianImplementation self) -> Description"""
        return _func.HessianImplementation_getDescription(self)

    def isActualImplementation(self):
        """isActualImplementation(HessianImplementation self) -> OT::Bool"""
        return _func.HessianImplementation_isActualImplementation(self)

    def getMarginal(self, *args):
        """
        getMarginal(HessianImplementation self, OT::UnsignedLong const i) -> HessianImplementation
        getMarginal(HessianImplementation self, Indices indices) -> HessianImplementation
        """
        return _func.HessianImplementation_getMarginal(self, *args)

    def hessian(self, *args):
        """hessian(HessianImplementation self, NumericalPoint inP) -> SymmetricTensor"""
        return _func.HessianImplementation_hessian(self, *args)

    def getInputDimension(self):
        """getInputDimension(HessianImplementation self) -> OT::UnsignedLong"""
        return _func.HessianImplementation_getInputDimension(self)

    def getOutputDimension(self):
        """getOutputDimension(HessianImplementation self) -> OT::UnsignedLong"""
        return _func.HessianImplementation_getOutputDimension(self)

    def getCallsNumber(self):
        """getCallsNumber(HessianImplementation self) -> OT::UnsignedLong"""
        return _func.HessianImplementation_getCallsNumber(self)

    def Is(self, *args):
        """Is(HessianImplementation self, PersistentObject other) -> OT::Bool"""
        return _func.HessianImplementation_Is(self, *args)

    def getId(self):
        """getId(HessianImplementation self) -> OT::Id"""
        return _func.HessianImplementation_getId(self)

    def setShadowedId(self, *args):
        """setShadowedId(HessianImplementation self, OT::Id id)"""
        return _func.HessianImplementation_setShadowedId(self, *args)

    def getShadowedId(self):
        """getShadowedId(HessianImplementation self) -> OT::Id"""
        return _func.HessianImplementation_getShadowedId(self)

    def setVisibility(self, *args):
        """setVisibility(HessianImplementation self, OT::Bool visible)"""
        return _func.HessianImplementation_setVisibility(self, *args)

    def getVisibility(self):
        """getVisibility(HessianImplementation self) -> OT::Bool"""
        return _func.HessianImplementation_getVisibility(self)

    def hasName(self):
        """hasName(HessianImplementation self) -> OT::Bool"""
        return _func.HessianImplementation_hasName(self)

    def hasVisibleName(self):
        """hasVisibleName(HessianImplementation self) -> OT::Bool"""
        return _func.HessianImplementation_hasVisibleName(self)

    def getName(self):
        """getName(HessianImplementation self) -> OT::String"""
        return _func.HessianImplementation_getName(self)

    def setName(self, *args):
        """setName(HessianImplementation self, OT::String const & name)"""
        return _func.HessianImplementation_setName(self, *args)

HessianImplementation_swigregister = _func.HessianImplementation_swigregister
HessianImplementation_swigregister(HessianImplementation)

class NumericalMathFunctionImplementation(openturns.common.PersistentObject):
    """Proxy of C++ OT::NumericalMathFunctionImplementation class"""
    __swig_setmethods__ = {}
    for _s in [openturns.common.PersistentObject]: __swig_setmethods__.update(getattr(_s,'__swig_setmethods__',{}))
    __setattr__ = lambda self, name, value: _swig_setattr(self, NumericalMathFunctionImplementation, name, value)
    __swig_getmethods__ = {}
    for _s in [openturns.common.PersistentObject]: __swig_getmethods__.update(getattr(_s,'__swig_getmethods__',{}))
    __getattr__ = lambda self, name: _swig_getattr(self, NumericalMathFunctionImplementation, name)
    def GetClassName():
        """GetClassName() -> OT::String"""
        return _func.NumericalMathFunctionImplementation_GetClassName()

    if _newclass:GetClassName = staticmethod(GetClassName)
    __swig_getmethods__["GetClassName"] = lambda x: GetClassName
    def getClassName(self):
        """getClassName(NumericalMathFunctionImplementation self) -> OT::String"""
        return _func.NumericalMathFunctionImplementation_getClassName(self)

    def GetValidConstants():
        """GetValidConstants() -> Description"""
        return _func.NumericalMathFunctionImplementation_GetValidConstants()

    if _newclass:GetValidConstants = staticmethod(GetValidConstants)
    __swig_getmethods__["GetValidConstants"] = lambda x: GetValidConstants
    def GetValidFunctions():
        """GetValidFunctions() -> Description"""
        return _func.NumericalMathFunctionImplementation_GetValidFunctions()

    if _newclass:GetValidFunctions = staticmethod(GetValidFunctions)
    __swig_getmethods__["GetValidFunctions"] = lambda x: GetValidFunctions
    def GetValidOperators():
        """GetValidOperators() -> Description"""
        return _func.NumericalMathFunctionImplementation_GetValidOperators()

    if _newclass:GetValidOperators = staticmethod(GetValidOperators)
    __swig_getmethods__["GetValidOperators"] = lambda x: GetValidOperators
    def __mul__(self, *args):
        """
        __mul__(NumericalMathFunctionImplementation self, NumericalMathFunctionImplementation right) -> NumericalMathFunctionImplementation
        __mul__(NumericalMathFunctionImplementation self, NumericalMathFunctionImplementationPointer p_right) -> NumericalMathFunctionImplementation
        """
        return _func.NumericalMathFunctionImplementation___mul__(self, *args)

    def __eq__(self, *args):
        """__eq__(NumericalMathFunctionImplementation self, NumericalMathFunctionImplementation other) -> OT::Bool"""
        return _func.NumericalMathFunctionImplementation___eq__(self, *args)

    def __repr__(self):
        """__repr__(NumericalMathFunctionImplementation self) -> OT::String"""
        return _func.NumericalMathFunctionImplementation___repr__(self)

    def __str__(self, offset=""):
        """
        __str__(NumericalMathFunctionImplementation self, OT::String const & offset="") -> OT::String
        __str__(NumericalMathFunctionImplementation self) -> OT::String
        """
        return _func.NumericalMathFunctionImplementation___str__(self, offset)

    def enableCache(self):
        """enableCache(NumericalMathFunctionImplementation self)"""
        return _func.NumericalMathFunctionImplementation_enableCache(self)

    def disableCache(self):
        """disableCache(NumericalMathFunctionImplementation self)"""
        return _func.NumericalMathFunctionImplementation_disableCache(self)

    def isCacheEnabled(self):
        """isCacheEnabled(NumericalMathFunctionImplementation self) -> OT::Bool"""
        return _func.NumericalMathFunctionImplementation_isCacheEnabled(self)

    def getCacheHits(self):
        """getCacheHits(NumericalMathFunctionImplementation self) -> OT::UnsignedLong"""
        return _func.NumericalMathFunctionImplementation_getCacheHits(self)

    def addCacheContent(self, *args):
        """addCacheContent(NumericalMathFunctionImplementation self, NumericalSample inSample, NumericalSample outSample)"""
        return _func.NumericalMathFunctionImplementation_addCacheContent(self, *args)

    def getCacheInput(self):
        """getCacheInput(NumericalMathFunctionImplementation self) -> NumericalSample"""
        return _func.NumericalMathFunctionImplementation_getCacheInput(self)

    def getCacheOutput(self):
        """getCacheOutput(NumericalMathFunctionImplementation self) -> NumericalSample"""
        return _func.NumericalMathFunctionImplementation_getCacheOutput(self)

    def clearCache(self):
        """clearCache(NumericalMathFunctionImplementation self)"""
        return _func.NumericalMathFunctionImplementation_clearCache(self)

    def enableHistory(self):
        """enableHistory(NumericalMathFunctionImplementation self)"""
        return _func.NumericalMathFunctionImplementation_enableHistory(self)

    def disableHistory(self):
        """disableHistory(NumericalMathFunctionImplementation self)"""
        return _func.NumericalMathFunctionImplementation_disableHistory(self)

    def isHistoryEnabled(self):
        """isHistoryEnabled(NumericalMathFunctionImplementation self) -> OT::Bool"""
        return _func.NumericalMathFunctionImplementation_isHistoryEnabled(self)

    def clearHistory(self):
        """clearHistory(NumericalMathFunctionImplementation self)"""
        return _func.NumericalMathFunctionImplementation_clearHistory(self)

    def getInputHistory(self):
        """getInputHistory(NumericalMathFunctionImplementation self) -> HistoryStrategy"""
        return _func.NumericalMathFunctionImplementation_getInputHistory(self)

    def getOutputHistory(self):
        """getOutputHistory(NumericalMathFunctionImplementation self) -> HistoryStrategy"""
        return _func.NumericalMathFunctionImplementation_getOutputHistory(self)

    def setEvaluationImplementation(self, *args):
        """setEvaluationImplementation(NumericalMathFunctionImplementation self, EvaluationImplementation evaluationImplementation)"""
        return _func.NumericalMathFunctionImplementation_setEvaluationImplementation(self, *args)

    def getEvaluationImplementation(self):
        """getEvaluationImplementation(NumericalMathFunctionImplementation self) -> EvaluationImplementation"""
        return _func.NumericalMathFunctionImplementation_getEvaluationImplementation(self)

    def setGradientImplementation(self, *args):
        """setGradientImplementation(NumericalMathFunctionImplementation self, GradientImplementation gradientImplementation)"""
        return _func.NumericalMathFunctionImplementation_setGradientImplementation(self, *args)

    def getGradientImplementation(self):
        """getGradientImplementation(NumericalMathFunctionImplementation self) -> GradientImplementation"""
        return _func.NumericalMathFunctionImplementation_getGradientImplementation(self)

    def setHessianImplementation(self, *args):
        """setHessianImplementation(NumericalMathFunctionImplementation self, HessianImplementation hessianImplementation)"""
        return _func.NumericalMathFunctionImplementation_setHessianImplementation(self, *args)

    def getHessianImplementation(self):
        """getHessianImplementation(NumericalMathFunctionImplementation self) -> HessianImplementation"""
        return _func.NumericalMathFunctionImplementation_getHessianImplementation(self)

    def getInitialEvaluationImplementation(self):
        """getInitialEvaluationImplementation(NumericalMathFunctionImplementation self) -> EvaluationImplementation"""
        return _func.NumericalMathFunctionImplementation_getInitialEvaluationImplementation(self)

    def getInitialGradientImplementation(self):
        """getInitialGradientImplementation(NumericalMathFunctionImplementation self) -> GradientImplementation"""
        return _func.NumericalMathFunctionImplementation_getInitialGradientImplementation(self)

    def getInitialHessianImplementation(self):
        """getInitialHessianImplementation(NumericalMathFunctionImplementation self) -> HessianImplementation"""
        return _func.NumericalMathFunctionImplementation_getInitialHessianImplementation(self)

    def getUseDefaultGradientImplementation(self):
        """getUseDefaultGradientImplementation(NumericalMathFunctionImplementation self) -> OT::Bool"""
        return _func.NumericalMathFunctionImplementation_getUseDefaultGradientImplementation(self)

    def setUseDefaultGradientImplementation(self, *args):
        """setUseDefaultGradientImplementation(NumericalMathFunctionImplementation self, OT::Bool const gradientFlag)"""
        return _func.NumericalMathFunctionImplementation_setUseDefaultGradientImplementation(self, *args)

    def getUseDefaultHessianImplementation(self):
        """getUseDefaultHessianImplementation(NumericalMathFunctionImplementation self) -> OT::Bool"""
        return _func.NumericalMathFunctionImplementation_getUseDefaultHessianImplementation(self)

    def setUseDefaultHessianImplementation(self, *args):
        """setUseDefaultHessianImplementation(NumericalMathFunctionImplementation self, OT::Bool const hessianFlag)"""
        return _func.NumericalMathFunctionImplementation_setUseDefaultHessianImplementation(self, *args)

    def __call__(self, *args):
        """
        __call__(NumericalMathFunctionImplementation self, NumericalPoint inP) -> NumericalPoint
        __call__(NumericalMathFunctionImplementation self, NumericalSample inS) -> NumericalSample
        __call__(NumericalMathFunctionImplementation self, TimeSeries inTS) -> TimeSeries
        """
        return _func.NumericalMathFunctionImplementation___call__(self, *args)

    def gradient(self, *args):
        """gradient(NumericalMathFunctionImplementation self, NumericalPoint inP) -> Matrix"""
        return _func.NumericalMathFunctionImplementation_gradient(self, *args)

    def hessian(self, *args):
        """hessian(NumericalMathFunctionImplementation self, NumericalPoint inP) -> SymmetricTensor"""
        return _func.NumericalMathFunctionImplementation_hessian(self, *args)

    def parametersGradient(self, *args):
        """parametersGradient(NumericalMathFunctionImplementation self, NumericalPoint inP) -> Matrix"""
        return _func.NumericalMathFunctionImplementation_parametersGradient(self, *args)

    def getParameters(self):
        """getParameters(NumericalMathFunctionImplementation self) -> NumericalPointWithDescription"""
        return _func.NumericalMathFunctionImplementation_getParameters(self)

    def setParameters(self, *args):
        """setParameters(NumericalMathFunctionImplementation self, NumericalPointWithDescription parameters)"""
        return _func.NumericalMathFunctionImplementation_setParameters(self, *args)

    def getInputNumericalPointDimension(self):
        """getInputNumericalPointDimension(NumericalMathFunctionImplementation self) -> OT::UnsignedLong"""
        return _func.NumericalMathFunctionImplementation_getInputNumericalPointDimension(self)

    def getOutputNumericalPointDimension(self):
        """getOutputNumericalPointDimension(NumericalMathFunctionImplementation self) -> OT::UnsignedLong"""
        return _func.NumericalMathFunctionImplementation_getOutputNumericalPointDimension(self)

    def getInputDimension(self):
        """getInputDimension(NumericalMathFunctionImplementation self) -> OT::UnsignedLong"""
        return _func.NumericalMathFunctionImplementation_getInputDimension(self)

    def getOutputDimension(self):
        """getOutputDimension(NumericalMathFunctionImplementation self) -> OT::UnsignedLong"""
        return _func.NumericalMathFunctionImplementation_getOutputDimension(self)

    def setDescription(self, *args):
        """setDescription(NumericalMathFunctionImplementation self, Description description)"""
        return _func.NumericalMathFunctionImplementation_setDescription(self, *args)

    def getDescription(self):
        """getDescription(NumericalMathFunctionImplementation self) -> Description"""
        return _func.NumericalMathFunctionImplementation_getDescription(self)

    def getInputDescription(self):
        """getInputDescription(NumericalMathFunctionImplementation self) -> Description"""
        return _func.NumericalMathFunctionImplementation_getInputDescription(self)

    def getOutputDescription(self):
        """getOutputDescription(NumericalMathFunctionImplementation self) -> Description"""
        return _func.NumericalMathFunctionImplementation_getOutputDescription(self)

    def getMarginal(self, *args):
        """
        getMarginal(NumericalMathFunctionImplementation self, OT::UnsignedLong const i) -> NumericalMathFunctionImplementationPointer
        getMarginal(NumericalMathFunctionImplementation self, Indices indices) -> NumericalMathFunctionImplementationPointer
        """
        return _func.NumericalMathFunctionImplementation_getMarginal(self, *args)

    def getEvaluationCallsNumber(self):
        """getEvaluationCallsNumber(NumericalMathFunctionImplementation self) -> OT::UnsignedLong"""
        return _func.NumericalMathFunctionImplementation_getEvaluationCallsNumber(self)

    def getGradientCallsNumber(self):
        """getGradientCallsNumber(NumericalMathFunctionImplementation self) -> OT::UnsignedLong"""
        return _func.NumericalMathFunctionImplementation_getGradientCallsNumber(self)

    def getHessianCallsNumber(self):
        """getHessianCallsNumber(NumericalMathFunctionImplementation self) -> OT::UnsignedLong"""
        return _func.NumericalMathFunctionImplementation_getHessianCallsNumber(self)

    def draw(self, *args):
        """
        draw(NumericalMathFunctionImplementation self, OT::UnsignedLong const inputMarginal, OT::UnsignedLong const outputMarginal, NumericalPoint centralPoint, 
            OT::NumericalScalar const xMin, OT::NumericalScalar const xMax, 
            OT::UnsignedLong const pointNumber=OT::ResourceMap::GetAsUnsignedLong("NumericalMathEvaluationImplementation-DefaultPointNumber")) -> Graph
        draw(NumericalMathFunctionImplementation self, OT::UnsignedLong const inputMarginal, OT::UnsignedLong const outputMarginal, NumericalPoint centralPoint, 
            OT::NumericalScalar const xMin, OT::NumericalScalar const xMax) -> Graph
        draw(NumericalMathFunctionImplementation self, OT::UnsignedLong const firstInputMarginal, OT::UnsignedLong const secondInputMarginal, 
            OT::UnsignedLong const outputMarginal, NumericalPoint centralPoint, NumericalPoint xMin, 
            NumericalPoint xMax, Indices pointNumber=OT::Indices(2, ResourceMap::GetAsUnsignedLong("NumericalMathEvaluationImplementation-DefaultPointNumber"))) -> Graph
        draw(NumericalMathFunctionImplementation self, OT::UnsignedLong const firstInputMarginal, OT::UnsignedLong const secondInputMarginal, 
            OT::UnsignedLong const outputMarginal, NumericalPoint centralPoint, NumericalPoint xMin, 
            NumericalPoint xMax) -> Graph
        draw(NumericalMathFunctionImplementation self, OT::NumericalScalar const xMin, OT::NumericalScalar const xMax, OT::UnsignedLong const pointNumber=OT::ResourceMap::GetAsUnsignedLong("NumericalMathEvaluationImplementation-DefaultPointNumber")) -> Graph
        draw(NumericalMathFunctionImplementation self, OT::NumericalScalar const xMin, OT::NumericalScalar const xMax) -> Graph
        draw(NumericalMathFunctionImplementation self, NumericalPoint xMin, NumericalPoint xMax, Indices pointNumber=OT::Indices(2, ResourceMap::GetAsUnsignedLong("NumericalMathEvaluationImplementation-DefaultPointNumber"))) -> Graph
        draw(NumericalMathFunctionImplementation self, NumericalPoint xMin, NumericalPoint xMax) -> Graph
        """
        return _func.NumericalMathFunctionImplementation_draw(self, *args)

    def __init__(self, *args): 
        """
        __init__(OT::NumericalMathFunctionImplementation self) -> NumericalMathFunctionImplementation
        __init__(OT::NumericalMathFunctionImplementation self, OT::String const & name) -> NumericalMathFunctionImplementation
        __init__(OT::NumericalMathFunctionImplementation self, WrapperFile wrapperFile) -> NumericalMathFunctionImplementation
        __init__(OT::NumericalMathFunctionImplementation self, Description inputVariablesNames, Description outputVariablesNames, Description formulas) -> NumericalMathFunctionImplementation
        __init__(OT::NumericalMathFunctionImplementation self, NumericalSample inputSample, NumericalSample outputSample) -> NumericalMathFunctionImplementation
        __init__(OT::NumericalMathFunctionImplementation self, EvaluationImplementation funcImpl, GradientImplementation gradImpl, HessianImplementation hessImpl) -> NumericalMathFunctionImplementation
        __init__(OT::NumericalMathFunctionImplementation self, EvaluationImplementation evaluationImplementation) -> NumericalMathFunctionImplementation
        __init__(OT::NumericalMathFunctionImplementation self, NumericalMathFunctionImplementation other) -> NumericalMathFunctionImplementation
        """
        this = _func.new_NumericalMathFunctionImplementation(*args)
        try: self.this.append(this)
        except: self.this = this
    __swig_destroy__ = _func.delete_NumericalMathFunctionImplementation
    __del__ = lambda self : None;
NumericalMathFunctionImplementation_swigregister = _func.NumericalMathFunctionImplementation_swigregister
NumericalMathFunctionImplementation_swigregister(NumericalMathFunctionImplementation)

def NumericalMathFunctionImplementation_GetClassName():
  """NumericalMathFunctionImplementation_GetClassName() -> OT::String"""
  return _func.NumericalMathFunctionImplementation_GetClassName()

def NumericalMathFunctionImplementation_GetValidConstants():
  """NumericalMathFunctionImplementation_GetValidConstants() -> Description"""
  return _func.NumericalMathFunctionImplementation_GetValidConstants()

def NumericalMathFunctionImplementation_GetValidFunctions():
  """NumericalMathFunctionImplementation_GetValidFunctions() -> Description"""
  return _func.NumericalMathFunctionImplementation_GetValidFunctions()

def NumericalMathFunctionImplementation_GetValidOperators():
  """NumericalMathFunctionImplementation_GetValidOperators() -> Description"""
  return _func.NumericalMathFunctionImplementation_GetValidOperators()

class ProductNumericalMathFunction(NumericalMathFunctionImplementation):
    """Proxy of C++ OT::ProductNumericalMathFunction class"""
    __swig_setmethods__ = {}
    for _s in [NumericalMathFunctionImplementation]: __swig_setmethods__.update(getattr(_s,'__swig_setmethods__',{}))
    __setattr__ = lambda self, name, value: _swig_setattr(self, ProductNumericalMathFunction, name, value)
    __swig_getmethods__ = {}
    for _s in [NumericalMathFunctionImplementation]: __swig_getmethods__.update(getattr(_s,'__swig_getmethods__',{}))
    __getattr__ = lambda self, name: _swig_getattr(self, ProductNumericalMathFunction, name)
    def GetClassName():
        """GetClassName() -> OT::String"""
        return _func.ProductNumericalMathFunction_GetClassName()

    if _newclass:GetClassName = staticmethod(GetClassName)
    __swig_getmethods__["GetClassName"] = lambda x: GetClassName
    def getClassName(self):
        """getClassName(ProductNumericalMathFunction self) -> OT::String"""
        return _func.ProductNumericalMathFunction_getClassName(self)

    def __eq__(self, *args):
        """__eq__(ProductNumericalMathFunction self, ProductNumericalMathFunction other) -> OT::Bool"""
        return _func.ProductNumericalMathFunction___eq__(self, *args)

    def __repr__(self):
        """__repr__(ProductNumericalMathFunction self) -> OT::String"""
        return _func.ProductNumericalMathFunction___repr__(self)

    def __str__(self, offset=""):
        """
        __str__(ProductNumericalMathFunction self, OT::String const & offset="") -> OT::String
        __str__(ProductNumericalMathFunction self) -> OT::String
        """
        return _func.ProductNumericalMathFunction___str__(self, offset)

    def parametersGradient(self, *args):
        """parametersGradient(ProductNumericalMathFunction self, NumericalPoint inP) -> Matrix"""
        return _func.ProductNumericalMathFunction_parametersGradient(self, *args)

    def __init__(self, *args): 
        """
        __init__(OT::ProductNumericalMathFunction self, NumericalMathFunctionImplementationPointer p_left, NumericalMathFunctionImplementationPointer p_right) -> ProductNumericalMathFunction
        __init__(OT::ProductNumericalMathFunction self, ProductNumericalMathFunction other) -> ProductNumericalMathFunction
        """
        this = _func.new_ProductNumericalMathFunction(*args)
        try: self.this.append(this)
        except: self.this = this
    __swig_destroy__ = _func.delete_ProductNumericalMathFunction
    __del__ = lambda self : None;
ProductNumericalMathFunction_swigregister = _func.ProductNumericalMathFunction_swigregister
ProductNumericalMathFunction_swigregister(ProductNumericalMathFunction)

def ProductNumericalMathFunction_GetClassName():
  """ProductNumericalMathFunction_GetClassName() -> OT::String"""
  return _func.ProductNumericalMathFunction_GetClassName()

class NumericalMathFunctionImplementationTypedInterfaceObject(openturns.common.InterfaceObject):
    """Proxy of C++ OT::TypedInterfaceObject<(OT::NumericalMathFunctionImplementation)> class"""
    __swig_setmethods__ = {}
    for _s in [openturns.common.InterfaceObject]: __swig_setmethods__.update(getattr(_s,'__swig_setmethods__',{}))
    __setattr__ = lambda self, name, value: _swig_setattr(self, NumericalMathFunctionImplementationTypedInterfaceObject, name, value)
    __swig_getmethods__ = {}
    for _s in [openturns.common.InterfaceObject]: __swig_getmethods__.update(getattr(_s,'__swig_getmethods__',{}))
    __getattr__ = lambda self, name: _swig_getattr(self, NumericalMathFunctionImplementationTypedInterfaceObject, name)
    __repr__ = _swig_repr
    def __init__(self, *args): 
        """
        __init__(OT::TypedInterfaceObject<(OT::NumericalMathFunctionImplementation)> self) -> NumericalMathFunctionImplementationTypedInterfaceObject
        __init__(OT::TypedInterfaceObject<(OT::NumericalMathFunctionImplementation)> self, NumericalMathFunctionImplementationPointer impl) -> NumericalMathFunctionImplementationTypedInterfaceObject
        """
        this = _func.new_NumericalMathFunctionImplementationTypedInterfaceObject(*args)
        try: self.this.append(this)
        except: self.this = this
    def getImplementation(self, *args):
        """
        getImplementation(NumericalMathFunctionImplementationTypedInterfaceObject self) -> NumericalMathFunctionImplementationPointer
        getImplementation(NumericalMathFunctionImplementationTypedInterfaceObject self) -> NumericalMathFunctionImplementationPointer
        """
        return _func.NumericalMathFunctionImplementationTypedInterfaceObject_getImplementation(self, *args)

    def getImplementationAsPersistentObject(self):
        """getImplementationAsPersistentObject(NumericalMathFunctionImplementationTypedInterfaceObject self) -> PersistentObjectPointer"""
        return _func.NumericalMathFunctionImplementationTypedInterfaceObject_getImplementationAsPersistentObject(self)

    def setImplementationAsPersistentObject(self, *args):
        """setImplementationAsPersistentObject(NumericalMathFunctionImplementationTypedInterfaceObject self, PersistentObjectPointer obj)"""
        return _func.NumericalMathFunctionImplementationTypedInterfaceObject_setImplementationAsPersistentObject(self, *args)

    def swap(self, *args):
        """swap(NumericalMathFunctionImplementationTypedInterfaceObject self, NumericalMathFunctionImplementationTypedInterfaceObject other)"""
        return _func.NumericalMathFunctionImplementationTypedInterfaceObject_swap(self, *args)

    def setName(self, *args):
        """setName(NumericalMathFunctionImplementationTypedInterfaceObject self, OT::String const & name)"""
        return _func.NumericalMathFunctionImplementationTypedInterfaceObject_setName(self, *args)

    def getName(self):
        """getName(NumericalMathFunctionImplementationTypedInterfaceObject self) -> OT::String"""
        return _func.NumericalMathFunctionImplementationTypedInterfaceObject_getName(self)

    def __eq__(self, *args):
        """__eq__(NumericalMathFunctionImplementationTypedInterfaceObject self, NumericalMathFunctionImplementationTypedInterfaceObject other) -> OT::Bool"""
        return _func.NumericalMathFunctionImplementationTypedInterfaceObject___eq__(self, *args)

    __swig_destroy__ = _func.delete_NumericalMathFunctionImplementationTypedInterfaceObject
    __del__ = lambda self : None;
NumericalMathFunctionImplementationTypedInterfaceObject_swigregister = _func.NumericalMathFunctionImplementationTypedInterfaceObject_swigregister
NumericalMathFunctionImplementationTypedInterfaceObject_swigregister(NumericalMathFunctionImplementationTypedInterfaceObject)

class NumericalMathFunctionCollection(_object):
    """Proxy of C++ OT::Collection<(OT::NumericalMathFunction)> class"""
    __swig_setmethods__ = {}
    __setattr__ = lambda self, name, value: _swig_setattr(self, NumericalMathFunctionCollection, name, value)
    __swig_getmethods__ = {}
    __getattr__ = lambda self, name: _swig_getattr(self, NumericalMathFunctionCollection, name)
    __swig_destroy__ = _func.delete_NumericalMathFunctionCollection
    __del__ = lambda self : None;
    def clear(self):
        """clear(NumericalMathFunctionCollection self)"""
        return _func.NumericalMathFunctionCollection_clear(self)

    def __len__(self):
        """__len__(NumericalMathFunctionCollection self) -> OT::UnsignedLong"""
        return _func.NumericalMathFunctionCollection___len__(self)

    def __eq__(self, *args):
        """__eq__(NumericalMathFunctionCollection self, NumericalMathFunctionCollection rhs) -> OT::Bool"""
        return _func.NumericalMathFunctionCollection___eq__(self, *args)

    def __contains__(self, *args):
        """__contains__(NumericalMathFunctionCollection self, NumericalMathFunction val) -> OT::Bool"""
        return _func.NumericalMathFunctionCollection___contains__(self, *args)

    def __getitem__(self, *args):
        """__getitem__(NumericalMathFunctionCollection self, OT::UnsignedLong const i) -> NumericalMathFunction"""
        return _func.NumericalMathFunctionCollection___getitem__(self, *args)

    def __setitem__(self, *args):
        """__setitem__(NumericalMathFunctionCollection self, OT::UnsignedLong const i, NumericalMathFunction val)"""
        return _func.NumericalMathFunctionCollection___setitem__(self, *args)

    def __delitem__(self, *args):
        """__delitem__(NumericalMathFunctionCollection self, OT::UnsignedLong const i)"""
        return _func.NumericalMathFunctionCollection___delitem__(self, *args)

    def at(self, *args):
        """
        at(NumericalMathFunctionCollection self, OT::UnsignedLong const i) -> NumericalMathFunction
        at(NumericalMathFunctionCollection self, OT::UnsignedLong const i) -> NumericalMathFunction
        """
        return _func.NumericalMathFunctionCollection_at(self, *args)

    def add(self, *args):
        """
        add(NumericalMathFunctionCollection self, NumericalMathFunction elt)
        add(NumericalMathFunctionCollection self, NumericalMathFunctionCollection coll)
        """
        return _func.NumericalMathFunctionCollection_add(self, *args)

    def getSize(self):
        """getSize(NumericalMathFunctionCollection self) -> OT::UnsignedLong"""
        return _func.NumericalMathFunctionCollection_getSize(self)

    def resize(self, *args):
        """resize(NumericalMathFunctionCollection self, OT::UnsignedLong const newSize)"""
        return _func.NumericalMathFunctionCollection_resize(self, *args)

    def isEmpty(self):
        """isEmpty(NumericalMathFunctionCollection self) -> OT::Bool"""
        return _func.NumericalMathFunctionCollection_isEmpty(self)

    def __repr__(self):
        """__repr__(NumericalMathFunctionCollection self) -> OT::String"""
        return _func.NumericalMathFunctionCollection___repr__(self)

    def __str__(self, offset=""):
        """
        __str__(NumericalMathFunctionCollection self, OT::String const & offset="") -> OT::String
        __str__(NumericalMathFunctionCollection self) -> OT::String
        """
        return _func.NumericalMathFunctionCollection___str__(self, offset)

    def __init__(self, *args): 
        """
        __init__(OT::Collection<(OT::NumericalMathFunction)> self) -> NumericalMathFunctionCollection
        __init__(OT::Collection<(OT::NumericalMathFunction)> self, OT::UnsignedLong const size) -> NumericalMathFunctionCollection
        __init__(OT::Collection<(OT::NumericalMathFunction)> self, OT::UnsignedLong const size, NumericalMathFunction value) -> NumericalMathFunctionCollection
        __init__(OT::Collection<(OT::NumericalMathFunction)> self, PyObject * pyObj) -> NumericalMathFunctionCollection
        __init__(OT::Collection<(OT::NumericalMathFunction)> self, NumericalMathFunctionCollection other) -> NumericalMathFunctionCollection
        """
        this = _func.new_NumericalMathFunctionCollection(*args)
        try: self.this.append(this)
        except: self.this = this
NumericalMathFunctionCollection_swigregister = _func.NumericalMathFunctionCollection_swigregister
NumericalMathFunctionCollection_swigregister(NumericalMathFunctionCollection)

class NumericalMathFunction(NumericalMathFunctionImplementationTypedInterfaceObject):
    """Proxy of C++ OT::NumericalMathFunction class"""
    __swig_setmethods__ = {}
    for _s in [NumericalMathFunctionImplementationTypedInterfaceObject]: __swig_setmethods__.update(getattr(_s,'__swig_setmethods__',{}))
    __setattr__ = lambda self, name, value: _swig_setattr(self, NumericalMathFunction, name, value)
    __swig_getmethods__ = {}
    for _s in [NumericalMathFunctionImplementationTypedInterfaceObject]: __swig_getmethods__.update(getattr(_s,'__swig_getmethods__',{}))
    __getattr__ = lambda self, name: _swig_getattr(self, NumericalMathFunction, name)
    def GetClassName():
        """GetClassName() -> OT::String"""
        return _func.NumericalMathFunction_GetClassName()

    if _newclass:GetClassName = staticmethod(GetClassName)
    __swig_getmethods__["GetClassName"] = lambda x: GetClassName
    def getClassName(self):
        """getClassName(NumericalMathFunction self) -> OT::String"""
        return _func.NumericalMathFunction_getClassName(self)

    def __eq__(self, *args):
        """__eq__(NumericalMathFunction self, NumericalMathFunction other) -> OT::Bool"""
        return _func.NumericalMathFunction___eq__(self, *args)

    def __repr__(self):
        """__repr__(NumericalMathFunction self) -> OT::String"""
        return _func.NumericalMathFunction___repr__(self)

    def __str__(self, offset=""):
        """
        __str__(NumericalMathFunction self, OT::String const & offset="") -> OT::String
        __str__(NumericalMathFunction self) -> OT::String
        """
        return _func.NumericalMathFunction___str__(self, offset)

    def enableCache(self):
        """enableCache(NumericalMathFunction self)"""
        return _func.NumericalMathFunction_enableCache(self)

    def disableCache(self):
        """disableCache(NumericalMathFunction self)"""
        return _func.NumericalMathFunction_disableCache(self)

    def isCacheEnabled(self):
        """isCacheEnabled(NumericalMathFunction self) -> OT::Bool"""
        return _func.NumericalMathFunction_isCacheEnabled(self)

    def getCacheHits(self):
        """getCacheHits(NumericalMathFunction self) -> OT::UnsignedLong"""
        return _func.NumericalMathFunction_getCacheHits(self)

    def addCacheContent(self, *args):
        """addCacheContent(NumericalMathFunction self, NumericalSample inSample, NumericalSample outSample)"""
        return _func.NumericalMathFunction_addCacheContent(self, *args)

    def getCacheInput(self):
        """getCacheInput(NumericalMathFunction self) -> NumericalSample"""
        return _func.NumericalMathFunction_getCacheInput(self)

    def getCacheOutput(self):
        """getCacheOutput(NumericalMathFunction self) -> NumericalSample"""
        return _func.NumericalMathFunction_getCacheOutput(self)

    def clearCache(self):
        """clearCache(NumericalMathFunction self)"""
        return _func.NumericalMathFunction_clearCache(self)

    def enableHistory(self):
        """enableHistory(NumericalMathFunction self)"""
        return _func.NumericalMathFunction_enableHistory(self)

    def disableHistory(self):
        """disableHistory(NumericalMathFunction self)"""
        return _func.NumericalMathFunction_disableHistory(self)

    def isHistoryEnabled(self):
        """isHistoryEnabled(NumericalMathFunction self) -> OT::Bool"""
        return _func.NumericalMathFunction_isHistoryEnabled(self)

    def clearHistory(self):
        """clearHistory(NumericalMathFunction self)"""
        return _func.NumericalMathFunction_clearHistory(self)

    def getInputHistory(self):
        """getInputHistory(NumericalMathFunction self) -> HistoryStrategy"""
        return _func.NumericalMathFunction_getInputHistory(self)

    def getOutputHistory(self):
        """getOutputHistory(NumericalMathFunction self) -> HistoryStrategy"""
        return _func.NumericalMathFunction_getOutputHistory(self)

    def setEvaluationImplementation(self, *args):
        """setEvaluationImplementation(NumericalMathFunction self, EvaluationImplementation functionImplementation)"""
        return _func.NumericalMathFunction_setEvaluationImplementation(self, *args)

    def getEvaluationImplementation(self):
        """getEvaluationImplementation(NumericalMathFunction self) -> EvaluationImplementation"""
        return _func.NumericalMathFunction_getEvaluationImplementation(self)

    def setGradientImplementation(self, *args):
        """setGradientImplementation(NumericalMathFunction self, NumericalMathGradientImplementation gradientImplementation)"""
        return _func.NumericalMathFunction_setGradientImplementation(self, *args)

    def getGradientImplementation(self):
        """getGradientImplementation(NumericalMathFunction self) -> GradientImplementation"""
        return _func.NumericalMathFunction_getGradientImplementation(self)

    def setHessianImplementation(self, *args):
        """setHessianImplementation(NumericalMathFunction self, NumericalMathHessianImplementation hessianImplementation)"""
        return _func.NumericalMathFunction_setHessianImplementation(self, *args)

    def getHessianImplementation(self):
        """getHessianImplementation(NumericalMathFunction self) -> HessianImplementation"""
        return _func.NumericalMathFunction_getHessianImplementation(self)

    def getInitialEvaluationImplementation(self):
        """getInitialEvaluationImplementation(NumericalMathFunction self) -> EvaluationImplementation"""
        return _func.NumericalMathFunction_getInitialEvaluationImplementation(self)

    def getInitialGradientImplementation(self):
        """getInitialGradientImplementation(NumericalMathFunction self) -> GradientImplementation"""
        return _func.NumericalMathFunction_getInitialGradientImplementation(self)

    def getInitialHessianImplementation(self):
        """getInitialHessianImplementation(NumericalMathFunction self) -> HessianImplementation"""
        return _func.NumericalMathFunction_getInitialHessianImplementation(self)

    def getUseDefaultGradientImplementation(self):
        """getUseDefaultGradientImplementation(NumericalMathFunction self) -> OT::Bool"""
        return _func.NumericalMathFunction_getUseDefaultGradientImplementation(self)

    def setUseDefaultGradientImplementation(self, *args):
        """setUseDefaultGradientImplementation(NumericalMathFunction self, OT::Bool const gradientFlag)"""
        return _func.NumericalMathFunction_setUseDefaultGradientImplementation(self, *args)

    def getUseDefaultHessianImplementation(self):
        """getUseDefaultHessianImplementation(NumericalMathFunction self) -> OT::Bool"""
        return _func.NumericalMathFunction_getUseDefaultHessianImplementation(self)

    def setUseDefaultHessianImplementation(self, *args):
        """setUseDefaultHessianImplementation(NumericalMathFunction self, OT::Bool const hessianFlag)"""
        return _func.NumericalMathFunction_setUseDefaultHessianImplementation(self, *args)

    def __mul__(self, *args):
        """__mul__(NumericalMathFunction self, NumericalMathFunction right) -> NumericalMathFunction"""
        return _func.NumericalMathFunction___mul__(self, *args)

    def __call__(self, *args):
        """
        __call__(NumericalMathFunction self, NumericalPoint inP) -> NumericalPoint
        __call__(NumericalMathFunction self, NumericalSample inS) -> NumericalSample
        __call__(NumericalMathFunction self, TimeSeries inTS) -> TimeSeries
        """
        return _func.NumericalMathFunction___call__(self, *args)

    def gradient(self, *args):
        """gradient(NumericalMathFunction self, NumericalPoint inP) -> Matrix"""
        return _func.NumericalMathFunction_gradient(self, *args)

    def hessian(self, *args):
        """hessian(NumericalMathFunction self, NumericalPoint inP) -> SymmetricTensor"""
        return _func.NumericalMathFunction_hessian(self, *args)

    def parametersGradient(self, *args):
        """parametersGradient(NumericalMathFunction self, NumericalPoint inP) -> Matrix"""
        return _func.NumericalMathFunction_parametersGradient(self, *args)

    def getParameters(self):
        """getParameters(NumericalMathFunction self) -> NumericalPointWithDescription"""
        return _func.NumericalMathFunction_getParameters(self)

    def setParameters(self, *args):
        """setParameters(NumericalMathFunction self, NumericalPointWithDescription parameters)"""
        return _func.NumericalMathFunction_setParameters(self, *args)

    def getInputDimension(self):
        """getInputDimension(NumericalMathFunction self) -> OT::UnsignedLong"""
        return _func.NumericalMathFunction_getInputDimension(self)

    def getOutputDimension(self):
        """getOutputDimension(NumericalMathFunction self) -> OT::UnsignedLong"""
        return _func.NumericalMathFunction_getOutputDimension(self)

    def setDescription(self, *args):
        """setDescription(NumericalMathFunction self, Description description)"""
        return _func.NumericalMathFunction_setDescription(self, *args)

    def getDescription(self):
        """getDescription(NumericalMathFunction self) -> Description"""
        return _func.NumericalMathFunction_getDescription(self)

    def getInputDescription(self):
        """getInputDescription(NumericalMathFunction self) -> Description"""
        return _func.NumericalMathFunction_getInputDescription(self)

    def getOutputDescription(self):
        """getOutputDescription(NumericalMathFunction self) -> Description"""
        return _func.NumericalMathFunction_getOutputDescription(self)

    def getMarginal(self, *args):
        """
        getMarginal(NumericalMathFunction self, OT::UnsignedLong const i) -> NumericalMathFunction
        getMarginal(NumericalMathFunction self, Indices indices) -> NumericalMathFunction
        """
        return _func.NumericalMathFunction_getMarginal(self, *args)

    def getCallsNumber(self):
        """getCallsNumber(NumericalMathFunction self) -> OT::UnsignedLong"""
        return _func.NumericalMathFunction_getCallsNumber(self)

    def getEvaluationCallsNumber(self):
        """getEvaluationCallsNumber(NumericalMathFunction self) -> OT::UnsignedLong"""
        return _func.NumericalMathFunction_getEvaluationCallsNumber(self)

    def getGradientCallsNumber(self):
        """getGradientCallsNumber(NumericalMathFunction self) -> OT::UnsignedLong"""
        return _func.NumericalMathFunction_getGradientCallsNumber(self)

    def getHessianCallsNumber(self):
        """getHessianCallsNumber(NumericalMathFunction self) -> OT::UnsignedLong"""
        return _func.NumericalMathFunction_getHessianCallsNumber(self)

    def draw(self, *args):
        """
        draw(NumericalMathFunction self, OT::UnsignedLong const inputMarginal, OT::UnsignedLong const outputMarginal, NumericalPoint centralPoint, 
            OT::NumericalScalar const xMin, OT::NumericalScalar const xMax, 
            OT::UnsignedLong const pointNumber=OT::ResourceMap::GetAsUnsignedLong("NumericalMathEvaluationImplementation-DefaultPointNumber")) -> Graph
        draw(NumericalMathFunction self, OT::UnsignedLong const inputMarginal, OT::UnsignedLong const outputMarginal, NumericalPoint centralPoint, 
            OT::NumericalScalar const xMin, OT::NumericalScalar const xMax) -> Graph
        draw(NumericalMathFunction self, OT::UnsignedLong const firstInputMarginal, OT::UnsignedLong const secondInputMarginal, 
            OT::UnsignedLong const outputMarginal, NumericalPoint centralPoint, NumericalPoint xMin, 
            NumericalPoint xMax, Indices pointNumber=OT::Indices(2, ResourceMap::GetAsUnsignedLong("NumericalMathEvaluationImplementation-DefaultPointNumber"))) -> Graph
        draw(NumericalMathFunction self, OT::UnsignedLong const firstInputMarginal, OT::UnsignedLong const secondInputMarginal, 
            OT::UnsignedLong const outputMarginal, NumericalPoint centralPoint, NumericalPoint xMin, 
            NumericalPoint xMax) -> Graph
        draw(NumericalMathFunction self, OT::NumericalScalar const xMin, OT::NumericalScalar const xMax, OT::UnsignedLong const pointNumber=OT::ResourceMap::GetAsUnsignedLong("NumericalMathEvaluationImplementation-DefaultPointNumber")) -> Graph
        draw(NumericalMathFunction self, OT::NumericalScalar const xMin, OT::NumericalScalar const xMax) -> Graph
        draw(NumericalMathFunction self, NumericalPoint xMin, NumericalPoint xMax, Indices pointNumber=OT::Indices(2, ResourceMap::GetAsUnsignedLong("NumericalMathEvaluationImplementation-DefaultPointNumber"))) -> Graph
        draw(NumericalMathFunction self, NumericalPoint xMin, NumericalPoint xMax) -> Graph
        """
        return _func.NumericalMathFunction_draw(self, *args)

    def GetValidConstants():
        """GetValidConstants() -> Description"""
        return _func.NumericalMathFunction_GetValidConstants()

    if _newclass:GetValidConstants = staticmethod(GetValidConstants)
    __swig_getmethods__["GetValidConstants"] = lambda x: GetValidConstants
    def GetValidFunctions():
        """GetValidFunctions() -> Description"""
        return _func.NumericalMathFunction_GetValidFunctions()

    if _newclass:GetValidFunctions = staticmethod(GetValidFunctions)
    __swig_getmethods__["GetValidFunctions"] = lambda x: GetValidFunctions
    def GetValidOperators():
        """GetValidOperators() -> Description"""
        return _func.NumericalMathFunction_GetValidOperators()

    if _newclass:GetValidOperators = staticmethod(GetValidOperators)
    __swig_getmethods__["GetValidOperators"] = lambda x: GetValidOperators
    def __init__(self, *args): 
        """
        __init__(OT::NumericalMathFunction self) -> NumericalMathFunction
        __init__(OT::NumericalMathFunction self, OT::String const & name) -> NumericalMathFunction
        __init__(OT::NumericalMathFunction self, NumericalMathFunctionImplementation implementation) -> NumericalMathFunction
        __init__(OT::NumericalMathFunction self, NumericalMathEvaluationImplementation evaluation) -> NumericalMathFunction
        __init__(OT::NumericalMathFunction self, NumericalMathFunction left, NumericalMathFunction right) -> NumericalMathFunction
        __init__(OT::NumericalMathFunction self, Description inputVariablesNames, Description outputVariablesNames, Description formulas) -> NumericalMathFunction
        __init__(OT::NumericalMathFunction self, Description inputVariablesNames, Description formulas) -> NumericalMathFunction
        __init__(OT::NumericalMathFunction self, NumericalMathFunction function, ComparisonOperator comparisonOperator, OT::NumericalScalar const threshold) -> NumericalMathFunction
        __init__(OT::NumericalMathFunction self, NumericalMathFunctionCollection functionCollection) -> NumericalMathFunction
        __init__(OT::NumericalMathFunction self, NumericalMathFunctionCollection functionCollection, NumericalPoint coefficients) -> NumericalMathFunction
        __init__(OT::NumericalMathFunction self, NumericalMathFunctionCollection functionCollection, NumericalSample coefficients) -> NumericalMathFunction
        __init__(OT::NumericalMathFunction self, OT::String const & inputVariableName, OT::String const & formula, OT::String const & outputVariableName="outputVariable") -> NumericalMathFunction
        __init__(OT::NumericalMathFunction self, OT::String const & inputVariableName, OT::String const & formula) -> NumericalMathFunction
        __init__(OT::NumericalMathFunction self, WrapperFile wrapperFile) -> NumericalMathFunction
        __init__(OT::NumericalMathFunction self, NumericalSample inputSample, NumericalSample outputSample) -> NumericalMathFunction
        __init__(OT::NumericalMathFunction self, PyObject * pyObj) -> NumericalMathFunction
        __init__(OT::NumericalMathFunction self, NumericalMathFunction other) -> NumericalMathFunction
        """
        this = _func.new_NumericalMathFunction(*args)
        try: self.this.append(this)
        except: self.this = this
    __swig_destroy__ = _func.delete_NumericalMathFunction
    __del__ = lambda self : None;
NumericalMathFunction_swigregister = _func.NumericalMathFunction_swigregister
NumericalMathFunction_swigregister(NumericalMathFunction)

def NumericalMathFunction_GetClassName():
  """NumericalMathFunction_GetClassName() -> OT::String"""
  return _func.NumericalMathFunction_GetClassName()

def NumericalMathFunction_GetValidConstants():
  """NumericalMathFunction_GetValidConstants() -> Description"""
  return _func.NumericalMathFunction_GetValidConstants()

def NumericalMathFunction_GetValidFunctions():
  """NumericalMathFunction_GetValidFunctions() -> Description"""
  return _func.NumericalMathFunction_GetValidFunctions()

def NumericalMathFunction_GetValidOperators():
  """NumericalMathFunction_GetValidOperators() -> Description"""
  return _func.NumericalMathFunction_GetValidOperators()

# We have to make sure the submodule is loaded with absolute path
import openturns.typ

class OpenTURNSPythonFunction(object):
    """
    OpenTURNSPythonFunction is a class to subclass
    before it can be passed on to a NumericalMathFunction
    -----

    Constructor arguments:
    n: an integer, the input dimension
    p: an integer, the output dimension

    Functions to overload:
    _exec(X): single evaluation, X is a sequence of scalars
    _exec_sample(X): multiple evaluations, X is a 2-d sequence of scalars
    """
    def __init__(self, n=0, p=0) :
        try:
            self.__n = int(n)
        except:
            raise TypeError( 'n argument is not an integer.' )
        try:
            self.__p = int(p)
        except:
            raise TypeError( 'p argument is not an integer.' )
        self.__descIn  = map( lambda i: 'x' + str(i), range(n) )
        self.__descOut = map( lambda i: 'y' + str(i), range(p) )
        
    def setInputDescription(self, descIn):
        if (len(descIn) != self.__n):
            raise ValueError( 'Input description size does NOT match input dimension' )
        self.__descIn  = descIn

    def getInputDescription(self):
        return self.__descIn

    def setOutputDescription(self, descOut):
        if (len(descOut) != self.__p):
            raise ValueError( 'Output description size does NOT match output dimension' )
        self.__descOut  = descOut

    def getOutputDescription(self):
        return self.__descOut

    def getInputDimension(self) :
        return self.__n

    def getOutputDimension(self) :
        return self.__p

    def __str__(self):
        return 'OpenTURNSPythonFunction( %s #%d ) -> %s #%d' % (self.__descIn, self.__n, self.__descOut, self.__p)

    def __repr__(self):
        return self.__str__()

    def __call__(self, X) :
        Y = None
        try:
            pt = openturns.typ.NumericalPoint( X )
        except TypeError:
            try:
                ns = openturns.typ.NumericalSample( X )
            except TypeError:
                raise TypeError( 'Expect a 1-d or 2-d float sequence as argument' )
            else :
                Y = self._exec_sample( ns )
        else :
            Y = self._exec( pt )
        return Y

    def _exec(self, X) :
        if ( not hasattr( self, 'f' ) ):
            raise RuntimeError( 'You must define a method f(X) -> Y, where X and Y are 1-d float sequence objects' )
        import warnings
        warnings.warn( 'usage of method named "f" is now deprecated. Rename it to "_exec" instead', DeprecationWarning )
        return self.f( X )

    def f(self, X) :
        raise RuntimeError( 'You must define a method f(X) -> Y, where X and Y are 1-d float sequence objects' )

    def _exec_sample(self, X) :
        res = list()
        for point in X:
            res.append( self._exec( point ) )
        return res

        

class PythonFunction(NumericalMathFunction):
    """
    PythonFunction allows to build an OpenTURNS function
    from a python function and its dimension attributes
    -----

    Arguments:
    n: an integer, the input dimension
    p: an integer, the output dimension
    func: a pure python function, called on a single point
    func_sample: a pure python function, called on multiple points at once

    Note: you may either one of func or func_sample arguments
    """
    def __new__(self, n, p, func=None, func_sample=None):

        class OpenTURNSPythonFunctionAdvanced(OpenTURNSPythonFunction) :
            def __init__(self, n, p, func=None, func_sample=None) :
                if func == None and func_sample == None:
                    raise RuntimeError( 'no func nor func_sample given.' )
                super(OpenTURNSPythonFunctionAdvanced, self).__init__(n, p)
                import collections
                if func != None:
                    if not isinstance(func, collections.Callable):
                        raise RuntimeError( 'func argument is not callable.' )
                    self._exec = func
                    self.__class__.__name__ = func.__name__
                if func_sample != None:
                    if not isinstance(func_sample, collections.Callable):
                        raise RuntimeError( 'func_sample argument is not callable.' )
                    self._exec_sample = func_sample
                    # implement exec from exec_sample
                    if func == None:
                        self.__class__.__name__ = func_sample.__name__
                        self._exec = self.exec_point_on_exec_sample

            def exec_point_on_exec_sample(self, X):
                return self._exec_sample([X])[0]

        instance = OpenTURNSPythonFunctionAdvanced(n, p, func, func_sample)
        return NumericalMathFunction(instance)

class DynamicalFunctionImplementation(openturns.common.PersistentObject):
    """Proxy of C++ OT::DynamicalFunctionImplementation class"""
    __swig_setmethods__ = {}
    for _s in [openturns.common.PersistentObject]: __swig_setmethods__.update(getattr(_s,'__swig_setmethods__',{}))
    __setattr__ = lambda self, name, value: _swig_setattr(self, DynamicalFunctionImplementation, name, value)
    __swig_getmethods__ = {}
    for _s in [openturns.common.PersistentObject]: __swig_getmethods__.update(getattr(_s,'__swig_getmethods__',{}))
    __getattr__ = lambda self, name: _swig_getattr(self, DynamicalFunctionImplementation, name)
    def GetClassName():
        """GetClassName() -> OT::String"""
        return _func.DynamicalFunctionImplementation_GetClassName()

    if _newclass:GetClassName = staticmethod(GetClassName)
    __swig_getmethods__["GetClassName"] = lambda x: GetClassName
    def getClassName(self):
        """getClassName(DynamicalFunctionImplementation self) -> OT::String"""
        return _func.DynamicalFunctionImplementation_getClassName(self)

    def __eq__(self, *args):
        """__eq__(DynamicalFunctionImplementation self, DynamicalFunctionImplementation other) -> OT::Bool"""
        return _func.DynamicalFunctionImplementation___eq__(self, *args)

    def __repr__(self):
        """__repr__(DynamicalFunctionImplementation self) -> OT::String"""
        return _func.DynamicalFunctionImplementation___repr__(self)

    def __str__(self, offset=""):
        """
        __str__(DynamicalFunctionImplementation self, OT::String const & offset="") -> OT::String
        __str__(DynamicalFunctionImplementation self) -> OT::String
        """
        return _func.DynamicalFunctionImplementation___str__(self, offset)

    def __call__(self, *args):
        """
        __call__(DynamicalFunctionImplementation self, OT::NumericalScalar const timeStamp, NumericalPoint inP) -> NumericalPoint
        __call__(DynamicalFunctionImplementation self, TimeSeries inTS) -> TimeSeries
        __call__(DynamicalFunctionImplementation self, ProcessSample inPS) -> ProcessSample
        """
        return _func.DynamicalFunctionImplementation___call__(self, *args)

    def getInputDimension(self):
        """getInputDimension(DynamicalFunctionImplementation self) -> OT::UnsignedLong"""
        return _func.DynamicalFunctionImplementation_getInputDimension(self)

    def getOutputDimension(self):
        """getOutputDimension(DynamicalFunctionImplementation self) -> OT::UnsignedLong"""
        return _func.DynamicalFunctionImplementation_getOutputDimension(self)

    def setInputDescription(self, *args):
        """setInputDescription(DynamicalFunctionImplementation self, Description inputDescription)"""
        return _func.DynamicalFunctionImplementation_setInputDescription(self, *args)

    def getInputDescription(self):
        """getInputDescription(DynamicalFunctionImplementation self) -> Description"""
        return _func.DynamicalFunctionImplementation_getInputDescription(self)

    def setOutputDescription(self, *args):
        """setOutputDescription(DynamicalFunctionImplementation self, Description outputDescription)"""
        return _func.DynamicalFunctionImplementation_setOutputDescription(self, *args)

    def getOutputDescription(self):
        """getOutputDescription(DynamicalFunctionImplementation self) -> Description"""
        return _func.DynamicalFunctionImplementation_getOutputDescription(self)

    def getMarginal(self, *args):
        """
        getMarginal(DynamicalFunctionImplementation self, OT::UnsignedLong const i) -> OT::DynamicalFunctionImplementation::Implementation
        getMarginal(DynamicalFunctionImplementation self, Indices indices) -> OT::DynamicalFunctionImplementation::Implementation
        """
        return _func.DynamicalFunctionImplementation_getMarginal(self, *args)

    def getCallsNumber(self):
        """getCallsNumber(DynamicalFunctionImplementation self) -> OT::UnsignedLong"""
        return _func.DynamicalFunctionImplementation_getCallsNumber(self)

    def computeOutputTimeGrid(self, *args):
        """computeOutputTimeGrid(DynamicalFunctionImplementation self, RegularGrid inputTimeGrid) -> RegularGrid"""
        return _func.DynamicalFunctionImplementation_computeOutputTimeGrid(self, *args)

    def __init__(self, *args): 
        """
        __init__(OT::DynamicalFunctionImplementation self) -> DynamicalFunctionImplementation
        __init__(OT::DynamicalFunctionImplementation self, DynamicalFunctionImplementation other) -> DynamicalFunctionImplementation
        """
        this = _func.new_DynamicalFunctionImplementation(*args)
        try: self.this.append(this)
        except: self.this = this
    __swig_destroy__ = _func.delete_DynamicalFunctionImplementation
    __del__ = lambda self : None;
DynamicalFunctionImplementation_swigregister = _func.DynamicalFunctionImplementation_swigregister
DynamicalFunctionImplementation_swigregister(DynamicalFunctionImplementation)

def DynamicalFunctionImplementation_GetClassName():
  """DynamicalFunctionImplementation_GetClassName() -> OT::String"""
  return _func.DynamicalFunctionImplementation_GetClassName()

class DynamicalFunctionImplementationTypedInterfaceObject(openturns.common.InterfaceObject):
    """Proxy of C++ OT::TypedInterfaceObject<(OT::DynamicalFunctionImplementation)> class"""
    __swig_setmethods__ = {}
    for _s in [openturns.common.InterfaceObject]: __swig_setmethods__.update(getattr(_s,'__swig_setmethods__',{}))
    __setattr__ = lambda self, name, value: _swig_setattr(self, DynamicalFunctionImplementationTypedInterfaceObject, name, value)
    __swig_getmethods__ = {}
    for _s in [openturns.common.InterfaceObject]: __swig_getmethods__.update(getattr(_s,'__swig_getmethods__',{}))
    __getattr__ = lambda self, name: _swig_getattr(self, DynamicalFunctionImplementationTypedInterfaceObject, name)
    __repr__ = _swig_repr
    def __init__(self, *args): 
        """
        __init__(OT::TypedInterfaceObject<(OT::DynamicalFunctionImplementation)> self) -> DynamicalFunctionImplementationTypedInterfaceObject
        __init__(OT::TypedInterfaceObject<(OT::DynamicalFunctionImplementation)> self, OT::TypedInterfaceObject< OT::DynamicalFunctionImplementation >::Implementation const & impl) -> DynamicalFunctionImplementationTypedInterfaceObject
        """
        this = _func.new_DynamicalFunctionImplementationTypedInterfaceObject(*args)
        try: self.this.append(this)
        except: self.this = this
    def getImplementation(self, *args):
        """
        getImplementation(DynamicalFunctionImplementationTypedInterfaceObject self) -> OT::TypedInterfaceObject< OT::DynamicalFunctionImplementation >::Implementation
        getImplementation(DynamicalFunctionImplementationTypedInterfaceObject self) -> OT::TypedInterfaceObject< OT::DynamicalFunctionImplementation >::Implementation const &
        """
        return _func.DynamicalFunctionImplementationTypedInterfaceObject_getImplementation(self, *args)

    def getImplementationAsPersistentObject(self):
        """getImplementationAsPersistentObject(DynamicalFunctionImplementationTypedInterfaceObject self) -> PersistentObjectPointer"""
        return _func.DynamicalFunctionImplementationTypedInterfaceObject_getImplementationAsPersistentObject(self)

    def setImplementationAsPersistentObject(self, *args):
        """setImplementationAsPersistentObject(DynamicalFunctionImplementationTypedInterfaceObject self, PersistentObjectPointer obj)"""
        return _func.DynamicalFunctionImplementationTypedInterfaceObject_setImplementationAsPersistentObject(self, *args)

    def swap(self, *args):
        """swap(DynamicalFunctionImplementationTypedInterfaceObject self, DynamicalFunctionImplementationTypedInterfaceObject other)"""
        return _func.DynamicalFunctionImplementationTypedInterfaceObject_swap(self, *args)

    def setName(self, *args):
        """setName(DynamicalFunctionImplementationTypedInterfaceObject self, OT::String const & name)"""
        return _func.DynamicalFunctionImplementationTypedInterfaceObject_setName(self, *args)

    def getName(self):
        """getName(DynamicalFunctionImplementationTypedInterfaceObject self) -> OT::String"""
        return _func.DynamicalFunctionImplementationTypedInterfaceObject_getName(self)

    def __eq__(self, *args):
        """__eq__(DynamicalFunctionImplementationTypedInterfaceObject self, DynamicalFunctionImplementationTypedInterfaceObject other) -> OT::Bool"""
        return _func.DynamicalFunctionImplementationTypedInterfaceObject___eq__(self, *args)

    __swig_destroy__ = _func.delete_DynamicalFunctionImplementationTypedInterfaceObject
    __del__ = lambda self : None;
DynamicalFunctionImplementationTypedInterfaceObject_swigregister = _func.DynamicalFunctionImplementationTypedInterfaceObject_swigregister
DynamicalFunctionImplementationTypedInterfaceObject_swigregister(DynamicalFunctionImplementationTypedInterfaceObject)

class DynamicalFunction(DynamicalFunctionImplementationTypedInterfaceObject):
    """Proxy of C++ OT::DynamicalFunction class"""
    __swig_setmethods__ = {}
    for _s in [DynamicalFunctionImplementationTypedInterfaceObject]: __swig_setmethods__.update(getattr(_s,'__swig_setmethods__',{}))
    __setattr__ = lambda self, name, value: _swig_setattr(self, DynamicalFunction, name, value)
    __swig_getmethods__ = {}
    for _s in [DynamicalFunctionImplementationTypedInterfaceObject]: __swig_getmethods__.update(getattr(_s,'__swig_getmethods__',{}))
    __getattr__ = lambda self, name: _swig_getattr(self, DynamicalFunction, name)
    def GetClassName():
        """GetClassName() -> OT::String"""
        return _func.DynamicalFunction_GetClassName()

    if _newclass:GetClassName = staticmethod(GetClassName)
    __swig_getmethods__["GetClassName"] = lambda x: GetClassName
    def getClassName(self):
        """getClassName(DynamicalFunction self) -> OT::String"""
        return _func.DynamicalFunction_getClassName(self)

    def __eq__(self, *args):
        """__eq__(DynamicalFunction self, DynamicalFunction other) -> OT::Bool"""
        return _func.DynamicalFunction___eq__(self, *args)

    def __repr__(self):
        """__repr__(DynamicalFunction self) -> OT::String"""
        return _func.DynamicalFunction___repr__(self)

    def __str__(self, offset=""):
        """
        __str__(DynamicalFunction self, OT::String const & offset="") -> OT::String
        __str__(DynamicalFunction self) -> OT::String
        """
        return _func.DynamicalFunction___str__(self, offset)

    def __call__(self, *args):
        """
        __call__(DynamicalFunction self, OT::NumericalScalar const timeStamp, NumericalPoint inP) -> NumericalPoint
        __call__(DynamicalFunction self, TimeSeries inTS) -> TimeSeries
        __call__(DynamicalFunction self, ProcessSample inPS) -> ProcessSample
        """
        return _func.DynamicalFunction___call__(self, *args)

    def getMarginal(self, *args):
        """
        getMarginal(DynamicalFunction self, OT::UnsignedLong const i) -> DynamicalFunction
        getMarginal(DynamicalFunction self, Indices indices) -> DynamicalFunction
        """
        return _func.DynamicalFunction_getMarginal(self, *args)

    def getInputDimension(self):
        """getInputDimension(DynamicalFunction self) -> OT::UnsignedLong"""
        return _func.DynamicalFunction_getInputDimension(self)

    def getOutputDimension(self):
        """getOutputDimension(DynamicalFunction self) -> OT::UnsignedLong"""
        return _func.DynamicalFunction_getOutputDimension(self)

    def getInputDescription(self):
        """getInputDescription(DynamicalFunction self) -> Description"""
        return _func.DynamicalFunction_getInputDescription(self)

    def getOutputDescription(self):
        """getOutputDescription(DynamicalFunction self) -> Description"""
        return _func.DynamicalFunction_getOutputDescription(self)

    def getCallsNumber(self):
        """getCallsNumber(DynamicalFunction self) -> OT::UnsignedLong"""
        return _func.DynamicalFunction_getCallsNumber(self)

    def __init__(self, *args): 
        """
        __init__(OT::DynamicalFunction self) -> DynamicalFunction
        __init__(OT::DynamicalFunction self, NumericalMathFunction function) -> DynamicalFunction
        __init__(OT::DynamicalFunction self, DynamicalFunctionImplementation implementation) -> DynamicalFunction
        __init__(OT::DynamicalFunction self, OT::TypedInterfaceObject< OT::DynamicalFunctionImplementation >::Implementation const & p_implementation) -> DynamicalFunction
        __init__(OT::DynamicalFunction self, DynamicalFunction other) -> DynamicalFunction
        """
        this = _func.new_DynamicalFunction(*args)
        try: self.this.append(this)
        except: self.this = this
    __swig_destroy__ = _func.delete_DynamicalFunction
    __del__ = lambda self : None;
DynamicalFunction_swigregister = _func.DynamicalFunction_swigregister
DynamicalFunction_swigregister(DynamicalFunction)

def DynamicalFunction_GetClassName():
  """DynamicalFunction_GetClassName() -> OT::String"""
  return _func.DynamicalFunction_GetClassName()

class SpatialFunction(DynamicalFunctionImplementation):
    """Proxy of C++ OT::SpatialFunction class"""
    __swig_setmethods__ = {}
    for _s in [DynamicalFunctionImplementation]: __swig_setmethods__.update(getattr(_s,'__swig_setmethods__',{}))
    __setattr__ = lambda self, name, value: _swig_setattr(self, SpatialFunction, name, value)
    __swig_getmethods__ = {}
    for _s in [DynamicalFunctionImplementation]: __swig_getmethods__.update(getattr(_s,'__swig_getmethods__',{}))
    __getattr__ = lambda self, name: _swig_getattr(self, SpatialFunction, name)
    def GetClassName():
        """GetClassName() -> OT::String"""
        return _func.SpatialFunction_GetClassName()

    if _newclass:GetClassName = staticmethod(GetClassName)
    __swig_getmethods__["GetClassName"] = lambda x: GetClassName
    def getClassName(self):
        """getClassName(SpatialFunction self) -> OT::String"""
        return _func.SpatialFunction_getClassName(self)

    def __eq__(self, *args):
        """__eq__(SpatialFunction self, SpatialFunction other) -> OT::Bool"""
        return _func.SpatialFunction___eq__(self, *args)

    def __repr__(self):
        """__repr__(SpatialFunction self) -> OT::String"""
        return _func.SpatialFunction___repr__(self)

    def __str__(self, offset=""):
        """
        __str__(SpatialFunction self, OT::String const & offset="") -> OT::String
        __str__(SpatialFunction self) -> OT::String
        """
        return _func.SpatialFunction___str__(self, offset)

    def __call__(self, *args):
        """__call__(SpatialFunction self, TimeSeries inTS) -> TimeSeries"""
        return _func.SpatialFunction___call__(self, *args)

    def getMarginal(self, *args):
        """
        getMarginal(SpatialFunction self, OT::UnsignedLong const i) -> OT::DynamicalFunctionImplementation::Implementation
        getMarginal(SpatialFunction self, Indices indices) -> OT::DynamicalFunctionImplementation::Implementation
        """
        return _func.SpatialFunction_getMarginal(self, *args)

    def getEvaluation(self):
        """getEvaluation(SpatialFunction self) -> EvaluationImplementation"""
        return _func.SpatialFunction_getEvaluation(self)

    def __init__(self, *args): 
        """
        __init__(OT::SpatialFunction self) -> SpatialFunction
        __init__(OT::SpatialFunction self, NumericalMathFunction function) -> SpatialFunction
        __init__(OT::SpatialFunction self, NumericalMathEvaluationImplementation evaluation) -> SpatialFunction
        __init__(OT::SpatialFunction self, SpatialFunction other) -> SpatialFunction
        """
        this = _func.new_SpatialFunction(*args)
        try: self.this.append(this)
        except: self.this = this
    __swig_destroy__ = _func.delete_SpatialFunction
    __del__ = lambda self : None;
SpatialFunction_swigregister = _func.SpatialFunction_swigregister
SpatialFunction_swigregister(SpatialFunction)

def SpatialFunction_GetClassName():
  """SpatialFunction_GetClassName() -> OT::String"""
  return _func.SpatialFunction_GetClassName()

class TemporalFunction(DynamicalFunctionImplementation):
    """Proxy of C++ OT::TemporalFunction class"""
    __swig_setmethods__ = {}
    for _s in [DynamicalFunctionImplementation]: __swig_setmethods__.update(getattr(_s,'__swig_setmethods__',{}))
    __setattr__ = lambda self, name, value: _swig_setattr(self, TemporalFunction, name, value)
    __swig_getmethods__ = {}
    for _s in [DynamicalFunctionImplementation]: __swig_getmethods__.update(getattr(_s,'__swig_getmethods__',{}))
    __getattr__ = lambda self, name: _swig_getattr(self, TemporalFunction, name)
    def GetClassName():
        """GetClassName() -> OT::String"""
        return _func.TemporalFunction_GetClassName()

    if _newclass:GetClassName = staticmethod(GetClassName)
    __swig_getmethods__["GetClassName"] = lambda x: GetClassName
    def getClassName(self):
        """getClassName(TemporalFunction self) -> OT::String"""
        return _func.TemporalFunction_getClassName(self)

    def __eq__(self, *args):
        """__eq__(TemporalFunction self, TemporalFunction other) -> OT::Bool"""
        return _func.TemporalFunction___eq__(self, *args)

    def __repr__(self):
        """__repr__(TemporalFunction self) -> OT::String"""
        return _func.TemporalFunction___repr__(self)

    def __str__(self, offset=""):
        """
        __str__(TemporalFunction self, OT::String const & offset="") -> OT::String
        __str__(TemporalFunction self) -> OT::String
        """
        return _func.TemporalFunction___str__(self, offset)

    def __call__(self, *args):
        """__call__(TemporalFunction self, TimeSeries inTS) -> TimeSeries"""
        return _func.TemporalFunction___call__(self, *args)

    def getMarginal(self, *args):
        """
        getMarginal(TemporalFunction self, OT::UnsignedLong const i) -> OT::DynamicalFunctionImplementation::Implementation
        getMarginal(TemporalFunction self, Indices indices) -> OT::DynamicalFunctionImplementation::Implementation
        """
        return _func.TemporalFunction_getMarginal(self, *args)

    def getEvaluation(self):
        """getEvaluation(TemporalFunction self) -> EvaluationImplementation"""
        return _func.TemporalFunction_getEvaluation(self)

    def __init__(self, *args): 
        """
        __init__(OT::TemporalFunction self) -> TemporalFunction
        __init__(OT::TemporalFunction self, NumericalMathFunction function) -> TemporalFunction
        __init__(OT::TemporalFunction self, NumericalMathEvaluationImplementation evaluation) -> TemporalFunction
        __init__(OT::TemporalFunction self, TemporalFunction other) -> TemporalFunction
        """
        this = _func.new_TemporalFunction(*args)
        try: self.this.append(this)
        except: self.this = this
    __swig_destroy__ = _func.delete_TemporalFunction
    __del__ = lambda self : None;
TemporalFunction_swigregister = _func.TemporalFunction_swigregister
TemporalFunction_swigregister(TemporalFunction)

def TemporalFunction_GetClassName():
  """TemporalFunction_GetClassName() -> OT::String"""
  return _func.TemporalFunction_GetClassName()

class ComposedNumericalMathFunction(NumericalMathFunctionImplementation):
    """Proxy of C++ OT::ComposedNumericalMathFunction class"""
    __swig_setmethods__ = {}
    for _s in [NumericalMathFunctionImplementation]: __swig_setmethods__.update(getattr(_s,'__swig_setmethods__',{}))
    __setattr__ = lambda self, name, value: _swig_setattr(self, ComposedNumericalMathFunction, name, value)
    __swig_getmethods__ = {}
    for _s in [NumericalMathFunctionImplementation]: __swig_getmethods__.update(getattr(_s,'__swig_getmethods__',{}))
    __getattr__ = lambda self, name: _swig_getattr(self, ComposedNumericalMathFunction, name)
    def GetClassName():
        """GetClassName() -> OT::String"""
        return _func.ComposedNumericalMathFunction_GetClassName()

    if _newclass:GetClassName = staticmethod(GetClassName)
    __swig_getmethods__["GetClassName"] = lambda x: GetClassName
    def getClassName(self):
        """getClassName(ComposedNumericalMathFunction self) -> OT::String"""
        return _func.ComposedNumericalMathFunction_getClassName(self)

    def __eq__(self, *args):
        """__eq__(ComposedNumericalMathFunction self, ComposedNumericalMathFunction other) -> OT::Bool"""
        return _func.ComposedNumericalMathFunction___eq__(self, *args)

    def __repr__(self):
        """__repr__(ComposedNumericalMathFunction self) -> OT::String"""
        return _func.ComposedNumericalMathFunction___repr__(self)

    def parametersGradient(self, *args):
        """parametersGradient(ComposedNumericalMathFunction self, NumericalPoint inP) -> Matrix"""
        return _func.ComposedNumericalMathFunction_parametersGradient(self, *args)

    def __init__(self, *args): 
        """
        __init__(OT::ComposedNumericalMathFunction self) -> ComposedNumericalMathFunction
        __init__(OT::ComposedNumericalMathFunction self, NumericalMathFunctionImplementationPointer p_left, NumericalMathFunctionImplementationPointer p_right) -> ComposedNumericalMathFunction
        __init__(OT::ComposedNumericalMathFunction self, NumericalMathFunction left, NumericalMathFunction right) -> ComposedNumericalMathFunction
        __init__(OT::ComposedNumericalMathFunction self, ComposedNumericalMathFunction other) -> ComposedNumericalMathFunction
        """
        this = _func.new_ComposedNumericalMathFunction(*args)
        try: self.this.append(this)
        except: self.this = this
    __swig_destroy__ = _func.delete_ComposedNumericalMathFunction
    __del__ = lambda self : None;
ComposedNumericalMathFunction_swigregister = _func.ComposedNumericalMathFunction_swigregister
ComposedNumericalMathFunction_swigregister(ComposedNumericalMathFunction)

def ComposedNumericalMathFunction_GetClassName():
  """ComposedNumericalMathFunction_GetClassName() -> OT::String"""
  return _func.ComposedNumericalMathFunction_GetClassName()

class DualLinearCombinationEvaluationImplementation(NumericalMathEvaluationImplementation):
    """Proxy of C++ OT::DualLinearCombinationEvaluationImplementation class"""
    __swig_setmethods__ = {}
    for _s in [NumericalMathEvaluationImplementation]: __swig_setmethods__.update(getattr(_s,'__swig_setmethods__',{}))
    __setattr__ = lambda self, name, value: _swig_setattr(self, DualLinearCombinationEvaluationImplementation, name, value)
    __swig_getmethods__ = {}
    for _s in [NumericalMathEvaluationImplementation]: __swig_getmethods__.update(getattr(_s,'__swig_getmethods__',{}))
    __getattr__ = lambda self, name: _swig_getattr(self, DualLinearCombinationEvaluationImplementation, name)
    def GetClassName():
        """GetClassName() -> OT::String"""
        return _func.DualLinearCombinationEvaluationImplementation_GetClassName()

    if _newclass:GetClassName = staticmethod(GetClassName)
    __swig_getmethods__["GetClassName"] = lambda x: GetClassName
    def getClassName(self):
        """getClassName(DualLinearCombinationEvaluationImplementation self) -> OT::String"""
        return _func.DualLinearCombinationEvaluationImplementation_getClassName(self)

    def setDescription(self, *args):
        """setDescription(DualLinearCombinationEvaluationImplementation self, Description description)"""
        return _func.DualLinearCombinationEvaluationImplementation_setDescription(self, *args)

    def __repr__(self):
        """__repr__(DualLinearCombinationEvaluationImplementation self) -> OT::String"""
        return _func.DualLinearCombinationEvaluationImplementation___repr__(self)

    def __str__(self, offset=""):
        """
        __str__(DualLinearCombinationEvaluationImplementation self, OT::String const & offset="") -> OT::String
        __str__(DualLinearCombinationEvaluationImplementation self) -> OT::String
        """
        return _func.DualLinearCombinationEvaluationImplementation___str__(self, offset)

    def __call__(self, *args):
        """__call__(DualLinearCombinationEvaluationImplementation self, NumericalPoint inP) -> NumericalPoint"""
        return _func.DualLinearCombinationEvaluationImplementation___call__(self, *args)

    def getCoefficients(self):
        """getCoefficients(DualLinearCombinationEvaluationImplementation self) -> NumericalSample"""
        return _func.DualLinearCombinationEvaluationImplementation_getCoefficients(self)

    def getFunctionsCollection(self):
        """getFunctionsCollection(DualLinearCombinationEvaluationImplementation self) -> NumericalMathFunctionCollection"""
        return _func.DualLinearCombinationEvaluationImplementation_getFunctionsCollection(self)

    def setFunctionsCollectionAndCoefficients(self, *args):
        """setFunctionsCollectionAndCoefficients(DualLinearCombinationEvaluationImplementation self, NumericalMathFunctionCollection functionsCollection, NumericalSample coefficients)"""
        return _func.DualLinearCombinationEvaluationImplementation_setFunctionsCollectionAndCoefficients(self, *args)

    def getInputDimension(self):
        """getInputDimension(DualLinearCombinationEvaluationImplementation self) -> OT::UnsignedLong"""
        return _func.DualLinearCombinationEvaluationImplementation_getInputDimension(self)

    def getOutputDimension(self):
        """getOutputDimension(DualLinearCombinationEvaluationImplementation self) -> OT::UnsignedLong"""
        return _func.DualLinearCombinationEvaluationImplementation_getOutputDimension(self)

    def parametersGradient(self, *args):
        """parametersGradient(DualLinearCombinationEvaluationImplementation self, NumericalPoint inP) -> Matrix"""
        return _func.DualLinearCombinationEvaluationImplementation_parametersGradient(self, *args)

    def getParameters(self):
        """getParameters(DualLinearCombinationEvaluationImplementation self) -> NumericalPointWithDescription"""
        return _func.DualLinearCombinationEvaluationImplementation_getParameters(self)

    def getMarginal(self, *args):
        """
        getMarginal(DualLinearCombinationEvaluationImplementation self, OT::UnsignedLong const i) -> EvaluationImplementation
        getMarginal(DualLinearCombinationEvaluationImplementation self, Indices indices) -> EvaluationImplementation
        """
        return _func.DualLinearCombinationEvaluationImplementation_getMarginal(self, *args)

    def __init__(self, *args): 
        """
        __init__(OT::DualLinearCombinationEvaluationImplementation self) -> DualLinearCombinationEvaluationImplementation
        __init__(OT::DualLinearCombinationEvaluationImplementation self, NumericalMathFunctionCollection functionsCollection, NumericalSample coefficients) -> DualLinearCombinationEvaluationImplementation
        __init__(OT::DualLinearCombinationEvaluationImplementation self, DualLinearCombinationEvaluationImplementation other) -> DualLinearCombinationEvaluationImplementation
        """
        this = _func.new_DualLinearCombinationEvaluationImplementation(*args)
        try: self.this.append(this)
        except: self.this = this
    __swig_destroy__ = _func.delete_DualLinearCombinationEvaluationImplementation
    __del__ = lambda self : None;
DualLinearCombinationEvaluationImplementation_swigregister = _func.DualLinearCombinationEvaluationImplementation_swigregister
DualLinearCombinationEvaluationImplementation_swigregister(DualLinearCombinationEvaluationImplementation)

def DualLinearCombinationEvaluationImplementation_GetClassName():
  """DualLinearCombinationEvaluationImplementation_GetClassName() -> OT::String"""
  return _func.DualLinearCombinationEvaluationImplementation_GetClassName()

class DualLinearCombinationGradientImplementation(NumericalMathGradientImplementation):
    """Proxy of C++ OT::DualLinearCombinationGradientImplementation class"""
    __swig_setmethods__ = {}
    for _s in [NumericalMathGradientImplementation]: __swig_setmethods__.update(getattr(_s,'__swig_setmethods__',{}))
    __setattr__ = lambda self, name, value: _swig_setattr(self, DualLinearCombinationGradientImplementation, name, value)
    __swig_getmethods__ = {}
    for _s in [NumericalMathGradientImplementation]: __swig_getmethods__.update(getattr(_s,'__swig_getmethods__',{}))
    __getattr__ = lambda self, name: _swig_getattr(self, DualLinearCombinationGradientImplementation, name)
    def GetClassName():
        """GetClassName() -> OT::String"""
        return _func.DualLinearCombinationGradientImplementation_GetClassName()

    if _newclass:GetClassName = staticmethod(GetClassName)
    __swig_getmethods__["GetClassName"] = lambda x: GetClassName
    def getClassName(self):
        """getClassName(DualLinearCombinationGradientImplementation self) -> OT::String"""
        return _func.DualLinearCombinationGradientImplementation_getClassName(self)

    def gradient(self, *args):
        """gradient(DualLinearCombinationGradientImplementation self, NumericalPoint inP) -> Matrix"""
        return _func.DualLinearCombinationGradientImplementation_gradient(self, *args)

    def getInputDimension(self):
        """getInputDimension(DualLinearCombinationGradientImplementation self) -> OT::UnsignedLong"""
        return _func.DualLinearCombinationGradientImplementation_getInputDimension(self)

    def getOutputDimension(self):
        """getOutputDimension(DualLinearCombinationGradientImplementation self) -> OT::UnsignedLong"""
        return _func.DualLinearCombinationGradientImplementation_getOutputDimension(self)

    def __repr__(self):
        """__repr__(DualLinearCombinationGradientImplementation self) -> OT::String"""
        return _func.DualLinearCombinationGradientImplementation___repr__(self)

    def __init__(self, *args): 
        """
        __init__(OT::DualLinearCombinationGradientImplementation self) -> DualLinearCombinationGradientImplementation
        __init__(OT::DualLinearCombinationGradientImplementation self, DualLinearCombinationEvaluationImplementation evaluation) -> DualLinearCombinationGradientImplementation
        __init__(OT::DualLinearCombinationGradientImplementation self, DualLinearCombinationGradientImplementation other) -> DualLinearCombinationGradientImplementation
        """
        this = _func.new_DualLinearCombinationGradientImplementation(*args)
        try: self.this.append(this)
        except: self.this = this
    __swig_destroy__ = _func.delete_DualLinearCombinationGradientImplementation
    __del__ = lambda self : None;
DualLinearCombinationGradientImplementation_swigregister = _func.DualLinearCombinationGradientImplementation_swigregister
DualLinearCombinationGradientImplementation_swigregister(DualLinearCombinationGradientImplementation)

def DualLinearCombinationGradientImplementation_GetClassName():
  """DualLinearCombinationGradientImplementation_GetClassName() -> OT::String"""
  return _func.DualLinearCombinationGradientImplementation_GetClassName()

class DualLinearCombinationHessianImplementation(NumericalMathHessianImplementation):
    """Proxy of C++ OT::DualLinearCombinationHessianImplementation class"""
    __swig_setmethods__ = {}
    for _s in [NumericalMathHessianImplementation]: __swig_setmethods__.update(getattr(_s,'__swig_setmethods__',{}))
    __setattr__ = lambda self, name, value: _swig_setattr(self, DualLinearCombinationHessianImplementation, name, value)
    __swig_getmethods__ = {}
    for _s in [NumericalMathHessianImplementation]: __swig_getmethods__.update(getattr(_s,'__swig_getmethods__',{}))
    __getattr__ = lambda self, name: _swig_getattr(self, DualLinearCombinationHessianImplementation, name)
    def GetClassName():
        """GetClassName() -> OT::String"""
        return _func.DualLinearCombinationHessianImplementation_GetClassName()

    if _newclass:GetClassName = staticmethod(GetClassName)
    __swig_getmethods__["GetClassName"] = lambda x: GetClassName
    def getClassName(self):
        """getClassName(DualLinearCombinationHessianImplementation self) -> OT::String"""
        return _func.DualLinearCombinationHessianImplementation_getClassName(self)

    def hessian(self, *args):
        """hessian(DualLinearCombinationHessianImplementation self, NumericalPoint inP) -> SymmetricTensor"""
        return _func.DualLinearCombinationHessianImplementation_hessian(self, *args)

    def getInputDimension(self):
        """getInputDimension(DualLinearCombinationHessianImplementation self) -> OT::UnsignedLong"""
        return _func.DualLinearCombinationHessianImplementation_getInputDimension(self)

    def getOutputDimension(self):
        """getOutputDimension(DualLinearCombinationHessianImplementation self) -> OT::UnsignedLong"""
        return _func.DualLinearCombinationHessianImplementation_getOutputDimension(self)

    def __repr__(self):
        """__repr__(DualLinearCombinationHessianImplementation self) -> OT::String"""
        return _func.DualLinearCombinationHessianImplementation___repr__(self)

    def __init__(self, *args): 
        """
        __init__(OT::DualLinearCombinationHessianImplementation self) -> DualLinearCombinationHessianImplementation
        __init__(OT::DualLinearCombinationHessianImplementation self, DualLinearCombinationEvaluationImplementation evaluation) -> DualLinearCombinationHessianImplementation
        __init__(OT::DualLinearCombinationHessianImplementation self, DualLinearCombinationHessianImplementation other) -> DualLinearCombinationHessianImplementation
        """
        this = _func.new_DualLinearCombinationHessianImplementation(*args)
        try: self.this.append(this)
        except: self.this = this
    __swig_destroy__ = _func.delete_DualLinearCombinationHessianImplementation
    __del__ = lambda self : None;
DualLinearCombinationHessianImplementation_swigregister = _func.DualLinearCombinationHessianImplementation_swigregister
DualLinearCombinationHessianImplementation_swigregister(DualLinearCombinationHessianImplementation)

def DualLinearCombinationHessianImplementation_GetClassName():
  """DualLinearCombinationHessianImplementation_GetClassName() -> OT::String"""
  return _func.DualLinearCombinationHessianImplementation_GetClassName()

class LinearCombinationEvaluationImplementation(NumericalMathEvaluationImplementation):
    """Proxy of C++ OT::LinearCombinationEvaluationImplementation class"""
    __swig_setmethods__ = {}
    for _s in [NumericalMathEvaluationImplementation]: __swig_setmethods__.update(getattr(_s,'__swig_setmethods__',{}))
    __setattr__ = lambda self, name, value: _swig_setattr(self, LinearCombinationEvaluationImplementation, name, value)
    __swig_getmethods__ = {}
    for _s in [NumericalMathEvaluationImplementation]: __swig_getmethods__.update(getattr(_s,'__swig_getmethods__',{}))
    __getattr__ = lambda self, name: _swig_getattr(self, LinearCombinationEvaluationImplementation, name)
    def GetClassName():
        """GetClassName() -> OT::String"""
        return _func.LinearCombinationEvaluationImplementation_GetClassName()

    if _newclass:GetClassName = staticmethod(GetClassName)
    __swig_getmethods__["GetClassName"] = lambda x: GetClassName
    def getClassName(self):
        """getClassName(LinearCombinationEvaluationImplementation self) -> OT::String"""
        return _func.LinearCombinationEvaluationImplementation_getClassName(self)

    def __repr__(self):
        """__repr__(LinearCombinationEvaluationImplementation self) -> OT::String"""
        return _func.LinearCombinationEvaluationImplementation___repr__(self)

    def __str__(self, offset=""):
        """
        __str__(LinearCombinationEvaluationImplementation self, OT::String const & offset="") -> OT::String
        __str__(LinearCombinationEvaluationImplementation self) -> OT::String
        """
        return _func.LinearCombinationEvaluationImplementation___str__(self, offset)

    def __call__(self, *args):
        """__call__(LinearCombinationEvaluationImplementation self, NumericalPoint inP) -> NumericalPoint"""
        return _func.LinearCombinationEvaluationImplementation___call__(self, *args)

    def getCoefficients(self):
        """getCoefficients(LinearCombinationEvaluationImplementation self) -> NumericalPoint"""
        return _func.LinearCombinationEvaluationImplementation_getCoefficients(self)

    def getFunctionsCollection(self):
        """getFunctionsCollection(LinearCombinationEvaluationImplementation self) -> NumericalMathFunctionCollection"""
        return _func.LinearCombinationEvaluationImplementation_getFunctionsCollection(self)

    def setFunctionsCollectionAndCoefficients(self, *args):
        """setFunctionsCollectionAndCoefficients(LinearCombinationEvaluationImplementation self, NumericalMathFunctionCollection functionsCollection, NumericalPoint coefficients)"""
        return _func.LinearCombinationEvaluationImplementation_setFunctionsCollectionAndCoefficients(self, *args)

    def getInputDimension(self):
        """getInputDimension(LinearCombinationEvaluationImplementation self) -> OT::UnsignedLong"""
        return _func.LinearCombinationEvaluationImplementation_getInputDimension(self)

    def getOutputDimension(self):
        """getOutputDimension(LinearCombinationEvaluationImplementation self) -> OT::UnsignedLong"""
        return _func.LinearCombinationEvaluationImplementation_getOutputDimension(self)

    def parametersGradient(self, *args):
        """parametersGradient(LinearCombinationEvaluationImplementation self, NumericalPoint inP) -> Matrix"""
        return _func.LinearCombinationEvaluationImplementation_parametersGradient(self, *args)

    def getParameters(self):
        """getParameters(LinearCombinationEvaluationImplementation self) -> NumericalPointWithDescription"""
        return _func.LinearCombinationEvaluationImplementation_getParameters(self)

    def getMarginal(self, *args):
        """
        getMarginal(LinearCombinationEvaluationImplementation self, OT::UnsignedLong const i) -> EvaluationImplementation
        getMarginal(LinearCombinationEvaluationImplementation self, Indices indices) -> EvaluationImplementation
        """
        return _func.LinearCombinationEvaluationImplementation_getMarginal(self, *args)

    def __init__(self, *args): 
        """
        __init__(OT::LinearCombinationEvaluationImplementation self) -> LinearCombinationEvaluationImplementation
        __init__(OT::LinearCombinationEvaluationImplementation self, NumericalMathFunctionCollection functionsCollection, NumericalPoint coefficients) -> LinearCombinationEvaluationImplementation
        __init__(OT::LinearCombinationEvaluationImplementation self, LinearCombinationEvaluationImplementation other) -> LinearCombinationEvaluationImplementation
        """
        this = _func.new_LinearCombinationEvaluationImplementation(*args)
        try: self.this.append(this)
        except: self.this = this
    __swig_destroy__ = _func.delete_LinearCombinationEvaluationImplementation
    __del__ = lambda self : None;
LinearCombinationEvaluationImplementation_swigregister = _func.LinearCombinationEvaluationImplementation_swigregister
LinearCombinationEvaluationImplementation_swigregister(LinearCombinationEvaluationImplementation)

def LinearCombinationEvaluationImplementation_GetClassName():
  """LinearCombinationEvaluationImplementation_GetClassName() -> OT::String"""
  return _func.LinearCombinationEvaluationImplementation_GetClassName()

class LinearCombinationGradientImplementation(NumericalMathGradientImplementation):
    """Proxy of C++ OT::LinearCombinationGradientImplementation class"""
    __swig_setmethods__ = {}
    for _s in [NumericalMathGradientImplementation]: __swig_setmethods__.update(getattr(_s,'__swig_setmethods__',{}))
    __setattr__ = lambda self, name, value: _swig_setattr(self, LinearCombinationGradientImplementation, name, value)
    __swig_getmethods__ = {}
    for _s in [NumericalMathGradientImplementation]: __swig_getmethods__.update(getattr(_s,'__swig_getmethods__',{}))
    __getattr__ = lambda self, name: _swig_getattr(self, LinearCombinationGradientImplementation, name)
    def GetClassName():
        """GetClassName() -> OT::String"""
        return _func.LinearCombinationGradientImplementation_GetClassName()

    if _newclass:GetClassName = staticmethod(GetClassName)
    __swig_getmethods__["GetClassName"] = lambda x: GetClassName
    def getClassName(self):
        """getClassName(LinearCombinationGradientImplementation self) -> OT::String"""
        return _func.LinearCombinationGradientImplementation_getClassName(self)

    def gradient(self, *args):
        """gradient(LinearCombinationGradientImplementation self, NumericalPoint inP) -> Matrix"""
        return _func.LinearCombinationGradientImplementation_gradient(self, *args)

    def getInputDimension(self):
        """getInputDimension(LinearCombinationGradientImplementation self) -> OT::UnsignedLong"""
        return _func.LinearCombinationGradientImplementation_getInputDimension(self)

    def getOutputDimension(self):
        """getOutputDimension(LinearCombinationGradientImplementation self) -> OT::UnsignedLong"""
        return _func.LinearCombinationGradientImplementation_getOutputDimension(self)

    def __repr__(self):
        """__repr__(LinearCombinationGradientImplementation self) -> OT::String"""
        return _func.LinearCombinationGradientImplementation___repr__(self)

    def __str__(self, offset=""):
        """
        __str__(LinearCombinationGradientImplementation self, OT::String const & offset="") -> OT::String
        __str__(LinearCombinationGradientImplementation self) -> OT::String
        """
        return _func.LinearCombinationGradientImplementation___str__(self, offset)

    def __init__(self, *args): 
        """
        __init__(OT::LinearCombinationGradientImplementation self) -> LinearCombinationGradientImplementation
        __init__(OT::LinearCombinationGradientImplementation self, LinearCombinationEvaluationImplementation evaluation) -> LinearCombinationGradientImplementation
        __init__(OT::LinearCombinationGradientImplementation self, LinearCombinationGradientImplementation other) -> LinearCombinationGradientImplementation
        """
        this = _func.new_LinearCombinationGradientImplementation(*args)
        try: self.this.append(this)
        except: self.this = this
    __swig_destroy__ = _func.delete_LinearCombinationGradientImplementation
    __del__ = lambda self : None;
LinearCombinationGradientImplementation_swigregister = _func.LinearCombinationGradientImplementation_swigregister
LinearCombinationGradientImplementation_swigregister(LinearCombinationGradientImplementation)

def LinearCombinationGradientImplementation_GetClassName():
  """LinearCombinationGradientImplementation_GetClassName() -> OT::String"""
  return _func.LinearCombinationGradientImplementation_GetClassName()

class LinearCombinationHessianImplementation(NumericalMathHessianImplementation):
    """Proxy of C++ OT::LinearCombinationHessianImplementation class"""
    __swig_setmethods__ = {}
    for _s in [NumericalMathHessianImplementation]: __swig_setmethods__.update(getattr(_s,'__swig_setmethods__',{}))
    __setattr__ = lambda self, name, value: _swig_setattr(self, LinearCombinationHessianImplementation, name, value)
    __swig_getmethods__ = {}
    for _s in [NumericalMathHessianImplementation]: __swig_getmethods__.update(getattr(_s,'__swig_getmethods__',{}))
    __getattr__ = lambda self, name: _swig_getattr(self, LinearCombinationHessianImplementation, name)
    def GetClassName():
        """GetClassName() -> OT::String"""
        return _func.LinearCombinationHessianImplementation_GetClassName()

    if _newclass:GetClassName = staticmethod(GetClassName)
    __swig_getmethods__["GetClassName"] = lambda x: GetClassName
    def getClassName(self):
        """getClassName(LinearCombinationHessianImplementation self) -> OT::String"""
        return _func.LinearCombinationHessianImplementation_getClassName(self)

    def hessian(self, *args):
        """hessian(LinearCombinationHessianImplementation self, NumericalPoint inP) -> SymmetricTensor"""
        return _func.LinearCombinationHessianImplementation_hessian(self, *args)

    def getInputDimension(self):
        """getInputDimension(LinearCombinationHessianImplementation self) -> OT::UnsignedLong"""
        return _func.LinearCombinationHessianImplementation_getInputDimension(self)

    def getOutputDimension(self):
        """getOutputDimension(LinearCombinationHessianImplementation self) -> OT::UnsignedLong"""
        return _func.LinearCombinationHessianImplementation_getOutputDimension(self)

    def __repr__(self):
        """__repr__(LinearCombinationHessianImplementation self) -> OT::String"""
        return _func.LinearCombinationHessianImplementation___repr__(self)

    def __str__(self, offset=""):
        """
        __str__(LinearCombinationHessianImplementation self, OT::String const & offset="") -> OT::String
        __str__(LinearCombinationHessianImplementation self) -> OT::String
        """
        return _func.LinearCombinationHessianImplementation___str__(self, offset)

    def __init__(self, *args): 
        """
        __init__(OT::LinearCombinationHessianImplementation self) -> LinearCombinationHessianImplementation
        __init__(OT::LinearCombinationHessianImplementation self, LinearCombinationEvaluationImplementation evaluation) -> LinearCombinationHessianImplementation
        __init__(OT::LinearCombinationHessianImplementation self, LinearCombinationHessianImplementation other) -> LinearCombinationHessianImplementation
        """
        this = _func.new_LinearCombinationHessianImplementation(*args)
        try: self.this.append(this)
        except: self.this = this
    __swig_destroy__ = _func.delete_LinearCombinationHessianImplementation
    __del__ = lambda self : None;
LinearCombinationHessianImplementation_swigregister = _func.LinearCombinationHessianImplementation_swigregister
LinearCombinationHessianImplementation_swigregister(LinearCombinationHessianImplementation)

def LinearCombinationHessianImplementation_GetClassName():
  """LinearCombinationHessianImplementation_GetClassName() -> OT::String"""
  return _func.LinearCombinationHessianImplementation_GetClassName()

class LinearNumericalMathFunction(NumericalMathFunction):
    """Proxy of C++ OT::LinearNumericalMathFunction class"""
    __swig_setmethods__ = {}
    for _s in [NumericalMathFunction]: __swig_setmethods__.update(getattr(_s,'__swig_setmethods__',{}))
    __setattr__ = lambda self, name, value: _swig_setattr(self, LinearNumericalMathFunction, name, value)
    __swig_getmethods__ = {}
    for _s in [NumericalMathFunction]: __swig_getmethods__.update(getattr(_s,'__swig_getmethods__',{}))
    __getattr__ = lambda self, name: _swig_getattr(self, LinearNumericalMathFunction, name)
    def GetClassName():
        """GetClassName() -> OT::String"""
        return _func.LinearNumericalMathFunction_GetClassName()

    if _newclass:GetClassName = staticmethod(GetClassName)
    __swig_getmethods__["GetClassName"] = lambda x: GetClassName
    def getClassName(self):
        """getClassName(LinearNumericalMathFunction self) -> OT::String"""
        return _func.LinearNumericalMathFunction_getClassName(self)

    def __eq__(self, *args):
        """__eq__(LinearNumericalMathFunction self, LinearNumericalMathFunction other) -> OT::Bool"""
        return _func.LinearNumericalMathFunction___eq__(self, *args)

    def __repr__(self):
        """__repr__(LinearNumericalMathFunction self) -> OT::String"""
        return _func.LinearNumericalMathFunction___repr__(self)

    def __init__(self, *args): 
        """
        __init__(OT::LinearNumericalMathFunction self, NumericalPoint center, NumericalPoint constant, Matrix linear) -> LinearNumericalMathFunction
        __init__(OT::LinearNumericalMathFunction self, LinearNumericalMathFunction other) -> LinearNumericalMathFunction
        """
        this = _func.new_LinearNumericalMathFunction(*args)
        try: self.this.append(this)
        except: self.this = this
    __swig_destroy__ = _func.delete_LinearNumericalMathFunction
    __del__ = lambda self : None;
LinearNumericalMathFunction_swigregister = _func.LinearNumericalMathFunction_swigregister
LinearNumericalMathFunction_swigregister(LinearNumericalMathFunction)

def LinearNumericalMathFunction_GetClassName():
  """LinearNumericalMathFunction_GetClassName() -> OT::String"""
  return _func.LinearNumericalMathFunction_GetClassName()

class UniVariatePolynomialImplementation(openturns.common.PersistentObject):
    """Proxy of C++ OT::UniVariatePolynomialImplementation class"""
    __swig_setmethods__ = {}
    for _s in [openturns.common.PersistentObject]: __swig_setmethods__.update(getattr(_s,'__swig_setmethods__',{}))
    __setattr__ = lambda self, name, value: _swig_setattr(self, UniVariatePolynomialImplementation, name, value)
    __swig_getmethods__ = {}
    for _s in [openturns.common.PersistentObject]: __swig_getmethods__.update(getattr(_s,'__swig_getmethods__',{}))
    __getattr__ = lambda self, name: _swig_getattr(self, UniVariatePolynomialImplementation, name)
    def GetClassName():
        """GetClassName() -> OT::String"""
        return _func.UniVariatePolynomialImplementation_GetClassName()

    if _newclass:GetClassName = staticmethod(GetClassName)
    __swig_getmethods__["GetClassName"] = lambda x: GetClassName
    def getClassName(self):
        """getClassName(UniVariatePolynomialImplementation self) -> OT::String"""
        return _func.UniVariatePolynomialImplementation_getClassName(self)

    def __repr__(self):
        """__repr__(UniVariatePolynomialImplementation self) -> OT::String"""
        return _func.UniVariatePolynomialImplementation___repr__(self)

    def __str__(self, *args):
        """
        __str__(UniVariatePolynomialImplementation self, OT::String const & offset="") -> OT::String
        __str__(UniVariatePolynomialImplementation self) -> OT::String
        __str__(UniVariatePolynomialImplementation self, OT::String const & variableName, OT::String const & offset) -> OT::String
        """
        return _func.UniVariatePolynomialImplementation___str__(self, *args)

    def __call__(self, *args):
        """
        __call__(UniVariatePolynomialImplementation self, OT::NumericalScalar const x) -> OT::NumericalScalar
        __call__(UniVariatePolynomialImplementation self, OT::NumericalComplex const z) -> OT::NumericalComplex
        """
        return _func.UniVariatePolynomialImplementation___call__(self, *args)

    def derivative(self, *args):
        """derivative(UniVariatePolynomialImplementation self, OT::NumericalScalar const x) -> OT::NumericalScalar"""
        return _func.UniVariatePolynomialImplementation_derivative(self, *args)

    def derivate(self):
        """derivate(UniVariatePolynomialImplementation self) -> UniVariatePolynomialImplementation"""
        return _func.UniVariatePolynomialImplementation_derivate(self)

    def __mul__(self, *args):
        """
        __mul__(UniVariatePolynomialImplementation self, OT::NumericalScalar const scalar) -> UniVariatePolynomialImplementation
        __mul__(UniVariatePolynomialImplementation self, UniVariatePolynomialImplementation uniVariatePolynomial) -> UniVariatePolynomialImplementation
        """
        return _func.UniVariatePolynomialImplementation___mul__(self, *args)

    def incrementDegree(self, degree=1):
        """
        incrementDegree(UniVariatePolynomialImplementation self, OT::UnsignedLong const degree=1) -> UniVariatePolynomialImplementation
        incrementDegree(UniVariatePolynomialImplementation self) -> UniVariatePolynomialImplementation
        """
        return _func.UniVariatePolynomialImplementation_incrementDegree(self, degree)

    def __add__(self, *args):
        """__add__(UniVariatePolynomialImplementation self, UniVariatePolynomialImplementation uniVariatePolynomial) -> UniVariatePolynomialImplementation"""
        return _func.UniVariatePolynomialImplementation___add__(self, *args)

    def __sub__(self, *args):
        """__sub__(UniVariatePolynomialImplementation self, UniVariatePolynomialImplementation uniVariatePolynomial) -> UniVariatePolynomialImplementation"""
        return _func.UniVariatePolynomialImplementation___sub__(self, *args)

    def setCoefficients(self, *args):
        """setCoefficients(UniVariatePolynomialImplementation self, NumericalPoint coefficients)"""
        return _func.UniVariatePolynomialImplementation_setCoefficients(self, *args)

    def getCoefficients(self):
        """getCoefficients(UniVariatePolynomialImplementation self) -> NumericalPoint"""
        return _func.UniVariatePolynomialImplementation_getCoefficients(self)

    def getDegree(self):
        """getDegree(UniVariatePolynomialImplementation self) -> OT::UnsignedLong"""
        return _func.UniVariatePolynomialImplementation_getDegree(self)

    def getRoots(self):
        """getRoots(UniVariatePolynomialImplementation self) -> NumericalComplexCollection"""
        return _func.UniVariatePolynomialImplementation_getRoots(self)

    def draw(self, *args):
        """draw(UniVariatePolynomialImplementation self, OT::NumericalScalar const xMin, OT::NumericalScalar const xMax, OT::UnsignedLong const pointNumber) -> Graph"""
        return _func.UniVariatePolynomialImplementation_draw(self, *args)

    def __init__(self, *args): 
        """
        __init__(OT::UniVariatePolynomialImplementation self) -> UniVariatePolynomialImplementation
        __init__(OT::UniVariatePolynomialImplementation self, NumericalPoint coefficients) -> UniVariatePolynomialImplementation
        __init__(OT::UniVariatePolynomialImplementation self, UniVariatePolynomialImplementation other) -> UniVariatePolynomialImplementation
        """
        this = _func.new_UniVariatePolynomialImplementation(*args)
        try: self.this.append(this)
        except: self.this = this
    __swig_destroy__ = _func.delete_UniVariatePolynomialImplementation
    __del__ = lambda self : None;
UniVariatePolynomialImplementation_swigregister = _func.UniVariatePolynomialImplementation_swigregister
UniVariatePolynomialImplementation_swigregister(UniVariatePolynomialImplementation)

def UniVariatePolynomialImplementation_GetClassName():
  """UniVariatePolynomialImplementation_GetClassName() -> OT::String"""
  return _func.UniVariatePolynomialImplementation_GetClassName()

class UniVariatePolynomialImplementationTypedInterfaceObject(openturns.common.InterfaceObject):
    """Proxy of C++ OT::TypedInterfaceObject<(OT::UniVariatePolynomialImplementation)> class"""
    __swig_setmethods__ = {}
    for _s in [openturns.common.InterfaceObject]: __swig_setmethods__.update(getattr(_s,'__swig_setmethods__',{}))
    __setattr__ = lambda self, name, value: _swig_setattr(self, UniVariatePolynomialImplementationTypedInterfaceObject, name, value)
    __swig_getmethods__ = {}
    for _s in [openturns.common.InterfaceObject]: __swig_getmethods__.update(getattr(_s,'__swig_getmethods__',{}))
    __getattr__ = lambda self, name: _swig_getattr(self, UniVariatePolynomialImplementationTypedInterfaceObject, name)
    __repr__ = _swig_repr
    def __init__(self, *args): 
        """
        __init__(OT::TypedInterfaceObject<(OT::UniVariatePolynomialImplementation)> self) -> UniVariatePolynomialImplementationTypedInterfaceObject
        __init__(OT::TypedInterfaceObject<(OT::UniVariatePolynomialImplementation)> self, UniVariatePolynomialImplementationPointer impl) -> UniVariatePolynomialImplementationTypedInterfaceObject
        """
        this = _func.new_UniVariatePolynomialImplementationTypedInterfaceObject(*args)
        try: self.this.append(this)
        except: self.this = this
    def getImplementation(self, *args):
        """
        getImplementation(UniVariatePolynomialImplementationTypedInterfaceObject self) -> UniVariatePolynomialImplementationPointer
        getImplementation(UniVariatePolynomialImplementationTypedInterfaceObject self) -> UniVariatePolynomialImplementationPointer
        """
        return _func.UniVariatePolynomialImplementationTypedInterfaceObject_getImplementation(self, *args)

    def getImplementationAsPersistentObject(self):
        """getImplementationAsPersistentObject(UniVariatePolynomialImplementationTypedInterfaceObject self) -> PersistentObjectPointer"""
        return _func.UniVariatePolynomialImplementationTypedInterfaceObject_getImplementationAsPersistentObject(self)

    def setImplementationAsPersistentObject(self, *args):
        """setImplementationAsPersistentObject(UniVariatePolynomialImplementationTypedInterfaceObject self, PersistentObjectPointer obj)"""
        return _func.UniVariatePolynomialImplementationTypedInterfaceObject_setImplementationAsPersistentObject(self, *args)

    def swap(self, *args):
        """swap(UniVariatePolynomialImplementationTypedInterfaceObject self, UniVariatePolynomialImplementationTypedInterfaceObject other)"""
        return _func.UniVariatePolynomialImplementationTypedInterfaceObject_swap(self, *args)

    def setName(self, *args):
        """setName(UniVariatePolynomialImplementationTypedInterfaceObject self, OT::String const & name)"""
        return _func.UniVariatePolynomialImplementationTypedInterfaceObject_setName(self, *args)

    def getName(self):
        """getName(UniVariatePolynomialImplementationTypedInterfaceObject self) -> OT::String"""
        return _func.UniVariatePolynomialImplementationTypedInterfaceObject_getName(self)

    def __eq__(self, *args):
        """__eq__(UniVariatePolynomialImplementationTypedInterfaceObject self, UniVariatePolynomialImplementationTypedInterfaceObject other) -> OT::Bool"""
        return _func.UniVariatePolynomialImplementationTypedInterfaceObject___eq__(self, *args)

    __swig_destroy__ = _func.delete_UniVariatePolynomialImplementationTypedInterfaceObject
    __del__ = lambda self : None;
UniVariatePolynomialImplementationTypedInterfaceObject_swigregister = _func.UniVariatePolynomialImplementationTypedInterfaceObject_swigregister
UniVariatePolynomialImplementationTypedInterfaceObject_swigregister(UniVariatePolynomialImplementationTypedInterfaceObject)

class UniVariatePolynomial(UniVariatePolynomialImplementationTypedInterfaceObject):
    """Proxy of C++ OT::UniVariatePolynomial class"""
    __swig_setmethods__ = {}
    for _s in [UniVariatePolynomialImplementationTypedInterfaceObject]: __swig_setmethods__.update(getattr(_s,'__swig_setmethods__',{}))
    __setattr__ = lambda self, name, value: _swig_setattr(self, UniVariatePolynomial, name, value)
    __swig_getmethods__ = {}
    for _s in [UniVariatePolynomialImplementationTypedInterfaceObject]: __swig_getmethods__.update(getattr(_s,'__swig_getmethods__',{}))
    __getattr__ = lambda self, name: _swig_getattr(self, UniVariatePolynomial, name)
    def GetClassName():
        """GetClassName() -> OT::String"""
        return _func.UniVariatePolynomial_GetClassName()

    if _newclass:GetClassName = staticmethod(GetClassName)
    __swig_getmethods__["GetClassName"] = lambda x: GetClassName
    def getClassName(self):
        """getClassName(UniVariatePolynomial self) -> OT::String"""
        return _func.UniVariatePolynomial_getClassName(self)

    def __repr__(self):
        """__repr__(UniVariatePolynomial self) -> OT::String"""
        return _func.UniVariatePolynomial___repr__(self)

    def __str__(self, *args):
        """
        __str__(UniVariatePolynomial self, OT::String const & offset="") -> OT::String
        __str__(UniVariatePolynomial self) -> OT::String
        __str__(UniVariatePolynomial self, OT::String const & variableName, OT::String const & offset) -> OT::String
        """
        return _func.UniVariatePolynomial___str__(self, *args)

    def __call__(self, *args):
        """
        __call__(UniVariatePolynomial self, OT::NumericalScalar const x) -> OT::NumericalScalar
        __call__(UniVariatePolynomial self, OT::NumericalComplex const z) -> OT::NumericalComplex
        """
        return _func.UniVariatePolynomial___call__(self, *args)

    def derivative(self, *args):
        """derivative(UniVariatePolynomial self, OT::NumericalScalar const x) -> OT::NumericalScalar"""
        return _func.UniVariatePolynomial_derivative(self, *args)

    def derivate(self):
        """derivate(UniVariatePolynomial self) -> UniVariatePolynomial"""
        return _func.UniVariatePolynomial_derivate(self)

    def __mul__(self, *args):
        """
        __mul__(UniVariatePolynomial self, OT::NumericalScalar const scalar) -> UniVariatePolynomial
        __mul__(UniVariatePolynomial self, UniVariatePolynomial uniVariatePolynomial) -> UniVariatePolynomial
        """
        return _func.UniVariatePolynomial___mul__(self, *args)

    def incrementDegree(self, degree=1):
        """
        incrementDegree(UniVariatePolynomial self, OT::UnsignedLong const degree=1) -> UniVariatePolynomial
        incrementDegree(UniVariatePolynomial self) -> UniVariatePolynomial
        """
        return _func.UniVariatePolynomial_incrementDegree(self, degree)

    def __add__(self, *args):
        """__add__(UniVariatePolynomial self, UniVariatePolynomial uniVariatePolynomial) -> UniVariatePolynomial"""
        return _func.UniVariatePolynomial___add__(self, *args)

    def __sub__(self, *args):
        """__sub__(UniVariatePolynomial self, UniVariatePolynomial uniVariatePolynomial) -> UniVariatePolynomial"""
        return _func.UniVariatePolynomial___sub__(self, *args)

    def setCoefficients(self, *args):
        """setCoefficients(UniVariatePolynomial self, NumericalPoint coefficients)"""
        return _func.UniVariatePolynomial_setCoefficients(self, *args)

    def getCoefficients(self):
        """getCoefficients(UniVariatePolynomial self) -> NumericalPoint"""
        return _func.UniVariatePolynomial_getCoefficients(self)

    def getDegree(self):
        """getDegree(UniVariatePolynomial self) -> OT::UnsignedLong"""
        return _func.UniVariatePolynomial_getDegree(self)

    def getRoots(self):
        """getRoots(UniVariatePolynomial self) -> NumericalComplexCollection"""
        return _func.UniVariatePolynomial_getRoots(self)

    def draw(self, *args):
        """draw(UniVariatePolynomial self, OT::NumericalScalar const xMin, OT::NumericalScalar const xMax, OT::UnsignedLong const pointNumber) -> Graph"""
        return _func.UniVariatePolynomial_draw(self, *args)

    def __init__(self, *args): 
        """
        __init__(OT::UniVariatePolynomial self) -> UniVariatePolynomial
        __init__(OT::UniVariatePolynomial self, NumericalPoint coefficients) -> UniVariatePolynomial
        __init__(OT::UniVariatePolynomial self, UniVariatePolynomialImplementation implementation) -> UniVariatePolynomial
        __init__(OT::UniVariatePolynomial self, UniVariatePolynomialImplementationPointer p_implementation) -> UniVariatePolynomial
        __init__(OT::UniVariatePolynomial self, UniVariatePolynomial other) -> UniVariatePolynomial
        __init__(OT::UniVariatePolynomial self, PyObject * pyObj) -> UniVariatePolynomial
        """
        this = _func.new_UniVariatePolynomial(*args)
        try: self.this.append(this)
        except: self.this = this
    __swig_destroy__ = _func.delete_UniVariatePolynomial
    __del__ = lambda self : None;
UniVariatePolynomial_swigregister = _func.UniVariatePolynomial_swigregister
UniVariatePolynomial_swigregister(UniVariatePolynomial)

def UniVariatePolynomial_GetClassName():
  """UniVariatePolynomial_GetClassName() -> OT::String"""
  return _func.UniVariatePolynomial_GetClassName()

class AggregatedNumericalMathEvaluationImplementation(NumericalMathEvaluationImplementation):
    """Proxy of C++ OT::AggregatedNumericalMathEvaluationImplementation class"""
    __swig_setmethods__ = {}
    for _s in [NumericalMathEvaluationImplementation]: __swig_setmethods__.update(getattr(_s,'__swig_setmethods__',{}))
    __setattr__ = lambda self, name, value: _swig_setattr(self, AggregatedNumericalMathEvaluationImplementation, name, value)
    __swig_getmethods__ = {}
    for _s in [NumericalMathEvaluationImplementation]: __swig_getmethods__.update(getattr(_s,'__swig_getmethods__',{}))
    __getattr__ = lambda self, name: _swig_getattr(self, AggregatedNumericalMathEvaluationImplementation, name)
    def GetClassName():
        """GetClassName() -> OT::String"""
        return _func.AggregatedNumericalMathEvaluationImplementation_GetClassName()

    if _newclass:GetClassName = staticmethod(GetClassName)
    __swig_getmethods__["GetClassName"] = lambda x: GetClassName
    def getClassName(self):
        """getClassName(AggregatedNumericalMathEvaluationImplementation self) -> OT::String"""
        return _func.AggregatedNumericalMathEvaluationImplementation_getClassName(self)

    def __repr__(self):
        """__repr__(AggregatedNumericalMathEvaluationImplementation self) -> OT::String"""
        return _func.AggregatedNumericalMathEvaluationImplementation___repr__(self)

    def __str__(self, offset=""):
        """
        __str__(AggregatedNumericalMathEvaluationImplementation self, OT::String const & offset="") -> OT::String
        __str__(AggregatedNumericalMathEvaluationImplementation self) -> OT::String
        """
        return _func.AggregatedNumericalMathEvaluationImplementation___str__(self, offset)

    def __call__(self, *args):
        """
        __call__(AggregatedNumericalMathEvaluationImplementation self, NumericalPoint inP) -> NumericalPoint
        __call__(AggregatedNumericalMathEvaluationImplementation self, NumericalSample inS) -> NumericalSample
        """
        return _func.AggregatedNumericalMathEvaluationImplementation___call__(self, *args)

    def getFunctionsCollection(self):
        """getFunctionsCollection(AggregatedNumericalMathEvaluationImplementation self) -> NumericalMathFunctionCollection"""
        return _func.AggregatedNumericalMathEvaluationImplementation_getFunctionsCollection(self)

    def setFunctionsCollection(self, *args):
        """setFunctionsCollection(AggregatedNumericalMathEvaluationImplementation self, NumericalMathFunctionCollection functionsCollection)"""
        return _func.AggregatedNumericalMathEvaluationImplementation_setFunctionsCollection(self, *args)

    def getMarginal(self, *args):
        """
        getMarginal(AggregatedNumericalMathEvaluationImplementation self, OT::UnsignedLong const i) -> EvaluationImplementation
        getMarginal(AggregatedNumericalMathEvaluationImplementation self, Indices indices) -> EvaluationImplementation
        """
        return _func.AggregatedNumericalMathEvaluationImplementation_getMarginal(self, *args)

    def getInputDimension(self):
        """getInputDimension(AggregatedNumericalMathEvaluationImplementation self) -> OT::UnsignedLong"""
        return _func.AggregatedNumericalMathEvaluationImplementation_getInputDimension(self)

    def getOutputDimension(self):
        """getOutputDimension(AggregatedNumericalMathEvaluationImplementation self) -> OT::UnsignedLong"""
        return _func.AggregatedNumericalMathEvaluationImplementation_getOutputDimension(self)

    def parametersGradient(self, *args):
        """parametersGradient(AggregatedNumericalMathEvaluationImplementation self, NumericalPoint inP) -> Matrix"""
        return _func.AggregatedNumericalMathEvaluationImplementation_parametersGradient(self, *args)

    def getParameters(self):
        """getParameters(AggregatedNumericalMathEvaluationImplementation self) -> NumericalPointWithDescription"""
        return _func.AggregatedNumericalMathEvaluationImplementation_getParameters(self)

    def __init__(self, *args): 
        """
        __init__(OT::AggregatedNumericalMathEvaluationImplementation self) -> AggregatedNumericalMathEvaluationImplementation
        __init__(OT::AggregatedNumericalMathEvaluationImplementation self, NumericalMathFunctionCollection functionsCollection) -> AggregatedNumericalMathEvaluationImplementation
        __init__(OT::AggregatedNumericalMathEvaluationImplementation self, AggregatedNumericalMathEvaluationImplementation other) -> AggregatedNumericalMathEvaluationImplementation
        """
        this = _func.new_AggregatedNumericalMathEvaluationImplementation(*args)
        try: self.this.append(this)
        except: self.this = this
    __swig_destroy__ = _func.delete_AggregatedNumericalMathEvaluationImplementation
    __del__ = lambda self : None;
AggregatedNumericalMathEvaluationImplementation_swigregister = _func.AggregatedNumericalMathEvaluationImplementation_swigregister
AggregatedNumericalMathEvaluationImplementation_swigregister(AggregatedNumericalMathEvaluationImplementation)

def AggregatedNumericalMathEvaluationImplementation_GetClassName():
  """AggregatedNumericalMathEvaluationImplementation_GetClassName() -> OT::String"""
  return _func.AggregatedNumericalMathEvaluationImplementation_GetClassName()

class PiecewiseLinearEvaluationImplementation(NumericalMathEvaluationImplementation):
    """Proxy of C++ OT::PiecewiseLinearEvaluationImplementation class"""
    __swig_setmethods__ = {}
    for _s in [NumericalMathEvaluationImplementation]: __swig_setmethods__.update(getattr(_s,'__swig_setmethods__',{}))
    __setattr__ = lambda self, name, value: _swig_setattr(self, PiecewiseLinearEvaluationImplementation, name, value)
    __swig_getmethods__ = {}
    for _s in [NumericalMathEvaluationImplementation]: __swig_getmethods__.update(getattr(_s,'__swig_getmethods__',{}))
    __getattr__ = lambda self, name: _swig_getattr(self, PiecewiseLinearEvaluationImplementation, name)
    def GetClassName():
        """GetClassName() -> OT::String"""
        return _func.PiecewiseLinearEvaluationImplementation_GetClassName()

    if _newclass:GetClassName = staticmethod(GetClassName)
    __swig_getmethods__["GetClassName"] = lambda x: GetClassName
    def getClassName(self):
        """getClassName(PiecewiseLinearEvaluationImplementation self) -> OT::String"""
        return _func.PiecewiseLinearEvaluationImplementation_getClassName(self)

    def __repr__(self):
        """__repr__(PiecewiseLinearEvaluationImplementation self) -> OT::String"""
        return _func.PiecewiseLinearEvaluationImplementation___repr__(self)

    def __str__(self, offset=""):
        """
        __str__(PiecewiseLinearEvaluationImplementation self, OT::String const & offset="") -> OT::String
        __str__(PiecewiseLinearEvaluationImplementation self) -> OT::String
        """
        return _func.PiecewiseLinearEvaluationImplementation___str__(self, offset)

    def __call__(self, *args):
        """
        __call__(PiecewiseLinearEvaluationImplementation self, NumericalPoint inP) -> NumericalPoint
        __call__(PiecewiseLinearEvaluationImplementation self, NumericalSample inSample) -> NumericalSample
        __call__(PiecewiseLinearEvaluationImplementation self, TimeSeries inTimeSeries) -> TimeSeries
        __call__(PiecewiseLinearEvaluationImplementation self, NumericalPoint inP) -> NumericalPoint
        """
        return _func.PiecewiseLinearEvaluationImplementation___call__(self, *args)

    def getLocations(self):
        """getLocations(PiecewiseLinearEvaluationImplementation self) -> NumericalPoint"""
        return _func.PiecewiseLinearEvaluationImplementation_getLocations(self)

    def setLocations(self, *args):
        """setLocations(PiecewiseLinearEvaluationImplementation self, NumericalPoint locations)"""
        return _func.PiecewiseLinearEvaluationImplementation_setLocations(self, *args)

    def getValues(self):
        """getValues(PiecewiseLinearEvaluationImplementation self) -> NumericalSample"""
        return _func.PiecewiseLinearEvaluationImplementation_getValues(self)

    def setValues(self, *args):
        """
        setValues(PiecewiseLinearEvaluationImplementation self, NumericalPoint values)
        setValues(PiecewiseLinearEvaluationImplementation self, NumericalSample values)
        """
        return _func.PiecewiseLinearEvaluationImplementation_setValues(self, *args)

    def setLocationsAndValues(self, *args):
        """setLocationsAndValues(PiecewiseLinearEvaluationImplementation self, NumericalPoint locations, NumericalSample values)"""
        return _func.PiecewiseLinearEvaluationImplementation_setLocationsAndValues(self, *args)

    def getInputDimension(self):
        """getInputDimension(PiecewiseLinearEvaluationImplementation self) -> OT::UnsignedLong"""
        return _func.PiecewiseLinearEvaluationImplementation_getInputDimension(self)

    def getOutputDimension(self):
        """getOutputDimension(PiecewiseLinearEvaluationImplementation self) -> OT::UnsignedLong"""
        return _func.PiecewiseLinearEvaluationImplementation_getOutputDimension(self)

    def __init__(self, *args): 
        """
        __init__(OT::PiecewiseLinearEvaluationImplementation self) -> PiecewiseLinearEvaluationImplementation
        __init__(OT::PiecewiseLinearEvaluationImplementation self, NumericalPoint locations, NumericalPoint values) -> PiecewiseLinearEvaluationImplementation
        __init__(OT::PiecewiseLinearEvaluationImplementation self, NumericalPoint locations, NumericalSample values) -> PiecewiseLinearEvaluationImplementation
        __init__(OT::PiecewiseLinearEvaluationImplementation self, PiecewiseLinearEvaluationImplementation other) -> PiecewiseLinearEvaluationImplementation
        """
        this = _func.new_PiecewiseLinearEvaluationImplementation(*args)
        try: self.this.append(this)
        except: self.this = this
    __swig_destroy__ = _func.delete_PiecewiseLinearEvaluationImplementation
    __del__ = lambda self : None;
PiecewiseLinearEvaluationImplementation_swigregister = _func.PiecewiseLinearEvaluationImplementation_swigregister
PiecewiseLinearEvaluationImplementation_swigregister(PiecewiseLinearEvaluationImplementation)

def PiecewiseLinearEvaluationImplementation_GetClassName():
  """PiecewiseLinearEvaluationImplementation_GetClassName() -> OT::String"""
  return _func.PiecewiseLinearEvaluationImplementation_GetClassName()

class PiecewiseHermiteEvaluationImplementation(NumericalMathEvaluationImplementation):
    """Proxy of C++ OT::PiecewiseHermiteEvaluationImplementation class"""
    __swig_setmethods__ = {}
    for _s in [NumericalMathEvaluationImplementation]: __swig_setmethods__.update(getattr(_s,'__swig_setmethods__',{}))
    __setattr__ = lambda self, name, value: _swig_setattr(self, PiecewiseHermiteEvaluationImplementation, name, value)
    __swig_getmethods__ = {}
    for _s in [NumericalMathEvaluationImplementation]: __swig_getmethods__.update(getattr(_s,'__swig_getmethods__',{}))
    __getattr__ = lambda self, name: _swig_getattr(self, PiecewiseHermiteEvaluationImplementation, name)
    def GetClassName():
        """GetClassName() -> OT::String"""
        return _func.PiecewiseHermiteEvaluationImplementation_GetClassName()

    if _newclass:GetClassName = staticmethod(GetClassName)
    __swig_getmethods__["GetClassName"] = lambda x: GetClassName
    def getClassName(self):
        """getClassName(PiecewiseHermiteEvaluationImplementation self) -> OT::String"""
        return _func.PiecewiseHermiteEvaluationImplementation_getClassName(self)

    def __repr__(self):
        """__repr__(PiecewiseHermiteEvaluationImplementation self) -> OT::String"""
        return _func.PiecewiseHermiteEvaluationImplementation___repr__(self)

    def __str__(self, offset=""):
        """
        __str__(PiecewiseHermiteEvaluationImplementation self, OT::String const & offset="") -> OT::String
        __str__(PiecewiseHermiteEvaluationImplementation self) -> OT::String
        """
        return _func.PiecewiseHermiteEvaluationImplementation___str__(self, offset)

    def __call__(self, *args):
        """
        __call__(PiecewiseHermiteEvaluationImplementation self, NumericalPoint inP) -> NumericalPoint
        __call__(PiecewiseHermiteEvaluationImplementation self, NumericalSample inSample) -> NumericalSample
        __call__(PiecewiseHermiteEvaluationImplementation self, TimeSeries inTimeSeries) -> TimeSeries
        __call__(PiecewiseHermiteEvaluationImplementation self, NumericalPoint inP) -> NumericalPoint
        """
        return _func.PiecewiseHermiteEvaluationImplementation___call__(self, *args)

    def getLocations(self):
        """getLocations(PiecewiseHermiteEvaluationImplementation self) -> NumericalPoint"""
        return _func.PiecewiseHermiteEvaluationImplementation_getLocations(self)

    def setLocations(self, *args):
        """setLocations(PiecewiseHermiteEvaluationImplementation self, NumericalPoint locations)"""
        return _func.PiecewiseHermiteEvaluationImplementation_setLocations(self, *args)

    def getValues(self):
        """getValues(PiecewiseHermiteEvaluationImplementation self) -> NumericalSample"""
        return _func.PiecewiseHermiteEvaluationImplementation_getValues(self)

    def setValues(self, *args):
        """setValues(PiecewiseHermiteEvaluationImplementation self, NumericalSample values)"""
        return _func.PiecewiseHermiteEvaluationImplementation_setValues(self, *args)

    def getDerivatives(self):
        """getDerivatives(PiecewiseHermiteEvaluationImplementation self) -> NumericalSample"""
        return _func.PiecewiseHermiteEvaluationImplementation_getDerivatives(self)

    def setDerivatives(self, *args):
        """setDerivatives(PiecewiseHermiteEvaluationImplementation self, NumericalSample derivatives)"""
        return _func.PiecewiseHermiteEvaluationImplementation_setDerivatives(self, *args)

    def setLocationsValuesAndDerivatives(self, *args):
        """setLocationsValuesAndDerivatives(PiecewiseHermiteEvaluationImplementation self, NumericalPoint locations, NumericalSample values, NumericalSample derivatives)"""
        return _func.PiecewiseHermiteEvaluationImplementation_setLocationsValuesAndDerivatives(self, *args)

    def getInputDimension(self):
        """getInputDimension(PiecewiseHermiteEvaluationImplementation self) -> OT::UnsignedLong"""
        return _func.PiecewiseHermiteEvaluationImplementation_getInputDimension(self)

    def getOutputDimension(self):
        """getOutputDimension(PiecewiseHermiteEvaluationImplementation self) -> OT::UnsignedLong"""
        return _func.PiecewiseHermiteEvaluationImplementation_getOutputDimension(self)

    def __init__(self, *args): 
        """
        __init__(OT::PiecewiseHermiteEvaluationImplementation self) -> PiecewiseHermiteEvaluationImplementation
        __init__(OT::PiecewiseHermiteEvaluationImplementation self, NumericalPoint locations, NumericalPoint values, NumericalPoint derivatives) -> PiecewiseHermiteEvaluationImplementation
        __init__(OT::PiecewiseHermiteEvaluationImplementation self, NumericalPoint locations, NumericalSample values, NumericalSample derivatives) -> PiecewiseHermiteEvaluationImplementation
        __init__(OT::PiecewiseHermiteEvaluationImplementation self, PiecewiseHermiteEvaluationImplementation other) -> PiecewiseHermiteEvaluationImplementation
        """
        this = _func.new_PiecewiseHermiteEvaluationImplementation(*args)
        try: self.this.append(this)
        except: self.this = this
    __swig_destroy__ = _func.delete_PiecewiseHermiteEvaluationImplementation
    __del__ = lambda self : None;
PiecewiseHermiteEvaluationImplementation_swigregister = _func.PiecewiseHermiteEvaluationImplementation_swigregister
PiecewiseHermiteEvaluationImplementation_swigregister(PiecewiseHermiteEvaluationImplementation)

def PiecewiseHermiteEvaluationImplementation_GetClassName():
  """PiecewiseHermiteEvaluationImplementation_GetClassName() -> OT::String"""
  return _func.PiecewiseHermiteEvaluationImplementation_GetClassName()

class AnalyticalNumericalMathEvaluationImplementation(NumericalMathEvaluationImplementation):
    """Proxy of C++ OT::AnalyticalNumericalMathEvaluationImplementation class"""
    __swig_setmethods__ = {}
    for _s in [NumericalMathEvaluationImplementation]: __swig_setmethods__.update(getattr(_s,'__swig_setmethods__',{}))
    __setattr__ = lambda self, name, value: _swig_setattr(self, AnalyticalNumericalMathEvaluationImplementation, name, value)
    __swig_getmethods__ = {}
    for _s in [NumericalMathEvaluationImplementation]: __swig_getmethods__.update(getattr(_s,'__swig_getmethods__',{}))
    __getattr__ = lambda self, name: _swig_getattr(self, AnalyticalNumericalMathEvaluationImplementation, name)
    def GetClassName():
        """GetClassName() -> OT::String"""
        return _func.AnalyticalNumericalMathEvaluationImplementation_GetClassName()

    if _newclass:GetClassName = staticmethod(GetClassName)
    __swig_getmethods__["GetClassName"] = lambda x: GetClassName
    def getClassName(self):
        """getClassName(AnalyticalNumericalMathEvaluationImplementation self) -> OT::String"""
        return _func.AnalyticalNumericalMathEvaluationImplementation_getClassName(self)

    def __eq__(self, *args):
        """__eq__(AnalyticalNumericalMathEvaluationImplementation self, AnalyticalNumericalMathEvaluationImplementation other) -> OT::Bool"""
        return _func.AnalyticalNumericalMathEvaluationImplementation___eq__(self, *args)

    def __repr__(self):
        """__repr__(AnalyticalNumericalMathEvaluationImplementation self) -> OT::String"""
        return _func.AnalyticalNumericalMathEvaluationImplementation___repr__(self)

    def __str__(self, offset=""):
        """
        __str__(AnalyticalNumericalMathEvaluationImplementation self, OT::String const & offset="") -> OT::String
        __str__(AnalyticalNumericalMathEvaluationImplementation self) -> OT::String
        """
        return _func.AnalyticalNumericalMathEvaluationImplementation___str__(self, offset)

    def __call__(self, *args):
        """
        __call__(AnalyticalNumericalMathEvaluationImplementation self, NumericalPoint inP) -> NumericalPoint
        __call__(AnalyticalNumericalMathEvaluationImplementation self, NumericalSample inSample) -> NumericalSample
        __call__(AnalyticalNumericalMathEvaluationImplementation self, TimeSeries inTimeSeries) -> TimeSeries
        __call__(AnalyticalNumericalMathEvaluationImplementation self, NumericalPoint inP) -> NumericalPoint
        """
        return _func.AnalyticalNumericalMathEvaluationImplementation___call__(self, *args)

    def getInputDimension(self):
        """getInputDimension(AnalyticalNumericalMathEvaluationImplementation self) -> OT::UnsignedLong"""
        return _func.AnalyticalNumericalMathEvaluationImplementation_getInputDimension(self)

    def getOutputDimension(self):
        """getOutputDimension(AnalyticalNumericalMathEvaluationImplementation self) -> OT::UnsignedLong"""
        return _func.AnalyticalNumericalMathEvaluationImplementation_getOutputDimension(self)

    def getMarginal(self, *args):
        """
        getMarginal(AnalyticalNumericalMathEvaluationImplementation self, OT::UnsignedLong const i) -> EvaluationImplementation
        getMarginal(AnalyticalNumericalMathEvaluationImplementation self, Indices indices) -> EvaluationImplementation
        """
        return _func.AnalyticalNumericalMathEvaluationImplementation_getMarginal(self, *args)

    def getInputVariablesNames(self):
        """getInputVariablesNames(AnalyticalNumericalMathEvaluationImplementation self) -> Description"""
        return _func.AnalyticalNumericalMathEvaluationImplementation_getInputVariablesNames(self)

    def getOutputVariablesNames(self):
        """getOutputVariablesNames(AnalyticalNumericalMathEvaluationImplementation self) -> Description"""
        return _func.AnalyticalNumericalMathEvaluationImplementation_getOutputVariablesNames(self)

    def getFormulas(self):
        """getFormulas(AnalyticalNumericalMathEvaluationImplementation self) -> Description"""
        return _func.AnalyticalNumericalMathEvaluationImplementation_getFormulas(self)

    def __init__(self, *args): 
        """
        __init__(OT::AnalyticalNumericalMathEvaluationImplementation self) -> AnalyticalNumericalMathEvaluationImplementation
        __init__(OT::AnalyticalNumericalMathEvaluationImplementation self, Description inputVariablesNames, Description outputVariablesNames, Description formulas) -> AnalyticalNumericalMathEvaluationImplementation
        __init__(OT::AnalyticalNumericalMathEvaluationImplementation self, AnalyticalNumericalMathEvaluationImplementation other) -> AnalyticalNumericalMathEvaluationImplementation
        """
        this = _func.new_AnalyticalNumericalMathEvaluationImplementation(*args)
        try: self.this.append(this)
        except: self.this = this
    __swig_destroy__ = _func.delete_AnalyticalNumericalMathEvaluationImplementation
    __del__ = lambda self : None;
AnalyticalNumericalMathEvaluationImplementation_swigregister = _func.AnalyticalNumericalMathEvaluationImplementation_swigregister
AnalyticalNumericalMathEvaluationImplementation_swigregister(AnalyticalNumericalMathEvaluationImplementation)

def AnalyticalNumericalMathEvaluationImplementation_GetClassName():
  """AnalyticalNumericalMathEvaluationImplementation_GetClassName() -> OT::String"""
  return _func.AnalyticalNumericalMathEvaluationImplementation_GetClassName()

class AnalyticalNumericalMathGradientImplementation(NumericalMathGradientImplementation):
    """Proxy of C++ OT::AnalyticalNumericalMathGradientImplementation class"""
    __swig_setmethods__ = {}
    for _s in [NumericalMathGradientImplementation]: __swig_setmethods__.update(getattr(_s,'__swig_setmethods__',{}))
    __setattr__ = lambda self, name, value: _swig_setattr(self, AnalyticalNumericalMathGradientImplementation, name, value)
    __swig_getmethods__ = {}
    for _s in [NumericalMathGradientImplementation]: __swig_getmethods__.update(getattr(_s,'__swig_getmethods__',{}))
    __getattr__ = lambda self, name: _swig_getattr(self, AnalyticalNumericalMathGradientImplementation, name)
    def GetClassName():
        """GetClassName() -> OT::String"""
        return _func.AnalyticalNumericalMathGradientImplementation_GetClassName()

    if _newclass:GetClassName = staticmethod(GetClassName)
    __swig_getmethods__["GetClassName"] = lambda x: GetClassName
    def getClassName(self):
        """getClassName(AnalyticalNumericalMathGradientImplementation self) -> OT::String"""
        return _func.AnalyticalNumericalMathGradientImplementation_getClassName(self)

    def __eq__(self, *args):
        """__eq__(AnalyticalNumericalMathGradientImplementation self, AnalyticalNumericalMathGradientImplementation other) -> OT::Bool"""
        return _func.AnalyticalNumericalMathGradientImplementation___eq__(self, *args)

    def __repr__(self):
        """__repr__(AnalyticalNumericalMathGradientImplementation self) -> OT::String"""
        return _func.AnalyticalNumericalMathGradientImplementation___repr__(self)

    def __str__(self, offset=""):
        """
        __str__(AnalyticalNumericalMathGradientImplementation self, OT::String const & offset="") -> OT::String
        __str__(AnalyticalNumericalMathGradientImplementation self) -> OT::String
        """
        return _func.AnalyticalNumericalMathGradientImplementation___str__(self, offset)

    def gradient(self, *args):
        """
        gradient(AnalyticalNumericalMathGradientImplementation self, NumericalPoint inP) -> Matrix
        gradient(AnalyticalNumericalMathGradientImplementation self, NumericalPoint inP) -> Matrix
        """
        return _func.AnalyticalNumericalMathGradientImplementation_gradient(self, *args)

    def getInputDimension(self):
        """getInputDimension(AnalyticalNumericalMathGradientImplementation self) -> OT::UnsignedLong"""
        return _func.AnalyticalNumericalMathGradientImplementation_getInputDimension(self)

    def getOutputDimension(self):
        """getOutputDimension(AnalyticalNumericalMathGradientImplementation self) -> OT::UnsignedLong"""
        return _func.AnalyticalNumericalMathGradientImplementation_getOutputDimension(self)

    def getFormula(self, *args):
        """getFormula(AnalyticalNumericalMathGradientImplementation self, OT::UnsignedLong const i, OT::UnsignedLong const j) -> OT::String"""
        return _func.AnalyticalNumericalMathGradientImplementation_getFormula(self, *args)

    def getMarginal(self, *args):
        """
        getMarginal(AnalyticalNumericalMathGradientImplementation self, OT::UnsignedLong const i) -> GradientImplementation
        getMarginal(AnalyticalNumericalMathGradientImplementation self, Indices indices) -> GradientImplementation
        """
        return _func.AnalyticalNumericalMathGradientImplementation_getMarginal(self, *args)

    def __init__(self, *args): 
        """
        __init__(OT::AnalyticalNumericalMathGradientImplementation self) -> AnalyticalNumericalMathGradientImplementation
        __init__(OT::AnalyticalNumericalMathGradientImplementation self, AnalyticalNumericalMathEvaluationImplementation evaluation) -> AnalyticalNumericalMathGradientImplementation
        __init__(OT::AnalyticalNumericalMathGradientImplementation self, AnalyticalNumericalMathGradientImplementation other) -> AnalyticalNumericalMathGradientImplementation
        """
        this = _func.new_AnalyticalNumericalMathGradientImplementation(*args)
        try: self.this.append(this)
        except: self.this = this
    __swig_destroy__ = _func.delete_AnalyticalNumericalMathGradientImplementation
    __del__ = lambda self : None;
AnalyticalNumericalMathGradientImplementation_swigregister = _func.AnalyticalNumericalMathGradientImplementation_swigregister
AnalyticalNumericalMathGradientImplementation_swigregister(AnalyticalNumericalMathGradientImplementation)

def AnalyticalNumericalMathGradientImplementation_GetClassName():
  """AnalyticalNumericalMathGradientImplementation_GetClassName() -> OT::String"""
  return _func.AnalyticalNumericalMathGradientImplementation_GetClassName()

class AnalyticalNumericalMathHessianImplementation(NumericalMathHessianImplementation):
    """Proxy of C++ OT::AnalyticalNumericalMathHessianImplementation class"""
    __swig_setmethods__ = {}
    for _s in [NumericalMathHessianImplementation]: __swig_setmethods__.update(getattr(_s,'__swig_setmethods__',{}))
    __setattr__ = lambda self, name, value: _swig_setattr(self, AnalyticalNumericalMathHessianImplementation, name, value)
    __swig_getmethods__ = {}
    for _s in [NumericalMathHessianImplementation]: __swig_getmethods__.update(getattr(_s,'__swig_getmethods__',{}))
    __getattr__ = lambda self, name: _swig_getattr(self, AnalyticalNumericalMathHessianImplementation, name)
    def GetClassName():
        """GetClassName() -> OT::String"""
        return _func.AnalyticalNumericalMathHessianImplementation_GetClassName()

    if _newclass:GetClassName = staticmethod(GetClassName)
    __swig_getmethods__["GetClassName"] = lambda x: GetClassName
    def getClassName(self):
        """getClassName(AnalyticalNumericalMathHessianImplementation self) -> OT::String"""
        return _func.AnalyticalNumericalMathHessianImplementation_getClassName(self)

    def __eq__(self, *args):
        """__eq__(AnalyticalNumericalMathHessianImplementation self, AnalyticalNumericalMathHessianImplementation other) -> OT::Bool"""
        return _func.AnalyticalNumericalMathHessianImplementation___eq__(self, *args)

    def __repr__(self):
        """__repr__(AnalyticalNumericalMathHessianImplementation self) -> OT::String"""
        return _func.AnalyticalNumericalMathHessianImplementation___repr__(self)

    def __str__(self, offset=""):
        """
        __str__(AnalyticalNumericalMathHessianImplementation self, OT::String const & offset="") -> OT::String
        __str__(AnalyticalNumericalMathHessianImplementation self) -> OT::String
        """
        return _func.AnalyticalNumericalMathHessianImplementation___str__(self, offset)

    def hessian(self, *args):
        """
        hessian(AnalyticalNumericalMathHessianImplementation self, NumericalPoint inP) -> SymmetricTensor
        hessian(AnalyticalNumericalMathHessianImplementation self, NumericalPoint inP) -> SymmetricTensor
        """
        return _func.AnalyticalNumericalMathHessianImplementation_hessian(self, *args)

    def getFormula(self, *args):
        """getFormula(AnalyticalNumericalMathHessianImplementation self, OT::UnsignedLong const i, OT::UnsignedLong const j, OT::UnsignedLong const k) -> OT::String"""
        return _func.AnalyticalNumericalMathHessianImplementation_getFormula(self, *args)

    def getInputDimension(self):
        """getInputDimension(AnalyticalNumericalMathHessianImplementation self) -> OT::UnsignedLong"""
        return _func.AnalyticalNumericalMathHessianImplementation_getInputDimension(self)

    def getOutputDimension(self):
        """getOutputDimension(AnalyticalNumericalMathHessianImplementation self) -> OT::UnsignedLong"""
        return _func.AnalyticalNumericalMathHessianImplementation_getOutputDimension(self)

    def getMarginal(self, *args):
        """
        getMarginal(AnalyticalNumericalMathHessianImplementation self, OT::UnsignedLong const i) -> HessianImplementation
        getMarginal(AnalyticalNumericalMathHessianImplementation self, Indices indices) -> HessianImplementation
        """
        return _func.AnalyticalNumericalMathHessianImplementation_getMarginal(self, *args)

    def __init__(self, *args): 
        """
        __init__(OT::AnalyticalNumericalMathHessianImplementation self) -> AnalyticalNumericalMathHessianImplementation
        __init__(OT::AnalyticalNumericalMathHessianImplementation self, AnalyticalNumericalMathEvaluationImplementation evaluation) -> AnalyticalNumericalMathHessianImplementation
        __init__(OT::AnalyticalNumericalMathHessianImplementation self, AnalyticalNumericalMathHessianImplementation other) -> AnalyticalNumericalMathHessianImplementation
        """
        this = _func.new_AnalyticalNumericalMathHessianImplementation(*args)
        try: self.this.append(this)
        except: self.this = this
    __swig_destroy__ = _func.delete_AnalyticalNumericalMathHessianImplementation
    __del__ = lambda self : None;
AnalyticalNumericalMathHessianImplementation_swigregister = _func.AnalyticalNumericalMathHessianImplementation_swigregister
AnalyticalNumericalMathHessianImplementation_swigregister(AnalyticalNumericalMathHessianImplementation)

def AnalyticalNumericalMathHessianImplementation_GetClassName():
  """AnalyticalNumericalMathHessianImplementation_GetClassName() -> OT::String"""
  return _func.AnalyticalNumericalMathHessianImplementation_GetClassName()

class DatabaseNumericalMathEvaluationImplementation(NumericalMathEvaluationImplementation):
    """Proxy of C++ OT::DatabaseNumericalMathEvaluationImplementation class"""
    __swig_setmethods__ = {}
    for _s in [NumericalMathEvaluationImplementation]: __swig_setmethods__.update(getattr(_s,'__swig_setmethods__',{}))
    __setattr__ = lambda self, name, value: _swig_setattr(self, DatabaseNumericalMathEvaluationImplementation, name, value)
    __swig_getmethods__ = {}
    for _s in [NumericalMathEvaluationImplementation]: __swig_getmethods__.update(getattr(_s,'__swig_getmethods__',{}))
    __getattr__ = lambda self, name: _swig_getattr(self, DatabaseNumericalMathEvaluationImplementation, name)
    def GetClassName():
        """GetClassName() -> OT::String"""
        return _func.DatabaseNumericalMathEvaluationImplementation_GetClassName()

    if _newclass:GetClassName = staticmethod(GetClassName)
    __swig_getmethods__["GetClassName"] = lambda x: GetClassName
    def getClassName(self):
        """getClassName(DatabaseNumericalMathEvaluationImplementation self) -> OT::String"""
        return _func.DatabaseNumericalMathEvaluationImplementation_getClassName(self)

    def __eq__(self, *args):
        """__eq__(DatabaseNumericalMathEvaluationImplementation self, DatabaseNumericalMathEvaluationImplementation other) -> OT::Bool"""
        return _func.DatabaseNumericalMathEvaluationImplementation___eq__(self, *args)

    def __repr__(self):
        """__repr__(DatabaseNumericalMathEvaluationImplementation self) -> OT::String"""
        return _func.DatabaseNumericalMathEvaluationImplementation___repr__(self)

    def __str__(self, offset=""):
        """
        __str__(DatabaseNumericalMathEvaluationImplementation self, OT::String const & offset="") -> OT::String
        __str__(DatabaseNumericalMathEvaluationImplementation self) -> OT::String
        """
        return _func.DatabaseNumericalMathEvaluationImplementation___str__(self, offset)

    def setInputSample(self, *args):
        """setInputSample(DatabaseNumericalMathEvaluationImplementation self, NumericalSample inputSample)"""
        return _func.DatabaseNumericalMathEvaluationImplementation_setInputSample(self, *args)

    def getInputSample(self):
        """getInputSample(DatabaseNumericalMathEvaluationImplementation self) -> NumericalSample"""
        return _func.DatabaseNumericalMathEvaluationImplementation_getInputSample(self)

    def setOutputSample(self, *args):
        """setOutputSample(DatabaseNumericalMathEvaluationImplementation self, NumericalSample outputSample)"""
        return _func.DatabaseNumericalMathEvaluationImplementation_setOutputSample(self, *args)

    def getOutputSample(self):
        """getOutputSample(DatabaseNumericalMathEvaluationImplementation self) -> NumericalSample"""
        return _func.DatabaseNumericalMathEvaluationImplementation_getOutputSample(self)

    def __call__(self, *args):
        """__call__(DatabaseNumericalMathEvaluationImplementation self, NumericalPoint inP) -> NumericalPoint"""
        return _func.DatabaseNumericalMathEvaluationImplementation___call__(self, *args)

    def getInputDimension(self):
        """getInputDimension(DatabaseNumericalMathEvaluationImplementation self) -> OT::UnsignedLong"""
        return _func.DatabaseNumericalMathEvaluationImplementation_getInputDimension(self)

    def getOutputDimension(self):
        """getOutputDimension(DatabaseNumericalMathEvaluationImplementation self) -> OT::UnsignedLong"""
        return _func.DatabaseNumericalMathEvaluationImplementation_getOutputDimension(self)

    def __init__(self, *args): 
        """
        __init__(OT::DatabaseNumericalMathEvaluationImplementation self) -> DatabaseNumericalMathEvaluationImplementation
        __init__(OT::DatabaseNumericalMathEvaluationImplementation self, NumericalSample inputSample, NumericalSample outputSample, OT::Bool const activateCache=True) -> DatabaseNumericalMathEvaluationImplementation
        __init__(OT::DatabaseNumericalMathEvaluationImplementation self, NumericalSample inputSample, NumericalSample outputSample) -> DatabaseNumericalMathEvaluationImplementation
        __init__(OT::DatabaseNumericalMathEvaluationImplementation self, DatabaseNumericalMathEvaluationImplementation other) -> DatabaseNumericalMathEvaluationImplementation
        """
        this = _func.new_DatabaseNumericalMathEvaluationImplementation(*args)
        try: self.this.append(this)
        except: self.this = this
    __swig_destroy__ = _func.delete_DatabaseNumericalMathEvaluationImplementation
    __del__ = lambda self : None;
DatabaseNumericalMathEvaluationImplementation_swigregister = _func.DatabaseNumericalMathEvaluationImplementation_swigregister
DatabaseNumericalMathEvaluationImplementation_swigregister(DatabaseNumericalMathEvaluationImplementation)

def DatabaseNumericalMathEvaluationImplementation_GetClassName():
  """DatabaseNumericalMathEvaluationImplementation_GetClassName() -> OT::String"""
  return _func.DatabaseNumericalMathEvaluationImplementation_GetClassName()

class IndicatorNumericalMathEvaluationImplementation(NumericalMathEvaluationImplementation):
    """Proxy of C++ OT::IndicatorNumericalMathEvaluationImplementation class"""
    __swig_setmethods__ = {}
    for _s in [NumericalMathEvaluationImplementation]: __swig_setmethods__.update(getattr(_s,'__swig_setmethods__',{}))
    __setattr__ = lambda self, name, value: _swig_setattr(self, IndicatorNumericalMathEvaluationImplementation, name, value)
    __swig_getmethods__ = {}
    for _s in [NumericalMathEvaluationImplementation]: __swig_getmethods__.update(getattr(_s,'__swig_getmethods__',{}))
    __getattr__ = lambda self, name: _swig_getattr(self, IndicatorNumericalMathEvaluationImplementation, name)
    def GetClassName():
        """GetClassName() -> OT::String"""
        return _func.IndicatorNumericalMathEvaluationImplementation_GetClassName()

    if _newclass:GetClassName = staticmethod(GetClassName)
    __swig_getmethods__["GetClassName"] = lambda x: GetClassName
    def getClassName(self):
        """getClassName(IndicatorNumericalMathEvaluationImplementation self) -> OT::String"""
        return _func.IndicatorNumericalMathEvaluationImplementation_getClassName(self)

    def __eq__(self, *args):
        """__eq__(IndicatorNumericalMathEvaluationImplementation self, IndicatorNumericalMathEvaluationImplementation other) -> OT::Bool"""
        return _func.IndicatorNumericalMathEvaluationImplementation___eq__(self, *args)

    def __repr__(self):
        """__repr__(IndicatorNumericalMathEvaluationImplementation self) -> OT::String"""
        return _func.IndicatorNumericalMathEvaluationImplementation___repr__(self)

    def __call__(self, *args):
        """
        __call__(IndicatorNumericalMathEvaluationImplementation self, NumericalPoint inP) -> NumericalPoint
        __call__(IndicatorNumericalMathEvaluationImplementation self, NumericalSample inSample) -> NumericalSample
        __call__(IndicatorNumericalMathEvaluationImplementation self, TimeSeries inTimeSeries) -> TimeSeries
        __call__(IndicatorNumericalMathEvaluationImplementation self, NumericalPoint inP) -> NumericalPoint
        """
        return _func.IndicatorNumericalMathEvaluationImplementation___call__(self, *args)

    def getEvaluationImplementation(self):
        """getEvaluationImplementation(IndicatorNumericalMathEvaluationImplementation self) -> EvaluationImplementation"""
        return _func.IndicatorNumericalMathEvaluationImplementation_getEvaluationImplementation(self)

    def setEvaluationImplementation(self, *args):
        """setEvaluationImplementation(IndicatorNumericalMathEvaluationImplementation self, EvaluationImplementation p_evaluation)"""
        return _func.IndicatorNumericalMathEvaluationImplementation_setEvaluationImplementation(self, *args)

    def getComparisonOperator(self):
        """getComparisonOperator(IndicatorNumericalMathEvaluationImplementation self) -> ComparisonOperator"""
        return _func.IndicatorNumericalMathEvaluationImplementation_getComparisonOperator(self)

    def setComparisonOperator(self, *args):
        """setComparisonOperator(IndicatorNumericalMathEvaluationImplementation self, ComparisonOperator comparisonOperator)"""
        return _func.IndicatorNumericalMathEvaluationImplementation_setComparisonOperator(self, *args)

    def getThreshold(self):
        """getThreshold(IndicatorNumericalMathEvaluationImplementation self) -> OT::NumericalScalar"""
        return _func.IndicatorNumericalMathEvaluationImplementation_getThreshold(self)

    def setThreshold(self, *args):
        """setThreshold(IndicatorNumericalMathEvaluationImplementation self, OT::NumericalScalar const threshold)"""
        return _func.IndicatorNumericalMathEvaluationImplementation_setThreshold(self, *args)

    def getInputDimension(self):
        """getInputDimension(IndicatorNumericalMathEvaluationImplementation self) -> OT::UnsignedLong"""
        return _func.IndicatorNumericalMathEvaluationImplementation_getInputDimension(self)

    def getOutputDimension(self):
        """getOutputDimension(IndicatorNumericalMathEvaluationImplementation self) -> OT::UnsignedLong"""
        return _func.IndicatorNumericalMathEvaluationImplementation_getOutputDimension(self)

    def __init__(self, *args): 
        """
        __init__(OT::IndicatorNumericalMathEvaluationImplementation self) -> IndicatorNumericalMathEvaluationImplementation
        __init__(OT::IndicatorNumericalMathEvaluationImplementation self, EvaluationImplementation p_evaluation, ComparisonOperator comparisonOperator, OT::NumericalScalar const threshold) -> IndicatorNumericalMathEvaluationImplementation
        __init__(OT::IndicatorNumericalMathEvaluationImplementation self, IndicatorNumericalMathEvaluationImplementation other) -> IndicatorNumericalMathEvaluationImplementation
        """
        this = _func.new_IndicatorNumericalMathEvaluationImplementation(*args)
        try: self.this.append(this)
        except: self.this = this
    __swig_destroy__ = _func.delete_IndicatorNumericalMathEvaluationImplementation
    __del__ = lambda self : None;
IndicatorNumericalMathEvaluationImplementation_swigregister = _func.IndicatorNumericalMathEvaluationImplementation_swigregister
IndicatorNumericalMathEvaluationImplementation_swigregister(IndicatorNumericalMathEvaluationImplementation)

def IndicatorNumericalMathEvaluationImplementation_GetClassName():
  """IndicatorNumericalMathEvaluationImplementation_GetClassName() -> OT::String"""
  return _func.IndicatorNumericalMathEvaluationImplementation_GetClassName()

class PolynomialCollection(_object):
    """Proxy of C++ OT::Collection<(OT::UniVariatePolynomial)> class"""
    __swig_setmethods__ = {}
    __setattr__ = lambda self, name, value: _swig_setattr(self, PolynomialCollection, name, value)
    __swig_getmethods__ = {}
    __getattr__ = lambda self, name: _swig_getattr(self, PolynomialCollection, name)
    __swig_destroy__ = _func.delete_PolynomialCollection
    __del__ = lambda self : None;
    def clear(self):
        """clear(PolynomialCollection self)"""
        return _func.PolynomialCollection_clear(self)

    def __len__(self):
        """__len__(PolynomialCollection self) -> OT::UnsignedLong"""
        return _func.PolynomialCollection___len__(self)

    def __eq__(self, *args):
        """__eq__(PolynomialCollection self, PolynomialCollection rhs) -> OT::Bool"""
        return _func.PolynomialCollection___eq__(self, *args)

    def __contains__(self, *args):
        """__contains__(PolynomialCollection self, UniVariatePolynomial val) -> OT::Bool"""
        return _func.PolynomialCollection___contains__(self, *args)

    def __getitem__(self, *args):
        """__getitem__(PolynomialCollection self, OT::UnsignedLong const i) -> UniVariatePolynomial"""
        return _func.PolynomialCollection___getitem__(self, *args)

    def __setitem__(self, *args):
        """__setitem__(PolynomialCollection self, OT::UnsignedLong const i, UniVariatePolynomial val)"""
        return _func.PolynomialCollection___setitem__(self, *args)

    def __delitem__(self, *args):
        """__delitem__(PolynomialCollection self, OT::UnsignedLong const i)"""
        return _func.PolynomialCollection___delitem__(self, *args)

    def at(self, *args):
        """
        at(PolynomialCollection self, OT::UnsignedLong const i) -> UniVariatePolynomial
        at(PolynomialCollection self, OT::UnsignedLong const i) -> UniVariatePolynomial
        """
        return _func.PolynomialCollection_at(self, *args)

    def add(self, *args):
        """
        add(PolynomialCollection self, UniVariatePolynomial elt)
        add(PolynomialCollection self, PolynomialCollection coll)
        """
        return _func.PolynomialCollection_add(self, *args)

    def getSize(self):
        """getSize(PolynomialCollection self) -> OT::UnsignedLong"""
        return _func.PolynomialCollection_getSize(self)

    def resize(self, *args):
        """resize(PolynomialCollection self, OT::UnsignedLong const newSize)"""
        return _func.PolynomialCollection_resize(self, *args)

    def isEmpty(self):
        """isEmpty(PolynomialCollection self) -> OT::Bool"""
        return _func.PolynomialCollection_isEmpty(self)

    def __repr__(self):
        """__repr__(PolynomialCollection self) -> OT::String"""
        return _func.PolynomialCollection___repr__(self)

    def __str__(self, offset=""):
        """
        __str__(PolynomialCollection self, OT::String const & offset="") -> OT::String
        __str__(PolynomialCollection self) -> OT::String
        """
        return _func.PolynomialCollection___str__(self, offset)

    def __init__(self, *args): 
        """
        __init__(OT::Collection<(OT::UniVariatePolynomial)> self) -> PolynomialCollection
        __init__(OT::Collection<(OT::UniVariatePolynomial)> self, OT::UnsignedLong const size) -> PolynomialCollection
        __init__(OT::Collection<(OT::UniVariatePolynomial)> self, OT::UnsignedLong const size, UniVariatePolynomial value) -> PolynomialCollection
        __init__(OT::Collection<(OT::UniVariatePolynomial)> self, PyObject * pyObj) -> PolynomialCollection
        __init__(OT::Collection<(OT::UniVariatePolynomial)> self, PolynomialCollection other) -> PolynomialCollection
        """
        this = _func.new_PolynomialCollection(*args)
        try: self.this.append(this)
        except: self.this = this
PolynomialCollection_swigregister = _func.PolynomialCollection_swigregister
PolynomialCollection_swigregister(PolynomialCollection)

class PolynomialPersistentCollection(openturns.common.PersistentObject,PolynomialCollection):
    """Proxy of C++ OT::PersistentCollection<(OT::UniVariatePolynomial)> class"""
    __swig_setmethods__ = {}
    for _s in [openturns.common.PersistentObject,PolynomialCollection]: __swig_setmethods__.update(getattr(_s,'__swig_setmethods__',{}))
    __setattr__ = lambda self, name, value: _swig_setattr(self, PolynomialPersistentCollection, name, value)
    __swig_getmethods__ = {}
    for _s in [openturns.common.PersistentObject,PolynomialCollection]: __swig_getmethods__.update(getattr(_s,'__swig_getmethods__',{}))
    __getattr__ = lambda self, name: _swig_getattr(self, PolynomialPersistentCollection, name)
    def GetClassName():
        """GetClassName() -> OT::String"""
        return _func.PolynomialPersistentCollection_GetClassName()

    if _newclass:GetClassName = staticmethod(GetClassName)
    __swig_getmethods__["GetClassName"] = lambda x: GetClassName
    def getClassName(self):
        """getClassName(PolynomialPersistentCollection self) -> OT::String"""
        return _func.PolynomialPersistentCollection_getClassName(self)

    def __init__(self, *args): 
        """
        __init__(OT::PersistentCollection<(OT::UniVariatePolynomial)> self) -> PolynomialPersistentCollection
        __init__(OT::PersistentCollection<(OT::UniVariatePolynomial)> self, PolynomialCollection collection) -> PolynomialPersistentCollection
        __init__(OT::PersistentCollection<(OT::UniVariatePolynomial)> self, OT::UnsignedLong const size) -> PolynomialPersistentCollection
        __init__(OT::PersistentCollection<(OT::UniVariatePolynomial)> self, OT::UnsignedLong const size, UniVariatePolynomial value) -> PolynomialPersistentCollection
        """
        this = _func.new_PolynomialPersistentCollection(*args)
        try: self.this.append(this)
        except: self.this = this
    def __repr__(self):
        """__repr__(PolynomialPersistentCollection self) -> OT::String"""
        return _func.PolynomialPersistentCollection___repr__(self)

    def __str__(self, offset=""):
        """
        __str__(PolynomialPersistentCollection self, OT::String const & offset="") -> OT::String
        __str__(PolynomialPersistentCollection self) -> OT::String
        """
        return _func.PolynomialPersistentCollection___str__(self, offset)

    __swig_destroy__ = _func.delete_PolynomialPersistentCollection
    __del__ = lambda self : None;
PolynomialPersistentCollection_swigregister = _func.PolynomialPersistentCollection_swigregister
PolynomialPersistentCollection_swigregister(PolynomialPersistentCollection)

def PolynomialPersistentCollection_GetClassName():
  """PolynomialPersistentCollection_GetClassName() -> OT::String"""
  return _func.PolynomialPersistentCollection_GetClassName()

class ProductPolynomialEvaluationImplementation(NumericalMathEvaluationImplementation):
    """Proxy of C++ OT::ProductPolynomialEvaluationImplementation class"""
    __swig_setmethods__ = {}
    for _s in [NumericalMathEvaluationImplementation]: __swig_setmethods__.update(getattr(_s,'__swig_setmethods__',{}))
    __setattr__ = lambda self, name, value: _swig_setattr(self, ProductPolynomialEvaluationImplementation, name, value)
    __swig_getmethods__ = {}
    for _s in [NumericalMathEvaluationImplementation]: __swig_getmethods__.update(getattr(_s,'__swig_getmethods__',{}))
    __getattr__ = lambda self, name: _swig_getattr(self, ProductPolynomialEvaluationImplementation, name)
    def GetClassName():
        """GetClassName() -> OT::String"""
        return _func.ProductPolynomialEvaluationImplementation_GetClassName()

    if _newclass:GetClassName = staticmethod(GetClassName)
    __swig_getmethods__["GetClassName"] = lambda x: GetClassName
    def getClassName(self):
        """getClassName(ProductPolynomialEvaluationImplementation self) -> OT::String"""
        return _func.ProductPolynomialEvaluationImplementation_getClassName(self)

    def __repr__(self):
        """__repr__(ProductPolynomialEvaluationImplementation self) -> OT::String"""
        return _func.ProductPolynomialEvaluationImplementation___repr__(self)

    def __str__(self, offset=""):
        """
        __str__(ProductPolynomialEvaluationImplementation self, OT::String const & offset="") -> OT::String
        __str__(ProductPolynomialEvaluationImplementation self) -> OT::String
        """
        return _func.ProductPolynomialEvaluationImplementation___str__(self, offset)

    def __call__(self, *args):
        """__call__(ProductPolynomialEvaluationImplementation self, NumericalPoint inP) -> NumericalPoint"""
        return _func.ProductPolynomialEvaluationImplementation___call__(self, *args)

    def getInputDimension(self):
        """getInputDimension(ProductPolynomialEvaluationImplementation self) -> OT::UnsignedLong"""
        return _func.ProductPolynomialEvaluationImplementation_getInputDimension(self)

    def getOutputDimension(self):
        """getOutputDimension(ProductPolynomialEvaluationImplementation self) -> OT::UnsignedLong"""
        return _func.ProductPolynomialEvaluationImplementation_getOutputDimension(self)

    def __init__(self, *args): 
        """
        __init__(OT::ProductPolynomialEvaluationImplementation self, PolynomialCollection coll) -> ProductPolynomialEvaluationImplementation
        __init__(OT::ProductPolynomialEvaluationImplementation self, ProductPolynomialEvaluationImplementation other) -> ProductPolynomialEvaluationImplementation
        """
        this = _func.new_ProductPolynomialEvaluationImplementation(*args)
        try: self.this.append(this)
        except: self.this = this
    __swig_destroy__ = _func.delete_ProductPolynomialEvaluationImplementation
    __del__ = lambda self : None;
ProductPolynomialEvaluationImplementation_swigregister = _func.ProductPolynomialEvaluationImplementation_swigregister
ProductPolynomialEvaluationImplementation_swigregister(ProductPolynomialEvaluationImplementation)

def ProductPolynomialEvaluationImplementation_GetClassName():
  """ProductPolynomialEvaluationImplementation_GetClassName() -> OT::String"""
  return _func.ProductPolynomialEvaluationImplementation_GetClassName()

class RestrictedEvaluationImplementation(NumericalMathEvaluationImplementation):
    """Proxy of C++ OT::RestrictedEvaluationImplementation class"""
    __swig_setmethods__ = {}
    for _s in [NumericalMathEvaluationImplementation]: __swig_setmethods__.update(getattr(_s,'__swig_setmethods__',{}))
    __setattr__ = lambda self, name, value: _swig_setattr(self, RestrictedEvaluationImplementation, name, value)
    __swig_getmethods__ = {}
    for _s in [NumericalMathEvaluationImplementation]: __swig_getmethods__.update(getattr(_s,'__swig_getmethods__',{}))
    __getattr__ = lambda self, name: _swig_getattr(self, RestrictedEvaluationImplementation, name)
    def GetClassName():
        """GetClassName() -> OT::String"""
        return _func.RestrictedEvaluationImplementation_GetClassName()

    if _newclass:GetClassName = staticmethod(GetClassName)
    __swig_getmethods__["GetClassName"] = lambda x: GetClassName
    def getClassName(self):
        """getClassName(RestrictedEvaluationImplementation self) -> OT::String"""
        return _func.RestrictedEvaluationImplementation_getClassName(self)

    def __eq__(self, *args):
        """__eq__(RestrictedEvaluationImplementation self, RestrictedEvaluationImplementation other) -> OT::Bool"""
        return _func.RestrictedEvaluationImplementation___eq__(self, *args)

    def __repr__(self):
        """__repr__(RestrictedEvaluationImplementation self) -> OT::String"""
        return _func.RestrictedEvaluationImplementation___repr__(self)

    def __str__(self, offset=""):
        """
        __str__(RestrictedEvaluationImplementation self, OT::String const & offset="") -> OT::String
        __str__(RestrictedEvaluationImplementation self) -> OT::String
        """
        return _func.RestrictedEvaluationImplementation___str__(self, offset)

    def __call__(self, *args):
        """
        __call__(RestrictedEvaluationImplementation self, NumericalPoint inP) -> NumericalPoint
        __call__(RestrictedEvaluationImplementation self, NumericalSample inSample) -> NumericalSample
        __call__(RestrictedEvaluationImplementation self, TimeSeries inTimeSeries) -> TimeSeries
        __call__(RestrictedEvaluationImplementation self, NumericalPoint inP) -> NumericalPoint
        """
        return _func.RestrictedEvaluationImplementation___call__(self, *args)

    def getInputDimension(self):
        """getInputDimension(RestrictedEvaluationImplementation self) -> OT::UnsignedLong"""
        return _func.RestrictedEvaluationImplementation_getInputDimension(self)

    def getOutputDimension(self):
        """getOutputDimension(RestrictedEvaluationImplementation self) -> OT::UnsignedLong"""
        return _func.RestrictedEvaluationImplementation_getOutputDimension(self)

    def getEvaluation(self):
        """getEvaluation(RestrictedEvaluationImplementation self) -> EvaluationImplementation"""
        return _func.RestrictedEvaluationImplementation_getEvaluation(self)

    def setEvaluation(self, *args):
        """setEvaluation(RestrictedEvaluationImplementation self, NumericalMathEvaluationImplementation evaluation)"""
        return _func.RestrictedEvaluationImplementation_setEvaluation(self, *args)

    def getRestrictionIndices(self):
        """getRestrictionIndices(RestrictedEvaluationImplementation self) -> Indices"""
        return _func.RestrictedEvaluationImplementation_getRestrictionIndices(self)

    def setRestrictionIndices(self, *args):
        """setRestrictionIndices(RestrictedEvaluationImplementation self, Indices restrictionIndices)"""
        return _func.RestrictedEvaluationImplementation_setRestrictionIndices(self, *args)

    def getReferencePoint(self):
        """getReferencePoint(RestrictedEvaluationImplementation self) -> NumericalPoint"""
        return _func.RestrictedEvaluationImplementation_getReferencePoint(self)

    def setReferencePoint(self, *args):
        """setReferencePoint(RestrictedEvaluationImplementation self, NumericalPoint referencePoint)"""
        return _func.RestrictedEvaluationImplementation_setReferencePoint(self, *args)

    def __init__(self, *args): 
        """
        __init__(OT::RestrictedEvaluationImplementation self) -> RestrictedEvaluationImplementation
        __init__(OT::RestrictedEvaluationImplementation self, NumericalMathEvaluationImplementation evaluation, Indices restrictionIndices, NumericalPoint referencePoint) -> RestrictedEvaluationImplementation
        __init__(OT::RestrictedEvaluationImplementation self, EvaluationImplementation p_evaluation, Indices restrictionIndices, NumericalPoint referencePoint) -> RestrictedEvaluationImplementation
        __init__(OT::RestrictedEvaluationImplementation self, RestrictedEvaluationImplementation other) -> RestrictedEvaluationImplementation
        """
        this = _func.new_RestrictedEvaluationImplementation(*args)
        try: self.this.append(this)
        except: self.this = this
    __swig_destroy__ = _func.delete_RestrictedEvaluationImplementation
    __del__ = lambda self : None;
RestrictedEvaluationImplementation_swigregister = _func.RestrictedEvaluationImplementation_swigregister
RestrictedEvaluationImplementation_swigregister(RestrictedEvaluationImplementation)

def RestrictedEvaluationImplementation_GetClassName():
  """RestrictedEvaluationImplementation_GetClassName() -> OT::String"""
  return _func.RestrictedEvaluationImplementation_GetClassName()

class RestrictedGradientImplementation(NumericalMathGradientImplementation):
    """Proxy of C++ OT::RestrictedGradientImplementation class"""
    __swig_setmethods__ = {}
    for _s in [NumericalMathGradientImplementation]: __swig_setmethods__.update(getattr(_s,'__swig_setmethods__',{}))
    __setattr__ = lambda self, name, value: _swig_setattr(self, RestrictedGradientImplementation, name, value)
    __swig_getmethods__ = {}
    for _s in [NumericalMathGradientImplementation]: __swig_getmethods__.update(getattr(_s,'__swig_getmethods__',{}))
    __getattr__ = lambda self, name: _swig_getattr(self, RestrictedGradientImplementation, name)
    def GetClassName():
        """GetClassName() -> OT::String"""
        return _func.RestrictedGradientImplementation_GetClassName()

    if _newclass:GetClassName = staticmethod(GetClassName)
    __swig_getmethods__["GetClassName"] = lambda x: GetClassName
    def getClassName(self):
        """getClassName(RestrictedGradientImplementation self) -> OT::String"""
        return _func.RestrictedGradientImplementation_getClassName(self)

    def __eq__(self, *args):
        """__eq__(RestrictedGradientImplementation self, RestrictedGradientImplementation other) -> OT::Bool"""
        return _func.RestrictedGradientImplementation___eq__(self, *args)

    def __repr__(self):
        """__repr__(RestrictedGradientImplementation self) -> OT::String"""
        return _func.RestrictedGradientImplementation___repr__(self)

    def __str__(self, offset=""):
        """
        __str__(RestrictedGradientImplementation self, OT::String const & offset="") -> OT::String
        __str__(RestrictedGradientImplementation self) -> OT::String
        """
        return _func.RestrictedGradientImplementation___str__(self, offset)

    def gradient(self, *args):
        """
        gradient(RestrictedGradientImplementation self, NumericalPoint inP) -> Matrix
        gradient(RestrictedGradientImplementation self, NumericalPoint inP) -> Matrix
        """
        return _func.RestrictedGradientImplementation_gradient(self, *args)

    def getInputDimension(self):
        """getInputDimension(RestrictedGradientImplementation self) -> OT::UnsignedLong"""
        return _func.RestrictedGradientImplementation_getInputDimension(self)

    def getOutputDimension(self):
        """getOutputDimension(RestrictedGradientImplementation self) -> OT::UnsignedLong"""
        return _func.RestrictedGradientImplementation_getOutputDimension(self)

    def getGradient(self):
        """getGradient(RestrictedGradientImplementation self) -> GradientImplementation"""
        return _func.RestrictedGradientImplementation_getGradient(self)

    def setGradient(self, *args):
        """setGradient(RestrictedGradientImplementation self, NumericalMathGradientImplementation gradient)"""
        return _func.RestrictedGradientImplementation_setGradient(self, *args)

    def getRestrictionIndices(self):
        """getRestrictionIndices(RestrictedGradientImplementation self) -> Indices"""
        return _func.RestrictedGradientImplementation_getRestrictionIndices(self)

    def setRestrictionIndices(self, *args):
        """setRestrictionIndices(RestrictedGradientImplementation self, Indices restrictionIndices)"""
        return _func.RestrictedGradientImplementation_setRestrictionIndices(self, *args)

    def getReferencePoint(self):
        """getReferencePoint(RestrictedGradientImplementation self) -> NumericalPoint"""
        return _func.RestrictedGradientImplementation_getReferencePoint(self)

    def setReferencePoint(self, *args):
        """setReferencePoint(RestrictedGradientImplementation self, NumericalPoint referencePoint)"""
        return _func.RestrictedGradientImplementation_setReferencePoint(self, *args)

    def __init__(self, *args): 
        """
        __init__(OT::RestrictedGradientImplementation self) -> RestrictedGradientImplementation
        __init__(OT::RestrictedGradientImplementation self, NumericalMathGradientImplementation gradient, Indices restrictionIndices, NumericalPoint referencePoint) -> RestrictedGradientImplementation
        __init__(OT::RestrictedGradientImplementation self, RestrictedGradientImplementation other) -> RestrictedGradientImplementation
        """
        this = _func.new_RestrictedGradientImplementation(*args)
        try: self.this.append(this)
        except: self.this = this
    __swig_destroy__ = _func.delete_RestrictedGradientImplementation
    __del__ = lambda self : None;
RestrictedGradientImplementation_swigregister = _func.RestrictedGradientImplementation_swigregister
RestrictedGradientImplementation_swigregister(RestrictedGradientImplementation)

def RestrictedGradientImplementation_GetClassName():
  """RestrictedGradientImplementation_GetClassName() -> OT::String"""
  return _func.RestrictedGradientImplementation_GetClassName()

class RestrictedHessianImplementation(NumericalMathHessianImplementation):
    """Proxy of C++ OT::RestrictedHessianImplementation class"""
    __swig_setmethods__ = {}
    for _s in [NumericalMathHessianImplementation]: __swig_setmethods__.update(getattr(_s,'__swig_setmethods__',{}))
    __setattr__ = lambda self, name, value: _swig_setattr(self, RestrictedHessianImplementation, name, value)
    __swig_getmethods__ = {}
    for _s in [NumericalMathHessianImplementation]: __swig_getmethods__.update(getattr(_s,'__swig_getmethods__',{}))
    __getattr__ = lambda self, name: _swig_getattr(self, RestrictedHessianImplementation, name)
    def GetClassName():
        """GetClassName() -> OT::String"""
        return _func.RestrictedHessianImplementation_GetClassName()

    if _newclass:GetClassName = staticmethod(GetClassName)
    __swig_getmethods__["GetClassName"] = lambda x: GetClassName
    def getClassName(self):
        """getClassName(RestrictedHessianImplementation self) -> OT::String"""
        return _func.RestrictedHessianImplementation_getClassName(self)

    def __eq__(self, *args):
        """__eq__(RestrictedHessianImplementation self, RestrictedHessianImplementation other) -> OT::Bool"""
        return _func.RestrictedHessianImplementation___eq__(self, *args)

    def __repr__(self):
        """__repr__(RestrictedHessianImplementation self) -> OT::String"""
        return _func.RestrictedHessianImplementation___repr__(self)

    def __str__(self, offset=""):
        """
        __str__(RestrictedHessianImplementation self, OT::String const & offset="") -> OT::String
        __str__(RestrictedHessianImplementation self) -> OT::String
        """
        return _func.RestrictedHessianImplementation___str__(self, offset)

    def hessian(self, *args):
        """
        hessian(RestrictedHessianImplementation self, NumericalPoint inP) -> SymmetricTensor
        hessian(RestrictedHessianImplementation self, NumericalPoint inP) -> SymmetricTensor
        """
        return _func.RestrictedHessianImplementation_hessian(self, *args)

    def getInputDimension(self):
        """getInputDimension(RestrictedHessianImplementation self) -> OT::UnsignedLong"""
        return _func.RestrictedHessianImplementation_getInputDimension(self)

    def getOutputDimension(self):
        """getOutputDimension(RestrictedHessianImplementation self) -> OT::UnsignedLong"""
        return _func.RestrictedHessianImplementation_getOutputDimension(self)

    def getHessian(self):
        """getHessian(RestrictedHessianImplementation self) -> HessianImplementation"""
        return _func.RestrictedHessianImplementation_getHessian(self)

    def setHessian(self, *args):
        """setHessian(RestrictedHessianImplementation self, NumericalMathHessianImplementation hessian)"""
        return _func.RestrictedHessianImplementation_setHessian(self, *args)

    def getRestrictionIndices(self):
        """getRestrictionIndices(RestrictedHessianImplementation self) -> Indices"""
        return _func.RestrictedHessianImplementation_getRestrictionIndices(self)

    def setRestrictionIndices(self, *args):
        """setRestrictionIndices(RestrictedHessianImplementation self, Indices restrictionIndices)"""
        return _func.RestrictedHessianImplementation_setRestrictionIndices(self, *args)

    def getReferencePoint(self):
        """getReferencePoint(RestrictedHessianImplementation self) -> NumericalPoint"""
        return _func.RestrictedHessianImplementation_getReferencePoint(self)

    def setReferencePoint(self, *args):
        """setReferencePoint(RestrictedHessianImplementation self, NumericalPoint referencePoint)"""
        return _func.RestrictedHessianImplementation_setReferencePoint(self, *args)

    def __init__(self, *args): 
        """
        __init__(OT::RestrictedHessianImplementation self) -> RestrictedHessianImplementation
        __init__(OT::RestrictedHessianImplementation self, NumericalMathHessianImplementation hessian, Indices restrictionIndices, NumericalPoint referencePoint) -> RestrictedHessianImplementation
        __init__(OT::RestrictedHessianImplementation self, RestrictedHessianImplementation other) -> RestrictedHessianImplementation
        """
        this = _func.new_RestrictedHessianImplementation(*args)
        try: self.this.append(this)
        except: self.this = this
    __swig_destroy__ = _func.delete_RestrictedHessianImplementation
    __del__ = lambda self : None;
RestrictedHessianImplementation_swigregister = _func.RestrictedHessianImplementation_swigregister
RestrictedHessianImplementation_swigregister(RestrictedHessianImplementation)

def RestrictedHessianImplementation_GetClassName():
  """RestrictedHessianImplementation_GetClassName() -> OT::String"""
  return _func.RestrictedHessianImplementation_GetClassName()

class NumericalMathFunctionPersistentCollection(openturns.common.PersistentObject,NumericalMathFunctionCollection):
    """Proxy of C++ OT::PersistentCollection<(OT::NumericalMathFunction)> class"""
    __swig_setmethods__ = {}
    for _s in [openturns.common.PersistentObject,NumericalMathFunctionCollection]: __swig_setmethods__.update(getattr(_s,'__swig_setmethods__',{}))
    __setattr__ = lambda self, name, value: _swig_setattr(self, NumericalMathFunctionPersistentCollection, name, value)
    __swig_getmethods__ = {}
    for _s in [openturns.common.PersistentObject,NumericalMathFunctionCollection]: __swig_getmethods__.update(getattr(_s,'__swig_getmethods__',{}))
    __getattr__ = lambda self, name: _swig_getattr(self, NumericalMathFunctionPersistentCollection, name)
    def GetClassName():
        """GetClassName() -> OT::String"""
        return _func.NumericalMathFunctionPersistentCollection_GetClassName()

    if _newclass:GetClassName = staticmethod(GetClassName)
    __swig_getmethods__["GetClassName"] = lambda x: GetClassName
    def getClassName(self):
        """getClassName(NumericalMathFunctionPersistentCollection self) -> OT::String"""
        return _func.NumericalMathFunctionPersistentCollection_getClassName(self)

    def __init__(self, *args): 
        """
        __init__(OT::PersistentCollection<(OT::NumericalMathFunction)> self) -> NumericalMathFunctionPersistentCollection
        __init__(OT::PersistentCollection<(OT::NumericalMathFunction)> self, NumericalMathFunctionCollection collection) -> NumericalMathFunctionPersistentCollection
        __init__(OT::PersistentCollection<(OT::NumericalMathFunction)> self, OT::UnsignedLong const size) -> NumericalMathFunctionPersistentCollection
        __init__(OT::PersistentCollection<(OT::NumericalMathFunction)> self, OT::UnsignedLong const size, NumericalMathFunction value) -> NumericalMathFunctionPersistentCollection
        """
        this = _func.new_NumericalMathFunctionPersistentCollection(*args)
        try: self.this.append(this)
        except: self.this = this
    def __repr__(self):
        """__repr__(NumericalMathFunctionPersistentCollection self) -> OT::String"""
        return _func.NumericalMathFunctionPersistentCollection___repr__(self)

    def __str__(self, offset=""):
        """
        __str__(NumericalMathFunctionPersistentCollection self, OT::String const & offset="") -> OT::String
        __str__(NumericalMathFunctionPersistentCollection self) -> OT::String
        """
        return _func.NumericalMathFunctionPersistentCollection___str__(self, offset)

    __swig_destroy__ = _func.delete_NumericalMathFunctionPersistentCollection
    __del__ = lambda self : None;
NumericalMathFunctionPersistentCollection_swigregister = _func.NumericalMathFunctionPersistentCollection_swigregister
NumericalMathFunctionPersistentCollection_swigregister(NumericalMathFunctionPersistentCollection)

def NumericalMathFunctionPersistentCollection_GetClassName():
  """NumericalMathFunctionPersistentCollection_GetClassName() -> OT::String"""
  return _func.NumericalMathFunctionPersistentCollection_GetClassName()

class Basis(NumericalMathFunctionPersistentCollection):
    """Proxy of C++ OT::Basis class"""
    __swig_setmethods__ = {}
    for _s in [NumericalMathFunctionPersistentCollection]: __swig_setmethods__.update(getattr(_s,'__swig_setmethods__',{}))
    __setattr__ = lambda self, name, value: _swig_setattr(self, Basis, name, value)
    __swig_getmethods__ = {}
    for _s in [NumericalMathFunctionPersistentCollection]: __swig_getmethods__.update(getattr(_s,'__swig_getmethods__',{}))
    __getattr__ = lambda self, name: _swig_getattr(self, Basis, name)
    def GetClassName():
        """GetClassName() -> OT::String"""
        return _func.Basis_GetClassName()

    if _newclass:GetClassName = staticmethod(GetClassName)
    __swig_getmethods__["GetClassName"] = lambda x: GetClassName
    def getClassName(self):
        """getClassName(Basis self) -> OT::String"""
        return _func.Basis_getClassName(self)

    def __repr__(self):
        """__repr__(Basis self) -> OT::String"""
        return _func.Basis___repr__(self)

    def __str__(self, offset=""):
        """
        __str__(Basis self, OT::String const & offset="") -> OT::String
        __str__(Basis self) -> OT::String
        """
        return _func.Basis___str__(self, offset)

    def getDimension(self):
        """getDimension(Basis self) -> OT::UnsignedLong"""
        return _func.Basis_getDimension(self)

    def __init__(self, *args): 
        """
        __init__(OT::Basis self) -> Basis
        __init__(OT::Basis self, NumericalMathFunctionCollection coll) -> Basis
        __init__(OT::Basis self, Basis other) -> Basis
        __init__(OT::Basis self, PyObject * pyObj) -> Basis
        """
        this = _func.new_Basis(*args)
        try: self.this.append(this)
        except: self.this = this
    __swig_destroy__ = _func.delete_Basis
    __del__ = lambda self : None;
Basis_swigregister = _func.Basis_swigregister
Basis_swigregister(Basis)

def Basis_GetClassName():
  """Basis_GetClassName() -> OT::String"""
  return _func.Basis_GetClassName()

class IndicesCollection(_object):
    """Proxy of C++ OT::Collection<(OT::Indices)> class"""
    __swig_setmethods__ = {}
    __setattr__ = lambda self, name, value: _swig_setattr(self, IndicesCollection, name, value)
    __swig_getmethods__ = {}
    __getattr__ = lambda self, name: _swig_getattr(self, IndicesCollection, name)
    __swig_destroy__ = _func.delete_IndicesCollection
    __del__ = lambda self : None;
    def clear(self):
        """clear(IndicesCollection self)"""
        return _func.IndicesCollection_clear(self)

    def __len__(self):
        """__len__(IndicesCollection self) -> OT::UnsignedLong"""
        return _func.IndicesCollection___len__(self)

    def __eq__(self, *args):
        """__eq__(IndicesCollection self, IndicesCollection rhs) -> OT::Bool"""
        return _func.IndicesCollection___eq__(self, *args)

    def __contains__(self, *args):
        """__contains__(IndicesCollection self, Indices val) -> OT::Bool"""
        return _func.IndicesCollection___contains__(self, *args)

    def __getitem__(self, *args):
        """__getitem__(IndicesCollection self, OT::UnsignedLong const i) -> Indices"""
        return _func.IndicesCollection___getitem__(self, *args)

    def __setitem__(self, *args):
        """__setitem__(IndicesCollection self, OT::UnsignedLong const i, Indices val)"""
        return _func.IndicesCollection___setitem__(self, *args)

    def __delitem__(self, *args):
        """__delitem__(IndicesCollection self, OT::UnsignedLong const i)"""
        return _func.IndicesCollection___delitem__(self, *args)

    def at(self, *args):
        """
        at(IndicesCollection self, OT::UnsignedLong const i) -> Indices
        at(IndicesCollection self, OT::UnsignedLong const i) -> Indices
        """
        return _func.IndicesCollection_at(self, *args)

    def add(self, *args):
        """
        add(IndicesCollection self, Indices elt)
        add(IndicesCollection self, IndicesCollection coll)
        """
        return _func.IndicesCollection_add(self, *args)

    def getSize(self):
        """getSize(IndicesCollection self) -> OT::UnsignedLong"""
        return _func.IndicesCollection_getSize(self)

    def resize(self, *args):
        """resize(IndicesCollection self, OT::UnsignedLong const newSize)"""
        return _func.IndicesCollection_resize(self, *args)

    def isEmpty(self):
        """isEmpty(IndicesCollection self) -> OT::Bool"""
        return _func.IndicesCollection_isEmpty(self)

    def __repr__(self):
        """__repr__(IndicesCollection self) -> OT::String"""
        return _func.IndicesCollection___repr__(self)

    def __str__(self, offset=""):
        """
        __str__(IndicesCollection self, OT::String const & offset="") -> OT::String
        __str__(IndicesCollection self) -> OT::String
        """
        return _func.IndicesCollection___str__(self, offset)

    def __init__(self, *args): 
        """
        __init__(OT::Collection<(OT::Indices)> self) -> IndicesCollection
        __init__(OT::Collection<(OT::Indices)> self, OT::UnsignedLong const size) -> IndicesCollection
        __init__(OT::Collection<(OT::Indices)> self, OT::UnsignedLong const size, Indices value) -> IndicesCollection
        __init__(OT::Collection<(OT::Indices)> self, PyObject * pyObj) -> IndicesCollection
        __init__(OT::Collection<(OT::Indices)> self, IndicesCollection other) -> IndicesCollection
        """
        this = _func.new_IndicesCollection(*args)
        try: self.this.append(this)
        except: self.this = this
IndicesCollection_swigregister = _func.IndicesCollection_swigregister
IndicesCollection_swigregister(IndicesCollection)

class IndicesPersistentCollection(openturns.common.PersistentObject,IndicesCollection):
    """Proxy of C++ OT::PersistentCollection<(OT::Indices)> class"""
    __swig_setmethods__ = {}
    for _s in [openturns.common.PersistentObject,IndicesCollection]: __swig_setmethods__.update(getattr(_s,'__swig_setmethods__',{}))
    __setattr__ = lambda self, name, value: _swig_setattr(self, IndicesPersistentCollection, name, value)
    __swig_getmethods__ = {}
    for _s in [openturns.common.PersistentObject,IndicesCollection]: __swig_getmethods__.update(getattr(_s,'__swig_getmethods__',{}))
    __getattr__ = lambda self, name: _swig_getattr(self, IndicesPersistentCollection, name)
    def GetClassName():
        """GetClassName() -> OT::String"""
        return _func.IndicesPersistentCollection_GetClassName()

    if _newclass:GetClassName = staticmethod(GetClassName)
    __swig_getmethods__["GetClassName"] = lambda x: GetClassName
    def getClassName(self):
        """getClassName(IndicesPersistentCollection self) -> OT::String"""
        return _func.IndicesPersistentCollection_getClassName(self)

    def __init__(self, *args): 
        """
        __init__(OT::PersistentCollection<(OT::Indices)> self) -> IndicesPersistentCollection
        __init__(OT::PersistentCollection<(OT::Indices)> self, IndicesCollection collection) -> IndicesPersistentCollection
        __init__(OT::PersistentCollection<(OT::Indices)> self, OT::UnsignedLong const size) -> IndicesPersistentCollection
        __init__(OT::PersistentCollection<(OT::Indices)> self, OT::UnsignedLong const size, Indices value) -> IndicesPersistentCollection
        """
        this = _func.new_IndicesPersistentCollection(*args)
        try: self.this.append(this)
        except: self.this = this
    def __repr__(self):
        """__repr__(IndicesPersistentCollection self) -> OT::String"""
        return _func.IndicesPersistentCollection___repr__(self)

    def __str__(self, offset=""):
        """
        __str__(IndicesPersistentCollection self, OT::String const & offset="") -> OT::String
        __str__(IndicesPersistentCollection self) -> OT::String
        """
        return _func.IndicesPersistentCollection___str__(self, offset)

    __swig_destroy__ = _func.delete_IndicesPersistentCollection
    __del__ = lambda self : None;
IndicesPersistentCollection_swigregister = _func.IndicesPersistentCollection_swigregister
IndicesPersistentCollection_swigregister(IndicesPersistentCollection)

def IndicesPersistentCollection_GetClassName():
  """IndicesPersistentCollection_GetClassName() -> OT::String"""
  return _func.IndicesPersistentCollection_GetClassName()

class BasisSequenceImplementation(IndicesPersistentCollection):
    """Proxy of C++ OT::BasisSequenceImplementation class"""
    __swig_setmethods__ = {}
    for _s in [IndicesPersistentCollection]: __swig_setmethods__.update(getattr(_s,'__swig_setmethods__',{}))
    __setattr__ = lambda self, name, value: _swig_setattr(self, BasisSequenceImplementation, name, value)
    __swig_getmethods__ = {}
    for _s in [IndicesPersistentCollection]: __swig_getmethods__.update(getattr(_s,'__swig_getmethods__',{}))
    __getattr__ = lambda self, name: _swig_getattr(self, BasisSequenceImplementation, name)
    def GetClassName():
        """GetClassName() -> OT::String"""
        return _func.BasisSequenceImplementation_GetClassName()

    if _newclass:GetClassName = staticmethod(GetClassName)
    __swig_getmethods__["GetClassName"] = lambda x: GetClassName
    def getClassName(self):
        """getClassName(BasisSequenceImplementation self) -> OT::String"""
        return _func.BasisSequenceImplementation_getClassName(self)

    def __repr__(self):
        """__repr__(BasisSequenceImplementation self) -> OT::String"""
        return _func.BasisSequenceImplementation___repr__(self)

    def __str__(self, offset=""):
        """
        __str__(BasisSequenceImplementation self, OT::String const & offset="") -> OT::String
        __str__(BasisSequenceImplementation self) -> OT::String
        """
        return _func.BasisSequenceImplementation___str__(self, offset)

    def getDimension(self):
        """getDimension(BasisSequenceImplementation self) -> OT::UnsignedLong"""
        return _func.BasisSequenceImplementation_getDimension(self)

    def getMasterBasis(self):
        """getMasterBasis(BasisSequenceImplementation self) -> Basis"""
        return _func.BasisSequenceImplementation_getMasterBasis(self)

    def getBasis(self, *args):
        """getBasis(BasisSequenceImplementation self, OT::UnsignedLong const index) -> Basis"""
        return _func.BasisSequenceImplementation_getBasis(self, *args)

    def getIndices(self, *args):
        """getIndices(BasisSequenceImplementation self, OT::UnsignedLong const index) -> Indices"""
        return _func.BasisSequenceImplementation_getIndices(self, *args)

    def __init__(self, *args): 
        """
        __init__(OT::BasisSequenceImplementation self) -> BasisSequenceImplementation
        __init__(OT::BasisSequenceImplementation self, Basis masterBasis) -> BasisSequenceImplementation
        __init__(OT::BasisSequenceImplementation self, BasisSequenceImplementation other) -> BasisSequenceImplementation
        """
        this = _func.new_BasisSequenceImplementation(*args)
        try: self.this.append(this)
        except: self.this = this
    __swig_destroy__ = _func.delete_BasisSequenceImplementation
    __del__ = lambda self : None;
BasisSequenceImplementation_swigregister = _func.BasisSequenceImplementation_swigregister
BasisSequenceImplementation_swigregister(BasisSequenceImplementation)

def BasisSequenceImplementation_GetClassName():
  """BasisSequenceImplementation_GetClassName() -> OT::String"""
  return _func.BasisSequenceImplementation_GetClassName()

class BasisSequenceImplementationTypedInterfaceObject(openturns.common.InterfaceObject):
    """Proxy of C++ OT::TypedInterfaceObject<(OT::BasisSequenceImplementation)> class"""
    __swig_setmethods__ = {}
    for _s in [openturns.common.InterfaceObject]: __swig_setmethods__.update(getattr(_s,'__swig_setmethods__',{}))
    __setattr__ = lambda self, name, value: _swig_setattr(self, BasisSequenceImplementationTypedInterfaceObject, name, value)
    __swig_getmethods__ = {}
    for _s in [openturns.common.InterfaceObject]: __swig_getmethods__.update(getattr(_s,'__swig_getmethods__',{}))
    __getattr__ = lambda self, name: _swig_getattr(self, BasisSequenceImplementationTypedInterfaceObject, name)
    __repr__ = _swig_repr
    def __init__(self, *args): 
        """
        __init__(OT::TypedInterfaceObject<(OT::BasisSequenceImplementation)> self) -> BasisSequenceImplementationTypedInterfaceObject
        __init__(OT::TypedInterfaceObject<(OT::BasisSequenceImplementation)> self, OT::TypedInterfaceObject< OT::BasisSequenceImplementation >::Implementation const & impl) -> BasisSequenceImplementationTypedInterfaceObject
        """
        this = _func.new_BasisSequenceImplementationTypedInterfaceObject(*args)
        try: self.this.append(this)
        except: self.this = this
    def getImplementation(self, *args):
        """
        getImplementation(BasisSequenceImplementationTypedInterfaceObject self) -> OT::TypedInterfaceObject< OT::BasisSequenceImplementation >::Implementation
        getImplementation(BasisSequenceImplementationTypedInterfaceObject self) -> OT::TypedInterfaceObject< OT::BasisSequenceImplementation >::Implementation const &
        """
        return _func.BasisSequenceImplementationTypedInterfaceObject_getImplementation(self, *args)

    def getImplementationAsPersistentObject(self):
        """getImplementationAsPersistentObject(BasisSequenceImplementationTypedInterfaceObject self) -> PersistentObjectPointer"""
        return _func.BasisSequenceImplementationTypedInterfaceObject_getImplementationAsPersistentObject(self)

    def setImplementationAsPersistentObject(self, *args):
        """setImplementationAsPersistentObject(BasisSequenceImplementationTypedInterfaceObject self, PersistentObjectPointer obj)"""
        return _func.BasisSequenceImplementationTypedInterfaceObject_setImplementationAsPersistentObject(self, *args)

    def swap(self, *args):
        """swap(BasisSequenceImplementationTypedInterfaceObject self, BasisSequenceImplementationTypedInterfaceObject other)"""
        return _func.BasisSequenceImplementationTypedInterfaceObject_swap(self, *args)

    def setName(self, *args):
        """setName(BasisSequenceImplementationTypedInterfaceObject self, OT::String const & name)"""
        return _func.BasisSequenceImplementationTypedInterfaceObject_setName(self, *args)

    def getName(self):
        """getName(BasisSequenceImplementationTypedInterfaceObject self) -> OT::String"""
        return _func.BasisSequenceImplementationTypedInterfaceObject_getName(self)

    def __eq__(self, *args):
        """__eq__(BasisSequenceImplementationTypedInterfaceObject self, BasisSequenceImplementationTypedInterfaceObject other) -> OT::Bool"""
        return _func.BasisSequenceImplementationTypedInterfaceObject___eq__(self, *args)

    __swig_destroy__ = _func.delete_BasisSequenceImplementationTypedInterfaceObject
    __del__ = lambda self : None;
BasisSequenceImplementationTypedInterfaceObject_swigregister = _func.BasisSequenceImplementationTypedInterfaceObject_swigregister
BasisSequenceImplementationTypedInterfaceObject_swigregister(BasisSequenceImplementationTypedInterfaceObject)

class BasisSequenceImplementationTypedCollectionInterfaceObject(BasisSequenceImplementationTypedInterfaceObject):
    """Proxy of C++ OT::TypedCollectionInterfaceObject<(OT::BasisSequenceImplementation)> class"""
    __swig_setmethods__ = {}
    for _s in [BasisSequenceImplementationTypedInterfaceObject]: __swig_setmethods__.update(getattr(_s,'__swig_setmethods__',{}))
    __setattr__ = lambda self, name, value: _swig_setattr(self, BasisSequenceImplementationTypedCollectionInterfaceObject, name, value)
    __swig_getmethods__ = {}
    for _s in [BasisSequenceImplementationTypedInterfaceObject]: __swig_getmethods__.update(getattr(_s,'__swig_getmethods__',{}))
    __getattr__ = lambda self, name: _swig_getattr(self, BasisSequenceImplementationTypedCollectionInterfaceObject, name)
    __repr__ = _swig_repr
    def __init__(self, *args): 
        """
        __init__(OT::TypedCollectionInterfaceObject<(OT::BasisSequenceImplementation)> self) -> BasisSequenceImplementationTypedCollectionInterfaceObject
        __init__(OT::TypedCollectionInterfaceObject<(OT::BasisSequenceImplementation)> self, OT::TypedCollectionInterfaceObject< OT::BasisSequenceImplementation >::Implementation const & impl) -> BasisSequenceImplementationTypedCollectionInterfaceObject
        """
        this = _func.new_BasisSequenceImplementationTypedCollectionInterfaceObject(*args)
        try: self.this.append(this)
        except: self.this = this
    def __getitem__(self, *args):
        """__getitem__(BasisSequenceImplementationTypedCollectionInterfaceObject self, OT::UnsignedLong i) -> Indices"""
        return _func.BasisSequenceImplementationTypedCollectionInterfaceObject___getitem__(self, *args)

    def __setitem__(self, *args):
        """__setitem__(BasisSequenceImplementationTypedCollectionInterfaceObject self, OT::UnsignedLong i, Indices val)"""
        return _func.BasisSequenceImplementationTypedCollectionInterfaceObject___setitem__(self, *args)

    def add(self, *args):
        """add(BasisSequenceImplementationTypedCollectionInterfaceObject self, Indices elt)"""
        return _func.BasisSequenceImplementationTypedCollectionInterfaceObject_add(self, *args)

    def getSize(self):
        """getSize(BasisSequenceImplementationTypedCollectionInterfaceObject self) -> OT::UnsignedLong"""
        return _func.BasisSequenceImplementationTypedCollectionInterfaceObject_getSize(self)

    def getDimension(self):
        """getDimension(BasisSequenceImplementationTypedCollectionInterfaceObject self) -> OT::UnsignedLong"""
        return _func.BasisSequenceImplementationTypedCollectionInterfaceObject_getDimension(self)

    def isEmpty(self):
        """isEmpty(BasisSequenceImplementationTypedCollectionInterfaceObject self) -> OT::Bool"""
        return _func.BasisSequenceImplementationTypedCollectionInterfaceObject_isEmpty(self)

    def erase(self, *args):
        """erase(BasisSequenceImplementationTypedCollectionInterfaceObject self, OT::UnsignedLong position)"""
        return _func.BasisSequenceImplementationTypedCollectionInterfaceObject_erase(self, *args)

    __swig_destroy__ = _func.delete_BasisSequenceImplementationTypedCollectionInterfaceObject
    __del__ = lambda self : None;
BasisSequenceImplementationTypedCollectionInterfaceObject_swigregister = _func.BasisSequenceImplementationTypedCollectionInterfaceObject_swigregister
BasisSequenceImplementationTypedCollectionInterfaceObject_swigregister(BasisSequenceImplementationTypedCollectionInterfaceObject)

class BasisSequence(BasisSequenceImplementationTypedCollectionInterfaceObject):
    """Proxy of C++ OT::BasisSequence class"""
    __swig_setmethods__ = {}
    for _s in [BasisSequenceImplementationTypedCollectionInterfaceObject]: __swig_setmethods__.update(getattr(_s,'__swig_setmethods__',{}))
    __setattr__ = lambda self, name, value: _swig_setattr(self, BasisSequence, name, value)
    __swig_getmethods__ = {}
    for _s in [BasisSequenceImplementationTypedCollectionInterfaceObject]: __swig_getmethods__.update(getattr(_s,'__swig_getmethods__',{}))
    __getattr__ = lambda self, name: _swig_getattr(self, BasisSequence, name)
    def GetClassName():
        """GetClassName() -> OT::String"""
        return _func.BasisSequence_GetClassName()

    if _newclass:GetClassName = staticmethod(GetClassName)
    __swig_getmethods__["GetClassName"] = lambda x: GetClassName
    def getClassName(self):
        """getClassName(BasisSequence self) -> OT::String"""
        return _func.BasisSequence_getClassName(self)

    def getDimension(self):
        """getDimension(BasisSequence self) -> OT::UnsignedLong"""
        return _func.BasisSequence_getDimension(self)

    def getMasterBasis(self):
        """getMasterBasis(BasisSequence self) -> Basis"""
        return _func.BasisSequence_getMasterBasis(self)

    def getBasis(self, *args):
        """getBasis(BasisSequence self, OT::UnsignedLong const index) -> Basis"""
        return _func.BasisSequence_getBasis(self, *args)

    def getIndices(self, *args):
        """getIndices(BasisSequence self, OT::UnsignedLong const index) -> Indices"""
        return _func.BasisSequence_getIndices(self, *args)

    def __repr__(self):
        """__repr__(BasisSequence self) -> OT::String"""
        return _func.BasisSequence___repr__(self)

    def __str__(self, offset=""):
        """
        __str__(BasisSequence self, OT::String const & offset="") -> OT::String
        __str__(BasisSequence self) -> OT::String
        """
        return _func.BasisSequence___str__(self, offset)

    def __init__(self, *args): 
        """
        __init__(OT::BasisSequence self) -> BasisSequence
        __init__(OT::BasisSequence self, Basis psi) -> BasisSequence
        __init__(OT::BasisSequence self, BasisSequenceImplementation implementation) -> BasisSequence
        __init__(OT::BasisSequence self, BasisSequence other) -> BasisSequence
        """
        this = _func.new_BasisSequence(*args)
        try: self.this.append(this)
        except: self.this = this
    __swig_destroy__ = _func.delete_BasisSequence
    __del__ = lambda self : None;
BasisSequence_swigregister = _func.BasisSequence_swigregister
BasisSequence_swigregister(BasisSequence)

def BasisSequence_GetClassName():
  """BasisSequence_GetClassName() -> OT::String"""
  return _func.BasisSequence_GetClassName()

class BasisSequenceFactoryImplementation(openturns.common.PersistentObject):
    """Proxy of C++ OT::BasisSequenceFactoryImplementation class"""
    __swig_setmethods__ = {}
    for _s in [openturns.common.PersistentObject]: __swig_setmethods__.update(getattr(_s,'__swig_setmethods__',{}))
    __setattr__ = lambda self, name, value: _swig_setattr(self, BasisSequenceFactoryImplementation, name, value)
    __swig_getmethods__ = {}
    for _s in [openturns.common.PersistentObject]: __swig_getmethods__.update(getattr(_s,'__swig_getmethods__',{}))
    __getattr__ = lambda self, name: _swig_getattr(self, BasisSequenceFactoryImplementation, name)
    def __init__(self, *args, **kwargs): raise AttributeError("No constructor defined - class is abstract")
    def GetClassName():
        """GetClassName() -> OT::String"""
        return _func.BasisSequenceFactoryImplementation_GetClassName()

    if _newclass:GetClassName = staticmethod(GetClassName)
    __swig_getmethods__["GetClassName"] = lambda x: GetClassName
    def getClassName(self):
        """getClassName(BasisSequenceFactoryImplementation self) -> OT::String"""
        return _func.BasisSequenceFactoryImplementation_getClassName(self)

    def setVerbose(self, *args):
        """setVerbose(BasisSequenceFactoryImplementation self, OT::Bool const verbose)"""
        return _func.BasisSequenceFactoryImplementation_setVerbose(self, *args)

    def getVerbose(self):
        """getVerbose(BasisSequenceFactoryImplementation self) -> OT::Bool"""
        return _func.BasisSequenceFactoryImplementation_getVerbose(self)

    def build(self, *args):
        """build(BasisSequenceFactoryImplementation self, NumericalSample x, NumericalSample y, Basis psi) -> BasisSequence"""
        return _func.BasisSequenceFactoryImplementation_build(self, *args)

    def setMaximumRelativeConvergence(self, *args):
        """setMaximumRelativeConvergence(BasisSequenceFactoryImplementation self, OT::NumericalScalar const coefficientsPaths)"""
        return _func.BasisSequenceFactoryImplementation_setMaximumRelativeConvergence(self, *args)

    def getMaximumRelativeConvergence(self):
        """getMaximumRelativeConvergence(BasisSequenceFactoryImplementation self) -> OT::NumericalScalar"""
        return _func.BasisSequenceFactoryImplementation_getMaximumRelativeConvergence(self)

    def __repr__(self):
        """__repr__(BasisSequenceFactoryImplementation self) -> OT::String"""
        return _func.BasisSequenceFactoryImplementation___repr__(self)

    def __str__(self, offset=""):
        """
        __str__(BasisSequenceFactoryImplementation self, OT::String const & offset="") -> OT::String
        __str__(BasisSequenceFactoryImplementation self) -> OT::String
        """
        return _func.BasisSequenceFactoryImplementation___str__(self, offset)

    __swig_destroy__ = _func.delete_BasisSequenceFactoryImplementation
    __del__ = lambda self : None;
BasisSequenceFactoryImplementation_swigregister = _func.BasisSequenceFactoryImplementation_swigregister
BasisSequenceFactoryImplementation_swigregister(BasisSequenceFactoryImplementation)

def BasisSequenceFactoryImplementation_GetClassName():
  """BasisSequenceFactoryImplementation_GetClassName() -> OT::String"""
  return _func.BasisSequenceFactoryImplementation_GetClassName()

class BasisSequenceFactoryImplementationTypedInterfaceObject(openturns.common.InterfaceObject):
    """Proxy of C++ OT::TypedInterfaceObject<(OT::BasisSequenceFactoryImplementation)> class"""
    __swig_setmethods__ = {}
    for _s in [openturns.common.InterfaceObject]: __swig_setmethods__.update(getattr(_s,'__swig_setmethods__',{}))
    __setattr__ = lambda self, name, value: _swig_setattr(self, BasisSequenceFactoryImplementationTypedInterfaceObject, name, value)
    __swig_getmethods__ = {}
    for _s in [openturns.common.InterfaceObject]: __swig_getmethods__.update(getattr(_s,'__swig_getmethods__',{}))
    __getattr__ = lambda self, name: _swig_getattr(self, BasisSequenceFactoryImplementationTypedInterfaceObject, name)
    __repr__ = _swig_repr
    def __init__(self, *args): 
        """
        __init__(OT::TypedInterfaceObject<(OT::BasisSequenceFactoryImplementation)> self) -> BasisSequenceFactoryImplementationTypedInterfaceObject
        __init__(OT::TypedInterfaceObject<(OT::BasisSequenceFactoryImplementation)> self, OT::TypedInterfaceObject< OT::BasisSequenceFactoryImplementation >::Implementation const & impl) -> BasisSequenceFactoryImplementationTypedInterfaceObject
        """
        this = _func.new_BasisSequenceFactoryImplementationTypedInterfaceObject(*args)
        try: self.this.append(this)
        except: self.this = this
    def getImplementation(self, *args):
        """
        getImplementation(BasisSequenceFactoryImplementationTypedInterfaceObject self) -> OT::TypedInterfaceObject< OT::BasisSequenceFactoryImplementation >::Implementation
        getImplementation(BasisSequenceFactoryImplementationTypedInterfaceObject self) -> OT::TypedInterfaceObject< OT::BasisSequenceFactoryImplementation >::Implementation const &
        """
        return _func.BasisSequenceFactoryImplementationTypedInterfaceObject_getImplementation(self, *args)

    def getImplementationAsPersistentObject(self):
        """getImplementationAsPersistentObject(BasisSequenceFactoryImplementationTypedInterfaceObject self) -> PersistentObjectPointer"""
        return _func.BasisSequenceFactoryImplementationTypedInterfaceObject_getImplementationAsPersistentObject(self)

    def setImplementationAsPersistentObject(self, *args):
        """setImplementationAsPersistentObject(BasisSequenceFactoryImplementationTypedInterfaceObject self, PersistentObjectPointer obj)"""
        return _func.BasisSequenceFactoryImplementationTypedInterfaceObject_setImplementationAsPersistentObject(self, *args)

    def swap(self, *args):
        """swap(BasisSequenceFactoryImplementationTypedInterfaceObject self, BasisSequenceFactoryImplementationTypedInterfaceObject other)"""
        return _func.BasisSequenceFactoryImplementationTypedInterfaceObject_swap(self, *args)

    def setName(self, *args):
        """setName(BasisSequenceFactoryImplementationTypedInterfaceObject self, OT::String const & name)"""
        return _func.BasisSequenceFactoryImplementationTypedInterfaceObject_setName(self, *args)

    def getName(self):
        """getName(BasisSequenceFactoryImplementationTypedInterfaceObject self) -> OT::String"""
        return _func.BasisSequenceFactoryImplementationTypedInterfaceObject_getName(self)

    def __eq__(self, *args):
        """__eq__(BasisSequenceFactoryImplementationTypedInterfaceObject self, BasisSequenceFactoryImplementationTypedInterfaceObject other) -> OT::Bool"""
        return _func.BasisSequenceFactoryImplementationTypedInterfaceObject___eq__(self, *args)

    __swig_destroy__ = _func.delete_BasisSequenceFactoryImplementationTypedInterfaceObject
    __del__ = lambda self : None;
BasisSequenceFactoryImplementationTypedInterfaceObject_swigregister = _func.BasisSequenceFactoryImplementationTypedInterfaceObject_swigregister
BasisSequenceFactoryImplementationTypedInterfaceObject_swigregister(BasisSequenceFactoryImplementationTypedInterfaceObject)

class BasisSequenceFactory(BasisSequenceFactoryImplementationTypedInterfaceObject):
    """Proxy of C++ OT::BasisSequenceFactory class"""
    __swig_setmethods__ = {}
    for _s in [BasisSequenceFactoryImplementationTypedInterfaceObject]: __swig_setmethods__.update(getattr(_s,'__swig_setmethods__',{}))
    __setattr__ = lambda self, name, value: _swig_setattr(self, BasisSequenceFactory, name, value)
    __swig_getmethods__ = {}
    for _s in [BasisSequenceFactoryImplementationTypedInterfaceObject]: __swig_getmethods__.update(getattr(_s,'__swig_getmethods__',{}))
    __getattr__ = lambda self, name: _swig_getattr(self, BasisSequenceFactory, name)
    def GetClassName():
        """GetClassName() -> OT::String"""
        return _func.BasisSequenceFactory_GetClassName()

    if _newclass:GetClassName = staticmethod(GetClassName)
    __swig_getmethods__["GetClassName"] = lambda x: GetClassName
    def getClassName(self):
        """getClassName(BasisSequenceFactory self) -> OT::String"""
        return _func.BasisSequenceFactory_getClassName(self)

    def __repr__(self):
        """__repr__(BasisSequenceFactory self) -> OT::String"""
        return _func.BasisSequenceFactory___repr__(self)

    def __str__(self, offset=""):
        """
        __str__(BasisSequenceFactory self, OT::String const & offset="") -> OT::String
        __str__(BasisSequenceFactory self) -> OT::String
        """
        return _func.BasisSequenceFactory___str__(self, offset)

    def setVerbose(self, *args):
        """setVerbose(BasisSequenceFactory self, OT::Bool const verbose)"""
        return _func.BasisSequenceFactory_setVerbose(self, *args)

    def getVerbose(self):
        """getVerbose(BasisSequenceFactory self) -> OT::Bool"""
        return _func.BasisSequenceFactory_getVerbose(self)

    def build(self, *args):
        """build(BasisSequenceFactory self, NumericalSample x, NumericalSample y, Basis psi) -> BasisSequence"""
        return _func.BasisSequenceFactory_build(self, *args)

    def setMaximumRelativeConvergence(self, *args):
        """setMaximumRelativeConvergence(BasisSequenceFactory self, OT::NumericalScalar const coefficientsPaths)"""
        return _func.BasisSequenceFactory_setMaximumRelativeConvergence(self, *args)

    def getMaximumRelativeConvergence(self):
        """getMaximumRelativeConvergence(BasisSequenceFactory self) -> OT::NumericalScalar"""
        return _func.BasisSequenceFactory_getMaximumRelativeConvergence(self)

    def __init__(self, *args): 
        """
        __init__(OT::BasisSequenceFactory self) -> BasisSequenceFactory
        __init__(OT::BasisSequenceFactory self, BasisSequenceFactoryImplementation implementation) -> BasisSequenceFactory
        __init__(OT::BasisSequenceFactory self, BasisSequenceFactory other) -> BasisSequenceFactory
        """
        this = _func.new_BasisSequenceFactory(*args)
        try: self.this.append(this)
        except: self.this = this
    __swig_destroy__ = _func.delete_BasisSequenceFactory
    __del__ = lambda self : None;
BasisSequenceFactory_swigregister = _func.BasisSequenceFactory_swigregister
BasisSequenceFactory_swigregister(BasisSequenceFactory)

def BasisSequenceFactory_GetClassName():
  """BasisSequenceFactory_GetClassName() -> OT::String"""
  return _func.BasisSequenceFactory_GetClassName()

class LAR(BasisSequenceFactoryImplementation):
    """Proxy of C++ OT::LAR class"""
    __swig_setmethods__ = {}
    for _s in [BasisSequenceFactoryImplementation]: __swig_setmethods__.update(getattr(_s,'__swig_setmethods__',{}))
    __setattr__ = lambda self, name, value: _swig_setattr(self, LAR, name, value)
    __swig_getmethods__ = {}
    for _s in [BasisSequenceFactoryImplementation]: __swig_getmethods__.update(getattr(_s,'__swig_getmethods__',{}))
    __getattr__ = lambda self, name: _swig_getattr(self, LAR, name)
    def GetClassName():
        """GetClassName() -> OT::String"""
        return _func.LAR_GetClassName()

    if _newclass:GetClassName = staticmethod(GetClassName)
    __swig_getmethods__["GetClassName"] = lambda x: GetClassName
    def getClassName(self):
        """getClassName(LAR self) -> OT::String"""
        return _func.LAR_getClassName(self)

    def build(self, *args):
        """build(LAR self, NumericalSample x, NumericalSample y, Basis psi) -> BasisSequence"""
        return _func.LAR_build(self, *args)

    def __repr__(self):
        """__repr__(LAR self) -> OT::String"""
        return _func.LAR___repr__(self)

    def __str__(self, offset=""):
        """
        __str__(LAR self, OT::String const & offset="") -> OT::String
        __str__(LAR self) -> OT::String
        """
        return _func.LAR___str__(self, offset)

    def __init__(self, *args): 
        """
        __init__(OT::LAR self, OT::Bool const verbose=False) -> LAR
        __init__(OT::LAR self) -> LAR
        __init__(OT::LAR self, LAR other) -> LAR
        """
        this = _func.new_LAR(*args)
        try: self.this.append(this)
        except: self.this = this
    __swig_destroy__ = _func.delete_LAR
    __del__ = lambda self : None;
LAR_swigregister = _func.LAR_swigregister
LAR_swigregister(LAR)

def LAR_GetClassName():
  """LAR_GetClassName() -> OT::String"""
  return _func.LAR_GetClassName()

class BoxCoxEvaluationImplementation(NumericalMathEvaluationImplementation):
    """Proxy of C++ OT::BoxCoxEvaluationImplementation class"""
    __swig_setmethods__ = {}
    for _s in [NumericalMathEvaluationImplementation]: __swig_setmethods__.update(getattr(_s,'__swig_setmethods__',{}))
    __setattr__ = lambda self, name, value: _swig_setattr(self, BoxCoxEvaluationImplementation, name, value)
    __swig_getmethods__ = {}
    for _s in [NumericalMathEvaluationImplementation]: __swig_getmethods__.update(getattr(_s,'__swig_getmethods__',{}))
    __getattr__ = lambda self, name: _swig_getattr(self, BoxCoxEvaluationImplementation, name)
    def GetClassName():
        """GetClassName() -> OT::String"""
        return _func.BoxCoxEvaluationImplementation_GetClassName()

    if _newclass:GetClassName = staticmethod(GetClassName)
    __swig_getmethods__["GetClassName"] = lambda x: GetClassName
    def getClassName(self):
        """getClassName(BoxCoxEvaluationImplementation self) -> OT::String"""
        return _func.BoxCoxEvaluationImplementation_getClassName(self)

    def __eq__(self, *args):
        """__eq__(BoxCoxEvaluationImplementation self, BoxCoxEvaluationImplementation other) -> OT::Bool"""
        return _func.BoxCoxEvaluationImplementation___eq__(self, *args)

    def __repr__(self):
        """__repr__(BoxCoxEvaluationImplementation self) -> OT::String"""
        return _func.BoxCoxEvaluationImplementation___repr__(self)

    def __str__(self, offset=""):
        """
        __str__(BoxCoxEvaluationImplementation self, OT::String const & offset="") -> OT::String
        __str__(BoxCoxEvaluationImplementation self) -> OT::String
        """
        return _func.BoxCoxEvaluationImplementation___str__(self, offset)

    def __call__(self, *args):
        """
        __call__(BoxCoxEvaluationImplementation self, NumericalPoint inP) -> NumericalPoint
        __call__(BoxCoxEvaluationImplementation self, NumericalSample inSample) -> NumericalSample
        __call__(BoxCoxEvaluationImplementation self, TimeSeries inTimeSeries) -> TimeSeries
        __call__(BoxCoxEvaluationImplementation self, NumericalPoint inP) -> NumericalPoint
        """
        return _func.BoxCoxEvaluationImplementation___call__(self, *args)

    def getInputDimension(self):
        """getInputDimension(BoxCoxEvaluationImplementation self) -> OT::UnsignedLong"""
        return _func.BoxCoxEvaluationImplementation_getInputDimension(self)

    def getOutputDimension(self):
        """getOutputDimension(BoxCoxEvaluationImplementation self) -> OT::UnsignedLong"""
        return _func.BoxCoxEvaluationImplementation_getOutputDimension(self)

    def getLambda(self):
        """getLambda(BoxCoxEvaluationImplementation self) -> NumericalPoint"""
        return _func.BoxCoxEvaluationImplementation_getLambda(self)

    def getShift(self):
        """getShift(BoxCoxEvaluationImplementation self) -> NumericalPoint"""
        return _func.BoxCoxEvaluationImplementation_getShift(self)

    def __init__(self, *args): 
        """
        __init__(OT::BoxCoxEvaluationImplementation self) -> BoxCoxEvaluationImplementation
        __init__(OT::BoxCoxEvaluationImplementation self, NumericalPoint lamda) -> BoxCoxEvaluationImplementation
        __init__(OT::BoxCoxEvaluationImplementation self, NumericalPoint lamda, NumericalPoint shift) -> BoxCoxEvaluationImplementation
        __init__(OT::BoxCoxEvaluationImplementation self, BoxCoxEvaluationImplementation other) -> BoxCoxEvaluationImplementation
        """
        this = _func.new_BoxCoxEvaluationImplementation(*args)
        try: self.this.append(this)
        except: self.this = this
    __swig_destroy__ = _func.delete_BoxCoxEvaluationImplementation
    __del__ = lambda self : None;
BoxCoxEvaluationImplementation_swigregister = _func.BoxCoxEvaluationImplementation_swigregister
BoxCoxEvaluationImplementation_swigregister(BoxCoxEvaluationImplementation)

def BoxCoxEvaluationImplementation_GetClassName():
  """BoxCoxEvaluationImplementation_GetClassName() -> OT::String"""
  return _func.BoxCoxEvaluationImplementation_GetClassName()

class BoxCoxTransform(NumericalMathFunction):
    """Proxy of C++ OT::BoxCoxTransform class"""
    __swig_setmethods__ = {}
    for _s in [NumericalMathFunction]: __swig_setmethods__.update(getattr(_s,'__swig_setmethods__',{}))
    __setattr__ = lambda self, name, value: _swig_setattr(self, BoxCoxTransform, name, value)
    __swig_getmethods__ = {}
    for _s in [NumericalMathFunction]: __swig_getmethods__.update(getattr(_s,'__swig_getmethods__',{}))
    __getattr__ = lambda self, name: _swig_getattr(self, BoxCoxTransform, name)
    __repr__ = _swig_repr
    def GetClassName():
        """GetClassName() -> OT::String"""
        return _func.BoxCoxTransform_GetClassName()

    if _newclass:GetClassName = staticmethod(GetClassName)
    __swig_getmethods__["GetClassName"] = lambda x: GetClassName
    def getClassName(self):
        """getClassName(BoxCoxTransform self) -> OT::String"""
        return _func.BoxCoxTransform_getClassName(self)

    def getLambda(self):
        """getLambda(BoxCoxTransform self) -> NumericalPoint"""
        return _func.BoxCoxTransform_getLambda(self)

    def getShift(self):
        """getShift(BoxCoxTransform self) -> NumericalPoint"""
        return _func.BoxCoxTransform_getShift(self)

    def getInverse(self):
        """getInverse(BoxCoxTransform self) -> InverseBoxCoxTransform"""
        return _func.BoxCoxTransform_getInverse(self)

    def __init__(self, *args): 
        """
        __init__(OT::BoxCoxTransform self) -> BoxCoxTransform
        __init__(OT::BoxCoxTransform self, NumericalPoint _lambda) -> BoxCoxTransform
        __init__(OT::BoxCoxTransform self, NumericalPoint _lambda, NumericalPoint shift) -> BoxCoxTransform
        __init__(OT::BoxCoxTransform self, OT::NumericalScalar const & _lambda) -> BoxCoxTransform
        __init__(OT::BoxCoxTransform self, OT::NumericalScalar const & _lambda, OT::NumericalScalar const & shift) -> BoxCoxTransform
        __init__(OT::BoxCoxTransform self, BoxCoxTransform other) -> BoxCoxTransform
        """
        this = _func.new_BoxCoxTransform(*args)
        try: self.this.append(this)
        except: self.this = this
    __swig_destroy__ = _func.delete_BoxCoxTransform
    __del__ = lambda self : None;
BoxCoxTransform_swigregister = _func.BoxCoxTransform_swigregister
BoxCoxTransform_swigregister(BoxCoxTransform)

def BoxCoxTransform_GetClassName():
  """BoxCoxTransform_GetClassName() -> OT::String"""
  return _func.BoxCoxTransform_GetClassName()

class InverseBoxCoxEvaluationImplementation(NumericalMathEvaluationImplementation):
    """Proxy of C++ OT::InverseBoxCoxEvaluationImplementation class"""
    __swig_setmethods__ = {}
    for _s in [NumericalMathEvaluationImplementation]: __swig_setmethods__.update(getattr(_s,'__swig_setmethods__',{}))
    __setattr__ = lambda self, name, value: _swig_setattr(self, InverseBoxCoxEvaluationImplementation, name, value)
    __swig_getmethods__ = {}
    for _s in [NumericalMathEvaluationImplementation]: __swig_getmethods__.update(getattr(_s,'__swig_getmethods__',{}))
    __getattr__ = lambda self, name: _swig_getattr(self, InverseBoxCoxEvaluationImplementation, name)
    def GetClassName():
        """GetClassName() -> OT::String"""
        return _func.InverseBoxCoxEvaluationImplementation_GetClassName()

    if _newclass:GetClassName = staticmethod(GetClassName)
    __swig_getmethods__["GetClassName"] = lambda x: GetClassName
    def getClassName(self):
        """getClassName(InverseBoxCoxEvaluationImplementation self) -> OT::String"""
        return _func.InverseBoxCoxEvaluationImplementation_getClassName(self)

    def __eq__(self, *args):
        """__eq__(InverseBoxCoxEvaluationImplementation self, InverseBoxCoxEvaluationImplementation other) -> OT::Bool"""
        return _func.InverseBoxCoxEvaluationImplementation___eq__(self, *args)

    def __repr__(self):
        """__repr__(InverseBoxCoxEvaluationImplementation self) -> OT::String"""
        return _func.InverseBoxCoxEvaluationImplementation___repr__(self)

    def __str__(self, offset=""):
        """
        __str__(InverseBoxCoxEvaluationImplementation self, OT::String const & offset="") -> OT::String
        __str__(InverseBoxCoxEvaluationImplementation self) -> OT::String
        """
        return _func.InverseBoxCoxEvaluationImplementation___str__(self, offset)

    def __call__(self, *args):
        """
        __call__(InverseBoxCoxEvaluationImplementation self, NumericalPoint inP) -> NumericalPoint
        __call__(InverseBoxCoxEvaluationImplementation self, NumericalSample inSample) -> NumericalSample
        __call__(InverseBoxCoxEvaluationImplementation self, TimeSeries inTimeSeries) -> TimeSeries
        __call__(InverseBoxCoxEvaluationImplementation self, NumericalPoint inP) -> NumericalPoint
        """
        return _func.InverseBoxCoxEvaluationImplementation___call__(self, *args)

    def getInputDimension(self):
        """getInputDimension(InverseBoxCoxEvaluationImplementation self) -> OT::UnsignedLong"""
        return _func.InverseBoxCoxEvaluationImplementation_getInputDimension(self)

    def getOutputDimension(self):
        """getOutputDimension(InverseBoxCoxEvaluationImplementation self) -> OT::UnsignedLong"""
        return _func.InverseBoxCoxEvaluationImplementation_getOutputDimension(self)

    def getLambda(self):
        """getLambda(InverseBoxCoxEvaluationImplementation self) -> NumericalPoint"""
        return _func.InverseBoxCoxEvaluationImplementation_getLambda(self)

    def getShift(self):
        """getShift(InverseBoxCoxEvaluationImplementation self) -> NumericalPoint"""
        return _func.InverseBoxCoxEvaluationImplementation_getShift(self)

    def __init__(self, *args): 
        """
        __init__(OT::InverseBoxCoxEvaluationImplementation self) -> InverseBoxCoxEvaluationImplementation
        __init__(OT::InverseBoxCoxEvaluationImplementation self, NumericalPoint lamda) -> InverseBoxCoxEvaluationImplementation
        __init__(OT::InverseBoxCoxEvaluationImplementation self, NumericalPoint lamda, NumericalPoint shift) -> InverseBoxCoxEvaluationImplementation
        __init__(OT::InverseBoxCoxEvaluationImplementation self, InverseBoxCoxEvaluationImplementation other) -> InverseBoxCoxEvaluationImplementation
        """
        this = _func.new_InverseBoxCoxEvaluationImplementation(*args)
        try: self.this.append(this)
        except: self.this = this
    __swig_destroy__ = _func.delete_InverseBoxCoxEvaluationImplementation
    __del__ = lambda self : None;
InverseBoxCoxEvaluationImplementation_swigregister = _func.InverseBoxCoxEvaluationImplementation_swigregister
InverseBoxCoxEvaluationImplementation_swigregister(InverseBoxCoxEvaluationImplementation)

def InverseBoxCoxEvaluationImplementation_GetClassName():
  """InverseBoxCoxEvaluationImplementation_GetClassName() -> OT::String"""
  return _func.InverseBoxCoxEvaluationImplementation_GetClassName()

class InverseBoxCoxTransform(NumericalMathFunction):
    """Proxy of C++ OT::InverseBoxCoxTransform class"""
    __swig_setmethods__ = {}
    for _s in [NumericalMathFunction]: __swig_setmethods__.update(getattr(_s,'__swig_setmethods__',{}))
    __setattr__ = lambda self, name, value: _swig_setattr(self, InverseBoxCoxTransform, name, value)
    __swig_getmethods__ = {}
    for _s in [NumericalMathFunction]: __swig_getmethods__.update(getattr(_s,'__swig_getmethods__',{}))
    __getattr__ = lambda self, name: _swig_getattr(self, InverseBoxCoxTransform, name)
    __repr__ = _swig_repr
    def GetClassName():
        """GetClassName() -> OT::String"""
        return _func.InverseBoxCoxTransform_GetClassName()

    if _newclass:GetClassName = staticmethod(GetClassName)
    __swig_getmethods__["GetClassName"] = lambda x: GetClassName
    def getClassName(self):
        """getClassName(InverseBoxCoxTransform self) -> OT::String"""
        return _func.InverseBoxCoxTransform_getClassName(self)

    def getLambda(self):
        """getLambda(InverseBoxCoxTransform self) -> NumericalPoint"""
        return _func.InverseBoxCoxTransform_getLambda(self)

    def getShift(self):
        """getShift(InverseBoxCoxTransform self) -> NumericalPoint"""
        return _func.InverseBoxCoxTransform_getShift(self)

    def getInverse(self):
        """getInverse(InverseBoxCoxTransform self) -> BoxCoxTransform"""
        return _func.InverseBoxCoxTransform_getInverse(self)

    def __init__(self, *args): 
        """
        __init__(OT::InverseBoxCoxTransform self) -> InverseBoxCoxTransform
        __init__(OT::InverseBoxCoxTransform self, NumericalPoint _lambda) -> InverseBoxCoxTransform
        __init__(OT::InverseBoxCoxTransform self, NumericalPoint _lambda, NumericalPoint shift) -> InverseBoxCoxTransform
        __init__(OT::InverseBoxCoxTransform self, OT::NumericalScalar const & _lambda) -> InverseBoxCoxTransform
        __init__(OT::InverseBoxCoxTransform self, OT::NumericalScalar const & _lambda, OT::NumericalScalar const & shift) -> InverseBoxCoxTransform
        __init__(OT::InverseBoxCoxTransform self, InverseBoxCoxTransform other) -> InverseBoxCoxTransform
        """
        this = _func.new_InverseBoxCoxTransform(*args)
        try: self.this.append(this)
        except: self.this = this
    __swig_destroy__ = _func.delete_InverseBoxCoxTransform
    __del__ = lambda self : None;
InverseBoxCoxTransform_swigregister = _func.InverseBoxCoxTransform_swigregister
InverseBoxCoxTransform_swigregister(InverseBoxCoxTransform)

def InverseBoxCoxTransform_GetClassName():
  """InverseBoxCoxTransform_GetClassName() -> OT::String"""
  return _func.InverseBoxCoxTransform_GetClassName()

class TrendEvaluationImplementation(NumericalMathEvaluationImplementation):
    """Proxy of C++ OT::TrendEvaluationImplementation class"""
    __swig_setmethods__ = {}
    for _s in [NumericalMathEvaluationImplementation]: __swig_setmethods__.update(getattr(_s,'__swig_setmethods__',{}))
    __setattr__ = lambda self, name, value: _swig_setattr(self, TrendEvaluationImplementation, name, value)
    __swig_getmethods__ = {}
    for _s in [NumericalMathEvaluationImplementation]: __swig_getmethods__.update(getattr(_s,'__swig_getmethods__',{}))
    __getattr__ = lambda self, name: _swig_getattr(self, TrendEvaluationImplementation, name)
    def GetClassName():
        """GetClassName() -> OT::String"""
        return _func.TrendEvaluationImplementation_GetClassName()

    if _newclass:GetClassName = staticmethod(GetClassName)
    __swig_getmethods__["GetClassName"] = lambda x: GetClassName
    def getClassName(self):
        """getClassName(TrendEvaluationImplementation self) -> OT::String"""
        return _func.TrendEvaluationImplementation_getClassName(self)

    def __eq__(self, *args):
        """__eq__(TrendEvaluationImplementation self, TrendEvaluationImplementation other) -> OT::Bool"""
        return _func.TrendEvaluationImplementation___eq__(self, *args)

    def __repr__(self):
        """__repr__(TrendEvaluationImplementation self) -> OT::String"""
        return _func.TrendEvaluationImplementation___repr__(self)

    def __str__(self, offset=""):
        """
        __str__(TrendEvaluationImplementation self, OT::String const & offset="") -> OT::String
        __str__(TrendEvaluationImplementation self) -> OT::String
        """
        return _func.TrendEvaluationImplementation___str__(self, offset)

    def __call__(self, *args):
        """
        __call__(TrendEvaluationImplementation self, NumericalPoint inP) -> NumericalPoint
        __call__(TrendEvaluationImplementation self, NumericalSample inSample) -> NumericalSample
        __call__(TrendEvaluationImplementation self, TimeSeries inTimeSeries) -> TimeSeries
        __call__(TrendEvaluationImplementation self, NumericalPoint inP) -> NumericalPoint
        """
        return _func.TrendEvaluationImplementation___call__(self, *args)

    def getInputDimension(self):
        """getInputDimension(TrendEvaluationImplementation self) -> OT::UnsignedLong"""
        return _func.TrendEvaluationImplementation_getInputDimension(self)

    def getOutputDimension(self):
        """getOutputDimension(TrendEvaluationImplementation self) -> OT::UnsignedLong"""
        return _func.TrendEvaluationImplementation_getOutputDimension(self)

    def getFunction(self):
        """getFunction(TrendEvaluationImplementation self) -> NumericalMathFunction"""
        return _func.TrendEvaluationImplementation_getFunction(self)

    def __init__(self, *args): 
        """
        __init__(OT::TrendEvaluationImplementation self) -> TrendEvaluationImplementation
        __init__(OT::TrendEvaluationImplementation self, NumericalMathFunction function) -> TrendEvaluationImplementation
        __init__(OT::TrendEvaluationImplementation self, TrendEvaluationImplementation other) -> TrendEvaluationImplementation
        """
        this = _func.new_TrendEvaluationImplementation(*args)
        try: self.this.append(this)
        except: self.this = this
    __swig_destroy__ = _func.delete_TrendEvaluationImplementation
    __del__ = lambda self : None;
TrendEvaluationImplementation_swigregister = _func.TrendEvaluationImplementation_swigregister
TrendEvaluationImplementation_swigregister(TrendEvaluationImplementation)

def TrendEvaluationImplementation_GetClassName():
  """TrendEvaluationImplementation_GetClassName() -> OT::String"""
  return _func.TrendEvaluationImplementation_GetClassName()

class TrendTransform(TemporalFunction):
    """Proxy of C++ OT::TrendTransform class"""
    __swig_setmethods__ = {}
    for _s in [TemporalFunction]: __swig_setmethods__.update(getattr(_s,'__swig_setmethods__',{}))
    __setattr__ = lambda self, name, value: _swig_setattr(self, TrendTransform, name, value)
    __swig_getmethods__ = {}
    for _s in [TemporalFunction]: __swig_getmethods__.update(getattr(_s,'__swig_getmethods__',{}))
    __getattr__ = lambda self, name: _swig_getattr(self, TrendTransform, name)
    def GetClassName():
        """GetClassName() -> OT::String"""
        return _func.TrendTransform_GetClassName()

    if _newclass:GetClassName = staticmethod(GetClassName)
    __swig_getmethods__["GetClassName"] = lambda x: GetClassName
    def getClassName(self):
        """getClassName(TrendTransform self) -> OT::String"""
        return _func.TrendTransform_getClassName(self)

    def __eq__(self, *args):
        """__eq__(TrendTransform self, TrendTransform other) -> OT::Bool"""
        return _func.TrendTransform___eq__(self, *args)

    def __repr__(self):
        """__repr__(TrendTransform self) -> OT::String"""
        return _func.TrendTransform___repr__(self)

    def __str__(self, offset=""):
        """
        __str__(TrendTransform self, OT::String const & offset="") -> OT::String
        __str__(TrendTransform self) -> OT::String
        """
        return _func.TrendTransform___str__(self, offset)

    def __call__(self, *args):
        """
        __call__(TrendTransform self, TimeSeries inTS) -> TimeSeries
        __call__(TrendTransform self, TimeSeries inTS) -> TimeSeries
        """
        return _func.TrendTransform___call__(self, *args)

    def getInverse(self):
        """getInverse(TrendTransform self) -> InverseTrendTransform"""
        return _func.TrendTransform_getInverse(self)

    def __init__(self, *args): 
        """
        __init__(OT::TrendTransform self) -> TrendTransform
        __init__(OT::TrendTransform self, NumericalMathFunction function) -> TrendTransform
        __init__(OT::TrendTransform self, EvaluationImplementation p_evaluation) -> TrendTransform
        __init__(OT::TrendTransform self, NumericalMathEvaluationImplementation evaluation) -> TrendTransform
        __init__(OT::TrendTransform self, TrendTransform other) -> TrendTransform
        """
        this = _func.new_TrendTransform(*args)
        try: self.this.append(this)
        except: self.this = this
    __swig_destroy__ = _func.delete_TrendTransform
    __del__ = lambda self : None;
TrendTransform_swigregister = _func.TrendTransform_swigregister
TrendTransform_swigregister(TrendTransform)

def TrendTransform_GetClassName():
  """TrendTransform_GetClassName() -> OT::String"""
  return _func.TrendTransform_GetClassName()

class InverseTrendEvaluationImplementation(NumericalMathEvaluationImplementation):
    """Proxy of C++ OT::InverseTrendEvaluationImplementation class"""
    __swig_setmethods__ = {}
    for _s in [NumericalMathEvaluationImplementation]: __swig_setmethods__.update(getattr(_s,'__swig_setmethods__',{}))
    __setattr__ = lambda self, name, value: _swig_setattr(self, InverseTrendEvaluationImplementation, name, value)
    __swig_getmethods__ = {}
    for _s in [NumericalMathEvaluationImplementation]: __swig_getmethods__.update(getattr(_s,'__swig_getmethods__',{}))
    __getattr__ = lambda self, name: _swig_getattr(self, InverseTrendEvaluationImplementation, name)
    def GetClassName():
        """GetClassName() -> OT::String"""
        return _func.InverseTrendEvaluationImplementation_GetClassName()

    if _newclass:GetClassName = staticmethod(GetClassName)
    __swig_getmethods__["GetClassName"] = lambda x: GetClassName
    def getClassName(self):
        """getClassName(InverseTrendEvaluationImplementation self) -> OT::String"""
        return _func.InverseTrendEvaluationImplementation_getClassName(self)

    def __eq__(self, *args):
        """__eq__(InverseTrendEvaluationImplementation self, InverseTrendEvaluationImplementation other) -> OT::Bool"""
        return _func.InverseTrendEvaluationImplementation___eq__(self, *args)

    def __repr__(self):
        """__repr__(InverseTrendEvaluationImplementation self) -> OT::String"""
        return _func.InverseTrendEvaluationImplementation___repr__(self)

    def __str__(self, offset=""):
        """
        __str__(InverseTrendEvaluationImplementation self, OT::String const & offset="") -> OT::String
        __str__(InverseTrendEvaluationImplementation self) -> OT::String
        """
        return _func.InverseTrendEvaluationImplementation___str__(self, offset)

    def __call__(self, *args):
        """
        __call__(InverseTrendEvaluationImplementation self, NumericalPoint inP) -> NumericalPoint
        __call__(InverseTrendEvaluationImplementation self, NumericalSample inSample) -> NumericalSample
        __call__(InverseTrendEvaluationImplementation self, TimeSeries inTimeSeries) -> TimeSeries
        __call__(InverseTrendEvaluationImplementation self, NumericalPoint inP) -> NumericalPoint
        """
        return _func.InverseTrendEvaluationImplementation___call__(self, *args)

    def getInputDimension(self):
        """getInputDimension(InverseTrendEvaluationImplementation self) -> OT::UnsignedLong"""
        return _func.InverseTrendEvaluationImplementation_getInputDimension(self)

    def getOutputDimension(self):
        """getOutputDimension(InverseTrendEvaluationImplementation self) -> OT::UnsignedLong"""
        return _func.InverseTrendEvaluationImplementation_getOutputDimension(self)

    def getFunction(self):
        """getFunction(InverseTrendEvaluationImplementation self) -> NumericalMathFunction"""
        return _func.InverseTrendEvaluationImplementation_getFunction(self)

    def __init__(self, *args): 
        """
        __init__(OT::InverseTrendEvaluationImplementation self) -> InverseTrendEvaluationImplementation
        __init__(OT::InverseTrendEvaluationImplementation self, NumericalMathFunction function) -> InverseTrendEvaluationImplementation
        __init__(OT::InverseTrendEvaluationImplementation self, InverseTrendEvaluationImplementation other) -> InverseTrendEvaluationImplementation
        """
        this = _func.new_InverseTrendEvaluationImplementation(*args)
        try: self.this.append(this)
        except: self.this = this
    __swig_destroy__ = _func.delete_InverseTrendEvaluationImplementation
    __del__ = lambda self : None;
InverseTrendEvaluationImplementation_swigregister = _func.InverseTrendEvaluationImplementation_swigregister
InverseTrendEvaluationImplementation_swigregister(InverseTrendEvaluationImplementation)

def InverseTrendEvaluationImplementation_GetClassName():
  """InverseTrendEvaluationImplementation_GetClassName() -> OT::String"""
  return _func.InverseTrendEvaluationImplementation_GetClassName()

class InverseTrendTransform(TemporalFunction):
    """Proxy of C++ OT::InverseTrendTransform class"""
    __swig_setmethods__ = {}
    for _s in [TemporalFunction]: __swig_setmethods__.update(getattr(_s,'__swig_setmethods__',{}))
    __setattr__ = lambda self, name, value: _swig_setattr(self, InverseTrendTransform, name, value)
    __swig_getmethods__ = {}
    for _s in [TemporalFunction]: __swig_getmethods__.update(getattr(_s,'__swig_getmethods__',{}))
    __getattr__ = lambda self, name: _swig_getattr(self, InverseTrendTransform, name)
    def GetClassName():
        """GetClassName() -> OT::String"""
        return _func.InverseTrendTransform_GetClassName()

    if _newclass:GetClassName = staticmethod(GetClassName)
    __swig_getmethods__["GetClassName"] = lambda x: GetClassName
    def getClassName(self):
        """getClassName(InverseTrendTransform self) -> OT::String"""
        return _func.InverseTrendTransform_getClassName(self)

    def getInverse(self):
        """getInverse(InverseTrendTransform self) -> TrendTransform"""
        return _func.InverseTrendTransform_getInverse(self)

    def __eq__(self, *args):
        """__eq__(InverseTrendTransform self, InverseTrendTransform other) -> OT::Bool"""
        return _func.InverseTrendTransform___eq__(self, *args)

    def __repr__(self):
        """__repr__(InverseTrendTransform self) -> OT::String"""
        return _func.InverseTrendTransform___repr__(self)

    def __str__(self, offset=""):
        """
        __str__(InverseTrendTransform self, OT::String const & offset="") -> OT::String
        __str__(InverseTrendTransform self) -> OT::String
        """
        return _func.InverseTrendTransform___str__(self, offset)

    def __call__(self, *args):
        """
        __call__(InverseTrendTransform self, TimeSeries inTS) -> TimeSeries
        __call__(InverseTrendTransform self, TimeSeries inTS) -> TimeSeries
        """
        return _func.InverseTrendTransform___call__(self, *args)

    def __init__(self, *args): 
        """
        __init__(OT::InverseTrendTransform self) -> InverseTrendTransform
        __init__(OT::InverseTrendTransform self, NumericalMathFunction function) -> InverseTrendTransform
        __init__(OT::InverseTrendTransform self, EvaluationImplementation p_evaluation) -> InverseTrendTransform
        __init__(OT::InverseTrendTransform self, NumericalMathEvaluationImplementation evaluation) -> InverseTrendTransform
        __init__(OT::InverseTrendTransform self, InverseTrendTransform other) -> InverseTrendTransform
        """
        this = _func.new_InverseTrendTransform(*args)
        try: self.this.append(this)
        except: self.this = this
    __swig_destroy__ = _func.delete_InverseTrendTransform
    __del__ = lambda self : None;
InverseTrendTransform_swigregister = _func.InverseTrendTransform_swigregister
InverseTrendTransform_swigregister(InverseTrendTransform)

def InverseTrendTransform_GetClassName():
  """InverseTrendTransform_GetClassName() -> OT::String"""
  return _func.InverseTrendTransform_GetClassName()

class NumericalMathEvaluationImplementationPointer(_object):
    """Proxy of C++ OT::Pointer<(OT::NumericalMathEvaluationImplementation)> class"""
    __swig_setmethods__ = {}
    __setattr__ = lambda self, name, value: _swig_setattr(self, NumericalMathEvaluationImplementationPointer, name, value)
    __swig_getmethods__ = {}
    __getattr__ = lambda self, name: _swig_getattr(self, NumericalMathEvaluationImplementationPointer, name)
    __swig_setmethods__["ptr_"] = _func.NumericalMathEvaluationImplementationPointer_ptr__set
    __swig_getmethods__["ptr_"] = _func.NumericalMathEvaluationImplementationPointer_ptr__get
    if _newclass:ptr_ = _swig_property(_func.NumericalMathEvaluationImplementationPointer_ptr__get, _func.NumericalMathEvaluationImplementationPointer_ptr__set)
    def __init__(self, *args): 
        """
        __init__(OT::Pointer<(OT::NumericalMathEvaluationImplementation)> self) -> NumericalMathEvaluationImplementationPointer
        __init__(OT::Pointer<(OT::NumericalMathEvaluationImplementation)> self, NumericalMathEvaluationImplementation ptr) -> NumericalMathEvaluationImplementationPointer
        """
        this = _func.new_NumericalMathEvaluationImplementationPointer(*args)
        try: self.this.append(this)
        except: self.this = this
    __swig_destroy__ = _func.delete_NumericalMathEvaluationImplementationPointer
    __del__ = lambda self : None;
    def reset(self):
        """reset(NumericalMathEvaluationImplementationPointer self)"""
        return _func.NumericalMathEvaluationImplementationPointer_reset(self)

    def __ref__(self, *args):
        """
        __ref__(NumericalMathEvaluationImplementationPointer self) -> NumericalMathEvaluationImplementation
        __ref__(NumericalMathEvaluationImplementationPointer self) -> NumericalMathEvaluationImplementation
        """
        return _func.NumericalMathEvaluationImplementationPointer___ref__(self, *args)

    def __deref__(self):
        """__deref__(NumericalMathEvaluationImplementationPointer self) -> NumericalMathEvaluationImplementation"""
        return _func.NumericalMathEvaluationImplementationPointer___deref__(self)

    def isNull(self):
        """isNull(NumericalMathEvaluationImplementationPointer self) -> OT::Bool"""
        return _func.NumericalMathEvaluationImplementationPointer_isNull(self)

    def __nonzero__(self):
        return _func.NumericalMathEvaluationImplementationPointer___nonzero__(self)
    __bool__ = __nonzero__


    def get(self):
        """get(NumericalMathEvaluationImplementationPointer self) -> NumericalMathEvaluationImplementation"""
        return _func.NumericalMathEvaluationImplementationPointer_get(self)

    def getImplementation(self):
        """getImplementation(NumericalMathEvaluationImplementationPointer self) -> OT::Pointer< OT::NumericalMathEvaluationImplementation >::pointer_type const &"""
        return _func.NumericalMathEvaluationImplementationPointer_getImplementation(self)

    def unique(self):
        """unique(NumericalMathEvaluationImplementationPointer self) -> OT::Bool"""
        return _func.NumericalMathEvaluationImplementationPointer_unique(self)

    def use_count(self):
        """use_count(NumericalMathEvaluationImplementationPointer self) -> OT::UnsignedLong"""
        return _func.NumericalMathEvaluationImplementationPointer_use_count(self)

    def swap(self, *args):
        """swap(NumericalMathEvaluationImplementationPointer self, EvaluationImplementation other)"""
        return _func.NumericalMathEvaluationImplementationPointer_swap(self, *args)

    def GetClassName(self):
        """GetClassName(NumericalMathEvaluationImplementationPointer self) -> OT::String"""
        return _func.NumericalMathEvaluationImplementationPointer_GetClassName(self)

    def getClassName(self):
        """getClassName(NumericalMathEvaluationImplementationPointer self) -> OT::String"""
        return _func.NumericalMathEvaluationImplementationPointer_getClassName(self)

    def __eq__(self, *args):
        """__eq__(NumericalMathEvaluationImplementationPointer self, NumericalMathEvaluationImplementation other) -> OT::Bool"""
        return _func.NumericalMathEvaluationImplementationPointer___eq__(self, *args)

    def __repr__(self):
        """__repr__(NumericalMathEvaluationImplementationPointer self) -> OT::String"""
        return _func.NumericalMathEvaluationImplementationPointer___repr__(self)

    def __str__(self, offset=""):
        """
        __str__(NumericalMathEvaluationImplementationPointer self, OT::String const & offset="") -> OT::String
        __str__(NumericalMathEvaluationImplementationPointer self) -> OT::String
        """
        return _func.NumericalMathEvaluationImplementationPointer___str__(self, offset)

    def setDescription(self, *args):
        """setDescription(NumericalMathEvaluationImplementationPointer self, Description description)"""
        return _func.NumericalMathEvaluationImplementationPointer_setDescription(self, *args)

    def getDescription(self):
        """getDescription(NumericalMathEvaluationImplementationPointer self) -> Description"""
        return _func.NumericalMathEvaluationImplementationPointer_getDescription(self)

    def getInputDescription(self):
        """getInputDescription(NumericalMathEvaluationImplementationPointer self) -> Description"""
        return _func.NumericalMathEvaluationImplementationPointer_getInputDescription(self)

    def setInputDescription(self, *args):
        """setInputDescription(NumericalMathEvaluationImplementationPointer self, Description inputDescription)"""
        return _func.NumericalMathEvaluationImplementationPointer_setInputDescription(self, *args)

    def getOutputDescription(self):
        """getOutputDescription(NumericalMathEvaluationImplementationPointer self) -> Description"""
        return _func.NumericalMathEvaluationImplementationPointer_getOutputDescription(self)

    def setOutputDescription(self, *args):
        """setOutputDescription(NumericalMathEvaluationImplementationPointer self, Description outputDescription)"""
        return _func.NumericalMathEvaluationImplementationPointer_setOutputDescription(self, *args)

    def enableHistory(self):
        """enableHistory(NumericalMathEvaluationImplementationPointer self)"""
        return _func.NumericalMathEvaluationImplementationPointer_enableHistory(self)

    def disableHistory(self):
        """disableHistory(NumericalMathEvaluationImplementationPointer self)"""
        return _func.NumericalMathEvaluationImplementationPointer_disableHistory(self)

    def isHistoryEnabled(self):
        """isHistoryEnabled(NumericalMathEvaluationImplementationPointer self) -> OT::Bool"""
        return _func.NumericalMathEvaluationImplementationPointer_isHistoryEnabled(self)

    def clearHistory(self):
        """clearHistory(NumericalMathEvaluationImplementationPointer self)"""
        return _func.NumericalMathEvaluationImplementationPointer_clearHistory(self)

    def getInputHistory(self):
        """getInputHistory(NumericalMathEvaluationImplementationPointer self) -> HistoryStrategy"""
        return _func.NumericalMathEvaluationImplementationPointer_getInputHistory(self)

    def getOutputHistory(self):
        """getOutputHistory(NumericalMathEvaluationImplementationPointer self) -> HistoryStrategy"""
        return _func.NumericalMathEvaluationImplementationPointer_getOutputHistory(self)

    def enableCache(self):
        """enableCache(NumericalMathEvaluationImplementationPointer self)"""
        return _func.NumericalMathEvaluationImplementationPointer_enableCache(self)

    def disableCache(self):
        """disableCache(NumericalMathEvaluationImplementationPointer self)"""
        return _func.NumericalMathEvaluationImplementationPointer_disableCache(self)

    def isCacheEnabled(self):
        """isCacheEnabled(NumericalMathEvaluationImplementationPointer self) -> OT::Bool"""
        return _func.NumericalMathEvaluationImplementationPointer_isCacheEnabled(self)

    def getCacheHits(self):
        """getCacheHits(NumericalMathEvaluationImplementationPointer self) -> OT::UnsignedLong"""
        return _func.NumericalMathEvaluationImplementationPointer_getCacheHits(self)

    def addCacheContent(self, *args):
        """addCacheContent(NumericalMathEvaluationImplementationPointer self, NumericalSample inSample, NumericalSample outSample)"""
        return _func.NumericalMathEvaluationImplementationPointer_addCacheContent(self, *args)

    def getCacheInput(self):
        """getCacheInput(NumericalMathEvaluationImplementationPointer self) -> NumericalSample"""
        return _func.NumericalMathEvaluationImplementationPointer_getCacheInput(self)

    def getCacheOutput(self):
        """getCacheOutput(NumericalMathEvaluationImplementationPointer self) -> NumericalSample"""
        return _func.NumericalMathEvaluationImplementationPointer_getCacheOutput(self)

    def clearCache(self):
        """clearCache(NumericalMathEvaluationImplementationPointer self)"""
        return _func.NumericalMathEvaluationImplementationPointer_clearCache(self)

    def isActualImplementation(self):
        """isActualImplementation(NumericalMathEvaluationImplementationPointer self) -> OT::Bool"""
        return _func.NumericalMathEvaluationImplementationPointer_isActualImplementation(self)

    def __call__(self, *args):
        """
        __call__(NumericalMathEvaluationImplementationPointer self, NumericalPoint inP) -> NumericalPoint
        __call__(NumericalMathEvaluationImplementationPointer self, NumericalSample inSample) -> NumericalSample
        __call__(NumericalMathEvaluationImplementationPointer self, TimeSeries inTimeSeries) -> TimeSeries
        """
        return _func.NumericalMathEvaluationImplementationPointer___call__(self, *args)

    def getInputDimension(self):
        """getInputDimension(NumericalMathEvaluationImplementationPointer self) -> OT::UnsignedLong"""
        return _func.NumericalMathEvaluationImplementationPointer_getInputDimension(self)

    def getOutputDimension(self):
        """getOutputDimension(NumericalMathEvaluationImplementationPointer self) -> OT::UnsignedLong"""
        return _func.NumericalMathEvaluationImplementationPointer_getOutputDimension(self)

    def getMarginal(self, *args):
        """
        getMarginal(NumericalMathEvaluationImplementationPointer self, OT::UnsignedLong const i) -> EvaluationImplementation
        getMarginal(NumericalMathEvaluationImplementationPointer self, Indices indices) -> EvaluationImplementation
        """
        return _func.NumericalMathEvaluationImplementationPointer_getMarginal(self, *args)

    def parametersGradient(self, *args):
        """parametersGradient(NumericalMathEvaluationImplementationPointer self, NumericalPoint inP) -> Matrix"""
        return _func.NumericalMathEvaluationImplementationPointer_parametersGradient(self, *args)

    def getParameters(self):
        """getParameters(NumericalMathEvaluationImplementationPointer self) -> NumericalPointWithDescription"""
        return _func.NumericalMathEvaluationImplementationPointer_getParameters(self)

    def setParameters(self, *args):
        """setParameters(NumericalMathEvaluationImplementationPointer self, NumericalPointWithDescription parameters)"""
        return _func.NumericalMathEvaluationImplementationPointer_setParameters(self, *args)

    def getCallsNumber(self):
        """getCallsNumber(NumericalMathEvaluationImplementationPointer self) -> OT::UnsignedLong"""
        return _func.NumericalMathEvaluationImplementationPointer_getCallsNumber(self)

    def draw(self, *args):
        """
        draw(NumericalMathEvaluationImplementationPointer self, OT::UnsignedLong const inputMarginal, OT::UnsignedLong const outputMarginal, NumericalPoint centralPoint, 
            OT::NumericalScalar const xMin, OT::NumericalScalar const xMax, 
            OT::UnsignedLong const pointNumber=OT::ResourceMap::GetAsUnsignedLong("NumericalMathEvaluationImplementation-DefaultPointNumber")) -> Graph
        draw(NumericalMathEvaluationImplementationPointer self, OT::UnsignedLong const inputMarginal, OT::UnsignedLong const outputMarginal, NumericalPoint centralPoint, 
            OT::NumericalScalar const xMin, OT::NumericalScalar const xMax) -> Graph
        draw(NumericalMathEvaluationImplementationPointer self, OT::UnsignedLong const firstInputMarginal, OT::UnsignedLong const secondInputMarginal, 
            OT::UnsignedLong const outputMarginal, NumericalPoint centralPoint, NumericalPoint xMin, 
            NumericalPoint xMax, Indices pointNumber=OT::Indices(2, ResourceMap::GetAsUnsignedLong("NumericalMathEvaluationImplementation-DefaultPointNumber"))) -> Graph
        draw(NumericalMathEvaluationImplementationPointer self, OT::UnsignedLong const firstInputMarginal, OT::UnsignedLong const secondInputMarginal, 
            OT::UnsignedLong const outputMarginal, NumericalPoint centralPoint, NumericalPoint xMin, 
            NumericalPoint xMax) -> Graph
        draw(NumericalMathEvaluationImplementationPointer self, OT::NumericalScalar const xMin, OT::NumericalScalar const xMax, OT::UnsignedLong const pointNumber=OT::ResourceMap::GetAsUnsignedLong("NumericalMathEvaluationImplementation-DefaultPointNumber")) -> Graph
        draw(NumericalMathEvaluationImplementationPointer self, OT::NumericalScalar const xMin, OT::NumericalScalar const xMax) -> Graph
        draw(NumericalMathEvaluationImplementationPointer self, NumericalPoint xMin, NumericalPoint xMax, Indices pointNumber=OT::Indices(2, ResourceMap::GetAsUnsignedLong("NumericalMathEvaluationImplementation-DefaultPointNumber"))) -> Graph
        draw(NumericalMathEvaluationImplementationPointer self, NumericalPoint xMin, NumericalPoint xMax) -> Graph
        """
        return _func.NumericalMathEvaluationImplementationPointer_draw(self, *args)

    def Is(self, *args):
        """Is(NumericalMathEvaluationImplementationPointer self, PersistentObject other) -> OT::Bool"""
        return _func.NumericalMathEvaluationImplementationPointer_Is(self, *args)

    def getId(self):
        """getId(NumericalMathEvaluationImplementationPointer self) -> OT::Id"""
        return _func.NumericalMathEvaluationImplementationPointer_getId(self)

    def setShadowedId(self, *args):
        """setShadowedId(NumericalMathEvaluationImplementationPointer self, OT::Id id)"""
        return _func.NumericalMathEvaluationImplementationPointer_setShadowedId(self, *args)

    def getShadowedId(self):
        """getShadowedId(NumericalMathEvaluationImplementationPointer self) -> OT::Id"""
        return _func.NumericalMathEvaluationImplementationPointer_getShadowedId(self)

    def setVisibility(self, *args):
        """setVisibility(NumericalMathEvaluationImplementationPointer self, OT::Bool visible)"""
        return _func.NumericalMathEvaluationImplementationPointer_setVisibility(self, *args)

    def getVisibility(self):
        """getVisibility(NumericalMathEvaluationImplementationPointer self) -> OT::Bool"""
        return _func.NumericalMathEvaluationImplementationPointer_getVisibility(self)

    def hasName(self):
        """hasName(NumericalMathEvaluationImplementationPointer self) -> OT::Bool"""
        return _func.NumericalMathEvaluationImplementationPointer_hasName(self)

    def hasVisibleName(self):
        """hasVisibleName(NumericalMathEvaluationImplementationPointer self) -> OT::Bool"""
        return _func.NumericalMathEvaluationImplementationPointer_hasVisibleName(self)

    def getName(self):
        """getName(NumericalMathEvaluationImplementationPointer self) -> OT::String"""
        return _func.NumericalMathEvaluationImplementationPointer_getName(self)

    def setName(self, *args):
        """setName(NumericalMathEvaluationImplementationPointer self, OT::String const & name)"""
        return _func.NumericalMathEvaluationImplementationPointer_setName(self, *args)

NumericalMathEvaluationImplementationPointer_swigregister = _func.NumericalMathEvaluationImplementationPointer_swigregister
NumericalMathEvaluationImplementationPointer_swigregister(NumericalMathEvaluationImplementationPointer)

class NumericalMathFunctionImplementationPointer(_object):
    """Proxy of C++ OT::Pointer<(OT::NumericalMathFunctionImplementation)> class"""
    __swig_setmethods__ = {}
    __setattr__ = lambda self, name, value: _swig_setattr(self, NumericalMathFunctionImplementationPointer, name, value)
    __swig_getmethods__ = {}
    __getattr__ = lambda self, name: _swig_getattr(self, NumericalMathFunctionImplementationPointer, name)
    __swig_setmethods__["ptr_"] = _func.NumericalMathFunctionImplementationPointer_ptr__set
    __swig_getmethods__["ptr_"] = _func.NumericalMathFunctionImplementationPointer_ptr__get
    if _newclass:ptr_ = _swig_property(_func.NumericalMathFunctionImplementationPointer_ptr__get, _func.NumericalMathFunctionImplementationPointer_ptr__set)
    def __init__(self, *args): 
        """
        __init__(OT::Pointer<(OT::NumericalMathFunctionImplementation)> self) -> NumericalMathFunctionImplementationPointer
        __init__(OT::Pointer<(OT::NumericalMathFunctionImplementation)> self, NumericalMathFunctionImplementation ptr) -> NumericalMathFunctionImplementationPointer
        """
        this = _func.new_NumericalMathFunctionImplementationPointer(*args)
        try: self.this.append(this)
        except: self.this = this
    __swig_destroy__ = _func.delete_NumericalMathFunctionImplementationPointer
    __del__ = lambda self : None;
    def reset(self):
        """reset(NumericalMathFunctionImplementationPointer self)"""
        return _func.NumericalMathFunctionImplementationPointer_reset(self)

    def __ref__(self, *args):
        """
        __ref__(NumericalMathFunctionImplementationPointer self) -> NumericalMathFunctionImplementation
        __ref__(NumericalMathFunctionImplementationPointer self) -> NumericalMathFunctionImplementation
        """
        return _func.NumericalMathFunctionImplementationPointer___ref__(self, *args)

    def __deref__(self):
        """__deref__(NumericalMathFunctionImplementationPointer self) -> NumericalMathFunctionImplementation"""
        return _func.NumericalMathFunctionImplementationPointer___deref__(self)

    def isNull(self):
        """isNull(NumericalMathFunctionImplementationPointer self) -> OT::Bool"""
        return _func.NumericalMathFunctionImplementationPointer_isNull(self)

    def __nonzero__(self):
        return _func.NumericalMathFunctionImplementationPointer___nonzero__(self)
    __bool__ = __nonzero__


    def get(self):
        """get(NumericalMathFunctionImplementationPointer self) -> NumericalMathFunctionImplementation"""
        return _func.NumericalMathFunctionImplementationPointer_get(self)

    def getImplementation(self):
        """getImplementation(NumericalMathFunctionImplementationPointer self) -> OT::Pointer< OT::NumericalMathFunctionImplementation >::pointer_type const &"""
        return _func.NumericalMathFunctionImplementationPointer_getImplementation(self)

    def unique(self):
        """unique(NumericalMathFunctionImplementationPointer self) -> OT::Bool"""
        return _func.NumericalMathFunctionImplementationPointer_unique(self)

    def use_count(self):
        """use_count(NumericalMathFunctionImplementationPointer self) -> OT::UnsignedLong"""
        return _func.NumericalMathFunctionImplementationPointer_use_count(self)

    def swap(self, *args):
        """swap(NumericalMathFunctionImplementationPointer self, NumericalMathFunctionImplementationPointer other)"""
        return _func.NumericalMathFunctionImplementationPointer_swap(self, *args)

    def GetClassName(self):
        """GetClassName(NumericalMathFunctionImplementationPointer self) -> OT::String"""
        return _func.NumericalMathFunctionImplementationPointer_GetClassName(self)

    def getClassName(self):
        """getClassName(NumericalMathFunctionImplementationPointer self) -> OT::String"""
        return _func.NumericalMathFunctionImplementationPointer_getClassName(self)

    def GetValidConstants(self):
        """GetValidConstants(NumericalMathFunctionImplementationPointer self) -> Description"""
        return _func.NumericalMathFunctionImplementationPointer_GetValidConstants(self)

    def GetValidFunctions(self):
        """GetValidFunctions(NumericalMathFunctionImplementationPointer self) -> Description"""
        return _func.NumericalMathFunctionImplementationPointer_GetValidFunctions(self)

    def GetValidOperators(self):
        """GetValidOperators(NumericalMathFunctionImplementationPointer self) -> Description"""
        return _func.NumericalMathFunctionImplementationPointer_GetValidOperators(self)

    def __mul__(self, *args):
        """
        __mul__(NumericalMathFunctionImplementationPointer self, NumericalMathFunctionImplementation right) -> NumericalMathFunctionImplementation
        __mul__(NumericalMathFunctionImplementationPointer self, NumericalMathFunctionImplementationPointer p_right) -> NumericalMathFunctionImplementation
        """
        return _func.NumericalMathFunctionImplementationPointer___mul__(self, *args)

    def __eq__(self, *args):
        """__eq__(NumericalMathFunctionImplementationPointer self, NumericalMathFunctionImplementation other) -> OT::Bool"""
        return _func.NumericalMathFunctionImplementationPointer___eq__(self, *args)

    def __repr__(self):
        """__repr__(NumericalMathFunctionImplementationPointer self) -> OT::String"""
        return _func.NumericalMathFunctionImplementationPointer___repr__(self)

    def __str__(self, offset=""):
        """
        __str__(NumericalMathFunctionImplementationPointer self, OT::String const & offset="") -> OT::String
        __str__(NumericalMathFunctionImplementationPointer self) -> OT::String
        """
        return _func.NumericalMathFunctionImplementationPointer___str__(self, offset)

    def enableCache(self):
        """enableCache(NumericalMathFunctionImplementationPointer self)"""
        return _func.NumericalMathFunctionImplementationPointer_enableCache(self)

    def disableCache(self):
        """disableCache(NumericalMathFunctionImplementationPointer self)"""
        return _func.NumericalMathFunctionImplementationPointer_disableCache(self)

    def isCacheEnabled(self):
        """isCacheEnabled(NumericalMathFunctionImplementationPointer self) -> OT::Bool"""
        return _func.NumericalMathFunctionImplementationPointer_isCacheEnabled(self)

    def getCacheHits(self):
        """getCacheHits(NumericalMathFunctionImplementationPointer self) -> OT::UnsignedLong"""
        return _func.NumericalMathFunctionImplementationPointer_getCacheHits(self)

    def addCacheContent(self, *args):
        """addCacheContent(NumericalMathFunctionImplementationPointer self, NumericalSample inSample, NumericalSample outSample)"""
        return _func.NumericalMathFunctionImplementationPointer_addCacheContent(self, *args)

    def getCacheInput(self):
        """getCacheInput(NumericalMathFunctionImplementationPointer self) -> NumericalSample"""
        return _func.NumericalMathFunctionImplementationPointer_getCacheInput(self)

    def getCacheOutput(self):
        """getCacheOutput(NumericalMathFunctionImplementationPointer self) -> NumericalSample"""
        return _func.NumericalMathFunctionImplementationPointer_getCacheOutput(self)

    def clearCache(self):
        """clearCache(NumericalMathFunctionImplementationPointer self)"""
        return _func.NumericalMathFunctionImplementationPointer_clearCache(self)

    def enableHistory(self):
        """enableHistory(NumericalMathFunctionImplementationPointer self)"""
        return _func.NumericalMathFunctionImplementationPointer_enableHistory(self)

    def disableHistory(self):
        """disableHistory(NumericalMathFunctionImplementationPointer self)"""
        return _func.NumericalMathFunctionImplementationPointer_disableHistory(self)

    def isHistoryEnabled(self):
        """isHistoryEnabled(NumericalMathFunctionImplementationPointer self) -> OT::Bool"""
        return _func.NumericalMathFunctionImplementationPointer_isHistoryEnabled(self)

    def clearHistory(self):
        """clearHistory(NumericalMathFunctionImplementationPointer self)"""
        return _func.NumericalMathFunctionImplementationPointer_clearHistory(self)

    def getInputHistory(self):
        """getInputHistory(NumericalMathFunctionImplementationPointer self) -> HistoryStrategy"""
        return _func.NumericalMathFunctionImplementationPointer_getInputHistory(self)

    def getOutputHistory(self):
        """getOutputHistory(NumericalMathFunctionImplementationPointer self) -> HistoryStrategy"""
        return _func.NumericalMathFunctionImplementationPointer_getOutputHistory(self)

    def setEvaluationImplementation(self, *args):
        """setEvaluationImplementation(NumericalMathFunctionImplementationPointer self, EvaluationImplementation evaluationImplementation)"""
        return _func.NumericalMathFunctionImplementationPointer_setEvaluationImplementation(self, *args)

    def getEvaluationImplementation(self):
        """getEvaluationImplementation(NumericalMathFunctionImplementationPointer self) -> EvaluationImplementation"""
        return _func.NumericalMathFunctionImplementationPointer_getEvaluationImplementation(self)

    def setGradientImplementation(self, *args):
        """setGradientImplementation(NumericalMathFunctionImplementationPointer self, GradientImplementation gradientImplementation)"""
        return _func.NumericalMathFunctionImplementationPointer_setGradientImplementation(self, *args)

    def getGradientImplementation(self):
        """getGradientImplementation(NumericalMathFunctionImplementationPointer self) -> GradientImplementation"""
        return _func.NumericalMathFunctionImplementationPointer_getGradientImplementation(self)

    def setHessianImplementation(self, *args):
        """setHessianImplementation(NumericalMathFunctionImplementationPointer self, HessianImplementation hessianImplementation)"""
        return _func.NumericalMathFunctionImplementationPointer_setHessianImplementation(self, *args)

    def getHessianImplementation(self):
        """getHessianImplementation(NumericalMathFunctionImplementationPointer self) -> HessianImplementation"""
        return _func.NumericalMathFunctionImplementationPointer_getHessianImplementation(self)

    def getInitialEvaluationImplementation(self):
        """getInitialEvaluationImplementation(NumericalMathFunctionImplementationPointer self) -> EvaluationImplementation"""
        return _func.NumericalMathFunctionImplementationPointer_getInitialEvaluationImplementation(self)

    def getInitialGradientImplementation(self):
        """getInitialGradientImplementation(NumericalMathFunctionImplementationPointer self) -> GradientImplementation"""
        return _func.NumericalMathFunctionImplementationPointer_getInitialGradientImplementation(self)

    def getInitialHessianImplementation(self):
        """getInitialHessianImplementation(NumericalMathFunctionImplementationPointer self) -> HessianImplementation"""
        return _func.NumericalMathFunctionImplementationPointer_getInitialHessianImplementation(self)

    def getUseDefaultGradientImplementation(self):
        """getUseDefaultGradientImplementation(NumericalMathFunctionImplementationPointer self) -> OT::Bool"""
        return _func.NumericalMathFunctionImplementationPointer_getUseDefaultGradientImplementation(self)

    def setUseDefaultGradientImplementation(self, *args):
        """setUseDefaultGradientImplementation(NumericalMathFunctionImplementationPointer self, OT::Bool const gradientFlag)"""
        return _func.NumericalMathFunctionImplementationPointer_setUseDefaultGradientImplementation(self, *args)

    def getUseDefaultHessianImplementation(self):
        """getUseDefaultHessianImplementation(NumericalMathFunctionImplementationPointer self) -> OT::Bool"""
        return _func.NumericalMathFunctionImplementationPointer_getUseDefaultHessianImplementation(self)

    def setUseDefaultHessianImplementation(self, *args):
        """setUseDefaultHessianImplementation(NumericalMathFunctionImplementationPointer self, OT::Bool const hessianFlag)"""
        return _func.NumericalMathFunctionImplementationPointer_setUseDefaultHessianImplementation(self, *args)

    def __call__(self, *args):
        """
        __call__(NumericalMathFunctionImplementationPointer self, NumericalPoint inP) -> NumericalPoint
        __call__(NumericalMathFunctionImplementationPointer self, NumericalSample inS) -> NumericalSample
        __call__(NumericalMathFunctionImplementationPointer self, TimeSeries inTS) -> TimeSeries
        """
        return _func.NumericalMathFunctionImplementationPointer___call__(self, *args)

    def gradient(self, *args):
        """gradient(NumericalMathFunctionImplementationPointer self, NumericalPoint inP) -> Matrix"""
        return _func.NumericalMathFunctionImplementationPointer_gradient(self, *args)

    def hessian(self, *args):
        """hessian(NumericalMathFunctionImplementationPointer self, NumericalPoint inP) -> SymmetricTensor"""
        return _func.NumericalMathFunctionImplementationPointer_hessian(self, *args)

    def parametersGradient(self, *args):
        """parametersGradient(NumericalMathFunctionImplementationPointer self, NumericalPoint inP) -> Matrix"""
        return _func.NumericalMathFunctionImplementationPointer_parametersGradient(self, *args)

    def getParameters(self):
        """getParameters(NumericalMathFunctionImplementationPointer self) -> NumericalPointWithDescription"""
        return _func.NumericalMathFunctionImplementationPointer_getParameters(self)

    def setParameters(self, *args):
        """setParameters(NumericalMathFunctionImplementationPointer self, NumericalPointWithDescription parameters)"""
        return _func.NumericalMathFunctionImplementationPointer_setParameters(self, *args)

    def getInputNumericalPointDimension(self):
        """getInputNumericalPointDimension(NumericalMathFunctionImplementationPointer self) -> OT::UnsignedLong"""
        return _func.NumericalMathFunctionImplementationPointer_getInputNumericalPointDimension(self)

    def getOutputNumericalPointDimension(self):
        """getOutputNumericalPointDimension(NumericalMathFunctionImplementationPointer self) -> OT::UnsignedLong"""
        return _func.NumericalMathFunctionImplementationPointer_getOutputNumericalPointDimension(self)

    def getInputDimension(self):
        """getInputDimension(NumericalMathFunctionImplementationPointer self) -> OT::UnsignedLong"""
        return _func.NumericalMathFunctionImplementationPointer_getInputDimension(self)

    def getOutputDimension(self):
        """getOutputDimension(NumericalMathFunctionImplementationPointer self) -> OT::UnsignedLong"""
        return _func.NumericalMathFunctionImplementationPointer_getOutputDimension(self)

    def setDescription(self, *args):
        """setDescription(NumericalMathFunctionImplementationPointer self, Description description)"""
        return _func.NumericalMathFunctionImplementationPointer_setDescription(self, *args)

    def getDescription(self):
        """getDescription(NumericalMathFunctionImplementationPointer self) -> Description"""
        return _func.NumericalMathFunctionImplementationPointer_getDescription(self)

    def getInputDescription(self):
        """getInputDescription(NumericalMathFunctionImplementationPointer self) -> Description"""
        return _func.NumericalMathFunctionImplementationPointer_getInputDescription(self)

    def getOutputDescription(self):
        """getOutputDescription(NumericalMathFunctionImplementationPointer self) -> Description"""
        return _func.NumericalMathFunctionImplementationPointer_getOutputDescription(self)

    def getMarginal(self, *args):
        """
        getMarginal(NumericalMathFunctionImplementationPointer self, OT::UnsignedLong const i) -> NumericalMathFunctionImplementationPointer
        getMarginal(NumericalMathFunctionImplementationPointer self, Indices indices) -> NumericalMathFunctionImplementationPointer
        """
        return _func.NumericalMathFunctionImplementationPointer_getMarginal(self, *args)

    def getEvaluationCallsNumber(self):
        """getEvaluationCallsNumber(NumericalMathFunctionImplementationPointer self) -> OT::UnsignedLong"""
        return _func.NumericalMathFunctionImplementationPointer_getEvaluationCallsNumber(self)

    def getGradientCallsNumber(self):
        """getGradientCallsNumber(NumericalMathFunctionImplementationPointer self) -> OT::UnsignedLong"""
        return _func.NumericalMathFunctionImplementationPointer_getGradientCallsNumber(self)

    def getHessianCallsNumber(self):
        """getHessianCallsNumber(NumericalMathFunctionImplementationPointer self) -> OT::UnsignedLong"""
        return _func.NumericalMathFunctionImplementationPointer_getHessianCallsNumber(self)

    def draw(self, *args):
        """
        draw(NumericalMathFunctionImplementationPointer self, OT::UnsignedLong const inputMarginal, OT::UnsignedLong const outputMarginal, NumericalPoint centralPoint, 
            OT::NumericalScalar const xMin, OT::NumericalScalar const xMax, 
            OT::UnsignedLong const pointNumber=OT::ResourceMap::GetAsUnsignedLong("NumericalMathEvaluationImplementation-DefaultPointNumber")) -> Graph
        draw(NumericalMathFunctionImplementationPointer self, OT::UnsignedLong const inputMarginal, OT::UnsignedLong const outputMarginal, NumericalPoint centralPoint, 
            OT::NumericalScalar const xMin, OT::NumericalScalar const xMax) -> Graph
        draw(NumericalMathFunctionImplementationPointer self, OT::UnsignedLong const firstInputMarginal, OT::UnsignedLong const secondInputMarginal, 
            OT::UnsignedLong const outputMarginal, NumericalPoint centralPoint, NumericalPoint xMin, 
            NumericalPoint xMax, Indices pointNumber=OT::Indices(2, ResourceMap::GetAsUnsignedLong("NumericalMathEvaluationImplementation-DefaultPointNumber"))) -> Graph
        draw(NumericalMathFunctionImplementationPointer self, OT::UnsignedLong const firstInputMarginal, OT::UnsignedLong const secondInputMarginal, 
            OT::UnsignedLong const outputMarginal, NumericalPoint centralPoint, NumericalPoint xMin, 
            NumericalPoint xMax) -> Graph
        draw(NumericalMathFunctionImplementationPointer self, OT::NumericalScalar const xMin, OT::NumericalScalar const xMax, OT::UnsignedLong const pointNumber=OT::ResourceMap::GetAsUnsignedLong("NumericalMathEvaluationImplementation-DefaultPointNumber")) -> Graph
        draw(NumericalMathFunctionImplementationPointer self, OT::NumericalScalar const xMin, OT::NumericalScalar const xMax) -> Graph
        draw(NumericalMathFunctionImplementationPointer self, NumericalPoint xMin, NumericalPoint xMax, Indices pointNumber=OT::Indices(2, ResourceMap::GetAsUnsignedLong("NumericalMathEvaluationImplementation-DefaultPointNumber"))) -> Graph
        draw(NumericalMathFunctionImplementationPointer self, NumericalPoint xMin, NumericalPoint xMax) -> Graph
        """
        return _func.NumericalMathFunctionImplementationPointer_draw(self, *args)

    def Is(self, *args):
        """Is(NumericalMathFunctionImplementationPointer self, PersistentObject other) -> OT::Bool"""
        return _func.NumericalMathFunctionImplementationPointer_Is(self, *args)

    def getId(self):
        """getId(NumericalMathFunctionImplementationPointer self) -> OT::Id"""
        return _func.NumericalMathFunctionImplementationPointer_getId(self)

    def setShadowedId(self, *args):
        """setShadowedId(NumericalMathFunctionImplementationPointer self, OT::Id id)"""
        return _func.NumericalMathFunctionImplementationPointer_setShadowedId(self, *args)

    def getShadowedId(self):
        """getShadowedId(NumericalMathFunctionImplementationPointer self) -> OT::Id"""
        return _func.NumericalMathFunctionImplementationPointer_getShadowedId(self)

    def setVisibility(self, *args):
        """setVisibility(NumericalMathFunctionImplementationPointer self, OT::Bool visible)"""
        return _func.NumericalMathFunctionImplementationPointer_setVisibility(self, *args)

    def getVisibility(self):
        """getVisibility(NumericalMathFunctionImplementationPointer self) -> OT::Bool"""
        return _func.NumericalMathFunctionImplementationPointer_getVisibility(self)

    def hasName(self):
        """hasName(NumericalMathFunctionImplementationPointer self) -> OT::Bool"""
        return _func.NumericalMathFunctionImplementationPointer_hasName(self)

    def hasVisibleName(self):
        """hasVisibleName(NumericalMathFunctionImplementationPointer self) -> OT::Bool"""
        return _func.NumericalMathFunctionImplementationPointer_hasVisibleName(self)

    def getName(self):
        """getName(NumericalMathFunctionImplementationPointer self) -> OT::String"""
        return _func.NumericalMathFunctionImplementationPointer_getName(self)

    def setName(self, *args):
        """setName(NumericalMathFunctionImplementationPointer self, OT::String const & name)"""
        return _func.NumericalMathFunctionImplementationPointer_setName(self, *args)

NumericalMathFunctionImplementationPointer_swigregister = _func.NumericalMathFunctionImplementationPointer_swigregister
NumericalMathFunctionImplementationPointer_swigregister(NumericalMathFunctionImplementationPointer)

class NumericalMathGradientImplementationPointer(_object):
    """Proxy of C++ OT::Pointer<(OT::NumericalMathGradientImplementation)> class"""
    __swig_setmethods__ = {}
    __setattr__ = lambda self, name, value: _swig_setattr(self, NumericalMathGradientImplementationPointer, name, value)
    __swig_getmethods__ = {}
    __getattr__ = lambda self, name: _swig_getattr(self, NumericalMathGradientImplementationPointer, name)
    __swig_setmethods__["ptr_"] = _func.NumericalMathGradientImplementationPointer_ptr__set
    __swig_getmethods__["ptr_"] = _func.NumericalMathGradientImplementationPointer_ptr__get
    if _newclass:ptr_ = _swig_property(_func.NumericalMathGradientImplementationPointer_ptr__get, _func.NumericalMathGradientImplementationPointer_ptr__set)
    def __init__(self, *args): 
        """
        __init__(OT::Pointer<(OT::NumericalMathGradientImplementation)> self) -> NumericalMathGradientImplementationPointer
        __init__(OT::Pointer<(OT::NumericalMathGradientImplementation)> self, NumericalMathGradientImplementation ptr) -> NumericalMathGradientImplementationPointer
        """
        this = _func.new_NumericalMathGradientImplementationPointer(*args)
        try: self.this.append(this)
        except: self.this = this
    __swig_destroy__ = _func.delete_NumericalMathGradientImplementationPointer
    __del__ = lambda self : None;
    def reset(self):
        """reset(NumericalMathGradientImplementationPointer self)"""
        return _func.NumericalMathGradientImplementationPointer_reset(self)

    def __ref__(self, *args):
        """
        __ref__(NumericalMathGradientImplementationPointer self) -> NumericalMathGradientImplementation
        __ref__(NumericalMathGradientImplementationPointer self) -> NumericalMathGradientImplementation
        """
        return _func.NumericalMathGradientImplementationPointer___ref__(self, *args)

    def __deref__(self):
        """__deref__(NumericalMathGradientImplementationPointer self) -> NumericalMathGradientImplementation"""
        return _func.NumericalMathGradientImplementationPointer___deref__(self)

    def isNull(self):
        """isNull(NumericalMathGradientImplementationPointer self) -> OT::Bool"""
        return _func.NumericalMathGradientImplementationPointer_isNull(self)

    def __nonzero__(self):
        return _func.NumericalMathGradientImplementationPointer___nonzero__(self)
    __bool__ = __nonzero__


    def get(self):
        """get(NumericalMathGradientImplementationPointer self) -> NumericalMathGradientImplementation"""
        return _func.NumericalMathGradientImplementationPointer_get(self)

    def getImplementation(self):
        """getImplementation(NumericalMathGradientImplementationPointer self) -> OT::Pointer< OT::NumericalMathGradientImplementation >::pointer_type const &"""
        return _func.NumericalMathGradientImplementationPointer_getImplementation(self)

    def unique(self):
        """unique(NumericalMathGradientImplementationPointer self) -> OT::Bool"""
        return _func.NumericalMathGradientImplementationPointer_unique(self)

    def use_count(self):
        """use_count(NumericalMathGradientImplementationPointer self) -> OT::UnsignedLong"""
        return _func.NumericalMathGradientImplementationPointer_use_count(self)

    def swap(self, *args):
        """swap(NumericalMathGradientImplementationPointer self, GradientImplementation other)"""
        return _func.NumericalMathGradientImplementationPointer_swap(self, *args)

    def GetClassName(self):
        """GetClassName(NumericalMathGradientImplementationPointer self) -> OT::String"""
        return _func.NumericalMathGradientImplementationPointer_GetClassName(self)

    def getClassName(self):
        """getClassName(NumericalMathGradientImplementationPointer self) -> OT::String"""
        return _func.NumericalMathGradientImplementationPointer_getClassName(self)

    def __eq__(self, *args):
        """__eq__(NumericalMathGradientImplementationPointer self, NumericalMathGradientImplementation other) -> OT::Bool"""
        return _func.NumericalMathGradientImplementationPointer___eq__(self, *args)

    def __repr__(self):
        """__repr__(NumericalMathGradientImplementationPointer self) -> OT::String"""
        return _func.NumericalMathGradientImplementationPointer___repr__(self)

    def __str__(self, offset=""):
        """
        __str__(NumericalMathGradientImplementationPointer self, OT::String const & offset="") -> OT::String
        __str__(NumericalMathGradientImplementationPointer self) -> OT::String
        """
        return _func.NumericalMathGradientImplementationPointer___str__(self, offset)

    def setDescription(self, *args):
        """setDescription(NumericalMathGradientImplementationPointer self, Description description)"""
        return _func.NumericalMathGradientImplementationPointer_setDescription(self, *args)

    def getDescription(self):
        """getDescription(NumericalMathGradientImplementationPointer self) -> Description"""
        return _func.NumericalMathGradientImplementationPointer_getDescription(self)

    def getMarginal(self, *args):
        """
        getMarginal(NumericalMathGradientImplementationPointer self, OT::UnsignedLong const i) -> GradientImplementation
        getMarginal(NumericalMathGradientImplementationPointer self, Indices indices) -> GradientImplementation
        """
        return _func.NumericalMathGradientImplementationPointer_getMarginal(self, *args)

    def isActualImplementation(self):
        """isActualImplementation(NumericalMathGradientImplementationPointer self) -> OT::Bool"""
        return _func.NumericalMathGradientImplementationPointer_isActualImplementation(self)

    def gradient(self, *args):
        """gradient(NumericalMathGradientImplementationPointer self, NumericalPoint inP) -> Matrix"""
        return _func.NumericalMathGradientImplementationPointer_gradient(self, *args)

    def getInputDimension(self):
        """getInputDimension(NumericalMathGradientImplementationPointer self) -> OT::UnsignedLong"""
        return _func.NumericalMathGradientImplementationPointer_getInputDimension(self)

    def getOutputDimension(self):
        """getOutputDimension(NumericalMathGradientImplementationPointer self) -> OT::UnsignedLong"""
        return _func.NumericalMathGradientImplementationPointer_getOutputDimension(self)

    def getCallsNumber(self):
        """getCallsNumber(NumericalMathGradientImplementationPointer self) -> OT::UnsignedLong"""
        return _func.NumericalMathGradientImplementationPointer_getCallsNumber(self)

    def Is(self, *args):
        """Is(NumericalMathGradientImplementationPointer self, PersistentObject other) -> OT::Bool"""
        return _func.NumericalMathGradientImplementationPointer_Is(self, *args)

    def getId(self):
        """getId(NumericalMathGradientImplementationPointer self) -> OT::Id"""
        return _func.NumericalMathGradientImplementationPointer_getId(self)

    def setShadowedId(self, *args):
        """setShadowedId(NumericalMathGradientImplementationPointer self, OT::Id id)"""
        return _func.NumericalMathGradientImplementationPointer_setShadowedId(self, *args)

    def getShadowedId(self):
        """getShadowedId(NumericalMathGradientImplementationPointer self) -> OT::Id"""
        return _func.NumericalMathGradientImplementationPointer_getShadowedId(self)

    def setVisibility(self, *args):
        """setVisibility(NumericalMathGradientImplementationPointer self, OT::Bool visible)"""
        return _func.NumericalMathGradientImplementationPointer_setVisibility(self, *args)

    def getVisibility(self):
        """getVisibility(NumericalMathGradientImplementationPointer self) -> OT::Bool"""
        return _func.NumericalMathGradientImplementationPointer_getVisibility(self)

    def hasName(self):
        """hasName(NumericalMathGradientImplementationPointer self) -> OT::Bool"""
        return _func.NumericalMathGradientImplementationPointer_hasName(self)

    def hasVisibleName(self):
        """hasVisibleName(NumericalMathGradientImplementationPointer self) -> OT::Bool"""
        return _func.NumericalMathGradientImplementationPointer_hasVisibleName(self)

    def getName(self):
        """getName(NumericalMathGradientImplementationPointer self) -> OT::String"""
        return _func.NumericalMathGradientImplementationPointer_getName(self)

    def setName(self, *args):
        """setName(NumericalMathGradientImplementationPointer self, OT::String const & name)"""
        return _func.NumericalMathGradientImplementationPointer_setName(self, *args)

NumericalMathGradientImplementationPointer_swigregister = _func.NumericalMathGradientImplementationPointer_swigregister
NumericalMathGradientImplementationPointer_swigregister(NumericalMathGradientImplementationPointer)

class NumericalMathHessianImplementationPointer(_object):
    """Proxy of C++ OT::Pointer<(OT::NumericalMathHessianImplementation)> class"""
    __swig_setmethods__ = {}
    __setattr__ = lambda self, name, value: _swig_setattr(self, NumericalMathHessianImplementationPointer, name, value)
    __swig_getmethods__ = {}
    __getattr__ = lambda self, name: _swig_getattr(self, NumericalMathHessianImplementationPointer, name)
    __swig_setmethods__["ptr_"] = _func.NumericalMathHessianImplementationPointer_ptr__set
    __swig_getmethods__["ptr_"] = _func.NumericalMathHessianImplementationPointer_ptr__get
    if _newclass:ptr_ = _swig_property(_func.NumericalMathHessianImplementationPointer_ptr__get, _func.NumericalMathHessianImplementationPointer_ptr__set)
    def __init__(self, *args): 
        """
        __init__(OT::Pointer<(OT::NumericalMathHessianImplementation)> self) -> NumericalMathHessianImplementationPointer
        __init__(OT::Pointer<(OT::NumericalMathHessianImplementation)> self, NumericalMathHessianImplementation ptr) -> NumericalMathHessianImplementationPointer
        """
        this = _func.new_NumericalMathHessianImplementationPointer(*args)
        try: self.this.append(this)
        except: self.this = this
    __swig_destroy__ = _func.delete_NumericalMathHessianImplementationPointer
    __del__ = lambda self : None;
    def reset(self):
        """reset(NumericalMathHessianImplementationPointer self)"""
        return _func.NumericalMathHessianImplementationPointer_reset(self)

    def __ref__(self, *args):
        """
        __ref__(NumericalMathHessianImplementationPointer self) -> NumericalMathHessianImplementation
        __ref__(NumericalMathHessianImplementationPointer self) -> NumericalMathHessianImplementation
        """
        return _func.NumericalMathHessianImplementationPointer___ref__(self, *args)

    def __deref__(self):
        """__deref__(NumericalMathHessianImplementationPointer self) -> NumericalMathHessianImplementation"""
        return _func.NumericalMathHessianImplementationPointer___deref__(self)

    def isNull(self):
        """isNull(NumericalMathHessianImplementationPointer self) -> OT::Bool"""
        return _func.NumericalMathHessianImplementationPointer_isNull(self)

    def __nonzero__(self):
        return _func.NumericalMathHessianImplementationPointer___nonzero__(self)
    __bool__ = __nonzero__


    def get(self):
        """get(NumericalMathHessianImplementationPointer self) -> NumericalMathHessianImplementation"""
        return _func.NumericalMathHessianImplementationPointer_get(self)

    def getImplementation(self):
        """getImplementation(NumericalMathHessianImplementationPointer self) -> OT::Pointer< OT::NumericalMathHessianImplementation >::pointer_type const &"""
        return _func.NumericalMathHessianImplementationPointer_getImplementation(self)

    def unique(self):
        """unique(NumericalMathHessianImplementationPointer self) -> OT::Bool"""
        return _func.NumericalMathHessianImplementationPointer_unique(self)

    def use_count(self):
        """use_count(NumericalMathHessianImplementationPointer self) -> OT::UnsignedLong"""
        return _func.NumericalMathHessianImplementationPointer_use_count(self)

    def swap(self, *args):
        """swap(NumericalMathHessianImplementationPointer self, HessianImplementation other)"""
        return _func.NumericalMathHessianImplementationPointer_swap(self, *args)

    def GetClassName(self):
        """GetClassName(NumericalMathHessianImplementationPointer self) -> OT::String"""
        return _func.NumericalMathHessianImplementationPointer_GetClassName(self)

    def getClassName(self):
        """getClassName(NumericalMathHessianImplementationPointer self) -> OT::String"""
        return _func.NumericalMathHessianImplementationPointer_getClassName(self)

    def __eq__(self, *args):
        """__eq__(NumericalMathHessianImplementationPointer self, NumericalMathHessianImplementation other) -> OT::Bool"""
        return _func.NumericalMathHessianImplementationPointer___eq__(self, *args)

    def __repr__(self):
        """__repr__(NumericalMathHessianImplementationPointer self) -> OT::String"""
        return _func.NumericalMathHessianImplementationPointer___repr__(self)

    def __str__(self, offset=""):
        """
        __str__(NumericalMathHessianImplementationPointer self, OT::String const & offset="") -> OT::String
        __str__(NumericalMathHessianImplementationPointer self) -> OT::String
        """
        return _func.NumericalMathHessianImplementationPointer___str__(self, offset)

    def setDescription(self, *args):
        """setDescription(NumericalMathHessianImplementationPointer self, Description description)"""
        return _func.NumericalMathHessianImplementationPointer_setDescription(self, *args)

    def getDescription(self):
        """getDescription(NumericalMathHessianImplementationPointer self) -> Description"""
        return _func.NumericalMathHessianImplementationPointer_getDescription(self)

    def isActualImplementation(self):
        """isActualImplementation(NumericalMathHessianImplementationPointer self) -> OT::Bool"""
        return _func.NumericalMathHessianImplementationPointer_isActualImplementation(self)

    def getMarginal(self, *args):
        """
        getMarginal(NumericalMathHessianImplementationPointer self, OT::UnsignedLong const i) -> HessianImplementation
        getMarginal(NumericalMathHessianImplementationPointer self, Indices indices) -> HessianImplementation
        """
        return _func.NumericalMathHessianImplementationPointer_getMarginal(self, *args)

    def hessian(self, *args):
        """hessian(NumericalMathHessianImplementationPointer self, NumericalPoint inP) -> SymmetricTensor"""
        return _func.NumericalMathHessianImplementationPointer_hessian(self, *args)

    def getInputDimension(self):
        """getInputDimension(NumericalMathHessianImplementationPointer self) -> OT::UnsignedLong"""
        return _func.NumericalMathHessianImplementationPointer_getInputDimension(self)

    def getOutputDimension(self):
        """getOutputDimension(NumericalMathHessianImplementationPointer self) -> OT::UnsignedLong"""
        return _func.NumericalMathHessianImplementationPointer_getOutputDimension(self)

    def getCallsNumber(self):
        """getCallsNumber(NumericalMathHessianImplementationPointer self) -> OT::UnsignedLong"""
        return _func.NumericalMathHessianImplementationPointer_getCallsNumber(self)

    def Is(self, *args):
        """Is(NumericalMathHessianImplementationPointer self, PersistentObject other) -> OT::Bool"""
        return _func.NumericalMathHessianImplementationPointer_Is(self, *args)

    def getId(self):
        """getId(NumericalMathHessianImplementationPointer self) -> OT::Id"""
        return _func.NumericalMathHessianImplementationPointer_getId(self)

    def setShadowedId(self, *args):
        """setShadowedId(NumericalMathHessianImplementationPointer self, OT::Id id)"""
        return _func.NumericalMathHessianImplementationPointer_setShadowedId(self, *args)

    def getShadowedId(self):
        """getShadowedId(NumericalMathHessianImplementationPointer self) -> OT::Id"""
        return _func.NumericalMathHessianImplementationPointer_getShadowedId(self)

    def setVisibility(self, *args):
        """setVisibility(NumericalMathHessianImplementationPointer self, OT::Bool visible)"""
        return _func.NumericalMathHessianImplementationPointer_setVisibility(self, *args)

    def getVisibility(self):
        """getVisibility(NumericalMathHessianImplementationPointer self) -> OT::Bool"""
        return _func.NumericalMathHessianImplementationPointer_getVisibility(self)

    def hasName(self):
        """hasName(NumericalMathHessianImplementationPointer self) -> OT::Bool"""
        return _func.NumericalMathHessianImplementationPointer_hasName(self)

    def hasVisibleName(self):
        """hasVisibleName(NumericalMathHessianImplementationPointer self) -> OT::Bool"""
        return _func.NumericalMathHessianImplementationPointer_hasVisibleName(self)

    def getName(self):
        """getName(NumericalMathHessianImplementationPointer self) -> OT::String"""
        return _func.NumericalMathHessianImplementationPointer_getName(self)

    def setName(self, *args):
        """setName(NumericalMathHessianImplementationPointer self, OT::String const & name)"""
        return _func.NumericalMathHessianImplementationPointer_setName(self, *args)

NumericalMathHessianImplementationPointer_swigregister = _func.NumericalMathHessianImplementationPointer_swigregister
NumericalMathHessianImplementationPointer_swigregister(NumericalMathHessianImplementationPointer)

class UniVariatePolynomialImplementationPointer(_object):
    """Proxy of C++ OT::Pointer<(OT::UniVariatePolynomialImplementation)> class"""
    __swig_setmethods__ = {}
    __setattr__ = lambda self, name, value: _swig_setattr(self, UniVariatePolynomialImplementationPointer, name, value)
    __swig_getmethods__ = {}
    __getattr__ = lambda self, name: _swig_getattr(self, UniVariatePolynomialImplementationPointer, name)
    __swig_setmethods__["ptr_"] = _func.UniVariatePolynomialImplementationPointer_ptr__set
    __swig_getmethods__["ptr_"] = _func.UniVariatePolynomialImplementationPointer_ptr__get
    if _newclass:ptr_ = _swig_property(_func.UniVariatePolynomialImplementationPointer_ptr__get, _func.UniVariatePolynomialImplementationPointer_ptr__set)
    def __init__(self, *args): 
        """
        __init__(OT::Pointer<(OT::UniVariatePolynomialImplementation)> self) -> UniVariatePolynomialImplementationPointer
        __init__(OT::Pointer<(OT::UniVariatePolynomialImplementation)> self, UniVariatePolynomialImplementation ptr) -> UniVariatePolynomialImplementationPointer
        """
        this = _func.new_UniVariatePolynomialImplementationPointer(*args)
        try: self.this.append(this)
        except: self.this = this
    __swig_destroy__ = _func.delete_UniVariatePolynomialImplementationPointer
    __del__ = lambda self : None;
    def reset(self):
        """reset(UniVariatePolynomialImplementationPointer self)"""
        return _func.UniVariatePolynomialImplementationPointer_reset(self)

    def __ref__(self, *args):
        """
        __ref__(UniVariatePolynomialImplementationPointer self) -> UniVariatePolynomialImplementation
        __ref__(UniVariatePolynomialImplementationPointer self) -> UniVariatePolynomialImplementation
        """
        return _func.UniVariatePolynomialImplementationPointer___ref__(self, *args)

    def __deref__(self):
        """__deref__(UniVariatePolynomialImplementationPointer self) -> UniVariatePolynomialImplementation"""
        return _func.UniVariatePolynomialImplementationPointer___deref__(self)

    def isNull(self):
        """isNull(UniVariatePolynomialImplementationPointer self) -> OT::Bool"""
        return _func.UniVariatePolynomialImplementationPointer_isNull(self)

    def __nonzero__(self):
        return _func.UniVariatePolynomialImplementationPointer___nonzero__(self)
    __bool__ = __nonzero__


    def get(self):
        """get(UniVariatePolynomialImplementationPointer self) -> UniVariatePolynomialImplementation"""
        return _func.UniVariatePolynomialImplementationPointer_get(self)

    def getImplementation(self):
        """getImplementation(UniVariatePolynomialImplementationPointer self) -> OT::Pointer< OT::UniVariatePolynomialImplementation >::pointer_type const &"""
        return _func.UniVariatePolynomialImplementationPointer_getImplementation(self)

    def unique(self):
        """unique(UniVariatePolynomialImplementationPointer self) -> OT::Bool"""
        return _func.UniVariatePolynomialImplementationPointer_unique(self)

    def use_count(self):
        """use_count(UniVariatePolynomialImplementationPointer self) -> OT::UnsignedLong"""
        return _func.UniVariatePolynomialImplementationPointer_use_count(self)

    def swap(self, *args):
        """swap(UniVariatePolynomialImplementationPointer self, UniVariatePolynomialImplementationPointer other)"""
        return _func.UniVariatePolynomialImplementationPointer_swap(self, *args)

    def GetClassName(self):
        """GetClassName(UniVariatePolynomialImplementationPointer self) -> OT::String"""
        return _func.UniVariatePolynomialImplementationPointer_GetClassName(self)

    def getClassName(self):
        """getClassName(UniVariatePolynomialImplementationPointer self) -> OT::String"""
        return _func.UniVariatePolynomialImplementationPointer_getClassName(self)

    def __repr__(self):
        """__repr__(UniVariatePolynomialImplementationPointer self) -> OT::String"""
        return _func.UniVariatePolynomialImplementationPointer___repr__(self)

    def __str__(self, *args):
        """
        __str__(UniVariatePolynomialImplementationPointer self, OT::String const & offset="") -> OT::String
        __str__(UniVariatePolynomialImplementationPointer self) -> OT::String
        __str__(UniVariatePolynomialImplementationPointer self, OT::String const & variableName, OT::String const & offset) -> OT::String
        """
        return _func.UniVariatePolynomialImplementationPointer___str__(self, *args)

    def __call__(self, *args):
        """
        __call__(UniVariatePolynomialImplementationPointer self, OT::NumericalScalar const x) -> OT::NumericalScalar
        __call__(UniVariatePolynomialImplementationPointer self, OT::NumericalComplex const z) -> OT::NumericalComplex
        """
        return _func.UniVariatePolynomialImplementationPointer___call__(self, *args)

    def derivative(self, *args):
        """derivative(UniVariatePolynomialImplementationPointer self, OT::NumericalScalar const x) -> OT::NumericalScalar"""
        return _func.UniVariatePolynomialImplementationPointer_derivative(self, *args)

    def derivate(self):
        """derivate(UniVariatePolynomialImplementationPointer self) -> UniVariatePolynomialImplementation"""
        return _func.UniVariatePolynomialImplementationPointer_derivate(self)

    def __mul__(self, *args):
        """
        __mul__(UniVariatePolynomialImplementationPointer self, OT::NumericalScalar const scalar) -> UniVariatePolynomialImplementation
        __mul__(UniVariatePolynomialImplementationPointer self, UniVariatePolynomialImplementation uniVariatePolynomial) -> UniVariatePolynomialImplementation
        """
        return _func.UniVariatePolynomialImplementationPointer___mul__(self, *args)

    def incrementDegree(self, degree=1):
        """
        incrementDegree(UniVariatePolynomialImplementationPointer self, OT::UnsignedLong const degree=1) -> UniVariatePolynomialImplementation
        incrementDegree(UniVariatePolynomialImplementationPointer self) -> UniVariatePolynomialImplementation
        """
        return _func.UniVariatePolynomialImplementationPointer_incrementDegree(self, degree)

    def __add__(self, *args):
        """__add__(UniVariatePolynomialImplementationPointer self, UniVariatePolynomialImplementation uniVariatePolynomial) -> UniVariatePolynomialImplementation"""
        return _func.UniVariatePolynomialImplementationPointer___add__(self, *args)

    def __sub__(self, *args):
        """__sub__(UniVariatePolynomialImplementationPointer self, UniVariatePolynomialImplementation uniVariatePolynomial) -> UniVariatePolynomialImplementation"""
        return _func.UniVariatePolynomialImplementationPointer___sub__(self, *args)

    def setCoefficients(self, *args):
        """setCoefficients(UniVariatePolynomialImplementationPointer self, NumericalPoint coefficients)"""
        return _func.UniVariatePolynomialImplementationPointer_setCoefficients(self, *args)

    def getCoefficients(self):
        """getCoefficients(UniVariatePolynomialImplementationPointer self) -> NumericalPoint"""
        return _func.UniVariatePolynomialImplementationPointer_getCoefficients(self)

    def getDegree(self):
        """getDegree(UniVariatePolynomialImplementationPointer self) -> OT::UnsignedLong"""
        return _func.UniVariatePolynomialImplementationPointer_getDegree(self)

    def getRoots(self):
        """getRoots(UniVariatePolynomialImplementationPointer self) -> NumericalComplexCollection"""
        return _func.UniVariatePolynomialImplementationPointer_getRoots(self)

    def draw(self, *args):
        """draw(UniVariatePolynomialImplementationPointer self, OT::NumericalScalar const xMin, OT::NumericalScalar const xMax, OT::UnsignedLong const pointNumber) -> Graph"""
        return _func.UniVariatePolynomialImplementationPointer_draw(self, *args)

    def __eq__(self, *args):
        """__eq__(UniVariatePolynomialImplementationPointer self, PersistentObject other) -> OT::Bool"""
        return _func.UniVariatePolynomialImplementationPointer___eq__(self, *args)

    def Is(self, *args):
        """Is(UniVariatePolynomialImplementationPointer self, PersistentObject other) -> OT::Bool"""
        return _func.UniVariatePolynomialImplementationPointer_Is(self, *args)

    def getId(self):
        """getId(UniVariatePolynomialImplementationPointer self) -> OT::Id"""
        return _func.UniVariatePolynomialImplementationPointer_getId(self)

    def setShadowedId(self, *args):
        """setShadowedId(UniVariatePolynomialImplementationPointer self, OT::Id id)"""
        return _func.UniVariatePolynomialImplementationPointer_setShadowedId(self, *args)

    def getShadowedId(self):
        """getShadowedId(UniVariatePolynomialImplementationPointer self) -> OT::Id"""
        return _func.UniVariatePolynomialImplementationPointer_getShadowedId(self)

    def setVisibility(self, *args):
        """setVisibility(UniVariatePolynomialImplementationPointer self, OT::Bool visible)"""
        return _func.UniVariatePolynomialImplementationPointer_setVisibility(self, *args)

    def getVisibility(self):
        """getVisibility(UniVariatePolynomialImplementationPointer self) -> OT::Bool"""
        return _func.UniVariatePolynomialImplementationPointer_getVisibility(self)

    def hasName(self):
        """hasName(UniVariatePolynomialImplementationPointer self) -> OT::Bool"""
        return _func.UniVariatePolynomialImplementationPointer_hasName(self)

    def hasVisibleName(self):
        """hasVisibleName(UniVariatePolynomialImplementationPointer self) -> OT::Bool"""
        return _func.UniVariatePolynomialImplementationPointer_hasVisibleName(self)

    def getName(self):
        """getName(UniVariatePolynomialImplementationPointer self) -> OT::String"""
        return _func.UniVariatePolynomialImplementationPointer_getName(self)

    def setName(self, *args):
        """setName(UniVariatePolynomialImplementationPointer self, OT::String const & name)"""
        return _func.UniVariatePolynomialImplementationPointer_setName(self, *args)

UniVariatePolynomialImplementationPointer_swigregister = _func.UniVariatePolynomialImplementationPointer_swigregister
UniVariatePolynomialImplementationPointer_swigregister(UniVariatePolynomialImplementationPointer)

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