python-openturns 1.3-3 / usr / lib / python2.7 / dist-packages / openturns / metamodel.py

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




"""
Meta-modelling.
"""


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

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

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

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

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


class SwigPyIterator(_object):
    """Proxy of C++ swig::SwigPyIterator class"""
    __swig_setmethods__ = {}
    __setattr__ = lambda self, name, value: _swig_setattr(self, SwigPyIterator, name, value)
    __swig_getmethods__ = {}
    __getattr__ = lambda self, name: _swig_getattr(self, SwigPyIterator, name)
    def __init__(self, *args, **kwargs): raise AttributeError("No constructor defined - class is abstract")
    __repr__ = _swig_repr
    __swig_destroy__ = _metamodel.delete_SwigPyIterator
    __del__ = lambda self : None;
    def value(self):
        """value(SwigPyIterator self) -> PyObject *"""
        return _metamodel.SwigPyIterator_value(self)

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

GCC_VERSION = _metamodel.GCC_VERSION
class TestFailed:
  """
  TestFailed is used to raise an uniform exception in tests
  """
  __type = "TestFailed"
  def __init__(self,reason=""):
    self.reason = reason
  def type(self):
    return TestFailed.__type
  def what(self):
    return self.reason
  def __str__(self):
    return TestFailed.__type + ": " + self.reason
  def __lshift__(self,ch):
    self.reason += ch
    return self

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

    if _newclass:GetClassName = staticmethod(GetClassName)
    __swig_getmethods__["GetClassName"] = lambda x: GetClassName
    def getClassName(self):
        """getClassName(TestResult self) -> OT::String"""
        return _metamodel.TestResult_getClassName(self)

    def setDescription(self, *args):
        """setDescription(TestResult self, Description description)"""
        return _metamodel.TestResult_setDescription(self, *args)

    def getDescription(self):
        """getDescription(TestResult self) -> Description"""
        return _metamodel.TestResult_getDescription(self)

    def __repr__(self):
        """__repr__(TestResult self) -> OT::String"""
        return _metamodel.TestResult___repr__(self)

    def getBinaryQualityMeasure(self):
        """getBinaryQualityMeasure(TestResult self) -> OT::Bool"""
        return _metamodel.TestResult_getBinaryQualityMeasure(self)

    def getPValue(self):
        """getPValue(TestResult self) -> OT::NumericalScalar"""
        return _metamodel.TestResult_getPValue(self)

    def getThreshold(self):
        """getThreshold(TestResult self) -> OT::NumericalScalar"""
        return _metamodel.TestResult_getThreshold(self)

    def getTestType(self):
        """getTestType(TestResult self) -> OT::String"""
        return _metamodel.TestResult_getTestType(self)

    def __eq__(self, *args):
        """__eq__(TestResult self, TestResult other) -> OT::Bool"""
        return _metamodel.TestResult___eq__(self, *args)

    def __init__(self, *args): 
        """
        __init__(OT::TestResult self) -> TestResult
        __init__(OT::TestResult self, OT::String const & type, OT::Bool const binMeasure, OT::NumericalScalar const pVal, 
            OT::NumericalScalar const pThreshold) -> TestResult
        __init__(OT::TestResult self, TestResult other) -> TestResult
        __init__(OT::TestResult self, PyObject * pyObj) -> TestResult
        """
        this = _metamodel.new_TestResult(*args)
        try: self.this.append(this)
        except: self.this = this
    __swig_destroy__ = _metamodel.delete_TestResult
    __del__ = lambda self : None;
TestResult_swigregister = _metamodel.TestResult_swigregister
TestResult_swigregister(TestResult)

def TestResult_GetClassName():
  """TestResult_GetClassName() -> OT::String"""
  return _metamodel.TestResult_GetClassName()

import openturns.base
import openturns.statistics
import openturns.graph
import openturns.func
import openturns.geom
import openturns.diff
import openturns.optim
import openturns.solver
import openturns.algo
import openturns.experiment
import openturns.model_copula
import openturns.weightedexperiment
import openturns.orthogonalbasis
import openturns.randomvector
class MetaModelResult(openturns.common.PersistentObject):
    """Proxy of C++ OT::MetaModelResult class"""
    __swig_setmethods__ = {}
    for _s in [openturns.common.PersistentObject]: __swig_setmethods__.update(getattr(_s,'__swig_setmethods__',{}))
    __setattr__ = lambda self, name, value: _swig_setattr(self, MetaModelResult, name, value)
    __swig_getmethods__ = {}
    for _s in [openturns.common.PersistentObject]: __swig_getmethods__.update(getattr(_s,'__swig_getmethods__',{}))
    __getattr__ = lambda self, name: _swig_getattr(self, MetaModelResult, name)
    def GetClassName():
        """GetClassName() -> OT::String"""
        return _metamodel.MetaModelResult_GetClassName()

    if _newclass:GetClassName = staticmethod(GetClassName)
    __swig_getmethods__["GetClassName"] = lambda x: GetClassName
    def getClassName(self):
        """getClassName(MetaModelResult self) -> OT::String"""
        return _metamodel.MetaModelResult_getClassName(self)

    def setModel(self, *args):
        """setModel(MetaModelResult self, NumericalMathFunction model)"""
        return _metamodel.MetaModelResult_setModel(self, *args)

    def getModel(self):
        """getModel(MetaModelResult self) -> NumericalMathFunction"""
        return _metamodel.MetaModelResult_getModel(self)

    def setMetaModel(self, *args):
        """setMetaModel(MetaModelResult self, NumericalMathFunction metaModel)"""
        return _metamodel.MetaModelResult_setMetaModel(self, *args)

    def getMetaModel(self):
        """getMetaModel(MetaModelResult self) -> NumericalMathFunction"""
        return _metamodel.MetaModelResult_getMetaModel(self)

    def setResiduals(self, *args):
        """setResiduals(MetaModelResult self, NumericalPoint residuals)"""
        return _metamodel.MetaModelResult_setResiduals(self, *args)

    def getResiduals(self):
        """getResiduals(MetaModelResult self) -> NumericalPoint"""
        return _metamodel.MetaModelResult_getResiduals(self)

    def setRelativeErrors(self, *args):
        """setRelativeErrors(MetaModelResult self, NumericalPoint relativeErrors)"""
        return _metamodel.MetaModelResult_setRelativeErrors(self, *args)

    def getRelativeErrors(self):
        """getRelativeErrors(MetaModelResult self) -> NumericalPoint"""
        return _metamodel.MetaModelResult_getRelativeErrors(self)

    def __repr__(self):
        """__repr__(MetaModelResult self) -> OT::String"""
        return _metamodel.MetaModelResult___repr__(self)

    def __init__(self, *args): 
        """
        __init__(OT::MetaModelResult self) -> MetaModelResult
        __init__(OT::MetaModelResult self, NumericalMathFunction model, NumericalMathFunction metaModel, NumericalPoint residuals, 
            NumericalPoint relativeErrors) -> MetaModelResult
        __init__(OT::MetaModelResult self, MetaModelResult other) -> MetaModelResult
        """
        this = _metamodel.new_MetaModelResult(*args)
        try: self.this.append(this)
        except: self.this = this
    __swig_destroy__ = _metamodel.delete_MetaModelResult
    __del__ = lambda self : None;
MetaModelResult_swigregister = _metamodel.MetaModelResult_swigregister
MetaModelResult_swigregister(MetaModelResult)

def MetaModelResult_GetClassName():
  """MetaModelResult_GetClassName() -> OT::String"""
  return _metamodel.MetaModelResult_GetClassName()

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

    if _newclass:GetClassName = staticmethod(GetClassName)
    __swig_getmethods__["GetClassName"] = lambda x: GetClassName
    def getClassName(self):
        """getClassName(MetaModelAlgorithm self) -> OT::String"""
        return _metamodel.MetaModelAlgorithm_getClassName(self)

    def __repr__(self):
        """__repr__(MetaModelAlgorithm self) -> OT::String"""
        return _metamodel.MetaModelAlgorithm___repr__(self)

    def setDistribution(self, *args):
        """setDistribution(MetaModelAlgorithm self, Distribution distribution)"""
        return _metamodel.MetaModelAlgorithm_setDistribution(self, *args)

    def getDistribution(self):
        """getDistribution(MetaModelAlgorithm self) -> Distribution"""
        return _metamodel.MetaModelAlgorithm_getDistribution(self)

    def run(self):
        """run(MetaModelAlgorithm self)"""
        return _metamodel.MetaModelAlgorithm_run(self)

    def getInputSample(self):
        """getInputSample(MetaModelAlgorithm self) -> NumericalSample"""
        return _metamodel.MetaModelAlgorithm_getInputSample(self)

    def getOutputSample(self):
        """getOutputSample(MetaModelAlgorithm self) -> NumericalSample"""
        return _metamodel.MetaModelAlgorithm_getOutputSample(self)

    def __init__(self, *args): 
        """
        __init__(OT::MetaModelAlgorithm self, OT::String const & name=DefaultName) -> MetaModelAlgorithm
        __init__(OT::MetaModelAlgorithm self) -> MetaModelAlgorithm
        __init__(OT::MetaModelAlgorithm self, Distribution distribution, NumericalMathFunction model, OT::String const & name=DefaultName) -> MetaModelAlgorithm
        __init__(OT::MetaModelAlgorithm self, Distribution distribution, NumericalMathFunction model) -> MetaModelAlgorithm
        __init__(OT::MetaModelAlgorithm self, MetaModelAlgorithm other) -> MetaModelAlgorithm
        """
        this = _metamodel.new_MetaModelAlgorithm(*args)
        try: self.this.append(this)
        except: self.this = this
    __swig_destroy__ = _metamodel.delete_MetaModelAlgorithm
    __del__ = lambda self : None;
MetaModelAlgorithm_swigregister = _metamodel.MetaModelAlgorithm_swigregister
MetaModelAlgorithm_swigregister(MetaModelAlgorithm)

def MetaModelAlgorithm_GetClassName():
  """MetaModelAlgorithm_GetClassName() -> OT::String"""
  return _metamodel.MetaModelAlgorithm_GetClassName()

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

    if _newclass:GetClassName = staticmethod(GetClassName)
    __swig_getmethods__["GetClassName"] = lambda x: GetClassName
    def getClassName(self):
        """getClassName(LinearTaylor self) -> OT::String"""
        return _metamodel.LinearTaylor_getClassName(self)

    def __repr__(self):
        """__repr__(LinearTaylor self) -> OT::String"""
        return _metamodel.LinearTaylor___repr__(self)

    def run(self):
        """run(LinearTaylor self)"""
        return _metamodel.LinearTaylor_run(self)

    def getCenter(self):
        """getCenter(LinearTaylor self) -> NumericalPoint"""
        return _metamodel.LinearTaylor_getCenter(self)

    def getConstant(self):
        """getConstant(LinearTaylor self) -> NumericalPoint"""
        return _metamodel.LinearTaylor_getConstant(self)

    def getLinear(self):
        """getLinear(LinearTaylor self) -> Matrix"""
        return _metamodel.LinearTaylor_getLinear(self)

    def getInputFunction(self):
        """getInputFunction(LinearTaylor self) -> NumericalMathFunction"""
        return _metamodel.LinearTaylor_getInputFunction(self)

    def getResponseSurface(self):
        """getResponseSurface(LinearTaylor self) -> NumericalMathFunction"""
        return _metamodel.LinearTaylor_getResponseSurface(self)

    def __init__(self, *args): 
        """
        __init__(OT::LinearTaylor self, OT::String const & name=DefaultName) -> LinearTaylor
        __init__(OT::LinearTaylor self) -> LinearTaylor
        __init__(OT::LinearTaylor self, NumericalPoint center, NumericalMathFunction inputFunction, OT::String const & name=DefaultName) -> LinearTaylor
        __init__(OT::LinearTaylor self, NumericalPoint center, NumericalMathFunction inputFunction) -> LinearTaylor
        __init__(OT::LinearTaylor self, LinearTaylor other) -> LinearTaylor
        """
        this = _metamodel.new_LinearTaylor(*args)
        try: self.this.append(this)
        except: self.this = this
    __swig_destroy__ = _metamodel.delete_LinearTaylor
    __del__ = lambda self : None;
LinearTaylor_swigregister = _metamodel.LinearTaylor_swigregister
LinearTaylor_swigregister(LinearTaylor)

def LinearTaylor_GetClassName():
  """LinearTaylor_GetClassName() -> OT::String"""
  return _metamodel.LinearTaylor_GetClassName()

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

    if _newclass:GetClassName = staticmethod(GetClassName)
    __swig_getmethods__["GetClassName"] = lambda x: GetClassName
    def getClassName(self):
        """getClassName(QuadraticTaylor self) -> OT::String"""
        return _metamodel.QuadraticTaylor_getClassName(self)

    def __repr__(self):
        """__repr__(QuadraticTaylor self) -> OT::String"""
        return _metamodel.QuadraticTaylor___repr__(self)

    def run(self):
        """run(QuadraticTaylor self)"""
        return _metamodel.QuadraticTaylor_run(self)

    def getCenter(self):
        """getCenter(QuadraticTaylor self) -> NumericalPoint"""
        return _metamodel.QuadraticTaylor_getCenter(self)

    def getConstant(self):
        """getConstant(QuadraticTaylor self) -> NumericalPoint"""
        return _metamodel.QuadraticTaylor_getConstant(self)

    def getLinear(self):
        """getLinear(QuadraticTaylor self) -> Matrix"""
        return _metamodel.QuadraticTaylor_getLinear(self)

    def getQuadratic(self):
        """getQuadratic(QuadraticTaylor self) -> SymmetricTensor"""
        return _metamodel.QuadraticTaylor_getQuadratic(self)

    def getInputFunction(self):
        """getInputFunction(QuadraticTaylor self) -> NumericalMathFunction"""
        return _metamodel.QuadraticTaylor_getInputFunction(self)

    def getResponseSurface(self):
        """getResponseSurface(QuadraticTaylor self) -> NumericalMathFunction"""
        return _metamodel.QuadraticTaylor_getResponseSurface(self)

    def __init__(self, *args): 
        """
        __init__(OT::QuadraticTaylor self, OT::String const & name=DefaultName) -> QuadraticTaylor
        __init__(OT::QuadraticTaylor self) -> QuadraticTaylor
        __init__(OT::QuadraticTaylor self, NumericalPoint center, NumericalMathFunction inputFunction, OT::String const & name=DefaultName) -> QuadraticTaylor
        __init__(OT::QuadraticTaylor self, NumericalPoint center, NumericalMathFunction inputFunction) -> QuadraticTaylor
        __init__(OT::QuadraticTaylor self, QuadraticTaylor other) -> QuadraticTaylor
        """
        this = _metamodel.new_QuadraticTaylor(*args)
        try: self.this.append(this)
        except: self.this = this
    __swig_destroy__ = _metamodel.delete_QuadraticTaylor
    __del__ = lambda self : None;
QuadraticTaylor_swigregister = _metamodel.QuadraticTaylor_swigregister
QuadraticTaylor_swigregister(QuadraticTaylor)

def QuadraticTaylor_GetClassName():
  """QuadraticTaylor_GetClassName() -> OT::String"""
  return _metamodel.QuadraticTaylor_GetClassName()

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

    if _newclass:GetClassName = staticmethod(GetClassName)
    __swig_getmethods__["GetClassName"] = lambda x: GetClassName
    def getClassName(self):
        """getClassName(LinearLeastSquares self) -> OT::String"""
        return _metamodel.LinearLeastSquares_getClassName(self)

    def __repr__(self):
        """__repr__(LinearLeastSquares self) -> OT::String"""
        return _metamodel.LinearLeastSquares___repr__(self)

    def run(self):
        """run(LinearLeastSquares self)"""
        return _metamodel.LinearLeastSquares_run(self)

    def getConstant(self):
        """getConstant(LinearLeastSquares self) -> NumericalPoint"""
        return _metamodel.LinearLeastSquares_getConstant(self)

    def getLinear(self):
        """getLinear(LinearLeastSquares self) -> Matrix"""
        return _metamodel.LinearLeastSquares_getLinear(self)

    def getInputFunction(self):
        """getInputFunction(LinearLeastSquares self) -> NumericalMathFunction"""
        return _metamodel.LinearLeastSquares_getInputFunction(self)

    def getResponseSurface(self):
        """getResponseSurface(LinearLeastSquares self) -> NumericalMathFunction"""
        return _metamodel.LinearLeastSquares_getResponseSurface(self)

    def getDataIn(self):
        """getDataIn(LinearLeastSquares self) -> NumericalSample"""
        return _metamodel.LinearLeastSquares_getDataIn(self)

    def setDataOut(self, *args):
        """setDataOut(LinearLeastSquares self, NumericalSample dataOut)"""
        return _metamodel.LinearLeastSquares_setDataOut(self, *args)

    def getDataOut(self):
        """getDataOut(LinearLeastSquares self) -> NumericalSample"""
        return _metamodel.LinearLeastSquares_getDataOut(self)

    def __init__(self, *args): 
        """
        __init__(OT::LinearLeastSquares self, NumericalSample dataIn, NumericalMathFunction inputFunction, OT::String const & name=DefaultName) -> LinearLeastSquares
        __init__(OT::LinearLeastSquares self, NumericalSample dataIn, NumericalMathFunction inputFunction) -> LinearLeastSquares
        __init__(OT::LinearLeastSquares self, NumericalSample dataIn, NumericalSample dataOut, OT::String const & name=DefaultName) -> LinearLeastSquares
        __init__(OT::LinearLeastSquares self, NumericalSample dataIn, NumericalSample dataOut) -> LinearLeastSquares
        __init__(OT::LinearLeastSquares self, LinearLeastSquares other) -> LinearLeastSquares
        """
        this = _metamodel.new_LinearLeastSquares(*args)
        try: self.this.append(this)
        except: self.this = this
    __swig_destroy__ = _metamodel.delete_LinearLeastSquares
    __del__ = lambda self : None;
LinearLeastSquares_swigregister = _metamodel.LinearLeastSquares_swigregister
LinearLeastSquares_swigregister(LinearLeastSquares)

def LinearLeastSquares_GetClassName():
  """LinearLeastSquares_GetClassName() -> OT::String"""
  return _metamodel.LinearLeastSquares_GetClassName()

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

    if _newclass:GetClassName = staticmethod(GetClassName)
    __swig_getmethods__["GetClassName"] = lambda x: GetClassName
    def getClassName(self):
        """getClassName(QuadraticLeastSquares self) -> OT::String"""
        return _metamodel.QuadraticLeastSquares_getClassName(self)

    def __repr__(self):
        """__repr__(QuadraticLeastSquares self) -> OT::String"""
        return _metamodel.QuadraticLeastSquares___repr__(self)

    def run(self):
        """run(QuadraticLeastSquares self)"""
        return _metamodel.QuadraticLeastSquares_run(self)

    def getConstant(self):
        """getConstant(QuadraticLeastSquares self) -> NumericalPoint"""
        return _metamodel.QuadraticLeastSquares_getConstant(self)

    def getLinear(self):
        """getLinear(QuadraticLeastSquares self) -> Matrix"""
        return _metamodel.QuadraticLeastSquares_getLinear(self)

    def getQuadratic(self):
        """getQuadratic(QuadraticLeastSquares self) -> SymmetricTensor"""
        return _metamodel.QuadraticLeastSquares_getQuadratic(self)

    def getInputFunction(self):
        """getInputFunction(QuadraticLeastSquares self) -> NumericalMathFunction"""
        return _metamodel.QuadraticLeastSquares_getInputFunction(self)

    def getResponseSurface(self):
        """getResponseSurface(QuadraticLeastSquares self) -> NumericalMathFunction"""
        return _metamodel.QuadraticLeastSquares_getResponseSurface(self)

    def getDataIn(self):
        """getDataIn(QuadraticLeastSquares self) -> NumericalSample"""
        return _metamodel.QuadraticLeastSquares_getDataIn(self)

    def setDataOut(self, *args):
        """setDataOut(QuadraticLeastSquares self, NumericalSample dataOut)"""
        return _metamodel.QuadraticLeastSquares_setDataOut(self, *args)

    def getDataOut(self):
        """getDataOut(QuadraticLeastSquares self) -> NumericalSample"""
        return _metamodel.QuadraticLeastSquares_getDataOut(self)

    def __init__(self, *args): 
        """
        __init__(OT::QuadraticLeastSquares self, NumericalSample dataIn, NumericalMathFunction inputFunction, OT::String const & name=DefaultName) -> QuadraticLeastSquares
        __init__(OT::QuadraticLeastSquares self, NumericalSample dataIn, NumericalMathFunction inputFunction) -> QuadraticLeastSquares
        __init__(OT::QuadraticLeastSquares self, NumericalSample dataIn, NumericalSample dataOut, OT::String const & name=DefaultName) -> QuadraticLeastSquares
        __init__(OT::QuadraticLeastSquares self, NumericalSample dataIn, NumericalSample dataOut) -> QuadraticLeastSquares
        __init__(OT::QuadraticLeastSquares self, QuadraticLeastSquares other) -> QuadraticLeastSquares
        """
        this = _metamodel.new_QuadraticLeastSquares(*args)
        try: self.this.append(this)
        except: self.this = this
    __swig_destroy__ = _metamodel.delete_QuadraticLeastSquares
    __del__ = lambda self : None;
QuadraticLeastSquares_swigregister = _metamodel.QuadraticLeastSquares_swigregister
QuadraticLeastSquares_swigregister(QuadraticLeastSquares)

def QuadraticLeastSquares_GetClassName():
  """QuadraticLeastSquares_GetClassName() -> OT::String"""
  return _metamodel.QuadraticLeastSquares_GetClassName()

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

    if _newclass:GetClassName = staticmethod(GetClassName)
    __swig_getmethods__["GetClassName"] = lambda x: GetClassName
    def getClassName(self):
        """getClassName(AdaptiveStrategyImplementation self) -> OT::String"""
        return _metamodel.AdaptiveStrategyImplementation_getClassName(self)

    def setMaximumDimension(self, *args):
        """setMaximumDimension(AdaptiveStrategyImplementation self, OT::UnsignedLong const maximumDimension)"""
        return _metamodel.AdaptiveStrategyImplementation_setMaximumDimension(self, *args)

    def getMaximumDimension(self):
        """getMaximumDimension(AdaptiveStrategyImplementation self) -> OT::UnsignedLong"""
        return _metamodel.AdaptiveStrategyImplementation_getMaximumDimension(self)

    def computeInitialBasis(self):
        """computeInitialBasis(AdaptiveStrategyImplementation self)"""
        return _metamodel.AdaptiveStrategyImplementation_computeInitialBasis(self)

    def updateBasis(self, *args):
        """updateBasis(AdaptiveStrategyImplementation self, NumericalPoint alpha_k_p_, OT::NumericalScalar const residual_p_, OT::NumericalScalar const relativeError_p_)"""
        return _metamodel.AdaptiveStrategyImplementation_updateBasis(self, *args)

    def __repr__(self):
        """__repr__(AdaptiveStrategyImplementation self) -> OT::String"""
        return _metamodel.AdaptiveStrategyImplementation___repr__(self)

    def getBasis(self):
        """getBasis(AdaptiveStrategyImplementation self) -> OrthogonalBasis"""
        return _metamodel.AdaptiveStrategyImplementation_getBasis(self)

    def getPsi(self):
        """getPsi(AdaptiveStrategyImplementation self) -> NumericalMathFunctionCollection"""
        return _metamodel.AdaptiveStrategyImplementation_getPsi(self)

    def __init__(self, *args): 
        """
        __init__(OT::AdaptiveStrategyImplementation self) -> AdaptiveStrategyImplementation
        __init__(OT::AdaptiveStrategyImplementation self, OrthogonalBasis basis, OT::UnsignedLong const maximumDimension) -> AdaptiveStrategyImplementation
        __init__(OT::AdaptiveStrategyImplementation self, AdaptiveStrategyImplementation other) -> AdaptiveStrategyImplementation
        """
        this = _metamodel.new_AdaptiveStrategyImplementation(*args)
        try: self.this.append(this)
        except: self.this = this
    __swig_destroy__ = _metamodel.delete_AdaptiveStrategyImplementation
    __del__ = lambda self : None;
AdaptiveStrategyImplementation_swigregister = _metamodel.AdaptiveStrategyImplementation_swigregister
AdaptiveStrategyImplementation_swigregister(AdaptiveStrategyImplementation)

def AdaptiveStrategyImplementation_GetClassName():
  """AdaptiveStrategyImplementation_GetClassName() -> OT::String"""
  return _metamodel.AdaptiveStrategyImplementation_GetClassName()

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

    if _newclass:GetClassName = staticmethod(GetClassName)
    __swig_getmethods__["GetClassName"] = lambda x: GetClassName
    def getClassName(self):
        """getClassName(FixedStrategy self) -> OT::String"""
        return _metamodel.FixedStrategy_getClassName(self)

    def computeInitialBasis(self):
        """computeInitialBasis(FixedStrategy self)"""
        return _metamodel.FixedStrategy_computeInitialBasis(self)

    def updateBasis(self, *args):
        """updateBasis(FixedStrategy self, NumericalPoint alpha_k_p_, OT::NumericalScalar const residual_p_, OT::NumericalScalar const relativeError_p_)"""
        return _metamodel.FixedStrategy_updateBasis(self, *args)

    def __repr__(self):
        """__repr__(FixedStrategy self) -> OT::String"""
        return _metamodel.FixedStrategy___repr__(self)

    def __init__(self, *args): 
        """
        __init__(OT::FixedStrategy self, OrthogonalBasis basis, OT::UnsignedLong const maximumDimension) -> FixedStrategy
        __init__(OT::FixedStrategy self, FixedStrategy other) -> FixedStrategy
        """
        this = _metamodel.new_FixedStrategy(*args)
        try: self.this.append(this)
        except: self.this = this
    __swig_destroy__ = _metamodel.delete_FixedStrategy
    __del__ = lambda self : None;
FixedStrategy_swigregister = _metamodel.FixedStrategy_swigregister
FixedStrategy_swigregister(FixedStrategy)

def FixedStrategy_GetClassName():
  """FixedStrategy_GetClassName() -> OT::String"""
  return _metamodel.FixedStrategy_GetClassName()

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

    if _newclass:GetClassName = staticmethod(GetClassName)
    __swig_getmethods__["GetClassName"] = lambda x: GetClassName
    def getClassName(self):
        """getClassName(SequentialStrategy self) -> OT::String"""
        return _metamodel.SequentialStrategy_getClassName(self)

    def computeInitialBasis(self):
        """computeInitialBasis(SequentialStrategy self)"""
        return _metamodel.SequentialStrategy_computeInitialBasis(self)

    def updateBasis(self, *args):
        """updateBasis(SequentialStrategy self, NumericalPoint alpha_k_p_, OT::NumericalScalar const residual_p_, OT::NumericalScalar const relativeError_p_)"""
        return _metamodel.SequentialStrategy_updateBasis(self, *args)

    def __repr__(self):
        """__repr__(SequentialStrategy self) -> OT::String"""
        return _metamodel.SequentialStrategy___repr__(self)

    def __init__(self, *args): 
        """
        __init__(OT::SequentialStrategy self, OrthogonalBasis basis, OT::UnsignedLong const maximumDimension, OT::Bool const verbose=False) -> SequentialStrategy
        __init__(OT::SequentialStrategy self, OrthogonalBasis basis, OT::UnsignedLong const maximumDimension) -> SequentialStrategy
        __init__(OT::SequentialStrategy self, SequentialStrategy other) -> SequentialStrategy
        """
        this = _metamodel.new_SequentialStrategy(*args)
        try: self.this.append(this)
        except: self.this = this
    __swig_destroy__ = _metamodel.delete_SequentialStrategy
    __del__ = lambda self : None;
SequentialStrategy_swigregister = _metamodel.SequentialStrategy_swigregister
SequentialStrategy_swigregister(SequentialStrategy)

def SequentialStrategy_GetClassName():
  """SequentialStrategy_GetClassName() -> OT::String"""
  return _metamodel.SequentialStrategy_GetClassName()

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

    if _newclass:GetClassName = staticmethod(GetClassName)
    __swig_getmethods__["GetClassName"] = lambda x: GetClassName
    def getClassName(self):
        """getClassName(CleaningStrategy self) -> OT::String"""
        return _metamodel.CleaningStrategy_getClassName(self)

    def computeInitialBasis(self):
        """computeInitialBasis(CleaningStrategy self)"""
        return _metamodel.CleaningStrategy_computeInitialBasis(self)

    def updateBasis(self, *args):
        """updateBasis(CleaningStrategy self, NumericalPoint alpha_k_p_, OT::NumericalScalar const residual_p_, OT::NumericalScalar const relativeError_p_)"""
        return _metamodel.CleaningStrategy_updateBasis(self, *args)

    def __repr__(self):
        """__repr__(CleaningStrategy self) -> OT::String"""
        return _metamodel.CleaningStrategy___repr__(self)

    def getCurrentVectorIndex(self):
        """getCurrentVectorIndex(CleaningStrategy self) -> OT::UnsignedLong"""
        return _metamodel.CleaningStrategy_getCurrentVectorIndex(self)

    def getMaximumSize(self):
        """getMaximumSize(CleaningStrategy self) -> OT::UnsignedLong"""
        return _metamodel.CleaningStrategy_getMaximumSize(self)

    def setMaximumSize(self, *args):
        """setMaximumSize(CleaningStrategy self, OT::UnsignedLong const maximumSize)"""
        return _metamodel.CleaningStrategy_setMaximumSize(self, *args)

    def getSignificanceFactor(self):
        """getSignificanceFactor(CleaningStrategy self) -> OT::NumericalScalar"""
        return _metamodel.CleaningStrategy_getSignificanceFactor(self)

    def setSignificanceFactor(self, *args):
        """setSignificanceFactor(CleaningStrategy self, OT::NumericalScalar const significanceFactor)"""
        return _metamodel.CleaningStrategy_setSignificanceFactor(self, *args)

    def getVerbose(self):
        """getVerbose(CleaningStrategy self) -> OT::Bool"""
        return _metamodel.CleaningStrategy_getVerbose(self)

    def setVerbose(self, *args):
        """setVerbose(CleaningStrategy self, OT::Bool const verbose)"""
        return _metamodel.CleaningStrategy_setVerbose(self, *args)

    def __init__(self, *args): 
        """
        __init__(OT::CleaningStrategy self, OrthogonalBasis basis, OT::UnsignedLong const maximumDimension, OT::Bool const verbose=False) -> CleaningStrategy
        __init__(OT::CleaningStrategy self, OrthogonalBasis basis, OT::UnsignedLong const maximumDimension) -> CleaningStrategy
        __init__(OT::CleaningStrategy self, OrthogonalBasis basis, OT::UnsignedLong const maximumDimension, OT::UnsignedLong const maximumSize, 
            OT::NumericalScalar const significanceFactor, OT::Bool const verbose=False) -> CleaningStrategy
        __init__(OT::CleaningStrategy self, OrthogonalBasis basis, OT::UnsignedLong const maximumDimension, OT::UnsignedLong const maximumSize, 
            OT::NumericalScalar const significanceFactor) -> CleaningStrategy
        __init__(OT::CleaningStrategy self, CleaningStrategy other) -> CleaningStrategy
        """
        this = _metamodel.new_CleaningStrategy(*args)
        try: self.this.append(this)
        except: self.this = this
    __swig_destroy__ = _metamodel.delete_CleaningStrategy
    __del__ = lambda self : None;
CleaningStrategy_swigregister = _metamodel.CleaningStrategy_swigregister
CleaningStrategy_swigregister(CleaningStrategy)

def CleaningStrategy_GetClassName():
  """CleaningStrategy_GetClassName() -> OT::String"""
  return _metamodel.CleaningStrategy_GetClassName()

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

    def getImplementationAsPersistentObject(self):
        """getImplementationAsPersistentObject(AdaptiveStrategyImplementationTypedInterfaceObject self) -> PersistentObjectPointer"""
        return _metamodel.AdaptiveStrategyImplementationTypedInterfaceObject_getImplementationAsPersistentObject(self)

    def setImplementationAsPersistentObject(self, *args):
        """setImplementationAsPersistentObject(AdaptiveStrategyImplementationTypedInterfaceObject self, PersistentObjectPointer obj)"""
        return _metamodel.AdaptiveStrategyImplementationTypedInterfaceObject_setImplementationAsPersistentObject(self, *args)

    def swap(self, *args):
        """swap(AdaptiveStrategyImplementationTypedInterfaceObject self, AdaptiveStrategyImplementationTypedInterfaceObject other)"""
        return _metamodel.AdaptiveStrategyImplementationTypedInterfaceObject_swap(self, *args)

    def setName(self, *args):
        """setName(AdaptiveStrategyImplementationTypedInterfaceObject self, OT::String const & name)"""
        return _metamodel.AdaptiveStrategyImplementationTypedInterfaceObject_setName(self, *args)

    def getName(self):
        """getName(AdaptiveStrategyImplementationTypedInterfaceObject self) -> OT::String"""
        return _metamodel.AdaptiveStrategyImplementationTypedInterfaceObject_getName(self)

    def __eq__(self, *args):
        """__eq__(AdaptiveStrategyImplementationTypedInterfaceObject self, AdaptiveStrategyImplementationTypedInterfaceObject other) -> OT::Bool"""
        return _metamodel.AdaptiveStrategyImplementationTypedInterfaceObject___eq__(self, *args)

    __swig_destroy__ = _metamodel.delete_AdaptiveStrategyImplementationTypedInterfaceObject
    __del__ = lambda self : None;
AdaptiveStrategyImplementationTypedInterfaceObject_swigregister = _metamodel.AdaptiveStrategyImplementationTypedInterfaceObject_swigregister
AdaptiveStrategyImplementationTypedInterfaceObject_swigregister(AdaptiveStrategyImplementationTypedInterfaceObject)

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

    if _newclass:GetClassName = staticmethod(GetClassName)
    __swig_getmethods__["GetClassName"] = lambda x: GetClassName
    def getClassName(self):
        """getClassName(AdaptiveStrategy self) -> OT::String"""
        return _metamodel.AdaptiveStrategy_getClassName(self)

    def setMaximumDimension(self, *args):
        """setMaximumDimension(AdaptiveStrategy self, OT::UnsignedLong const maximumDimension)"""
        return _metamodel.AdaptiveStrategy_setMaximumDimension(self, *args)

    def getMaximumDimension(self):
        """getMaximumDimension(AdaptiveStrategy self) -> OT::UnsignedLong"""
        return _metamodel.AdaptiveStrategy_getMaximumDimension(self)

    def computeInitialBasis(self):
        """computeInitialBasis(AdaptiveStrategy self)"""
        return _metamodel.AdaptiveStrategy_computeInitialBasis(self)

    def updateBasis(self, *args):
        """updateBasis(AdaptiveStrategy self, NumericalPoint alpha_k_p_, OT::NumericalScalar const residual_p_, OT::NumericalScalar const relativeError_p_)"""
        return _metamodel.AdaptiveStrategy_updateBasis(self, *args)

    def getBasis(self):
        """getBasis(AdaptiveStrategy self) -> OrthogonalBasis"""
        return _metamodel.AdaptiveStrategy_getBasis(self)

    def getPsi(self):
        """getPsi(AdaptiveStrategy self) -> NumericalMathFunctionCollection"""
        return _metamodel.AdaptiveStrategy_getPsi(self)

    def __repr__(self):
        """__repr__(AdaptiveStrategy self) -> OT::String"""
        return _metamodel.AdaptiveStrategy___repr__(self)

    def __str__(self, offset=""):
        """
        __str__(AdaptiveStrategy self, OT::String const & offset="") -> OT::String
        __str__(AdaptiveStrategy self) -> OT::String
        """
        return _metamodel.AdaptiveStrategy___str__(self, offset)

    def __init__(self, *args): 
        """
        __init__(OT::AdaptiveStrategy self) -> AdaptiveStrategy
        __init__(OT::AdaptiveStrategy self, OrthogonalBasis basis, OT::UnsignedLong const maximumDimension) -> AdaptiveStrategy
        __init__(OT::AdaptiveStrategy self, AdaptiveStrategyImplementation implementation) -> AdaptiveStrategy
        __init__(OT::AdaptiveStrategy self, AdaptiveStrategy other) -> AdaptiveStrategy
        """
        this = _metamodel.new_AdaptiveStrategy(*args)
        try: self.this.append(this)
        except: self.this = this
    __swig_destroy__ = _metamodel.delete_AdaptiveStrategy
    __del__ = lambda self : None;
AdaptiveStrategy_swigregister = _metamodel.AdaptiveStrategy_swigregister
AdaptiveStrategy_swigregister(AdaptiveStrategy)

def AdaptiveStrategy_GetClassName():
  """AdaptiveStrategy_GetClassName() -> OT::String"""
  return _metamodel.AdaptiveStrategy_GetClassName()

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

    if _newclass:GetClassName = staticmethod(GetClassName)
    __swig_getmethods__["GetClassName"] = lambda x: GetClassName
    def getClassName(self):
        """getClassName(ProjectionStrategyImplementation self) -> OT::String"""
        return _metamodel.ProjectionStrategyImplementation_getClassName(self)

    def __repr__(self):
        """__repr__(ProjectionStrategyImplementation self) -> OT::String"""
        return _metamodel.ProjectionStrategyImplementation___repr__(self)

    def setMeasure(self, *args):
        """setMeasure(ProjectionStrategyImplementation self, Distribution measure)"""
        return _metamodel.ProjectionStrategyImplementation_setMeasure(self, *args)

    def getMeasure(self):
        """getMeasure(ProjectionStrategyImplementation self) -> Distribution"""
        return _metamodel.ProjectionStrategyImplementation_getMeasure(self)

    def getInputSample(self):
        """getInputSample(ProjectionStrategyImplementation self) -> NumericalSample"""
        return _metamodel.ProjectionStrategyImplementation_getInputSample(self)

    def getOutputSample(self):
        """getOutputSample(ProjectionStrategyImplementation self) -> NumericalSample"""
        return _metamodel.ProjectionStrategyImplementation_getOutputSample(self)

    def setExperiment(self, *args):
        """setExperiment(ProjectionStrategyImplementation self, WeightedExperiment weightedExperiment)"""
        return _metamodel.ProjectionStrategyImplementation_setExperiment(self, *args)

    def getExperiment(self):
        """getExperiment(ProjectionStrategyImplementation self) -> WeightedExperiment"""
        return _metamodel.ProjectionStrategyImplementation_getExperiment(self)

    def computeCoefficients(self, *args):
        """
        computeCoefficients(ProjectionStrategyImplementation self, NumericalMathFunction function, NumericalMathFunctionCollection partialBasis, Indices indices, 
            Indices addedRanks, Indices conservedRanks, Indices removedRanks, 
            OT::UnsignedLong const marginalIndex=0)
        computeCoefficients(ProjectionStrategyImplementation self, NumericalMathFunction function, NumericalMathFunctionCollection partialBasis, Indices indices, 
            Indices addedRanks, Indices conservedRanks, Indices removedRanks)
        """
        return _metamodel.ProjectionStrategyImplementation_computeCoefficients(self, *args)

    def __init__(self, *args): 
        """
        __init__(OT::ProjectionStrategyImplementation self) -> ProjectionStrategyImplementation
        __init__(OT::ProjectionStrategyImplementation self, Distribution measure) -> ProjectionStrategyImplementation
        __init__(OT::ProjectionStrategyImplementation self, WeightedExperiment weightedExperiment) -> ProjectionStrategyImplementation
        __init__(OT::ProjectionStrategyImplementation self, Distribution measure, WeightedExperiment weightedExperiment) -> ProjectionStrategyImplementation
        __init__(OT::ProjectionStrategyImplementation self, NumericalSample inputSample, NumericalPoint weights, NumericalSample outputSample) -> ProjectionStrategyImplementation
        __init__(OT::ProjectionStrategyImplementation self, ProjectionStrategyImplementation other) -> ProjectionStrategyImplementation
        """
        this = _metamodel.new_ProjectionStrategyImplementation(*args)
        try: self.this.append(this)
        except: self.this = this
    __swig_destroy__ = _metamodel.delete_ProjectionStrategyImplementation
    __del__ = lambda self : None;
ProjectionStrategyImplementation_swigregister = _metamodel.ProjectionStrategyImplementation_swigregister
ProjectionStrategyImplementation_swigregister(ProjectionStrategyImplementation)

def ProjectionStrategyImplementation_GetClassName():
  """ProjectionStrategyImplementation_GetClassName() -> OT::String"""
  return _metamodel.ProjectionStrategyImplementation_GetClassName()

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

    if _newclass:GetClassName = staticmethod(GetClassName)
    __swig_getmethods__["GetClassName"] = lambda x: GetClassName
    def getClassName(self):
        """getClassName(LeastSquaresStrategy self) -> OT::String"""
        return _metamodel.LeastSquaresStrategy_getClassName(self)

    def __repr__(self):
        """__repr__(LeastSquaresStrategy self) -> OT::String"""
        return _metamodel.LeastSquaresStrategy___repr__(self)

    def computeCoefficients(self, *args):
        """
        computeCoefficients(LeastSquaresStrategy self, NumericalMathFunction function, NumericalMathFunctionCollection partialBasis, Indices indices, 
            Indices addedRanks, Indices conservedRanks, Indices removedRanks, 
            OT::UnsignedLong const marginalIndex=0)
        computeCoefficients(LeastSquaresStrategy self, NumericalMathFunction function, NumericalMathFunctionCollection partialBasis, Indices indices, 
            Indices addedRanks, Indices conservedRanks, Indices removedRanks)
        """
        return _metamodel.LeastSquaresStrategy_computeCoefficients(self, *args)

    def __init__(self, *args): 
        """
        __init__(OT::LeastSquaresStrategy self, ApproximationAlgorithmImplementationFactory factory=OT::PenalizedLeastSquaresAlgorithmFactory()) -> LeastSquaresStrategy
        __init__(OT::LeastSquaresStrategy self) -> LeastSquaresStrategy
        __init__(OT::LeastSquaresStrategy self, Distribution measure, ApproximationAlgorithmImplementationFactory factory=OT::PenalizedLeastSquaresAlgorithmFactory()) -> LeastSquaresStrategy
        __init__(OT::LeastSquaresStrategy self, Distribution measure) -> LeastSquaresStrategy
        __init__(OT::LeastSquaresStrategy self, WeightedExperiment weightedExperiment, ApproximationAlgorithmImplementationFactory factory=OT::PenalizedLeastSquaresAlgorithmFactory()) -> LeastSquaresStrategy
        __init__(OT::LeastSquaresStrategy self, WeightedExperiment weightedExperiment) -> LeastSquaresStrategy
        __init__(OT::LeastSquaresStrategy self, Distribution measure, WeightedExperiment weightedExperiment, ApproximationAlgorithmImplementationFactory factory=OT::PenalizedLeastSquaresAlgorithmFactory()) -> LeastSquaresStrategy
        __init__(OT::LeastSquaresStrategy self, Distribution measure, WeightedExperiment weightedExperiment) -> LeastSquaresStrategy
        __init__(OT::LeastSquaresStrategy self, NumericalSample inputSample, NumericalPoint weights, NumericalSample outputSample, 
            ApproximationAlgorithmImplementationFactory factory=OT::PenalizedLeastSquaresAlgorithmFactory()) -> LeastSquaresStrategy
        __init__(OT::LeastSquaresStrategy self, NumericalSample inputSample, NumericalPoint weights, NumericalSample outputSample) -> LeastSquaresStrategy
        __init__(OT::LeastSquaresStrategy self, NumericalSample inputSample, NumericalSample outputSample, ApproximationAlgorithmImplementationFactory factory=OT::PenalizedLeastSquaresAlgorithmFactory()) -> LeastSquaresStrategy
        __init__(OT::LeastSquaresStrategy self, NumericalSample inputSample, NumericalSample outputSample) -> LeastSquaresStrategy
        __init__(OT::LeastSquaresStrategy self, LeastSquaresStrategy other) -> LeastSquaresStrategy
        """
        this = _metamodel.new_LeastSquaresStrategy(*args)
        try: self.this.append(this)
        except: self.this = this
    __swig_destroy__ = _metamodel.delete_LeastSquaresStrategy
    __del__ = lambda self : None;
LeastSquaresStrategy_swigregister = _metamodel.LeastSquaresStrategy_swigregister
LeastSquaresStrategy_swigregister(LeastSquaresStrategy)

def LeastSquaresStrategy_GetClassName():
  """LeastSquaresStrategy_GetClassName() -> OT::String"""
  return _metamodel.LeastSquaresStrategy_GetClassName()

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

    if _newclass:GetClassName = staticmethod(GetClassName)
    __swig_getmethods__["GetClassName"] = lambda x: GetClassName
    def getClassName(self):
        """getClassName(IntegrationStrategy self) -> OT::String"""
        return _metamodel.IntegrationStrategy_getClassName(self)

    def __repr__(self):
        """__repr__(IntegrationStrategy self) -> OT::String"""
        return _metamodel.IntegrationStrategy___repr__(self)

    def computeCoefficients(self, *args):
        """
        computeCoefficients(IntegrationStrategy self, NumericalMathFunction function, NumericalMathFunctionCollection partialBasis, Indices indices, 
            Indices addedRanks, Indices conservedRanks, Indices removedRanks, 
            OT::UnsignedLong const marginalIndex=0)
        computeCoefficients(IntegrationStrategy self, NumericalMathFunction function, NumericalMathFunctionCollection partialBasis, Indices indices, 
            Indices addedRanks, Indices conservedRanks, Indices removedRanks)
        """
        return _metamodel.IntegrationStrategy_computeCoefficients(self, *args)

    def __init__(self, *args): 
        """
        __init__(OT::IntegrationStrategy self) -> IntegrationStrategy
        __init__(OT::IntegrationStrategy self, Distribution measure) -> IntegrationStrategy
        __init__(OT::IntegrationStrategy self, WeightedExperiment weightedExperiment) -> IntegrationStrategy
        __init__(OT::IntegrationStrategy self, Distribution measure, WeightedExperiment weightedExperiment) -> IntegrationStrategy
        __init__(OT::IntegrationStrategy self, NumericalSample inputSample, NumericalPoint weights, NumericalSample outputSample) -> IntegrationStrategy
        __init__(OT::IntegrationStrategy self, NumericalSample inputSample, NumericalSample outputSample) -> IntegrationStrategy
        __init__(OT::IntegrationStrategy self, IntegrationStrategy other) -> IntegrationStrategy
        """
        this = _metamodel.new_IntegrationStrategy(*args)
        try: self.this.append(this)
        except: self.this = this
    __swig_destroy__ = _metamodel.delete_IntegrationStrategy
    __del__ = lambda self : None;
IntegrationStrategy_swigregister = _metamodel.IntegrationStrategy_swigregister
IntegrationStrategy_swigregister(IntegrationStrategy)

def IntegrationStrategy_GetClassName():
  """IntegrationStrategy_GetClassName() -> OT::String"""
  return _metamodel.IntegrationStrategy_GetClassName()

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

    def getImplementationAsPersistentObject(self):
        """getImplementationAsPersistentObject(ProjectionStrategyImplementationTypedInterfaceObject self) -> PersistentObjectPointer"""
        return _metamodel.ProjectionStrategyImplementationTypedInterfaceObject_getImplementationAsPersistentObject(self)

    def setImplementationAsPersistentObject(self, *args):
        """setImplementationAsPersistentObject(ProjectionStrategyImplementationTypedInterfaceObject self, PersistentObjectPointer obj)"""
        return _metamodel.ProjectionStrategyImplementationTypedInterfaceObject_setImplementationAsPersistentObject(self, *args)

    def swap(self, *args):
        """swap(ProjectionStrategyImplementationTypedInterfaceObject self, ProjectionStrategyImplementationTypedInterfaceObject other)"""
        return _metamodel.ProjectionStrategyImplementationTypedInterfaceObject_swap(self, *args)

    def setName(self, *args):
        """setName(ProjectionStrategyImplementationTypedInterfaceObject self, OT::String const & name)"""
        return _metamodel.ProjectionStrategyImplementationTypedInterfaceObject_setName(self, *args)

    def getName(self):
        """getName(ProjectionStrategyImplementationTypedInterfaceObject self) -> OT::String"""
        return _metamodel.ProjectionStrategyImplementationTypedInterfaceObject_getName(self)

    def __eq__(self, *args):
        """__eq__(ProjectionStrategyImplementationTypedInterfaceObject self, ProjectionStrategyImplementationTypedInterfaceObject other) -> OT::Bool"""
        return _metamodel.ProjectionStrategyImplementationTypedInterfaceObject___eq__(self, *args)

    __swig_destroy__ = _metamodel.delete_ProjectionStrategyImplementationTypedInterfaceObject
    __del__ = lambda self : None;
ProjectionStrategyImplementationTypedInterfaceObject_swigregister = _metamodel.ProjectionStrategyImplementationTypedInterfaceObject_swigregister
ProjectionStrategyImplementationTypedInterfaceObject_swigregister(ProjectionStrategyImplementationTypedInterfaceObject)

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

    if _newclass:GetClassName = staticmethod(GetClassName)
    __swig_getmethods__["GetClassName"] = lambda x: GetClassName
    def getClassName(self):
        """getClassName(ProjectionStrategy self) -> OT::String"""
        return _metamodel.ProjectionStrategy_getClassName(self)

    def setMeasure(self, *args):
        """setMeasure(ProjectionStrategy self, Distribution measure)"""
        return _metamodel.ProjectionStrategy_setMeasure(self, *args)

    def getMeasure(self):
        """getMeasure(ProjectionStrategy self) -> Distribution"""
        return _metamodel.ProjectionStrategy_getMeasure(self)

    def getInputSample(self):
        """getInputSample(ProjectionStrategy self) -> NumericalSample"""
        return _metamodel.ProjectionStrategy_getInputSample(self)

    def getOutputSample(self):
        """getOutputSample(ProjectionStrategy self) -> NumericalSample"""
        return _metamodel.ProjectionStrategy_getOutputSample(self)

    def setExperiment(self, *args):
        """setExperiment(ProjectionStrategy self, WeightedExperiment weightedExperiment)"""
        return _metamodel.ProjectionStrategy_setExperiment(self, *args)

    def getExperiment(self):
        """getExperiment(ProjectionStrategy self) -> WeightedExperiment"""
        return _metamodel.ProjectionStrategy_getExperiment(self)

    def computeCoefficients(self, *args):
        """
        computeCoefficients(ProjectionStrategy self, NumericalMathFunction function, NumericalMathFunctionCollection partialBasis, Indices indices, 
            Indices addedRanks, Indices conservedRanks, Indices removedRanks, 
            OT::UnsignedLong const marginalIndex=0)
        computeCoefficients(ProjectionStrategy self, NumericalMathFunction function, NumericalMathFunctionCollection partialBasis, Indices indices, 
            Indices addedRanks, Indices conservedRanks, Indices removedRanks)
        """
        return _metamodel.ProjectionStrategy_computeCoefficients(self, *args)

    def __repr__(self):
        """__repr__(ProjectionStrategy self) -> OT::String"""
        return _metamodel.ProjectionStrategy___repr__(self)

    def __str__(self, offset=""):
        """
        __str__(ProjectionStrategy self, OT::String const & offset="") -> OT::String
        __str__(ProjectionStrategy self) -> OT::String
        """
        return _metamodel.ProjectionStrategy___str__(self, offset)

    def __init__(self, *args): 
        """
        __init__(OT::ProjectionStrategy self) -> ProjectionStrategy
        __init__(OT::ProjectionStrategy self, Distribution measure) -> ProjectionStrategy
        __init__(OT::ProjectionStrategy self, ProjectionStrategyImplementation implementation) -> ProjectionStrategy
        __init__(OT::ProjectionStrategy self, ProjectionStrategy other) -> ProjectionStrategy
        """
        this = _metamodel.new_ProjectionStrategy(*args)
        try: self.this.append(this)
        except: self.this = this
    __swig_destroy__ = _metamodel.delete_ProjectionStrategy
    __del__ = lambda self : None;
ProjectionStrategy_swigregister = _metamodel.ProjectionStrategy_swigregister
ProjectionStrategy_swigregister(ProjectionStrategy)

def ProjectionStrategy_GetClassName():
  """ProjectionStrategy_GetClassName() -> OT::String"""
  return _metamodel.ProjectionStrategy_GetClassName()

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

    if _newclass:GetClassName = staticmethod(GetClassName)
    __swig_getmethods__["GetClassName"] = lambda x: GetClassName
    def getClassName(self):
        """getClassName(FunctionalChaosResult self) -> OT::String"""
        return _metamodel.FunctionalChaosResult_getClassName(self)

    def __repr__(self):
        """__repr__(FunctionalChaosResult self) -> OT::String"""
        return _metamodel.FunctionalChaosResult___repr__(self)

    def __str__(self, offset=""):
        """
        __str__(FunctionalChaosResult self, OT::String const & offset="") -> OT::String
        __str__(FunctionalChaosResult self) -> OT::String
        """
        return _metamodel.FunctionalChaosResult___str__(self, offset)

    def getDistribution(self):
        """getDistribution(FunctionalChaosResult self) -> Distribution"""
        return _metamodel.FunctionalChaosResult_getDistribution(self)

    def getTransformation(self):
        """getTransformation(FunctionalChaosResult self) -> NumericalMathFunction"""
        return _metamodel.FunctionalChaosResult_getTransformation(self)

    def getInverseTransformation(self):
        """getInverseTransformation(FunctionalChaosResult self) -> NumericalMathFunction"""
        return _metamodel.FunctionalChaosResult_getInverseTransformation(self)

    def getComposedModel(self):
        """getComposedModel(FunctionalChaosResult self) -> NumericalMathFunction"""
        return _metamodel.FunctionalChaosResult_getComposedModel(self)

    def getOrthogonalBasis(self):
        """getOrthogonalBasis(FunctionalChaosResult self) -> OrthogonalBasis"""
        return _metamodel.FunctionalChaosResult_getOrthogonalBasis(self)

    def getIndices(self):
        """getIndices(FunctionalChaosResult self) -> Indices"""
        return _metamodel.FunctionalChaosResult_getIndices(self)

    def getCoefficients(self):
        """getCoefficients(FunctionalChaosResult self) -> NumericalSample"""
        return _metamodel.FunctionalChaosResult_getCoefficients(self)

    def getReducedBasis(self):
        """getReducedBasis(FunctionalChaosResult self) -> NumericalMathFunctionCollection"""
        return _metamodel.FunctionalChaosResult_getReducedBasis(self)

    def getComposedMetaModel(self):
        """getComposedMetaModel(FunctionalChaosResult self) -> NumericalMathFunction"""
        return _metamodel.FunctionalChaosResult_getComposedMetaModel(self)

    def __init__(self, *args): 
        """
        __init__(OT::FunctionalChaosResult self) -> FunctionalChaosResult
        __init__(OT::FunctionalChaosResult self, NumericalMathFunction model, Distribution distribution, NumericalMathFunction transformation, 
            NumericalMathFunction inverseTransformation, NumericalMathFunction composedModel, 
            OrthogonalBasis orthogonalBasis, Indices I, NumericalSample alpha_k, 
            NumericalMathFunctionCollection Psi_k, NumericalPoint residuals, 
            NumericalPoint relativeErrors) -> FunctionalChaosResult
        __init__(OT::FunctionalChaosResult self, FunctionalChaosResult other) -> FunctionalChaosResult
        """
        this = _metamodel.new_FunctionalChaosResult(*args)
        try: self.this.append(this)
        except: self.this = this
    __swig_destroy__ = _metamodel.delete_FunctionalChaosResult
    __del__ = lambda self : None;
FunctionalChaosResult_swigregister = _metamodel.FunctionalChaosResult_swigregister
FunctionalChaosResult_swigregister(FunctionalChaosResult)

def FunctionalChaosResult_GetClassName():
  """FunctionalChaosResult_GetClassName() -> OT::String"""
  return _metamodel.FunctionalChaosResult_GetClassName()

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

    if _newclass:GetClassName = staticmethod(GetClassName)
    __swig_getmethods__["GetClassName"] = lambda x: GetClassName
    def getClassName(self):
        """getClassName(FunctionalChaosAlgorithm self) -> OT::String"""
        return _metamodel.FunctionalChaosAlgorithm_getClassName(self)

    def __repr__(self):
        """__repr__(FunctionalChaosAlgorithm self) -> OT::String"""
        return _metamodel.FunctionalChaosAlgorithm___repr__(self)

    def setMaximumResidual(self, *args):
        """setMaximumResidual(FunctionalChaosAlgorithm self, OT::NumericalScalar residual)"""
        return _metamodel.FunctionalChaosAlgorithm_setMaximumResidual(self, *args)

    def getMaximumResidual(self):
        """getMaximumResidual(FunctionalChaosAlgorithm self) -> OT::NumericalScalar"""
        return _metamodel.FunctionalChaosAlgorithm_getMaximumResidual(self)

    def setProjectionStrategy(self, *args):
        """setProjectionStrategy(FunctionalChaosAlgorithm self, ProjectionStrategy projectionStrategy)"""
        return _metamodel.FunctionalChaosAlgorithm_setProjectionStrategy(self, *args)

    def getProjectionStrategy(self):
        """getProjectionStrategy(FunctionalChaosAlgorithm self) -> ProjectionStrategy"""
        return _metamodel.FunctionalChaosAlgorithm_getProjectionStrategy(self)

    def run(self):
        """run(FunctionalChaosAlgorithm self)"""
        return _metamodel.FunctionalChaosAlgorithm_run(self)

    def getResult(self):
        """getResult(FunctionalChaosAlgorithm self) -> FunctionalChaosResult"""
        return _metamodel.FunctionalChaosAlgorithm_getResult(self)

    def getInputSample(self):
        """getInputSample(FunctionalChaosAlgorithm self) -> NumericalSample"""
        return _metamodel.FunctionalChaosAlgorithm_getInputSample(self)

    def getOutputSample(self):
        """getOutputSample(FunctionalChaosAlgorithm self) -> NumericalSample"""
        return _metamodel.FunctionalChaosAlgorithm_getOutputSample(self)

    def __init__(self, *args): 
        """
        __init__(OT::FunctionalChaosAlgorithm self, NumericalMathFunction model, Distribution distribution, AdaptiveStrategy adaptiveStrategy, 
            ProjectionStrategy projectionStrategy) -> FunctionalChaosAlgorithm
        __init__(OT::FunctionalChaosAlgorithm self, NumericalSample inputSample, NumericalSample outputSample, Distribution distribution, 
            AdaptiveStrategy adaptiveStrategy, ProjectionStrategy projectionStrategy) -> FunctionalChaosAlgorithm
        __init__(OT::FunctionalChaosAlgorithm self, NumericalSample inputSample, NumericalPoint weights, NumericalSample outputSample, 
            Distribution distribution, AdaptiveStrategy adaptiveStrategy, ProjectionStrategy projectionStrategy) -> FunctionalChaosAlgorithm
        __init__(OT::FunctionalChaosAlgorithm self, NumericalMathFunction model, Distribution distribution, AdaptiveStrategy adaptiveStrategy) -> FunctionalChaosAlgorithm
        __init__(OT::FunctionalChaosAlgorithm self, NumericalSample inputSample, NumericalSample outputSample, Distribution distribution, 
            AdaptiveStrategy adaptiveStrategy) -> FunctionalChaosAlgorithm
        __init__(OT::FunctionalChaosAlgorithm self, NumericalSample inputSample, NumericalPoint weights, NumericalSample outputSample, 
            Distribution distribution, AdaptiveStrategy adaptiveStrategy) -> FunctionalChaosAlgorithm
        __init__(OT::FunctionalChaosAlgorithm self, FunctionalChaosAlgorithm other) -> FunctionalChaosAlgorithm
        """
        this = _metamodel.new_FunctionalChaosAlgorithm(*args)
        try: self.this.append(this)
        except: self.this = this
    __swig_destroy__ = _metamodel.delete_FunctionalChaosAlgorithm
    __del__ = lambda self : None;
FunctionalChaosAlgorithm_swigregister = _metamodel.FunctionalChaosAlgorithm_swigregister
FunctionalChaosAlgorithm_swigregister(FunctionalChaosAlgorithm)

def FunctionalChaosAlgorithm_GetClassName():
  """FunctionalChaosAlgorithm_GetClassName() -> OT::String"""
  return _metamodel.FunctionalChaosAlgorithm_GetClassName()

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

    if _newclass:GetClassName = staticmethod(GetClassName)
    __swig_getmethods__["GetClassName"] = lambda x: GetClassName
    def getClassName(self):
        """getClassName(KrigingAlgorithm self) -> OT::String"""
        return _metamodel.KrigingAlgorithm_getClassName(self)

    def __repr__(self):
        """__repr__(KrigingAlgorithm self) -> OT::String"""
        return _metamodel.KrigingAlgorithm___repr__(self)

    def setOptimizer(self, *args):
        """setOptimizer(KrigingAlgorithm self, BoundConstrainedAlgorithm optimizer)"""
        return _metamodel.KrigingAlgorithm_setOptimizer(self, *args)

    def getOptimizer(self):
        """getOptimizer(KrigingAlgorithm self) -> BoundConstrainedAlgorithm"""
        return _metamodel.KrigingAlgorithm_getOptimizer(self)

    def run(self):
        """run(KrigingAlgorithm self)"""
        return _metamodel.KrigingAlgorithm_run(self)

    def setInputTransformation(self, *args):
        """setInputTransformation(KrigingAlgorithm self, NumericalMathFunction inputTransformation)"""
        return _metamodel.KrigingAlgorithm_setInputTransformation(self, *args)

    def getInputTransformation(self):
        """getInputTransformation(KrigingAlgorithm self) -> NumericalMathFunction"""
        return _metamodel.KrigingAlgorithm_getInputTransformation(self)

    def getConditionalCovarianceModel(self):
        """getConditionalCovarianceModel(KrigingAlgorithm self) -> CovarianceModel"""
        return _metamodel.KrigingAlgorithm_getConditionalCovarianceModel(self)

    def getInputSample(self):
        """getInputSample(KrigingAlgorithm self) -> NumericalSample"""
        return _metamodel.KrigingAlgorithm_getInputSample(self)

    def getOutputSample(self):
        """getOutputSample(KrigingAlgorithm self) -> NumericalSample"""
        return _metamodel.KrigingAlgorithm_getOutputSample(self)

    def getResult(self):
        """getResult(KrigingAlgorithm self) -> MetaModelResult"""
        return _metamodel.KrigingAlgorithm_getResult(self)

    def __init__(self, *args): 
        """
        __init__(OT::KrigingAlgorithm self) -> KrigingAlgorithm
        __init__(OT::KrigingAlgorithm self, NumericalSample inputSample, NumericalSample outputSample, Basis basis, CovarianceModel covarianceModel) -> KrigingAlgorithm
        __init__(OT::KrigingAlgorithm self, NumericalSample inputSample, Distribution inputDistribution, NumericalSample outputSample, 
            Basis basis, CovarianceModel covarianceModel) -> KrigingAlgorithm
        __init__(OT::KrigingAlgorithm self, KrigingAlgorithm other) -> KrigingAlgorithm
        """
        this = _metamodel.new_KrigingAlgorithm(*args)
        try: self.this.append(this)
        except: self.this = this
    __swig_destroy__ = _metamodel.delete_KrigingAlgorithm
    __del__ = lambda self : None;
KrigingAlgorithm_swigregister = _metamodel.KrigingAlgorithm_swigregister
KrigingAlgorithm_swigregister(KrigingAlgorithm)

def KrigingAlgorithm_GetClassName():
  """KrigingAlgorithm_GetClassName() -> OT::String"""
  return _metamodel.KrigingAlgorithm_GetClassName()

class PythonRandomVector(object):
    """"
    PythonRandomVector is a class to subclass
    before it can be passed on to a RandomVector
    """
    def __init__(self, dim=0):
        # Warning: these names are used in PythonRandomVectorImplementation class. Synchronize the files if changed
        self.__dim = dim
        self.__desc = list(map( lambda i: 'x' + str(i), range(dim) ))

    def __str__(self):
        return 'PythonRandomVector -> %s #%d' % (self.__desc, self.__dim)

    def __repr__(self):
        return self.__str__()
      
    def getDimension(self) :
        return self.__dim
    
    def setDescription(self, desc):
        if (len(desc) != self.__dim):
            raise ValueError('Description size does NOT match dimension')
        self.__desc  = desc
        
    def getDescription(self):
        return self.__desc
      
    def getRealization(self) :
        raise RuntimeError('You must define a method getRealization() -> X, where X is a NumericalPoint')
      
    def getMean(self):
        raise RuntimeError('You must define a method mean -> X, where X is a NumericalPoint')
      
    def getCovariance(self):
        raise RuntimeError('You must define a method var -> M, where M is a CovarianceMatrix')

class SciPyRandomVector(PythonRandomVector):     
    """
    SciPyRandomVector subclasses allows to 
    build a PythonRandomVector from a scipy distribution
    """
    def __init__(self, dist):
        super(SciPyRandomVector, self).__init__(1)
        if dist.__class__.__name__ != 'rv_frozen':
            raise TypeError('Argument is not a scipy distribution')
        self._dist = dist
      
    def getRealization(self):
        rvs = self._dist.rvs()
        return [rvs]
      
    def getSample(self, size):
        rvs = self._dist.rvs(size)
        return rvs.reshape(size, 1)
    
    def getMean(self):
        mean = float(self._dist.stats('m'))
        return [mean]
      
    def getCovariance(self):
        var = float(self._dist.stats('v'))
        return [[var]]
    

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

    def getImplementationAsPersistentObject(self):
        """getImplementationAsPersistentObject(RandomVectorImplementationTypedInterfaceObject self) -> PersistentObjectPointer"""
        return _metamodel.RandomVectorImplementationTypedInterfaceObject_getImplementationAsPersistentObject(self)

    def setImplementationAsPersistentObject(self, *args):
        """setImplementationAsPersistentObject(RandomVectorImplementationTypedInterfaceObject self, PersistentObjectPointer obj)"""
        return _metamodel.RandomVectorImplementationTypedInterfaceObject_setImplementationAsPersistentObject(self, *args)

    def swap(self, *args):
        """swap(RandomVectorImplementationTypedInterfaceObject self, RandomVectorImplementationTypedInterfaceObject other)"""
        return _metamodel.RandomVectorImplementationTypedInterfaceObject_swap(self, *args)

    def setName(self, *args):
        """setName(RandomVectorImplementationTypedInterfaceObject self, OT::String const & name)"""
        return _metamodel.RandomVectorImplementationTypedInterfaceObject_setName(self, *args)

    def getName(self):
        """getName(RandomVectorImplementationTypedInterfaceObject self) -> OT::String"""
        return _metamodel.RandomVectorImplementationTypedInterfaceObject_getName(self)

    def __eq__(self, *args):
        """__eq__(RandomVectorImplementationTypedInterfaceObject self, RandomVectorImplementationTypedInterfaceObject other) -> OT::Bool"""
        return _metamodel.RandomVectorImplementationTypedInterfaceObject___eq__(self, *args)

    __swig_destroy__ = _metamodel.delete_RandomVectorImplementationTypedInterfaceObject
    __del__ = lambda self : None;
RandomVectorImplementationTypedInterfaceObject_swigregister = _metamodel.RandomVectorImplementationTypedInterfaceObject_swigregister
RandomVectorImplementationTypedInterfaceObject_swigregister(RandomVectorImplementationTypedInterfaceObject)

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

    if _newclass:GetClassName = staticmethod(GetClassName)
    __swig_getmethods__["GetClassName"] = lambda x: GetClassName
    def getClassName(self):
        """getClassName(RandomVector self) -> OT::String"""
        return _metamodel.RandomVector_getClassName(self)

    def __repr__(self):
        """__repr__(RandomVector self) -> OT::String"""
        return _metamodel.RandomVector___repr__(self)

    def __str__(self, offset=""):
        """
        __str__(RandomVector self, OT::String const & offset="") -> OT::String
        __str__(RandomVector self) -> OT::String
        """
        return _metamodel.RandomVector___str__(self, offset)

    def setDescription(self, *args):
        """setDescription(RandomVector self, Description description)"""
        return _metamodel.RandomVector_setDescription(self, *args)

    def getDescription(self):
        """getDescription(RandomVector self) -> Description"""
        return _metamodel.RandomVector_getDescription(self)

    def isComposite(self):
        """isComposite(RandomVector self) -> OT::Bool"""
        return _metamodel.RandomVector_isComposite(self)

    def getDimension(self):
        """getDimension(RandomVector self) -> OT::UnsignedLong"""
        return _metamodel.RandomVector_getDimension(self)

    def getRealization(self):
        """getRealization(RandomVector self) -> NumericalPoint"""
        return _metamodel.RandomVector_getRealization(self)

    def getSample(self, *args):
        """getSample(RandomVector self, OT::UnsignedLong const size) -> NumericalSample"""
        return _metamodel.RandomVector_getSample(self, *args)

    def getMarginal(self, *args):
        """
        getMarginal(RandomVector self, OT::UnsignedLong const i) -> RandomVector
        getMarginal(RandomVector self, Indices indices) -> RandomVector
        """
        return _metamodel.RandomVector_getMarginal(self, *args)

    def getMean(self):
        """getMean(RandomVector self) -> NumericalPoint"""
        return _metamodel.RandomVector_getMean(self)

    def getCovariance(self):
        """getCovariance(RandomVector self) -> CovarianceMatrix"""
        return _metamodel.RandomVector_getCovariance(self)

    def getAntecedent(self):
        """getAntecedent(RandomVector self) -> RandomVectorImplementationPointer"""
        return _metamodel.RandomVector_getAntecedent(self)

    def getFunction(self):
        """getFunction(RandomVector self) -> NumericalMathFunction"""
        return _metamodel.RandomVector_getFunction(self)

    def getDistribution(self):
        """getDistribution(RandomVector self) -> Distribution"""
        return _metamodel.RandomVector_getDistribution(self)

    def getOperator(self):
        """getOperator(RandomVector self) -> ComparisonOperator"""
        return _metamodel.RandomVector_getOperator(self)

    def getThreshold(self):
        """getThreshold(RandomVector self) -> OT::NumericalScalar"""
        return _metamodel.RandomVector_getThreshold(self)

    def __init__(self, *args): 
        """
        __init__(OT::RandomVector self) -> RandomVector
        __init__(OT::RandomVector self, RandomVectorImplementation implementation, OT::String const & name=DefaultName) -> RandomVector
        __init__(OT::RandomVector self, RandomVectorImplementation implementation) -> RandomVector
        __init__(OT::RandomVector self, RandomVectorImplementationPointer p_implementation, OT::String const & name=DefaultName) -> RandomVector
        __init__(OT::RandomVector self, RandomVectorImplementationPointer p_implementation) -> RandomVector
        __init__(OT::RandomVector self, NumericalPoint point, OT::String const & name=DefaultName) -> RandomVector
        __init__(OT::RandomVector self, NumericalPoint point) -> RandomVector
        __init__(OT::RandomVector self, Distribution distribution, OT::String const & name=DefaultName) -> RandomVector
        __init__(OT::RandomVector self, Distribution distribution) -> RandomVector
        __init__(OT::RandomVector self, Distribution distribution, RandomVector randomParameters, OT::String const & name=DefaultName) -> RandomVector
        __init__(OT::RandomVector self, Distribution distribution, RandomVector randomParameters) -> RandomVector
        __init__(OT::RandomVector self, NumericalMathFunction function, RandomVector antecedent, OT::String const & name=DefaultName) -> RandomVector
        __init__(OT::RandomVector self, NumericalMathFunction function, RandomVector antecedent) -> RandomVector
        __init__(OT::RandomVector self, FunctionalChaosResult functionalChaosResult) -> RandomVector
        __init__(OT::RandomVector self, RandomVector other) -> RandomVector
        __init__(OT::RandomVector self, PyObject * pyObj) -> RandomVector
        """
        this = _metamodel.new_RandomVector(*args)
        try: self.this.append(this)
        except: self.this = this
    __swig_destroy__ = _metamodel.delete_RandomVector
    __del__ = lambda self : None;
RandomVector_swigregister = _metamodel.RandomVector_swigregister
RandomVector_swigregister(RandomVector)

def RandomVector_GetClassName():
  """RandomVector_GetClassName() -> OT::String"""
  return _metamodel.RandomVector_GetClassName()

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

    if _newclass:GetClassName = staticmethod(GetClassName)
    __swig_getmethods__["GetClassName"] = lambda x: GetClassName
    def getClassName(self):
        """getClassName(CompositeRandomVector self) -> OT::String"""
        return _metamodel.CompositeRandomVector_getClassName(self)

    def __repr__(self):
        """__repr__(CompositeRandomVector self) -> OT::String"""
        return _metamodel.CompositeRandomVector___repr__(self)

    def isComposite(self):
        """isComposite(CompositeRandomVector self) -> OT::Bool"""
        return _metamodel.CompositeRandomVector_isComposite(self)

    def getDimension(self):
        """getDimension(CompositeRandomVector self) -> OT::UnsignedLong"""
        return _metamodel.CompositeRandomVector_getDimension(self)

    def getRealization(self):
        """getRealization(CompositeRandomVector self) -> NumericalPoint"""
        return _metamodel.CompositeRandomVector_getRealization(self)

    def getSample(self, *args):
        """getSample(CompositeRandomVector self, OT::UnsignedLong const size) -> NumericalSample"""
        return _metamodel.CompositeRandomVector_getSample(self, *args)

    def getMean(self):
        """getMean(CompositeRandomVector self) -> NumericalPoint"""
        return _metamodel.CompositeRandomVector_getMean(self)

    def getCovariance(self):
        """getCovariance(CompositeRandomVector self) -> CovarianceMatrix"""
        return _metamodel.CompositeRandomVector_getCovariance(self)

    def getMarginal(self, *args):
        """
        getMarginal(CompositeRandomVector self, OT::UnsignedLong const i) -> RandomVectorImplementationPointer
        getMarginal(CompositeRandomVector self, Indices indices) -> RandomVectorImplementationPointer
        """
        return _metamodel.CompositeRandomVector_getMarginal(self, *args)

    def getAntecedent(self):
        """getAntecedent(CompositeRandomVector self) -> RandomVectorImplementationPointer"""
        return _metamodel.CompositeRandomVector_getAntecedent(self)

    def getFunction(self):
        """getFunction(CompositeRandomVector self) -> NumericalMathFunction"""
        return _metamodel.CompositeRandomVector_getFunction(self)

    def getDistribution(self):
        """getDistribution(CompositeRandomVector self) -> Distribution"""
        return _metamodel.CompositeRandomVector_getDistribution(self)

    def __init__(self, *args): 
        """
        __init__(OT::CompositeRandomVector self, OT::String const & name=DefaultName) -> CompositeRandomVector
        __init__(OT::CompositeRandomVector self) -> CompositeRandomVector
        __init__(OT::CompositeRandomVector self, NumericalMathFunction function, RandomVectorImplementationPointer p_antecedent, OT::String const & name=DefaultName) -> CompositeRandomVector
        __init__(OT::CompositeRandomVector self, NumericalMathFunction function, RandomVectorImplementationPointer p_antecedent) -> CompositeRandomVector
        __init__(OT::CompositeRandomVector self, NumericalMathFunction function, RandomVector antecedent, OT::String const & name=DefaultName) -> CompositeRandomVector
        __init__(OT::CompositeRandomVector self, NumericalMathFunction function, RandomVector antecedent) -> CompositeRandomVector
        __init__(OT::CompositeRandomVector self, CompositeRandomVector other) -> CompositeRandomVector
        """
        this = _metamodel.new_CompositeRandomVector(*args)
        try: self.this.append(this)
        except: self.this = this
    __swig_destroy__ = _metamodel.delete_CompositeRandomVector
    __del__ = lambda self : None;
CompositeRandomVector_swigregister = _metamodel.CompositeRandomVector_swigregister
CompositeRandomVector_swigregister(CompositeRandomVector)

def CompositeRandomVector_GetClassName():
  """CompositeRandomVector_GetClassName() -> OT::String"""
  return _metamodel.CompositeRandomVector_GetClassName()

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

    if _newclass:GetClassName = staticmethod(GetClassName)
    __swig_getmethods__["GetClassName"] = lambda x: GetClassName
    def getClassName(self):
        """getClassName(EventRandomVectorImplementation self) -> OT::String"""
        return _metamodel.EventRandomVectorImplementation_getClassName(self)

    def __repr__(self):
        """__repr__(EventRandomVectorImplementation self) -> OT::String"""
        return _metamodel.EventRandomVectorImplementation___repr__(self)

    def getDimension(self):
        """getDimension(EventRandomVectorImplementation self) -> OT::UnsignedLong"""
        return _metamodel.EventRandomVectorImplementation_getDimension(self)

    def getOperator(self):
        """getOperator(EventRandomVectorImplementation self) -> ComparisonOperator"""
        return _metamodel.EventRandomVectorImplementation_getOperator(self)

    def getThreshold(self):
        """getThreshold(EventRandomVectorImplementation self) -> OT::NumericalScalar"""
        return _metamodel.EventRandomVectorImplementation_getThreshold(self)

    def getRealization(self):
        """getRealization(EventRandomVectorImplementation self) -> NumericalPoint"""
        return _metamodel.EventRandomVectorImplementation_getRealization(self)

    def getSample(self, *args):
        """getSample(EventRandomVectorImplementation self, OT::UnsignedLong size) -> NumericalSample"""
        return _metamodel.EventRandomVectorImplementation_getSample(self, *args)

    def __init__(self, *args): 
        """
        __init__(OT::EventRandomVectorImplementation self) -> EventRandomVectorImplementation
        __init__(OT::EventRandomVectorImplementation self, RandomVectorImplementation antecedent, ComparisonOperator op, OT::NumericalScalar const threshold, 
            OT::String const & name=DefaultName) -> EventRandomVectorImplementation
        __init__(OT::EventRandomVectorImplementation self, RandomVectorImplementation antecedent, ComparisonOperator op, OT::NumericalScalar const threshold) -> EventRandomVectorImplementation
        __init__(OT::EventRandomVectorImplementation self, EventRandomVectorImplementation other) -> EventRandomVectorImplementation
        """
        this = _metamodel.new_EventRandomVectorImplementation(*args)
        try: self.this.append(this)
        except: self.this = this
    __swig_destroy__ = _metamodel.delete_EventRandomVectorImplementation
    __del__ = lambda self : None;
EventRandomVectorImplementation_swigregister = _metamodel.EventRandomVectorImplementation_swigregister
EventRandomVectorImplementation_swigregister(EventRandomVectorImplementation)

def EventRandomVectorImplementation_GetClassName():
  """EventRandomVectorImplementation_GetClassName() -> OT::String"""
  return _metamodel.EventRandomVectorImplementation_GetClassName()

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

    if _newclass:GetClassName = staticmethod(GetClassName)
    __swig_getmethods__["GetClassName"] = lambda x: GetClassName
    def getClassName(self):
        """getClassName(EventDomainImplementation self) -> OT::String"""
        return _metamodel.EventDomainImplementation_getClassName(self)

    def __repr__(self):
        """__repr__(EventDomainImplementation self) -> OT::String"""
        return _metamodel.EventDomainImplementation___repr__(self)

    def getDimension(self):
        """getDimension(EventDomainImplementation self) -> OT::UnsignedLong"""
        return _metamodel.EventDomainImplementation_getDimension(self)

    def getDomain(self):
        """getDomain(EventDomainImplementation self) -> Domain"""
        return _metamodel.EventDomainImplementation_getDomain(self)

    def getRealization(self):
        """getRealization(EventDomainImplementation self) -> NumericalPoint"""
        return _metamodel.EventDomainImplementation_getRealization(self)

    def getSample(self, *args):
        """getSample(EventDomainImplementation self, OT::UnsignedLong const size) -> NumericalSample"""
        return _metamodel.EventDomainImplementation_getSample(self, *args)

    def __init__(self, *args): 
        """
        __init__(OT::EventDomainImplementation self) -> EventDomainImplementation
        __init__(OT::EventDomainImplementation self, RandomVectorImplementation antecedent, Domain domain, OT::String const & name=DefaultName) -> EventDomainImplementation
        __init__(OT::EventDomainImplementation self, RandomVectorImplementation antecedent, Domain domain) -> EventDomainImplementation
        __init__(OT::EventDomainImplementation self, EventDomainImplementation other) -> EventDomainImplementation
        """
        this = _metamodel.new_EventDomainImplementation(*args)
        try: self.this.append(this)
        except: self.this = this
    __swig_destroy__ = _metamodel.delete_EventDomainImplementation
    __del__ = lambda self : None;
EventDomainImplementation_swigregister = _metamodel.EventDomainImplementation_swigregister
EventDomainImplementation_swigregister(EventDomainImplementation)

def EventDomainImplementation_GetClassName():
  """EventDomainImplementation_GetClassName() -> OT::String"""
  return _metamodel.EventDomainImplementation_GetClassName()

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

    if _newclass:GetClassName = staticmethod(GetClassName)
    __swig_getmethods__["GetClassName"] = lambda x: GetClassName
    def getClassName(self):
        """getClassName(EventProcess self) -> OT::String"""
        return _metamodel.EventProcess_getClassName(self)

    def __repr__(self):
        """__repr__(EventProcess self) -> OT::String"""
        return _metamodel.EventProcess___repr__(self)

    def getDimension(self):
        """getDimension(EventProcess self) -> OT::UnsignedLong"""
        return _metamodel.EventProcess_getDimension(self)

    def getDomain(self):
        """getDomain(EventProcess self) -> Domain"""
        return _metamodel.EventProcess_getDomain(self)

    def getProcess(self):
        """getProcess(EventProcess self) -> Process"""
        return _metamodel.EventProcess_getProcess(self)

    def getRealization(self):
        """getRealization(EventProcess self) -> NumericalPoint"""
        return _metamodel.EventProcess_getRealization(self)

    def __init__(self, *args): 
        """
        __init__(OT::EventProcess self) -> EventProcess
        __init__(OT::EventProcess self, Process process, Domain domain, OT::String const & name=DefaultName) -> EventProcess
        __init__(OT::EventProcess self, Process process, Domain domain) -> EventProcess
        __init__(OT::EventProcess self, EventProcess other) -> EventProcess
        """
        this = _metamodel.new_EventProcess(*args)
        try: self.this.append(this)
        except: self.this = this
    __swig_destroy__ = _metamodel.delete_EventProcess
    __del__ = lambda self : None;
EventProcess_swigregister = _metamodel.EventProcess_swigregister
EventProcess_swigregister(EventProcess)

def EventProcess_GetClassName():
  """EventProcess_GetClassName() -> OT::String"""
  return _metamodel.EventProcess_GetClassName()

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

    if _newclass:GetClassName = staticmethod(GetClassName)
    __swig_getmethods__["GetClassName"] = lambda x: GetClassName
    def getClassName(self):
        """getClassName(ConditionalRandomVector self) -> OT::String"""
        return _metamodel.ConditionalRandomVector_getClassName(self)

    def __repr__(self):
        """__repr__(ConditionalRandomVector self) -> OT::String"""
        return _metamodel.ConditionalRandomVector___repr__(self)

    def getDimension(self):
        """getDimension(ConditionalRandomVector self) -> OT::UnsignedLong"""
        return _metamodel.ConditionalRandomVector_getDimension(self)

    def getRealization(self, *args):
        """
        getRealization(ConditionalRandomVector self) -> NumericalPoint
        getRealization(ConditionalRandomVector self, NumericalPoint parameters) -> NumericalPoint
        """
        return _metamodel.ConditionalRandomVector_getRealization(self, *args)

    def getDistribution(self):
        """getDistribution(ConditionalRandomVector self) -> Distribution"""
        return _metamodel.ConditionalRandomVector_getDistribution(self)

    def getRandomParameters(self):
        """getRandomParameters(ConditionalRandomVector self) -> RandomVector"""
        return _metamodel.ConditionalRandomVector_getRandomParameters(self)

    def __init__(self, *args): 
        """
        __init__(OT::ConditionalRandomVector self, Distribution distribution, RandomVector randomParameters, OT::String const & name=DefaultName) -> ConditionalRandomVector
        __init__(OT::ConditionalRandomVector self, Distribution distribution, RandomVector randomParameters) -> ConditionalRandomVector
        __init__(OT::ConditionalRandomVector self, ConditionalRandomVector other) -> ConditionalRandomVector
        """
        this = _metamodel.new_ConditionalRandomVector(*args)
        try: self.this.append(this)
        except: self.this = this
    __swig_destroy__ = _metamodel.delete_ConditionalRandomVector
    __del__ = lambda self : None;
ConditionalRandomVector_swigregister = _metamodel.ConditionalRandomVector_swigregister
ConditionalRandomVector_swigregister(ConditionalRandomVector)

def ConditionalRandomVector_GetClassName():
  """ConditionalRandomVector_GetClassName() -> OT::String"""
  return _metamodel.ConditionalRandomVector_GetClassName()

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

    if _newclass:GetClassName = staticmethod(GetClassName)
    __swig_getmethods__["GetClassName"] = lambda x: GetClassName
    def getClassName(self):
        """getClassName(Event self) -> OT::String"""
        return _metamodel.Event_getClassName(self)

    def __repr__(self):
        """__repr__(Event self) -> OT::String"""
        return _metamodel.Event___repr__(self)

    def __str__(self, offset=""):
        """
        __str__(Event self, OT::String const & offset="") -> OT::String
        __str__(Event self) -> OT::String
        """
        return _metamodel.Event___str__(self, offset)

    def __init__(self, *args): 
        """
        __init__(OT::Event self) -> Event
        __init__(OT::Event self, RandomVector antecedent, ComparisonOperator op, OT::NumericalScalar const threshold, 
            OT::String const & name=DefaultName) -> Event
        __init__(OT::Event self, RandomVector antecedent, ComparisonOperator op, OT::NumericalScalar const threshold) -> Event
        __init__(OT::Event self, RandomVector antecedent, Domain domain, OT::String const & name=DefaultName) -> Event
        __init__(OT::Event self, RandomVector antecedent, Domain domain) -> Event
        __init__(OT::Event self, Process process, Domain domain, OT::String const & name=DefaultName) -> Event
        __init__(OT::Event self, Process process, Domain domain) -> Event
        __init__(OT::Event self, Event other) -> Event
        """
        this = _metamodel.new_Event(*args)
        try: self.this.append(this)
        except: self.this = this
    __swig_destroy__ = _metamodel.delete_Event
    __del__ = lambda self : None;
Event_swigregister = _metamodel.Event_swigregister
Event_swigregister(Event)

def Event_GetClassName():
  """Event_GetClassName() -> OT::String"""
  return _metamodel.Event_GetClassName()

class StandardEvent(Event):
    """Proxy of C++ OT::StandardEvent class"""
    __swig_setmethods__ = {}
    for _s in [Event]: __swig_setmethods__.update(getattr(_s,'__swig_setmethods__',{}))
    __setattr__ = lambda self, name, value: _swig_setattr(self, StandardEvent, name, value)
    __swig_getmethods__ = {}
    for _s in [Event]: __swig_getmethods__.update(getattr(_s,'__swig_getmethods__',{}))
    __getattr__ = lambda self, name: _swig_getattr(self, StandardEvent, name)
    __repr__ = _swig_repr
    def GetClassName():
        """GetClassName() -> OT::String"""
        return _metamodel.StandardEvent_GetClassName()

    if _newclass:GetClassName = staticmethod(GetClassName)
    __swig_getmethods__["GetClassName"] = lambda x: GetClassName
    def getClassName(self):
        """getClassName(StandardEvent self) -> OT::String"""
        return _metamodel.StandardEvent_getClassName(self)

    def __init__(self, *args): 
        """
        __init__(OT::StandardEvent self) -> StandardEvent
        __init__(OT::StandardEvent self, RandomVector antecedent, ComparisonOperator op, OT::NumericalScalar const threshold, 
            OT::String const & name=DefaultName) -> StandardEvent
        __init__(OT::StandardEvent self, RandomVector antecedent, ComparisonOperator op, OT::NumericalScalar const threshold) -> StandardEvent
        __init__(OT::StandardEvent self, Event event, OT::String const & name=DefaultName) -> StandardEvent
        __init__(OT::StandardEvent self, Event event) -> StandardEvent
        __init__(OT::StandardEvent self, StandardEvent other) -> StandardEvent
        """
        this = _metamodel.new_StandardEvent(*args)
        try: self.this.append(this)
        except: self.this = this
    __swig_destroy__ = _metamodel.delete_StandardEvent
    __del__ = lambda self : None;
StandardEvent_swigregister = _metamodel.StandardEvent_swigregister
StandardEvent_swigregister(StandardEvent)

def StandardEvent_GetClassName():
  """StandardEvent_GetClassName() -> OT::String"""
  return _metamodel.StandardEvent_GetClassName()

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

    if _newclass:GetClassName = staticmethod(GetClassName)
    __swig_getmethods__["GetClassName"] = lambda x: GetClassName
    def getClassName(self):
        """getClassName(FunctionalChaosRandomVector self) -> OT::String"""
        return _metamodel.FunctionalChaosRandomVector_getClassName(self)

    def __repr__(self):
        """__repr__(FunctionalChaosRandomVector self) -> OT::String"""
        return _metamodel.FunctionalChaosRandomVector___repr__(self)

    def getMean(self):
        """getMean(FunctionalChaosRandomVector self) -> NumericalPoint"""
        return _metamodel.FunctionalChaosRandomVector_getMean(self)

    def getCovariance(self):
        """getCovariance(FunctionalChaosRandomVector self) -> CovarianceMatrix"""
        return _metamodel.FunctionalChaosRandomVector_getCovariance(self)

    def getSobolIndex(self, *args):
        """
        getSobolIndex(FunctionalChaosRandomVector self, Indices variableIndices, OT::UnsignedLong const marginalIndex=0) -> OT::NumericalScalar
        getSobolIndex(FunctionalChaosRandomVector self, Indices variableIndices) -> OT::NumericalScalar
        getSobolIndex(FunctionalChaosRandomVector self, OT::UnsignedLong const variableIndex, OT::UnsignedLong const marginalIndex=0) -> OT::NumericalScalar
        getSobolIndex(FunctionalChaosRandomVector self, OT::UnsignedLong const variableIndex) -> OT::NumericalScalar
        """
        return _metamodel.FunctionalChaosRandomVector_getSobolIndex(self, *args)

    def getSobolTotalIndex(self, *args):
        """
        getSobolTotalIndex(FunctionalChaosRandomVector self, Indices variableIndices, OT::UnsignedLong const marginalIndex=0) -> OT::NumericalScalar
        getSobolTotalIndex(FunctionalChaosRandomVector self, Indices variableIndices) -> OT::NumericalScalar
        getSobolTotalIndex(FunctionalChaosRandomVector self, OT::UnsignedLong const variableIndex, OT::UnsignedLong const marginalIndex=0) -> OT::NumericalScalar
        getSobolTotalIndex(FunctionalChaosRandomVector self, OT::UnsignedLong const variableIndex) -> OT::NumericalScalar
        """
        return _metamodel.FunctionalChaosRandomVector_getSobolTotalIndex(self, *args)

    def getFunctionalChaoResult(self):
        """getFunctionalChaoResult(FunctionalChaosRandomVector self) -> FunctionalChaosResult"""
        return _metamodel.FunctionalChaosRandomVector_getFunctionalChaoResult(self)

    def __init__(self, *args): 
        """
        __init__(OT::FunctionalChaosRandomVector self, FunctionalChaosResult functionalChaosResult) -> FunctionalChaosRandomVector
        __init__(OT::FunctionalChaosRandomVector self, FunctionalChaosRandomVector other) -> FunctionalChaosRandomVector
        """
        this = _metamodel.new_FunctionalChaosRandomVector(*args)
        try: self.this.append(this)
        except: self.this = this
    __swig_destroy__ = _metamodel.delete_FunctionalChaosRandomVector
    __del__ = lambda self : None;
FunctionalChaosRandomVector_swigregister = _metamodel.FunctionalChaosRandomVector_swigregister
FunctionalChaosRandomVector_swigregister(FunctionalChaosRandomVector)

def FunctionalChaosRandomVector_GetClassName():
  """FunctionalChaosRandomVector_GetClassName() -> OT::String"""
  return _metamodel.FunctionalChaosRandomVector_GetClassName()

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