Logo Search packages:      
Sourcecode: openturns version File versions  Download package

ot.py

# This file was automatically generated by SWIG (http://www.swig.org).
# Version 1.3.35
#
# Don't modify this file, modify the SWIG interface instead.
# This file is compatible with both classic and new-style classes.

"""
Open TURNS is a set of tools and algorithms to realize uncertainty analysis.
"""

import _ot
import new
new_instancemethod = new.instancemethod
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__ == 'PySwigObject':
            self.__dict__[name] = value
            return
    method = class_type.__swig_setmethods__.get(name,None)
    if method: return method(self,value)
    if (not static) or hasattr(self,name):
        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,)

import types
try:
    _object = types.ObjectType
    _newclass = 1
except AttributeError:
00050     class _object : pass
    _newclass = 0
del types


00055 class PySwigIterator(_object):
    """Proxy of C++ PySwigIterator class"""
    __swig_setmethods__ = {}
    __setattr__ = lambda self, name, value: _swig_setattr(self, PySwigIterator, name, value)
    __swig_getmethods__ = {}
    __getattr__ = lambda self, name: _swig_getattr(self, PySwigIterator, name)
    def __init__(self, *args, **kwargs): raise AttributeError, "No constructor defined"
    __repr__ = _swig_repr
    __swig_destroy__ = _ot.delete_PySwigIterator
    __del__ = lambda self : None;
00065     def value(*args):
        """value(self) -> PyObject"""
        return _ot.PySwigIterator_value(*args)

00069     def incr(*args):
        """
        incr(self, size_t n=1) -> PySwigIterator
        incr(self) -> PySwigIterator
        """
        return _ot.PySwigIterator_incr(*args)

00076     def decr(*args):
        """
        decr(self, size_t n=1) -> PySwigIterator
        decr(self) -> PySwigIterator
        """
        return _ot.PySwigIterator_decr(*args)

00083     def distance(*args):
        """distance(self, PySwigIterator x) -> ptrdiff_t"""
        return _ot.PySwigIterator_distance(*args)

00087     def equal(*args):
        """equal(self, PySwigIterator x) -> bool"""
        return _ot.PySwigIterator_equal(*args)

00091     def copy(*args):
        """copy(self) -> PySwigIterator"""
        return _ot.PySwigIterator_copy(*args)

00095     def next(*args):
        """next(self) -> PyObject"""
        return _ot.PySwigIterator_next(*args)

00099     def previous(*args):
        """previous(self) -> PyObject"""
        return _ot.PySwigIterator_previous(*args)

00103     def advance(*args):
        """advance(self, ptrdiff_t n) -> PySwigIterator"""
        return _ot.PySwigIterator_advance(*args)

00107     def __eq__(*args):
        """__eq__(self, PySwigIterator x) -> bool"""
        return _ot.PySwigIterator___eq__(*args)

00111     def __ne__(*args):
        """__ne__(self, PySwigIterator x) -> bool"""
        return _ot.PySwigIterator___ne__(*args)

00115     def __iadd__(*args):
        """__iadd__(self, ptrdiff_t n) -> PySwigIterator"""
        return _ot.PySwigIterator___iadd__(*args)

00119     def __isub__(*args):
        """__isub__(self, ptrdiff_t n) -> PySwigIterator"""
        return _ot.PySwigIterator___isub__(*args)

00123     def __add__(*args):
        """__add__(self, ptrdiff_t n) -> PySwigIterator"""
        return _ot.PySwigIterator___add__(*args)

00127     def __sub__(*args):
        """
        __sub__(self, ptrdiff_t n) -> PySwigIterator
        __sub__(self, PySwigIterator x) -> ptrdiff_t
        """
        return _ot.PySwigIterator___sub__(*args)

    def __iter__(self): return self
PySwigIterator_swigregister = _ot.PySwigIterator_swigregister
PySwigIterator_swigregister(PySwigIterator)

00138 class Exception(_object):
    """Proxy of C++ Exception class"""
    __swig_setmethods__ = {}
    __setattr__ = lambda self, name, value: _swig_setattr(self, Exception, name, value)
    __swig_getmethods__ = {}
    __getattr__ = lambda self, name: _swig_getattr(self, Exception, name)
    __repr__ = _swig_repr
00145     def __init__(self, *args): 
        """
        __init__(self, OpenTURNS::PointInSourceFile point) -> Exception
        __init__(self, Exception other) -> Exception
        """
        this = _ot.new_Exception(*args)
        try: self.this.append(this)
        except: self.this = this
    __swig_destroy__ = _ot.delete_Exception
    __del__ = lambda self : None;
00155     def str(*args):
        """str(self) -> String"""
        return _ot.Exception_str(*args)

00159     def where(*args):
        """where(self) -> char"""
        return _ot.Exception_where(*args)

00163     def what(*args):
        """what(self) -> char"""
        return _ot.Exception_what(*args)

00167     def type(*args):
        """type(self) -> char"""
        return _ot.Exception_type(*args)

Exception_swigregister = _ot.Exception_swigregister
Exception_swigregister(Exception)

00174 class ExceptionNames(_object):
    """Proxy of C++ ExceptionNames class"""
    __swig_setmethods__ = {}
    __setattr__ = lambda self, name, value: _swig_setattr(self, ExceptionNames, name, value)
    __swig_getmethods__ = {}
    __getattr__ = lambda self, name: _swig_getattr(self, ExceptionNames, name)
    def __init__(self, *args, **kwargs): raise AttributeError, "No constructor defined"
    __repr__ = _swig_repr
00182     def get(*args):
        """get(unsigned int id) -> String"""
        return _ot.ExceptionNames_get(*args)

    if _newclass:get = staticmethod(get)
    __swig_getmethods__["get"] = lambda x: get
00188     def release(*args):
        """release()"""
        return _ot.ExceptionNames_release(*args)

    if _newclass:release = staticmethod(release)
    __swig_getmethods__["release"] = lambda x: release
    __swig_destroy__ = _ot.delete_ExceptionNames
    __del__ = lambda self : None;
ExceptionNames_swigregister = _ot.ExceptionNames_swigregister
ExceptionNames_swigregister(ExceptionNames)

def ExceptionNames_get(*args):
  """ExceptionNames_get(unsigned int id) -> String"""
  return _ot.ExceptionNames_get(*args)

def ExceptionNames_release(*args):
  """ExceptionNames_release()"""
  return _ot.ExceptionNames_release(*args)

00207 class FileNotFoundException(Exception):
    """Proxy of C++ FileNotFoundException class"""
    __swig_setmethods__ = {}
    for _s in [Exception]: __swig_setmethods__.update(getattr(_s,'__swig_setmethods__',{}))
    __setattr__ = lambda self, name, value: _swig_setattr(self, FileNotFoundException, name, value)
    __swig_getmethods__ = {}
    for _s in [Exception]: __swig_getmethods__.update(getattr(_s,'__swig_getmethods__',{}))
    __getattr__ = lambda self, name: _swig_getattr(self, FileNotFoundException, name)
    __repr__ = _swig_repr
00216     def __init__(self, *args): 
        """__init__(self, OpenTURNS::PointInSourceFile point) -> FileNotFoundException"""
        this = _ot.new_FileNotFoundException(*args)
        try: self.this.append(this)
        except: self.this = this
    __swig_destroy__ = _ot.delete_FileNotFoundException
    __del__ = lambda self : None;
FileNotFoundException_swigregister = _ot.FileNotFoundException_swigregister
FileNotFoundException_swigregister(FileNotFoundException)

00226 class InternalException(Exception):
    """Proxy of C++ InternalException class"""
    __swig_setmethods__ = {}
    for _s in [Exception]: __swig_setmethods__.update(getattr(_s,'__swig_setmethods__',{}))
    __setattr__ = lambda self, name, value: _swig_setattr(self, InternalException, name, value)
    __swig_getmethods__ = {}
    for _s in [Exception]: __swig_getmethods__.update(getattr(_s,'__swig_getmethods__',{}))
    __getattr__ = lambda self, name: _swig_getattr(self, InternalException, name)
    __repr__ = _swig_repr
00235     def __init__(self, *args): 
        """__init__(self, OpenTURNS::PointInSourceFile point) -> InternalException"""
        this = _ot.new_InternalException(*args)
        try: self.this.append(this)
        except: self.this = this
    __swig_destroy__ = _ot.delete_InternalException
    __del__ = lambda self : None;
InternalException_swigregister = _ot.InternalException_swigregister
InternalException_swigregister(InternalException)

00245 class InvalidArgumentException(Exception):
    """Proxy of C++ InvalidArgumentException class"""
    __swig_setmethods__ = {}
    for _s in [Exception]: __swig_setmethods__.update(getattr(_s,'__swig_setmethods__',{}))
    __setattr__ = lambda self, name, value: _swig_setattr(self, InvalidArgumentException, name, value)
    __swig_getmethods__ = {}
    for _s in [Exception]: __swig_getmethods__.update(getattr(_s,'__swig_getmethods__',{}))
    __getattr__ = lambda self, name: _swig_getattr(self, InvalidArgumentException, name)
    __repr__ = _swig_repr
00254     def __init__(self, *args): 
        """__init__(self, OpenTURNS::PointInSourceFile point) -> InvalidArgumentException"""
        this = _ot.new_InvalidArgumentException(*args)
        try: self.this.append(this)
        except: self.this = this
    __swig_destroy__ = _ot.delete_InvalidArgumentException
    __del__ = lambda self : None;
InvalidArgumentException_swigregister = _ot.InvalidArgumentException_swigregister
InvalidArgumentException_swigregister(InvalidArgumentException)

00264 class InvalidDimensionException(Exception):
    """Proxy of C++ InvalidDimensionException class"""
    __swig_setmethods__ = {}
    for _s in [Exception]: __swig_setmethods__.update(getattr(_s,'__swig_setmethods__',{}))
    __setattr__ = lambda self, name, value: _swig_setattr(self, InvalidDimensionException, name, value)
    __swig_getmethods__ = {}
    for _s in [Exception]: __swig_getmethods__.update(getattr(_s,'__swig_getmethods__',{}))
    __getattr__ = lambda self, name: _swig_getattr(self, InvalidDimensionException, name)
    __repr__ = _swig_repr
00273     def __init__(self, *args): 
        """__init__(self, OpenTURNS::PointInSourceFile point) -> InvalidDimensionException"""
        this = _ot.new_InvalidDimensionException(*args)
        try: self.this.append(this)
        except: self.this = this
    __swig_destroy__ = _ot.delete_InvalidDimensionException
    __del__ = lambda self : None;
InvalidDimensionException_swigregister = _ot.InvalidDimensionException_swigregister
InvalidDimensionException_swigregister(InvalidDimensionException)

00283 class NoWrapperFileFoundException(Exception):
    """Proxy of C++ NoWrapperFileFoundException class"""
    __swig_setmethods__ = {}
    for _s in [Exception]: __swig_setmethods__.update(getattr(_s,'__swig_setmethods__',{}))
    __setattr__ = lambda self, name, value: _swig_setattr(self, NoWrapperFileFoundException, name, value)
    __swig_getmethods__ = {}
    for _s in [Exception]: __swig_getmethods__.update(getattr(_s,'__swig_getmethods__',{}))
    __getattr__ = lambda self, name: _swig_getattr(self, NoWrapperFileFoundException, name)
    __repr__ = _swig_repr
00292     def __init__(self, *args): 
        """__init__(self, OpenTURNS::PointInSourceFile point) -> NoWrapperFileFoundException"""
        this = _ot.new_NoWrapperFileFoundException(*args)
        try: self.this.append(this)
        except: self.this = this
    __swig_destroy__ = _ot.delete_NoWrapperFileFoundException
    __del__ = lambda self : None;
NoWrapperFileFoundException_swigregister = _ot.NoWrapperFileFoundException_swigregister
NoWrapperFileFoundException_swigregister(NoWrapperFileFoundException)

00302 class NotYetImplementedException(Exception):
    """Proxy of C++ NotYetImplementedException class"""
    __swig_setmethods__ = {}
    for _s in [Exception]: __swig_setmethods__.update(getattr(_s,'__swig_setmethods__',{}))
    __setattr__ = lambda self, name, value: _swig_setattr(self, NotYetImplementedException, name, value)
    __swig_getmethods__ = {}
    for _s in [Exception]: __swig_getmethods__.update(getattr(_s,'__swig_getmethods__',{}))
    __getattr__ = lambda self, name: _swig_getattr(self, NotYetImplementedException, name)
    __repr__ = _swig_repr
00311     def __init__(self, *args): 
        """__init__(self, OpenTURNS::PointInSourceFile point) -> NotYetImplementedException"""
        this = _ot.new_NotYetImplementedException(*args)
        try: self.this.append(this)
        except: self.this = this
    __swig_destroy__ = _ot.delete_NotYetImplementedException
    __del__ = lambda self : None;
NotYetImplementedException_swigregister = _ot.NotYetImplementedException_swigregister
NotYetImplementedException_swigregister(NotYetImplementedException)

00321 class OutOfBoundException(Exception):
    """Proxy of C++ OutOfBoundException class"""
    __swig_setmethods__ = {}
    for _s in [Exception]: __swig_setmethods__.update(getattr(_s,'__swig_setmethods__',{}))
    __setattr__ = lambda self, name, value: _swig_setattr(self, OutOfBoundException, name, value)
    __swig_getmethods__ = {}
    for _s in [Exception]: __swig_getmethods__.update(getattr(_s,'__swig_getmethods__',{}))
    __getattr__ = lambda self, name: _swig_getattr(self, OutOfBoundException, name)
    __repr__ = _swig_repr
00330     def __init__(self, *args): 
        """__init__(self, OpenTURNS::PointInSourceFile point) -> OutOfBoundException"""
        this = _ot.new_OutOfBoundException(*args)
        try: self.this.append(this)
        except: self.this = this
    __swig_destroy__ = _ot.delete_OutOfBoundException
    __del__ = lambda self : None;
OutOfBoundException_swigregister = _ot.OutOfBoundException_swigregister
OutOfBoundException_swigregister(OutOfBoundException)

00340 class WrapperFileParsingException(Exception):
    """Proxy of C++ WrapperFileParsingException class"""
    __swig_setmethods__ = {}
    for _s in [Exception]: __swig_setmethods__.update(getattr(_s,'__swig_setmethods__',{}))
    __setattr__ = lambda self, name, value: _swig_setattr(self, WrapperFileParsingException, name, value)
    __swig_getmethods__ = {}
    for _s in [Exception]: __swig_getmethods__.update(getattr(_s,'__swig_getmethods__',{}))
    __getattr__ = lambda self, name: _swig_getattr(self, WrapperFileParsingException, name)
    __repr__ = _swig_repr
00349     def __init__(self, *args): 
        """__init__(self, OpenTURNS::PointInSourceFile point) -> WrapperFileParsingException"""
        this = _ot.new_WrapperFileParsingException(*args)
        try: self.this.append(this)
        except: self.this = this
    __swig_destroy__ = _ot.delete_WrapperFileParsingException
    __del__ = lambda self : None;
WrapperFileParsingException_swigregister = _ot.WrapperFileParsingException_swigregister
WrapperFileParsingException_swigregister(WrapperFileParsingException)

00359 class WrapperInternalException(InternalException):
    """Proxy of C++ WrapperInternalException class"""
    __swig_setmethods__ = {}
    for _s in [InternalException]: __swig_setmethods__.update(getattr(_s,'__swig_setmethods__',{}))
    __setattr__ = lambda self, name, value: _swig_setattr(self, WrapperInternalException, name, value)
    __swig_getmethods__ = {}
    for _s in [InternalException]: __swig_getmethods__.update(getattr(_s,'__swig_getmethods__',{}))
    __getattr__ = lambda self, name: _swig_getattr(self, WrapperInternalException, name)
    __repr__ = _swig_repr
00368     def __init__(self, *args): 
        """__init__(self, OpenTURNS::PointInSourceFile point) -> WrapperInternalException"""
        this = _ot.new_WrapperInternalException(*args)
        try: self.this.append(this)
        except: self.this = this
    __swig_destroy__ = _ot.delete_WrapperInternalException
    __del__ = lambda self : None;
WrapperInternalException_swigregister = _ot.WrapperInternalException_swigregister
WrapperInternalException_swigregister(WrapperInternalException)

00378 class XMLException(Exception):
    """Proxy of C++ XMLException class"""
    __swig_setmethods__ = {}
    for _s in [Exception]: __swig_setmethods__.update(getattr(_s,'__swig_setmethods__',{}))
    __setattr__ = lambda self, name, value: _swig_setattr(self, XMLException, name, value)
    __swig_getmethods__ = {}
    for _s in [Exception]: __swig_getmethods__.update(getattr(_s,'__swig_getmethods__',{}))
    __getattr__ = lambda self, name: _swig_getattr(self, XMLException, name)
    __repr__ = _swig_repr
00387     def __init__(self, *args): 
        """__init__(self, OpenTURNS::PointInSourceFile point) -> XMLException"""
        this = _ot.new_XMLException(*args)
        try: self.this.append(this)
        except: self.this = this
    __swig_destroy__ = _ot.delete_XMLException
    __del__ = lambda self : None;
XMLException_swigregister = _ot.XMLException_swigregister
XMLException_swigregister(XMLException)

00397 class XMLParserException(Exception):
    """Proxy of C++ XMLParserException class"""
    __swig_setmethods__ = {}
    for _s in [Exception]: __swig_setmethods__.update(getattr(_s,'__swig_setmethods__',{}))
    __setattr__ = lambda self, name, value: _swig_setattr(self, XMLParserException, name, value)
    __swig_getmethods__ = {}
    for _s in [Exception]: __swig_getmethods__.update(getattr(_s,'__swig_getmethods__',{}))
    __getattr__ = lambda self, name: _swig_getattr(self, XMLParserException, name)
    __repr__ = _swig_repr
00406     def __init__(self, *args): 
        """__init__(self, OpenTURNS::PointInSourceFile point) -> XMLParserException"""
        this = _ot.new_XMLParserException(*args)
        try: self.this.append(this)
        except: self.this = this
    __swig_destroy__ = _ot.delete_XMLParserException
    __del__ = lambda self : None;
XMLParserException_swigregister = _ot.XMLParserException_swigregister
XMLParserException_swigregister(XMLParserException)

00416 class DynamicLibraryException(Exception):
    """Proxy of C++ DynamicLibraryException class"""
    __swig_setmethods__ = {}
    for _s in [Exception]: __swig_setmethods__.update(getattr(_s,'__swig_setmethods__',{}))
    __setattr__ = lambda self, name, value: _swig_setattr(self, DynamicLibraryException, name, value)
    __swig_getmethods__ = {}
    for _s in [Exception]: __swig_getmethods__.update(getattr(_s,'__swig_getmethods__',{}))
    __getattr__ = lambda self, name: _swig_getattr(self, DynamicLibraryException, name)
    __repr__ = _swig_repr
00425     def __init__(self, *args): 
        """__init__(self, OpenTURNS::PointInSourceFile point) -> DynamicLibraryException"""
        this = _ot.new_DynamicLibraryException(*args)
        try: self.this.append(this)
        except: self.this = this
    __swig_destroy__ = _ot.delete_DynamicLibraryException
    __del__ = lambda self : None;
DynamicLibraryException_swigregister = _ot.DynamicLibraryException_swigregister
DynamicLibraryException_swigregister(DynamicLibraryException)

00435 class NotSymmetricDefinitePositiveException(Exception):
    """Proxy of C++ NotSymmetricDefinitePositiveException class"""
    __swig_setmethods__ = {}
    for _s in [Exception]: __swig_setmethods__.update(getattr(_s,'__swig_setmethods__',{}))
    __setattr__ = lambda self, name, value: _swig_setattr(self, NotSymmetricDefinitePositiveException, name, value)
    __swig_getmethods__ = {}
    for _s in [Exception]: __swig_getmethods__.update(getattr(_s,'__swig_getmethods__',{}))
    __getattr__ = lambda self, name: _swig_getattr(self, NotSymmetricDefinitePositiveException, name)
    __repr__ = _swig_repr
00444     def __init__(self, *args): 
        """__init__(self, OpenTURNS::PointInSourceFile point) -> NotSymmetricDefinitePositiveException"""
        this = _ot.new_NotSymmetricDefinitePositiveException(*args)
        try: self.this.append(this)
        except: self.this = this
    __swig_destroy__ = _ot.delete_NotSymmetricDefinitePositiveException
    __del__ = lambda self : None;
NotSymmetricDefinitePositiveException_swigregister = _ot.NotSymmetricDefinitePositiveException_swigregister
NotSymmetricDefinitePositiveException_swigregister(NotSymmetricDefinitePositiveException)

00454 class InvalidRangeException(Exception):
    """Proxy of C++ InvalidRangeException class"""
    __swig_setmethods__ = {}
    for _s in [Exception]: __swig_setmethods__.update(getattr(_s,'__swig_setmethods__',{}))
    __setattr__ = lambda self, name, value: _swig_setattr(self, InvalidRangeException, name, value)
    __swig_getmethods__ = {}
    for _s in [Exception]: __swig_getmethods__.update(getattr(_s,'__swig_getmethods__',{}))
    __getattr__ = lambda self, name: _swig_getattr(self, InvalidRangeException, name)
    __repr__ = _swig_repr
00463     def __init__(self, *args): 
        """__init__(self, OpenTURNS::PointInSourceFile point) -> InvalidRangeException"""
        this = _ot.new_InvalidRangeException(*args)
        try: self.this.append(this)
        except: self.this = this
    __swig_destroy__ = _ot.delete_InvalidRangeException
    __del__ = lambda self : None;
InvalidRangeException_swigregister = _ot.InvalidRangeException_swigregister
InvalidRangeException_swigregister(InvalidRangeException)

00473 class NotDefinedException(Exception):
    """Proxy of C++ NotDefinedException class"""
    __swig_setmethods__ = {}
    for _s in [Exception]: __swig_setmethods__.update(getattr(_s,'__swig_setmethods__',{}))
    __setattr__ = lambda self, name, value: _swig_setattr(self, NotDefinedException, name, value)
    __swig_getmethods__ = {}
    for _s in [Exception]: __swig_getmethods__.update(getattr(_s,'__swig_getmethods__',{}))
    __getattr__ = lambda self, name: _swig_getattr(self, NotDefinedException, name)
    __repr__ = _swig_repr
00482     def __init__(self, *args): 
        """__init__(self, OpenTURNS::PointInSourceFile point) -> NotDefinedException"""
        this = _ot.new_NotDefinedException(*args)
        try: self.this.append(this)
        except: self.this = this
    __swig_destroy__ = _ot.delete_NotDefinedException
    __del__ = lambda self : None;
NotDefinedException_swigregister = _ot.NotDefinedException_swigregister
NotDefinedException_swigregister(NotDefinedException)

00492 class NetworkException(Exception):
    """Proxy of C++ NetworkException class"""
    __swig_setmethods__ = {}
    for _s in [Exception]: __swig_setmethods__.update(getattr(_s,'__swig_setmethods__',{}))
    __setattr__ = lambda self, name, value: _swig_setattr(self, NetworkException, name, value)
    __swig_getmethods__ = {}
    for _s in [Exception]: __swig_getmethods__.update(getattr(_s,'__swig_getmethods__',{}))
    __getattr__ = lambda self, name: _swig_getattr(self, NetworkException, name)
    __repr__ = _swig_repr
00501     def __init__(self, *args): 
        """__init__(self, OpenTURNS::PointInSourceFile point) -> NetworkException"""
        this = _ot.new_NetworkException(*args)
        try: self.this.append(this)
        except: self.this = this
    __swig_destroy__ = _ot.delete_NetworkException
    __del__ = lambda self : None;
NetworkException_swigregister = _ot.NetworkException_swigregister
NetworkException_swigregister(NetworkException)

00511 class RException(Exception):
    """Proxy of C++ RException class"""
    __swig_setmethods__ = {}
    for _s in [Exception]: __swig_setmethods__.update(getattr(_s,'__swig_setmethods__',{}))
    __setattr__ = lambda self, name, value: _swig_setattr(self, RException, name, value)
    __swig_getmethods__ = {}
    for _s in [Exception]: __swig_getmethods__.update(getattr(_s,'__swig_getmethods__',{}))
    __getattr__ = lambda self, name: _swig_getattr(self, RException, name)
    __repr__ = _swig_repr
00520     def __init__(self, *args): 
        """__init__(self, OpenTURNS::PointInSourceFile point) -> RException"""
        this = _ot.new_RException(*args)
        try: self.this.append(this)
        except: self.this = this
    __swig_destroy__ = _ot.delete_RException
    __del__ = lambda self : None;
RException_swigregister = _ot.RException_swigregister
RException_swigregister(RException)

00530 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

#from openturns_viewer import ViewImage,StopViewer,WaitForViewer

def TESTPREAMBLE():
  """
  TESTPREAMBLE() catches the --version argument on the command line,
  prints a identification string and then exits softly.
  """
  import sys
  if "--version" in sys.argv:
    print sys.argv[0] + " : $Id: openturns.i 916 2008-08-28 15:36:47Z dutka $"
    sys.exit(0)

def Show(graph):
  try :
    if (Graph(graph).getClassName()=="Graph"):
      from rpy import r
      tmp=r(graph.getRCommand())
      graph.clean()
  except :
    try :
      if (Drawable(graph).getClassName()=="Drawable"):
        from rpy import r
        tmp=r(graph.draw())
        graph.clean()
    except :
      import sys
      print "Error in Show", sys.exc_type, sys.exc_value

00575 class Object(_object):
    """Proxy of C++ Object class"""
    __swig_setmethods__ = {}
    __setattr__ = lambda self, name, value: _swig_setattr(self, Object, name, value)
    __swig_getmethods__ = {}
    __getattr__ = lambda self, name: _swig_getattr(self, Object, name)
    def __init__(self, *args, **kwargs): raise AttributeError, "No constructor defined"
    __repr__ = _swig_repr
00583     def GetClassName(*args):
        """GetClassName() -> String"""
        return _ot.Object_GetClassName(*args)

    if _newclass:GetClassName = staticmethod(GetClassName)
    __swig_getmethods__["GetClassName"] = lambda x: GetClassName
00589     def getClassName(*args):
        """getClassName(self) -> String"""
        return _ot.Object_getClassName(*args)

    __swig_destroy__ = _ot.delete_Object
    __del__ = lambda self : None;
00595     def str(*args):
        """str(self) -> String"""
        return _ot.Object_str(*args)

00599     def __str__(*args):
        """__str__(self) -> String"""
        return _ot.Object___str__(*args)

Object_swigregister = _ot.Object_swigregister
Object_swigregister(Object)

def Object_GetClassName(*args):
  """Object_GetClassName() -> String"""
  return _ot.Object_GetClassName(*args)

00610 class PersistentObject(Object):
    """Proxy of C++ PersistentObject class"""
    __swig_setmethods__ = {}
    for _s in [Object]: __swig_setmethods__.update(getattr(_s,'__swig_setmethods__',{}))
    __setattr__ = lambda self, name, value: _swig_setattr(self, PersistentObject, name, value)
    __swig_getmethods__ = {}
    for _s in [Object]: __swig_getmethods__.update(getattr(_s,'__swig_getmethods__',{}))
    __getattr__ = lambda self, name: _swig_getattr(self, PersistentObject, name)
    def __init__(self, *args, **kwargs): raise AttributeError, "No constructor defined"
    __repr__ = _swig_repr
00620     def GetClassName(*args):
        """GetClassName() -> String"""
        return _ot.PersistentObject_GetClassName(*args)

    if _newclass:GetClassName = staticmethod(GetClassName)
    __swig_getmethods__["GetClassName"] = lambda x: GetClassName
00626     def getClassName(*args):
        """getClassName(self) -> String"""
        return _ot.PersistentObject_getClassName(*args)

00630     def clone(*args):
        """clone(self) -> PersistentObject"""
        return _ot.PersistentObject_clone(*args)

    __swig_destroy__ = _ot.delete_PersistentObject
    __del__ = lambda self : None;
00636     def __eq__(*args):
        """__eq__(self, PersistentObject other) -> Bool"""
        return _ot.PersistentObject___eq__(*args)

00640     def Is(*args):
        """Is(self, PersistentObject other) -> Bool"""
        return _ot.PersistentObject_Is(*args)

00644     def str(*args):
        """str(self) -> String"""
        return _ot.PersistentObject_str(*args)

00648     def getId(*args):
        """getId(self) -> Id"""
        return _ot.PersistentObject_getId(*args)

00652     def setShadowedId(*args):
        """setShadowedId(self, Id id)"""
        return _ot.PersistentObject_setShadowedId(*args)

00656     def getShadowedId(*args):
        """getShadowedId(self) -> Id"""
        return _ot.PersistentObject_getShadowedId(*args)

00660     def setVisibility(*args):
        """setVisibility(self, Bool visible)"""
        return _ot.PersistentObject_setVisibility(*args)

00664     def getVisibility(*args):
        """getVisibility(self) -> Bool"""
        return _ot.PersistentObject_getVisibility(*args)

00668     def getName(*args):
        """getName(self) -> String"""
        return _ot.PersistentObject_getName(*args)

00672     def setName(*args):
        """setName(self, String name)"""
        return _ot.PersistentObject_setName(*args)

00676     def save(*args):
        """
        save(self, StorageManager mgr, bool fromStudy=False)
        save(self, StorageManager mgr)
        save(self, OpenTURNS::Base::Common::StorageManager::Advocate adv)
        """
        return _ot.PersistentObject_save(*args)

00684     def load(*args):
        """load(self, OpenTURNS::Base::Common::StorageManager::Advocate adv)"""
        return _ot.PersistentObject_load(*args)

PersistentObject_swigregister = _ot.PersistentObject_swigregister
PersistentObject_swigregister(PersistentObject)
cvar = _ot.cvar
DefaultName = cvar.DefaultName

def PersistentObject_GetClassName(*args):
  """PersistentObject_GetClassName() -> String"""
  return _ot.PersistentObject_GetClassName(*args)

00697 class dynamic_cast_tag(_object):
    """Proxy of C++ dynamic_cast_tag class"""
    __swig_setmethods__ = {}
    __setattr__ = lambda self, name, value: _swig_setattr(self, dynamic_cast_tag, name, value)
    __swig_getmethods__ = {}
    __getattr__ = lambda self, name: _swig_getattr(self, dynamic_cast_tag, name)
    __repr__ = _swig_repr
00704     def __init__(self, *args): 
        """__init__(self) -> dynamic_cast_tag"""
        this = _ot.new_dynamic_cast_tag(*args)
        try: self.this.append(this)
        except: self.this = this
    __swig_destroy__ = _ot.delete_dynamic_cast_tag
    __del__ = lambda self : None;
dynamic_cast_tag_swigregister = _ot.dynamic_cast_tag_swigregister
dynamic_cast_tag_swigregister(dynamic_cast_tag)

00714 class InterfaceObject(Object):
    """Proxy of C++ InterfaceObject class"""
    __swig_setmethods__ = {}
    for _s in [Object]: __swig_setmethods__.update(getattr(_s,'__swig_setmethods__',{}))
    __setattr__ = lambda self, name, value: _swig_setattr(self, InterfaceObject, name, value)
    __swig_getmethods__ = {}
    for _s in [Object]: __swig_getmethods__.update(getattr(_s,'__swig_getmethods__',{}))
    __getattr__ = lambda self, name: _swig_getattr(self, InterfaceObject, name)
    def __init__(self, *args, **kwargs): raise AttributeError, "No constructor defined"
    __repr__ = _swig_repr
00724     def GetClassName(*args):
        """GetClassName() -> String"""
        return _ot.InterfaceObject_GetClassName(*args)

    if _newclass:GetClassName = staticmethod(GetClassName)
    __swig_getmethods__["GetClassName"] = lambda x: GetClassName
00730     def getClassName(*args):
        """getClassName(self) -> String"""
        return _ot.InterfaceObject_getClassName(*args)

    __swig_destroy__ = _ot.delete_InterfaceObject
    __del__ = lambda self : None;
00736     def str(*args):
        """str(self) -> String"""
        return _ot.InterfaceObject_str(*args)

00740     def getImplementationAsPersistentObject(*args):
        """getImplementationAsPersistentObject(self) -> ImplementationAsPersistentObject"""
        return _ot.InterfaceObject_getImplementationAsPersistentObject(*args)

00744     def setImplementationAsPersistentObject(*args):
        """setImplementationAsPersistentObject(self, ImplementationAsPersistentObject obj)"""
        return _ot.InterfaceObject_setImplementationAsPersistentObject(*args)

00748     def getId(*args):
        """getId(self) -> Id"""
        return _ot.InterfaceObject_getId(*args)

00752     def setName(*args):
        """setName(self, String name)"""
        return _ot.InterfaceObject_setName(*args)

00756     def getName(*args):
        """getName(self) -> String"""
        return _ot.InterfaceObject_getName(*args)

00760     def save(*args):
        """save(self, StorageManager mgr)"""
        return _ot.InterfaceObject_save(*args)

InterfaceObject_swigregister = _ot.InterfaceObject_swigregister
InterfaceObject_swigregister(InterfaceObject)

def InterfaceObject_GetClassName(*args):
  """InterfaceObject_GetClassName() -> String"""
  return _ot.InterfaceObject_GetClassName(*args)

00771 class Study(Object):
    """Proxy of C++ Study class"""
    __swig_setmethods__ = {}
    for _s in [Object]: __swig_setmethods__.update(getattr(_s,'__swig_setmethods__',{}))
    __setattr__ = lambda self, name, value: _swig_setattr(self, Study, name, value)
    __swig_getmethods__ = {}
    for _s in [Object]: __swig_getmethods__.update(getattr(_s,'__swig_getmethods__',{}))
    __getattr__ = lambda self, name: _swig_getattr(self, Study, name)
    __repr__ = _swig_repr
00780     def GetClassName(*args):
        """GetClassName() -> String"""
        return _ot.Study_GetClassName(*args)

    if _newclass:GetClassName = staticmethod(GetClassName)
    __swig_getmethods__["GetClassName"] = lambda x: GetClassName
00786     def getClassName(*args):
        """getClassName(self) -> String"""
        return _ot.Study_getClassName(*args)

    MAINMAP = _ot.Study_MAINMAP
    GUIMAP = _ot.Study_GUIMAP
    TUIMAP = _ot.Study_TUIMAP
    LAST = _ot.Study_LAST
00794     def str(*args):
        """str(self) -> String"""
        return _ot.Study_str(*args)

00798     def save(*args):
        """save(self)"""
        return _ot.Study_save(*args)

00802     def load(*args):
        """load(self)"""
        return _ot.Study_load(*args)

00806     def setStorageManager(*args):
        """setStorageManager(self, StorageManager smgr)"""
        return _ot.Study_setStorageManager(*args)

00810     def getStorageManager(*args):
        """getStorageManager(self) -> StorageManagerImplementation"""
        return _ot.Study_getStorageManager(*args)

00814     def add(*args):
        """
        add(self, InterfaceObject io, Map map=MAINMAP)
        add(self, InterfaceObject io)
        add(self, PersistentObject po, Map map=MAINMAP)
        add(self, PersistentObject po)
        """
        return _ot.Study_add(*args)

00823     def remove(*args):
        """
        remove(self, InterfaceObject io, Map map=MAINMAP)
        remove(self, InterfaceObject io)
        """
        return _ot.Study_remove(*args)

00830     def hasObject(*args):
        """hasObject(self, Id id) -> Bool"""
        return _ot.Study_hasObject(*args)

00834     def getObject(*args):
        """getObject(self, Id id) -> MapElement"""
        return _ot.Study_getObject(*args)

00838     def fillObject(*args):
        """
        fillObject(self, PersistentObject po, String name)
        fillObject(self, InterfaceObject io, String name)
        fillObject(self, PersistentObject po, Id id)
        fillObject(self, InterfaceObject io, Id id)
        """
        return _ot.Study_fillObject(*args)

00847     def __str__(*args):
        """__str__(self) -> String"""
        return _ot.Study___str__(*args)

00851     def __init__(self, *args): 
        """
        __init__(self) -> Study
        __init__(self, Study other) -> Study
        """
        this = _ot.new_Study(*args)
        try: self.this.append(this)
        except: self.this = this
    __swig_destroy__ = _ot.delete_Study
    __del__ = lambda self : None;
Study_swigregister = _ot.Study_swigregister
Study_swigregister(Study)

def Study_GetClassName(*args):
  """Study_GetClassName() -> String"""
  return _ot.Study_GetClassName(*args)

00868 class StorageManager(Object):
    """Proxy of C++ StorageManager class"""
    __swig_setmethods__ = {}
    for _s in [Object]: __swig_setmethods__.update(getattr(_s,'__swig_setmethods__',{}))
    __setattr__ = lambda self, name, value: _swig_setattr(self, StorageManager, name, value)
    __swig_getmethods__ = {}
    for _s in [Object]: __swig_getmethods__.update(getattr(_s,'__swig_getmethods__',{}))
    __getattr__ = lambda self, name: _swig_getattr(self, StorageManager, name)
    __repr__ = _swig_repr
00877     def GetClassName(*args):
        """GetClassName() -> String"""
        return _ot.StorageManager_GetClassName(*args)

    if _newclass:GetClassName = staticmethod(GetClassName)
    __swig_getmethods__["GetClassName"] = lambda x: GetClassName
00883     def getClassName(*args):
        """getClassName(self) -> String"""
        return _ot.StorageManager_getClassName(*args)

    SAVE = _ot.StorageManager_SAVE
    LOAD = _ot.StorageManager_LOAD
    ObjectEntity = _ot.StorageManager_ObjectEntity
    NumericalScalarEntity = _ot.StorageManager_NumericalScalarEntity
    NumericalComplexEntity = _ot.StorageManager_NumericalComplexEntity
    StringEntity = _ot.StorageManager_StringEntity
    UnsignedLongEntity = _ot.StorageManager_UnsignedLongEntity
    BoolEntity = _ot.StorageManager_BoolEntity
    EntityNameEnumSize = _ot.StorageManager_EntityNameEnumSize
    IdAttribute = _ot.StorageManager_IdAttribute
    ClassAttribute = _ot.StorageManager_ClassAttribute
    NameAttribute = _ot.StorageManager_NameAttribute
    SizeAttribute = _ot.StorageManager_SizeAttribute
    DimensionAttribute = _ot.StorageManager_DimensionAttribute
    IndexAttribute = _ot.StorageManager_IndexAttribute
    StudyVisibleAttribute = _ot.StorageManager_StudyVisibleAttribute
    MemberNameAttribute = _ot.StorageManager_MemberNameAttribute
    VersionAttribute = _ot.StorageManager_VersionAttribute
    KeyAttribute = _ot.StorageManager_KeyAttribute
    ValueAttribute = _ot.StorageManager_ValueAttribute
    MaxSizeAttribute = _ot.StorageManager_MaxSizeAttribute
    AttributeNameEnumSize = _ot.StorageManager_AttributeNameEnumSize
00909     def __init__(self, *args): 
        """
        __init__(self, UnsignedLong defaultVersion=1) -> StorageManager
        __init__(self) -> StorageManager
        """
        this = _ot.new_StorageManager(*args)
        try: self.this.append(this)
        except: self.this = this
00917     def clone(*args):
        """clone(self) -> StorageManager"""
        return _ot.StorageManager_clone(*args)

00921     def str(*args):
        """str(self) -> String"""
        return _ot.StorageManager_str(*args)

00925     def save(*args):
        """
        save(self, PersistentObject obj, bool fromStudy=False)
        save(self, PersistentObject obj)
        """
        return _ot.StorageManager_save(*args)

00932     def load(*args):
        """load(self, Study study)"""
        return _ot.StorageManager_load(*args)

00936     def getStudy(*args):
        """getStudy(self) -> Study"""
        return _ot.StorageManager_getStudy(*args)

00940     def setStudy(*args):
        """setStudy(self, Study p_study)"""
        return _ot.StorageManager_setStudy(*args)

00944     def getDefaultStudyVersion(*args):
        """getDefaultStudyVersion(self) -> UnsignedLong"""
        return _ot.StorageManager_getDefaultStudyVersion(*args)

00948     def getStudyVersion(*args):
        """getStudyVersion(self) -> UnsignedLong"""
        return _ot.StorageManager_getStudyVersion(*args)

00952     def setStudyVersion(*args):
        """setStudyVersion(self, UnsignedLong version)"""
        return _ot.StorageManager_setStudyVersion(*args)

00956     def initialize(*args):
        """initialize(self, MethodCall caller)"""
        return _ot.StorageManager_initialize(*args)

00960     def finalize(*args):
        """finalize(self, MethodCall caller)"""
        return _ot.StorageManager_finalize(*args)

00964     def read(*args):
        """read(self)"""
        return _ot.StorageManager_read(*args)

00968     def write(*args):
        """write(self)"""
        return _ot.StorageManager_write(*args)

00972     def getEntityString(*args):
        """getEntityString(self, EntityName entity) -> String"""
        return _ot.StorageManager_getEntityString(*args)

00976     def getAttributeString(*args):
        """getAttributeString(self, AttributeName attribute) -> String"""
        return _ot.StorageManager_getAttributeString(*args)

00980     def isSavedObject(*args):
        """isSavedObject(self, Id id) -> Bool"""
        return _ot.StorageManager_isSavedObject(*args)

00984     def markObjectAsSaved(*args):
        """markObjectAsSaved(self, Id id)"""
        return _ot.StorageManager_markObjectAsSaved(*args)

    __swig_destroy__ = _ot.delete_StorageManager
    __del__ = lambda self : None;
StorageManager_swigregister = _ot.StorageManager_swigregister
StorageManager_swigregister(StorageManager)

def StorageManager_GetClassName(*args):
  """StorageManager_GetClassName() -> String"""
  return _ot.StorageManager_GetClassName(*args)

00997 class XMLStorageManager(StorageManager):
    """Proxy of C++ XMLStorageManager class"""
    __swig_setmethods__ = {}
    for _s in [StorageManager]: __swig_setmethods__.update(getattr(_s,'__swig_setmethods__',{}))
    __setattr__ = lambda self, name, value: _swig_setattr(self, XMLStorageManager, name, value)
    __swig_getmethods__ = {}
    for _s in [StorageManager]: __swig_getmethods__.update(getattr(_s,'__swig_getmethods__',{}))
    __getattr__ = lambda self, name: _swig_getattr(self, XMLStorageManager, name)
    __repr__ = _swig_repr
01006     def GetClassName(*args):
        """GetClassName() -> String"""
        return _ot.XMLStorageManager_GetClassName(*args)

    if _newclass:GetClassName = staticmethod(GetClassName)
    __swig_getmethods__["GetClassName"] = lambda x: GetClassName
01012     def getClassName(*args):
        """getClassName(self) -> String"""
        return _ot.XMLStorageManager_getClassName(*args)

01016     def __init__(self, *args): 
        """__init__(self, FileName filename) -> XMLStorageManager"""
        this = _ot.new_XMLStorageManager(*args)
        try: self.this.append(this)
        except: self.this = this
01021     def clone(*args):
        """clone(self) -> XMLStorageManager"""
        return _ot.XMLStorageManager_clone(*args)

01025     def str(*args):
        """str(self) -> String"""
        return _ot.XMLStorageManager_str(*args)

01029     def getFileName(*args):
        """getFileName(self) -> String"""
        return _ot.XMLStorageManager_getFileName(*args)

01033     def setFileName(*args):
        """setFileName(self, String fileName)"""
        return _ot.XMLStorageManager_setFileName(*args)

01037     def save(*args):
        """
        save(self, PersistentObject obj, bool fromStudy=False)
        save(self, PersistentObject obj)
        """
        return _ot.XMLStorageManager_save(*args)

01044     def load(*args):
        """load(self, Study study)"""
        return _ot.XMLStorageManager_load(*args)

01048     def initialize(*args):
        """initialize(self, MethodCall caller)"""
        return _ot.XMLStorageManager_initialize(*args)

01052     def finalize(*args):
        """finalize(self, MethodCall caller)"""
        return _ot.XMLStorageManager_finalize(*args)

01056     def read(*args):
        """read(self)"""
        return _ot.XMLStorageManager_read(*args)

01060     def write(*args):
        """write(self)"""
        return _ot.XMLStorageManager_write(*args)

    __swig_destroy__ = _ot.delete_XMLStorageManager
    __del__ = lambda self : None;
XMLStorageManager_swigregister = _ot.XMLStorageManager_swigregister
XMLStorageManager_swigregister(XMLStorageManager)

def XMLStorageManager_GetClassName(*args):
  """XMLStorageManager_GetClassName() -> String"""
  return _ot.XMLStorageManager_GetClassName(*args)

01073 class Log(_object):
    """Proxy of C++ Log class"""
    __swig_setmethods__ = {}
    __setattr__ = lambda self, name, value: _swig_setattr(self, Log, name, value)
    __swig_getmethods__ = {}
    __getattr__ = lambda self, name: _swig_getattr(self, Log, name)
    __repr__ = _swig_repr
01080     def Debug(*args):
        """Debug(String msg)"""
        return _ot.Log_Debug(*args)

    if _newclass:Debug = staticmethod(Debug)
    __swig_getmethods__["Debug"] = lambda x: Debug
01086     def Wrapper(*args):
        """Wrapper(String msg)"""
        return _ot.Log_Wrapper(*args)

    if _newclass:Wrapper = staticmethod(Wrapper)
    __swig_getmethods__["Wrapper"] = lambda x: Wrapper
01092     def Info(*args):
        """Info(String msg)"""
        return _ot.Log_Info(*args)

    if _newclass:Info = staticmethod(Info)
    __swig_getmethods__["Info"] = lambda x: Info
01098     def User(*args):
        """User(String msg)"""
        return _ot.Log_User(*args)

    if _newclass:User = staticmethod(User)
    __swig_getmethods__["User"] = lambda x: User
01104     def Warn(*args):
        """Warn(String msg)"""
        return _ot.Log_Warn(*args)

    if _newclass:Warn = staticmethod(Warn)
    __swig_getmethods__["Warn"] = lambda x: Warn
01110     def Error(*args):
        """Error(String msg)"""
        return _ot.Log_Error(*args)

    if _newclass:Error = staticmethod(Error)
    __swig_getmethods__["Error"] = lambda x: Error
01116     def SetFile(*args):
        """SetFile(FileName file)"""
        return _ot.Log_SetFile(*args)

    if _newclass:SetFile = staticmethod(SetFile)
    __swig_getmethods__["SetFile"] = lambda x: SetFile
01122     def Show(*args):
        """Show(Severity flags)"""
        return _ot.Log_Show(*args)

    if _newclass:Show = staticmethod(Show)
    __swig_getmethods__["Show"] = lambda x: Show
01128     def Flags(*args):
        """Flags() -> Severity"""
        return _ot.Log_Flags(*args)

    if _newclass:Flags = staticmethod(Flags)
    __swig_getmethods__["Flags"] = lambda x: Flags
    __swig_destroy__ = _ot.delete_Log
    __del__ = lambda self : None;
01136     def __init__(self, *args): 
        """__init__(self, Log other) -> Log"""
        this = _ot.new_Log(*args)
        try: self.this.append(this)
        except: self.this = this
Log_swigregister = _ot.Log_swigregister
Log_swigregister(Log)
Log.DBG = _ot.cvar.Log_DBG
Log.WRAPPER = _ot.cvar.Log_WRAPPER
Log.INFO = _ot.cvar.Log_INFO
Log.USER = _ot.cvar.Log_USER
Log.WARN = _ot.cvar.Log_WARN
Log.ERROR = _ot.cvar.Log_ERROR
Log.NONE = _ot.cvar.Log_NONE
Log.ALL = _ot.cvar.Log_ALL

def Log_Debug(*args):
  """Log_Debug(String msg)"""
  return _ot.Log_Debug(*args)

def Log_Wrapper(*args):
  """Log_Wrapper(String msg)"""
  return _ot.Log_Wrapper(*args)

def Log_Info(*args):
  """Log_Info(String msg)"""
  return _ot.Log_Info(*args)

def Log_User(*args):
  """Log_User(String msg)"""
  return _ot.Log_User(*args)

def Log_Warn(*args):
  """Log_Warn(String msg)"""
  return _ot.Log_Warn(*args)

def Log_Error(*args):
  """Log_Error(String msg)"""
  return _ot.Log_Error(*args)

def Log_SetFile(*args):
  """Log_SetFile(FileName file)"""
  return _ot.Log_SetFile(*args)

def Log_Show(*args):
  """Log_Show(Severity flags)"""
  return _ot.Log_Show(*args)

def Log_Flags(*args):
  """Log_Flags() -> Severity"""
  return _ot.Log_Flags(*args)

01188 class StringStringMap(_object):
    """Proxy of C++ StringStringMap class"""
    __swig_setmethods__ = {}
    __setattr__ = lambda self, name, value: _swig_setattr(self, StringStringMap, name, value)
    __swig_getmethods__ = {}
    __getattr__ = lambda self, name: _swig_getattr(self, StringStringMap, name)
    __repr__ = _swig_repr
01195     def iterator(*args):
        """iterator(self, PyObject PYTHON_SELF) -> PySwigIterator"""
        return _ot.StringStringMap_iterator(*args)

    def __iter__(self): return self.iterator()
01200     def __nonzero__(*args):
        """__nonzero__(self) -> bool"""
        return _ot.StringStringMap___nonzero__(*args)

01204     def __len__(*args):
        """__len__(self) -> std::map<(std::string,std::string)>::size_type"""
        return _ot.StringStringMap___len__(*args)

01208     def __getitem__(*args):
        """__getitem__(self, std::map<(std::string,std::string)>::key_type key) -> std::map<(std::string,std::string)>::mapped_type"""
        return _ot.StringStringMap___getitem__(*args)

01212     def __delitem__(*args):
        """__delitem__(self, std::map<(std::string,std::string)>::key_type key)"""
        return _ot.StringStringMap___delitem__(*args)

01216     def has_key(*args):
        """has_key(self, std::map<(std::string,std::string)>::key_type key) -> bool"""
        return _ot.StringStringMap_has_key(*args)

01220     def keys(*args):
        """keys(self) -> PyObject"""
        return _ot.StringStringMap_keys(*args)

01224     def values(*args):
        """values(self) -> PyObject"""
        return _ot.StringStringMap_values(*args)

01228     def items(*args):
        """items(self) -> PyObject"""
        return _ot.StringStringMap_items(*args)

01232     def __contains__(*args):
        """__contains__(self, std::map<(std::string,std::string)>::key_type key) -> bool"""
        return _ot.StringStringMap___contains__(*args)

01236     def key_iterator(*args):
        """key_iterator(self, PyObject PYTHON_SELF) -> PySwigIterator"""
        return _ot.StringStringMap_key_iterator(*args)

01240     def value_iterator(*args):
        """value_iterator(self, PyObject PYTHON_SELF) -> PySwigIterator"""
        return _ot.StringStringMap_value_iterator(*args)

    def __iter__(self): return self.key_iterator()
    def iterkeys(self): return self.key_iterator()
    def itervalues(self): return self.value_iterator()
    def iteritems(self): return self.iterator()
01248     def __setitem__(*args):
        """
        __setitem__(self, std::map<(std::string,std::string)>::key_type key, 
            std::map<(std::string,std::string)>::mapped_type x)
        """
        return _ot.StringStringMap___setitem__(*args)

01255     def __init__(self, *args): 
        """
        __init__(self, std::less<(std::string)> ?) -> StringStringMap
        __init__(self) -> StringStringMap
        __init__(self, StringStringMap ?) -> StringStringMap
        """
        this = _ot.new_StringStringMap(*args)
        try: self.this.append(this)
        except: self.this = this
01264     def empty(*args):
        """empty(self) -> bool"""
        return _ot.StringStringMap_empty(*args)

01268     def size(*args):
        """size(self) -> std::map<(std::string,std::string)>::size_type"""
        return _ot.StringStringMap_size(*args)

01272     def clear(*args):
        """clear(self)"""
        return _ot.StringStringMap_clear(*args)

01276     def swap(*args):
        """swap(self, StringStringMap v)"""
        return _ot.StringStringMap_swap(*args)

01280     def get_allocator(*args):
        """get_allocator(self) -> std::map<(std::string,std::string)>::allocator_type"""
        return _ot.StringStringMap_get_allocator(*args)

01284     def begin(*args):
        """begin(self) -> std::map<(std::string,std::string)>::const_iterator"""
        return _ot.StringStringMap_begin(*args)

01288     def end(*args):
        """end(self) -> std::map<(std::string,std::string)>::const_iterator"""
        return _ot.StringStringMap_end(*args)

01292     def rbegin(*args):
        """rbegin(self) -> std::map<(std::string,std::string)>::const_reverse_iterator"""
        return _ot.StringStringMap_rbegin(*args)

01296     def rend(*args):
        """rend(self) -> std::map<(std::string,std::string)>::const_reverse_iterator"""
        return _ot.StringStringMap_rend(*args)

01300     def count(*args):
        """count(self, std::map<(std::string,std::string)>::key_type x) -> std::map<(std::string,std::string)>::size_type"""
        return _ot.StringStringMap_count(*args)

01304     def erase(*args):
        """
        erase(self, std::map<(std::string,std::string)>::key_type x) -> std::map<(std::string,std::string)>::size_type
        erase(self, std::map<(std::string,std::string)>::iterator position)
        erase(self, std::map<(std::string,std::string)>::iterator first, 
            std::map<(std::string,std::string)>::iterator last)
        """
        return _ot.StringStringMap_erase(*args)

01313     def find(*args):
        """find(self, std::map<(std::string,std::string)>::key_type x) -> std::map<(std::string,std::string)>::iterator"""
        return _ot.StringStringMap_find(*args)

01317     def lower_bound(*args):
        """lower_bound(self, std::map<(std::string,std::string)>::key_type x) -> std::map<(std::string,std::string)>::iterator"""
        return _ot.StringStringMap_lower_bound(*args)

01321     def upper_bound(*args):
        """upper_bound(self, std::map<(std::string,std::string)>::key_type x) -> std::map<(std::string,std::string)>::iterator"""
        return _ot.StringStringMap_upper_bound(*args)

    __swig_destroy__ = _ot.delete_StringStringMap
    __del__ = lambda self : None;
StringStringMap_swigregister = _ot.StringStringMap_swigregister
StringStringMap_swigregister(StringStringMap)

01330 class ResourceMap(StringStringMap):
    """Proxy of C++ ResourceMap class"""
    __swig_setmethods__ = {}
    for _s in [StringStringMap]: __swig_setmethods__.update(getattr(_s,'__swig_setmethods__',{}))
    __setattr__ = lambda self, name, value: _swig_setattr(self, ResourceMap, name, value)
    __swig_getmethods__ = {}
    for _s in [StringStringMap]: __swig_getmethods__.update(getattr(_s,'__swig_getmethods__',{}))
    __getattr__ = lambda self, name: _swig_getattr(self, ResourceMap, name)
    __repr__ = _swig_repr
01339     def GetInstance(*args):
        """GetInstance() -> ResourceMap"""
        return _ot.ResourceMap_GetInstance(*args)

    if _newclass:GetInstance = staticmethod(GetInstance)
    __swig_getmethods__["GetInstance"] = lambda x: GetInstance
    __swig_setmethods__["P_instance_"] = _ot.ResourceMap_P_instance__set
    __swig_getmethods__["P_instance_"] = _ot.ResourceMap_P_instance__get
    if _newclass:P_instance_ = _swig_property(_ot.ResourceMap_P_instance__get, _ot.ResourceMap_P_instance__set)
01348     def get(*args):
        """get(self, KeyType key) -> String"""
        return _ot.ResourceMap_get(*args)

01352     def set(*args):
        """set(self, KeyType key, MappedType value)"""
        return _ot.ResourceMap_set(*args)

01356     def str(*args):
        """str(self) -> String"""
        return _ot.ResourceMap_str(*args)

01360     def __str__(*args):
        """__str__(self) -> String"""
        return _ot.ResourceMap___str__(*args)

01364     def __init__(self, *args): 
        """__init__(self, ResourceMap other) -> ResourceMap"""
        this = _ot.new_ResourceMap(*args)
        try: self.this.append(this)
        except: self.this = this
    __swig_destroy__ = _ot.delete_ResourceMap
    __del__ = lambda self : None;
ResourceMap_swigregister = _ot.ResourceMap_swigregister
ResourceMap_swigregister(ResourceMap)

def ResourceMap_GetInstance(*args):
  """ResourceMap_GetInstance() -> ResourceMap"""
  return _ot.ResourceMap_GetInstance(*args)

01378 class ComparisonOperatorImplementation(PersistentObject):
    """Proxy of C++ ComparisonOperatorImplementation class"""
    __swig_setmethods__ = {}
    for _s in [PersistentObject]: __swig_setmethods__.update(getattr(_s,'__swig_setmethods__',{}))
    __setattr__ = lambda self, name, value: _swig_setattr(self, ComparisonOperatorImplementation, name, value)
    __swig_getmethods__ = {}
    for _s in [PersistentObject]: __swig_getmethods__.update(getattr(_s,'__swig_getmethods__',{}))
    __getattr__ = lambda self, name: _swig_getattr(self, ComparisonOperatorImplementation, name)
    def __init__(self, *args, **kwargs): raise AttributeError, "No constructor defined"
    __repr__ = _swig_repr
01388     def GetClassName(*args):
        """GetClassName() -> String"""
        return _ot.ComparisonOperatorImplementation_GetClassName(*args)

    if _newclass:GetClassName = staticmethod(GetClassName)
    __swig_getmethods__["GetClassName"] = lambda x: GetClassName
01394     def getClassName(*args):
        """getClassName(self) -> String"""
        return _ot.ComparisonOperatorImplementation_getClassName(*args)

01398     def str(*args):
        """str(self) -> String"""
        return _ot.ComparisonOperatorImplementation_str(*args)

01402     def clone(*args):
        """clone(self) -> ComparisonOperatorImplementation"""
        return _ot.ComparisonOperatorImplementation_clone(*args)

01406     def __call__(*args):
        """__call__(self, NumericalScalar a, NumericalScalar b) -> Bool"""
        return _ot.ComparisonOperatorImplementation___call__(*args)

01410     def save(*args):
        """save(self, OpenTURNS::Base::Common::StorageManager::Advocate adv)"""
        return _ot.ComparisonOperatorImplementation_save(*args)

01414     def load(*args):
        """load(self, OpenTURNS::Base::Common::StorageManager::Advocate adv)"""
        return _ot.ComparisonOperatorImplementation_load(*args)

    __swig_destroy__ = _ot.delete_ComparisonOperatorImplementation
    __del__ = lambda self : None;
ComparisonOperatorImplementation_swigregister = _ot.ComparisonOperatorImplementation_swigregister
ComparisonOperatorImplementation_swigregister(ComparisonOperatorImplementation)

def __lshift__(*args):
  """
    __lshift__(std::ostream os, Exception obj) -> std::ostream
    __lshift__(std::ostream os, Object obj) -> std::ostream
    __lshift__(std::ostream os, ResourceMap obj) -> std::ostream
    """
  return _ot.__lshift__(*args)

def ComparisonOperatorImplementation_GetClassName(*args):
  """ComparisonOperatorImplementation_GetClassName() -> String"""
  return _ot.ComparisonOperatorImplementation_GetClassName(*args)

01435 class ComparisonOperatorImplementationTypedInterfaceObject(InterfaceObject):
    """Proxy of C++ ComparisonOperatorImplementationTypedInterfaceObject class"""
    __swig_setmethods__ = {}
    for _s in [InterfaceObject]: __swig_setmethods__.update(getattr(_s,'__swig_setmethods__',{}))
    __setattr__ = lambda self, name, value: _swig_setattr(self, ComparisonOperatorImplementationTypedInterfaceObject, name, value)
    __swig_getmethods__ = {}
    for _s in [InterfaceObject]: __swig_getmethods__.update(getattr(_s,'__swig_getmethods__',{}))
    __getattr__ = lambda self, name: _swig_getattr(self, ComparisonOperatorImplementationTypedInterfaceObject, name)
    __repr__ = _swig_repr
01444     def __init__(self, *args): 
        """
        __init__(self) -> ComparisonOperatorImplementationTypedInterfaceObject
        __init__(self, Implementation impl) -> ComparisonOperatorImplementationTypedInterfaceObject
        """
        this = _ot.new_ComparisonOperatorImplementationTypedInterfaceObject(*args)
        try: self.this.append(this)
        except: self.this = this
01452     def getImplementation(*args):
        """
        getImplementation(self) -> Implementation
        getImplementation(self) -> Implementation
        """
        return _ot.ComparisonOperatorImplementationTypedInterfaceObject_getImplementation(*args)

01459     def getImplementationAsPersistentObject(*args):
        """getImplementationAsPersistentObject(self) -> ImplementationAsPersistentObject"""
        return _ot.ComparisonOperatorImplementationTypedInterfaceObject_getImplementationAsPersistentObject(*args)

01463     def setImplementationAsPersistentObject(*args):
        """setImplementationAsPersistentObject(self, ImplementationAsPersistentObject obj)"""
        return _ot.ComparisonOperatorImplementationTypedInterfaceObject_setImplementationAsPersistentObject(*args)

01467     def swap(*args):
        """swap(self, ComparisonOperatorImplementationTypedInterfaceObject other)"""
        return _ot.ComparisonOperatorImplementationTypedInterfaceObject_swap(*args)

01471     def setName(*args):
        """setName(self, String name)"""
        return _ot.ComparisonOperatorImplementationTypedInterfaceObject_setName(*args)

01475     def getName(*args):
        """getName(self) -> String"""
        return _ot.ComparisonOperatorImplementationTypedInterfaceObject_getName(*args)

    __swig_destroy__ = _ot.delete_ComparisonOperatorImplementationTypedInterfaceObject
    __del__ = lambda self : None;
ComparisonOperatorImplementationTypedInterfaceObject_swigregister = _ot.ComparisonOperatorImplementationTypedInterfaceObject_swigregister
ComparisonOperatorImplementationTypedInterfaceObject_swigregister(ComparisonOperatorImplementationTypedInterfaceObject)

01484 class ComparisonOperator(ComparisonOperatorImplementationTypedInterfaceObject):
    """Proxy of C++ ComparisonOperator class"""
    __swig_setmethods__ = {}
    for _s in [ComparisonOperatorImplementationTypedInterfaceObject]: __swig_setmethods__.update(getattr(_s,'__swig_setmethods__',{}))
    __setattr__ = lambda self, name, value: _swig_setattr(self, ComparisonOperator, name, value)
    __swig_getmethods__ = {}
    for _s in [ComparisonOperatorImplementationTypedInterfaceObject]: __swig_getmethods__.update(getattr(_s,'__swig_getmethods__',{}))
    __getattr__ = lambda self, name: _swig_getattr(self, ComparisonOperator, name)
    __repr__ = _swig_repr
01493     def GetClassName(*args):
        """GetClassName() -> String"""
        return _ot.ComparisonOperator_GetClassName(*args)

    if _newclass:GetClassName = staticmethod(GetClassName)
    __swig_getmethods__["GetClassName"] = lambda x: GetClassName
01499     def getClassName(*args):
        """getClassName(self) -> String"""
        return _ot.ComparisonOperator_getClassName(*args)

01503     def __call__(*args):
        """__call__(self, NumericalScalar a, NumericalScalar b) -> Bool"""
        return _ot.ComparisonOperator___call__(*args)

01507     def compare(*args):
        """compare(self, NumericalScalar a, NumericalScalar b) -> Bool"""
        return _ot.ComparisonOperator_compare(*args)

01511     def __str__(*args):
        """__str__(self) -> String"""
        return _ot.ComparisonOperator___str__(*args)

01515     def __init__(self, *args): 
        """
        __init__(self) -> ComparisonOperator
        __init__(self, ComparisonOperatorImplementation op) -> ComparisonOperator
        __init__(self, ComparisonOperator other) -> ComparisonOperator
        """
        this = _ot.new_ComparisonOperator(*args)
        try: self.this.append(this)
        except: self.this = this
    __swig_destroy__ = _ot.delete_ComparisonOperator
    __del__ = lambda self : None;
ComparisonOperator_swigregister = _ot.ComparisonOperator_swigregister
ComparisonOperator_swigregister(ComparisonOperator)

def ComparisonOperator_GetClassName(*args):
  """ComparisonOperator_GetClassName() -> String"""
  return _ot.ComparisonOperator_GetClassName(*args)

01533 class Equal(ComparisonOperatorImplementation):
    """Proxy of C++ Equal class"""
    __swig_setmethods__ = {}
    for _s in [ComparisonOperatorImplementation]: __swig_setmethods__.update(getattr(_s,'__swig_setmethods__',{}))
    __setattr__ = lambda self, name, value: _swig_setattr(self, Equal, name, value)
    __swig_getmethods__ = {}
    for _s in [ComparisonOperatorImplementation]: __swig_getmethods__.update(getattr(_s,'__swig_getmethods__',{}))
    __getattr__ = lambda self, name: _swig_getattr(self, Equal, name)
    __repr__ = _swig_repr
01542     def GetClassName(*args):
        """GetClassName() -> String"""
        return _ot.Equal_GetClassName(*args)

    if _newclass:GetClassName = staticmethod(GetClassName)
    __swig_getmethods__["GetClassName"] = lambda x: GetClassName
01548     def getClassName(*args):
        """getClassName(self) -> String"""
        return _ot.Equal_getClassName(*args)

01552     def str(*args):
        """str(self) -> String"""
        return _ot.Equal_str(*args)

01556     def clone(*args):
        """clone(self) -> Equal"""
        return _ot.Equal_clone(*args)

01560     def __call__(*args):
        """__call__(self, NumericalScalar a, NumericalScalar b) -> Bool"""
        return _ot.Equal___call__(*args)

01564     def save(*args):
        """save(self, OpenTURNS::Base::Common::StorageManager::Advocate adv)"""
        return _ot.Equal_save(*args)

01568     def load(*args):
        """load(self, OpenTURNS::Base::Common::StorageManager::Advocate adv)"""
        return _ot.Equal_load(*args)

01572     def __str__(*args):
        """__str__(self) -> String"""
        return _ot.Equal___str__(*args)

01576     def __init__(self, *args): 
        """
        __init__(self) -> Equal
        __init__(self, Equal other) -> Equal
        """
        this = _ot.new_Equal(*args)
        try: self.this.append(this)
        except: self.this = this
    __swig_destroy__ = _ot.delete_Equal
    __del__ = lambda self : None;
Equal_swigregister = _ot.Equal_swigregister
Equal_swigregister(Equal)

def Equal_GetClassName(*args):
  """Equal_GetClassName() -> String"""
  return _ot.Equal_GetClassName(*args)

01593 class Greater(ComparisonOperatorImplementation):
    """Proxy of C++ Greater class"""
    __swig_setmethods__ = {}
    for _s in [ComparisonOperatorImplementation]: __swig_setmethods__.update(getattr(_s,'__swig_setmethods__',{}))
    __setattr__ = lambda self, name, value: _swig_setattr(self, Greater, name, value)
    __swig_getmethods__ = {}
    for _s in [ComparisonOperatorImplementation]: __swig_getmethods__.update(getattr(_s,'__swig_getmethods__',{}))
    __getattr__ = lambda self, name: _swig_getattr(self, Greater, name)
    __repr__ = _swig_repr
01602     def GetClassName(*args):
        """GetClassName() -> String"""
        return _ot.Greater_GetClassName(*args)

    if _newclass:GetClassName = staticmethod(GetClassName)
    __swig_getmethods__["GetClassName"] = lambda x: GetClassName
01608     def getClassName(*args):
        """getClassName(self) -> String"""
        return _ot.Greater_getClassName(*args)

01612     def str(*args):
        """str(self) -> String"""
        return _ot.Greater_str(*args)

01616     def clone(*args):
        """clone(self) -> Greater"""
        return _ot.Greater_clone(*args)

01620     def __call__(*args):
        """__call__(self, NumericalScalar a, NumericalScalar b) -> Bool"""
        return _ot.Greater___call__(*args)

01624     def save(*args):
        """save(self, OpenTURNS::Base::Common::StorageManager::Advocate adv)"""
        return _ot.Greater_save(*args)

01628     def load(*args):
        """load(self, OpenTURNS::Base::Common::StorageManager::Advocate adv)"""
        return _ot.Greater_load(*args)

01632     def __str__(*args):
        """__str__(self) -> String"""
        return _ot.Greater___str__(*args)

01636     def __init__(self, *args): 
        """
        __init__(self) -> Greater
        __init__(self, Greater other) -> Greater
        """
        this = _ot.new_Greater(*args)
        try: self.this.append(this)
        except: self.this = this
    __swig_destroy__ = _ot.delete_Greater
    __del__ = lambda self : None;
Greater_swigregister = _ot.Greater_swigregister
Greater_swigregister(Greater)

def Greater_GetClassName(*args):
  """Greater_GetClassName() -> String"""
  return _ot.Greater_GetClassName(*args)

01653 class GreaterOrEqual(ComparisonOperatorImplementation):
    """Proxy of C++ GreaterOrEqual class"""
    __swig_setmethods__ = {}
    for _s in [ComparisonOperatorImplementation]: __swig_setmethods__.update(getattr(_s,'__swig_setmethods__',{}))
    __setattr__ = lambda self, name, value: _swig_setattr(self, GreaterOrEqual, name, value)
    __swig_getmethods__ = {}
    for _s in [ComparisonOperatorImplementation]: __swig_getmethods__.update(getattr(_s,'__swig_getmethods__',{}))
    __getattr__ = lambda self, name: _swig_getattr(self, GreaterOrEqual, name)
    __repr__ = _swig_repr
01662     def GetClassName(*args):
        """GetClassName() -> String"""
        return _ot.GreaterOrEqual_GetClassName(*args)

    if _newclass:GetClassName = staticmethod(GetClassName)
    __swig_getmethods__["GetClassName"] = lambda x: GetClassName
01668     def getClassName(*args):
        """getClassName(self) -> String"""
        return _ot.GreaterOrEqual_getClassName(*args)

01672     def str(*args):
        """str(self) -> String"""
        return _ot.GreaterOrEqual_str(*args)

01676     def clone(*args):
        """clone(self) -> GreaterOrEqual"""
        return _ot.GreaterOrEqual_clone(*args)

01680     def __call__(*args):
        """__call__(self, NumericalScalar a, NumericalScalar b) -> Bool"""
        return _ot.GreaterOrEqual___call__(*args)

01684     def save(*args):
        """save(self, OpenTURNS::Base::Common::StorageManager::Advocate adv)"""
        return _ot.GreaterOrEqual_save(*args)

01688     def load(*args):
        """load(self, OpenTURNS::Base::Common::StorageManager::Advocate adv)"""
        return _ot.GreaterOrEqual_load(*args)

01692     def __str__(*args):
        """__str__(self) -> String"""
        return _ot.GreaterOrEqual___str__(*args)

01696     def __init__(self, *args): 
        """
        __init__(self) -> GreaterOrEqual
        __init__(self, GreaterOrEqual other) -> GreaterOrEqual
        """
        this = _ot.new_GreaterOrEqual(*args)
        try: self.this.append(this)
        except: self.this = this
    __swig_destroy__ = _ot.delete_GreaterOrEqual
    __del__ = lambda self : None;
GreaterOrEqual_swigregister = _ot.GreaterOrEqual_swigregister
GreaterOrEqual_swigregister(GreaterOrEqual)

def GreaterOrEqual_GetClassName(*args):
  """GreaterOrEqual_GetClassName() -> String"""
  return _ot.GreaterOrEqual_GetClassName(*args)

01713 class Less(ComparisonOperatorImplementation):
    """Proxy of C++ Less class"""
    __swig_setmethods__ = {}
    for _s in [ComparisonOperatorImplementation]: __swig_setmethods__.update(getattr(_s,'__swig_setmethods__',{}))
    __setattr__ = lambda self, name, value: _swig_setattr(self, Less, name, value)
    __swig_getmethods__ = {}
    for _s in [ComparisonOperatorImplementation]: __swig_getmethods__.update(getattr(_s,'__swig_getmethods__',{}))
    __getattr__ = lambda self, name: _swig_getattr(self, Less, name)
    __repr__ = _swig_repr
01722     def GetClassName(*args):
        """GetClassName() -> String"""
        return _ot.Less_GetClassName(*args)

    if _newclass:GetClassName = staticmethod(GetClassName)
    __swig_getmethods__["GetClassName"] = lambda x: GetClassName
01728     def getClassName(*args):
        """getClassName(self) -> String"""
        return _ot.Less_getClassName(*args)

01732     def str(*args):
        """str(self) -> String"""
        return _ot.Less_str(*args)

01736     def clone(*args):
        """clone(self) -> Less"""
        return _ot.Less_clone(*args)

01740     def __call__(*args):
        """__call__(self, NumericalScalar a, NumericalScalar b) -> Bool"""
        return _ot.Less___call__(*args)

01744     def save(*args):
        """save(self, OpenTURNS::Base::Common::StorageManager::Advocate adv)"""
        return _ot.Less_save(*args)

01748     def load(*args):
        """load(self, OpenTURNS::Base::Common::StorageManager::Advocate adv)"""
        return _ot.Less_load(*args)

01752     def __str__(*args):
        """__str__(self) -> String"""
        return _ot.Less___str__(*args)

01756     def __init__(self, *args): 
        """
        __init__(self) -> Less
        __init__(self, Less other) -> Less
        """
        this = _ot.new_Less(*args)
        try: self.this.append(this)
        except: self.this = this
    __swig_destroy__ = _ot.delete_Less
    __del__ = lambda self : None;
Less_swigregister = _ot.Less_swigregister
Less_swigregister(Less)

def Less_GetClassName(*args):
  """Less_GetClassName() -> String"""
  return _ot.Less_GetClassName(*args)

01773 class LessOrEqual(ComparisonOperatorImplementation):
    """Proxy of C++ LessOrEqual class"""
    __swig_setmethods__ = {}
    for _s in [ComparisonOperatorImplementation]: __swig_setmethods__.update(getattr(_s,'__swig_setmethods__',{}))
    __setattr__ = lambda self, name, value: _swig_setattr(self, LessOrEqual, name, value)
    __swig_getmethods__ = {}
    for _s in [ComparisonOperatorImplementation]: __swig_getmethods__.update(getattr(_s,'__swig_getmethods__',{}))
    __getattr__ = lambda self, name: _swig_getattr(self, LessOrEqual, name)
    __repr__ = _swig_repr
01782     def GetClassName(*args):
        """GetClassName() -> String"""
        return _ot.LessOrEqual_GetClassName(*args)

    if _newclass:GetClassName = staticmethod(GetClassName)
    __swig_getmethods__["GetClassName"] = lambda x: GetClassName
01788     def getClassName(*args):
        """getClassName(self) -> String"""
        return _ot.LessOrEqual_getClassName(*args)

01792     def str(*args):
        """str(self) -> String"""
        return _ot.LessOrEqual_str(*args)

01796     def clone(*args):
        """clone(self) -> LessOrEqual"""
        return _ot.LessOrEqual_clone(*args)

01800     def __call__(*args):
        """__call__(self, NumericalScalar a, NumericalScalar b) -> Bool"""
        return _ot.LessOrEqual___call__(*args)

01804     def save(*args):
        """save(self, OpenTURNS::Base::Common::StorageManager::Advocate adv)"""
        return _ot.LessOrEqual_save(*args)

01808     def load(*args):
        """load(self, OpenTURNS::Base::Common::StorageManager::Advocate adv)"""
        return _ot.LessOrEqual_load(*args)

01812     def __str__(*args):
        """__str__(self) -> String"""
        return _ot.LessOrEqual___str__(*args)

01816     def __init__(self, *args): 
        """
        __init__(self) -> LessOrEqual
        __init__(self, LessOrEqual other) -> LessOrEqual
        """
        this = _ot.new_LessOrEqual(*args)
        try: self.this.append(this)
        except: self.this = this
    __swig_destroy__ = _ot.delete_LessOrEqual
    __del__ = lambda self : None;
LessOrEqual_swigregister = _ot.LessOrEqual_swigregister
LessOrEqual_swigregister(LessOrEqual)

def LessOrEqual_GetClassName(*args):
  """LessOrEqual_GetClassName() -> String"""
  return _ot.LessOrEqual_GetClassName(*args)

01833 class Threadable(_object):
    """Proxy of C++ Threadable class"""
    __swig_setmethods__ = {}
    __setattr__ = lambda self, name, value: _swig_setattr(self, Threadable, name, value)
    __swig_getmethods__ = {}
    __getattr__ = lambda self, name: _swig_getattr(self, Threadable, name)
    def __init__(self, *args, **kwargs): raise AttributeError, "No constructor defined"
    __repr__ = _swig_repr
    __swig_destroy__ = _ot.delete_Threadable
    __del__ = lambda self : None;
01843     def run(*args):
        """run(self)"""
        return _ot.Threadable_run(*args)

Threadable_swigregister = _ot.Threadable_swigregister
Threadable_swigregister(Threadable)

01850 class PlatformInfo(_object):
    """Proxy of C++ PlatformInfo class"""
    __swig_setmethods__ = {}
    __setattr__ = lambda self, name, value: _swig_setattr(self, PlatformInfo, name, value)
    __swig_getmethods__ = {}
    __getattr__ = lambda self, name: _swig_getattr(self, PlatformInfo, name)
    __repr__ = _swig_repr
01857     def GetVersion(*args):
        """GetVersion() -> String"""
        return _ot.PlatformInfo_GetVersion(*args)

    if _newclass:GetVersion = staticmethod(GetVersion)
    __swig_getmethods__["GetVersion"] = lambda x: GetVersion
01863     def GetName(*args):
        """GetName() -> String"""
        return _ot.PlatformInfo_GetName(*args)

    if _newclass:GetName = staticmethod(GetName)
    __swig_getmethods__["GetName"] = lambda x: GetName
01869     def GetRevision(*args):
        """GetRevision() -> String"""
        return _ot.PlatformInfo_GetRevision(*args)

    if _newclass:GetRevision = staticmethod(GetRevision)
    __swig_getmethods__["GetRevision"] = lambda x: GetRevision
01875     def GetDate(*args):
        """GetDate() -> String"""
        return _ot.PlatformInfo_GetDate(*args)

    if _newclass:GetDate = staticmethod(GetDate)
    __swig_getmethods__["GetDate"] = lambda x: GetDate
01881     def GetId(*args):
        """GetId() -> String"""
        return _ot.PlatformInfo_GetId(*args)

    if _newclass:GetId = staticmethod(GetId)
    __swig_getmethods__["GetId"] = lambda x: GetId
01887     def GetConfigureCommandLine(*args):
        """GetConfigureCommandLine() -> String"""
        return _ot.PlatformInfo_GetConfigureCommandLine(*args)

    if _newclass:GetConfigureCommandLine = staticmethod(GetConfigureCommandLine)
    __swig_getmethods__["GetConfigureCommandLine"] = lambda x: GetConfigureCommandLine
01893     def GetNumericalPrecision(*args):
        """GetNumericalPrecision() -> int"""
        return _ot.PlatformInfo_GetNumericalPrecision(*args)

    if _newclass:GetNumericalPrecision = staticmethod(GetNumericalPrecision)
    __swig_getmethods__["GetNumericalPrecision"] = lambda x: GetNumericalPrecision
01899     def SetNumericalPrecision(*args):
        """SetNumericalPrecision(int precision)"""
        return _ot.PlatformInfo_SetNumericalPrecision(*args)

    if _newclass:SetNumericalPrecision = staticmethod(SetNumericalPrecision)
    __swig_getmethods__["SetNumericalPrecision"] = lambda x: SetNumericalPrecision
    __swig_destroy__ = _ot.delete_PlatformInfo
    __del__ = lambda self : None;
01907     def getVersion(*args):
        """getVersion(self) -> String"""
        return _ot.PlatformInfo_getVersion(*args)

01911     def getName(*args):
        """getName(self) -> String"""
        return _ot.PlatformInfo_getName(*args)

01915     def getRevision(*args):
        """getRevision(self) -> String"""
        return _ot.PlatformInfo_getRevision(*args)

01919     def getDate(*args):
        """getDate(self) -> String"""
        return _ot.PlatformInfo_getDate(*args)

01923     def getId(*args):
        """getId(self) -> String"""
        return _ot.PlatformInfo_getId(*args)

01927     def getConfigureCommandLine(*args):
        """getConfigureCommandLine(self) -> String"""
        return _ot.PlatformInfo_getConfigureCommandLine(*args)

01931     def getNumericalPrecision(*args):
        """getNumericalPrecision(self) -> int"""
        return _ot.PlatformInfo_getNumericalPrecision(*args)

01935     def setNumericalPrecision(*args):
        """setNumericalPrecision(self, int precision)"""
        return _ot.PlatformInfo_setNumericalPrecision(*args)

01939     def str(*args):
        """str(self) -> String"""
        return _ot.PlatformInfo_str(*args)

01943     def __str__(*args):
        """__str__(self) -> String"""
        return _ot.PlatformInfo___str__(*args)

01947     def __init__(self, *args): 
        """
        __init__(self) -> PlatformInfo
        __init__(self, PlatformInfo other) -> PlatformInfo
        """
        this = _ot.new_PlatformInfo(*args)
        try: self.this.append(this)
        except: self.this = this
PlatformInfo_swigregister = _ot.PlatformInfo_swigregister
PlatformInfo_swigregister(PlatformInfo)

def PlatformInfo_GetVersion(*args):
  """PlatformInfo_GetVersion() -> String"""
  return _ot.PlatformInfo_GetVersion(*args)

def PlatformInfo_GetName(*args):
  """PlatformInfo_GetName() -> String"""
  return _ot.PlatformInfo_GetName(*args)

def PlatformInfo_GetRevision(*args):
  """PlatformInfo_GetRevision() -> String"""
  return _ot.PlatformInfo_GetRevision(*args)

def PlatformInfo_GetDate(*args):
  """PlatformInfo_GetDate() -> String"""
  return _ot.PlatformInfo_GetDate(*args)

def PlatformInfo_GetId(*args):
  """PlatformInfo_GetId() -> String"""
  return _ot.PlatformInfo_GetId(*args)

def PlatformInfo_GetConfigureCommandLine(*args):
  """PlatformInfo_GetConfigureCommandLine() -> String"""
  return _ot.PlatformInfo_GetConfigureCommandLine(*args)

def PlatformInfo_GetNumericalPrecision(*args):
  """PlatformInfo_GetNumericalPrecision() -> int"""
  return _ot.PlatformInfo_GetNumericalPrecision(*args)

def PlatformInfo_SetNumericalPrecision(*args):
  """PlatformInfo_SetNumericalPrecision(int precision)"""
  return _ot.PlatformInfo_SetNumericalPrecision(*args)

01990 class UnsignedLongCollection(_object):
    """Proxy of C++ UnsignedLongCollection class"""
    __swig_setmethods__ = {}
    __setattr__ = lambda self, name, value: _swig_setattr(self, UnsignedLongCollection, name, value)
    __swig_getmethods__ = {}
    __getattr__ = lambda self, name: _swig_getattr(self, UnsignedLongCollection, name)
    __repr__ = _swig_repr
01997     def __init__(self, *args): 
        """
        __init__(self) -> UnsignedLongCollection
        __init__(self, UnsignedLong size) -> UnsignedLongCollection
        __init__(self, UnsignedLong size, unsigned long value) -> UnsignedLongCollection
        """
        this = _ot.new_UnsignedLongCollection(*args)
        try: self.this.append(this)
        except: self.this = this
02006     def clear(*args):
        """clear(self)"""
        return _ot.UnsignedLongCollection_clear(*args)

02010     def __str__(*args):
        """__str__(self) -> String"""
        return _ot.UnsignedLongCollection___str__(*args)

02014     def __getitem__(*args):
        """__getitem__(self, UnsignedLong i) -> unsigned long"""
        return _ot.UnsignedLongCollection___getitem__(*args)

02018     def __setitem__(*args):
        """__setitem__(self, UnsignedLong i, unsigned long val)"""
        return _ot.UnsignedLongCollection___setitem__(*args)

02022     def at(*args):
        """
        at(self, UnsignedLong i) -> unsigned long
        at(self, UnsignedLong i) -> unsigned long
        """
        return _ot.UnsignedLongCollection_at(*args)

02029     def add(*args):
        """add(self, unsigned long elt)"""
        return _ot.UnsignedLongCollection_add(*args)

02033     def getSize(*args):
        """getSize(self) -> UnsignedLong"""
        return _ot.UnsignedLongCollection_getSize(*args)

02037     def resize(*args):
        """resize(self, UnsignedLong newSize)"""
        return _ot.UnsignedLongCollection_resize(*args)

02041     def isEmpty(*args):
        """isEmpty(self) -> Bool"""
        return _ot.UnsignedLongCollection_isEmpty(*args)

02045     def str(*args):
        """str(self) -> String"""
        return _ot.UnsignedLongCollection_str(*args)

    __swig_destroy__ = _ot.delete_UnsignedLongCollection
    __del__ = lambda self : None;
UnsignedLongCollection_swigregister = _ot.UnsignedLongCollection_swigregister
UnsignedLongCollection_swigregister(UnsignedLongCollection)

02054 class StringCollection(_object):
    """Proxy of C++ StringCollection class"""
    __swig_setmethods__ = {}
    __setattr__ = lambda self, name, value: _swig_setattr(self, StringCollection, name, value)
    __swig_getmethods__ = {}
    __getattr__ = lambda self, name: _swig_getattr(self, StringCollection, name)
    __repr__ = _swig_repr
02061     def __init__(self, *args): 
        """
        __init__(self) -> StringCollection
        __init__(self, UnsignedLong size) -> StringCollection
        __init__(self, UnsignedLong size, string value) -> StringCollection
        """
        this = _ot.new_StringCollection(*args)
        try: self.this.append(this)
        except: self.this = this
02070     def clear(*args):
        """clear(self)"""
        return _ot.StringCollection_clear(*args)

02074     def __str__(*args):
        """__str__(self) -> String"""
        return _ot.StringCollection___str__(*args)

02078     def __getitem__(*args):
        """__getitem__(self, UnsignedLong i) -> string"""
        return _ot.StringCollection___getitem__(*args)

02082     def __setitem__(*args):
        """__setitem__(self, UnsignedLong i, string val)"""
        return _ot.StringCollection___setitem__(*args)

02086     def at(*args):
        """
        at(self, UnsignedLong i) -> string
        at(self, UnsignedLong i) -> string
        """
        return _ot.StringCollection_at(*args)

02093     def add(*args):
        """add(self, string elt)"""
        return _ot.StringCollection_add(*args)

02097     def getSize(*args):
        """getSize(self) -> UnsignedLong"""
        return _ot.StringCollection_getSize(*args)

02101     def resize(*args):
        """resize(self, UnsignedLong newSize)"""
        return _ot.StringCollection_resize(*args)

02105     def isEmpty(*args):
        """isEmpty(self) -> Bool"""
        return _ot.StringCollection_isEmpty(*args)

02109     def str(*args):
        """str(self) -> String"""
        return _ot.StringCollection_str(*args)

    __swig_destroy__ = _ot.delete_StringCollection
    __del__ = lambda self : None;
StringCollection_swigregister = _ot.StringCollection_swigregister
StringCollection_swigregister(StringCollection)

02118 class StringPersistentCollection(PersistentObject,StringCollection):
    """Proxy of C++ StringPersistentCollection class"""
    __swig_setmethods__ = {}
    for _s in [PersistentObject,StringCollection]: __swig_setmethods__.update(getattr(_s,'__swig_setmethods__',{}))
    __setattr__ = lambda self, name, value: _swig_setattr(self, StringPersistentCollection, name, value)
    __swig_getmethods__ = {}
    for _s in [PersistentObject,StringCollection]: __swig_getmethods__.update(getattr(_s,'__swig_getmethods__',{}))
    __getattr__ = lambda self, name: _swig_getattr(self, StringPersistentCollection, name)
    __repr__ = _swig_repr
02127     def GetClassName(*args):
        """GetClassName() -> String"""
        return _ot.StringPersistentCollection_GetClassName(*args)

    if _newclass:GetClassName = staticmethod(GetClassName)
    __swig_getmethods__["GetClassName"] = lambda x: GetClassName
02133     def getClassName(*args):
        """getClassName(self) -> String"""
        return _ot.StringPersistentCollection_getClassName(*args)

02137     def __init__(self, *args): 
        """
        __init__(self) -> StringPersistentCollection
        __init__(self, StringCollection collection) -> StringPersistentCollection
        __init__(self, UnsignedLong size) -> StringPersistentCollection
        __init__(self, UnsignedLong size, string value) -> StringPersistentCollection
        """
        this = _ot.new_StringPersistentCollection(*args)
        try: self.this.append(this)
        except: self.this = this
02147     def clone(*args):
        """clone(self) -> StringPersistentCollection"""
        return _ot.StringPersistentCollection_clone(*args)

02151     def str(*args):
        """str(self) -> String"""
        return _ot.StringPersistentCollection_str(*args)

02155     def save(*args):
        """save(self, OpenTURNS::Base::Type::PersistentCollection<(std::string)>::StorageManager::Advocate adv)"""
        return _ot.StringPersistentCollection_save(*args)

02159     def load(*args):
        """load(self, OpenTURNS::Base::Type::PersistentCollection<(std::string)>::StorageManager::Advocate adv)"""
        return _ot.StringPersistentCollection_load(*args)

02163     def __str__(*args):
        """__str__(self) -> String"""
        return _ot.StringPersistentCollection___str__(*args)

    __swig_destroy__ = _ot.delete_StringPersistentCollection
    __del__ = lambda self : None;
StringPersistentCollection_swigregister = _ot.StringPersistentCollection_swigregister
StringPersistentCollection_swigregister(StringPersistentCollection)

def StringPersistentCollection_GetClassName(*args):
  """StringPersistentCollection_GetClassName() -> String"""
  return _ot.StringPersistentCollection_GetClassName(*args)

02176 class DescriptionImplementation(StringPersistentCollection):
    """Proxy of C++ DescriptionImplementation class"""
    __swig_setmethods__ = {}
    for _s in [StringPersistentCollection]: __swig_setmethods__.update(getattr(_s,'__swig_setmethods__',{}))
    __setattr__ = lambda self, name, value: _swig_setattr(self, DescriptionImplementation, name, value)
    __swig_getmethods__ = {}
    for _s in [StringPersistentCollection]: __swig_getmethods__.update(getattr(_s,'__swig_getmethods__',{}))
    __getattr__ = lambda self, name: _swig_getattr(self, DescriptionImplementation, name)
    __repr__ = _swig_repr
02185     def GetClassName(*args):
        """GetClassName() -> String"""
        return _ot.DescriptionImplementation_GetClassName(*args)

    if _newclass:GetClassName = staticmethod(GetClassName)
    __swig_getmethods__["GetClassName"] = lambda x: GetClassName
02191     def getClassName(*args):
        """getClassName(self) -> String"""
        return _ot.DescriptionImplementation_getClassName(*args)

02195     def __init__(self, *args): 
        """
        __init__(self) -> DescriptionImplementation
        __init__(self, UnsignedLong size) -> DescriptionImplementation
        __init__(self, String value) -> DescriptionImplementation
        __init__(self, UnsignedLong size, String value) -> DescriptionImplementation
        """
        this = _ot.new_DescriptionImplementation(*args)
        try: self.this.append(this)
        except: self.this = this
02205     def clone(*args):
        """clone(self) -> DescriptionImplementation"""
        return _ot.DescriptionImplementation_clone(*args)

02209     def str(*args):
        """str(self) -> String"""
        return _ot.DescriptionImplementation_str(*args)

02213     def save(*args):
        """save(self, OpenTURNS::Base::Type::DescriptionImplementation::StorageManager::Advocate adv)"""
        return _ot.DescriptionImplementation_save(*args)

02217     def load(*args):
        """load(self, OpenTURNS::Base::Type::DescriptionImplementation::StorageManager::Advocate adv)"""
        return _ot.DescriptionImplementation_load(*args)

    __swig_destroy__ = _ot.delete_DescriptionImplementation
    __del__ = lambda self : None;
DescriptionImplementation_swigregister = _ot.DescriptionImplementation_swigregister
DescriptionImplementation_swigregister(DescriptionImplementation)

def DescriptionImplementation_GetClassName(*args):
  """DescriptionImplementation_GetClassName() -> String"""
  return _ot.DescriptionImplementation_GetClassName(*args)

02230 class DescriptionImplementationTypedInterfaceObject(InterfaceObject):
    """Proxy of C++ DescriptionImplementationTypedInterfaceObject class"""
    __swig_setmethods__ = {}
    for _s in [InterfaceObject]: __swig_setmethods__.update(getattr(_s,'__swig_setmethods__',{}))
    __setattr__ = lambda self, name, value: _swig_setattr(self, DescriptionImplementationTypedInterfaceObject, name, value)
    __swig_getmethods__ = {}
    for _s in [InterfaceObject]: __swig_getmethods__.update(getattr(_s,'__swig_getmethods__',{}))
    __getattr__ = lambda self, name: _swig_getattr(self, DescriptionImplementationTypedInterfaceObject, name)
    __repr__ = _swig_repr
02239     def __init__(self, *args): 
        """
        __init__(self) -> DescriptionImplementationTypedInterfaceObject
        __init__(self, Implementation impl) -> DescriptionImplementationTypedInterfaceObject
        """
        this = _ot.new_DescriptionImplementationTypedInterfaceObject(*args)
        try: self.this.append(this)
        except: self.this = this
02247     def getImplementation(*args):
        """
        getImplementation(self) -> Implementation
        getImplementation(self) -> Implementation
        """
        return _ot.DescriptionImplementationTypedInterfaceObject_getImplementation(*args)

02254     def getImplementationAsPersistentObject(*args):
        """getImplementationAsPersistentObject(self) -> ImplementationAsPersistentObject"""
        return _ot.DescriptionImplementationTypedInterfaceObject_getImplementationAsPersistentObject(*args)

02258     def setImplementationAsPersistentObject(*args):
        """setImplementationAsPersistentObject(self, ImplementationAsPersistentObject obj)"""
        return _ot.DescriptionImplementationTypedInterfaceObject_setImplementationAsPersistentObject(*args)

02262     def swap(*args):
        """swap(self, DescriptionImplementationTypedInterfaceObject other)"""
        return _ot.DescriptionImplementationTypedInterfaceObject_swap(*args)

02266     def setName(*args):
        """setName(self, String name)"""
        return _ot.DescriptionImplementationTypedInterfaceObject_setName(*args)

02270     def getName(*args):
        """getName(self) -> String"""
        return _ot.DescriptionImplementationTypedInterfaceObject_getName(*args)

    __swig_destroy__ = _ot.delete_DescriptionImplementationTypedInterfaceObject
    __del__ = lambda self : None;
DescriptionImplementationTypedInterfaceObject_swigregister = _ot.DescriptionImplementationTypedInterfaceObject_swigregister
DescriptionImplementationTypedInterfaceObject_swigregister(DescriptionImplementationTypedInterfaceObject)

02279 class DescriptionImplementationTypedCollectionInterfaceObject(DescriptionImplementationTypedInterfaceObject):
    """Proxy of C++ DescriptionImplementationTypedCollectionInterfaceObject class"""
    __swig_setmethods__ = {}
    for _s in [DescriptionImplementationTypedInterfaceObject]: __swig_setmethods__.update(getattr(_s,'__swig_setmethods__',{}))
    __setattr__ = lambda self, name, value: _swig_setattr(self, DescriptionImplementationTypedCollectionInterfaceObject, name, value)
    __swig_getmethods__ = {}
    for _s in [DescriptionImplementationTypedInterfaceObject]: __swig_getmethods__.update(getattr(_s,'__swig_getmethods__',{}))
    __getattr__ = lambda self, name: _swig_getattr(self, DescriptionImplementationTypedCollectionInterfaceObject, name)
    __repr__ = _swig_repr
02288     def __init__(self, *args): 
        """
        __init__(self) -> DescriptionImplementationTypedCollectionInterfaceObject
        __init__(self, Implementation impl) -> DescriptionImplementationTypedCollectionInterfaceObject
        """
        this = _ot.new_DescriptionImplementationTypedCollectionInterfaceObject(*args)
        try: self.this.append(this)
        except: self.this = this
02296     def __getitem__(*args):
        """__getitem__(self, UnsignedLong i) -> ImplementationElementType"""
        return _ot.DescriptionImplementationTypedCollectionInterfaceObject___getitem__(*args)

02300     def __setitem__(*args):
        """__setitem__(self, UnsignedLong i, ImplementationElementType val)"""
        return _ot.DescriptionImplementationTypedCollectionInterfaceObject___setitem__(*args)

02304     def add(*args):
        """add(self, ImplementationElementType elt)"""
        return _ot.DescriptionImplementationTypedCollectionInterfaceObject_add(*args)

02308     def getSize(*args):
        """getSize(self) -> UnsignedLong"""
        return _ot.DescriptionImplementationTypedCollectionInterfaceObject_getSize(*args)

02312     def isEmpty(*args):
        """isEmpty(self) -> Bool"""
        return _ot.DescriptionImplementationTypedCollectionInterfaceObject_isEmpty(*args)

02316     def erase(*args):
        """erase(self, UnsignedLong position)"""
        return _ot.DescriptionImplementationTypedCollectionInterfaceObject_erase(*args)

    __swig_destroy__ = _ot.delete_DescriptionImplementationTypedCollectionInterfaceObject
    __del__ = lambda self : None;
DescriptionImplementationTypedCollectionInterfaceObject_swigregister = _ot.DescriptionImplementationTypedCollectionInterfaceObject_swigregister
DescriptionImplementationTypedCollectionInterfaceObject_swigregister(DescriptionImplementationTypedCollectionInterfaceObject)

02325 class Description(DescriptionImplementationTypedCollectionInterfaceObject):
    """Proxy of C++ Description class"""
    __swig_setmethods__ = {}
    for _s in [DescriptionImplementationTypedCollectionInterfaceObject]: __swig_setmethods__.update(getattr(_s,'__swig_setmethods__',{}))
    __setattr__ = lambda self, name, value: _swig_setattr(self, Description, name, value)
    __swig_getmethods__ = {}
    for _s in [DescriptionImplementationTypedCollectionInterfaceObject]: __swig_getmethods__.update(getattr(_s,'__swig_getmethods__',{}))
    __getattr__ = lambda self, name: _swig_getattr(self, Description, name)
    __repr__ = _swig_repr
02334     def GetClassName(*args):
        """GetClassName() -> String"""
        return _ot.Description_GetClassName(*args)

    if _newclass:GetClassName = staticmethod(GetClassName)
    __swig_getmethods__["GetClassName"] = lambda x: GetClassName
02340     def getClassName(*args):
        """getClassName(self) -> String"""
        return _ot.Description_getClassName(*args)

02344     def sort(*args):
        """sort(self)"""
        return _ot.Description_sort(*args)

02348     def __init__(self, *args): 
        """
        __init__(self) -> Description
        __init__(self, UnsignedLong size) -> Description
        __init__(self, String value) -> Description
        __init__(self, UnsignedLong size, String value) -> Description
        __init__(self, DescriptionImplementation implementation) -> Description
        __init__(self, Description other) -> Description
        """
        this = _ot.new_Description(*args)
        try: self.this.append(this)
        except: self.this = this
    __swig_destroy__ = _ot.delete_Description
    __del__ = lambda self : None;
Description_swigregister = _ot.Description_swigregister
Description_swigregister(Description)

def Description_GetClassName(*args):
  """Description_GetClassName() -> String"""
  return _ot.Description_GetClassName(*args)

02369 class NumericalScalarCollection(_object):
    """Proxy of C++ NumericalScalarCollection class"""
    __swig_setmethods__ = {}
    __setattr__ = lambda self, name, value: _swig_setattr(self, NumericalScalarCollection, name, value)
    __swig_getmethods__ = {}
    __getattr__ = lambda self, name: _swig_getattr(self, NumericalScalarCollection, name)
    __repr__ = _swig_repr
02376     def __init__(self, *args): 
        """
        __init__(self) -> NumericalScalarCollection
        __init__(self, UnsignedLong size) -> NumericalScalarCollection
        __init__(self, UnsignedLong size, double value) -> NumericalScalarCollection
        """
        this = _ot.new_NumericalScalarCollection(*args)
        try: self.this.append(this)
        except: self.this = this
02385     def clear(*args):
        """clear(self)"""
        return _ot.NumericalScalarCollection_clear(*args)

02389     def __str__(*args):
        """__str__(self) -> String"""
        return _ot.NumericalScalarCollection___str__(*args)

02393     def __getitem__(*args):
        """__getitem__(self, UnsignedLong i) -> double"""
        return _ot.NumericalScalarCollection___getitem__(*args)

02397     def __setitem__(*args):
        """__setitem__(self, UnsignedLong i, double val)"""
        return _ot.NumericalScalarCollection___setitem__(*args)

02401     def at(*args):
        """
        at(self, UnsignedLong i) -> double
        at(self, UnsignedLong i) -> double
        """
        return _ot.NumericalScalarCollection_at(*args)

02408     def add(*args):
        """add(self, double elt)"""
        return _ot.NumericalScalarCollection_add(*args)

02412     def getSize(*args):
        """getSize(self) -> UnsignedLong"""
        return _ot.NumericalScalarCollection_getSize(*args)

02416     def resize(*args):
        """resize(self, UnsignedLong newSize)"""
        return _ot.NumericalScalarCollection_resize(*args)

02420     def isEmpty(*args):
        """isEmpty(self) -> Bool"""
        return _ot.NumericalScalarCollection_isEmpty(*args)

02424     def str(*args):
        """str(self) -> String"""
        return _ot.NumericalScalarCollection_str(*args)

    __swig_destroy__ = _ot.delete_NumericalScalarCollection
    __del__ = lambda self : None;
NumericalScalarCollection_swigregister = _ot.NumericalScalarCollection_swigregister
NumericalScalarCollection_swigregister(NumericalScalarCollection)

02433 class NumericalScalarPersistentCollection(PersistentObject,NumericalScalarCollection):
    """Proxy of C++ NumericalScalarPersistentCollection class"""
    __swig_setmethods__ = {}
    for _s in [PersistentObject,NumericalScalarCollection]: __swig_setmethods__.update(getattr(_s,'__swig_setmethods__',{}))
    __setattr__ = lambda self, name, value: _swig_setattr(self, NumericalScalarPersistentCollection, name, value)
    __swig_getmethods__ = {}
    for _s in [PersistentObject,NumericalScalarCollection]: __swig_getmethods__.update(getattr(_s,'__swig_getmethods__',{}))
    __getattr__ = lambda self, name: _swig_getattr(self, NumericalScalarPersistentCollection, name)
    __repr__ = _swig_repr
02442     def GetClassName(*args):
        """GetClassName() -> String"""
        return _ot.NumericalScalarPersistentCollection_GetClassName(*args)

    if _newclass:GetClassName = staticmethod(GetClassName)
    __swig_getmethods__["GetClassName"] = lambda x: GetClassName
02448     def getClassName(*args):
        """getClassName(self) -> String"""
        return _ot.NumericalScalarPersistentCollection_getClassName(*args)

02452     def __init__(self, *args): 
        """
        __init__(self) -> NumericalScalarPersistentCollection
        __init__(self, NumericalScalarCollection collection) -> NumericalScalarPersistentCollection
        __init__(self, UnsignedLong size) -> NumericalScalarPersistentCollection
        __init__(self, UnsignedLong size, double value) -> NumericalScalarPersistentCollection
        """
        this = _ot.new_NumericalScalarPersistentCollection(*args)
        try: self.this.append(this)
        except: self.this = this
02462     def clone(*args):
        """clone(self) -> NumericalScalarPersistentCollection"""
        return _ot.NumericalScalarPersistentCollection_clone(*args)

02466     def str(*args):
        """str(self) -> String"""
        return _ot.NumericalScalarPersistentCollection_str(*args)

02470     def save(*args):
        """save(self, OpenTURNS::Base::Type::PersistentCollection<(double)>::StorageManager::Advocate adv)"""
        return _ot.NumericalScalarPersistentCollection_save(*args)

02474     def load(*args):
        """load(self, OpenTURNS::Base::Type::PersistentCollection<(double)>::StorageManager::Advocate adv)"""
        return _ot.NumericalScalarPersistentCollection_load(*args)

02478     def __str__(*args):
        """__str__(self) -> String"""
        return _ot.NumericalScalarPersistentCollection___str__(*args)

    __swig_destroy__ = _ot.delete_NumericalScalarPersistentCollection
    __del__ = lambda self : None;
NumericalScalarPersistentCollection_swigregister = _ot.NumericalScalarPersistentCollection_swigregister
NumericalScalarPersistentCollection_swigregister(NumericalScalarPersistentCollection)

def NumericalScalarPersistentCollection_GetClassName(*args):
  """NumericalScalarPersistentCollection_GetClassName() -> String"""
  return _ot.NumericalScalarPersistentCollection_GetClassName(*args)

02491 class NumericalPointImplementation(NumericalScalarPersistentCollection):
    """Proxy of C++ NumericalPointImplementation class"""
    __swig_setmethods__ = {}
    for _s in [NumericalScalarPersistentCollection]: __swig_setmethods__.update(getattr(_s,'__swig_setmethods__',{}))
    __setattr__ = lambda self, name, value: _swig_setattr(self, NumericalPointImplementation, name, value)
    __swig_getmethods__ = {}
    for _s in [NumericalScalarPersistentCollection]: __swig_getmethods__.update(getattr(_s,'__swig_getmethods__',{}))
    __getattr__ = lambda self, name: _swig_getattr(self, NumericalPointImplementation, name)
    __repr__ = _swig_repr
02500     def GetClassName(*args):
        """GetClassName() -> String"""
        return _ot.NumericalPointImplementation_GetClassName(*args)

    if _newclass:GetClassName = staticmethod(GetClassName)
    __swig_getmethods__["GetClassName"] = lambda x: GetClassName
02506     def getClassName(*args):
        """getClassName(self) -> String"""
        return _ot.NumericalPointImplementation_getClassName(*args)

02510     def clone(*args):
        """clone(self) -> NumericalPointImplementation"""
        return _ot.NumericalPointImplementation_clone(*args)

02514     def setDescription(*args):
        """setDescription(self, Description description)"""
        return _ot.NumericalPointImplementation_setDescription(*args)

02518     def getDescription(*args):
        """getDescription(self) -> Description"""
        return _ot.NumericalPointImplementation_getDescription(*args)

02522     def str(*args):
        """str(self) -> String"""
        return _ot.NumericalPointImplementation_str(*args)

02526     def getDimension(*args):
        """getDimension(self) -> UnsignedLong"""
        return _ot.NumericalPointImplementation_getDimension(*args)

02530     def getSize(*args):
        """getSize(self) -> UnsignedLong"""
        return _ot.NumericalPointImplementation_getSize(*args)

02534     def getCollection(*args):
        """getCollection(self) -> NumericalScalarCollection"""
        return _ot.NumericalPointImplementation_getCollection(*args)

02538     def __add__(*args):
        """__add__(self, NumericalPointImplementation rhs) -> NumericalPointImplementation"""
        return _ot.NumericalPointImplementation___add__(*args)

02542     def __sub__(*args):
        """__sub__(self, NumericalPointImplementation rhs) -> NumericalPointImplementation"""
        return _ot.NumericalPointImplementation___sub__(*args)

02546     def __iadd__(*args):
        """__iadd__(self, NumericalPointImplementation other) -> NumericalPointImplementation"""
        return _ot.NumericalPointImplementation___iadd__(*args)

02550     def __isub__(*args):
        """__isub__(self, NumericalPointImplementation other) -> NumericalPointImplementation"""
        return _ot.NumericalPointImplementation___isub__(*args)

02554     def __mul__(*args):
        """__mul__(self, NumericalScalar scalar) -> NumericalPointImplementation"""
        return _ot.NumericalPointImplementation___mul__(*args)

02558     def __imul__(*args):
        """__imul__(self, NumericalScalar scalar) -> NumericalPointImplementation"""
        return _ot.NumericalPointImplementation___imul__(*args)

02562     def norm(*args):
        """norm(self) -> NumericalScalar"""
        return _ot.NumericalPointImplementation_norm(*args)

02566     def norm2(*args):
        """norm2(self) -> NumericalScalar"""
        return _ot.NumericalPointImplementation_norm2(*args)

02570     def dot(*args):
        """dot(NumericalPointImplementation lhs, NumericalPointImplementation rhs) -> NumericalScalar"""
        return _ot.NumericalPointImplementation_dot(*args)

    if _newclass:dot = staticmethod(dot)
    __swig_getmethods__["dot"] = lambda x: dot
02576     def save(*args):
        """save(self, OpenTURNS::Base::Type::NumericalPointImplementation::StorageManager::Advocate adv)"""
        return _ot.NumericalPointImplementation_save(*args)

02580     def load(*args):
        """load(self, OpenTURNS::Base::Type::NumericalPointImplementation::StorageManager::Advocate adv)"""
        return _ot.NumericalPointImplementation_load(*args)

02584     def __init__(self, *args): 
        """
        __init__(self) -> NumericalPointImplementation
        __init__(self, UnsignedLong size, NumericalScalar value=0.0) -> NumericalPointImplementation
        __init__(self, UnsignedLong size) -> NumericalPointImplementation
        __init__(self, NumericalScalarCollection coll) -> NumericalPointImplementation
        __init__(self, NumericalPointImplementation other) -> NumericalPointImplementation
        """
        this = _ot.new_NumericalPointImplementation(*args)
        try: self.this.append(this)
        except: self.this = this
    __swig_destroy__ = _ot.delete_NumericalPointImplementation
    __del__ = lambda self : None;
NumericalPointImplementation_swigregister = _ot.NumericalPointImplementation_swigregister
NumericalPointImplementation_swigregister(NumericalPointImplementation)

def NumericalPointImplementation_GetClassName(*args):
  """NumericalPointImplementation_GetClassName() -> String"""
  return _ot.NumericalPointImplementation_GetClassName(*args)

def NumericalPointImplementation_dot(*args):
  """NumericalPointImplementation_dot(NumericalPointImplementation lhs, NumericalPointImplementation rhs) -> NumericalScalar"""
  return _ot.NumericalPointImplementation_dot(*args)

02608 class NumericalPointImplementationTypedInterfaceObject(InterfaceObject):
    """Proxy of C++ NumericalPointImplementationTypedInterfaceObject class"""
    __swig_setmethods__ = {}
    for _s in [InterfaceObject]: __swig_setmethods__.update(getattr(_s,'__swig_setmethods__',{}))
    __setattr__ = lambda self, name, value: _swig_setattr(self, NumericalPointImplementationTypedInterfaceObject, name, value)
    __swig_getmethods__ = {}
    for _s in [InterfaceObject]: __swig_getmethods__.update(getattr(_s,'__swig_getmethods__',{}))
    __getattr__ = lambda self, name: _swig_getattr(self, NumericalPointImplementationTypedInterfaceObject, name)
    __repr__ = _swig_repr
02617     def __init__(self, *args): 
        """
        __init__(self) -> NumericalPointImplementationTypedInterfaceObject
        __init__(self, Implementation impl) -> NumericalPointImplementationTypedInterfaceObject
        """
        this = _ot.new_NumericalPointImplementationTypedInterfaceObject(*args)
        try: self.this.append(this)
        except: self.this = this
02625     def getImplementation(*args):
        """
        getImplementation(self) -> Implementation
        getImplementation(self) -> Implementation
        """
        return _ot.NumericalPointImplementationTypedInterfaceObject_getImplementation(*args)

02632     def getImplementationAsPersistentObject(*args):
        """getImplementationAsPersistentObject(self) -> ImplementationAsPersistentObject"""
        return _ot.NumericalPointImplementationTypedInterfaceObject_getImplementationAsPersistentObject(*args)

02636     def setImplementationAsPersistentObject(*args):
        """setImplementationAsPersistentObject(self, ImplementationAsPersistentObject obj)"""
        return _ot.NumericalPointImplementationTypedInterfaceObject_setImplementationAsPersistentObject(*args)

02640     def swap(*args):
        """swap(self, NumericalPointImplementationTypedInterfaceObject other)"""
        return _ot.NumericalPointImplementationTypedInterfaceObject_swap(*args)

02644     def setName(*args):
        """setName(self, String name)"""
        return _ot.NumericalPointImplementationTypedInterfaceObject_setName(*args)

02648     def getName(*args):
        """getName(self) -> String"""
        return _ot.NumericalPointImplementationTypedInterfaceObject_getName(*args)

    __swig_destroy__ = _ot.delete_NumericalPointImplementationTypedInterfaceObject
    __del__ = lambda self : None;
NumericalPointImplementationTypedInterfaceObject_swigregister = _ot.NumericalPointImplementationTypedInterfaceObject_swigregister
NumericalPointImplementationTypedInterfaceObject_swigregister(NumericalPointImplementationTypedInterfaceObject)

02657 class NumericalPointImplementationTypedCollectionInterfaceObject(NumericalPointImplementationTypedInterfaceObject):
    """Proxy of C++ NumericalPointImplementationTypedCollectionInterfaceObject class"""
    __swig_setmethods__ = {}
    for _s in [NumericalPointImplementationTypedInterfaceObject]: __swig_setmethods__.update(getattr(_s,'__swig_setmethods__',{}))
    __setattr__ = lambda self, name, value: _swig_setattr(self, NumericalPointImplementationTypedCollectionInterfaceObject, name, value)
    __swig_getmethods__ = {}
    for _s in [NumericalPointImplementationTypedInterfaceObject]: __swig_getmethods__.update(getattr(_s,'__swig_getmethods__',{}))
    __getattr__ = lambda self, name: _swig_getattr(self, NumericalPointImplementationTypedCollectionInterfaceObject, name)
    __repr__ = _swig_repr
02666     def __init__(self, *args): 
        """
        __init__(self) -> NumericalPointImplementationTypedCollectionInterfaceObject
        __init__(self, Implementation impl) -> NumericalPointImplementationTypedCollectionInterfaceObject
        """
        this = _ot.new_NumericalPointImplementationTypedCollectionInterfaceObject(*args)
        try: self.this.append(this)
        except: self.this = this
02674     def __getitem__(*args):
        """__getitem__(self, UnsignedLong i) -> ImplementationElementType"""
        return _ot.NumericalPointImplementationTypedCollectionInterfaceObject___getitem__(*args)

02678     def __setitem__(*args):
        """__setitem__(self, UnsignedLong i, ImplementationElementType val)"""
        return _ot.NumericalPointImplementationTypedCollectionInterfaceObject___setitem__(*args)

02682     def add(*args):
        """add(self, ImplementationElementType elt)"""
        return _ot.NumericalPointImplementationTypedCollectionInterfaceObject_add(*args)

02686     def getSize(*args):
        """getSize(self) -> UnsignedLong"""
        return _ot.NumericalPointImplementationTypedCollectionInterfaceObject_getSize(*args)

02690     def getDimension(*args):
        """getDimension(self) -> UnsignedLong"""
        return _ot.NumericalPointImplementationTypedCollectionInterfaceObject_getDimension(*args)

02694     def isEmpty(*args):
        """isEmpty(self) -> Bool"""
        return _ot.NumericalPointImplementationTypedCollectionInterfaceObject_isEmpty(*args)

02698     def erase(*args):
        """erase(self, UnsignedLong position)"""
        return _ot.NumericalPointImplementationTypedCollectionInterfaceObject_erase(*args)

    __swig_destroy__ = _ot.delete_NumericalPointImplementationTypedCollectionInterfaceObject
    __del__ = lambda self : None;
NumericalPointImplementationTypedCollectionInterfaceObject_swigregister = _ot.NumericalPointImplementationTypedCollectionInterfaceObject_swigregister
NumericalPointImplementationTypedCollectionInterfaceObject_swigregister(NumericalPointImplementationTypedCollectionInterfaceObject)

02707 class NumericalPoint(NumericalPointImplementationTypedCollectionInterfaceObject):
    """Proxy of C++ NumericalPoint class"""
    __swig_setmethods__ = {}
    for _s in [NumericalPointImplementationTypedCollectionInterfaceObject]: __swig_setmethods__.update(getattr(_s,'__swig_setmethods__',{}))
    __setattr__ = lambda self, name, value: _swig_setattr(self, NumericalPoint, name, value)
    __swig_getmethods__ = {}
    for _s in [NumericalPointImplementationTypedCollectionInterfaceObject]: __swig_getmethods__.update(getattr(_s,'__swig_getmethods__',{}))
    __getattr__ = lambda self, name: _swig_getattr(self, NumericalPoint, name)
    __repr__ = _swig_repr
02716     def GetClassName(*args):
        """GetClassName() -> String"""
        return _ot.NumericalPoint_GetClassName(*args)

    if _newclass:GetClassName = staticmethod(GetClassName)
    __swig_getmethods__["GetClassName"] = lambda x: GetClassName
02722     def getClassName(*args):
        """getClassName(self) -> String"""
        return _ot.NumericalPoint_getClassName(*args)

02726     def getCollection(*args):
        """getCollection(self) -> NumericalScalarCollection"""
        return _ot.NumericalPoint_getCollection(*args)

02730     def str(*args):
        """str(self) -> String"""
        return _ot.NumericalPoint_str(*args)

02734     def __eq__(*args):
        """__eq__(self, NumericalPoint rhs) -> Bool"""
        return _ot.NumericalPoint___eq__(*args)

02738     def __ne__(*args):
        """__ne__(self, NumericalPoint rhs) -> Bool"""
        return _ot.NumericalPoint___ne__(*args)

02742     def __add__(*args):
        """__add__(self, NumericalPoint rhs) -> NumericalPoint"""
        return _ot.NumericalPoint___add__(*args)

02746     def __sub__(*args):
        """__sub__(self, NumericalPoint rhs) -> NumericalPoint"""
        return _ot.NumericalPoint___sub__(*args)

02750     def __iadd__(*args):
        """__iadd__(self, NumericalPoint other) -> NumericalPoint"""
        return _ot.NumericalPoint___iadd__(*args)

02754     def __isub__(*args):
        """__isub__(self, NumericalPoint other) -> NumericalPoint"""
        return _ot.NumericalPoint___isub__(*args)

02758     def __mul__(*args):
        """__mul__(self, NumericalScalar scalar) -> NumericalPoint"""
        return _ot.NumericalPoint___mul__(*args)

02762     def __imul__(*args):
        """__imul__(self, NumericalScalar scalar) -> NumericalPoint"""
        return _ot.NumericalPoint___imul__(*args)

02766     def norm(*args):
        """norm(self) -> NumericalScalar"""
        return _ot.NumericalPoint_norm(*args)

02770     def norm2(*args):
        """norm2(self) -> NumericalScalar"""
        return _ot.NumericalPoint_norm2(*args)

02774     def dot(*args):
        """dot(NumericalPoint lhs, NumericalPoint rhs) -> NumericalScalar"""
        return _ot.NumericalPoint_dot(*args)

    if _newclass:dot = staticmethod(dot)
    __swig_getmethods__["dot"] = lambda x: dot
02780     def __init__(self, *args): 
        """
        __init__(self) -> NumericalPoint
        __init__(self, UnsignedLong size, NumericalScalar value=0.0) -> NumericalPoint
        __init__(self, UnsignedLong size) -> NumericalPoint
        __init__(self, NumericalPointImplementation implementation) -> NumericalPoint
        __init__(self, NumericalPoint other) -> NumericalPoint
        __init__(self, PyObject pyObj) -> NumericalPoint
        """
        this = _ot.new_NumericalPoint(*args)
        try: self.this.append(this)
        except: self.this = this
    __swig_destroy__ = _ot.delete_NumericalPoint
    __del__ = lambda self : None;
NumericalPoint_swigregister = _ot.NumericalPoint_swigregister
NumericalPoint_swigregister(NumericalPoint)

def NumericalPoint_GetClassName(*args):
  """NumericalPoint_GetClassName() -> String"""
  return _ot.NumericalPoint_GetClassName(*args)

def NumericalPoint_dot(*args):
  """NumericalPoint_dot(NumericalPoint lhs, NumericalPoint rhs) -> NumericalScalar"""
  return _ot.NumericalPoint_dot(*args)

02805 class NumericalPointCollection(_object):
    """Proxy of C++ NumericalPointCollection class"""
    __swig_setmethods__ = {}
    __setattr__ = lambda self, name, value: _swig_setattr(self, NumericalPointCollection, name, value)
    __swig_getmethods__ = {}
    __getattr__ = lambda self, name: _swig_getattr(self, NumericalPointCollection, name)
    __repr__ = _swig_repr
02812     def __init__(self, *args): 
        """
        __init__(self) -> NumericalPointCollection
        __init__(self, UnsignedLong size) -> NumericalPointCollection
        __init__(self, UnsignedLong size, NumericalPoint value) -> NumericalPointCollection
        """
        this = _ot.new_NumericalPointCollection(*args)
        try: self.this.append(this)
        except: self.this = this
02821     def clear(*args):
        """clear(self)"""
        return _ot.NumericalPointCollection_clear(*args)

02825     def __str__(*args):
        """__str__(self) -> String"""
        return _ot.NumericalPointCollection___str__(*args)

02829     def __getitem__(*args):
        """__getitem__(self, UnsignedLong i) -> NumericalPoint"""
        return _ot.NumericalPointCollection___getitem__(*args)

02833     def __setitem__(*args):
        """__setitem__(self, UnsignedLong i, NumericalPoint val)"""
        return _ot.NumericalPointCollection___setitem__(*args)

02837     def at(*args):
        """
        at(self, UnsignedLong i) -> NumericalPoint
        at(self, UnsignedLong i) -> NumericalPoint
        """
        return _ot.NumericalPointCollection_at(*args)

02844     def add(*args):
        """add(self, NumericalPoint elt)"""
        return _ot.NumericalPointCollection_add(*args)

02848     def getSize(*args):
        """getSize(self) -> UnsignedLong"""
        return _ot.NumericalPointCollection_getSize(*args)

02852     def resize(*args):
        """resize(self, UnsignedLong newSize)"""
        return _ot.NumericalPointCollection_resize(*args)

02856     def isEmpty(*args):
        """isEmpty(self) -> Bool"""
        return _ot.NumericalPointCollection_isEmpty(*args)

02860     def str(*args):
        """str(self) -> String"""
        return _ot.NumericalPointCollection_str(*args)

    __swig_destroy__ = _ot.delete_NumericalPointCollection
    __del__ = lambda self : None;
NumericalPointCollection_swigregister = _ot.NumericalPointCollection_swigregister
NumericalPointCollection_swigregister(NumericalPointCollection)

02869 class NumericalPointPersistentCollection(PersistentObject,NumericalPointCollection):
    """Proxy of C++ NumericalPointPersistentCollection class"""
    __swig_setmethods__ = {}
    for _s in [PersistentObject,NumericalPointCollection]: __swig_setmethods__.update(getattr(_s,'__swig_setmethods__',{}))
    __setattr__ = lambda self, name, value: _swig_setattr(self, NumericalPointPersistentCollection, name, value)
    __swig_getmethods__ = {}
    for _s in [PersistentObject,NumericalPointCollection]: __swig_getmethods__.update(getattr(_s,'__swig_getmethods__',{}))
    __getattr__ = lambda self, name: _swig_getattr(self, NumericalPointPersistentCollection, name)
    __repr__ = _swig_repr
02878     def GetClassName(*args):
        """GetClassName() -> String"""
        return _ot.NumericalPointPersistentCollection_GetClassName(*args)

    if _newclass:GetClassName = staticmethod(GetClassName)
    __swig_getmethods__["GetClassName"] = lambda x: GetClassName
02884     def getClassName(*args):
        """getClassName(self) -> String"""
        return _ot.NumericalPointPersistentCollection_getClassName(*args)

02888     def __init__(self, *args): 
        """
        __init__(self) -> NumericalPointPersistentCollection
        __init__(self, NumericalPointCollection collection) -> NumericalPointPersistentCollection
        __init__(self, UnsignedLong size) -> NumericalPointPersistentCollection
        __init__(self, UnsignedLong size, NumericalPoint value) -> NumericalPointPersistentCollection
        """
        this = _ot.new_NumericalPointPersistentCollection(*args)
        try: self.this.append(this)
        except: self.this = this
02898     def clone(*args):
        """clone(self) -> NumericalPointPersistentCollection"""
        return _ot.NumericalPointPersistentCollection_clone(*args)

02902     def str(*args):
        """str(self) -> String"""
        return _ot.NumericalPointPersistentCollection_str(*args)

02906     def save(*args):
        """save(self, OpenTURNS::Base::Type::PersistentCollection<(OpenTURNS::Base::Type::NumericalPoint)>::StorageManager::Advocate adv)"""
        return _ot.NumericalPointPersistentCollection_save(*args)

02910     def load(*args):
        """load(self, OpenTURNS::Base::Type::PersistentCollection<(OpenTURNS::Base::Type::NumericalPoint)>::StorageManager::Advocate adv)"""
        return _ot.NumericalPointPersistentCollection_load(*args)

02914     def __str__(*args):
        """__str__(self) -> String"""
        return _ot.NumericalPointPersistentCollection___str__(*args)

    __swig_destroy__ = _ot.delete_NumericalPointPersistentCollection
    __del__ = lambda self : None;
NumericalPointPersistentCollection_swigregister = _ot.NumericalPointPersistentCollection_swigregister
NumericalPointPersistentCollection_swigregister(NumericalPointPersistentCollection)

def NumericalPointPersistentCollection_GetClassName(*args):
  """NumericalPointPersistentCollection_GetClassName() -> String"""
  return _ot.NumericalPointPersistentCollection_GetClassName(*args)

02927 class NumericalPointImplementationWithDescription(NumericalPointImplementation):
    """Proxy of C++ NumericalPointImplementationWithDescription class"""
    __swig_setmethods__ = {}
    for _s in [NumericalPointImplementation]: __swig_setmethods__.update(getattr(_s,'__swig_setmethods__',{}))
    __setattr__ = lambda self, name, value: _swig_setattr(self, NumericalPointImplementationWithDescription, name, value)
    __swig_getmethods__ = {}
    for _s in [NumericalPointImplementation]: __swig_getmethods__.update(getattr(_s,'__swig_getmethods__',{}))
    __getattr__ = lambda self, name: _swig_getattr(self, NumericalPointImplementationWithDescription, name)
    __repr__ = _swig_repr
02936     def GetClassName(*args):
        """GetClassName() -> String"""
        return _ot.NumericalPointImplementationWithDescription_GetClassName(*args)

    if _newclass:GetClassName = staticmethod(GetClassName)
    __swig_getmethods__["GetClassName"] = lambda x: GetClassName
02942     def getClassName(*args):
        """getClassName(self) -> String"""
        return _ot.NumericalPointImplementationWithDescription_getClassName(*args)

02946     def clone(*args):
        """clone(self) -> NumericalPointImplementationWithDescription"""
        return _ot.NumericalPointImplementationWithDescription_clone(*args)

02950     def setDescription(*args):
        """setDescription(self, Description description)"""
        return _ot.NumericalPointImplementationWithDescription_setDescription(*args)

02954     def getDescription(*args):
        """getDescription(self) -> Description"""
        return _ot.NumericalPointImplementationWithDescription_getDescription(*args)

02958     def str(*args):
        """str(self) -> String"""
        return _ot.NumericalPointImplementationWithDescription_str(*args)

02962     def save(*args):
        """save(self, OpenTURNS::Base::Type::NumericalPointImplementationWithDescription::StorageManager::Advocate adv)"""
        return _ot.NumericalPointImplementationWithDescription_save(*args)

02966     def load(*args):
        """load(self, OpenTURNS::Base::Type::NumericalPointImplementationWithDescription::StorageManager::Advocate adv)"""
        return _ot.NumericalPointImplementationWithDescription_load(*args)

02970     def __init__(self, *args): 
        """
        __init__(self) -> NumericalPointImplementationWithDescription
        __init__(self, UnsignedLong size, NumericalScalar value=0.0) -> NumericalPointImplementationWithDescription
        __init__(self, UnsignedLong size) -> NumericalPointImplementationWithDescription
        __init__(self, NumericalScalarCollection coll) -> NumericalPointImplementationWithDescription
        __init__(self, NumericalPointImplementationPointer p_base) -> NumericalPointImplementationWithDescription
        __init__(self, NumericalPointImplementationWithDescription other) -> NumericalPointImplementationWithDescription
        """
        this = _ot.new_NumericalPointImplementationWithDescription(*args)
        try: self.this.append(this)
        except: self.this = this
    __swig_destroy__ = _ot.delete_NumericalPointImplementationWithDescription
    __del__ = lambda self : None;
NumericalPointImplementationWithDescription_swigregister = _ot.NumericalPointImplementationWithDescription_swigregister
NumericalPointImplementationWithDescription_swigregister(NumericalPointImplementationWithDescription)

def NumericalPointImplementationWithDescription_GetClassName(*args):
  """NumericalPointImplementationWithDescription_GetClassName() -> String"""
  return _ot.NumericalPointImplementationWithDescription_GetClassName(*args)

02991 class NumericalPointWithDescription(NumericalPoint):
    """Proxy of C++ NumericalPointWithDescription class"""
    __swig_setmethods__ = {}
    for _s in [NumericalPoint]: __swig_setmethods__.update(getattr(_s,'__swig_setmethods__',{}))
    __setattr__ = lambda self, name, value: _swig_setattr(self, NumericalPointWithDescription, name, value)
    __swig_getmethods__ = {}
    for _s in [NumericalPoint]: __swig_getmethods__.update(getattr(_s,'__swig_getmethods__',{}))
    __getattr__ = lambda self, name: _swig_getattr(self, NumericalPointWithDescription, name)
    __repr__ = _swig_repr
03000     def GetClassName(*args):
        """GetClassName() -> String"""
        return _ot.NumericalPointWithDescription_GetClassName(*args)

    if _newclass:GetClassName = staticmethod(GetClassName)
    __swig_getmethods__["GetClassName"] = lambda x: GetClassName
03006     def getClassName(*args):
        """getClassName(self) -> String"""
        return _ot.NumericalPointWithDescription_getClassName(*args)

03010     def setDescription(*args):
        """setDescription(self, Description description)"""
        return _ot.NumericalPointWithDescription_setDescription(*args)

03014     def getDescription(*args):
        """getDescription(self) -> Description"""
        return _ot.NumericalPointWithDescription_getDescription(*args)

03018     def str(*args):
        """str(self) -> String"""
        return _ot.NumericalPointWithDescription_str(*args)

03022     def __init__(self, *args): 
        """
        __init__(self) -> NumericalPointWithDescription
        __init__(self, UnsignedLong size, NumericalScalar value=0.0) -> NumericalPointWithDescription
        __init__(self, UnsignedLong size) -> NumericalPointWithDescription
        __init__(self, NumericalPointImplementationWithDescription implementation) -> NumericalPointWithDescription
        __init__(self, NumericalPoint point) -> NumericalPointWithDescription
        __init__(self, NumericalPointWithDescription other) -> NumericalPointWithDescription
        """
        this = _ot.new_NumericalPointWithDescription(*args)
        try: self.this.append(this)
        except: self.this = this
    __swig_destroy__ = _ot.delete_NumericalPointWithDescription
    __del__ = lambda self : None;
NumericalPointWithDescription_swigregister = _ot.NumericalPointWithDescription_swigregister
NumericalPointWithDescription_swigregister(NumericalPointWithDescription)

def NumericalPointWithDescription_GetClassName(*args):
  """NumericalPointWithDescription_GetClassName() -> String"""
  return _ot.NumericalPointWithDescription_GetClassName(*args)

03043 class NumericalPointWithDescriptionCollection(_object):
    """Proxy of C++ NumericalPointWithDescriptionCollection class"""
    __swig_setmethods__ = {}
    __setattr__ = lambda self, name, value: _swig_setattr(self, NumericalPointWithDescriptionCollection, name, value)
    __swig_getmethods__ = {}
    __getattr__ = lambda self, name: _swig_getattr(self, NumericalPointWithDescriptionCollection, name)
    __repr__ = _swig_repr
03050     def __init__(self, *args): 
        """
        __init__(self) -> NumericalPointWithDescriptionCollection
        __init__(self, UnsignedLong size) -> NumericalPointWithDescriptionCollection
        __init__(self, UnsignedLong size, NumericalPointWithDescription value) -> NumericalPointWithDescriptionCollection
        """
        this = _ot.new_NumericalPointWithDescriptionCollection(*args)
        try: self.this.append(this)
        except: self.this = this
03059     def clear(*args):
        """clear(self)"""
        return _ot.NumericalPointWithDescriptionCollection_clear(*args)

03063     def __str__(*args):
        """__str__(self) -> String"""
        return _ot.NumericalPointWithDescriptionCollection___str__(*args)

03067     def __getitem__(*args):
        """__getitem__(self, UnsignedLong i) -> NumericalPointWithDescription"""
        return _ot.NumericalPointWithDescriptionCollection___getitem__(*args)

03071     def __setitem__(*args):
        """__setitem__(self, UnsignedLong i, NumericalPointWithDescription val)"""
        return _ot.NumericalPointWithDescriptionCollection___setitem__(*args)

03075     def at(*args):
        """
        at(self, UnsignedLong i) -> NumericalPointWithDescription
        at(self, UnsignedLong i) -> NumericalPointWithDescription
        """
        return _ot.NumericalPointWithDescriptionCollection_at(*args)

03082     def add(*args):
        """add(self, NumericalPointWithDescription elt)"""
        return _ot.NumericalPointWithDescriptionCollection_add(*args)

03086     def getSize(*args):
        """getSize(self) -> UnsignedLong"""
        return _ot.NumericalPointWithDescriptionCollection_getSize(*args)

03090     def resize(*args):
        """resize(self, UnsignedLong newSize)"""
        return _ot.NumericalPointWithDescriptionCollection_resize(*args)

03094     def isEmpty(*args):
        """isEmpty(self) -> Bool"""
        return _ot.NumericalPointWithDescriptionCollection_isEmpty(*args)

03098     def str(*args):
        """str(self) -> String"""
        return _ot.NumericalPointWithDescriptionCollection_str(*args)

    __swig_destroy__ = _ot.delete_NumericalPointWithDescriptionCollection
    __del__ = lambda self : None;
NumericalPointWithDescriptionCollection_swigregister = _ot.NumericalPointWithDescriptionCollection_swigregister
NumericalPointWithDescriptionCollection_swigregister(NumericalPointWithDescriptionCollection)

03107 class NumericalPointWithDescriptionPersistentCollection(PersistentObject,NumericalPointWithDescriptionCollection):
    """Proxy of C++ NumericalPointWithDescriptionPersistentCollection class"""
    __swig_setmethods__ = {}
    for _s in [PersistentObject,NumericalPointWithDescriptionCollection]: __swig_setmethods__.update(getattr(_s,'__swig_setmethods__',{}))
    __setattr__ = lambda self, name, value: _swig_setattr(self, NumericalPointWithDescriptionPersistentCollection, name, value)
    __swig_getmethods__ = {}
    for _s in [PersistentObject,NumericalPointWithDescriptionCollection]: __swig_getmethods__.update(getattr(_s,'__swig_getmethods__',{}))
    __getattr__ = lambda self, name: _swig_getattr(self, NumericalPointWithDescriptionPersistentCollection, name)
    __repr__ = _swig_repr
03116     def GetClassName(*args):
        """GetClassName() -> String"""
        return _ot.NumericalPointWithDescriptionPersistentCollection_GetClassName(*args)

    if _newclass:GetClassName = staticmethod(GetClassName)
    __swig_getmethods__["GetClassName"] = lambda x: GetClassName
03122     def getClassName(*args):
        """getClassName(self) -> String"""
        return _ot.NumericalPointWithDescriptionPersistentCollection_getClassName(*args)

03126     def __init__(self, *args): 
        """
        __init__(self) -> NumericalPointWithDescriptionPersistentCollection
        __init__(self, NumericalPointWithDescriptionCollection collection) -> NumericalPointWithDescriptionPersistentCollection
        __init__(self, UnsignedLong size) -> NumericalPointWithDescriptionPersistentCollection
        __init__(self, UnsignedLong size, NumericalPointWithDescription value) -> NumericalPointWithDescriptionPersistentCollection
        """
        this = _ot.new_NumericalPointWithDescriptionPersistentCollection(*args)
        try: self.this.append(this)
        except: self.this = this
03136     def clone(*args):
        """clone(self) -> NumericalPointWithDescriptionPersistentCollection"""
        return _ot.NumericalPointWithDescriptionPersistentCollection_clone(*args)

03140     def str(*args):
        """str(self) -> String"""
        return _ot.NumericalPointWithDescriptionPersistentCollection_str(*args)

03144     def save(*args):
        """save(self, OpenTURNS::Base::Type::PersistentCollection<(OpenTURNS::Base::Type::NumericalPointWithDescription)>::StorageManager::Advocate adv)"""
        return _ot.NumericalPointWithDescriptionPersistentCollection_save(*args)

03148     def load(*args):
        """load(self, OpenTURNS::Base::Type::PersistentCollection<(OpenTURNS::Base::Type::NumericalPointWithDescription)>::StorageManager::Advocate adv)"""
        return _ot.NumericalPointWithDescriptionPersistentCollection_load(*args)

03152     def __str__(*args):
        """__str__(self) -> String"""
        return _ot.NumericalPointWithDescriptionPersistentCollection___str__(*args)

    __swig_destroy__ = _ot.delete_NumericalPointWithDescriptionPersistentCollection
    __del__ = lambda self : None;
NumericalPointWithDescriptionPersistentCollection_swigregister = _ot.NumericalPointWithDescriptionPersistentCollection_swigregister
NumericalPointWithDescriptionPersistentCollection_swigregister(NumericalPointWithDescriptionPersistentCollection)

def NumericalPointWithDescriptionPersistentCollection_GetClassName(*args):
  """NumericalPointWithDescriptionPersistentCollection_GetClassName() -> String"""
  return _ot.NumericalPointWithDescriptionPersistentCollection_GetClassName(*args)

03165 class Indices(UnsignedLongCollection):
    """Proxy of C++ Indices class"""
    __swig_setmethods__ = {}
    for _s in [UnsignedLongCollection]: __swig_setmethods__.update(getattr(_s,'__swig_setmethods__',{}))
    __setattr__ = lambda self, name, value: _swig_setattr(self, Indices, name, value)
    __swig_getmethods__ = {}
    for _s in [UnsignedLongCollection]: __swig_getmethods__.update(getattr(_s,'__swig_getmethods__',{}))
    __getattr__ = lambda self, name: _swig_getattr(self, Indices, name)
    __repr__ = _swig_repr
03174     def check(*args):
        """check(self, UnsignedLong bound) -> Bool"""
        return _ot.Indices_check(*args)

03178     def __init__(self, *args): 
        """
        __init__(self) -> Indices
        __init__(self, UnsignedLong size) -> Indices
        __init__(self, UnsignedLong size, UnsignedLong value) -> Indices
        __init__(self, Indices other) -> Indices
        """
        this = _ot.new_Indices(*args)
        try: self.this.append(this)
        except: self.this = this
    __swig_destroy__ = _ot.delete_Indices
    __del__ = lambda self : None;
Indices_swigregister = _ot.Indices_swigregister
Indices_swigregister(Indices)

03193 class BoolCollection(UnsignedLongCollection): pass

03195 class Interval(PersistentObject):
    """Proxy of C++ Interval class"""
    __swig_setmethods__ = {}
    for _s in [PersistentObject]: __swig_setmethods__.update(getattr(_s,'__swig_setmethods__',{}))
    __setattr__ = lambda self, name, value: _swig_setattr(self, Interval, name, value)
    __swig_getmethods__ = {}
    for _s in [PersistentObject]: __swig_getmethods__.update(getattr(_s,'__swig_getmethods__',{}))
    __getattr__ = lambda self, name: _swig_getattr(self, Interval, name)
    __repr__ = _swig_repr
03204     def GetClassName(*args):
        """GetClassName() -> String"""
        return _ot.Interval_GetClassName(*args)

    if _newclass:GetClassName = staticmethod(GetClassName)
    __swig_getmethods__["GetClassName"] = lambda x: GetClassName
03210     def getClassName(*args):
        """getClassName(self) -> String"""
        return _ot.Interval_getClassName(*args)

03214     def clone(*args):
        """clone(self) -> Interval"""
        return _ot.Interval_clone(*args)

03218     def isEmpty(*args):
        """isEmpty(self) -> Bool"""
        return _ot.Interval_isEmpty(*args)

03222     def isInside(*args):
        """isInside(self, NumericalPoint point) -> Bool"""
        return _ot.Interval_isInside(*args)

03226     def intersect(*args):
        """intersect(self, Interval other) -> Interval"""
        return _ot.Interval_intersect(*args)

03230     def join(*args):
        """join(self, Interval other) -> Interval"""
        return _ot.Interval_join(*args)

03234     def __add__(*args):
        """__add__(self, Interval rhs) -> Interval"""
        return _ot.Interval___add__(*args)

03238     def __sub__(*args):
        """__sub__(self, Interval rhs) -> Interval"""
        return _ot.Interval___sub__(*args)

03242     def __iadd__(*args):
        """__iadd__(self, Interval other) -> Interval"""
        return _ot.Interval___iadd__(*args)

03246     def __isub__(*args):
        """__isub__(self, Interval other) -> Interval"""
        return _ot.Interval___isub__(*args)

03250     def __mul__(*args):
        """__mul__(self, NumericalScalar scalar) -> Interval"""
        return _ot.Interval___mul__(*args)

03254     def __imul__(*args):
        """__imul__(self, NumericalScalar scalar) -> Interval"""
        return _ot.Interval___imul__(*args)

03258     def getDimension(*args):
        """getDimension(self) -> UnsignedLong"""
        return _ot.Interval_getDimension(*args)

03262     def getLowerBound(*args):
        """getLowerBound(self) -> NumericalPoint"""
        return _ot.Interval_getLowerBound(*args)

03266     def setLowerBound(*args):
        """setLowerBound(self, NumericalPoint lowerBound)"""
        return _ot.Interval_setLowerBound(*args)

03270     def getUpperBound(*args):
        """getUpperBound(self) -> NumericalPoint"""
        return _ot.Interval_getUpperBound(*args)

03274     def setUpperBound(*args):
        """setUpperBound(self, NumericalPoint upperBound)"""
        return _ot.Interval_setUpperBound(*args)

03278     def getFiniteLowerBound(*args):
        """getFiniteLowerBound(self) -> BoolCollection"""
        return _ot.Interval_getFiniteLowerBound(*args)

03282     def setFiniteLowerBound(*args):
        """setFiniteLowerBound(self, BoolCollection finiteLowerBound)"""
        return _ot.Interval_setFiniteLowerBound(*args)

03286     def getFiniteUpperBound(*args):
        """getFiniteUpperBound(self) -> BoolCollection"""
        return _ot.Interval_getFiniteUpperBound(*args)

03290     def setFiniteUpperBound(*args):
        """setFiniteUpperBound(self, BoolCollection finiteUpperBound)"""
        return _ot.Interval_setFiniteUpperBound(*args)

03294     def str(*args):
        """str(self) -> String"""
        return _ot.Interval_str(*args)

03298     def save(*args):
        """save(self, OpenTURNS::Base::Type::Interval::StorageManager::Advocate adv)"""
        return _ot.Interval_save(*args)

03302     def load(*args):
        """load(self, OpenTURNS::Base::Type::Interval::StorageManager::Advocate adv)"""
        return _ot.Interval_load(*args)

03306     def __init__(self, *args): 
        """
        __init__(self, UnsignedLong dimension=1) -> Interval
        __init__(self) -> Interval
        __init__(self, NumericalScalar lowerBound, NumericalScalar upperBound) -> Interval
        __init__(self, NumericalPoint lowerBound, NumericalPoint upperBound) -> Interval
        __init__(self, NumericalPoint lowerBound, NumericalPoint upperBound, 
            BoolCollection finiteLowerBound, BoolCollection finiteUpperBound) -> Interval
        __init__(self, Interval other) -> Interval
        """
        this = _ot.new_Interval(*args)
        try: self.this.append(this)
        except: self.this = this
    __swig_destroy__ = _ot.delete_Interval
    __del__ = lambda self : None;
Interval_swigregister = _ot.Interval_swigregister
Interval_swigregister(Interval)

def Interval_GetClassName(*args):
  """Interval_GetClassName() -> String"""
  return _ot.Interval_GetClassName(*args)

03328 class MatrixImplementation(NumericalScalarPersistentCollection):
    """Proxy of C++ MatrixImplementation class"""
    __swig_setmethods__ = {}
    for _s in [NumericalScalarPersistentCollection]: __swig_setmethods__.update(getattr(_s,'__swig_setmethods__',{}))
    __setattr__ = lambda self, name, value: _swig_setattr(self, MatrixImplementation, name, value)
    __swig_getmethods__ = {}
    for _s in [NumericalScalarPersistentCollection]: __swig_getmethods__.update(getattr(_s,'__swig_getmethods__',{}))
    __getattr__ = lambda self, name: _swig_getattr(self, MatrixImplementation, name)
    __repr__ = _swig_repr
03337     def GetClassName(*args):
        """GetClassName() -> String"""
        return _ot.MatrixImplementation_GetClassName(*args)

    if _newclass:GetClassName = staticmethod(GetClassName)
    __swig_getmethods__["GetClassName"] = lambda x: GetClassName
03343     def getClassName(*args):
        """getClassName(self) -> String"""
        return _ot.MatrixImplementation_getClassName(*args)

    DefaultSmallPivot = _ot.MatrixImplementation_DefaultSmallPivot
03348     def clone(*args):
        """clone(self) -> MatrixImplementation"""
        return _ot.MatrixImplementation_clone(*args)

03352     def str(*args):
        """str(self) -> String"""
        return _ot.MatrixImplementation_str(*args)

03356     def __call__(*args):
        """
        __call__(self, UnsignedLong i, UnsignedLong j) -> NumericalScalar
        __call__(self, UnsignedLong i, UnsignedLong j) -> NumericalScalar
        """
        return _ot.MatrixImplementation___call__(*args)

03363     def getNbRows(*args):
        """getNbRows(self) -> UnsignedLong"""
        return _ot.MatrixImplementation_getNbRows(*args)

03367     def getNbColumns(*args):
        """getNbColumns(self) -> UnsignedLong"""
        return _ot.MatrixImplementation_getNbColumns(*args)

03371     def getDimension(*args):
        """getDimension(self) -> UnsignedLong"""
        return _ot.MatrixImplementation_getDimension(*args)

03375     def transpose(*args):
        """transpose(self) -> MatrixImplementation"""
        return _ot.MatrixImplementation_transpose(*args)

03379     def __add__(*args):
        """__add__(self, MatrixImplementation m) -> MatrixImplementation"""
        return _ot.MatrixImplementation___add__(*args)

03383     def __sub__(*args):
        """__sub__(self, MatrixImplementation m) -> MatrixImplementation"""
        return _ot.MatrixImplementation___sub__(*args)

03387     def genProd(*args):
        """genProd(self, MatrixImplementation m) -> MatrixImplementation"""
        return _ot.MatrixImplementation_genProd(*args)

03391     def symProd(*args):
        """symProd(self, MatrixImplementation m, char symSide) -> MatrixImplementation"""
        return _ot.MatrixImplementation_symProd(*args)

03395     def genPower(*args):
        """genPower(self, UnsignedLong n) -> MatrixImplementation"""
        return _ot.MatrixImplementation_genPower(*args)

03399     def symPower(*args):
        """symPower(self, UnsignedLong n) -> MatrixImplementation"""
        return _ot.MatrixImplementation_symPower(*args)

03403     def genVectProd(*args):
        """genVectProd(self, NumericalPoint pt) -> NumericalPoint"""
        return _ot.MatrixImplementation_genVectProd(*args)

03407     def symVectProd(*args):
        """symVectProd(self, NumericalPoint pt) -> NumericalPoint"""
        return _ot.MatrixImplementation_symVectProd(*args)

03411     def __mul__(*args):
        """__mul__(self, NumericalScalar s) -> MatrixImplementation"""
        return _ot.MatrixImplementation___mul__(*args)

03415     def __div__(*args):
        """__div__(self, NumericalScalar s) -> MatrixImplementation"""
        return _ot.MatrixImplementation___div__(*args)

03419     def symmetrize(*args):
        """symmetrize(self)"""
        return _ot.MatrixImplementation_symmetrize(*args)

03423     def solveLinearSystemRect(*args):
        """
        solveLinearSystemRect(self, NumericalPoint b) -> NumericalPoint
        solveLinearSystemRect(self, MatrixImplementation b) -> MatrixImplementation
        """
        return _ot.MatrixImplementation_solveLinearSystemRect(*args)

03430     def solveLinearSystemSquare(*args):
        """
        solveLinearSystemSquare(self, NumericalPoint b) -> NumericalPoint
        solveLinearSystemSquare(self, MatrixImplementation b) -> MatrixImplementation
        """
        return _ot.MatrixImplementation_solveLinearSystemSquare(*args)

03437     def solveLinearSystemSym(*args):
        """
        solveLinearSystemSym(self, NumericalPoint b) -> NumericalPoint
        solveLinearSystemSym(self, MatrixImplementation b) -> MatrixImplementation
        """
        return _ot.MatrixImplementation_solveLinearSystemSym(*args)

03444     def computeDeterminant(*args):
        """computeDeterminant(self) -> NumericalScalar"""
        return _ot.MatrixImplementation_computeDeterminant(*args)

03448     def computeDeterminantSym(*args):
        """computeDeterminantSym(self) -> NumericalScalar"""
        return _ot.MatrixImplementation_computeDeterminantSym(*args)

03452     def computeEigenValuesSquare(*args):
        """computeEigenValuesSquare(self) -> NumericalPoint"""
        return _ot.MatrixImplementation_computeEigenValuesSquare(*args)

03456     def computeEigenValuesSym(*args):
        """computeEigenValuesSym(self) -> NumericalPoint"""
        return _ot.MatrixImplementation_computeEigenValuesSym(*args)

03460     def isPositiveDefinite(*args):
        """isPositiveDefinite(self) -> Bool"""
        return _ot.MatrixImplementation_isPositiveDefinite(*args)

03464     def computeCholesky(*args):
        """computeCholesky(self) -> MatrixImplementation"""
        return _ot.MatrixImplementation_computeCholesky(*args)

03468     def __eq__(*args):
        """__eq__(self, MatrixImplementation rhs) -> Bool"""
        return _ot.MatrixImplementation___eq__(*args)

03472     def __ne__(*args):
        """__ne__(self, MatrixImplementation rhs) -> Bool"""
        return _ot.MatrixImplementation___ne__(*args)

03476     def isEmpty(*args):
        """isEmpty(self) -> Bool"""
        return _ot.MatrixImplementation_isEmpty(*args)

03480     def save(*args):
        """save(self, OpenTURNS::Base::Type::PersistentCollection<(double)>::StorageManager::Advocate adv)"""
        return _ot.MatrixImplementation_save(*args)

03484     def load(*args):
        """load(self, OpenTURNS::Base::Type::PersistentCollection<(double)>::StorageManager::Advocate adv)"""
        return _ot.MatrixImplementation_load(*args)

03488     def __init__(self, *args): 
        """
        __init__(self) -> MatrixImplementation
        __init__(self, UnsignedLong rowDim, UnsignedLong colDim) -> MatrixImplementation
        __init__(self, UnsignedLong rowDim, UnsignedLong colDim, NumericalScalarCollection elementsValues) -> MatrixImplementation
        __init__(self, MatrixImplementation other) -> MatrixImplementation
        """
        this = _ot.new_MatrixImplementation(*args)
        try: self.this.append(this)
        except: self.this = this
    __swig_destroy__ = _ot.delete_MatrixImplementation
    __del__ = lambda self : None;
MatrixImplementation_swigregister = _ot.MatrixImplementation_swigregister
MatrixImplementation_swigregister(MatrixImplementation)

def MatrixImplementation_GetClassName(*args):
  """MatrixImplementation_GetClassName() -> String"""
  return _ot.MatrixImplementation_GetClassName(*args)

03507 class MatrixImplementationTypedInterfaceObject(InterfaceObject):
    """Proxy of C++ MatrixImplementationTypedInterfaceObject class"""
    __swig_setmethods__ = {}
    for _s in [InterfaceObject]: __swig_setmethods__.update(getattr(_s,'__swig_setmethods__',{}))
    __setattr__ = lambda self, name, value: _swig_setattr(self, MatrixImplementationTypedInterfaceObject, name, value)
    __swig_getmethods__ = {}
    for _s in [InterfaceObject]: __swig_getmethods__.update(getattr(_s,'__swig_getmethods__',{}))
    __getattr__ = lambda self, name: _swig_getattr(self, MatrixImplementationTypedInterfaceObject, name)
    __repr__ = _swig_repr
03516     def __init__(self, *args): 
        """
        __init__(self) -> MatrixImplementationTypedInterfaceObject
        __init__(self, Implementation impl) -> MatrixImplementationTypedInterfaceObject
        """
        this = _ot.new_MatrixImplementationTypedInterfaceObject(*args)
        try: self.this.append(this)
        except: self.this = this
03524     def getImplementation(*args):
        """
        getImplementation(self) -> Implementation
        getImplementation(self) -> Implementation
        """
        return _ot.MatrixImplementationTypedInterfaceObject_getImplementation(*args)

03531     def getImplementationAsPersistentObject(*args):
        """getImplementationAsPersistentObject(self) -> ImplementationAsPersistentObject"""
        return _ot.MatrixImplementationTypedInterfaceObject_getImplementationAsPersistentObject(*args)

03535     def setImplementationAsPersistentObject(*args):
        """setImplementationAsPersistentObject(self, ImplementationAsPersistentObject obj)"""
        return _ot.MatrixImplementationTypedInterfaceObject_setImplementationAsPersistentObject(*args)

03539     def swap(*args):
        """swap(self, MatrixImplementationTypedInterfaceObject other)"""
        return _ot.MatrixImplementationTypedInterfaceObject_swap(*args)

03543     def setName(*args):
        """setName(self, String name)"""
        return _ot.MatrixImplementationTypedInterfaceObject_setName(*args)

03547     def getName(*args):
        """getName(self) -> String"""
        return _ot.MatrixImplementationTypedInterfaceObject_getName(*args)

    __swig_destroy__ = _ot.delete_MatrixImplementationTypedInterfaceObject
    __del__ = lambda self : None;
MatrixImplementationTypedInterfaceObject_swigregister = _ot.MatrixImplementationTypedInterfaceObject_swigregister
MatrixImplementationTypedInterfaceObject_swigregister(MatrixImplementationTypedInterfaceObject)

03556 class Matrix(MatrixImplementationTypedInterfaceObject):
    """Proxy of C++ Matrix class"""
    __swig_setmethods__ = {}
    for _s in [MatrixImplementationTypedInterfaceObject]: __swig_setmethods__.update(getattr(_s,'__swig_setmethods__',{}))
    __setattr__ = lambda self, name, value: _swig_setattr(self, Matrix, name, value)
    __swig_getmethods__ = {}
    for _s in [MatrixImplementationTypedInterfaceObject]: __swig_getmethods__.update(getattr(_s,'__swig_getmethods__',{}))
    __getattr__ = lambda self, name: _swig_getattr(self, Matrix, name)
    __repr__ = _swig_repr
03565     def GetClassName(*args):
        """GetClassName() -> String"""
        return _ot.Matrix_GetClassName(*args)

    if _newclass:GetClassName = staticmethod(GetClassName)
    __swig_getmethods__["GetClassName"] = lambda x: GetClassName
03571     def getClassName(*args):
        """getClassName(self) -> String"""
        return _ot.Matrix_getClassName(*args)

03575     def str(*args):
        """str(self) -> String"""
        return _ot.Matrix_str(*args)

03579     def getNbRows(*args):
        """getNbRows(self) -> UnsignedLong"""
        return _ot.Matrix_getNbRows(*args)

03583     def getNbColumns(*args):
        """getNbColumns(self) -> UnsignedLong"""
        return _ot.Matrix_getNbColumns(*args)

03587     def transpose(*args):
        """transpose(self) -> Matrix"""
        return _ot.Matrix_transpose(*args)

03591     def __add__(*args):
        """
        __add__(self, Matrix m) -> Matrix
        __add__(self, SymmetricMatrix m) -> Matrix
        """
        return _ot.Matrix___add__(*args)

03598     def __sub__(*args):
        """
        __sub__(self, Matrix m) -> Matrix
        __sub__(self, SymmetricMatrix m) -> Matrix
        """
        return _ot.Matrix___sub__(*args)

03605     def __mul__(*args):
        """
        __mul__(self, Matrix m) -> Matrix
        __mul__(self, SymmetricMatrix m) -> Matrix
        __mul__(self, IdentityMatrix m) -> Matrix
        __mul__(self, NumericalPoint pt) -> NumericalPoint
        __mul__(self, NumericalScalar s) -> Matrix
        """
        return _ot.Matrix___mul__(*args)

03615     def __div__(*args):
        """__div__(self, NumericalScalar s) -> Matrix"""
        return _ot.Matrix___div__(*args)

03619     def solveLinearSystem(*args):
        """
        solveLinearSystem(self, NumericalPoint b) -> NumericalPoint
        solveLinearSystem(self, Matrix b) -> Matrix
        """
        return _ot.Matrix_solveLinearSystem(*args)

03626     def __eq__(*args):
        """__eq__(self, Matrix rhs) -> Bool"""
        return _ot.Matrix___eq__(*args)

03630     def isEmpty(*args):
        """isEmpty(self) -> Bool"""
        return _ot.Matrix_isEmpty(*args)

03634     def __getitem__(*args):
        """__getitem__(self, PyObject args) -> NumericalScalar"""
        return _ot.Matrix___getitem__(*args)

03638     def __setitem__(*args):
        """__setitem__(self, PyObject args, NumericalScalar val)"""
        return _ot.Matrix___setitem__(*args)

03642     def __init__(self, *args): 
        """
        __init__(self) -> Matrix
        __init__(self, UnsignedLong rowDim, UnsignedLong colDim) -> Matrix
        __init__(self, UnsignedLong rowDim, UnsignedLong colDim, NumericalScalarCollection elementsValues) -> Matrix
        __init__(self, Implementation i) -> Matrix
        __init__(self, Matrix other) -> Matrix
        """
        this = _ot.new_Matrix(*args)
        try: self.this.append(this)
        except: self.this = this
    __swig_destroy__ = _ot.delete_Matrix
    __del__ = lambda self : None;
Matrix_swigregister = _ot.Matrix_swigregister
Matrix_swigregister(Matrix)

def Matrix_GetClassName(*args):
  """Matrix_GetClassName() -> String"""
  return _ot.Matrix_GetClassName(*args)

03662 class SquareMatrix(Matrix):
    """Proxy of C++ SquareMatrix class"""
    __swig_setmethods__ = {}
    for _s in [Matrix]: __swig_setmethods__.update(getattr(_s,'__swig_setmethods__',{}))
    __setattr__ = lambda self, name, value: _swig_setattr(self, SquareMatrix, name, value)
    __swig_getmethods__ = {}
    for _s in [Matrix]: __swig_getmethods__.update(getattr(_s,'__swig_getmethods__',{}))
    __getattr__ = lambda self, name: _swig_getattr(self, SquareMatrix, name)
    __repr__ = _swig_repr
03671     def GetClassName(*args):
        """GetClassName() -> String"""
        return _ot.SquareMatrix_GetClassName(*args)

    if _newclass:GetClassName = staticmethod(GetClassName)
    __swig_getmethods__["GetClassName"] = lambda x: GetClassName
03677     def getClassName(*args):
        """getClassName(self) -> String"""
        return _ot.SquareMatrix_getClassName(*args)

03681     def str(*args):
        """str(self) -> String"""
        return _ot.SquareMatrix_str(*args)

03685     def getDimension(*args):
        """getDimension(self) -> UnsignedLong"""
        return _ot.SquareMatrix_getDimension(*args)

03689     def transpose(*args):
        """transpose(self) -> SquareMatrix"""
        return _ot.SquareMatrix_transpose(*args)

03693     def __add__(*args):
        """
        __add__(self, SquareMatrix m) -> SquareMatrix
        __add__(self, SymmetricMatrix m) -> SquareMatrix
        """
        return _ot.SquareMatrix___add__(*args)

03700     def __sub__(*args):
        """
        __sub__(self, SquareMatrix m) -> SquareMatrix
        __sub__(self, SymmetricMatrix m) -> SquareMatrix
        """
        return _ot.SquareMatrix___sub__(*args)

03707     def power(*args):
        """power(self, UnsignedLong n) -> SquareMatrix"""
        return _ot.SquareMatrix_power(*args)

03711     def __mul__(*args):
        """
        __mul__(self, SquareMatrix m) -> SquareMatrix
        __mul__(self, SymmetricMatrix m) -> SquareMatrix
        __mul__(self, IdentityMatrix m) -> SquareMatrix
        __mul__(self, NumericalPoint p) -> NumericalPoint
        __mul__(self, NumericalScalar s) -> SquareMatrix
        __mul__(self, Matrix m) -> Matrix
        """
        return _ot.SquareMatrix___mul__(*args)

03722     def __div__(*args):
        """__div__(self, NumericalScalar s) -> SquareMatrix"""
        return _ot.SquareMatrix___div__(*args)

03726     def solveLinearSystem(*args):
        """
        solveLinearSystem(self, NumericalPoint b) -> NumericalPoint
        solveLinearSystem(self, MatrixImplementation b) -> MatrixImplementation
        """
        return _ot.SquareMatrix_solveLinearSystem(*args)

03733     def computeDeterminant(*args):
        """computeDeterminant(self) -> NumericalScalar"""
        return _ot.SquareMatrix_computeDeterminant(*args)

03737     def computeEigenValues(*args):
        """computeEigenValues(self) -> NumericalPoint"""
        return _ot.SquareMatrix_computeEigenValues(*args)

03741     def __getitem__(*args):
        """__getitem__(self, PyObject args) -> NumericalScalar"""
        return _ot.SquareMatrix___getitem__(*args)

03745     def __setitem__(*args):
        """__setitem__(self, PyObject args, NumericalScalar val)"""
        return _ot.SquareMatrix___setitem__(*args)

03749     def __init__(self, *args): 
        """
        __init__(self) -> SquareMatrix
        __init__(self, UnsignedLong dim) -> SquareMatrix
        __init__(self, UnsignedLong dim, NumericalScalarCollection elementsValues) -> SquareMatrix
        __init__(self, Implementation i) -> SquareMatrix
        __init__(self, SquareMatrix other) -> SquareMatrix
        """
        this = _ot.new_SquareMatrix(*args)
        try: self.this.append(this)
        except: self.this = this
    __swig_destroy__ = _ot.delete_SquareMatrix
    __del__ = lambda self : None;
SquareMatrix_swigregister = _ot.SquareMatrix_swigregister
SquareMatrix_swigregister(SquareMatrix)

def SquareMatrix_GetClassName(*args):
  """SquareMatrix_GetClassName() -> String"""
  return _ot.SquareMatrix_GetClassName(*args)

03769 class SymmetricMatrix(SquareMatrix):
    """Proxy of C++ SymmetricMatrix class"""
    __swig_setmethods__ = {}
    for _s in [SquareMatrix]: __swig_setmethods__.update(getattr(_s,'__swig_setmethods__',{}))
    __setattr__ = lambda self, name, value: _swig_setattr(self, SymmetricMatrix, name, value)
    __swig_getmethods__ = {}
    for _s in [SquareMatrix]: __swig_getmethods__.update(getattr(_s,'__swig_getmethods__',{}))
    __getattr__ = lambda self, name: _swig_getattr(self, SymmetricMatrix, name)
    __repr__ = _swig_repr
03778     def GetClassName(*args):
        """GetClassName() -> String"""
        return _ot.SymmetricMatrix_GetClassName(*args)

    if _newclass:GetClassName = staticmethod(GetClassName)
    __swig_getmethods__["GetClassName"] = lambda x: GetClassName
03784     def getClassName(*args):
        """getClassName(self) -> String"""
        return _ot.SymmetricMatrix_getClassName(*args)

03788     def checkSymmetry(*args):
        """checkSymmetry(self)"""
        return _ot.SymmetricMatrix_checkSymmetry(*args)

03792     def str(*args):
        """str(self) -> String"""
        return _ot.SymmetricMatrix_str(*args)

03796     def transpose(*args):
        """transpose(self) -> SymmetricMatrix"""
        return _ot.SymmetricMatrix_transpose(*args)

03800     def __add__(*args):
        """
        __add__(self, Matrix m) -> Matrix
        __add__(self, SquareMatrix m) -> SquareMatrix
        __add__(self, SymmetricMatrix m) -> SymmetricMatrix
        """
        return _ot.SymmetricMatrix___add__(*args)

03808     def __sub__(*args):
        """
        __sub__(self, Matrix m) -> Matrix
        __sub__(self, SquareMatrix m) -> SquareMatrix
        __sub__(self, SymmetricMatrix m) -> SymmetricMatrix
        """
        return _ot.SymmetricMatrix___sub__(*args)

03816     def power(*args):
        """power(self, UnsignedLong n) -> SymmetricMatrix"""
        return _ot.SymmetricMatrix_power(*args)

03820     def __mul__(*args):
        """
        __mul__(self, Matrix m) -> Matrix
        __mul__(self, SquareMatrix m) -> SquareMatrix
        __mul__(self, SymmetricMatrix m) -> SymmetricMatrix
        __mul__(self, IdentityMatrix m) -> SymmetricMatrix
        __mul__(self, NumericalPoint p) -> NumericalPoint
        __mul__(self, NumericalScalar s) -> SymmetricMatrix
        """
        return _ot.SymmetricMatrix___mul__(*args)

03831     def __div__(*args):
        """__div__(self, NumericalScalar s) -> SymmetricMatrix"""
        return _ot.SymmetricMatrix___div__(*args)

03835     def solveLinearSystem(*args):
        """
        solveLinearSystem(self, NumericalPoint b) -> NumericalPoint
        solveLinearSystem(self, MatrixImplementation b) -> MatrixImplementation
        """
        return _ot.SymmetricMatrix_solveLinearSystem(*args)

03842     def computeDeterminant(*args):
        """computeDeterminant(self) -> NumericalScalar"""
        return _ot.SymmetricMatrix_computeDeterminant(*args)

03846     def computeEigenValues(*args):
        """computeEigenValues(self) -> NumericalPoint"""
        return _ot.SymmetricMatrix_computeEigenValues(*args)

03850     def __getitem__(*args):
        """__getitem__(self, PyObject args) -> NumericalScalar"""
        return _ot.SymmetricMatrix___getitem__(*args)

03854     def __setitem__(*args):
        """__setitem__(self, PyObject args, NumericalScalar val)"""
        return _ot.SymmetricMatrix___setitem__(*args)

03858     def __init__(self, *args): 
        """
        __init__(self) -> SymmetricMatrix
        __init__(self, UnsignedLong dim) -> SymmetricMatrix
        __init__(self, UnsignedLong dim, NumericalScalarCollection elementsValues) -> SymmetricMatrix
        __init__(self, Implementation i) -> SymmetricMatrix
        __init__(self, SymmetricMatrix other) -> SymmetricMatrix
        """
        this = _ot.new_SymmetricMatrix(*args)
        try: self.this.append(this)
        except: self.this = this
    __swig_destroy__ = _ot.delete_SymmetricMatrix
    __del__ = lambda self : None;
SymmetricMatrix_swigregister = _ot.SymmetricMatrix_swigregister
SymmetricMatrix_swigregister(SymmetricMatrix)

def SymmetricMatrix_GetClassName(*args):
  """SymmetricMatrix_GetClassName() -> String"""
  return _ot.SymmetricMatrix_GetClassName(*args)

03878 class TensorImplementation(NumericalScalarPersistentCollection):
    """Proxy of C++ TensorImplementation class"""
    __swig_setmethods__ = {}
    for _s in [NumericalScalarPersistentCollection]: __swig_setmethods__.update(getattr(_s,'__swig_setmethods__',{}))
    __setattr__ = lambda self, name, value: _swig_setattr(self, TensorImplementation, name, value)
    __swig_getmethods__ = {}
    for _s in [NumericalScalarPersistentCollection]: __swig_getmethods__.update(getattr(_s,'__swig_getmethods__',{}))
    __getattr__ = lambda self, name: _swig_getattr(self, TensorImplementation, name)
    __repr__ = _swig_repr
03887     def GetClassName(*args):
        """GetClassName() -> String"""
        return _ot.TensorImplementation_GetClassName(*args)

    if _newclass:GetClassName = staticmethod(GetClassName)
    __swig_getmethods__["GetClassName"] = lambda x: GetClassName
03893     def getClassName(*args):
        """getClassName(self) -> String"""
        return _ot.TensorImplementation_getClassName(*args)

03897     def clone(*args):
        """clone(self) -> TensorImplementation"""
        return _ot.TensorImplementation_clone(*args)

03901     def str(*args):
        """str(self) -> String"""
        return _ot.TensorImplementation_str(*args)

03905     def __call__(*args):
        """
        __call__(self, UnsignedLong i, UnsignedLong j, UnsignedLong k) -> NumericalScalar
        __call__(self, UnsignedLong i, UnsignedLong j, UnsignedLong k) -> NumericalScalar
        """
        return _ot.TensorImplementation___call__(*args)

03912     def getSheet(*args):
        """getSheet(self, UnsignedLong k) -> Matrix"""
        return _ot.TensorImplementation_getSheet(*args)

03916     def setSheet(*args):
        """setSheet(self, UnsignedLong k, Matrix m)"""
        return _ot.TensorImplementation_setSheet(*args)

03920     def getSheetSym(*args):
        """getSheetSym(self, UnsignedLong k) -> SymmetricMatrix"""
        return _ot.TensorImplementation_getSheetSym(*args)

03924     def setSheetSym(*args):
        """setSheetSym(self, UnsignedLong k, SymmetricMatrix m)"""
        return _ot.TensorImplementation_setSheetSym(*args)

03928     def getNbRows(*args):
        """getNbRows(self) -> UnsignedLong"""
        return _ot.TensorImplementation_getNbRows(*args)

03932     def getNbColumns(*args):
        """getNbColumns(self) -> UnsignedLong"""
        return _ot.TensorImplementation_getNbColumns(*args)

03936     def getNbSheets(*args):
        """getNbSheets(self) -> UnsignedLong"""
        return _ot.TensorImplementation_getNbSheets(*args)

03940     def symmetrize(*args):
        """symmetrize(self)"""
        return _ot.TensorImplementation_symmetrize(*args)

03944     def __eq__(*args):
        """__eq__(self, TensorImplementation rhs) -> Bool"""
        return _ot.TensorImplementation___eq__(*args)

03948     def isEmpty(*args):
        """isEmpty(self) -> Bool"""
        return _ot.TensorImplementation_isEmpty(*args)

03952     def save(*args):
        """save(self, OpenTURNS::Base::Type::PersistentCollection<(double)>::StorageManager::Advocate adv)"""
        return _ot.TensorImplementation_save(*args)

03956     def load(*args):
        """load(self, OpenTURNS::Base::Type::PersistentCollection<(double)>::StorageManager::Advocate adv)"""
        return _ot.TensorImplementation_load(*args)

03960     def __init__(self, *args): 
        """
        __init__(self) -> TensorImplementation
        __init__(self, UnsignedLong rowDim, UnsignedLong colDim, UnsignedLong sheetDim) -> TensorImplementation
        __init__(self, UnsignedLong rowDim, UnsignedLong colDim, UnsignedLong sheetDim, 
            NumericalScalarCollection elementsValues) -> TensorImplementation
        __init__(self, TensorImplementation other) -> TensorImplementation
        """
        this = _ot.new_TensorImplementation(*args)
        try: self.this.append(this)
        except: self.this = this
    __swig_destroy__ = _ot.delete_TensorImplementation
    __del__ = lambda self : None;
TensorImplementation_swigregister = _ot.TensorImplementation_swigregister
TensorImplementation_swigregister(TensorImplementation)

def __mul__(*args):
  """
    __mul__(NumericalScalar s, Matrix m) -> Matrix
    __mul__(NumericalScalar s, SquareMatrix m) -> SquareMatrix
    __mul__(NumericalScalar s, SymmetricMatrix m) -> SymmetricMatrix
    """
  return _ot.__mul__(*args)

def TensorImplementation_GetClassName(*args):
  """TensorImplementation_GetClassName() -> String"""
  return _ot.TensorImplementation_GetClassName(*args)

03988 class TensorImplementationTypedInterfaceObject(InterfaceObject):
    """Proxy of C++ TensorImplementationTypedInterfaceObject class"""
    __swig_setmethods__ = {}
    for _s in [InterfaceObject]: __swig_setmethods__.update(getattr(_s,'__swig_setmethods__',{}))
    __setattr__ = lambda self, name, value: _swig_setattr(self, TensorImplementationTypedInterfaceObject, name, value)
    __swig_getmethods__ = {}
    for _s in [InterfaceObject]: __swig_getmethods__.update(getattr(_s,'__swig_getmethods__',{}))
    __getattr__ = lambda self, name: _swig_getattr(self, TensorImplementationTypedInterfaceObject, name)
    __repr__ = _swig_repr
03997     def __init__(self, *args): 
        """
        __init__(self) -> TensorImplementationTypedInterfaceObject
        __init__(self, Implementation impl) -> TensorImplementationTypedInterfaceObject
        """
        this = _ot.new_TensorImplementationTypedInterfaceObject(*args)
        try: self.this.append(this)
        except: self.this = this
04005     def getImplementation(*args):
        """
        getImplementation(self) -> Implementation
        getImplementation(self) -> Implementation
        """
        return _ot.TensorImplementationTypedInterfaceObject_getImplementation(*args)

04012     def getImplementationAsPersistentObject(*args):
        """getImplementationAsPersistentObject(self) -> ImplementationAsPersistentObject"""
        return _ot.TensorImplementationTypedInterfaceObject_getImplementationAsPersistentObject(*args)

04016     def setImplementationAsPersistentObject(*args):
        """setImplementationAsPersistentObject(self, ImplementationAsPersistentObject obj)"""
        return _ot.TensorImplementationTypedInterfaceObject_setImplementationAsPersistentObject(*args)

04020     def swap(*args):
        """swap(self, TensorImplementationTypedInterfaceObject other)"""
        return _ot.TensorImplementationTypedInterfaceObject_swap(*args)

04024     def setName(*args):
        """setName(self, String name)"""
        return _ot.TensorImplementationTypedInterfaceObject_setName(*args)

04028     def getName(*args):
        """getName(self) -> String"""
        return _ot.TensorImplementationTypedInterfaceObject_getName(*args)

    __swig_destroy__ = _ot.delete_TensorImplementationTypedInterfaceObject
    __del__ = lambda self : None;
TensorImplementationTypedInterfaceObject_swigregister = _ot.TensorImplementationTypedInterfaceObject_swigregister
TensorImplementationTypedInterfaceObject_swigregister(TensorImplementationTypedInterfaceObject)

04037 class Tensor(TensorImplementationTypedInterfaceObject):
    """Proxy of C++ Tensor class"""
    __swig_setmethods__ = {}
    for _s in [TensorImplementationTypedInterfaceObject]: __swig_setmethods__.update(getattr(_s,'__swig_setmethods__',{}))
    __setattr__ = lambda self, name, value: _swig_setattr(self, Tensor, name, value)
    __swig_getmethods__ = {}
    for _s in [TensorImplementationTypedInterfaceObject]: __swig_getmethods__.update(getattr(_s,'__swig_getmethods__',{}))
    __getattr__ = lambda self, name: _swig_getattr(self, Tensor, name)
    __repr__ = _swig_repr
04046     def GetClassName(*args):
        """GetClassName() -> String"""
        return _ot.Tensor_GetClassName(*args)

    if _newclass:GetClassName = staticmethod(GetClassName)
    __swig_getmethods__["GetClassName"] = lambda x: GetClassName
04052     def getClassName(*args):
        """getClassName(self) -> String"""
        return _ot.Tensor_getClassName(*args)

04056     def str(*args):
        """str(self) -> String"""
        return _ot.Tensor_str(*args)

04060     def getSheet(*args):
        """getSheet(self, UnsignedLong k) -> Matrix"""
        return _ot.Tensor_getSheet(*args)

04064     def setSheet(*args):
        """setSheet(self, UnsignedLong k, Matrix m)"""
        return _ot.Tensor_setSheet(*args)

04068     def getNbRows(*args):
        """getNbRows(self) -> UnsignedLong"""
        return _ot.Tensor_getNbRows(*args)

04072     def getNbColumns(*args):
        """getNbColumns(self) -> UnsignedLong"""
        return _ot.Tensor_getNbColumns(*args)

04076     def getNbSheets(*args):
        """getNbSheets(self) -> UnsignedLong"""
        return _ot.Tensor_getNbSheets(*args)

04080     def __eq__(*args):
        """__eq__(self, Tensor rhs) -> Bool"""
        return _ot.Tensor___eq__(*args)

04084     def isEmpty(*args):
        """isEmpty(self) -> Bool"""
        return _ot.Tensor_isEmpty(*args)

04088     def __getitem__(*args):
        """__getitem__(self, PyObject args) -> NumericalScalar"""
        return _ot.Tensor___getitem__(*args)

04092     def __setitem__(*args):
        """__setitem__(self, PyObject args, NumericalScalar val)"""
        return _ot.Tensor___setitem__(*args)

04096     def __init__(self, *args): 
        """
        __init__(self) -> Tensor
        __init__(self, UnsignedLong rowDim, UnsignedLong colDim, UnsignedLong sheetDim) -> Tensor
        __init__(self, UnsignedLong rowDim, UnsignedLong colDim, UnsignedLong sheetDim, 
            NumericalScalarCollection elementsValues) -> Tensor
        __init__(self, Tensor other) -> Tensor
        """
        this = _ot.new_Tensor(*args)
        try: self.this.append(this)
        except: self.this = this
    __swig_destroy__ = _ot.delete_Tensor
    __del__ = lambda self : None;
Tensor_swigregister = _ot.Tensor_swigregister
Tensor_swigregister(Tensor)

def Tensor_GetClassName(*args):
  """Tensor_GetClassName() -> String"""
  return _ot.Tensor_GetClassName(*args)

04116 class SymmetricTensor(Tensor):
    """Proxy of C++ SymmetricTensor class"""
    __swig_setmethods__ = {}
    for _s in [Tensor]: __swig_setmethods__.update(getattr(_s,'__swig_setmethods__',{}))
    __setattr__ = lambda self, name, value: _swig_setattr(self, SymmetricTensor, name, value)
    __swig_getmethods__ = {}
    for _s in [Tensor]: __swig_getmethods__.update(getattr(_s,'__swig_getmethods__',{}))
    __getattr__ = lambda self, name: _swig_getattr(self, SymmetricTensor, name)
    __repr__ = _swig_repr
04125     def GetClassName(*args):
        """GetClassName() -> String"""
        return _ot.SymmetricTensor_GetClassName(*args)

    if _newclass:GetClassName = staticmethod(GetClassName)
    __swig_getmethods__["GetClassName"] = lambda x: GetClassName
04131     def getClassName(*args):
        """getClassName(self) -> String"""
        return _ot.SymmetricTensor_getClassName(*args)

04135     def str(*args):
        """str(self) -> String"""
        return _ot.SymmetricTensor_str(*args)

04139     def checkSymmetry(*args):
        """checkSymmetry(self)"""
        return _ot.SymmetricTensor_checkSymmetry(*args)

04143     def getSheet(*args):
        """getSheet(self, UnsignedLong k) -> SymmetricMatrix"""
        return _ot.SymmetricTensor_getSheet(*args)

04147     def setSheet(*args):
        """setSheet(self, UnsignedLong k, SymmetricMatrix m)"""
        return _ot.SymmetricTensor_setSheet(*args)

04151     def __getitem__(*args):
        """__getitem__(self, PyObject args) -> NumericalScalar"""
        return _ot.SymmetricTensor___getitem__(*args)

04155     def __setitem__(*args):
        """__setitem__(self, PyObject args, NumericalScalar val)"""
        return _ot.SymmetricTensor___setitem__(*args)

04159     def __init__(self, *args): 
        """
        __init__(self) -> SymmetricTensor
        __init__(self, UnsignedLong squareDim, UnsignedLong sheetDim) -> SymmetricTensor
        __init__(self, UnsignedLong squareDim, UnsignedLong sheetDim, NumericalScalarCollection elementsValues) -> SymmetricTensor
        __init__(self, SymmetricTensor other) -> SymmetricTensor
        """
        this = _ot.new_SymmetricTensor(*args)
        try: self.this.append(this)
        except: self.this = this
    __swig_destroy__ = _ot.delete_SymmetricTensor
    __del__ = lambda self : None;
SymmetricTensor_swigregister = _ot.SymmetricTensor_swigregister
SymmetricTensor_swigregister(SymmetricTensor)

def SymmetricTensor_GetClassName(*args):
  """SymmetricTensor_GetClassName() -> String"""
  return _ot.SymmetricTensor_GetClassName(*args)

04178 class Cache(PersistentObject):
    """Proxy of C++ Cache class"""
    __swig_setmethods__ = {}
    for _s in [PersistentObject]: __swig_setmethods__.update(getattr(_s,'__swig_setmethods__',{}))
    __setattr__ = lambda self, name, value: _swig_setattr(self, Cache, name, value)
    __swig_getmethods__ = {}
    for _s in [PersistentObject]: __swig_getmethods__.update(getattr(_s,'__swig_getmethods__',{}))
    __getattr__ = lambda self, name: _swig_getattr(self, Cache, name)
    __repr__ = _swig_repr
04187     def GetClassName(*args):
        """GetClassName() -> String"""
        return _ot.Cache_GetClassName(*args)

    if _newclass:GetClassName = staticmethod(GetClassName)
    __swig_getmethods__["GetClassName"] = lambda x: GetClassName
04193     def getClassName(*args):
        """getClassName(self) -> String"""
        return _ot.Cache_getClassName(*args)

04197     def clone(*args):
        """clone(self) -> Cache"""
        return _ot.Cache_clone(*args)

04201     def str(*args):
        """str(self) -> String"""
        return _ot.Cache_str(*args)

04205     def merge(*args):
        """merge(self, Cache other) -> Cache"""
        return _ot.Cache_merge(*args)

04209     def getHits(*args):
        """getHits(self) -> UnsignedLong"""
        return _ot.Cache_getHits(*args)

04213     def hasKey(*args):
        """hasKey(self, NumericalPoint key) -> Bool"""
        return _ot.Cache_hasKey(*args)

04217     def find(*args):
        """find(self, NumericalPoint key) -> NumericalPoint"""
        return _ot.Cache_find(*args)

04221     def add(*args):
        """add(self, NumericalPoint key, NumericalPoint value)"""
        return _ot.Cache_add(*args)

04225     def save(*args):
        """save(self, OpenTURNS::Base::Type::Cache::StorageManager::Advocate adv)"""
        return _ot.Cache_save(*args)

04229     def load(*args):
        """load(self, OpenTURNS::Base::Type::Cache::StorageManager::Advocate adv)"""
        return _ot.Cache_load(*args)

04233     def getSize(*args):
        """getSize(self) -> UnsignedLong"""
        return _ot.Cache_getSize(*args)

04237     def getMaxSize(*args):
        """getMaxSize(self) -> UnsignedLong"""
        return _ot.Cache_getMaxSize(*args)

04241     def isEnabled(*args):
        """isEnabled(self) -> Bool"""
        return _ot.Cache_isEnabled(*args)

04245     def enable(*args):
        """enable(self)"""
        return _ot.Cache_enable(*args)

04249     def disable(*args):
        """disable(self)"""
        return _ot.Cache_disable(*args)

04253     def __init__(self, *args): 
        """
        __init__(self) -> Cache
        __init__(self, UnsignedLong maxSize) -> Cache
        __init__(self, Cache other) -> Cache
        """
        this = _ot.new_Cache(*args)
        try: self.this.append(this)
        except: self.this = this
    __swig_destroy__ = _ot.delete_Cache
    __del__ = lambda self : None;
Cache_swigregister = _ot.Cache_swigregister
Cache_swigregister(Cache)

def Cache_GetClassName(*args):
  """Cache_GetClassName() -> String"""
  return _ot.Cache_GetClassName(*args)

04271 class CovarianceMatrix(SymmetricMatrix):
    """Proxy of C++ CovarianceMatrix class"""
    __swig_setmethods__ = {}
    for _s in [SymmetricMatrix]: __swig_setmethods__.update(getattr(_s,'__swig_setmethods__',{}))
    __setattr__ = lambda self, name, value: _swig_setattr(self, CovarianceMatrix, name, value)
    __swig_getmethods__ = {}
    for _s in [SymmetricMatrix]: __swig_getmethods__.update(getattr(_s,'__swig_getmethods__',{}))
    __getattr__ = lambda self, name: _swig_getattr(self, CovarianceMatrix, name)
    __repr__ = _swig_repr
04280     def GetClassName(*args):
        """GetClassName() -> String"""
        return _ot.CovarianceMatrix_GetClassName(*args)

    if _newclass:GetClassName = staticmethod(GetClassName)
    __swig_getmethods__["GetClassName"] = lambda x: GetClassName
04286     def getClassName(*args):
        """getClassName(self) -> String"""
        return _ot.CovarianceMatrix_getClassName(*args)

04290     def str(*args):
        """str(self) -> String"""
        return _ot.CovarianceMatrix_str(*args)

04294     def transpose(*args):
        """transpose(self) -> CovarianceMatrix"""
        return _ot.CovarianceMatrix_transpose(*args)

04298     def __add__(*args):
        """
        __add__(self, CovarianceMatrix m) -> CovarianceMatrix
        __add__(self, Matrix m) -> Matrix
        __add__(self, SquareMatrix m) -> SquareMatrix
        __add__(self, SymmetricMatrix m) -> SymmetricMatrix
        """
        return _ot.CovarianceMatrix___add__(*args)

04307     def __mul__(*args):
        """
        __mul__(self, IdentityMatrix m) -> CovarianceMatrix
        __mul__(self, Matrix m) -> Matrix
        __mul__(self, SquareMatrix m) -> SquareMatrix
        __mul__(self, SymmetricMatrix m) -> SymmetricMatrix
        __mul__(self, IdentityMatrix m) -> SymmetricMatrix
        __mul__(self, NumericalPoint p) -> NumericalPoint
        __mul__(self, NumericalScalar s) -> SymmetricMatrix
        """
        return _ot.CovarianceMatrix___mul__(*args)

04319     def isPositiveDefinite(*args):
        """isPositiveDefinite(self) -> Bool"""
        return _ot.CovarianceMatrix_isPositiveDefinite(*args)

04323     def computeCholesky(*args):
        """computeCholesky(self) -> SquareMatrix"""
        return _ot.CovarianceMatrix_computeCholesky(*args)

04327     def __getitem__(*args):
        """__getitem__(self, PyObject args) -> NumericalScalar"""
        return _ot.CovarianceMatrix___getitem__(*args)

04331     def __setitem__(*args):
        """__setitem__(self, PyObject args, NumericalScalar val)"""
        return _ot.CovarianceMatrix___setitem__(*args)

04335     def __init__(self, *args): 
        """
        __init__(self) -> CovarianceMatrix
        __init__(self, UnsignedLong dim) -> CovarianceMatrix
        __init__(self, UnsignedLong dim, NumericalScalarCollection elementsValuess) -> CovarianceMatrix
        __init__(self, Implementation i) -> CovarianceMatrix
        __init__(self, CovarianceMatrix other) -> CovarianceMatrix
        """
        this = _ot.new_CovarianceMatrix(*args)
        try: self.this.append(this)
        except: self.this = this
    __swig_destroy__ = _ot.delete_CovarianceMatrix
    __del__ = lambda self : None;
CovarianceMatrix_swigregister = _ot.CovarianceMatrix_swigregister
CovarianceMatrix_swigregister(CovarianceMatrix)

def CovarianceMatrix_GetClassName(*args):
  """CovarianceMatrix_GetClassName() -> String"""
  return _ot.CovarianceMatrix_GetClassName(*args)

04355 class CorrelationMatrix(CovarianceMatrix):
    """Proxy of C++ CorrelationMatrix class"""
    __swig_setmethods__ = {}
    for _s in [CovarianceMatrix]: __swig_setmethods__.update(getattr(_s,'__swig_setmethods__',{}))
    __setattr__ = lambda self, name, value: _swig_setattr(self, CorrelationMatrix, name, value)
    __swig_getmethods__ = {}
    for _s in [CovarianceMatrix]: __swig_getmethods__.update(getattr(_s,'__swig_getmethods__',{}))
    __getattr__ = lambda self, name: _swig_getattr(self, CorrelationMatrix, name)
    __repr__ = _swig_repr
04364     def GetClassName(*args):
        """GetClassName() -> String"""
        return _ot.CorrelationMatrix_GetClassName(*args)

    if _newclass:GetClassName = staticmethod(GetClassName)
    __swig_getmethods__["GetClassName"] = lambda x: GetClassName
04370     def getClassName(*args):
        """getClassName(self) -> String"""
        return _ot.CorrelationMatrix_getClassName(*args)

04374     def str(*args):
        """str(self) -> String"""
        return _ot.CorrelationMatrix_str(*args)

04378     def transpose(*args):
        """transpose(self) -> CorrelationMatrix"""
        return _ot.CorrelationMatrix_transpose(*args)

04382     def __mul__(*args):
        """
        __mul__(self, IdentityMatrix m) -> CorrelationMatrix
        __mul__(self, IdentityMatrix m) -> CovarianceMatrix
        """
        return _ot.CorrelationMatrix___mul__(*args)

04389     def __getitem__(*args):
        """__getitem__(self, PyObject args) -> NumericalScalar"""
        return _ot.CorrelationMatrix___getitem__(*args)

04393     def __setitem__(*args):
        """__setitem__(self, PyObject args, NumericalScalar val)"""
        return _ot.CorrelationMatrix___setitem__(*args)

04397     def __init__(self, *args): 
        """
        __init__(self) -> CorrelationMatrix
        __init__(self, UnsignedLong dim) -> CorrelationMatrix
        __init__(self, UnsignedLong dim, NumericalScalarCollection elementsValues) -> CorrelationMatrix
        __init__(self, CorrelationMatrix other) -> CorrelationMatrix
        """
        this = _ot.new_CorrelationMatrix(*args)
        try: self.this.append(this)
        except: self.this = this
    __swig_destroy__ = _ot.delete_CorrelationMatrix
    __del__ = lambda self : None;
CorrelationMatrix_swigregister = _ot.CorrelationMatrix_swigregister
CorrelationMatrix_swigregister(CorrelationMatrix)

def CorrelationMatrix_GetClassName(*args):
  """CorrelationMatrix_GetClassName() -> String"""
  return _ot.CorrelationMatrix_GetClassName(*args)

04416 class IdentityMatrix(CorrelationMatrix):
    """Proxy of C++ IdentityMatrix class"""
    __swig_setmethods__ = {}
    for _s in [CorrelationMatrix]: __swig_setmethods__.update(getattr(_s,'__swig_setmethods__',{}))
    __setattr__ = lambda self, name, value: _swig_setattr(self, IdentityMatrix, name, value)
    __swig_getmethods__ = {}
    for _s in [CorrelationMatrix]: __swig_getmethods__.update(getattr(_s,'__swig_getmethods__',{}))
    __getattr__ = lambda self, name: _swig_getattr(self, IdentityMatrix, name)
    __repr__ = _swig_repr
04425     def GetClassName(*args):
        """GetClassName() -> String"""
        return _ot.IdentityMatrix_GetClassName(*args)

    if _newclass:GetClassName = staticmethod(GetClassName)
    __swig_getmethods__["GetClassName"] = lambda x: GetClassName
04431     def getClassName(*args):
        """getClassName(self) -> String"""
        return _ot.IdentityMatrix_getClassName(*args)

04435     def str(*args):
        """str(self) -> String"""
        return _ot.IdentityMatrix_str(*args)

04439     def transpose(*args):
        """transpose(self) -> IdentityMatrix"""
        return _ot.IdentityMatrix_transpose(*args)

04443     def __mul__(*args):
        """
        __mul__(self, Matrix m) -> Matrix
        __mul__(self, SquareMatrix m) -> SquareMatrix
        __mul__(self, SymmetricMatrix m) -> SymmetricMatrix
        __mul__(self, CovarianceMatrix m) -> CovarianceMatrix
        __mul__(self, CorrelationMatrix m) -> CorrelationMatrix
        __mul__(self, IdentityMatrix m) -> CorrelationMatrix
        """
        return _ot.IdentityMatrix___mul__(*args)

04454     def solveLinearSystem(*args):
        """
        solveLinearSystem(self, NumericalPoint b) -> NumericalPoint
        solveLinearSystem(self, MatrixImplementation b) -> MatrixImplementation
        """
        return _ot.IdentityMatrix_solveLinearSystem(*args)

04461     def computeDeterminant(*args):
        """computeDeterminant(self) -> NumericalScalar"""
        return _ot.IdentityMatrix_computeDeterminant(*args)

04465     def computeEigenValues(*args):
        """computeEigenValues(self) -> NumericalPoint"""
        return _ot.IdentityMatrix_computeEigenValues(*args)

04469     def isPositiveDefinite(*args):
        """isPositiveDefinite(self) -> Bool"""
        return _ot.IdentityMatrix_isPositiveDefinite(*args)

04473     def computeCholesky(*args):
        """computeCholesky(self) -> SquareMatrix"""
        return _ot.IdentityMatrix_computeCholesky(*args)

04477     def __getitem__(*args):
        """__getitem__(self, PyObject args) -> NumericalScalar"""
        return _ot.IdentityMatrix___getitem__(*args)

04481     def __setitem__(*args):
        """__setitem__(self, PyObject args, NumericalScalar val)"""
        return _ot.IdentityMatrix___setitem__(*args)

04485     def __init__(self, *args): 
        """
        __init__(self) -> IdentityMatrix
        __init__(self, UnsignedLong dim) -> IdentityMatrix
        __init__(self, IdentityMatrix other) -> IdentityMatrix
        """
        this = _ot.new_IdentityMatrix(*args)
        try: self.this.append(this)
        except: self.this = this
    __swig_destroy__ = _ot.delete_IdentityMatrix
    __del__ = lambda self : None;
IdentityMatrix_swigregister = _ot.IdentityMatrix_swigregister
IdentityMatrix_swigregister(IdentityMatrix)

def IdentityMatrix_GetClassName(*args):
  """IdentityMatrix_GetClassName() -> String"""
  return _ot.IdentityMatrix_GetClassName(*args)

04503 class NumericalSampleImplementationTypedInterfaceObject(InterfaceObject):
    """Proxy of C++ NumericalSampleImplementationTypedInterfaceObject class"""
    __swig_setmethods__ = {}
    for _s in [InterfaceObject]: __swig_setmethods__.update(getattr(_s,'__swig_setmethods__',{}))
    __setattr__ = lambda self, name, value: _swig_setattr(self, NumericalSampleImplementationTypedInterfaceObject, name, value)
    __swig_getmethods__ = {}
    for _s in [InterfaceObject]: __swig_getmethods__.update(getattr(_s,'__swig_getmethods__',{}))
    __getattr__ = lambda self, name: _swig_getattr(self, NumericalSampleImplementationTypedInterfaceObject, name)
    __repr__ = _swig_repr
04512     def __init__(self, *args): 
        """
        __init__(self) -> NumericalSampleImplementationTypedInterfaceObject
        __init__(self, Implementation impl) -> NumericalSampleImplementationTypedInterfaceObject
        """
        this = _ot.new_NumericalSampleImplementationTypedInterfaceObject(*args)
        try: self.this.append(this)
        except: self.this = this
04520     def getImplementation(*args):
        """
        getImplementation(self) -> Implementation
        getImplementation(self) -> Implementation
        """
        return _ot.NumericalSampleImplementationTypedInterfaceObject_getImplementation(*args)

04527     def getImplementationAsPersistentObject(*args):
        """getImplementationAsPersistentObject(self) -> ImplementationAsPersistentObject"""
        return _ot.NumericalSampleImplementationTypedInterfaceObject_getImplementationAsPersistentObject(*args)

04531     def setImplementationAsPersistentObject(*args):
        """setImplementationAsPersistentObject(self, ImplementationAsPersistentObject obj)"""
        return _ot.NumericalSampleImplementationTypedInterfaceObject_setImplementationAsPersistentObject(*args)

04535     def swap(*args):
        """swap(self, NumericalSampleImplementationTypedInterfaceObject other)"""
        return _ot.NumericalSampleImplementationTypedInterfaceObject_swap(*args)

04539     def setName(*args):
        """setName(self, String name)"""
        return _ot.NumericalSampleImplementationTypedInterfaceObject_setName(*args)

04543     def getName(*args):
        """getName(self) -> String"""
        return _ot.NumericalSampleImplementationTypedInterfaceObject_getName(*args)

    __swig_destroy__ = _ot.delete_NumericalSampleImplementationTypedInterfaceObject
    __del__ = lambda self : None;
NumericalSampleImplementationTypedInterfaceObject_swigregister = _ot.NumericalSampleImplementationTypedInterfaceObject_swigregister
NumericalSampleImplementationTypedInterfaceObject_swigregister(NumericalSampleImplementationTypedInterfaceObject)

04552 class NumericalSampleImplementationTypedCollectionInterfaceObject(NumericalSampleImplementationTypedInterfaceObject):
    """Proxy of C++ NumericalSampleImplementationTypedCollectionInterfaceObject class"""
    __swig_setmethods__ = {}
    for _s in [NumericalSampleImplementationTypedInterfaceObject]: __swig_setmethods__.update(getattr(_s,'__swig_setmethods__',{}))
    __setattr__ = lambda self, name, value: _swig_setattr(self, NumericalSampleImplementationTypedCollectionInterfaceObject, name, value)
    __swig_getmethods__ = {}
    for _s in [NumericalSampleImplementationTypedInterfaceObject]: __swig_getmethods__.update(getattr(_s,'__swig_getmethods__',{}))
    __getattr__ = lambda self, name: _swig_getattr(self, NumericalSampleImplementationTypedCollectionInterfaceObject, name)
    __repr__ = _swig_repr
04561     def __init__(self, *args): 
        """
        __init__(self) -> NumericalSampleImplementationTypedCollectionInterfaceObject
        __init__(self, Implementation impl) -> NumericalSampleImplementationTypedCollectionInterfaceObject
        """
        this = _ot.new_NumericalSampleImplementationTypedCollectionInterfaceObject(*args)
        try: self.this.append(this)
        except: self.this = this
04569     def __getitem__(*args):
        """__getitem__(self, UnsignedLong i) -> ImplementationElementType"""
        return _ot.NumericalSampleImplementationTypedCollectionInterfaceObject___getitem__(*args)

04573     def __setitem__(*args):
        """__setitem__(self, UnsignedLong i, ImplementationElementType val)"""
        return _ot.NumericalSampleImplementationTypedCollectionInterfaceObject___setitem__(*args)

04577     def add(*args):
        """add(self, ImplementationElementType elt)"""
        return _ot.NumericalSampleImplementationTypedCollectionInterfaceObject_add(*args)

04581     def getSize(*args):
        """getSize(self) -> UnsignedLong"""
        return _ot.NumericalSampleImplementationTypedCollectionInterfaceObject_getSize(*args)

04585     def getDimension(*args):
        """getDimension(self) -> UnsignedLong"""
        return _ot.NumericalSampleImplementationTypedCollectionInterfaceObject_getDimension(*args)

04589     def isEmpty(*args):
        """isEmpty(self) -> Bool"""
        return _ot.NumericalSampleImplementationTypedCollectionInterfaceObject_isEmpty(*args)

04593     def erase(*args):
        """erase(self, UnsignedLong position)"""
        return _ot.NumericalSampleImplementationTypedCollectionInterfaceObject_erase(*args)

    __swig_destroy__ = _ot.delete_NumericalSampleImplementationTypedCollectionInterfaceObject
    __del__ = lambda self : None;
NumericalSampleImplementationTypedCollectionInterfaceObject_swigregister = _ot.NumericalSampleImplementationTypedCollectionInterfaceObject_swigregister
NumericalSampleImplementationTypedCollectionInterfaceObject_swigregister(NumericalSampleImplementationTypedCollectionInterfaceObject)

04602 class NumericalSampleImplementation(NumericalPointPersistentCollection):
    """Proxy of C++ NumericalSampleImplementation class"""
    __swig_setmethods__ = {}
    for _s in [NumericalPointPersistentCollection]: __swig_setmethods__.update(getattr(_s,'__swig_setmethods__',{}))
    __setattr__ = lambda self, name, value: _swig_setattr(self, NumericalSampleImplementation, name, value)
    __swig_getmethods__ = {}
    for _s in [NumericalPointPersistentCollection]: __swig_getmethods__.update(getattr(_s,'__swig_getmethods__',{}))
    __getattr__ = lambda self, name: _swig_getattr(self, NumericalSampleImplementation, name)
    __repr__ = _swig_repr
04611     def GetClassName(*args):
        """GetClassName() -> String"""
        return _ot.NumericalSampleImplementation_GetClassName(*args)

    if _newclass:GetClassName = staticmethod(GetClassName)
    __swig_getmethods__["GetClassName"] = lambda x: GetClassName
04617     def getClassName(*args):
        """getClassName(self) -> String"""
        return _ot.NumericalSampleImplementation_getClassName(*args)

    CSV = _ot.NumericalSampleImplementation_CSV
04622     def GetFromFile(*args):
        """
        GetFromFile(FileName fileName, ExternalFileFormat format=CSV) -> NumericalSampleImplementation
        GetFromFile(FileName fileName) -> NumericalSampleImplementation
        """
        return _ot.NumericalSampleImplementation_GetFromFile(*args)

    if _newclass:GetFromFile = staticmethod(GetFromFile)
    __swig_getmethods__["GetFromFile"] = lambda x: GetFromFile
04631     def BuildFromCSVFile(*args):
        """BuildFromCSVFile(FileName fileName) -> NumericalSampleImplementation"""
        return _ot.NumericalSampleImplementation_BuildFromCSVFile(*args)

    if _newclass:BuildFromCSVFile = staticmethod(BuildFromCSVFile)
    __swig_getmethods__["BuildFromCSVFile"] = lambda x: BuildFromCSVFile
04637     def storeToTemporaryFile(*args):
        """storeToTemporaryFile(self) -> String"""
        return _ot.NumericalSampleImplementation_storeToTemporaryFile(*args)

04641     def streamToRFormat(*args):
        """streamToRFormat(self) -> String"""
        return _ot.NumericalSampleImplementation_streamToRFormat(*args)

04645     def __init__(self, *args): 
        """
        __init__(self, UnsignedLong size, UnsignedLong dim) -> NumericalSampleImplementation
        __init__(self, UnsignedLong size, NumericalPoint point) -> NumericalSampleImplementation
        """
        this = _ot.new_NumericalSampleImplementation(*args)
        try: self.this.append(this)
        except: self.this = this
04653     def clone(*args):
        """clone(self) -> NumericalSampleImplementation"""
        return _ot.NumericalSampleImplementation_clone(*args)

04657     def setDescription(*args):
        """setDescription(self, Description description)"""
        return _ot.NumericalSampleImplementation_setDescription(*args)

04661     def getDescription(*args):
        """getDescription(self) -> Description"""
        return _ot.NumericalSampleImplementation_getDescription(*args)

04665     def __eq__(*args):
        """__eq__(self, NumericalSampleImplementation other) -> Bool"""
        return _ot.NumericalSampleImplementation___eq__(*args)

04669     def str(*args):
        """str(self) -> String"""
        return _ot.NumericalSampleImplementation_str(*args)

04673     def getDimension(*args):
        """getDimension(self) -> UnsignedLong"""
        return _ot.NumericalSampleImplementation_getDimension(*args)

04677     def add(*args):
        """add(self, NumericalPoint point)"""
        return _ot.NumericalSampleImplementation_add(*args)

04681     def computeMean(*args):
        """computeMean(self) -> NumericalPoint"""
        return _ot.NumericalSampleImplementation_computeMean(*args)

04685     def computeCovariance(*args):
        """computeCovariance(self) -> CovarianceMatrix"""
        return _ot.NumericalSampleImplementation_computeCovariance(*args)

04689     def computeStandardDeviation(*args):
        """computeStandardDeviation(self) -> SquareMatrix"""
        return _ot.NumericalSampleImplementation_computeStandardDeviation(*args)

04693     def computeStandardDeviationPerComponent(*args):
        """computeStandardDeviationPerComponent(self) -> NumericalPoint"""
        return _ot.NumericalSampleImplementation_computeStandardDeviationPerComponent(*args)

04697     def computePearsonCorrelation(*args):
        """computePearsonCorrelation(self) -> CorrelationMatrix"""
        return _ot.NumericalSampleImplementation_computePearsonCorrelation(*args)

04701     def computeSpearmanCorrelation(*args):
        """computeSpearmanCorrelation(self) -> CorrelationMatrix"""
        return _ot.NumericalSampleImplementation_computeSpearmanCorrelation(*args)

04705     def computeKendallTau(*args):
        """computeKendallTau(self) -> CorrelationMatrix"""
        return _ot.NumericalSampleImplementation_computeKendallTau(*args)

04709     def computeRangePerComponent(*args):
        """computeRangePerComponent(self) -> NumericalPoint"""
        return _ot.NumericalSampleImplementation_computeRangePerComponent(*args)

04713     def computeMedianPerComponent(*args):
        """computeMedianPerComponent(self) -> NumericalPoint"""
        return _ot.NumericalSampleImplementation_computeMedianPerComponent(*args)

04717     def computeVariancePerComponent(*args):
        """computeVariancePerComponent(self) -> NumericalPoint"""
        return _ot.NumericalSampleImplementation_computeVariancePerComponent(*args)

04721     def computeSkewnessPerComponent(*args):
        """computeSkewnessPerComponent(self) -> NumericalPoint"""
        return _ot.NumericalSampleImplementation_computeSkewnessPerComponent(*args)

04725     def computeKurtosisPerComponent(*args):
        """computeKurtosisPerComponent(self) -> NumericalPoint"""
        return _ot.NumericalSampleImplementation_computeKurtosisPerComponent(*args)

04729     def computeQuantilePerComponent(*args):
        """computeQuantilePerComponent(self, NumericalScalar prob) -> NumericalPoint"""
        return _ot.NumericalSampleImplementation_computeQuantilePerComponent(*args)

04733     def computeQuantile(*args):
        """computeQuantile(self, NumericalScalar prob) -> NumericalPoint"""
        return _ot.NumericalSampleImplementation_computeQuantile(*args)

04737     def computeEmpiricalCDF(*args):
        """computeEmpiricalCDF(self, NumericalPoint point) -> NumericalScalar"""
        return _ot.NumericalSampleImplementation_computeEmpiricalCDF(*args)

04741     def getMax(*args):
        """getMax(self) -> NumericalPoint"""
        return _ot.NumericalSampleImplementation_getMax(*args)

04745     def getMin(*args):
        """getMin(self) -> NumericalPoint"""
        return _ot.NumericalSampleImplementation_getMin(*args)

04749     def rank(*args):
        """
        rank(self) -> NumericalSampleImplementation
        rank(self, UnsignedLong index) -> NumericalSampleImplementation
        """
        return _ot.NumericalSampleImplementation_rank(*args)

04756     def sort(*args):
        """
        sort(self) -> NumericalSampleImplementation
        sort(self, UnsignedLong index) -> NumericalSampleImplementation
        """
        return _ot.NumericalSampleImplementation_sort(*args)

04763     def sortAccordingAComponent(*args):
        """sortAccordingAComponent(self, UnsignedLong index) -> NumericalSampleImplementation"""
        return _ot.NumericalSampleImplementation_sortAccordingAComponent(*args)

04767     def getMarginal(*args):
        """
        getMarginal(self, UnsignedLong index) -> NumericalSampleImplementation
        getMarginal(self, Indices indices) -> NumericalSampleImplementation
        """
        return _ot.NumericalSampleImplementation_getMarginal(*args)

04774     def translate(*args):
        """translate(self, NumericalPoint translation)"""
        return _ot.NumericalSampleImplementation_translate(*args)

04778     def scale(*args):
        """scale(self, NumericalPoint scaling)"""
        return _ot.NumericalSampleImplementation_scale(*args)

04782     def exportToCSVFile(*args):
        """exportToCSVFile(self, FileName filename)"""
        return _ot.NumericalSampleImplementation_exportToCSVFile(*args)

04786     def save(*args):
        """save(self, OpenTURNS::Base::Stat::NumericalSampleImplementation::StorageManager::Advocate adv)"""
        return _ot.NumericalSampleImplementation_save(*args)

04790     def load(*args):
        """load(self, OpenTURNS::Base::Stat::NumericalSampleImplementation::StorageManager::Advocate adv)"""
        return _ot.NumericalSampleImplementation_load(*args)

    __swig_destroy__ = _ot.delete_NumericalSampleImplementation
    __del__ = lambda self : None;
NumericalSampleImplementation_swigregister = _ot.NumericalSampleImplementation_swigregister
NumericalSampleImplementation_swigregister(NumericalSampleImplementation)

def NumericalSampleImplementation_GetClassName(*args):
  """NumericalSampleImplementation_GetClassName() -> String"""
  return _ot.NumericalSampleImplementation_GetClassName(*args)

def NumericalSampleImplementation_GetFromFile(*args):
  """
    GetFromFile(FileName fileName, ExternalFileFormat format=CSV) -> NumericalSampleImplementation
    NumericalSampleImplementation_GetFromFile(FileName fileName) -> NumericalSampleImplementation
    """
  return _ot.NumericalSampleImplementation_GetFromFile(*args)

def NumericalSampleImplementation_BuildFromCSVFile(*args):
  """NumericalSampleImplementation_BuildFromCSVFile(FileName fileName) -> NumericalSampleImplementation"""
  return _ot.NumericalSampleImplementation_BuildFromCSVFile(*args)

04814 class NumericalSample(NumericalSampleImplementationTypedCollectionInterfaceObject):
    """Proxy of C++ NumericalSample class"""
    __swig_setmethods__ = {}
    for _s in [NumericalSampleImplementationTypedCollectionInterfaceObject]: __swig_setmethods__.update(getattr(_s,'__swig_setmethods__',{}))
    __setattr__ = lambda self, name, value: _swig_setattr(self, NumericalSample, name, value)
    __swig_getmethods__ = {}
    for _s in [NumericalSampleImplementationTypedCollectionInterfaceObject]: __swig_getmethods__.update(getattr(_s,'__swig_getmethods__',{}))
    __getattr__ = lambda self, name: _swig_getattr(self, NumericalSample, name)
    __repr__ = _swig_repr
04823     def GetClassName(*args):
        """GetClassName() -> String"""
        return _ot.NumericalSample_GetClassName(*args)

    if _newclass:GetClassName = staticmethod(GetClassName)
    __swig_getmethods__["GetClassName"] = lambda x: GetClassName
04829     def getClassName(*args):
        """getClassName(self) -> String"""
        return _ot.NumericalSample_getClassName(*args)

04833     def ImportFromCSVFile(*args):
        """ImportFromCSVFile(FileName fileName) -> NumericalSample"""
        return _ot.NumericalSample_ImportFromCSVFile(*args)

    if _newclass:ImportFromCSVFile = staticmethod(ImportFromCSVFile)
    __swig_getmethods__["ImportFromCSVFile"] = lambda x: ImportFromCSVFile
04839     def exportToCSVFile(*args):
        """exportToCSVFile(self, FileName fileName)"""
        return _ot.NumericalSample_exportToCSVFile(*args)

04843     def streamToRFormat(*args):
        """streamToRFormat(self) -> String"""
        return _ot.NumericalSample_streamToRFormat(*args)

04847     def __eq__(*args):
        """__eq__(self, NumericalSample other) -> Bool"""
        return _ot.NumericalSample___eq__(*args)

04851     def str(*args):
        """str(self) -> String"""
        return _ot.NumericalSample_str(*args)

04855     def setDescription(*args):
        """setDescription(self, Description description)"""
        return _ot.NumericalSample_setDescription(*args)

04859     def getDescription(*args):
        """getDescription(self) -> Description"""
        return _ot.NumericalSample_getDescription(*args)

04863     def __getitem__(*args):
        """__getitem__(self, UnsignedLong i) -> NumericalPoint"""
        return _ot.NumericalSample___getitem__(*args)

04867     def __setitem__(*args):
        """__setitem__(self, UnsignedLong i, NumericalPoint val)"""
        return _ot.NumericalSample___setitem__(*args)

04871     def getDimension(*args):
        """getDimension(self) -> UnsignedLong"""
        return _ot.NumericalSample_getDimension(*args)

04875     def getSize(*args):
        """getSize(self) -> UnsignedLong"""
        return _ot.NumericalSample_getSize(*args)

04879     def getMax(*args):
        """getMax(self) -> NumericalPoint"""
        return _ot.NumericalSample_getMax(*args)

04883     def getMin(*args):
        """getMin(self) -> NumericalPoint"""
        return _ot.NumericalSample_getMin(*args)

04887     def add(*args):
        """add(self, NumericalPoint point)"""
        return _ot.NumericalSample_add(*args)

04891     def split(*args):
        """split(self, UnsignedLong index) -> NumericalSample"""
        return _ot.NumericalSample_split(*args)

04895     def computeMean(*args):
        """computeMean(self) -> NumericalPoint"""
        return _ot.NumericalSample_computeMean(*args)

04899     def computeCovariance(*args):
        """computeCovariance(self) -> CovarianceMatrix"""
        return _ot.NumericalSample_computeCovariance(*args)

04903     def computeStandardDeviation(*args):
        """computeStandardDeviation(self) -> SquareMatrix"""
        return _ot.NumericalSample_computeStandardDeviation(*args)

04907     def computeStandardDeviationPerComponent(*args):
        """computeStandardDeviationPerComponent(self) -> NumericalPoint"""
        return _ot.NumericalSample_computeStandardDeviationPerComponent(*args)

04911     def computePearsonCorrelation(*args):
        """computePearsonCorrelation(self) -> CorrelationMatrix"""
        return _ot.NumericalSample_computePearsonCorrelation(*args)

04915     def computeSpearmanCorrelation(*args):
        """computeSpearmanCorrelation(self) -> CorrelationMatrix"""
        return _ot.NumericalSample_computeSpearmanCorrelation(*args)

04919     def computeKendallTau(*args):
        """computeKendallTau(self) -> CorrelationMatrix"""
        return _ot.NumericalSample_computeKendallTau(*args)

04923     def computeRangePerComponent(*args):
        """computeRangePerComponent(self) -> NumericalPoint"""
        return _ot.NumericalSample_computeRangePerComponent(*args)

04927     def computeMedianPerComponent(*args):
        """computeMedianPerComponent(self) -> NumericalPoint"""
        return _ot.NumericalSample_computeMedianPerComponent(*args)

04931     def computeVariancePerComponent(*args):
        """computeVariancePerComponent(self) -> NumericalPoint"""
        return _ot.NumericalSample_computeVariancePerComponent(*args)

04935     def computeSkewnessPerComponent(*args):
        """computeSkewnessPerComponent(self) -> NumericalPoint"""
        return _ot.NumericalSample_computeSkewnessPerComponent(*args)

04939     def computeKurtosisPerComponent(*args):
        """computeKurtosisPerComponent(self) -> NumericalPoint"""
        return _ot.NumericalSample_computeKurtosisPerComponent(*args)

04943     def computeQuantilePerComponent(*args):
        """computeQuantilePerComponent(self, NumericalScalar prob) -> NumericalPoint"""
        return _ot.NumericalSample_computeQuantilePerComponent(*args)

04947     def computeQuantile(*args):
        """computeQuantile(self, NumericalScalar prob) -> NumericalPoint"""
        return _ot.NumericalSample_computeQuantile(*args)

04951     def computeEmpiricalCDF(*args):
        """computeEmpiricalCDF(self, NumericalPoint point) -> NumericalScalar"""
        return _ot.NumericalSample_computeEmpiricalCDF(*args)

04955     def find(*args):
        """find(self, NumericalPoint point) -> UnsignedLong"""
        return _ot.NumericalSample_find(*args)

04959     def translate(*args):
        """translate(self, NumericalPoint translation)"""
        return _ot.NumericalSample_translate(*args)

04963     def scale(*args):
        """scale(self, NumericalPoint scaling)"""
        return _ot.NumericalSample_scale(*args)

04967     def rank(*args):
        """
        rank(self) -> NumericalSample
        rank(self, UnsignedLong index) -> NumericalSample
        """
        return _ot.NumericalSample_rank(*args)

04974     def sort(*args):
        """
        sort(self) -> NumericalSample
        sort(self, UnsignedLong index) -> NumericalSample
        """
        return _ot.NumericalSample_sort(*args)

04981     def sortAccordingAComponent(*args):
        """sortAccordingAComponent(self, UnsignedLong index) -> NumericalSample"""
        return _ot.NumericalSample_sortAccordingAComponent(*args)

04985     def storeToTemporaryFile(*args):
        """storeToTemporaryFile(self) -> String"""
        return _ot.NumericalSample_storeToTemporaryFile(*args)

04989     def getMarginal(*args):
        """
        getMarginal(self, UnsignedLong index) -> NumericalSample
        getMarginal(self, Indices indices) -> NumericalSample
        """
        return _ot.NumericalSample_getMarginal(*args)

04996     def getImplementationAsPersistentObject(*args):
        """getImplementationAsPersistentObject(self) -> ImplementationAsPersistentObject"""
        return _ot.NumericalSample_getImplementationAsPersistentObject(*args)

05000     def setImplementationAsPersistentObject(*args):
        """setImplementationAsPersistentObject(self, ImplementationAsPersistentObject obj)"""
        return _ot.NumericalSample_setImplementationAsPersistentObject(*args)

05004     def __init__(self, *args): 
        """
        __init__(self) -> NumericalSample
        __init__(self, UnsignedLong size, UnsignedLong dim) -> NumericalSample
        __init__(self, UnsignedLong size, NumericalPoint point) -> NumericalSample
        __init__(self, NumericalSampleImplementation implementation) -> NumericalSample
        __init__(self, NumericalSample other) -> NumericalSample
        """
        this = _ot.new_NumericalSample(*args)
        try: self.this.append(this)
        except: self.this = this
    __swig_destroy__ = _ot.delete_NumericalSample
    __del__ = lambda self : None;
NumericalSample_swigregister = _ot.NumericalSample_swigregister
NumericalSample_swigregister(NumericalSample)

def NumericalSample_GetClassName(*args):
  """NumericalSample_GetClassName() -> String"""
  return _ot.NumericalSample_GetClassName(*args)

def NumericalSample_ImportFromCSVFile(*args):
  """NumericalSample_ImportFromCSVFile(FileName fileName) -> NumericalSample"""
  return _ot.NumericalSample_ImportFromCSVFile(*args)

05028 class HistoryStrategyImplementation(PersistentObject):
    """Proxy of C++ HistoryStrategyImplementation class"""
    __swig_setmethods__ = {}
    for _s in [PersistentObject]: __swig_setmethods__.update(getattr(_s,'__swig_setmethods__',{}))
    __setattr__ = lambda self, name, value: _swig_setattr(self, HistoryStrategyImplementation, name, value)
    __swig_getmethods__ = {}
    for _s in [PersistentObject]: __swig_getmethods__.update(getattr(_s,'__swig_getmethods__',{}))
    __getattr__ = lambda self, name: _swig_getattr(self, HistoryStrategyImplementation, name)
    __repr__ = _swig_repr
05037     def GetClassName(*args):
        """GetClassName() -> String"""
        return _ot.HistoryStrategyImplementation_GetClassName(*args)

    if _newclass:GetClassName = staticmethod(GetClassName)
    __swig_getmethods__["GetClassName"] = lambda x: GetClassName
05043     def getClassName(*args):
        """getClassName(self) -> String"""
        return _ot.HistoryStrategyImplementation_getClassName(*args)

05047     def clone(*args):
        """clone(self) -> HistoryStrategyImplementation"""
        return _ot.HistoryStrategyImplementation_clone(*args)

05051     def store(*args):
        """store(self, NumericalPoint point)"""
        return _ot.HistoryStrategyImplementation_store(*args)

05055     def reset(*args):
        """reset(self)"""
        return _ot.HistoryStrategyImplementation_reset(*args)

05059     def getSample(*args):
        """getSample(self) -> NumericalSample"""
        return _ot.HistoryStrategyImplementation_getSample(*args)

05063     def str(*args):
        """str(self) -> String"""
        return _ot.HistoryStrategyImplementation_str(*args)

05067     def __init__(self, *args): 
        """
        __init__(self) -> HistoryStrategyImplementation
        __init__(self, HistoryStrategyImplementation other) -> HistoryStrategyImplementation
        """
        this = _ot.new_HistoryStrategyImplementation(*args)
        try: self.this.append(this)
        except: self.this = this
    __swig_destroy__ = _ot.delete_HistoryStrategyImplementation
    __del__ = lambda self : None;
HistoryStrategyImplementation_swigregister = _ot.HistoryStrategyImplementation_swigregister
HistoryStrategyImplementation_swigregister(HistoryStrategyImplementation)

def HistoryStrategyImplementation_GetClassName(*args):
  """HistoryStrategyImplementation_GetClassName() -> String"""
  return _ot.HistoryStrategyImplementation_GetClassName(*args)

05084 class HistoryStrategyImplementationTypedInterfaceObject(InterfaceObject):
    """Proxy of C++ HistoryStrategyImplementationTypedInterfaceObject class"""
    __swig_setmethods__ = {}
    for _s in [InterfaceObject]: __swig_setmethods__.update(getattr(_s,'__swig_setmethods__',{}))
    __setattr__ = lambda self, name, value: _swig_setattr(self, HistoryStrategyImplementationTypedInterfaceObject, name, value)
    __swig_getmethods__ = {}
    for _s in [InterfaceObject]: __swig_getmethods__.update(getattr(_s,'__swig_getmethods__',{}))
    __getattr__ = lambda self, name: _swig_getattr(self, HistoryStrategyImplementationTypedInterfaceObject, name)
    __repr__ = _swig_repr
05093     def __init__(self, *args): 
        """
        __init__(self) -> HistoryStrategyImplementationTypedInterfaceObject
        __init__(self, Implementation impl) -> HistoryStrategyImplementationTypedInterfaceObject
        """
        this = _ot.new_HistoryStrategyImplementationTypedInterfaceObject(*args)
        try: self.this.append(this)
        except: self.this = this
05101     def getImplementation(*args):
        """
        getImplementation(self) -> Implementation
        getImplementation(self) -> Implementation
        """
        return _ot.HistoryStrategyImplementationTypedInterfaceObject_getImplementation(*args)

05108     def getImplementationAsPersistentObject(*args):
        """getImplementationAsPersistentObject(self) -> ImplementationAsPersistentObject"""
        return _ot.HistoryStrategyImplementationTypedInterfaceObject_getImplementationAsPersistentObject(*args)

05112     def setImplementationAsPersistentObject(*args):
        """setImplementationAsPersistentObject(self, ImplementationAsPersistentObject obj)"""
        return _ot.HistoryStrategyImplementationTypedInterfaceObject_setImplementationAsPersistentObject(*args)

05116     def swap(*args):
        """swap(self, HistoryStrategyImplementationTypedInterfaceObject other)"""
        return _ot.HistoryStrategyImplementationTypedInterfaceObject_swap(*args)

05120     def setName(*args):
        """setName(self, String name)"""
        return _ot.HistoryStrategyImplementationTypedInterfaceObject_setName(*args)

05124     def getName(*args):
        """getName(self) -> String"""
        return _ot.HistoryStrategyImplementationTypedInterfaceObject_getName(*args)

    __swig_destroy__ = _ot.delete_HistoryStrategyImplementationTypedInterfaceObject
    __del__ = lambda self : None;
HistoryStrategyImplementationTypedInterfaceObject_swigregister = _ot.HistoryStrategyImplementationTypedInterfaceObject_swigregister
HistoryStrategyImplementationTypedInterfaceObject_swigregister(HistoryStrategyImplementationTypedInterfaceObject)

05133 class HistoryStrategy(HistoryStrategyImplementationTypedInterfaceObject):
    """Proxy of C++ HistoryStrategy class"""
    __swig_setmethods__ = {}
    for _s in [HistoryStrategyImplementationTypedInterfaceObject]: __swig_setmethods__.update(getattr(_s,'__swig_setmethods__',{}))
    __setattr__ = lambda self, name, value: _swig_setattr(self, HistoryStrategy, name, value)
    __swig_getmethods__ = {}
    for _s in [HistoryStrategyImplementationTypedInterfaceObject]: __swig_getmethods__.update(getattr(_s,'__swig_getmethods__',{}))
    __getattr__ = lambda self, name: _swig_getattr(self, HistoryStrategy, name)
    __repr__ = _swig_repr
05142     def GetClassName(*args):
        """GetClassName() -> String"""
        return _ot.HistoryStrategy_GetClassName(*args)

    if _newclass:GetClassName = staticmethod(GetClassName)
    __swig_getmethods__["GetClassName"] = lambda x: GetClassName
05148     def getClassName(*args):
        """getClassName(self) -> String"""
        return _ot.HistoryStrategy_getClassName(*args)

05152     def store(*args):
        """store(self, NumericalPoint point)"""
        return _ot.HistoryStrategy_store(*args)

05156     def reset(*args):
        """reset(self)"""
        return _ot.HistoryStrategy_reset(*args)

05160     def getSample(*args):
        """getSample(self) -> NumericalSample"""
        return _ot.HistoryStrategy_getSample(*args)

05164     def str(*args):
        """str(self) -> String"""
        return _ot.HistoryStrategy_str(*args)

05168     def __init__(self, *args): 
        """
        __init__(self) -> HistoryStrategy
        __init__(self, HistoryStrategyImplementation implementation) -> HistoryStrategy
        __init__(self, Implementation p_implementation) -> HistoryStrategy
        __init__(self, HistoryStrategy other) -> HistoryStrategy
        """
        this = _ot.new_HistoryStrategy(*args)
        try: self.this.append(this)
        except: self.this = this
    __swig_destroy__ = _ot.delete_HistoryStrategy
    __del__ = lambda self : None;
HistoryStrategy_swigregister = _ot.HistoryStrategy_swigregister
HistoryStrategy_swigregister(HistoryStrategy)

def HistoryStrategy_GetClassName(*args):
  """HistoryStrategy_GetClassName() -> String"""
  return _ot.HistoryStrategy_GetClassName(*args)

05187 class Compact(HistoryStrategyImplementation):
    """Proxy of C++ Compact class"""
    __swig_setmethods__ = {}
    for _s in [HistoryStrategyImplementation]: __swig_setmethods__.update(getattr(_s,'__swig_setmethods__',{}))
    __setattr__ = lambda self, name, value: _swig_setattr(self, Compact, name, value)
    __swig_getmethods__ = {}
    for _s in [HistoryStrategyImplementation]: __swig_getmethods__.update(getattr(_s,'__swig_getmethods__',{}))
    __getattr__ = lambda self, name: _swig_getattr(self, Compact, name)
    __repr__ = _swig_repr
05196     def GetClassName(*args):
        """GetClassName() -> String"""
        return _ot.Compact_GetClassName(*args)

    if _newclass:GetClassName = staticmethod(GetClassName)
    __swig_getmethods__["GetClassName"] = lambda x: GetClassName
05202     def getClassName(*args):
        """getClassName(self) -> String"""
        return _ot.Compact_getClassName(*args)

    DefaultHalfMaximumSize = _ot.Compact_DefaultHalfMaximumSize
05207     def clone(*args):
        """clone(self) -> Compact"""
        return _ot.Compact_clone(*args)

05211     def store(*args):
        """store(self, NumericalPoint point)"""
        return _ot.Compact_store(*args)

05215     def getSample(*args):
        """getSample(self) -> NumericalSample"""
        return _ot.Compact_getSample(*args)

05219     def getHalfMaximumSize(*args):
        """getHalfMaximumSize(self) -> UnsignedLong"""
        return _ot.Compact_getHalfMaximumSize(*args)

05223     def getIndex(*args):
        """getIndex(self) -> UnsignedLong"""
        return _ot.Compact_getIndex(*args)

05227     def str(*args):
        """str(self) -> String"""
        return _ot.Compact_str(*args)

05231     def __init__(self, *args): 
        """
        __init__(self) -> Compact
        __init__(self, UnsignedLong halfMaximumSize) -> Compact
        __init__(self, Compact other) -> Compact
        """
        this = _ot.new_Compact(*args)
        try: self.this.append(this)
        except: self.this = this
    __swig_destroy__ = _ot.delete_Compact
    __del__ = lambda self : None;
Compact_swigregister = _ot.Compact_swigregister
Compact_swigregister(Compact)

def Compact_GetClassName(*args):
  """Compact_GetClassName() -> String"""
  return _ot.Compact_GetClassName(*args)

05249 class Full(HistoryStrategyImplementation):
    """Proxy of C++ Full class"""
    __swig_setmethods__ = {}
    for _s in [HistoryStrategyImplementation]: __swig_setmethods__.update(getattr(_s,'__swig_setmethods__',{}))
    __setattr__ = lambda self, name, value: _swig_setattr(self, Full, name, value)
    __swig_getmethods__ = {}
    for _s in [HistoryStrategyImplementation]: __swig_getmethods__.update(getattr(_s,'__swig_getmethods__',{}))
    __getattr__ = lambda self, name: _swig_getattr(self, Full, name)
    __repr__ = _swig_repr
05258     def GetClassName(*args):
        """GetClassName() -> String"""
        return _ot.Full_GetClassName(*args)

    if _newclass:GetClassName = staticmethod(GetClassName)
    __swig_getmethods__["GetClassName"] = lambda x: GetClassName
05264     def getClassName(*args):
        """getClassName(self) -> String"""
        return _ot.Full_getClassName(*args)

05268     def clone(*args):
        """clone(self) -> Full"""
        return _ot.Full_clone(*args)

05272     def store(*args):
        """store(self, NumericalPoint point)"""
        return _ot.Full_store(*args)

05276     def str(*args):
        """str(self) -> String"""
        return _ot.Full_str(*args)

05280     def __init__(self, *args): 
        """
        __init__(self) -> Full
        __init__(self, Full other) -> Full
        """
        this = _ot.new_Full(*args)
        try: self.this.append(this)
        except: self.this = this
    __swig_destroy__ = _ot.delete_Full
    __del__ = lambda self : None;
Full_swigregister = _ot.Full_swigregister
Full_swigregister(Full)

def Full_GetClassName(*args):
  """Full_GetClassName() -> String"""
  return _ot.Full_GetClassName(*args)

05297 class Last(HistoryStrategyImplementation):
    """Proxy of C++ Last class"""
    __swig_setmethods__ = {}
    for _s in [HistoryStrategyImplementation]: __swig_setmethods__.update(getattr(_s,'__swig_setmethods__',{}))
    __setattr__ = lambda self, name, value: _swig_setattr(self, Last, name, value)
    __swig_getmethods__ = {}
    for _s in [HistoryStrategyImplementation]: __swig_getmethods__.update(getattr(_s,'__swig_getmethods__',{}))
    __getattr__ = lambda self, name: _swig_getattr(self, Last, name)
    __repr__ = _swig_repr
05306     def GetClassName(*args):
        """GetClassName() -> String"""
        return _ot.Last_GetClassName(*args)

    if _newclass:GetClassName = staticmethod(GetClassName)
    __swig_getmethods__["GetClassName"] = lambda x: GetClassName
05312     def getClassName(*args):
        """getClassName(self) -> String"""
        return _ot.Last_getClassName(*args)

    DefaultMaximumSize = _ot.Last_DefaultMaximumSize
05317     def clone(*args):
        """clone(self) -> Last"""
        return _ot.Last_clone(*args)

05321     def store(*args):
        """store(self, NumericalPoint point)"""
        return _ot.Last_store(*args)

05325     def getSample(*args):
        """getSample(self) -> NumericalSample"""
        return _ot.Last_getSample(*args)

05329     def getMaximumSize(*args):
        """getMaximumSize(self) -> UnsignedLong"""
        return _ot.Last_getMaximumSize(*args)

05333     def getIndex(*args):
        """getIndex(self) -> UnsignedLong"""
        return _ot.Last_getIndex(*args)

05337     def getHasWrapped(*args):
        """getHasWrapped(self) -> Bool"""
        return _ot.Last_getHasWrapped(*args)

05341     def str(*args):
        """str(self) -> String"""
        return _ot.Last_str(*args)

05345     def __init__(self, *args): 
        """
        __init__(self) -> Last
        __init__(self, UnsignedLong maximumSize) -> Last
        __init__(self, Last other) -> Last
        """
        this = _ot.new_Last(*args)
        try: self.this.append(this)
        except: self.this = this
    __swig_destroy__ = _ot.delete_Last
    __del__ = lambda self : None;
Last_swigregister = _ot.Last_swigregister
Last_swigregister(Last)

def Last_GetClassName(*args):
  """Last_GetClassName() -> String"""
  return _ot.Last_GetClassName(*args)

05363 class Null(HistoryStrategyImplementation):
    """Proxy of C++ Null class"""
    __swig_setmethods__ = {}
    for _s in [HistoryStrategyImplementation]: __swig_setmethods__.update(getattr(_s,'__swig_setmethods__',{}))
    __setattr__ = lambda self, name, value: _swig_setattr(self, Null, name, value)
    __swig_getmethods__ = {}
    for _s in [HistoryStrategyImplementation]: __swig_getmethods__.update(getattr(_s,'__swig_getmethods__',{}))
    __getattr__ = lambda self, name: _swig_getattr(self, Null, name)
    __repr__ = _swig_repr
05372     def GetClassName(*args):
        """GetClassName() -> String"""
        return _ot.Null_GetClassName(*args)

    if _newclass:GetClassName = staticmethod(GetClassName)
    __swig_getmethods__["GetClassName"] = lambda x: GetClassName
05378     def getClassName(*args):
        """getClassName(self) -> String"""
        return _ot.Null_getClassName(*args)

05382     def clone(*args):
        """clone(self) -> Null"""
        return _ot.Null_clone(*args)

05386     def store(*args):
        """store(self, NumericalPoint point)"""
        return _ot.Null_store(*args)

05390     def str(*args):
        """str(self) -> String"""
        return _ot.Null_str(*args)

05394     def __init__(self, *args): 
        """
        __init__(self) -> Null
        __init__(self, Null other) -> Null
        """
        this = _ot.new_Null(*args)
        try: self.this.append(this)
        except: self.this = this
    __swig_destroy__ = _ot.delete_Null
    __del__ = lambda self : None;
Null_swigregister = _ot.Null_swigregister
Null_swigregister(Null)

def Null_GetClassName(*args):
  """Null_GetClassName() -> String"""
  return _ot.Null_GetClassName(*args)

05411 class ConfidenceInterval(PersistentObject):
    """Proxy of C++ ConfidenceInterval class"""
    __swig_setmethods__ = {}
    for _s in [PersistentObject]: __swig_setmethods__.update(getattr(_s,'__swig_setmethods__',{}))
    __setattr__ = lambda self, name, value: _swig_setattr(self, ConfidenceInterval, name, value)
    __swig_getmethods__ = {}
    for _s in [PersistentObject]: __swig_getmethods__.update(getattr(_s,'__swig_getmethods__',{}))
    __getattr__ = lambda self, name: _swig_getattr(self, ConfidenceInterval, name)
    __repr__ = _swig_repr
05420     def GetClassName(*args):
        """GetClassName() -> String"""
        return _ot.ConfidenceInterval_GetClassName(*args)

    if _newclass:GetClassName = staticmethod(GetClassName)
    __swig_getmethods__["GetClassName"] = lambda x: GetClassName
05426     def getClassName(*args):
        """getClassName(self) -> String"""
        return _ot.ConfidenceInterval_getClassName(*args)

05430     def clone(*args):
        """clone(self) -> ConfidenceInterval"""
        return _ot.ConfidenceInterval_clone(*args)

05434     def setDescription(*args):
        """setDescription(self, Description description)"""
        return _ot.ConfidenceInterval_setDescription(*args)

05438     def getDescription(*args):
        """getDescription(self) -> Description"""
        return _ot.ConfidenceInterval_getDescription(*args)

05442     def str(*args):
        """str(self) -> String"""
        return _ot.ConfidenceInterval_str(*args)

05446     def setValues(*args):
        """setValues(self, NumericalScalar firstPt, NumericalScalar lastPt)"""
        return _ot.ConfidenceInterval_setValues(*args)

05450     def getFirst(*args):
        """getFirst(self) -> NumericalScalar"""
        return _ot.ConfidenceInterval_getFirst(*args)

05454     def getLast(*args):
        """getLast(self) -> NumericalScalar"""
        return _ot.ConfidenceInterval_getLast(*args)

05458     def save(*args):
        """save(self, OpenTURNS::Base::Stat::ConfidenceInterval::StorageManager::Advocate adv)"""
        return _ot.ConfidenceInterval_save(*args)

05462     def load(*args):
        """load(self, OpenTURNS::Base::Stat::ConfidenceInterval::StorageManager::Advocate adv)"""
        return _ot.ConfidenceInterval_load(*args)

05466     def __eq__(*args):
        """__eq__(self, ConfidenceInterval rhs) -> Bool"""
        return _ot.ConfidenceInterval___eq__(*args)

05470     def __init__(self, *args): 
        """
        __init__(self, NumericalScalar firstPt=0.0, NumericalScalar lastPt=1.0) -> ConfidenceInterval
        __init__(self, NumericalScalar firstPt=0.0) -> ConfidenceInterval
        __init__(self) -> ConfidenceInterval
        __init__(self, ConfidenceInterval other) -> ConfidenceInterval
        """
        this = _ot.new_ConfidenceInterval(*args)
        try: self.this.append(this)
        except: self.this = this
    __swig_destroy__ = _ot.delete_ConfidenceInterval
    __del__ = lambda self : None;
ConfidenceInterval_swigregister = _ot.ConfidenceInterval_swigregister
ConfidenceInterval_swigregister(ConfidenceInterval)

def ConfidenceInterval_GetClassName(*args):
  """ConfidenceInterval_GetClassName() -> String"""
  return _ot.ConfidenceInterval_GetClassName(*args)

05489 class ConfidenceIntervalCollection(_object):
    """Proxy of C++ ConfidenceIntervalCollection class"""
    __swig_setmethods__ = {}
    __setattr__ = lambda self, name, value: _swig_setattr(self, ConfidenceIntervalCollection, name, value)
    __swig_getmethods__ = {}
    __getattr__ = lambda self, name: _swig_getattr(self, ConfidenceIntervalCollection, name)
    __repr__ = _swig_repr
05496     def __init__(self, *args): 
        """
        __init__(self) -> ConfidenceIntervalCollection
        __init__(self, UnsignedLong size) -> ConfidenceIntervalCollection
        __init__(self, UnsignedLong size, ConfidenceInterval value) -> ConfidenceIntervalCollection
        """
        this = _ot.new_ConfidenceIntervalCollection(*args)
        try: self.this.append(this)
        except: self.this = this
05505     def clear(*args):
        """clear(self)"""
        return _ot.ConfidenceIntervalCollection_clear(*args)

05509     def __str__(*args):
        """__str__(self) -> String"""
        return _ot.ConfidenceIntervalCollection___str__(*args)

05513     def __getitem__(*args):
        """__getitem__(self, UnsignedLong i) -> ConfidenceInterval"""
        return _ot.ConfidenceIntervalCollection___getitem__(*args)

05517     def __setitem__(*args):
        """__setitem__(self, UnsignedLong i, ConfidenceInterval val)"""
        return _ot.ConfidenceIntervalCollection___setitem__(*args)

05521     def at(*args):
        """
        at(self, UnsignedLong i) -> ConfidenceInterval
        at(self, UnsignedLong i) -> ConfidenceInterval
        """
        return _ot.ConfidenceIntervalCollection_at(*args)

05528     def add(*args):
        """add(self, ConfidenceInterval elt)"""
        return _ot.ConfidenceIntervalCollection_add(*args)

05532     def getSize(*args):
        """getSize(self) -> UnsignedLong"""
        return _ot.ConfidenceIntervalCollection_getSize(*args)

05536     def resize(*args):
        """resize(self, UnsignedLong newSize)"""
        return _ot.ConfidenceIntervalCollection_resize(*args)

05540     def isEmpty(*args):
        """isEmpty(self) -> Bool"""
        return _ot.ConfidenceIntervalCollection_isEmpty(*args)

05544     def str(*args):
        """str(self) -> String"""
        return _ot.ConfidenceIntervalCollection_str(*args)

    __swig_destroy__ = _ot.delete_ConfidenceIntervalCollection
    __del__ = lambda self : None;
ConfidenceIntervalCollection_swigregister = _ot.ConfidenceIntervalCollection_swigregister
ConfidenceIntervalCollection_swigregister(ConfidenceIntervalCollection)

05553 class ConfidenceIntervalPersistentCollection(PersistentObject,ConfidenceIntervalCollection):
    """Proxy of C++ ConfidenceIntervalPersistentCollection class"""
    __swig_setmethods__ = {}
    for _s in [PersistentObject,ConfidenceIntervalCollection]: __swig_setmethods__.update(getattr(_s,'__swig_setmethods__',{}))
    __setattr__ = lambda self, name, value: _swig_setattr(self, ConfidenceIntervalPersistentCollection, name, value)
    __swig_getmethods__ = {}
    for _s in [PersistentObject,ConfidenceIntervalCollection]: __swig_getmethods__.update(getattr(_s,'__swig_getmethods__',{}))
    __getattr__ = lambda self, name: _swig_getattr(self, ConfidenceIntervalPersistentCollection, name)
    __repr__ = _swig_repr
05562     def GetClassName(*args):
        """GetClassName() -> String"""
        return _ot.ConfidenceIntervalPersistentCollection_GetClassName(*args)

    if _newclass:GetClassName = staticmethod(GetClassName)
    __swig_getmethods__["GetClassName"] = lambda x: GetClassName
05568     def getClassName(*args):
        """getClassName(self) -> String"""
        return _ot.ConfidenceIntervalPersistentCollection_getClassName(*args)

05572     def __init__(self, *args): 
        """
        __init__(self) -> ConfidenceIntervalPersistentCollection
        __init__(self, ConfidenceIntervalCollection collection) -> ConfidenceIntervalPersistentCollection
        __init__(self, UnsignedLong size) -> ConfidenceIntervalPersistentCollection
        __init__(self, UnsignedLong size, ConfidenceInterval value) -> ConfidenceIntervalPersistentCollection
        """
        this = _ot.new_ConfidenceIntervalPersistentCollection(*args)
        try: self.this.append(this)
        except: self.this = this
05582     def clone(*args):
        """clone(self) -> ConfidenceIntervalPersistentCollection"""
        return _ot.ConfidenceIntervalPersistentCollection_clone(*args)

05586     def str(*args):
        """str(self) -> String"""
        return _ot.ConfidenceIntervalPersistentCollection_str(*args)

05590     def save(*args):
        """save(self, OpenTURNS::Base::Type::PersistentCollection<(OpenTURNS::Base::Stat::ConfidenceInterval)>::StorageManager::Advocate adv)"""
        return _ot.ConfidenceIntervalPersistentCollection_save(*args)

05594     def load(*args):
        """load(self, OpenTURNS::Base::Type::PersistentCollection<(OpenTURNS::Base::Stat::ConfidenceInterval)>::StorageManager::Advocate adv)"""
        return _ot.ConfidenceIntervalPersistentCollection_load(*args)

05598     def __str__(*args):
        """__str__(self) -> String"""
        return _ot.ConfidenceIntervalPersistentCollection___str__(*args)

    __swig_destroy__ = _ot.delete_ConfidenceIntervalPersistentCollection
    __del__ = lambda self : None;
ConfidenceIntervalPersistentCollection_swigregister = _ot.ConfidenceIntervalPersistentCollection_swigregister
ConfidenceIntervalPersistentCollection_swigregister(ConfidenceIntervalPersistentCollection)

def ConfidenceIntervalPersistentCollection_GetClassName(*args):
  """ConfidenceIntervalPersistentCollection_GetClassName() -> String"""
  return _ot.ConfidenceIntervalPersistentCollection_GetClassName(*args)

05611 class LinearModel(PersistentObject):
    """Proxy of C++ LinearModel class"""
    __swig_setmethods__ = {}
    for _s in [PersistentObject]: __swig_setmethods__.update(getattr(_s,'__swig_setmethods__',{}))
    __setattr__ = lambda self, name, value: _swig_setattr(self, LinearModel, name, value)
    __swig_getmethods__ = {}
    for _s in [PersistentObject]: __swig_getmethods__.update(getattr(_s,'__swig_getmethods__',{}))
    __getattr__ = lambda self, name: _swig_getattr(self, LinearModel, name)
    __repr__ = _swig_repr
05620     def GetClassName(*args):
        """GetClassName() -> String"""
        return _ot.LinearModel_GetClassName(*args)

    if _newclass:GetClassName = staticmethod(GetClassName)
    __swig_getmethods__["GetClassName"] = lambda x: GetClassName
05626     def getClassName(*args):
        """getClassName(self) -> String"""
        return _ot.LinearModel_getClassName(*args)

05630     def clone(*args):
        """clone(self) -> LinearModel"""
        return _ot.LinearModel_clone(*args)

05634     def str(*args):
        """str(self) -> String"""
        return _ot.LinearModel_str(*args)

05638     def getRegression(*args):
        """getRegression(self) -> NumericalPoint"""
        return _ot.LinearModel_getRegression(*args)

05642     def getConfidenceIntervals(*args):
        """getConfidenceIntervals(self) -> ConfidenceIntervalPersistentCollection"""
        return _ot.LinearModel_getConfidenceIntervals(*args)

05646     def getPValues(*args):
        """getPValues(self) -> NumericalScalarPersistentCollection"""
        return _ot.LinearModel_getPValues(*args)

05650     def getPredicted(*args):
        """getPredicted(self, NumericalSample predictor) -> NumericalSample"""
        return _ot.LinearModel_getPredicted(*args)

05654     def getResidual(*args):
        """getResidual(self, NumericalSample predictor, NumericalSample measured) -> NumericalSample"""
        return _ot.LinearModel_getResidual(*args)

05658     def save(*args):
        """save(self, OpenTURNS::Base::Stat::LinearModel::StorageManager::Advocate adv)"""
        return _ot.LinearModel_save(*args)

05662     def load(*args):
        """load(self, OpenTURNS::Base::Stat::LinearModel::StorageManager::Advocate adv)"""
        return _ot.LinearModel_load(*args)

05666     def __init__(self, *args): 
        """
        __init__(self) -> LinearModel
        __init__(self, NumericalPoint vectorR, ConfidenceIntervalPersistentCollection intervalsColl, 
            NumericalScalarPersistentCollection pValuesOfR) -> LinearModel
        __init__(self, NumericalPoint vectorR) -> LinearModel
        __init__(self, LinearModel other) -> LinearModel
        """
        this = _ot.new_LinearModel(*args)
        try: self.this.append(this)
        except: self.this = this
    __swig_destroy__ = _ot.delete_LinearModel
    __del__ = lambda self : None;
LinearModel_swigregister = _ot.LinearModel_swigregister
LinearModel_swigregister(LinearModel)

def LinearModel_GetClassName(*args):
  """LinearModel_GetClassName() -> String"""
  return _ot.LinearModel_GetClassName(*args)


def LinearModel_operator___eq__(*args):
  """LinearModel_operator___eq__(LinearModel lhs, LinearModel rhs) -> Bool"""
  return _ot.LinearModel_operator___eq__(*args)
05690 class LinearModelFactory(_object):
    """Proxy of C++ LinearModelFactory class"""
    __swig_setmethods__ = {}
    __setattr__ = lambda self, name, value: _swig_setattr(self, LinearModelFactory, name, value)
    __swig_getmethods__ = {}
    __getattr__ = lambda self, name: _swig_getattr(self, LinearModelFactory, name)
    __repr__ = _swig_repr
    __swig_destroy__ = _ot.delete_LinearModelFactory
    __del__ = lambda self : None;
05699     def buildLM(*args):
        """
        buildLM(self, NumericalSample samplePred, NumericalSample sampleLab, 
            NumericalScalar levelValue=) -> LinearModel
        buildLM(self, NumericalSample samplePred, NumericalSample sampleLab) -> LinearModel
        """
        return _ot.LinearModelFactory_buildLM(*args)

05707     def __init__(self, *args): 
        """
        __init__(self) -> LinearModelFactory
        __init__(self, LinearModelFactory other) -> LinearModelFactory
        """
        this = _ot.new_LinearModelFactory(*args)
        try: self.this.append(this)
        except: self.this = this
LinearModelFactory_swigregister = _ot.LinearModelFactory_swigregister
LinearModelFactory_swigregister(LinearModelFactory)

05718 class TestResult(PersistentObject):
    """Proxy of C++ TestResult class"""
    __swig_setmethods__ = {}
    for _s in [PersistentObject]: __swig_setmethods__.update(getattr(_s,'__swig_setmethods__',{}))
    __setattr__ = lambda self, name, value: _swig_setattr(self, TestResult, name, value)
    __swig_getmethods__ = {}
    for _s in [PersistentObject]: __swig_getmethods__.update(getattr(_s,'__swig_getmethods__',{}))
    __getattr__ = lambda self, name: _swig_getattr(self, TestResult, name)
    __repr__ = _swig_repr
05727     def GetClassName(*args):
        """GetClassName() -> String"""
        return _ot.TestResult_GetClassName(*args)

    if _newclass:GetClassName = staticmethod(GetClassName)
    __swig_getmethods__["GetClassName"] = lambda x: GetClassName
05733     def getClassName(*args):
        """getClassName(self) -> String"""
        return _ot.TestResult_getClassName(*args)

05737     def clone(*args):
        """clone(self) -> TestResult"""
        return _ot.TestResult_clone(*args)

05741     def setDescription(*args):
        """setDescription(self, Description description)"""
        return _ot.TestResult_setDescription(*args)

05745     def getDescription(*args):
        """getDescription(self) -> Description"""
        return _ot.TestResult_getDescription(*args)

05749     def str(*args):
        """str(self) -> String"""
        return _ot.TestResult_str(*args)

05753     def getBinaryQualityMeasure(*args):
        """getBinaryQualityMeasure(self) -> Bool"""
        return _ot.TestResult_getBinaryQualityMeasure(*args)

05757     def getPValue(*args):
        """getPValue(self) -> NumericalScalar"""
        return _ot.TestResult_getPValue(*args)

05761     def getThreshold(*args):
        """getThreshold(self) -> NumericalScalar"""
        return _ot.TestResult_getThreshold(*args)

05765     def getTestType(*args):
        """getTestType(self) -> String"""
        return _ot.TestResult_getTestType(*args)

05769     def __eq__(*args):
        """__eq__(self, TestResult rhs) -> Bool"""
        return _ot.TestResult___eq__(*args)

05773     def __init__(self, *args): 
        """
        __init__(self) -> TestResult
        __init__(self, String type, Bool binMeasure, NumericalScalar pVal, 
            NumericalScalar pThreshold) -> TestResult
        __init__(self, TestResult other) -> TestResult
        """
        this = _ot.new_TestResult(*args)
        try: self.this.append(this)
        except: self.this = this
    __swig_destroy__ = _ot.delete_TestResult
    __del__ = lambda self : None;
TestResult_swigregister = _ot.TestResult_swigregister
TestResult_swigregister(TestResult)

def TestResult_GetClassName(*args):
  """TestResult_GetClassName() -> String"""
  return _ot.TestResult_GetClassName(*args)

05792 class RandomGenerator(_object):
    """Proxy of C++ RandomGenerator class"""
    __swig_setmethods__ = {}
    __setattr__ = lambda self, name, value: _swig_setattr(self, RandomGenerator, name, value)
    __swig_getmethods__ = {}
    __getattr__ = lambda self, name: _swig_getattr(self, RandomGenerator, name)
    __repr__ = _swig_repr
05799     def SetSeed(*args):
        """SetSeed(UnsignedLong seed)"""
        return _ot.RandomGenerator_SetSeed(*args)

    if _newclass:SetSeed = staticmethod(SetSeed)
    __swig_getmethods__["SetSeed"] = lambda x: SetSeed
05805     def SetState(*args):
        """SetState(State state)"""
        return _ot.RandomGenerator_SetState(*args)

    if _newclass:SetState = staticmethod(SetState)
    __swig_getmethods__["SetState"] = lambda x: SetState
05811     def GetState(*args):
        """GetState() -> State"""
        return _ot.RandomGenerator_GetState(*args)

    if _newclass:GetState = staticmethod(GetState)
    __swig_getmethods__["GetState"] = lambda x: GetState
05817     def Generate(*args):
        """
        Generate() -> NumericalScalar
        Generate(UnsignedLong size) -> NumericalPoint
        """
        return _ot.RandomGenerator_Generate(*args)

    if _newclass:Generate = staticmethod(Generate)
    __swig_getmethods__["Generate"] = lambda x: Generate
05826     def IntegerGenerate(*args):
        """
        IntegerGenerate(UnsignedLong n) -> UnsignedLong
        IntegerGenerate(UnsignedLong size, UnsignedLong n) -> UnsignedLongCollection
        """
        return _ot.RandomGenerator_IntegerGenerate(*args)

    if _newclass:IntegerGenerate = staticmethod(IntegerGenerate)
    __swig_getmethods__["IntegerGenerate"] = lambda x: IntegerGenerate
05835     def __init__(self, *args): 
        """
        __init__(self) -> RandomGenerator
        __init__(self, RandomGenerator other) -> RandomGenerator
        """
        this = _ot.new_RandomGenerator(*args)
        try: self.this.append(this)
        except: self.this = this
    __swig_destroy__ = _ot.delete_RandomGenerator
    __del__ = lambda self : None;
RandomGenerator_swigregister = _ot.RandomGenerator_swigregister
RandomGenerator_swigregister(RandomGenerator)

def RandomGenerator_SetSeed(*args):
  """RandomGenerator_SetSeed(UnsignedLong seed)"""
  return _ot.RandomGenerator_SetSeed(*args)

def RandomGenerator_SetState(*args):
  """RandomGenerator_SetState(State state)"""
  return _ot.RandomGenerator_SetState(*args)

def RandomGenerator_GetState(*args):
  """RandomGenerator_GetState() -> State"""
  return _ot.RandomGenerator_GetState(*args)

def RandomGenerator_Generate(*args):
  """
    Generate() -> NumericalScalar
    RandomGenerator_Generate(UnsignedLong size) -> NumericalPoint
    """
  return _ot.RandomGenerator_Generate(*args)

def RandomGenerator_IntegerGenerate(*args):
  """
    IntegerGenerate(UnsignedLong n) -> UnsignedLong
    RandomGenerator_IntegerGenerate(UnsignedLong size, UnsignedLong n) -> UnsignedLongCollection
    """
  return _ot.RandomGenerator_IntegerGenerate(*args)

05874 class RandomGeneratorState(_object):
    """Proxy of C++ RandomGeneratorState class"""
    __swig_setmethods__ = {}
    __setattr__ = lambda self, name, value: _swig_setattr(self, RandomGeneratorState, name, value)
    __swig_getmethods__ = {}
    __getattr__ = lambda self, name: _swig_getattr(self, RandomGeneratorState, name)
    __repr__ = _swig_repr
    __swig_setmethods__["state_"] = _ot.RandomGeneratorState_state__set
    __swig_getmethods__["state_"] = _ot.RandomGeneratorState_state__get
    if _newclass:state_ = _swig_property(_ot.RandomGeneratorState_state__get, _ot.RandomGeneratorState_state__set)
    __swig_setmethods__["index_"] = _ot.RandomGeneratorState_index__set
    __swig_getmethods__["index_"] = _ot.RandomGeneratorState_index__get
    if _newclass:index_ = _swig_property(_ot.RandomGeneratorState_index__get, _ot.RandomGeneratorState_index__set)
05887     def __init__(self, *args): 
        """
        __init__(self) -> RandomGeneratorState
        __init__(self, UnsignedLongCollection state, UnsignedLong index) -> RandomGeneratorState
        """
        this = _ot.new_RandomGeneratorState(*args)
        try: self.this.append(this)
        except: self.this = this
    __swig_destroy__ = _ot.delete_RandomGeneratorState
    __del__ = lambda self : None;
05897     def __str__(*args):
        """__str__(self) -> String"""
        return _ot.RandomGeneratorState___str__(*args)

RandomGeneratorState_swigregister = _ot.RandomGeneratorState_swigregister
RandomGeneratorState_swigregister(RandomGeneratorState)

05904 class CorrelationAnalysis(_object):
    """Proxy of C++ CorrelationAnalysis class"""
    __swig_setmethods__ = {}
    __setattr__ = lambda self, name, value: _swig_setattr(self, CorrelationAnalysis, name, value)
    __swig_getmethods__ = {}
    __getattr__ = lambda self, name: _swig_getattr(self, CorrelationAnalysis, name)
    __repr__ = _swig_repr
05911     def PearsonCorrelation(*args):
        """
        PearsonCorrelation(NumericalSample inputSample, NumericalSample outputSample, 
            UnsignedLong index=0) -> NumericalScalar
        PearsonCorrelation(NumericalSample inputSample, NumericalSample outputSample) -> NumericalScalar
        """
        return _ot.CorrelationAnalysis_PearsonCorrelation(*args)

    if _newclass:PearsonCorrelation = staticmethod(PearsonCorrelation)
    __swig_getmethods__["PearsonCorrelation"] = lambda x: PearsonCorrelation
05921     def SpearmanCorrelation(*args):
        """
        SpearmanCorrelation(NumericalSample inputSample, NumericalSample outputSample, 
            UnsignedLong index=0) -> NumericalScalar
        SpearmanCorrelation(NumericalSample inputSample, NumericalSample outputSample) -> NumericalScalar
        """
        return _ot.CorrelationAnalysis_SpearmanCorrelation(*args)

    if _newclass:SpearmanCorrelation = staticmethod(SpearmanCorrelation)
    __swig_getmethods__["SpearmanCorrelation"] = lambda x: SpearmanCorrelation
05931     def SRC(*args):
        """SRC(NumericalSample inputSample, NumericalSample outputSample) -> NumericalPoint"""
        return _ot.CorrelationAnalysis_SRC(*args)

    if _newclass:SRC = staticmethod(SRC)
    __swig_getmethods__["SRC"] = lambda x: SRC
05937     def PCC(*args):
        """PCC(NumericalSample inputSample, NumericalSample outputSample) -> NumericalPoint"""
        return _ot.CorrelationAnalysis_PCC(*args)

    if _newclass:PCC = staticmethod(PCC)
    __swig_getmethods__["PCC"] = lambda x: PCC
05943     def SRRC(*args):
        """SRRC(NumericalSample inputSample, NumericalSample outputSample) -> NumericalPoint"""
        return _ot.CorrelationAnalysis_SRRC(*args)

    if _newclass:SRRC = staticmethod(SRRC)
    __swig_getmethods__["SRRC"] = lambda x: SRRC
05949     def PRCC(*args):
        """PRCC(NumericalSample inputSample, NumericalSample outputSample) -> NumericalPoint"""
        return _ot.CorrelationAnalysis_PRCC(*args)

    if _newclass:PRCC = staticmethod(PRCC)
    __swig_getmethods__["PRCC"] = lambda x: PRCC
05955     def __init__(self, *args): 
        """__init__(self, CorrelationAnalysis other) -> CorrelationAnalysis"""
        this = _ot.new_CorrelationAnalysis(*args)
        try: self.this.append(this)
        except: self.this = this
    __swig_destroy__ = _ot.delete_CorrelationAnalysis
    __del__ = lambda self : None;
CorrelationAnalysis_swigregister = _ot.CorrelationAnalysis_swigregister
CorrelationAnalysis_swigregister(CorrelationAnalysis)

def CorrelationAnalysis_PearsonCorrelation(*args):
  """
    PearsonCorrelation(NumericalSample inputSample, NumericalSample outputSample, 
        UnsignedLong index=0) -> NumericalScalar
    CorrelationAnalysis_PearsonCorrelation(NumericalSample inputSample, NumericalSample outputSample) -> NumericalScalar
    """
  return _ot.CorrelationAnalysis_PearsonCorrelation(*args)

def CorrelationAnalysis_SpearmanCorrelation(*args):
  """
    SpearmanCorrelation(NumericalSample inputSample, NumericalSample outputSample, 
        UnsignedLong index=0) -> NumericalScalar
    CorrelationAnalysis_SpearmanCorrelation(NumericalSample inputSample, NumericalSample outputSample) -> NumericalScalar
    """
  return _ot.CorrelationAnalysis_SpearmanCorrelation(*args)

def CorrelationAnalysis_SRC(*args):
  """CorrelationAnalysis_SRC(NumericalSample inputSample, NumericalSample outputSample) -> NumericalPoint"""
  return _ot.CorrelationAnalysis_SRC(*args)

def CorrelationAnalysis_PCC(*args):
  """CorrelationAnalysis_PCC(NumericalSample inputSample, NumericalSample outputSample) -> NumericalPoint"""
  return _ot.CorrelationAnalysis_PCC(*args)

def CorrelationAnalysis_SRRC(*args):
  """CorrelationAnalysis_SRRC(NumericalSample inputSample, NumericalSample outputSample) -> NumericalPoint"""
  return _ot.CorrelationAnalysis_SRRC(*args)

def CorrelationAnalysis_PRCC(*args):
  """CorrelationAnalysis_PRCC(NumericalSample inputSample, NumericalSample outputSample) -> NumericalPoint"""
  return _ot.CorrelationAnalysis_PRCC(*args)

05997 class SensitivityAnalysis(_object):
    """Proxy of C++ SensitivityAnalysis class"""
    __swig_setmethods__ = {}
    __setattr__ = lambda self, name, value: _swig_setattr(self, SensitivityAnalysis, name, value)
    __swig_getmethods__ = {}
    __getattr__ = lambda self, name: _swig_getattr(self, SensitivityAnalysis, name)
    __repr__ = _swig_repr
    DefaultSampleSize = _ot.SensitivityAnalysis_DefaultSampleSize
06005     def getFirstOrderIndices(*args):
        """getFirstOrderIndices(self) -> NumericalPoint"""
        return _ot.SensitivityAnalysis_getFirstOrderIndices(*args)

06009     def getTotalOrderIndices(*args):
        """getTotalOrderIndices(self) -> NumericalPoint"""
        return _ot.SensitivityAnalysis_getTotalOrderIndices(*args)

06013     def __init__(self, *args): 
        """
        __init__(self, NumericalSample inputSample1, NumericalSample inputSample2, 
            NumericalMathFunction model) -> SensitivityAnalysis
        __init__(self, SensitivityAnalysis other) -> SensitivityAnalysis
        """
        this = _ot.new_SensitivityAnalysis(*args)
        try: self.this.append(this)
        except: self.this = this
    __swig_destroy__ = _ot.delete_SensitivityAnalysis
    __del__ = lambda self : None;
SensitivityAnalysis_swigregister = _ot.SensitivityAnalysis_swigregister
SensitivityAnalysis_swigregister(SensitivityAnalysis)

06027 class WrapperSymbolProvided(_object):
    """Proxy of C++ WrapperSymbolProvided class"""
    __swig_setmethods__ = {}
    __setattr__ = lambda self, name, value: _swig_setattr(self, WrapperSymbolProvided, name, value)
    __swig_getmethods__ = {}
    __getattr__ = lambda self, name: _swig_getattr(self, WrapperSymbolProvided, name)
    __repr__ = _swig_repr
    NO = _ot.WrapperSymbolProvided_NO
    YES = _ot.WrapperSymbolProvided_YES
06036     def __init__(self, *args): 
        """__init__(self) -> WrapperSymbolProvided"""
        this = _ot.new_WrapperSymbolProvided(*args)
        try: self.this.append(this)
        except: self.this = this
    __swig_destroy__ = _ot.delete_WrapperSymbolProvided
    __del__ = lambda self : None;
WrapperSymbolProvided_swigregister = _ot.WrapperSymbolProvided_swigregister
WrapperSymbolProvided_swigregister(WrapperSymbolProvided)

06046 class WrapperComputedGradient(_object):
    """Proxy of C++ WrapperComputedGradient class"""
    __swig_setmethods__ = {}
    __setattr__ = lambda self, name, value: _swig_setattr(self, WrapperComputedGradient, name, value)
    __swig_getmethods__ = {}
    __getattr__ = lambda self, name: _swig_getattr(self, WrapperComputedGradient, name)
    __repr__ = _swig_repr
    NO = _ot.WrapperComputedGradient_NO
    YES = _ot.WrapperComputedGradient_YES
06055     def __init__(self, *args): 
        """__init__(self) -> WrapperComputedGradient"""
        this = _ot.new_WrapperComputedGradient(*args)
        try: self.this.append(this)
        except: self.this = this
    __swig_destroy__ = _ot.delete_WrapperComputedGradient
    __del__ = lambda self : None;
WrapperComputedGradient_swigregister = _ot.WrapperComputedGradient_swigregister
WrapperComputedGradient_swigregister(WrapperComputedGradient)

06065 class WrapperFunctionDescription(Object):
    """Proxy of C++ WrapperFunctionDescription class"""
    __swig_setmethods__ = {}
    for _s in [Object]: __swig_setmethods__.update(getattr(_s,'__swig_setmethods__',{}))
    __setattr__ = lambda self, name, value: _swig_setattr(self, WrapperFunctionDescription, name, value)
    __swig_getmethods__ = {}
    for _s in [Object]: __swig_getmethods__.update(getattr(_s,'__swig_getmethods__',{}))
    __getattr__ = lambda self, name: _swig_getattr(self, WrapperFunctionDescription, name)
    __repr__ = _swig_repr
    __swig_setmethods__["name_"] = _ot.WrapperFunctionDescription_name__set
    __swig_getmethods__["name_"] = _ot.WrapperFunctionDescription_name__get
    if _newclass:name_ = _swig_property(_ot.WrapperFunctionDescription_name__get, _ot.WrapperFunctionDescription_name__set)
    __swig_setmethods__["provided_"] = _ot.WrapperFunctionDescription_provided__set
    __swig_getmethods__["provided_"] = _ot.WrapperFunctionDescription_provided__get
    if _newclass:provided_ = _swig_property(_ot.WrapperFunctionDescription_provided__get, _ot.WrapperFunctionDescription_provided__set)
06080     def __init__(self, *args): 
        """__init__(self) -> WrapperFunctionDescription"""
        this = _ot.new_WrapperFunctionDescription(*args)
        try: self.this.append(this)
        except: self.this = this
06085     def str(*args):
        """str(self) -> String"""
        return _ot.WrapperFunctionDescription_str(*args)

    __swig_destroy__ = _ot.delete_WrapperFunctionDescription
    __del__ = lambda self : None;
WrapperFunctionDescription_swigregister = _ot.WrapperFunctionDescription_swigregister
WrapperFunctionDescription_swigregister(WrapperFunctionDescription)

06094 class WrapperDataFileType(_object):
    """Proxy of C++ WrapperDataFileType class"""
    __swig_setmethods__ = {}
    __setattr__ = lambda self, name, value: _swig_setattr(self, WrapperDataFileType, name, value)
    __swig_getmethods__ = {}
    __getattr__ = lambda self, name: _swig_getattr(self, WrapperDataFileType, name)
    __repr__ = _swig_repr
    IN = _ot.WrapperDataFileType_IN
    OUT = _ot.WrapperDataFileType_OUT
06103     def __init__(self, *args): 
        """__init__(self) -> WrapperDataFileType"""
        this = _ot.new_WrapperDataFileType(*args)
        try: self.this.append(this)
        except: self.this = this
    __swig_destroy__ = _ot.delete_WrapperDataFileType
    __del__ = lambda self : None;
WrapperDataFileType_swigregister = _ot.WrapperDataFileType_swigregister
WrapperDataFileType_swigregister(WrapperDataFileType)

06113 class WrapperDataFile(Object):
    """Proxy of C++ WrapperDataFile class"""
    __swig_setmethods__ = {}
    for _s in [Object]: __swig_setmethods__.update(getattr(_s,'__swig_setmethods__',{}))
    __setattr__ = lambda self, name, value: _swig_setattr(self, WrapperDataFile, name, value)
    __swig_getmethods__ = {}
    for _s in [Object]: __swig_getmethods__.update(getattr(_s,'__swig_getmethods__',{}))
    __getattr__ = lambda self, name: _swig_getattr(self, WrapperDataFile, name)
    __repr__ = _swig_repr
    __swig_setmethods__["id_"] = _ot.WrapperDataFile_id__set
    __swig_getmethods__["id_"] = _ot.WrapperDataFile_id__get
    if _newclass:id_ = _swig_property(_ot.WrapperDataFile_id__get, _ot.WrapperDataFile_id__set)
    __swig_setmethods__["name_"] = _ot.WrapperDataFile_name__set
    __swig_getmethods__["name_"] = _ot.WrapperDataFile_name__get
    if _newclass:name_ = _swig_property(_ot.WrapperDataFile_name__get, _ot.WrapperDataFile_name__set)
    __swig_setmethods__["path_"] = _ot.WrapperDataFile_path__set
    __swig_getmethods__["path_"] = _ot.WrapperDataFile_path__get
    if _newclass:path_ = _swig_property(_ot.WrapperDataFile_path__get, _ot.WrapperDataFile_path__set)
    __swig_setmethods__["subst_"] = _ot.WrapperDataFile_subst__set
    __swig_getmethods__["subst_"] = _ot.WrapperDataFile_subst__get
    if _newclass:subst_ = _swig_property(_ot.WrapperDataFile_subst__get, _ot.WrapperDataFile_subst__set)
    __swig_setmethods__["type_"] = _ot.WrapperDataFile_type__set
    __swig_getmethods__["type_"] = _ot.WrapperDataFile_type__get
    if _newclass:type_ = _swig_property(_ot.WrapperDataFile_type__get, _ot.WrapperDataFile_type__set)
06137     def __init__(self, *args): 
        """__init__(self) -> WrapperDataFile"""
        this = _ot.new_WrapperDataFile(*args)
        try: self.this.append(this)
        except: self.this = this
06142     def str(*args):
        """str(self) -> String"""
        return _ot.WrapperDataFile_str(*args)

    __swig_destroy__ = _ot.delete_WrapperDataFile
    __del__ = lambda self : None;
WrapperDataFile_swigregister = _ot.WrapperDataFile_swigregister
WrapperDataFile_swigregister(WrapperDataFile)

06151 class WrapperDataVariableType(_object):
    """Proxy of C++ WrapperDataVariableType class"""
    __swig_setmethods__ = {}
    __setattr__ = lambda self, name, value: _swig_setattr(self, WrapperDataVariableType, name, value)
    __swig_getmethods__ = {}
    __getattr__ = lambda self, name: _swig_getattr(self, WrapperDataVariableType, name)
    __repr__ = _swig_repr
    IN = _ot.WrapperDataVariableType_IN
    OUT = _ot.WrapperDataVariableType_OUT
06160     def __init__(self, *args): 
        """__init__(self) -> WrapperDataVariableType"""
        this = _ot.new_WrapperDataVariableType(*args)
        try: self.this.append(this)
        except: self.this = this
    __swig_destroy__ = _ot.delete_WrapperDataVariableType
    __del__ = lambda self : None;
WrapperDataVariableType_swigregister = _ot.WrapperDataVariableType_swigregister
WrapperDataVariableType_swigregister(WrapperDataVariableType)

06170 class WrapperDataVariable(Object):
    """Proxy of C++ WrapperDataVariable class"""
    __swig_setmethods__ = {}
    for _s in [Object]: __swig_setmethods__.update(getattr(_s,'__swig_setmethods__',{}))
    __setattr__ = lambda self, name, value: _swig_setattr(self, WrapperDataVariable, name, value)
    __swig_getmethods__ = {}
    for _s in [Object]: __swig_getmethods__.update(getattr(_s,'__swig_getmethods__',{}))
    __getattr__ = lambda self, name: _swig_getattr(self, WrapperDataVariable, name)
    __repr__ = _swig_repr
    __swig_setmethods__["id_"] = _ot.WrapperDataVariable_id__set
    __swig_getmethods__["id_"] = _ot.WrapperDataVariable_id__get
    if _newclass:id_ = _swig_property(_ot.WrapperDataVariable_id__get, _ot.WrapperDataVariable_id__set)
    __swig_setmethods__["comment_"] = _ot.WrapperDataVariable_comment__set
    __swig_getmethods__["comment_"] = _ot.WrapperDataVariable_comment__get
    if _newclass:comment_ = _swig_property(_ot.WrapperDataVariable_comment__get, _ot.WrapperDataVariable_comment__set)
    __swig_setmethods__["unit_"] = _ot.WrapperDataVariable_unit__set
    __swig_getmethods__["unit_"] = _ot.WrapperDataVariable_unit__get
    if _newclass:unit_ = _swig_property(_ot.WrapperDataVariable_unit__get, _ot.WrapperDataVariable_unit__set)
    __swig_setmethods__["regexp_"] = _ot.WrapperDataVariable_regexp__set
    __swig_getmethods__["regexp_"] = _ot.WrapperDataVariable_regexp__get
    if _newclass:regexp_ = _swig_property(_ot.WrapperDataVariable_regexp__get, _ot.WrapperDataVariable_regexp__set)
    __swig_setmethods__["format_"] = _ot.WrapperDataVariable_format__set
    __swig_getmethods__["format_"] = _ot.WrapperDataVariable_format__get
    if _newclass:format_ = _swig_property(_ot.WrapperDataVariable_format__get, _ot.WrapperDataVariable_format__set)
    __swig_setmethods__["type_"] = _ot.WrapperDataVariable_type__set
    __swig_getmethods__["type_"] = _ot.WrapperDataVariable_type__get
    if _newclass:type_ = _swig_property(_ot.WrapperDataVariable_type__get, _ot.WrapperDataVariable_type__set)
    __swig_setmethods__["gradient_"] = _ot.WrapperDataVariable_gradient__set
    __swig_getmethods__["gradient_"] = _ot.WrapperDataVariable_gradient__get
    if _newclass:gradient_ = _swig_property(_ot.WrapperDataVariable_gradient__get, _ot.WrapperDataVariable_gradient__set)
06200     def __init__(self, *args): 
        """__init__(self) -> WrapperDataVariable"""
        this = _ot.new_WrapperDataVariable(*args)
        try: self.this.append(this)
        except: self.this = this
06205     def str(*args):
        """str(self) -> String"""
        return _ot.WrapperDataVariable_str(*args)

    __swig_destroy__ = _ot.delete_WrapperDataVariable
    __del__ = lambda self : None;
WrapperDataVariable_swigregister = _ot.WrapperDataVariable_swigregister
WrapperDataVariable_swigregister(WrapperDataVariable)

06214 class WrapperState(_object):
    """Proxy of C++ WrapperState class"""
    __swig_setmethods__ = {}
    __setattr__ = lambda self, name, value: _swig_setattr(self, WrapperState, name, value)
    __swig_getmethods__ = {}
    __getattr__ = lambda self, name: _swig_getattr(self, WrapperState, name)
    __repr__ = _swig_repr
    SHARED = _ot.WrapperState_SHARED
    SPECIFIC = _ot.WrapperState_SPECIFIC
06223     def __init__(self, *args): 
        """__init__(self) -> WrapperState"""
        this = _ot.new_WrapperState(*args)
        try: self.this.append(this)
        except: self.this = this
    __swig_destroy__ = _ot.delete_WrapperState
    __del__ = lambda self : None;
WrapperState_swigregister = _ot.WrapperState_swigregister
WrapperState_swigregister(WrapperState)

06233 class WrapperMode(_object):
    """Proxy of C++ WrapperMode class"""
    __swig_setmethods__ = {}
    __setattr__ = lambda self, name, value: _swig_setattr(self, WrapperMode, name, value)
    __swig_getmethods__ = {}
    __getattr__ = lambda self, name: _swig_getattr(self, WrapperMode, name)
    __repr__ = _swig_repr
    STATICLINK = _ot.WrapperMode_STATICLINK
    DYNAMICLINK = _ot.WrapperMode_DYNAMICLINK
    FORK = _ot.WrapperMode_FORK
06243     def __init__(self, *args): 
        """__init__(self) -> WrapperMode"""
        this = _ot.new_WrapperMode(*args)
        try: self.this.append(this)
        except: self.this = this
    __swig_destroy__ = _ot.delete_WrapperMode
    __del__ = lambda self : None;
WrapperMode_swigregister = _ot.WrapperMode_swigregister
WrapperMode_swigregister(WrapperMode)

06253 class WrapperDataTransfer(_object):
    """Proxy of C++ WrapperDataTransfer class"""
    __swig_setmethods__ = {}
    __setattr__ = lambda self, name, value: _swig_setattr(self, WrapperDataTransfer, name, value)
    __swig_getmethods__ = {}
    __getattr__ = lambda self, name: _swig_getattr(self, WrapperDataTransfer, name)
    __repr__ = _swig_repr
    FILES = _ot.WrapperDataTransfer_FILES
    PIPE = _ot.WrapperDataTransfer_PIPE
    ARGUMENTS = _ot.WrapperDataTransfer_ARGUMENTS
    SOCKET = _ot.WrapperDataTransfer_SOCKET
    CORBA = _ot.WrapperDataTransfer_CORBA
06265     def __init__(self, *args): 
        """__init__(self) -> WrapperDataTransfer"""
        this = _ot.new_WrapperDataTransfer(*args)
        try: self.this.append(this)
        except: self.this = this
    __swig_destroy__ = _ot.delete_WrapperDataTransfer
    __del__ = lambda self : None;
WrapperDataTransfer_swigregister = _ot.WrapperDataTransfer_swigregister
WrapperDataTransfer_swigregister(WrapperDataTransfer)

06275 class WrapperParameter(Object):
    """Proxy of C++ WrapperParameter class"""
    __swig_setmethods__ = {}
    for _s in [Object]: __swig_setmethods__.update(getattr(_s,'__swig_setmethods__',{}))
    __setattr__ = lambda self, name, value: _swig_setattr(self, WrapperParameter, name, value)
    __swig_getmethods__ = {}
    for _s in [Object]: __swig_getmethods__.update(getattr(_s,'__swig_getmethods__',{}))
    __getattr__ = lambda self, name: _swig_getattr(self, WrapperParameter, name)
    __repr__ = _swig_repr
    __swig_setmethods__["state_"] = _ot.WrapperParameter_state__set
    __swig_getmethods__["state_"] = _ot.WrapperParameter_state__get
    if _newclass:state_ = _swig_property(_ot.WrapperParameter_state__get, _ot.WrapperParameter_state__set)
    __swig_setmethods__["mode_"] = _ot.WrapperParameter_mode__set
    __swig_getmethods__["mode_"] = _ot.WrapperParameter_mode__get
    if _newclass:mode_ = _swig_property(_ot.WrapperParameter_mode__get, _ot.WrapperParameter_mode__set)
    __swig_setmethods__["in_"] = _ot.WrapperParameter_in__set
    __swig_getmethods__["in_"] = _ot.WrapperParameter_in__get
    if _newclass:in_ = _swig_property(_ot.WrapperParameter_in__get, _ot.WrapperParameter_in__set)
    __swig_setmethods__["out_"] = _ot.WrapperParameter_out__set
    __swig_getmethods__["out_"] = _ot.WrapperParameter_out__get
    if _newclass:out_ = _swig_property(_ot.WrapperParameter_out__get, _ot.WrapperParameter_out__set)
    __swig_setmethods__["command_"] = _ot.WrapperParameter_command__set
    __swig_getmethods__["command_"] = _ot.WrapperParameter_command__get
    if _newclass:command_ = _swig_property(_ot.WrapperParameter_command__get, _ot.WrapperParameter_command__set)
06299     def __init__(self, *args): 
        """__init__(self) -> WrapperParameter"""
        this = _ot.new_WrapperParameter(*args)
        try: self.this.append(this)
        except: self.this = this
06304     def str(*args):
        """str(self) -> String"""
        return _ot.WrapperParameter_str(*args)

    __swig_destroy__ = _ot.delete_WrapperParameter
    __del__ = lambda self : None;
WrapperParameter_swigregister = _ot.WrapperParameter_swigregister
WrapperParameter_swigregister(WrapperParameter)

06313 class WrapperData(Object):
    """Proxy of C++ WrapperData class"""
    __swig_setmethods__ = {}
    for _s in [Object]: __swig_setmethods__.update(getattr(_s,'__swig_setmethods__',{}))
    __setattr__ = lambda self, name, value: _swig_setattr(self, WrapperData, name, value)
    __swig_getmethods__ = {}
    for _s in [Object]: __swig_getmethods__.update(getattr(_s,'__swig_getmethods__',{}))
    __getattr__ = lambda self, name: _swig_getattr(self, WrapperData, name)
    __repr__ = _swig_repr
06322     def GetClassName(*args):
        """GetClassName() -> String"""
        return _ot.WrapperData_GetClassName(*args)

    if _newclass:GetClassName = staticmethod(GetClassName)
    __swig_getmethods__["GetClassName"] = lambda x: GetClassName
06328     def getClassName(*args):
        """getClassName(self) -> String"""
        return _ot.WrapperData_getClassName(*args)

06332     def str(*args):
        """str(self) -> String"""
        return _ot.WrapperData_str(*args)

06336     def setLibraryPath(*args):
        """setLibraryPath(self, FileName path)"""
        return _ot.WrapperData_setLibraryPath(*args)

06340     def getLibraryPath(*args):
        """getLibraryPath(self) -> FileName"""
        return _ot.WrapperData_getLibraryPath(*args)

06344     def setFunctionDescription(*args):
        """setFunctionDescription(self, WrapperFunctionDescription funcDescription)"""
        return _ot.WrapperData_setFunctionDescription(*args)

06348     def getFunctionDescription(*args):
        """getFunctionDescription(self) -> WrapperFunctionDescription"""
        return _ot.WrapperData_getFunctionDescription(*args)

06352     def setGradientDescription(*args):
        """setGradientDescription(self, WrapperFunctionDescription gradDescription)"""
        return _ot.WrapperData_setGradientDescription(*args)

06356     def getGradientDescription(*args):
        """getGradientDescription(self) -> WrapperFunctionDescription"""
        return _ot.WrapperData_getGradientDescription(*args)

06360     def setHessianDescription(*args):
        """setHessianDescription(self, WrapperFunctionDescription hessDescription)"""
        return _ot.WrapperData_setHessianDescription(*args)

06364     def getHessianDescription(*args):
        """getHessianDescription(self) -> WrapperFunctionDescription"""
        return _ot.WrapperData_getHessianDescription(*args)

06368     def setFileList(*args):
        """setFileList(self, FileListType fileList)"""
        return _ot.WrapperData_setFileList(*args)

06372     def getFileList(*args):
        """getFileList(self) -> FileListType"""
        return _ot.WrapperData_getFileList(*args)

06376     def getNewFileListForCInterface(*args):
        """getNewFileListForCInterface(self) -> WrapperFileList"""
        return _ot.WrapperData_getNewFileListForCInterface(*args)

06380     def freeFileListForCInterface(*args):
        """freeFileListForCInterface(self, WrapperFileList fileList)"""
        return _ot.WrapperData_freeFileListForCInterface(*args)

06384     def setVariableList(*args):
        """setVariableList(self, VariableListType variableList)"""
        return _ot.WrapperData_setVariableList(*args)

06388     def getVariableList(*args):
        """getVariableList(self) -> VariableListType"""
        return _ot.WrapperData_getVariableList(*args)

06392     def getNewVariableListForCInterface(*args):
        """getNewVariableListForCInterface(self) -> WrapperVariableList"""
        return _ot.WrapperData_getNewVariableListForCInterface(*args)

06396     def freeVariableListForCInterface(*args):
        """freeVariableListForCInterface(self, WrapperVariableList variableList)"""
        return _ot.WrapperData_freeVariableListForCInterface(*args)

06400     def setParameters(*args):
        """setParameters(self, WrapperParameter parameters)"""
        return _ot.WrapperData_setParameters(*args)

06404     def getParameters(*args):
        """getParameters(self) -> WrapperParameter"""
        return _ot.WrapperData_getParameters(*args)

06408     def getNewParametersForCInterface(*args):
        """getNewParametersForCInterface(self) -> WrapperConfiguration"""
        return _ot.WrapperData_getNewParametersForCInterface(*args)

06412     def freeParametersForCInterface(*args):
        """freeParametersForCInterface(self, WrapperConfiguration parameters)"""
        return _ot.WrapperData_freeParametersForCInterface(*args)

06416     def __init__(self, *args): 
        """
        __init__(self) -> WrapperData
        __init__(self, WrapperData other) -> WrapperData
        """
        this = _ot.new_WrapperData(*args)
        try: self.this.append(this)
        except: self.this = this
    __swig_destroy__ = _ot.delete_WrapperData
    __del__ = lambda self : None;
WrapperData_swigregister = _ot.WrapperData_swigregister
WrapperData_swigregister(WrapperData)

def WrapperData_GetClassName(*args):
  """WrapperData_GetClassName() -> String"""
  return _ot.WrapperData_GetClassName(*args)

06433 class WrapperDataFileList(_object):
    """Proxy of C++ WrapperDataFileList class"""
    __swig_setmethods__ = {}
    __setattr__ = lambda self, name, value: _swig_setattr(self, WrapperDataFileList, name, value)
    __swig_getmethods__ = {}
    __getattr__ = lambda self, name: _swig_getattr(self, WrapperDataFileList, name)
    __repr__ = _swig_repr
06440     def __init__(self, *args): 
        """
        __init__(self) -> WrapperDataFileList
        __init__(self, UnsignedLong size) -> WrapperDataFileList
        __init__(self, UnsignedLong size, WrapperDataFile value) -> WrapperDataFileList
        """
        this = _ot.new_WrapperDataFileList(*args)
        try: self.this.append(this)
        except: self.this = this
06449     def clear(*args):
        """clear(self)"""
        return _ot.WrapperDataFileList_clear(*args)

06453     def __str__(*args):
        """__str__(self) -> String"""
        return _ot.WrapperDataFileList___str__(*args)

06457     def __getitem__(*args):
        """__getitem__(self, UnsignedLong i) -> WrapperDataFile"""
        return _ot.WrapperDataFileList___getitem__(*args)

06461     def __setitem__(*args):
        """__setitem__(self, UnsignedLong i, WrapperDataFile val)"""
        return _ot.WrapperDataFileList___setitem__(*args)

06465     def at(*args):
        """
        at(self, UnsignedLong i) -> WrapperDataFile
        at(self, UnsignedLong i) -> WrapperDataFile
        """
        return _ot.WrapperDataFileList_at(*args)

06472     def add(*args):
        """add(self, WrapperDataFile elt)"""
        return _ot.WrapperDataFileList_add(*args)

06476     def getSize(*args):
        """getSize(self) -> UnsignedLong"""
        return _ot.WrapperDataFileList_getSize(*args)

06480     def resize(*args):
        """resize(self, UnsignedLong newSize)"""
        return _ot.WrapperDataFileList_resize(*args)

06484     def isEmpty(*args):
        """isEmpty(self) -> Bool"""
        return _ot.WrapperDataFileList_isEmpty(*args)

06488     def str(*args):
        """str(self) -> String"""
        return _ot.WrapperDataFileList_str(*args)

    __swig_destroy__ = _ot.delete_WrapperDataFileList
    __del__ = lambda self : None;
WrapperDataFileList_swigregister = _ot.WrapperDataFileList_swigregister
WrapperDataFileList_swigregister(WrapperDataFileList)

06497 class WrapperDataVariableList(_object):
    """Proxy of C++ WrapperDataVariableList class"""
    __swig_setmethods__ = {}
    __setattr__ = lambda self, name, value: _swig_setattr(self, WrapperDataVariableList, name, value)
    __swig_getmethods__ = {}
    __getattr__ = lambda self, name: _swig_getattr(self, WrapperDataVariableList, name)
    __repr__ = _swig_repr
06504     def __init__(self, *args): 
        """
        __init__(self) -> WrapperDataVariableList
        __init__(self, UnsignedLong size) -> WrapperDataVariableList
        __init__(self, UnsignedLong size, WrapperDataVariable value) -> WrapperDataVariableList
        """
        this = _ot.new_WrapperDataVariableList(*args)
        try: self.this.append(this)
        except: self.this = this
06513     def clear(*args):
        """clear(self)"""
        return _ot.WrapperDataVariableList_clear(*args)

06517     def __str__(*args):
        """__str__(self) -> String"""
        return _ot.WrapperDataVariableList___str__(*args)

06521     def __getitem__(*args):
        """__getitem__(self, UnsignedLong i) -> WrapperDataVariable"""
        return _ot.WrapperDataVariableList___getitem__(*args)

06525     def __setitem__(*args):
        """__setitem__(self, UnsignedLong i, WrapperDataVariable val)"""
        return _ot.WrapperDataVariableList___setitem__(*args)

06529     def at(*args):
        """
        at(self, UnsignedLong i) -> WrapperDataVariable
        at(self, UnsignedLong i) -> WrapperDataVariable
        """
        return _ot.WrapperDataVariableList_at(*args)

06536     def add(*args):
        """add(self, WrapperDataVariable elt)"""
        return _ot.WrapperDataVariableList_add(*args)

06540     def getSize(*args):
        """getSize(self) -> UnsignedLong"""
        return _ot.WrapperDataVariableList_getSize(*args)

06544     def resize(*args):
        """resize(self, UnsignedLong newSize)"""
        return _ot.WrapperDataVariableList_resize(*args)

06548     def isEmpty(*args):
        """isEmpty(self) -> Bool"""
        return _ot.WrapperDataVariableList_isEmpty(*args)

06552     def str(*args):
        """str(self) -> String"""
        return _ot.WrapperDataVariableList_str(*args)

    __swig_destroy__ = _ot.delete_WrapperDataVariableList
    __del__ = lambda self : None;
WrapperDataVariableList_swigregister = _ot.WrapperDataVariableList_swigregister
WrapperDataVariableList_swigregister(WrapperDataVariableList)

06561 class WrapperFile(PersistentObject):
    """Proxy of C++ WrapperFile class"""
    __swig_setmethods__ = {}
    for _s in [PersistentObject]: __swig_setmethods__.update(getattr(_s,'__swig_setmethods__',{}))
    __setattr__ = lambda self, name, value: _swig_setattr(self, WrapperFile, name, value)
    __swig_getmethods__ = {}
    for _s in [PersistentObject]: __swig_getmethods__.update(getattr(_s,'__swig_getmethods__',{}))
    __getattr__ = lambda self, name: _swig_getattr(self, WrapperFile, name)
    __repr__ = _swig_repr
06570     def GetClassName(*args):
        """GetClassName() -> String"""
        return _ot.WrapperFile_GetClassName(*args)

    if _newclass:GetClassName = staticmethod(GetClassName)
    __swig_getmethods__["GetClassName"] = lambda x: GetClassName
06576     def getClassName(*args):
        """getClassName(self) -> String"""
        return _ot.WrapperFile_getClassName(*args)

06580     def FindWrapperPathByName(*args):
        """FindWrapperPathByName(String name) -> FileName"""
        return _ot.WrapperFile_FindWrapperPathByName(*args)

    if _newclass:FindWrapperPathByName = staticmethod(FindWrapperPathByName)
    __swig_getmethods__["FindWrapperPathByName"] = lambda x: FindWrapperPathByName
06586     def FindWrapperByName(*args):
        """FindWrapperByName(String name) -> WrapperFile"""
        return _ot.WrapperFile_FindWrapperByName(*args)

    if _newclass:FindWrapperByName = staticmethod(FindWrapperByName)
    __swig_getmethods__["FindWrapperByName"] = lambda x: FindWrapperByName
06592     def __init__(self, *args): 
        """__init__(self, FileName pathToFile) -> WrapperFile"""
        this = _ot.new_WrapperFile(*args)
        try: self.this.append(this)
        except: self.this = this
06597     def clone(*args):
        """clone(self) -> WrapperFile"""
        return _ot.WrapperFile_clone(*args)

06601     def str(*args):
        """str(self) -> String"""
        return _ot.WrapperFile_str(*args)

06605     def setDescriptionFilePath(*args):
        """setDescriptionFilePath(self, FileName path)"""
        return _ot.WrapperFile_setDescriptionFilePath(*args)

06609     def getDescriptionFilePath(*args):
        """getDescriptionFilePath(self) -> FileName"""
        return _ot.WrapperFile_getDescriptionFilePath(*args)

06613     def setWrapperData(*args):
        """setWrapperData(self, WrapperData data)"""
        return _ot.WrapperFile_setWrapperData(*args)

06617     def getWrapperData(*args):
        """getWrapperData(self) -> WrapperData"""
        return _ot.WrapperFile_getWrapperData(*args)

06621     def __str__(*args):
        """__str__(self) -> String"""
        return _ot.WrapperFile___str__(*args)

    __swig_destroy__ = _ot.delete_WrapperFile
    __del__ = lambda self : None;
WrapperFile_swigregister = _ot.WrapperFile_swigregister
WrapperFile_swigregister(WrapperFile)

def WrapperFile_GetClassName(*args):
  """WrapperFile_GetClassName() -> String"""
  return _ot.WrapperFile_GetClassName(*args)

def WrapperFile_FindWrapperPathByName(*args):
  """WrapperFile_FindWrapperPathByName(String name) -> FileName"""
  return _ot.WrapperFile_FindWrapperPathByName(*args)

def WrapperFile_FindWrapperByName(*args):
  """WrapperFile_FindWrapperByName(String name) -> WrapperFile"""
  return _ot.WrapperFile_FindWrapperByName(*args)

06642 class NumericalMathEvaluationImplementation(PersistentObject):
    """Proxy of C++ NumericalMathEvaluationImplementation class"""
    __swig_setmethods__ = {}
    for _s in [PersistentObject]: __swig_setmethods__.update(getattr(_s,'__swig_setmethods__',{}))
    __setattr__ = lambda self, name, value: _swig_setattr(self, NumericalMathEvaluationImplementation, name, value)
    __swig_getmethods__ = {}
    for _s in [PersistentObject]: __swig_getmethods__.update(getattr(_s,'__swig_getmethods__',{}))
    __getattr__ = lambda self, name: _swig_getattr(self, NumericalMathEvaluationImplementation, name)
    __repr__ = _swig_repr
06651     def GetClassName(*args):
        """GetClassName() -> String"""
        return _ot.NumericalMathEvaluationImplementation_GetClassName(*args)

    if _newclass:GetClassName = staticmethod(GetClassName)
    __swig_getmethods__["GetClassName"] = lambda x: GetClassName
06657     def getClassName(*args):
        """getClassName(self) -> String"""
        return _ot.NumericalMathEvaluationImplementation_getClassName(*args)

06661     def clone(*args):
        """clone(self) -> NumericalMathEvaluationImplementation"""
        return _ot.NumericalMathEvaluationImplementation_clone(*args)

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

06669     def str(*args):
        """str(self) -> String"""
        return _ot.NumericalMathEvaluationImplementation_str(*args)

06673     def setDescription(*args):
        """setDescription(self, Description description)"""
        return _ot.NumericalMathEvaluationImplementation_setDescription(*args)

06677     def getDescription(*args):
        """getDescription(self) -> Description"""
        return _ot.NumericalMathEvaluationImplementation_getDescription(*args)

06681     def getInputDescription(*args):
        """getInputDescription(self) -> Description"""
        return _ot.NumericalMathEvaluationImplementation_getInputDescription(*args)

06685     def getOutputDescription(*args):
        """getOutputDescription(self) -> Description"""
        return _ot.NumericalMathEvaluationImplementation_getOutputDescription(*args)

06689     def enableCache(*args):
        """enableCache(self)"""
        return _ot.NumericalMathEvaluationImplementation_enableCache(*args)

06693     def disableCache(*args):
        """disableCache(self)"""
        return _ot.NumericalMathEvaluationImplementation_disableCache(*args)

06697     def isCacheEnabled(*args):
        """isCacheEnabled(self) -> Bool"""
        return _ot.NumericalMathEvaluationImplementation_isCacheEnabled(*args)

06701     def isActualImplementation(*args):
        """isActualImplementation(self) -> Bool"""
        return _ot.NumericalMathEvaluationImplementation_isActualImplementation(*args)

06705     def __call__(*args):
        """
        __call__(self, NumericalPoint in) -> NumericalPoint
        __call__(self, NumericalSample inSample) -> NumericalSample
        """
        return _ot.NumericalMathEvaluationImplementation___call__(*args)

06712     def getInputNumericalPointDimension(*args):
        """getInputNumericalPointDimension(self) -> UnsignedLong"""
        return _ot.NumericalMathEvaluationImplementation_getInputNumericalPointDimension(*args)

06716     def getOutputNumericalPointDimension(*args):
        """getOutputNumericalPointDimension(self) -> UnsignedLong"""
        return _ot.NumericalMathEvaluationImplementation_getOutputNumericalPointDimension(*args)

06720     def parametersGradient(*args):
        """parametersGradient(self, NumericalPoint in) -> Matrix"""
        return _ot.NumericalMathEvaluationImplementation_parametersGradient(*args)

06724     def getParameters(*args):
        """getParameters(self) -> NumericalPointWithDescription"""
        return _ot.NumericalMathEvaluationImplementation_getParameters(*args)

06728     def setParameters(*args):
        """setParameters(self, NumericalPointWithDescription parameters)"""
        return _ot.NumericalMathEvaluationImplementation_setParameters(*args)

06732     def getCallsNumber(*args):
        """getCallsNumber(self) -> UnsignedLong"""
        return _ot.NumericalMathEvaluationImplementation_getCallsNumber(*args)

06736     def save(*args):
        """save(self, OpenTURNS::Base::Func::NumericalMathEvaluationImplementation::StorageManager::Advocate adv)"""
        return _ot.NumericalMathEvaluationImplementation_save(*args)

06740     def load(*args):
        """load(self, OpenTURNS::Base::Func::NumericalMathEvaluationImplementation::StorageManager::Advocate adv)"""
        return _ot.NumericalMathEvaluationImplementation_load(*args)

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

def NumericalMathEvaluationImplementation_GetClassName(*args):
  """NumericalMathEvaluationImplementation_GetClassName() -> String"""
  return _ot.NumericalMathEvaluationImplementation_GetClassName(*args)

06761 class NumericalMathGradientImplementation(PersistentObject):
    """Proxy of C++ NumericalMathGradientImplementation class"""
    __swig_setmethods__ = {}
    for _s in [PersistentObject]: __swig_setmethods__.update(getattr(_s,'__swig_setmethods__',{}))
    __setattr__ = lambda self, name, value: _swig_setattr(self, NumericalMathGradientImplementation, name, value)
    __swig_getmethods__ = {}
    for _s in [PersistentObject]: __swig_getmethods__.update(getattr(_s,'__swig_getmethods__',{}))
    __getattr__ = lambda self, name: _swig_getattr(self, NumericalMathGradientImplementation, name)
    __repr__ = _swig_repr
06770     def GetClassName(*args):
        """GetClassName() -> String"""
        return _ot.NumericalMathGradientImplementation_GetClassName(*args)

    if _newclass:GetClassName = staticmethod(GetClassName)
    __swig_getmethods__["GetClassName"] = lambda x: GetClassName
06776     def getClassName(*args):
        """getClassName(self) -> String"""
        return _ot.NumericalMathGradientImplementation_getClassName(*args)

06780     def clone(*args):
        """clone(self) -> NumericalMathGradientImplementation"""
        return _ot.NumericalMathGradientImplementation_clone(*args)

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

06788     def str(*args):
        """str(self) -> String"""
        return _ot.NumericalMathGradientImplementation_str(*args)

06792     def setDescription(*args):
        """setDescription(self, Description description)"""
        return _ot.NumericalMathGradientImplementation_setDescription(*args)

06796     def getDescription(*args):
        """getDescription(self) -> Description"""
        return _ot.NumericalMathGradientImplementation_getDescription(*args)

06800     def isActualImplementation(*args):
        """isActualImplementation(self) -> Bool"""
        return _ot.NumericalMathGradientImplementation_isActualImplementation(*args)

06804     def gradient(*args):
        """gradient(self, NumericalPoint in) -> Matrix"""
        return _ot.NumericalMathGradientImplementation_gradient(*args)

06808     def getInputNumericalPointDimension(*args):
        """getInputNumericalPointDimension(self) -> UnsignedLong"""
        return _ot.NumericalMathGradientImplementation_getInputNumericalPointDimension(*args)

06812     def getOutputNumericalPointDimension(*args):
        """getOutputNumericalPointDimension(self) -> UnsignedLong"""
        return _ot.NumericalMathGradientImplementation_getOutputNumericalPointDimension(*args)

06816     def getCallsNumber(*args):
        """getCallsNumber(self) -> UnsignedLong"""
        return _ot.NumericalMathGradientImplementation_getCallsNumber(*args)

06820     def save(*args):
        """save(self, OpenTURNS::Base::Func::NumericalMathGradientImplementation::StorageManager::Advocate adv)"""
        return _ot.NumericalMathGradientImplementation_save(*args)

06824     def load(*args):
        """load(self, OpenTURNS::Base::Func::NumericalMathGradientImplementation::StorageManager::Advocate adv)"""
        return _ot.NumericalMathGradientImplementation_load(*args)

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

def NumericalMathGradientImplementation_GetClassName(*args):
  """NumericalMathGradientImplementation_GetClassName() -> String"""
  return _ot.NumericalMathGradientImplementation_GetClassName(*args)

06845 class NumericalMathHessianImplementation(PersistentObject):
    """Proxy of C++ NumericalMathHessianImplementation class"""
    __swig_setmethods__ = {}
    for _s in [PersistentObject]: __swig_setmethods__.update(getattr(_s,'__swig_setmethods__',{}))
    __setattr__ = lambda self, name, value: _swig_setattr(self, NumericalMathHessianImplementation, name, value)
    __swig_getmethods__ = {}
    for _s in [PersistentObject]: __swig_getmethods__.update(getattr(_s,'__swig_getmethods__',{}))
    __getattr__ = lambda self, name: _swig_getattr(self, NumericalMathHessianImplementation, name)
    __repr__ = _swig_repr
06854     def GetClassName(*args):
        """GetClassName() -> String"""
        return _ot.NumericalMathHessianImplementation_GetClassName(*args)

    if _newclass:GetClassName = staticmethod(GetClassName)
    __swig_getmethods__["GetClassName"] = lambda x: GetClassName
06860     def getClassName(*args):
        """getClassName(self) -> String"""
        return _ot.NumericalMathHessianImplementation_getClassName(*args)

06864     def clone(*args):
        """clone(self) -> NumericalMathHessianImplementation"""
        return _ot.NumericalMathHessianImplementation_clone(*args)

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

06872     def str(*args):
        """str(self) -> String"""
        return _ot.NumericalMathHessianImplementation_str(*args)

06876     def setDescription(*args):
        """setDescription(self, Description description)"""
        return _ot.NumericalMathHessianImplementation_setDescription(*args)

06880     def getDescription(*args):
        """getDescription(self) -> Description"""
        return _ot.NumericalMathHessianImplementation_getDescription(*args)

06884     def isActualImplementation(*args):
        """isActualImplementation(self) -> Bool"""
        return _ot.NumericalMathHessianImplementation_isActualImplementation(*args)

06888     def hessian(*args):
        """hessian(self, NumericalPoint in) -> SymmetricTensor"""
        return _ot.NumericalMathHessianImplementation_hessian(*args)

06892     def getInputNumericalPointDimension(*args):
        """getInputNumericalPointDimension(self) -> UnsignedLong"""
        return _ot.NumericalMathHessianImplementation_getInputNumericalPointDimension(*args)

06896     def getOutputNumericalPointDimension(*args):
        """getOutputNumericalPointDimension(self) -> UnsignedLong"""
        return _ot.NumericalMathHessianImplementation_getOutputNumericalPointDimension(*args)

06900     def getCallsNumber(*args):
        """getCallsNumber(self) -> UnsignedLong"""
        return _ot.NumericalMathHessianImplementation_getCallsNumber(*args)

06904     def save(*args):
        """save(self, OpenTURNS::Base::Func::NumericalMathHessianImplementation::StorageManager::Advocate adv)"""
        return _ot.NumericalMathHessianImplementation_save(*args)

06908     def load(*args):
        """load(self, OpenTURNS::Base::Func::NumericalMathHessianImplementation::StorageManager::Advocate adv)"""
        return _ot.NumericalMathHessianImplementation_load(*args)

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

def NumericalMathHessianImplementation_GetClassName(*args):
  """NumericalMathHessianImplementation_GetClassName() -> String"""
  return _ot.NumericalMathHessianImplementation_GetClassName(*args)

06929 class NoNumericalMathEvaluationImplementation(NumericalMathEvaluationImplementation):
    """Proxy of C++ 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)
    __repr__ = _swig_repr
06938     def GetClassName(*args):
        """GetClassName() -> String"""
        return _ot.NoNumericalMathEvaluationImplementation_GetClassName(*args)

    if _newclass:GetClassName = staticmethod(GetClassName)
    __swig_getmethods__["GetClassName"] = lambda x: GetClassName
06944     def getClassName(*args):
        """getClassName(self) -> String"""
        return _ot.NoNumericalMathEvaluationImplementation_getClassName(*args)

06948     def clone(*args):
        """clone(self) -> NoNumericalMathEvaluationImplementation"""
        return _ot.NoNumericalMathEvaluationImplementation_clone(*args)

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

06956     def str(*args):
        """str(self) -> String"""
        return _ot.NoNumericalMathEvaluationImplementation_str(*args)

06960     def isActualImplementation(*args):
        """isActualImplementation(self) -> Bool"""
        return _ot.NoNumericalMathEvaluationImplementation_isActualImplementation(*args)

06964     def __call__(*args):
        """__call__(self, NumericalPoint in) -> NumericalPoint"""
        return _ot.NoNumericalMathEvaluationImplementation___call__(*args)

06968     def getInputNumericalPointDimension(*args):
        """getInputNumericalPointDimension(self) -> UnsignedLong"""
        return _ot.NoNumericalMathEvaluationImplementation_getInputNumericalPointDimension(*args)

06972     def getOutputNumericalPointDimension(*args):
        """getOutputNumericalPointDimension(self) -> UnsignedLong"""
        return _ot.NoNumericalMathEvaluationImplementation_getOutputNumericalPointDimension(*args)

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

def NoNumericalMathEvaluationImplementation_GetClassName(*args):
  """NoNumericalMathEvaluationImplementation_GetClassName() -> String"""
  return _ot.NoNumericalMathEvaluationImplementation_GetClassName(*args)

06993 class NoNumericalMathGradientImplementation(NumericalMathGradientImplementation):
    """Proxy of C++ 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)
    __repr__ = _swig_repr
07002     def GetClassName(*args):
        """GetClassName() -> String"""
        return _ot.NoNumericalMathGradientImplementation_GetClassName(*args)

    if _newclass:GetClassName = staticmethod(GetClassName)
    __swig_getmethods__["GetClassName"] = lambda x: GetClassName
07008     def getClassName(*args):
        """getClassName(self) -> String"""
        return _ot.NoNumericalMathGradientImplementation_getClassName(*args)

07012     def clone(*args):
        """clone(self) -> NoNumericalMathGradientImplementation"""
        return _ot.NoNumericalMathGradientImplementation_clone(*args)

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

07020     def str(*args):
        """str(self) -> String"""
        return _ot.NoNumericalMathGradientImplementation_str(*args)

07024     def gradient(*args):
        """gradient(self, NumericalPoint in) -> Matrix"""
        return _ot.NoNumericalMathGradientImplementation_gradient(*args)

07028     def getInputNumericalPointDimension(*args):
        """getInputNumericalPointDimension(self) -> UnsignedLong"""
        return _ot.NoNumericalMathGradientImplementation_getInputNumericalPointDimension(*args)

07032     def getOutputNumericalPointDimension(*args):
        """getOutputNumericalPointDimension(self) -> UnsignedLong"""
        return _ot.NoNumericalMathGradientImplementation_getOutputNumericalPointDimension(*args)

07036     def isActualImplementation(*args):
        """isActualImplementation(self) -> Bool"""
        return _ot.NoNumericalMathGradientImplementation_isActualImplementation(*args)

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

def NoNumericalMathGradientImplementation_GetClassName(*args):
  """NoNumericalMathGradientImplementation_GetClassName() -> String"""
  return _ot.NoNumericalMathGradientImplementation_GetClassName(*args)

07057 class NoNumericalMathHessianImplementation(NumericalMathHessianImplementation):
    """Proxy of C++ 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)
    __repr__ = _swig_repr
07066     def GetClassName(*args):
        """GetClassName() -> String"""
        return _ot.NoNumericalMathHessianImplementation_GetClassName(*args)

    if _newclass:GetClassName = staticmethod(GetClassName)
    __swig_getmethods__["GetClassName"] = lambda x: GetClassName
07072     def getClassName(*args):
        """getClassName(self) -> String"""
        return _ot.NoNumericalMathHessianImplementation_getClassName(*args)

07076     def clone(*args):
        """clone(self) -> NoNumericalMathHessianImplementation"""
        return _ot.NoNumericalMathHessianImplementation_clone(*args)

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

07084     def str(*args):
        """str(self) -> String"""
        return _ot.NoNumericalMathHessianImplementation_str(*args)

07088     def isActualImplementation(*args):
        """isActualImplementation(self) -> Bool"""
        return _ot.NoNumericalMathHessianImplementation_isActualImplementation(*args)

07092     def hessian(*args):
        """hessian(self, NumericalPoint in) -> SymmetricTensor"""
        return _ot.NoNumericalMathHessianImplementation_hessian(*args)

07096     def getInputNumericalPointDimension(*args):
        """getInputNumericalPointDimension(self) -> UnsignedLong"""
        return _ot.NoNumericalMathHessianImplementation_getInputNumericalPointDimension(*args)

07100     def getOutputNumericalPointDimension(*args):
        """getOutputNumericalPointDimension(self) -> UnsignedLong"""
        return _ot.NoNumericalMathHessianImplementation_getOutputNumericalPointDimension(*args)

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

def NoNumericalMathHessianImplementation_GetClassName(*args):
  """NoNumericalMathHessianImplementation_GetClassName() -> String"""
  return _ot.NoNumericalMathHessianImplementation_GetClassName(*args)

07121 class LinearNumericalMathEvaluationImplementation(NumericalMathEvaluationImplementation):
    """Proxy of C++ 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)
    __repr__ = _swig_repr
07130     def GetClassName(*args):
        """GetClassName() -> String"""
        return _ot.LinearNumericalMathEvaluationImplementation_GetClassName(*args)

    if _newclass:GetClassName = staticmethod(GetClassName)
    __swig_getmethods__["GetClassName"] = lambda x: GetClassName
07136     def getClassName(*args):
        """getClassName(self) -> String"""
        return _ot.LinearNumericalMathEvaluationImplementation_getClassName(*args)

07140     def clone(*args):
        """clone(self) -> LinearNumericalMathEvaluationImplementation"""
        return _ot.LinearNumericalMathEvaluationImplementation_clone(*args)

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

07148     def str(*args):
        """str(self) -> String"""
        return _ot.LinearNumericalMathEvaluationImplementation_str(*args)

07152     def __call__(*args):
        """
        __call__(self, NumericalPoint in) -> NumericalPoint
        __call__(self, NumericalSample in) -> NumericalSample
        """
        return _ot.LinearNumericalMathEvaluationImplementation___call__(*args)

07159     def getInputNumericalPointDimension(*args):
        """getInputNumericalPointDimension(self) -> UnsignedLong"""
        return _ot.LinearNumericalMathEvaluationImplementation_getInputNumericalPointDimension(*args)

07163     def getOutputNumericalPointDimension(*args):
        """getOutputNumericalPointDimension(self) -> UnsignedLong"""
        return _ot.LinearNumericalMathEvaluationImplementation_getOutputNumericalPointDimension(*args)

07167     def getCenter(*args):
        """getCenter(self) -> NumericalPoint"""
        return _ot.LinearNumericalMathEvaluationImplementation_getCenter(*args)

07171     def getConstant(*args):
        """getConstant(self) -> NumericalPoint"""
        return _ot.LinearNumericalMathEvaluationImplementation_getConstant(*args)

07175     def getLinear(*args):
        """getLinear(self) -> Matrix"""
        return _ot.LinearNumericalMathEvaluationImplementation_getLinear(*args)

07179     def save(*args):
        """save(self, OpenTURNS::Base::Func::LinearNumericalMathEvaluationImplementation::StorageManager::Advocate adv)"""
        return _ot.LinearNumericalMathEvaluationImplementation_save(*args)

07183     def load(*args):
        """load(self, OpenTURNS::Base::Func::LinearNumericalMathEvaluationImplementation::StorageManager::Advocate adv)"""
        return _ot.LinearNumericalMathEvaluationImplementation_load(*args)

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

def LinearNumericalMathEvaluationImplementation_GetClassName(*args):
  """LinearNumericalMathEvaluationImplementation_GetClassName() -> String"""
  return _ot.LinearNumericalMathEvaluationImplementation_GetClassName(*args)

07205 class LinearNumericalMathGradientImplementation(NumericalMathGradientImplementation):
    """Proxy of C++ 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)
    __repr__ = _swig_repr
07214     def GetClassName(*args):
        """GetClassName() -> String"""
        return _ot.LinearNumericalMathGradientImplementation_GetClassName(*args)

    if _newclass:GetClassName = staticmethod(GetClassName)
    __swig_getmethods__["GetClassName"] = lambda x: GetClassName
07220     def getClassName(*args):
        """getClassName(self) -> String"""
        return _ot.LinearNumericalMathGradientImplementation_getClassName(*args)

07224     def clone(*args):
        """clone(self) -> LinearNumericalMathGradientImplementation"""
        return _ot.LinearNumericalMathGradientImplementation_clone(*args)

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

07232     def str(*args):
        """str(self) -> String"""
        return _ot.LinearNumericalMathGradientImplementation_str(*args)

07236     def gradient(*args):
        """gradient(self, NumericalPoint in) -> Matrix"""
        return _ot.LinearNumericalMathGradientImplementation_gradient(*args)

07240     def getInputNumericalPointDimension(*args):
        """getInputNumericalPointDimension(self) -> UnsignedLong"""
        return _ot.LinearNumericalMathGradientImplementation_getInputNumericalPointDimension(*args)

07244     def getOutputNumericalPointDimension(*args):
        """getOutputNumericalPointDimension(self) -> UnsignedLong"""
        return _ot.LinearNumericalMathGradientImplementation_getOutputNumericalPointDimension(*args)

07248     def getCenter(*args):
        """getCenter(self) -> NumericalPoint"""
        return _ot.LinearNumericalMathGradientImplementation_getCenter(*args)

07252     def getConstant(*args):
        """getConstant(self) -> Matrix"""
        return _ot.LinearNumericalMathGradientImplementation_getConstant(*args)

07256     def getLinear(*args):
        """getLinear(self) -> SymmetricTensor"""
        return _ot.LinearNumericalMathGradientImplementation_getLinear(*args)

07260     def save(*args):
        """save(self, OpenTURNS::Base::Func::LinearNumericalMathGradientImplementation::StorageManager::Advocate adv)"""
        return _ot.LinearNumericalMathGradientImplementation_save(*args)

07264     def load(*args):
        """load(self, OpenTURNS::Base::Func::LinearNumericalMathGradientImplementation::StorageManager::Advocate adv)"""
        return _ot.LinearNumericalMathGradientImplementation_load(*args)

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

def LinearNumericalMathGradientImplementation_GetClassName(*args):
  """LinearNumericalMathGradientImplementation_GetClassName() -> String"""
  return _ot.LinearNumericalMathGradientImplementation_GetClassName(*args)

07286 class QuadraticNumericalMathEvaluationImplementation(NumericalMathEvaluationImplementation):
    """Proxy of C++ 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)
    __repr__ = _swig_repr
07295     def GetClassName(*args):
        """GetClassName() -> String"""
        return _ot.QuadraticNumericalMathEvaluationImplementation_GetClassName(*args)

    if _newclass:GetClassName = staticmethod(GetClassName)
    __swig_getmethods__["GetClassName"] = lambda x: GetClassName
07301     def getClassName(*args):
        """getClassName(self) -> String"""
        return _ot.QuadraticNumericalMathEvaluationImplementation_getClassName(*args)

07305     def clone(*args):
        """clone(self) -> QuadraticNumericalMathEvaluationImplementation"""
        return _ot.QuadraticNumericalMathEvaluationImplementation_clone(*args)

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

07313     def str(*args):
        """str(self) -> String"""
        return _ot.QuadraticNumericalMathEvaluationImplementation_str(*args)

07317     def __call__(*args):
        """__call__(self, NumericalPoint in) -> NumericalPoint"""
        return _ot.QuadraticNumericalMathEvaluationImplementation___call__(*args)

07321     def getInputNumericalPointDimension(*args):
        """getInputNumericalPointDimension(self) -> UnsignedLong"""
        return _ot.QuadraticNumericalMathEvaluationImplementation_getInputNumericalPointDimension(*args)

07325     def getOutputNumericalPointDimension(*args):
        """getOutputNumericalPointDimension(self) -> UnsignedLong"""
        return _ot.QuadraticNumericalMathEvaluationImplementation_getOutputNumericalPointDimension(*args)

07329     def getCenter(*args):
        """getCenter(self) -> NumericalPoint"""
        return _ot.QuadraticNumericalMathEvaluationImplementation_getCenter(*args)

07333     def getConstant(*args):
        """getConstant(self) -> NumericalPoint"""
        return _ot.QuadraticNumericalMathEvaluationImplementation_getConstant(*args)

07337     def getLinear(*args):
        """getLinear(self) -> Matrix"""
        return _ot.QuadraticNumericalMathEvaluationImplementation_getLinear(*args)

07341     def getQuadratic(*args):
        """getQuadratic(self) -> SymmetricTensor"""
        return _ot.QuadraticNumericalMathEvaluationImplementation_getQuadratic(*args)

07345     def save(*args):
        """save(self, OpenTURNS::Base::Func::QuadraticNumericalMathEvaluationImplementation::StorageManager::Advocate adv)"""
        return _ot.QuadraticNumericalMathEvaluationImplementation_save(*args)

07349     def load(*args):
        """load(self, OpenTURNS::Base::Func::QuadraticNumericalMathEvaluationImplementation::StorageManager::Advocate adv)"""
        return _ot.QuadraticNumericalMathEvaluationImplementation_load(*args)

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

def QuadraticNumericalMathEvaluationImplementation_GetClassName(*args):
  """QuadraticNumericalMathEvaluationImplementation_GetClassName() -> String"""
  return _ot.QuadraticNumericalMathEvaluationImplementation_GetClassName(*args)

07372 class ConstantNumericalMathGradientImplementation(NumericalMathGradientImplementation):
    """Proxy of C++ 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)
    __repr__ = _swig_repr
07381     def GetClassName(*args):
        """GetClassName() -> String"""
        return _ot.ConstantNumericalMathGradientImplementation_GetClassName(*args)

    if _newclass:GetClassName = staticmethod(GetClassName)
    __swig_getmethods__["GetClassName"] = lambda x: GetClassName
07387     def getClassName(*args):
        """getClassName(self) -> String"""
        return _ot.ConstantNumericalMathGradientImplementation_getClassName(*args)

07391     def clone(*args):
        """clone(self) -> ConstantNumericalMathGradientImplementation"""
        return _ot.ConstantNumericalMathGradientImplementation_clone(*args)

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

07399     def str(*args):
        """str(self) -> String"""
        return _ot.ConstantNumericalMathGradientImplementation_str(*args)

07403     def gradient(*args):
        """gradient(self, NumericalPoint in) -> Matrix"""
        return _ot.ConstantNumericalMathGradientImplementation_gradient(*args)

07407     def getInputNumericalPointDimension(*args):
        """getInputNumericalPointDimension(self) -> UnsignedLong"""
        return _ot.ConstantNumericalMathGradientImplementation_getInputNumericalPointDimension(*args)

07411     def getOutputNumericalPointDimension(*args):
        """getOutputNumericalPointDimension(self) -> UnsignedLong"""
        return _ot.ConstantNumericalMathGradientImplementation_getOutputNumericalPointDimension(*args)

07415     def getConstant(*args):
        """getConstant(self) -> Matrix"""
        return _ot.ConstantNumericalMathGradientImplementation_getConstant(*args)

07419     def save(*args):
        """save(self, OpenTURNS::Base::Func::ConstantNumericalMathGradientImplementation::StorageManager::Advocate adv)"""
        return _ot.ConstantNumericalMathGradientImplementation_save(*args)

07423     def load(*args):
        """load(self, OpenTURNS::Base::Func::ConstantNumericalMathGradientImplementation::StorageManager::Advocate adv)"""
        return _ot.ConstantNumericalMathGradientImplementation_load(*args)

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

def ConstantNumericalMathGradientImplementation_GetClassName(*args):
  """ConstantNumericalMathGradientImplementation_GetClassName() -> String"""
  return _ot.ConstantNumericalMathGradientImplementation_GetClassName(*args)

07445 class ConstantNumericalMathHessianImplementation(NumericalMathHessianImplementation):
    """Proxy of C++ 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)
    __repr__ = _swig_repr
07454     def GetClassName(*args):
        """GetClassName() -> String"""
        return _ot.ConstantNumericalMathHessianImplementation_GetClassName(*args)

    if _newclass:GetClassName = staticmethod(GetClassName)
    __swig_getmethods__["GetClassName"] = lambda x: GetClassName
07460     def getClassName(*args):
        """getClassName(self) -> String"""
        return _ot.ConstantNumericalMathHessianImplementation_getClassName(*args)

07464     def clone(*args):
        """clone(self) -> ConstantNumericalMathHessianImplementation"""
        return _ot.ConstantNumericalMathHessianImplementation_clone(*args)

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

07472     def str(*args):
        """str(self) -> String"""
        return _ot.ConstantNumericalMathHessianImplementation_str(*args)

07476     def hessian(*args):
        """hessian(self, NumericalPoint in) -> SymmetricTensor"""
        return _ot.ConstantNumericalMathHessianImplementation_hessian(*args)

07480     def getInputNumericalPointDimension(*args):
        """getInputNumericalPointDimension(self) -> UnsignedLong"""
        return _ot.ConstantNumericalMathHessianImplementation_getInputNumericalPointDimension(*args)

07484     def getOutputNumericalPointDimension(*args):
        """getOutputNumericalPointDimension(self) -> UnsignedLong"""
        return _ot.ConstantNumericalMathHessianImplementation_getOutputNumericalPointDimension(*args)

07488     def getConstant(*args):
        """getConstant(self) -> SymmetricTensor"""
        return _ot.ConstantNumericalMathHessianImplementation_getConstant(*args)

07492     def save(*args):
        """save(self, OpenTURNS::Base::Func::ConstantNumericalMathHessianImplementation::StorageManager::Advocate adv)"""
        return _ot.ConstantNumericalMathHessianImplementation_save(*args)

07496     def load(*args):
        """load(self, OpenTURNS::Base::Func::ConstantNumericalMathHessianImplementation::StorageManager::Advocate adv)"""
        return _ot.ConstantNumericalMathHessianImplementation_load(*args)

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

def ConstantNumericalMathHessianImplementation_GetClassName(*args):
  """ConstantNumericalMathHessianImplementation_GetClassName() -> String"""
  return _ot.ConstantNumericalMathHessianImplementation_GetClassName(*args)

07518 class ComputedNumericalMathEvaluationImplementation(NumericalMathEvaluationImplementation):
    """Proxy of C++ 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)
    __repr__ = _swig_repr
07527     def GetClassName(*args):
        """GetClassName() -> String"""
        return _ot.ComputedNumericalMathEvaluationImplementation_GetClassName(*args)

    if _newclass:GetClassName = staticmethod(GetClassName)
    __swig_getmethods__["GetClassName"] = lambda x: GetClassName
07533     def getClassName(*args):
        """getClassName(self) -> String"""
        return _ot.ComputedNumericalMathEvaluationImplementation_getClassName(*args)

07537     def __init__(self, *args): 
        """
        __init__(self, String name, WrapperFile file) -> ComputedNumericalMathEvaluationImplementation
        __init__(self, ComputedNumericalMathEvaluationImplementation other) -> ComputedNumericalMathEvaluationImplementation
        """
        this = _ot.new_ComputedNumericalMathEvaluationImplementation(*args)
        try: self.this.append(this)
        except: self.this = this
07545     def clone(*args):
        """clone(self) -> ComputedNumericalMathEvaluationImplementation"""
        return _ot.ComputedNumericalMathEvaluationImplementation_clone(*args)

    __swig_destroy__ = _ot.delete_ComputedNumericalMathEvaluationImplementation
    __del__ = lambda self : None;
07551     def __eq__(*args):
        """__eq__(self, ComputedNumericalMathEvaluationImplementation other) -> Bool"""
        return _ot.ComputedNumericalMathEvaluationImplementation___eq__(*args)

07555     def str(*args):
        """str(self) -> String"""
        return _ot.ComputedNumericalMathEvaluationImplementation_str(*args)

07559     def __call__(*args):
        """
        __call__(self, NumericalPoint in) -> NumericalPoint
        __call__(self, NumericalSample in) -> NumericalSample
        """
        return _ot.ComputedNumericalMathEvaluationImplementation___call__(*args)

07566     def getInputNumericalPointDimension(*args):
        """getInputNumericalPointDimension(self) -> UnsignedLong"""
        return _ot.ComputedNumericalMathEvaluationImplementation_getInputNumericalPointDimension(*args)

07570     def getOutputNumericalPointDimension(*args):
        """getOutputNumericalPointDimension(self) -> UnsignedLong"""
        return _ot.ComputedNumericalMathEvaluationImplementation_getOutputNumericalPointDimension(*args)

07574     def getDescription(*args):
        """getDescription(self) -> Description"""
        return _ot.ComputedNumericalMathEvaluationImplementation_getDescription(*args)

07578     def save(*args):
        """save(self, OpenTURNS::Base::Func::NumericalMathEvaluationImplementation::StorageManager::Advocate adv)"""
        return _ot.ComputedNumericalMathEvaluationImplementation_save(*args)

07582     def load(*args):
        """load(self, OpenTURNS::Base::Func::NumericalMathEvaluationImplementation::StorageManager::Advocate adv)"""
        return _ot.ComputedNumericalMathEvaluationImplementation_load(*args)

ComputedNumericalMathEvaluationImplementation_swigregister = _ot.ComputedNumericalMathEvaluationImplementation_swigregister
ComputedNumericalMathEvaluationImplementation_swigregister(ComputedNumericalMathEvaluationImplementation)

def ComputedNumericalMathEvaluationImplementation_GetClassName(*args):
  """ComputedNumericalMathEvaluationImplementation_GetClassName() -> String"""
  return _ot.ComputedNumericalMathEvaluationImplementation_GetClassName(*args)

07593 class ComputedNumericalMathGradientImplementation(NumericalMathGradientImplementation):
    """Proxy of C++ 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)
    __repr__ = _swig_repr
07602     def GetClassName(*args):
        """GetClassName() -> String"""
        return _ot.ComputedNumericalMathGradientImplementation_GetClassName(*args)

    if _newclass:GetClassName = staticmethod(GetClassName)
    __swig_getmethods__["GetClassName"] = lambda x: GetClassName
07608     def getClassName(*args):
        """getClassName(self) -> String"""
        return _ot.ComputedNumericalMathGradientImplementation_getClassName(*args)

07612     def __init__(self, *args): 
        """
        __init__(self, String name, WrapperFile file, void p_state=0) -> ComputedNumericalMathGradientImplementation
        __init__(self, String name, WrapperFile file) -> ComputedNumericalMathGradientImplementation
        __init__(self, ComputedNumericalMathGradientImplementation other) -> ComputedNumericalMathGradientImplementation
        """
        this = _ot.new_ComputedNumericalMathGradientImplementation(*args)
        try: self.this.append(this)
        except: self.this = this
07621     def clone(*args):
        """clone(self) -> ComputedNumericalMathGradientImplementation"""
        return _ot.ComputedNumericalMathGradientImplementation_clone(*args)

    __swig_destroy__ = _ot.delete_ComputedNumericalMathGradientImplementation
    __del__ = lambda self : None;
07627     def __eq__(*args):
        """__eq__(self, ComputedNumericalMathGradientImplementation other) -> Bool"""
        return _ot.ComputedNumericalMathGradientImplementation___eq__(*args)

07631     def str(*args):
        """str(self) -> String"""
        return _ot.ComputedNumericalMathGradientImplementation_str(*args)

07635     def gradient(*args):
        """gradient(self, NumericalPoint in) -> Matrix"""
        return _ot.ComputedNumericalMathGradientImplementation_gradient(*args)

07639     def getInputNumericalPointDimension(*args):
        """getInputNumericalPointDimension(self) -> UnsignedLong"""
        return _ot.ComputedNumericalMathGradientImplementation_getInputNumericalPointDimension(*args)

07643     def getOutputNumericalPointDimension(*args):
        """getOutputNumericalPointDimension(self) -> UnsignedLong"""
        return _ot.ComputedNumericalMathGradientImplementation_getOutputNumericalPointDimension(*args)

07647     def save(*args):
        """save(self, OpenTURNS::Base::Func::NumericalMathGradientImplementation::StorageManager::Advocate adv)"""
        return _ot.ComputedNumericalMathGradientImplementation_save(*args)

07651     def load(*args):
        """load(self, OpenTURNS::Base::Func::NumericalMathGradientImplementation::StorageManager::Advocate adv)"""
        return _ot.ComputedNumericalMathGradientImplementation_load(*args)

ComputedNumericalMathGradientImplementation_swigregister = _ot.ComputedNumericalMathGradientImplementation_swigregister
ComputedNumericalMathGradientImplementation_swigregister(ComputedNumericalMathGradientImplementation)

def ComputedNumericalMathGradientImplementation_GetClassName(*args):
  """ComputedNumericalMathGradientImplementation_GetClassName() -> String"""
  return _ot.ComputedNumericalMathGradientImplementation_GetClassName(*args)

07662 class ComputedNumericalMathHessianImplementation(NumericalMathHessianImplementation):
    """Proxy of C++ 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)
    __repr__ = _swig_repr
07671     def GetClassName(*args):
        """GetClassName() -> String"""
        return _ot.ComputedNumericalMathHessianImplementation_GetClassName(*args)

    if _newclass:GetClassName = staticmethod(GetClassName)
    __swig_getmethods__["GetClassName"] = lambda x: GetClassName
07677     def getClassName(*args):
        """getClassName(self) -> String"""
        return _ot.ComputedNumericalMathHessianImplementation_getClassName(*args)

07681     def __init__(self, *args): 
        """
        __init__(self, String name, WrapperFile file, void p_state=0) -> ComputedNumericalMathHessianImplementation
        __init__(self, String name, WrapperFile file) -> ComputedNumericalMathHessianImplementation
        __init__(self, ComputedNumericalMathHessianImplementation other) -> ComputedNumericalMathHessianImplementation
        """
        this = _ot.new_ComputedNumericalMathHessianImplementation(*args)
        try: self.this.append(this)
        except: self.this = this
07690     def clone(*args):
        """clone(self) -> ComputedNumericalMathHessianImplementation"""
        return _ot.ComputedNumericalMathHessianImplementation_clone(*args)

    __swig_destroy__ = _ot.delete_ComputedNumericalMathHessianImplementation
    __del__ = lambda self : None;
07696     def __eq__(*args):
        """__eq__(self, ComputedNumericalMathHessianImplementation other) -> Bool"""
        return _ot.ComputedNumericalMathHessianImplementation___eq__(*args)

07700     def str(*args):
        """str(self) -> String"""
        return _ot.ComputedNumericalMathHessianImplementation_str(*args)

07704     def hessian(*args):
        """hessian(self, NumericalPoint in) -> SymmetricTensor"""
        return _ot.ComputedNumericalMathHessianImplementation_hessian(*args)

07708     def getInputNumericalPointDimension(*args):
        """getInputNumericalPointDimension(self) -> UnsignedLong"""
        return _ot.ComputedNumericalMathHessianImplementation_getInputNumericalPointDimension(*args)

07712     def getOutputNumericalPointDimension(*args):
        """getOutputNumericalPointDimension(self) -> UnsignedLong"""
        return _ot.ComputedNumericalMathHessianImplementation_getOutputNumericalPointDimension(*args)

07716     def save(*args):
        """save(self, OpenTURNS::Base::Func::NumericalMathHessianImplementation::StorageManager::Advocate adv)"""
        return _ot.ComputedNumericalMathHessianImplementation_save(*args)

07720     def load(*args):
        """load(self, OpenTURNS::Base::Func::NumericalMathHessianImplementation::StorageManager::Advocate adv)"""
        return _ot.ComputedNumericalMathHessianImplementation_load(*args)

ComputedNumericalMathHessianImplementation_swigregister = _ot.ComputedNumericalMathHessianImplementation_swigregister
ComputedNumericalMathHessianImplementation_swigregister(ComputedNumericalMathHessianImplementation)

def ComputedNumericalMathHessianImplementation_GetClassName(*args):
  """ComputedNumericalMathHessianImplementation_GetClassName() -> String"""
  return _ot.ComputedNumericalMathHessianImplementation_GetClassName(*args)

07731 class ComposedNumericalMathEvaluationImplementation(NumericalMathEvaluationImplementation):
    """Proxy of C++ 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)
    __repr__ = _swig_repr
07740     def GetClassName(*args):
        """GetClassName() -> String"""
        return _ot.ComposedNumericalMathEvaluationImplementation_GetClassName(*args)

    if _newclass:GetClassName = staticmethod(GetClassName)
    __swig_getmethods__["GetClassName"] = lambda x: GetClassName
07746     def getClassName(*args):
        """getClassName(self) -> String"""
        return _ot.ComposedNumericalMathEvaluationImplementation_getClassName(*args)

07750     def clone(*args):
        """clone(self) -> ComposedNumericalMathEvaluationImplementation"""
        return _ot.ComposedNumericalMathEvaluationImplementation_clone(*args)

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

07758     def str(*args):
        """str(self) -> String"""
        return _ot.ComposedNumericalMathEvaluationImplementation_str(*args)

07762     def __call__(*args):
        """
        __call__(self, NumericalPoint in) -> NumericalPoint
        __call__(self, NumericalSample in) -> NumericalSample
        """
        return _ot.ComposedNumericalMathEvaluationImplementation___call__(*args)

07769     def getParameters(*args):
        """getParameters(self) -> NumericalPointWithDescription"""
        return _ot.ComposedNumericalMathEvaluationImplementation_getParameters(*args)

07773     def setParameters(*args):
        """setParameters(self, NumericalPointWithDescription parameters)"""
        return _ot.ComposedNumericalMathEvaluationImplementation_setParameters(*args)

07777     def getInputNumericalPointDimension(*args):
        """getInputNumericalPointDimension(self) -> UnsignedLong"""
        return _ot.ComposedNumericalMathEvaluationImplementation_getInputNumericalPointDimension(*args)

07781     def getOutputNumericalPointDimension(*args):
        """getOutputNumericalPointDimension(self) -> UnsignedLong"""
        return _ot.ComposedNumericalMathEvaluationImplementation_getOutputNumericalPointDimension(*args)

07785     def save(*args):
        """save(self, OpenTURNS::Base::Func::NumericalMathEvaluationImplementation::StorageManager::Advocate adv)"""
        return _ot.ComposedNumericalMathEvaluationImplementation_save(*args)

07789     def load(*args):
        """load(self, OpenTURNS::Base::Func::NumericalMathEvaluationImplementation::StorageManager::Advocate adv)"""
        return _ot.ComposedNumericalMathEvaluationImplementation_load(*args)

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

def ComposedNumericalMathEvaluationImplementation_GetClassName(*args):
  """ComposedNumericalMathEvaluationImplementation_GetClassName() -> String"""
  return _ot.ComposedNumericalMathEvaluationImplementation_GetClassName(*args)

07810 class ComposedNumericalMathGradientImplementation(NumericalMathGradientImplementation):
    """Proxy of C++ 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)
    __repr__ = _swig_repr
07819     def GetClassName(*args):
        """GetClassName() -> String"""
        return _ot.ComposedNumericalMathGradientImplementation_GetClassName(*args)

    if _newclass:GetClassName = staticmethod(GetClassName)
    __swig_getmethods__["GetClassName"] = lambda x: GetClassName
07825     def getClassName(*args):
        """getClassName(self) -> String"""
        return _ot.ComposedNumericalMathGradientImplementation_getClassName(*args)

07829     def clone(*args):
        """clone(self) -> ComposedNumericalMathGradientImplementation"""
        return _ot.ComposedNumericalMathGradientImplementation_clone(*args)

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

07837     def str(*args):
        """str(self) -> String"""
        return _ot.ComposedNumericalMathGradientImplementation_str(*args)

07841     def gradient(*args):
        """gradient(self, NumericalPoint in) -> Matrix"""
        return _ot.ComposedNumericalMathGradientImplementation_gradient(*args)

07845     def getInputNumericalPointDimension(*args):
        """getInputNumericalPointDimension(self) -> UnsignedLong"""
        return _ot.ComposedNumericalMathGradientImplementation_getInputNumericalPointDimension(*args)

07849     def getOutputNumericalPointDimension(*args):
        """getOutputNumericalPointDimension(self) -> UnsignedLong"""
        return _ot.ComposedNumericalMathGradientImplementation_getOutputNumericalPointDimension(*args)

07853     def save(*args):
        """save(self, OpenTURNS::Base::Func::ComposedNumericalMathGradientImplementation::StorageManager::Advocate adv)"""
        return _ot.ComposedNumericalMathGradientImplementation_save(*args)

07857     def load(*args):
        """load(self, OpenTURNS::Base::Func::ComposedNumericalMathGradientImplementation::StorageManager::Advocate adv)"""
        return _ot.ComposedNumericalMathGradientImplementation_load(*args)

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

def ComposedNumericalMathGradientImplementation_GetClassName(*args):
  """ComposedNumericalMathGradientImplementation_GetClassName() -> String"""
  return _ot.ComposedNumericalMathGradientImplementation_GetClassName(*args)

07879 class ComposedNumericalMathHessianImplementation(NumericalMathHessianImplementation):
    """Proxy of C++ 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)
    __repr__ = _swig_repr
07888     def GetClassName(*args):
        """GetClassName() -> String"""
        return _ot.ComposedNumericalMathHessianImplementation_GetClassName(*args)

    if _newclass:GetClassName = staticmethod(GetClassName)
    __swig_getmethods__["GetClassName"] = lambda x: GetClassName
07894     def getClassName(*args):
        """getClassName(self) -> String"""
        return _ot.ComposedNumericalMathHessianImplementation_getClassName(*args)

07898     def clone(*args):
        """clone(self) -> ComposedNumericalMathHessianImplementation"""
        return _ot.ComposedNumericalMathHessianImplementation_clone(*args)

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

07906     def str(*args):
        """str(self) -> String"""
        return _ot.ComposedNumericalMathHessianImplementation_str(*args)

07910     def hessian(*args):
        """hessian(self, NumericalPoint in) -> SymmetricTensor"""
        return _ot.ComposedNumericalMathHessianImplementation_hessian(*args)

07914     def getInputNumericalPointDimension(*args):
        """getInputNumericalPointDimension(self) -> UnsignedLong"""
        return _ot.ComposedNumericalMathHessianImplementation_getInputNumericalPointDimension(*args)

07918     def getOutputNumericalPointDimension(*args):
        """getOutputNumericalPointDimension(self) -> UnsignedLong"""
        return _ot.ComposedNumericalMathHessianImplementation_getOutputNumericalPointDimension(*args)

07922     def save(*args):
        """save(self, OpenTURNS::Base::Func::ComposedNumericalMathHessianImplementation::StorageManager::Advocate adv)"""
        return _ot.ComposedNumericalMathHessianImplementation_save(*args)

07926     def load(*args):
        """load(self, OpenTURNS::Base::Func::ComposedNumericalMathHessianImplementation::StorageManager::Advocate adv)"""
        return _ot.ComposedNumericalMathHessianImplementation_load(*args)

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

def ComposedNumericalMathHessianImplementation_GetClassName(*args):
  """ComposedNumericalMathHessianImplementation_GetClassName() -> String"""
  return _ot.ComposedNumericalMathHessianImplementation_GetClassName(*args)

07950 class EvaluationImplementation(_object):
    """Proxy of C++ EvaluationImplementation 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)
    __repr__ = _swig_repr
    __swig_setmethods__["ptr_"] = _ot.EvaluationImplementation_ptr__set
    __swig_getmethods__["ptr_"] = _ot.EvaluationImplementation_ptr__get
    if _newclass:ptr_ = _swig_property(_ot.EvaluationImplementation_ptr__get, _ot.EvaluationImplementation_ptr__set)
07960     def __init__(self, *args): 
        """
        __init__(self) -> EvaluationImplementation
        __init__(self, NumericalMathEvaluationImplementation ptr) -> EvaluationImplementation
        """
        this = _ot.new_EvaluationImplementation(*args)
        try: self.this.append(this)
        except: self.this = this
    __swig_destroy__ = _ot.delete_EvaluationImplementation
    __del__ = lambda self : None;
07970     def reset(*args):
        """reset(self)"""
        return _ot.EvaluationImplementation_reset(*args)

07974     def __ref__(*args):
        """
        __ref__(self) -> NumericalMathEvaluationImplementation
        __ref__(self) -> NumericalMathEvaluationImplementation
        """
        return _ot.EvaluationImplementation___ref__(*args)

07981     def __deref__(*args):
        """
        __deref__(self) -> NumericalMathEvaluationImplementation
        __deref__(self) -> NumericalMathEvaluationImplementation
        """
        return _ot.EvaluationImplementation___deref__(*args)

07988     def isNull(*args):
        """isNull(self) -> Bool"""
        return _ot.EvaluationImplementation_isNull(*args)

07992     def get(*args):
        """get(self) -> NumericalMathEvaluationImplementation"""
        return _ot.EvaluationImplementation_get(*args)

07996     def getImplementation(*args):
        """getImplementation(self) -> pointer_type"""
        return _ot.EvaluationImplementation_getImplementation(*args)

08000     def unique(*args):
        """unique(self) -> Bool"""
        return _ot.EvaluationImplementation_unique(*args)

08004     def use_count(*args):
        """use_count(self) -> UnsignedLong"""
        return _ot.EvaluationImplementation_use_count(*args)

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

08012     def GetClassName(*args):
        """GetClassName(self) -> String"""
        return _ot.EvaluationImplementation_GetClassName(*args)

08016     def getClassName(*args):
        """getClassName(self) -> String"""
        return _ot.EvaluationImplementation_getClassName(*args)

08020     def clone(*args):
        """clone(self) -> NumericalMathEvaluationImplementation"""
        return _ot.EvaluationImplementation_clone(*args)

08024     def __eq__(*args):
        """__eq__(self, NumericalMathEvaluationImplementation other) -> Bool"""
        return _ot.EvaluationImplementation___eq__(*args)

08028     def str(*args):
        """str(self) -> String"""
        return _ot.EvaluationImplementation_str(*args)

08032     def setDescription(*args):
        """setDescription(self, Description description)"""
        return _ot.EvaluationImplementation_setDescription(*args)

08036     def getDescription(*args):
        """getDescription(self) -> Description"""
        return _ot.EvaluationImplementation_getDescription(*args)

08040     def getInputDescription(*args):
        """getInputDescription(self) -> Description"""
        return _ot.EvaluationImplementation_getInputDescription(*args)

08044     def getOutputDescription(*args):
        """getOutputDescription(self) -> Description"""
        return _ot.EvaluationImplementation_getOutputDescription(*args)

08048     def enableCache(*args):
        """enableCache(self)"""
        return _ot.EvaluationImplementation_enableCache(*args)

08052     def disableCache(*args):
        """disableCache(self)"""
        return _ot.EvaluationImplementation_disableCache(*args)

08056     def isCacheEnabled(*args):
        """isCacheEnabled(self) -> Bool"""
        return _ot.EvaluationImplementation_isCacheEnabled(*args)

08060     def isActualImplementation(*args):
        """isActualImplementation(self) -> Bool"""
        return _ot.EvaluationImplementation_isActualImplementation(*args)

08064     def __call__(*args):
        """
        __call__(self, NumericalPoint in) -> NumericalPoint
        __call__(self, NumericalSample inSample) -> NumericalSample
        """
        return _ot.EvaluationImplementation___call__(*args)

08071     def getInputNumericalPointDimension(*args):
        """getInputNumericalPointDimension(self) -> UnsignedLong"""
        return _ot.EvaluationImplementation_getInputNumericalPointDimension(*args)

08075     def getOutputNumericalPointDimension(*args):
        """getOutputNumericalPointDimension(self) -> UnsignedLong"""
        return _ot.EvaluationImplementation_getOutputNumericalPointDimension(*args)

08079     def parametersGradient(*args):
        """parametersGradient(self, NumericalPoint in) -> Matrix"""
        return _ot.EvaluationImplementation_parametersGradient(*args)

08083     def getParameters(*args):
        """getParameters(self) -> NumericalPointWithDescription"""
        return _ot.EvaluationImplementation_getParameters(*args)

08087     def setParameters(*args):
        """setParameters(self, NumericalPointWithDescription parameters)"""
        return _ot.EvaluationImplementation_setParameters(*args)

08091     def getCallsNumber(*args):
        """getCallsNumber(self) -> UnsignedLong"""
        return _ot.EvaluationImplementation_getCallsNumber(*args)

08095     def save(*args):
        """save(self, OpenTURNS::Base::Func::NumericalMathEvaluationImplementation::StorageManager::Advocate adv)"""
        return _ot.EvaluationImplementation_save(*args)

08099     def load(*args):
        """load(self, OpenTURNS::Base::Func::NumericalMathEvaluationImplementation::StorageManager::Advocate adv)"""
        return _ot.EvaluationImplementation_load(*args)

08103     def Is(*args):
        """Is(self, PersistentObject other) -> Bool"""
        return _ot.EvaluationImplementation_Is(*args)

08107     def getId(*args):
        """getId(self) -> Id"""
        return _ot.EvaluationImplementation_getId(*args)

08111     def setShadowedId(*args):
        """setShadowedId(self, Id id)"""
        return _ot.EvaluationImplementation_setShadowedId(*args)

08115     def getShadowedId(*args):
        """getShadowedId(self) -> Id"""
        return _ot.EvaluationImplementation_getShadowedId(*args)

08119     def setVisibility(*args):
        """setVisibility(self, Bool visible)"""
        return _ot.EvaluationImplementation_setVisibility(*args)

08123     def getVisibility(*args):
        """getVisibility(self) -> Bool"""
        return _ot.EvaluationImplementation_getVisibility(*args)

08127     def getName(*args):
        """getName(self) -> String"""
        return _ot.EvaluationImplementation_getName(*args)

08131     def setName(*args):
        """setName(self, String name)"""
        return _ot.EvaluationImplementation_setName(*args)

08135     def __str__(*args):
        """__str__(self) -> String"""
        return _ot.EvaluationImplementation___str__(*args)

EvaluationImplementation_swigregister = _ot.EvaluationImplementation_swigregister
EvaluationImplementation_swigregister(EvaluationImplementation)

08142 class GradientImplementation(_object):
    """Proxy of C++ GradientImplementation 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)
    __repr__ = _swig_repr
    __swig_setmethods__["ptr_"] = _ot.GradientImplementation_ptr__set
    __swig_getmethods__["ptr_"] = _ot.GradientImplementation_ptr__get
    if _newclass:ptr_ = _swig_property(_ot.GradientImplementation_ptr__get, _ot.GradientImplementation_ptr__set)
08152     def __init__(self, *args): 
        """
        __init__(self) -> GradientImplementation
        __init__(self, NumericalMathGradientImplementation ptr) -> GradientImplementation
        """
        this = _ot.new_GradientImplementation(*args)
        try: self.this.append(this)
        except: self.this = this
    __swig_destroy__ = _ot.delete_GradientImplementation
    __del__ = lambda self : None;
08162     def reset(*args):
        """reset(self)"""
        return _ot.GradientImplementation_reset(*args)

08166     def __ref__(*args):
        """
        __ref__(self) -> NumericalMathGradientImplementation
        __ref__(self) -> NumericalMathGradientImplementation
        """
        return _ot.GradientImplementation___ref__(*args)

08173     def __deref__(*args):
        """
        __deref__(self) -> NumericalMathGradientImplementation
        __deref__(self) -> NumericalMathGradientImplementation
        """
        return _ot.GradientImplementation___deref__(*args)

08180     def isNull(*args):
        """isNull(self) -> Bool"""
        return _ot.GradientImplementation_isNull(*args)

08184     def get(*args):
        """get(self) -> NumericalMathGradientImplementation"""
        return _ot.GradientImplementation_get(*args)

08188     def getImplementation(*args):
        """getImplementation(self) -> pointer_type"""
        return _ot.GradientImplementation_getImplementation(*args)

08192     def unique(*args):
        """unique(self) -> Bool"""
        return _ot.GradientImplementation_unique(*args)

08196     def use_count(*args):
        """use_count(self) -> UnsignedLong"""
        return _ot.GradientImplementation_use_count(*args)

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

08204     def GetClassName(*args):
        """GetClassName(self) -> String"""
        return _ot.GradientImplementation_GetClassName(*args)

08208     def getClassName(*args):
        """getClassName(self) -> String"""
        return _ot.GradientImplementation_getClassName(*args)

08212     def clone(*args):
        """clone(self) -> NumericalMathGradientImplementation"""
        return _ot.GradientImplementation_clone(*args)