python-openturns 1.5-7build2 / 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):
    __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): return _metamodel.SwigPyIterator_value(self)
    def incr(self, n=1): return _metamodel.SwigPyIterator_incr(self, n)
    def decr(self, n=1): return _metamodel.SwigPyIterator_decr(self, n)
    def distance(self, *args): return _metamodel.SwigPyIterator_distance(self, *args)
    def equal(self, *args): return _metamodel.SwigPyIterator_equal(self, *args)
    def copy(self): return _metamodel.SwigPyIterator_copy(self)
    def next(self): return _metamodel.SwigPyIterator_next(self)
    def __next__(self): return _metamodel.SwigPyIterator___next__(self)
    def previous(self): return _metamodel.SwigPyIterator_previous(self)
    def advance(self, *args): return _metamodel.SwigPyIterator_advance(self, *args)
    def __eq__(self, *args): return _metamodel.SwigPyIterator___eq__(self, *args)
    def __ne__(self, *args): return _metamodel.SwigPyIterator___ne__(self, *args)
    def __iadd__(self, *args): return _metamodel.SwigPyIterator___iadd__(self, *args)
    def __isub__(self, *args): return _metamodel.SwigPyIterator___isub__(self, *args)
    def __add__(self, *args): return _metamodel.SwigPyIterator___add__(self, *args)
    def __sub__(self, *args): 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.base
import openturns.common
import openturns.wrapper
import openturns.typ
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):
    """
    Data structure containing a metamodel.

    Available constructor:
        MetaModelResult(model, metaModel, residuals, relativeErrors)

    Parameters
    ----------
    model : :class:`~openturns.NumericalMathFunction`
        Physical model approximated by a metamodel.
    metaModel : :class:`~openturns.NumericalMathFunction`
        Definition of the response surface(s) of the model's output(s).
    residuals : float sequence
        The residual values defined as follows for each output of the model:
        :math:`\\displaystyle \\frac{\\sqrt{\\sum_{i=1}^N (y_i - \\hat{y_i})^2}}{N}`
        with :math:`y_i` the :math:`N` model's values and :math:`\\hat{y_i}` the
        metamodel's values.
    relativeErrors : float sequence
        The relative errors defined as follows for each output of the model:
        :math:`\\displaystyle \\frac{\\sum_{i=1}^N (y_i - \\hat{y_i})^2}{N \\Var{\\vect{Y}}}`
        with :math:`\\vect{Y}` the vector of the :math:`N` model's values
        :math:`y_i` and :math:`\\hat{y_i}` the metamodel's values.

    Notes
    -----
    Structure created by the method run() of :class:`~openturns.KrigingAlgorithm`
    or :class:`~openturns.FunctionalChaosAlgorithm` and obtained thanks to the
    method getResult() of these classes.

    See also
    --------
    FunctionalChaosResult
    """
    __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(self):
        """
        Accessor to the object's name.

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

    def setModel(self, *args):
        """
        Accessor to the model.

        Parameters
        ----------
        model : :class:`~openturns.NumericalMathFunction`
            Physical model approximated by a metamodel.
        """
        return _metamodel.MetaModelResult_setModel(self, *args)

    def getModel(self):
        """
        Accessor to the model.

        Returns
        -------
        model : :class:`~openturns.NumericalMathFunction`
            Physical model approximated by a metamodel.
        """
        return _metamodel.MetaModelResult_getModel(self)

    def setMetaModel(self, *args):
        """
        Accessor to the metamodel.

        Parameters
        ----------
        metaModel : :class:`~openturns.NumericalMathFunction`
            Metamodel.
        """
        return _metamodel.MetaModelResult_setMetaModel(self, *args)

    def getMetaModel(self):
        """
        Accessor to the metamodel.

        Returns
        -------
        metaModel : :class:`~openturns.NumericalMathFunction`
            Metamodel.
        """
        return _metamodel.MetaModelResult_getMetaModel(self)

    def setResiduals(self, *args):
        """
        Accessor to the residuals.

        Parameters
        ----------
        residuals : float sequence
            The residual values defined as follows for each output of the model:
            :math:`\\displaystyle \\frac{\\sqrt{\\sum_{i=1}^N (y_i - \\hat{y_i})^2}}{N}`
            with :math:`y_i` the :math:`N` model's values and :math:`\\hat{y_i}` the
            metamodel's values.
        """
        return _metamodel.MetaModelResult_setResiduals(self, *args)

    def getResiduals(self):
        """
        Accessor to the residuals.

        Returns
        -------
        residuals : float sequence
            The residual values defined as follows for each output of the model:
            :math:`\\displaystyle \\frac{\\sqrt{\\sum_{i=1}^N (y_i - \\hat{y_i})^2}}{N}`
            with :math:`y_i` the :math:`N` model's values and :math:`\\hat{y_i}` the
            metamodel's values.
        """
        return _metamodel.MetaModelResult_getResiduals(self)

    def setRelativeErrors(self, *args):
        """
        Accessor to the relative errors.

        Parameters
        ----------
        relativeErrors : float sequence
            The relative errors defined as follows for each output of the model:
            :math:`\\displaystyle \\frac{\\sum_{i=1}^N (y_i - \\hat{y_i})^2}{N \\Var{\\vect{Y}}}`
            with :math:`\\vect{Y}` the vector of the :math:`N` model's values
            :math:`y_i` and :math:`\\hat{y_i}` the metamodel's values.
        """
        return _metamodel.MetaModelResult_setRelativeErrors(self, *args)

    def getRelativeErrors(self):
        """
        Accessor to the relative errors.

        Returns
        -------
        relativeErrors : float sequence
            The relative errors  defined as follows for each output of the model:
            :math:`\\displaystyle \\frac{\\sum_{i=1}^N (y_i - \\hat{y_i})^2}{N \\Var{\\vect{Y}}}`
            with :math:`\\vect{Y}` the vector of the :math:`N` model's values
            :math:`y_i` and :math:`\\hat{y_i}` the metamodel's values.
        """
        return _metamodel.MetaModelResult_getRelativeErrors(self)

    def __repr__(self): return _metamodel.MetaModelResult___repr__(self)
    def __init__(self, *args): 
        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)

class KrigingResult(MetaModelResult):
    """
    Kriging result.

    Notes
    -----
    Structure created by the method run() of a :class:`~openturns.KrigingAlgorithm`,
    and obtained thanks to the method getResult().

    Examples
    --------
    >>> import openturns as ot
    >>> f = ot.NumericalMathFunction(['x0'], ['y'], ['x0 * sin(x0)'])
    >>> sampleX = [[1.0], [2.0], [3.0], [4.0], [5.0], [6.0]]
    >>> sampleY = f(sampleX)
    >>> basis = ot.Basis([ot.NumericalMathFunction('x', 'x'), ot.NumericalMathFunction('x', 'x^2')])
    >>> covarianceModel = ot.GeneralizedExponential(1, 2.0, 2.0)
    >>> algoKriging = ot.KrigingAlgorithm(sampleX, sampleY, basis, covarianceModel)
    >>> algoKriging.run()
    >>> resKriging = algoKriging.getResult()
    >>> metaModel = resKriging.getMetaModel()
    >>> graph = metaModel.draw(0.0, 7.0)
    >>> cloud = ot.Cloud(sampleX, sampleY)
    >>> cloud.setPointStyle('fcircle')
    >>> graph.add(cloud)
    >>> graph.add(f.draw(0.0, 7.0))
    >>> graph.setColors(['black', 'blue', 'red'])

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

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

    def __repr__(self): return _metamodel.KrigingResult___repr__(self)
    def __str__(self, offset=""): return _metamodel.KrigingResult___str__(self, offset)
    def getBasis(self):
        """
        Accessor to the basis of the generalized linear model.

        Returns
        -------
        basis : :class:`~openturns.Basis`
            Basis of the generalized linear model.

        """
        return _metamodel.KrigingResult_getBasis(self)

    def getTrendCoefficients(self):
        """
        Accessor to the coefficients of the generalized linear model of the trend.

        Parameters
        ----------
        trendCoef :  :class:`~openturns.NumericalSample` which size is the ouput dimension of :math:`f` and which dimension is :math:`p`.

        Notes
        -----
        Each point of the sample refers to the vector:

        .. math::
            \\left(\\beta_1, \\ldots, \\beta_p\\right)

        """
        return _metamodel.KrigingResult_getTrendCoefficients(self)

    def getCovarianceModels(self):
        """
        Accessor to the collection of covariance models.

        Returns
        -------
        covModelColl : list of :class:`~openturns.CovarianceModel` which size is the ouput dimension of :math:`f`.

        Notes
        -----
        Each covariance model refers to the function :math:`c_{\\vect{\\theta}}(\\vect{x}, \\vect{y})`.

        """
        return _metamodel.KrigingResult_getCovarianceModels(self)

    def getCovarianceCoefficients(self):
        """
        Accessor to the covariance coefficients.

        Returns
        -------
        covCoeff :   :class:`~openturns.NumericalSample` which size is the ouput dimension of :math:`f` and which dimension is :math:`p`.

        Notes
        -----
        Each point of the sample refers to the vector:

        .. math::
            \\Tr{\\vect{c}_{\\vect{\\theta}}(\\vect{x})}\\mat{C}^{-1}(\\vect{y}-\\mat{F}\\, \\tilde{\\vect{\\beta}})

        """
        return _metamodel.KrigingResult_getCovarianceCoefficients(self)

    def __init__(self, *args): 
        this = _metamodel.new_KrigingResult(*args)
        try: self.this.append(this)
        except: self.this = this
    __swig_destroy__ = _metamodel.delete_KrigingResult
    __del__ = lambda self : None;
KrigingResult_swigregister = _metamodel.KrigingResult_swigregister
KrigingResult_swigregister(KrigingResult)

class MetaModelAlgorithm(openturns.common.PersistentObject):
    """
    Base class to compute a metamodel.

    Available constructor:
        MetaModelAlgorithm(*distribution, model*)

    Parameters
    ----------
    distribution : :class:`~openturns.Distribution`
        Joint probability density function of the physical input vector.
    model : :class:`~openturns.NumericalMathFunction`
        Physical model to be approximated by a metamodel.

    Notes
    -----
    A MetaModelAlgorithm object can be used only through its derived classes:

    - :class:`~openturns.KrigingAlgorithm`

    - :class:`~openturns.FunctionalChaosAlgorithm`
    """
    __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(self):
        """
        Accessor to the object's name.

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

    def __repr__(self): return _metamodel.MetaModelAlgorithm___repr__(self)
    def setDistribution(self, *args):
        """
        Accessor to the joint probability density function of the physical input vector.

        Parameters
        ----------
        distribution : :class:`~openturns.Distribution`
            Joint probability density function of the physical input vector.
        """
        return _metamodel.MetaModelAlgorithm_setDistribution(self, *args)

    def getDistribution(self):
        """
        Accessor to the joint probability density function of the physical input vector.

        Returns
        -------
        distribution : :class:`~openturns.Distribution`
            Joint probability density function of the physical input vector.
        """
        return _metamodel.MetaModelAlgorithm_getDistribution(self)

    def run(self):
        """
        Compute the response surfaces.

        Notes
        -----
        It computes the response surfaces and creates a
        :class:`~openturns.MetaModelResult` structure containing all the results.
        """
        return _metamodel.MetaModelAlgorithm_run(self)

    def getInputSample(self):
        """
        Accessor to the input sample.

        Returns
        -------
        inputSample : 2D float sequence
            Input sample of a model evaluated apart.
        """
        return _metamodel.MetaModelAlgorithm_getInputSample(self)

    def getOutputSample(self):
        """
        Accessor to the output sample.

        Returns
        -------
        outputSample : 2D float sequence
            Output sample of a model evaluated apart.
        """
        return _metamodel.MetaModelAlgorithm_getOutputSample(self)

    def __init__(self, *args): 
        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)

class LinearTaylor(openturns.common.PersistentObject):
    __swig_setmethods__ = {}
    for _s in [openturns.common.PersistentObject]: __swig_setmethods__.update(getattr(_s,'__swig_setmethods__',{}))
    __setattr__ = lambda self, name, value: _swig_setattr(self, 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(self):
        """
        Accessor to the object's name.

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

    def __repr__(self): return _metamodel.LinearTaylor___repr__(self)
    def run(self): return _metamodel.LinearTaylor_run(self)
    def getCenter(self): return _metamodel.LinearTaylor_getCenter(self)
    def getConstant(self): return _metamodel.LinearTaylor_getConstant(self)
    def getLinear(self): return _metamodel.LinearTaylor_getLinear(self)
    def getInputFunction(self): return _metamodel.LinearTaylor_getInputFunction(self)
    def getResponseSurface(self): return _metamodel.LinearTaylor_getResponseSurface(self)
    def __init__(self, *args): 
        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)

class QuadraticTaylor(openturns.common.PersistentObject):
    __swig_setmethods__ = {}
    for _s in [openturns.common.PersistentObject]: __swig_setmethods__.update(getattr(_s,'__swig_setmethods__',{}))
    __setattr__ = lambda self, name, value: _swig_setattr(self, 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(self):
        """
        Accessor to the object's name.

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

    def __repr__(self): return _metamodel.QuadraticTaylor___repr__(self)
    def run(self): return _metamodel.QuadraticTaylor_run(self)
    def getCenter(self): return _metamodel.QuadraticTaylor_getCenter(self)
    def getConstant(self): return _metamodel.QuadraticTaylor_getConstant(self)
    def getLinear(self): return _metamodel.QuadraticTaylor_getLinear(self)
    def getQuadratic(self): return _metamodel.QuadraticTaylor_getQuadratic(self)
    def getInputFunction(self): return _metamodel.QuadraticTaylor_getInputFunction(self)
    def getResponseSurface(self): return _metamodel.QuadraticTaylor_getResponseSurface(self)
    def __init__(self, *args): 
        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)

class LinearLeastSquares(openturns.common.PersistentObject):
    __swig_setmethods__ = {}
    for _s in [openturns.common.PersistentObject]: __swig_setmethods__.update(getattr(_s,'__swig_setmethods__',{}))
    __setattr__ = lambda self, name, value: _swig_setattr(self, 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(self):
        """
        Accessor to the object's name.

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

    def __repr__(self): return _metamodel.LinearLeastSquares___repr__(self)
    def run(self): return _metamodel.LinearLeastSquares_run(self)
    def getConstant(self): return _metamodel.LinearLeastSquares_getConstant(self)
    def getLinear(self): return _metamodel.LinearLeastSquares_getLinear(self)
    def getInputFunction(self): return _metamodel.LinearLeastSquares_getInputFunction(self)
    def getResponseSurface(self): return _metamodel.LinearLeastSquares_getResponseSurface(self)
    def getDataIn(self): return _metamodel.LinearLeastSquares_getDataIn(self)
    def setDataOut(self, *args): return _metamodel.LinearLeastSquares_setDataOut(self, *args)
    def getDataOut(self): return _metamodel.LinearLeastSquares_getDataOut(self)
    def __init__(self, *args): 
        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)

class QuadraticLeastSquares(openturns.common.PersistentObject):
    __swig_setmethods__ = {}
    for _s in [openturns.common.PersistentObject]: __swig_setmethods__.update(getattr(_s,'__swig_setmethods__',{}))
    __setattr__ = lambda self, name, value: _swig_setattr(self, 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(self):
        """
        Accessor to the object's name.

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

    def __repr__(self): return _metamodel.QuadraticLeastSquares___repr__(self)
    def run(self): return _metamodel.QuadraticLeastSquares_run(self)
    def getConstant(self): return _metamodel.QuadraticLeastSquares_getConstant(self)
    def getLinear(self): return _metamodel.QuadraticLeastSquares_getLinear(self)
    def getQuadratic(self): return _metamodel.QuadraticLeastSquares_getQuadratic(self)
    def getInputFunction(self): return _metamodel.QuadraticLeastSquares_getInputFunction(self)
    def getResponseSurface(self): return _metamodel.QuadraticLeastSquares_getResponseSurface(self)
    def getDataIn(self): return _metamodel.QuadraticLeastSquares_getDataIn(self)
    def setDataOut(self, *args): return _metamodel.QuadraticLeastSquares_setDataOut(self, *args)
    def getDataOut(self): return _metamodel.QuadraticLeastSquares_getDataOut(self)
    def __init__(self, *args): 
        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)

class AdaptiveStrategyImplementation(openturns.common.PersistentObject):
    __swig_setmethods__ = {}
    for _s in [openturns.common.PersistentObject]: __swig_setmethods__.update(getattr(_s,'__swig_setmethods__',{}))
    __setattr__ = lambda self, name, value: _swig_setattr(self, 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(self):
        """
        Accessor to the object's name.

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

    def setMaximumDimension(self, *args): return _metamodel.AdaptiveStrategyImplementation_setMaximumDimension(self, *args)
    def getMaximumDimension(self): return _metamodel.AdaptiveStrategyImplementation_getMaximumDimension(self)
    def computeInitialBasis(self): return _metamodel.AdaptiveStrategyImplementation_computeInitialBasis(self)
    def updateBasis(self, *args): return _metamodel.AdaptiveStrategyImplementation_updateBasis(self, *args)
    def __repr__(self): return _metamodel.AdaptiveStrategyImplementation___repr__(self)
    def getBasis(self): return _metamodel.AdaptiveStrategyImplementation_getBasis(self)
    def getPsi(self): return _metamodel.AdaptiveStrategyImplementation_getPsi(self)
    def __init__(self, *args): 
        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)

class FixedStrategy(AdaptiveStrategyImplementation):
    __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(self):
        """
        Accessor to the object's name.

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

    def computeInitialBasis(self): return _metamodel.FixedStrategy_computeInitialBasis(self)
    def updateBasis(self, *args): return _metamodel.FixedStrategy_updateBasis(self, *args)
    def __repr__(self): return _metamodel.FixedStrategy___repr__(self)
    def __init__(self, *args): 
        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)

class SequentialStrategy(AdaptiveStrategyImplementation):
    __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(self):
        """
        Accessor to the object's name.

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

    def computeInitialBasis(self): return _metamodel.SequentialStrategy_computeInitialBasis(self)
    def updateBasis(self, *args): return _metamodel.SequentialStrategy_updateBasis(self, *args)
    def __repr__(self): return _metamodel.SequentialStrategy___repr__(self)
    def __init__(self, *args): 
        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)

class CleaningStrategy(AdaptiveStrategyImplementation):
    __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(self):
        """
        Accessor to the object's name.

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

    def computeInitialBasis(self): return _metamodel.CleaningStrategy_computeInitialBasis(self)
    def updateBasis(self, *args): return _metamodel.CleaningStrategy_updateBasis(self, *args)
    def __repr__(self): return _metamodel.CleaningStrategy___repr__(self)
    def getCurrentVectorIndex(self): return _metamodel.CleaningStrategy_getCurrentVectorIndex(self)
    def getMaximumSize(self): return _metamodel.CleaningStrategy_getMaximumSize(self)
    def setMaximumSize(self, *args): return _metamodel.CleaningStrategy_setMaximumSize(self, *args)
    def getSignificanceFactor(self): return _metamodel.CleaningStrategy_getSignificanceFactor(self)
    def setSignificanceFactor(self, *args): return _metamodel.CleaningStrategy_setSignificanceFactor(self, *args)
    def getVerbose(self): return _metamodel.CleaningStrategy_getVerbose(self)
    def setVerbose(self, *args): return _metamodel.CleaningStrategy_setVerbose(self, *args)
    def __init__(self, *args): 
        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)

class AdaptiveStrategyImplementationTypedInterfaceObject(openturns.common.InterfaceObject):
    __swig_setmethods__ = {}
    for _s in [openturns.common.InterfaceObject]: __swig_setmethods__.update(getattr(_s,'__swig_setmethods__',{}))
    __setattr__ = lambda self, name, value: _swig_setattr(self, 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): 
        this = _metamodel.new_AdaptiveStrategyImplementationTypedInterfaceObject(*args)
        try: self.this.append(this)
        except: self.this = this
    def getImplementation(self, *args):
        """
        Accessor to the underlying implementation.

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

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

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

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

        Returns
        -------
        name : string
            The name of the object.
        """
        return _metamodel.AdaptiveStrategyImplementationTypedInterfaceObject_getName(self)

    def __eq__(self, *args): 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):
    __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(self):
        """
        Accessor to the object's name.

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

    def setMaximumDimension(self, *args): return _metamodel.AdaptiveStrategy_setMaximumDimension(self, *args)
    def getMaximumDimension(self): return _metamodel.AdaptiveStrategy_getMaximumDimension(self)
    def computeInitialBasis(self): return _metamodel.AdaptiveStrategy_computeInitialBasis(self)
    def updateBasis(self, *args): return _metamodel.AdaptiveStrategy_updateBasis(self, *args)
    def getBasis(self): return _metamodel.AdaptiveStrategy_getBasis(self)
    def getPsi(self): return _metamodel.AdaptiveStrategy_getPsi(self)
    def __repr__(self): return _metamodel.AdaptiveStrategy___repr__(self)
    def __str__(self, offset=""): return _metamodel.AdaptiveStrategy___str__(self, offset)
    def __init__(self, *args): 
        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)

class ProjectionStrategyImplementation(openturns.common.PersistentObject):
    __swig_setmethods__ = {}
    for _s in [openturns.common.PersistentObject]: __swig_setmethods__.update(getattr(_s,'__swig_setmethods__',{}))
    __setattr__ = lambda self, name, value: _swig_setattr(self, 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(self):
        """
        Accessor to the object's name.

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

    def __repr__(self): return _metamodel.ProjectionStrategyImplementation___repr__(self)
    def setMeasure(self, *args): return _metamodel.ProjectionStrategyImplementation_setMeasure(self, *args)
    def getMeasure(self): return _metamodel.ProjectionStrategyImplementation_getMeasure(self)
    def getInputSample(self): return _metamodel.ProjectionStrategyImplementation_getInputSample(self)
    def getOutputSample(self): return _metamodel.ProjectionStrategyImplementation_getOutputSample(self)
    def getWeights(self): return _metamodel.ProjectionStrategyImplementation_getWeights(self)
    def getResidual(self): return _metamodel.ProjectionStrategyImplementation_getResidual(self)
    def getRelativeError(self): return _metamodel.ProjectionStrategyImplementation_getRelativeError(self)
    def getCoefficients(self): return _metamodel.ProjectionStrategyImplementation_getCoefficients(self)
    def setExperiment(self, *args): return _metamodel.ProjectionStrategyImplementation_setExperiment(self, *args)
    def getExperiment(self): return _metamodel.ProjectionStrategyImplementation_getExperiment(self)
    def computeCoefficients(self, *args): return _metamodel.ProjectionStrategyImplementation_computeCoefficients(self, *args)
    def __init__(self, *args): 
        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)

class LeastSquaresStrategy(ProjectionStrategyImplementation):
    __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(self):
        """
        Accessor to the object's name.

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

    def __repr__(self): return _metamodel.LeastSquaresStrategy___repr__(self)
    def computeCoefficients(self, *args): return _metamodel.LeastSquaresStrategy_computeCoefficients(self, *args)
    def __init__(self, *args): 
        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)

class IntegrationStrategy(ProjectionStrategyImplementation):
    __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(self):
        """
        Accessor to the object's name.

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

    def __repr__(self): return _metamodel.IntegrationStrategy___repr__(self)
    def computeCoefficients(self, *args): return _metamodel.IntegrationStrategy_computeCoefficients(self, *args)
    def __init__(self, *args): 
        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)

class ProjectionStrategyImplementationTypedInterfaceObject(openturns.common.InterfaceObject):
    __swig_setmethods__ = {}
    for _s in [openturns.common.InterfaceObject]: __swig_setmethods__.update(getattr(_s,'__swig_setmethods__',{}))
    __setattr__ = lambda self, name, value: _swig_setattr(self, 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): 
        this = _metamodel.new_ProjectionStrategyImplementationTypedInterfaceObject(*args)
        try: self.this.append(this)
        except: self.this = this
    def getImplementation(self, *args):
        """
        Accessor to the underlying implementation.

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

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

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

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

        Returns
        -------
        name : string
            The name of the object.
        """
        return _metamodel.ProjectionStrategyImplementationTypedInterfaceObject_getName(self)

    def __eq__(self, *args): 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):
    __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(self):
        """
        Accessor to the object's name.

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

    def setMeasure(self, *args): return _metamodel.ProjectionStrategy_setMeasure(self, *args)
    def getMeasure(self): return _metamodel.ProjectionStrategy_getMeasure(self)
    def getInputSample(self): return _metamodel.ProjectionStrategy_getInputSample(self)
    def getOutputSample(self): return _metamodel.ProjectionStrategy_getOutputSample(self)
    def getWeights(self): return _metamodel.ProjectionStrategy_getWeights(self)
    def getResidual(self): return _metamodel.ProjectionStrategy_getResidual(self)
    def getRelativeError(self): return _metamodel.ProjectionStrategy_getRelativeError(self)
    def getCoefficients(self): return _metamodel.ProjectionStrategy_getCoefficients(self)
    def setExperiment(self, *args): return _metamodel.ProjectionStrategy_setExperiment(self, *args)
    def getExperiment(self): return _metamodel.ProjectionStrategy_getExperiment(self)
    def computeCoefficients(self, *args): return _metamodel.ProjectionStrategy_computeCoefficients(self, *args)
    def __repr__(self): return _metamodel.ProjectionStrategy___repr__(self)
    def __str__(self, offset=""): return _metamodel.ProjectionStrategy___str__(self, offset)
    def __init__(self, *args): 
        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)

class FunctionalChaosResult(MetaModelResult):
    """
    Functional chaos result.

    Notes
    -----
    Structure created by the method run() of
    :class:`~openturns.FunctionalChaosAlgorithm`, and obtained thanks to the method
    getResult().
    """
    __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(self):
        """
        Accessor to the object's name.

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

    def __repr__(self): return _metamodel.FunctionalChaosResult___repr__(self)
    def __str__(self, offset=""): return _metamodel.FunctionalChaosResult___str__(self, offset)
    def getDistribution(self):
        """
        Get the joint distribution of the physical input vector.

        Returns
        -------
        distribution : :class:`~openturns.Distribution`
            Joint distribution of the physical input vector
            :math:`f_{\\vect{X}}(\\vect{x})`.
        """
        return _metamodel.FunctionalChaosResult_getDistribution(self)

    def getTransformation(self):
        """
        Get the isoprobabilistic transformation.

        Returns
        -------
        transformation : :class:`~openturns.NumericalMathFunction`
            The isoprobabilistic transformation :math:`T` that transforms
            the input data into a data following the measure imposed by the selected
            orthonormal basis:
            :math:`T : \\Rset^{n_X}\\longrightarrow \\Rset^{n_X}, T(\\vect{X})=\\vect{U}`.
        """
        return _metamodel.FunctionalChaosResult_getTransformation(self)

    def getInverseTransformation(self):
        """
        Get the inverse isoprobabilistic transformation.

        Returns
        -------
        transformation : :class:`~openturns.NumericalMathFunction`
            The inverse isoprobabilistic transformation :math:`T^{-1}` that transforms
            the data distributed according to the measure imposed by the selected
            orthonormal basis into the input data:
            :math:`T^{-1}: \\Rset^{n_X}\\longrightarrow \\Rset^{n_X}, T^{-1}(\\vect{U})=\\vect{X}`
        """
        return _metamodel.FunctionalChaosResult_getInverseTransformation(self)

    def getComposedModel(self):
        """
        Get the composed model.

        Returns
        -------
        composedModel : :class:`~openturns.NumericalMathFunction`
            :math:`h` which is the composition of the physical model :math:`g` and the
            inverse isoprobabilistic transformation such as:
            :math:`h : \\vect{U} \\longrightarrow \\vect{Y}=g \\circ T^{-1}(\\vect{U})`.
            We have :math:`h=\\sum_{k\\in \\Nset} \\vect{a}_k \\Psi_k`.
        """
        return _metamodel.FunctionalChaosResult_getComposedModel(self)

    def getOrthogonalBasis(self):
        """
        Get the orthogonal basis.

        Returns
        -------
        basis : :class:`~openturns.OrthogonalBasis`
            Orthogonal basis.
        """
        return _metamodel.FunctionalChaosResult_getOrthogonalBasis(self)

    def getIndices(self):
        """
        Get the indices of the final basis.

        Returns
        -------
        indices : int sequence
            Collection of integers that represent the indices of the final basis.
        """
        return _metamodel.FunctionalChaosResult_getIndices(self)

    def getCoefficients(self):
        """
        Get the coefficients.

        Returns
        -------
        coefficients : 2D float sequence
            Collection of coefficients of the functional chaos
            :math:`(\\vect{a}_k)_{k \\in K}` with :math:`K` is a finite subset of
            :math:`\\Nset`.
        """
        return _metamodel.FunctionalChaosResult_getCoefficients(self)

    def getReducedBasis(self):
        """
        Get the reduced basis.

        Returns
        -------
        basis : list of :class:`~openturns.NumericalMathFunction`
            List of functions that correspond to the basis of the functional chaos
            :math:`(\\Psi_k)_{k\\in K}` with :math:`K` is a finite subset of
            :math:`\\Nset`.
        """
        return _metamodel.FunctionalChaosResult_getReducedBasis(self)

    def getComposedMetaModel(self):
        """
        Get the composed metamodel.

        Returns
        -------
        composedMetamodel : :class:`~openturns.NumericalMathFunction`
            :math:`\\hat{h}=\\sum_{k\\in K} \\vect{a}_k \\Psi_k` with :math:`K` is a
            finite subset of :math:`\\Nset`.
        """
        return _metamodel.FunctionalChaosResult_getComposedMetaModel(self)

    def __init__(self, *args): 
        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)

class FunctionalChaosAlgorithm(MetaModelAlgorithm):
    """
    Functional chaos algorithm.

    Available constructors:
        FunctionalChaosAlgorithm(*inputSample, outputSample*)

        FunctionalChaosAlgorithm(*inputSample, outputSample, distribution, adaptiveStrategy*)

        FunctionalChaosAlgorithm(*inputSample, outputSample, distribution, adaptiveStrategy, projectionStrategy*)

        FunctionalChaosAlgorithm(*model, distribution, adaptiveStrategy*)

        FunctionalChaosAlgorithm(*model, distribution, adaptiveStrategy, projectionStrategy*)

        FunctionalChaosAlgorithm(*inputSample, weights, outputSample, distribution, adaptiveStrategy*)

        FunctionalChaosAlgorithm(*inputSample, weights, outputSample, distribution, adaptiveStrategy, projectionStrategy*)

    Parameters
    ----------
    inputSample, outputSample : 2D float sequences
        The input random variables :math:`\\vect{X}=(X_1, \\dots, X_{n_X})^T`
        and the output samples :math:`\\vect{Y}` of a model evaluated apart.
    model : :class:`~openturns.NumericalMathFunction`
        Physical model :math:`g` such as :math:`\\vect{Y} = g(\\vect{X})` that
        behaves as a :class:`~openturns.NumericalMathFunction`. When
        :math:`\\vect{Y}` is of dimension :math:`n_Y>1`, OpenTURNS operates marginal
        by marginal, using the same multivariate orthonormal basis
        :math:`(\\Psi_k(\\vect{x}))_{k \\in \\Nset^{n_X}}` for all the marginals.
    distribution : :class:`~openturns.Distribution`
        Joint probability density function :math:`f_{\\vect{X}}(\\vect{x})`
        of the physical input vector :math:`\\vect{X}`.
    adaptiveStrategy : :class:`~openturns.AdaptiveStrategy`
        Strategy of selection of the different terms of the multivariate basis.
    projectionStrategy : :class:`~openturns.ProjectionStrategy`
        Defines the strategy of projection of the empirical model results in the
        selected orthonormal basis. If it is not mentioned, the projection
        strategy considered is the :class:`~openturns.LeastSquaresStrategy`.
    weights : float sequence
        Weights of each point of the *inputSample*. The weights :math:`\\omega_i`
        are determined such that
        :math:`\\sum_{i\\in I}\\omega_i \\delta_{\\vect{X}_i} \\simeq p_{\\vect{X}}`,
        where :math:`p_{\\vect{X}}` is the distribution of the input random vector
        :math:`\\vect{X}`. When not specified, the *weights* are all equal to:
        :math:`\\omega_i = \\frac{1}{cardI}`

    Notes
    -----
    Consider a physical model :math:`g` depending
    on a set random variables :math:`\\vect{X}=(X_1, \\dots, X_{n_X})^T`.
    We call functional chaos expansion the class of spectral methods which gathers
    all types of response surface that can be seen as a projection of the physical
    model in an orthonormal basis. This class of methods uses the Hilbertian space
    (square-integrable space: :math:`L^2`) to construct the response surface.

    The functional chaos representation implemented in OpenTURNS is the
    polynomial chaos (PC) expansion. It allows one to cast the response as a
    converging series featuring orthonormal polynomials.

    Consider that the output random variable of interest
    :math:`\\vect{Y} = g(\\vect{X})` has a finite variance, i.e.
    :math:`\\Var{g(\\vect{X})} < \\infty`

    Then it is shown that :math:`\\vect{Y}` may be expanded onto the PC basis as
    follows:

    .. math::

        g(\\vect{X}) = \\sum_{j=0}^{\\infty} \\vect{a}_j \\Psi_j(\\vect{X})\\circ T(\\vect{X})

    where the :math:`\\vect{a}_j=(a_{j,1}, \\dots, a_{j,n_Y})`'s are
    deterministic vectors of coefficients that fully characterize the response
    :math:`\\vect{Y}`. :math:`\\Psi_j`'s are multivariate polynomials that are
    orthonormal with respect to the joint probability density function (PDF)
    :math:`f_{\\vect{X}}(\\vect{x})` of :math:`\\vect{X}`. :math:`T` is the
    isoprobabilistic transformation which enables to rescale
    the components :math:`X_i` of random vector :math:`\\vect{X}` such as:

    .. math::

        Y \\equiv h(\\vect{U}) &= g \\circ T^{-1}(\\vect{U}) \\\\
                             &= \\sum_{j=0}^{\\infty} \\vect{a}_j \\Psi_j(\\vect{U})

    with :math:`\\vect{U} = T(\\vect{X})`

    Consider the case of independent input random variables. The PDF may be cast as:

    .. math::

        f_{\\vect{X}}(\\vect{x}) = \\prod_{i=1}^{n_X} f_{X_i}(x_i)

    where :math:`f_{X_i}(x_i)` is the marginal PDF of :math:`X_i`.
    Let us consider a family :math:`\\{\\pi_j^{(i)}, j \\in \\Nset\\}` of orthonormal
    univariate polynomials with respect to :math:`f_{X_i}`, i.e.:

    .. math::

        \\left<\\pi_j^{(i)}(U_i), \\pi_k^{(i)}(U_i)\\right>
            &\\equiv \\Expect{\\pi_j^{(i)}(U_i), \\pi_k^{(i)}(U_i)} \\\\
            &= \\delta_{j,k}

    where :math:`\\delta_{j,k}=1` if :math:`j=k` and :math:`0` otherwise.
    For more details on the selection of suitable families of orthogonal
    polynomials see :class:`~openturns.StandardDistributionPolynomialFactory`.
    Upon tensoring the :math:`n_X` resulting families of univariate polynomials,
    one gets a set of orthonormal multivariate polynomials
    :math:`\\{\\Psi_{\\vect{\\alpha}}, \\vect{\\alpha} \\in \\Nset^{n_X}\\}` defined by:

    .. math::

        \\Psi_{\\vect{\\alpha}}(\\vect{u}) \\equiv \\pi_{\\alpha_1}^{(1)}(u_1)
                          \\times \\dots \\times \\pi_{\\alpha_{n_X}}^{({n_X})}(u_{n_X})

    where the multi-index notation
    :math:`\\vect{\\alpha} \\equiv \\{\\alpha_1, \\dots, \\alpha_{n_X}\\}` has been
    introduced.


    For computational purpose, it is necessary to retain a finite number of
    terms by truncating the expansion. The metamodel :math:`\\hat{g}(\\vect{X})` is
    then represented by a *finite* subset of coefficients
    :math:`\\{\\vect{a}_k, k \\in K\\}` in a *truncated* basis
    :math:`\\{\\Psi_k, k \\in K\\}` as follows:

    .. math::

        \\hat{g}(\\vect{X}) = \\sum_{k \\in K} \\vect{a}_k \\Psi_k \\circ T(\\vect{X})

    with :math:`K` a finite subset of :math:`\\Nset`.

    So, a specific strategy for enumerating the infinite PC series has to be
    defined (see :class:`~openturns.EnumerateFunction`). Then, it is possible to
    use several strategies in order to truncate the representation (see
    :class:`~openturns.AdaptiveStrategy`). Finally, to characterize
    :math:`\\vect{Y}`, the PC coefficients are estimated thanks to a
    :class:`projection strategy <openturns.ProjectionStrategy>`.

    See also
    --------
    FunctionalChaosResult

    Examples
    --------
    >>> import openturns as ot
    >>> ot.RandomGenerator.SetSeed(0)
    >>> # Define the model
    >>> inputDim = 1
    >>> model = ot.NumericalMathFunction(['x'], ['y'], ['x*sin(x)'])
    >>> # Create the input distribution
    >>> distribution = ot.ComposedDistribution([ot.Uniform()]*inputDim)
    >>> # Construction of the multivariate orthonormal basis
    >>> polyColl = [0.]*inputDim
    >>> for i in range(distribution.getDimension()):
    ...     polyColl[i] = ot.StandardDistributionPolynomialFactory(distribution.getMarginal(i))
    >>> enumerateFunction = ot.LinearEnumerateFunction(inputDim)
    >>> productBasis = ot.OrthogonalProductPolynomialFactory(polyColl, enumerateFunction)
    >>> # Truncature strategy of the multivariate orthonormal basis
    >>> # We choose all the polynomials of degree <= 4
    >>> degree = 4
    >>> indexMax = enumerateFunction.getStrataCumulatedCardinal(degree)
    >>> print(indexMax)
    5
    >>> # We keep all the polynomials of degree <= 4
    >>> # which corresponds to the 5 first ones
    >>> adaptiveStrategy = ot.FixedStrategy(productBasis, indexMax)
    >>> # Evaluation strategy of the approximation coefficients
    >>> samplingSize = 50
    >>> experiment = ot.MonteCarloExperiment(samplingSize)
    >>> projectionStrategy = ot.LeastSquaresStrategy(experiment)
    >>> # Creation of the Functional Chaos Algorithm
    >>> algo = ot.FunctionalChaosAlgorithm(model, distribution, adaptiveStrategy,
    ...                                    projectionStrategy)
    >>> algo.run()
    >>> # Get the result
    >>> functionalChaosResult = algo.getResult()
    >>> metamodel = functionalChaosResult.getMetaModel()
    >>> # Tests
    >>> X = [0.5]
    >>> print(model(X))
    [0.239713]
    >>> print(metamodel(X))
    [0.239514]
    """
    __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(self):
        """
        Accessor to the object's name.

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

    def __repr__(self): return _metamodel.FunctionalChaosAlgorithm___repr__(self)
    def setMaximumResidual(self, *args):
        """
        Set the maximum residual.

        Parameters
        ----------
        residual : float
            Residual value needed in the projection strategy. By default, its value
            is :math:`0`.
        """
        return _metamodel.FunctionalChaosAlgorithm_setMaximumResidual(self, *args)

    def getMaximumResidual(self):
        """
        Get the maximum residual.

        Returns
        -------
        residual : float
            Residual value needed in the projection strategy. By default, its value
            is :math:`0`.
        """
        return _metamodel.FunctionalChaosAlgorithm_getMaximumResidual(self)

    def setProjectionStrategy(self, *args):
        """
        Set the projection strategy.

        Parameters
        ----------
        strategy : :class:`~openturns.ProjectionStrategy`
            Projection strategy of the :class:`~openturns.FunctionalChaosAlgorithm`.
        """
        return _metamodel.FunctionalChaosAlgorithm_setProjectionStrategy(self, *args)

    def getProjectionStrategy(self):
        """
        Get the projection strategy.

        Returns
        -------
        strategy : :class:`~openturns.ProjectionStrategy`
            Projection strategy of the :class:`~openturns.FunctionalChaosAlgorithm`.
        """
        return _metamodel.FunctionalChaosAlgorithm_getProjectionStrategy(self)

    def run(self):
        """
        Compute the response surfaces.

        Notes
        -----
        Execute the procedure of determination of coefficients using the projection
        strategy selected with respect to the AdaptiveStrategy selected. It provides
        the results as an object of type :class:`~openturns.FunctionalChaosResult`,
        recoverable thanks to the method :py:meth:`getResult`.
        """
        return _metamodel.FunctionalChaosAlgorithm_run(self)

    def getResult(self):
        """
        Get the results of the metamodel computation.

        Returns
        -------
        result : :class:`~openturns.FunctionalChaosResult`
            Structure containing all the results obtained after metamodel computation
            and created by the method :py:meth:`run`.
        """
        return _metamodel.FunctionalChaosAlgorithm_getResult(self)

    def getInputSample(self):
        """
        Accessor to the input sample.

        Returns
        -------
        inputSample : 2D float sequence
            Input sample of a model evaluated apart.
        """
        return _metamodel.FunctionalChaosAlgorithm_getInputSample(self)

    def getOutputSample(self):
        """
        Accessor to the output sample.

        Returns
        -------
        outputSample : 2D float sequence
            Output sample of a model evaluated apart.
        """
        return _metamodel.FunctionalChaosAlgorithm_getOutputSample(self)

    def __init__(self, *args): 
        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)

class KrigingAlgorithm(MetaModelAlgorithm):
    """
    Kriging algorithm.

    Available constructors:
        KrigingAlgorithm(*inputSample, outputSample, basis, covarianceModel, normalize=True*)

        KrigingAlgorithm(*inputSample, inputDistribution, outputSample, basis, covarianceModel*)

    Parameters
    ----------
    inputSample, outputSample : 2D float sequences
        The input and output samples of a model evaluated apart.
    inputDistribution : :class:`~openturns.Distribution`
        Joint probability density function of the physical input vector.
        If *inputDistribution* is not specified, the *inputSample* is assumed
        to be normally-distributed.
    basis : :class:`~openturns.Basis`
        Basis of the output of the regression.
    covarianceModel : :class:`~openturns.CovarianceModel`
        Correlation function.
    normalize : bool, optional
        If *True*, *inputSample* is normalized.

    Notes
    -----
    Kriging (also known as Gaussian process regression) is a Bayesian technique
    that aim at approximating functions (most often in order to surrogate it
    because it is expensive to evaluate). In the following it is assumed we aim at
    surrogating a scalar-valued model :math:`\\cM: \\vect{x} \\mapsto y`. Note the
    OpenTURNS implementation of Kriging can deal with vector-valued functions
    (:math:`\\cM: \\vect{x} \\mapsto \\vect{y}`), but it simply loops over each output.
    It is also assumed the model was runned over a design of experiments in order
    to produce a set of observations gathered in the following dataset:
    :math:`\\left(\\left(\\vect{x}^{(i)}, y^{(i)}\\right), i = 1, \\ldots, m\\right)`.
    Ultimately Kriging aims at producing a predictor (also known as a response
    surface or metamodel) denoted as :math:`\\tilde{\\cM}`.

    We put the following Gaussian process prior on the model :math:`\\cM`:

    .. math::

        Y(\\vect{x}) = \\Tr{\\vect{f}(\\vect{x})} \\vect{\\beta} + Z(\\vect{x})

    where :math:`\\Tr{\\vect{f}(\\vect{x})} \\vect{\\beta}` is a generalized linear
    model based upon a functional basis
    :math:`\\vect{f} = \\left(f_j, j = 1, \\ldots, p\\right)` and a vector of
    coefficients :math:`\\vect{\\beta} = \\left(\\beta_j, j = 1, \\ldots, p\\right)`.
    :math:`Z(\\vect{x})` is a zero-mean gaussian process with a stationary
    autocorrelation function depending on the distance between samples:

    .. math::

        \\mathbb{E}[Z(\\vect{x}), Z(\\vect{x'})] = \\sigma^2 R(\\vect{x} - \\vect{x'}, \\vect{\\theta})

    where :math:`\\sigma^2 > 0` is the variance and :math:`R` is the correlation
    function that solely depends on the Manhattan distance between input points
    :math:`\\vect{x} - \\vect{x'}` and a vector of parameters
    :math:`\\vect{\\theta} \\in \\Rset^{n_\\theta}`.

    Examples
    --------
    >>> import openturns as ot
    >>> f = ot.NumericalMathFunction(['x0'], ['f0'], ['x0 * sin(x0)'])
    >>> inputSample = ot.NumericalSample([[1.], [3.], [5.], [6.,], [7.], [8.]])
    >>> outputSample = f(inputSample)
    >>> # Create the algorithm
    >>> basis = ot.ConstantBasisFactory().build()
    >>> covarianceModel = ot.SquaredExponential(1)
    >>> algo = ot.KrigingAlgorithm(inputSample, outputSample, basis, covarianceModel)
    >>> algo.run()
    >>> # Get the results
    >>> result = algo.getResult()
    >>> metamodel = result.getMetaModel()
    """
    __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(self):
        """
        Accessor to the object's name.

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

    def __repr__(self): return _metamodel.KrigingAlgorithm___repr__(self)
    def setOptimizer(self, *args):
        """
        Set the solver used to optimize the covariance model parameters.

        Parameters
        ----------
        algorithm : :class:`~openturns.BoundConstrainedAlgorithm`
            Solver used to optimize the covariance model parameters.
        """
        return _metamodel.KrigingAlgorithm_setOptimizer(self, *args)

    def getOptimizer(self):
        """
        Get the solver used to optimize the covariance model parameters.

        Returns
        -------
        algorithm : :class:`~openturns.BoundConstrainedAlgorithm`
            Solver used to optimize the covariance model parameters.
        """
        return _metamodel.KrigingAlgorithm_getOptimizer(self)

    def run(self):
        """
        Compute the response surfaces.

        Notes
        -----
        It computes the response surfaces and creates a
        :class:`~openturns.MetaModelResult` structure containing all the results.
        """
        return _metamodel.KrigingAlgorithm_run(self)

    def setInputTransformation(self, *args):
        """
        Set the function normalizing the input.

        Parameters
        ----------
        transformation : :class:`~openturns.NumericalMathFunction`
            Function normalizing the input.
        """
        return _metamodel.KrigingAlgorithm_setInputTransformation(self, *args)

    def getInputTransformation(self):
        """
        Get the function normalizing the input.

        Returns
        -------
        transformation : :class:`~openturns.NumericalMathFunction`
            Function normalizing the input.
        """
        return _metamodel.KrigingAlgorithm_getInputTransformation(self)

    def getInputSample(self):
        """
        Accessor to the input sample.

        Returns
        -------
        inputSample : 2D float sequence
            Input sample of a model evaluated apart.
        """
        return _metamodel.KrigingAlgorithm_getInputSample(self)

    def getOutputSample(self):
        """
        Accessor to the output sample.

        Returns
        -------
        outputSample : 2D float sequence
            Output sample of a model evaluated apart.
        """
        return _metamodel.KrigingAlgorithm_getOutputSample(self)

    def getResult(self):
        """
        Get the results of the metamodel computation.

        Returns
        -------
        result : :class:`~openturns.MetaModelResult`
            Structure containing all the results obtained after metamodel computation
            and created by the method :py:meth:`run`.
        """
        return _metamodel.KrigingAlgorithm_getResult(self)

    def getLogLikelihoodFunction(self, *args): return _metamodel.KrigingAlgorithm_getLogLikelihoodFunction(self, *args)
    def __init__(self, *args): 
        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)

class PythonRandomVector(object):
    """
    Allow to override RandomVector from Python.

    Parameters
    ----------
    dim : positive int
        the vector dimension
        Default is 0.
    """
    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):
    """
    Build a PythonRandomVector from a scipy distribution.

    Parameters
    ----------
    dist : a scipy.stats distribution
        the distribution to wrap
    """
    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):
    __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): 
        this = _metamodel.new_RandomVectorImplementationTypedInterfaceObject(*args)
        try: self.this.append(this)
        except: self.this = this
    def getImplementation(self, *args):
        """
        Accessor to the underlying implementation.

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

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

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

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

        Returns
        -------
        name : string
            The name of the object.
        """
        return _metamodel.RandomVectorImplementationTypedInterfaceObject_getName(self)

    def __eq__(self, *args): 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):
    """
    Random vectors.

    Available constructors:
        RandomVector(*points*)

        RandomVector(*distribution*)

        RandomVector(*distribution, randomParameters*)

        RandomVector(*function, antecedent*)

        RandomVector(*functionalChaosResult*)

    Parameters
    ----------
    points : float sequence
        Sequence of values defining a :class:`~openturns.ConstantRandomVector`.
    distribution : :class:`~openturns.Distribution`
        Distribution of the :class:`~openturns.UsualRandomVector` to define.
    randomParameters : :class:`~openturns.RandomVector`
        RandomVector to define a distribution-based conditional vector.
        It defines random parameters for *distribution*.
    antecedent : :class:`~openturns.RandomVector`
        RandomVector :math:`\\underline{X}` of Usual type to define a
        :class:`~openturns.CompositeRandomVector` as the image through the function
        :math:`f` of :math:`\\underline{X}`: :math:`\\underline{Y}=f(\\underline{X})`.
    function : :class:`~openturns.NumericalMathFunction`
        Function :math:`f` to define a :class:`~openturns.CompositeRandomVector` as
        the image through this function of the antecedent :math:`\\underline{X}`:
        :math:`\\underline{Y}=f(\\underline{X})`.
    functionalChaosResult : :class:`~openturns.FunctionalChaosResult`
        Result to define a :class:`~openturns.FunctionalChaosRandomVector` as the
        image through a functional chaos approximation model of the associated
        :class:`~openturns.UsualRandomVector`.


    See also
    --------
    UsualRandomVector, CompositeRandomVector, ConditionalRandomVector,
    ConstantRandomVector, PosteriorRandomVector, FunctionalChaosRandomVector, Event
    """
    __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(self):
        """
        Accessor to the object's name.

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

    def __repr__(self): return _metamodel.RandomVector___repr__(self)
    def __str__(self, offset=""): return _metamodel.RandomVector___str__(self, offset)
    def setDescription(self, *args):
        """
        Accessor to the description of the RandomVector.

        Parameters
        ----------
        description : string or list of strings
            Describes the components of the RandomVector.
        """
        return _metamodel.RandomVector_setDescription(self, *args)

    def getDescription(self):
        """
        Accessor to the description of the RandomVector.

        Returns
        -------
        description : string or list of strings
            Describes the components of the RandomVector.
        """
        return _metamodel.RandomVector_getDescription(self)

    def isComposite(self):
        """
        Accessor to know if the RandomVector is a composite one.

        Returns
        -------
        isComposite : Bool
            Indicates if the RandomVector is of type Composite or not.
        """
        return _metamodel.RandomVector_isComposite(self)

    def getDimension(self):
        """
        Accessor to the dimension of the RandomVector.

        Returns
        -------
        dimension : positive int
            Dimension of the RandomVector.
        """
        return _metamodel.RandomVector_getDimension(self)

    def getRealization(self):
        """
        Compute one realization of the RandomVector.

        Returns
        -------
        aRealization : float sequence
            Sequence of values randomly determined from the RandomVector definition.
            In the case of an event: one realization of the event (considered as a
            Bernoulli variable) which is a boolean value (1 for the realization of the
            event and 0 else).

        See also
        --------
        getSample

        Examples
        --------
        >>> import openturns as ot
        >>> distribution = ot.Normal([0., 0.], [1., 1.], ot.CorrelationMatrix(2))
        >>> randomVector = ot.RandomVector(distribution)
        >>> ot.RandomGenerator.SetSeed(0)
        >>> print(randomVector.getRealization())
        [0.608202,-1.26617]
        >>> print(randomVector.getRealization())
        [-0.438266,1.20548]
        """
        return _metamodel.RandomVector_getRealization(self)

    def getSample(self, *args):
        """
        Compute realizations of the RandomVector.

        Parameters
        ----------
        n : int, :math:`n \\geq 0`
            Number of realizations needed.

        Returns
        -------
        realizations : 2D float sequence
            n sequences of values randomly determined from the RandomVector definition.
            In the case of an event: n realizations of the event (considered as a
            Bernoulli variable) which are boolean values (1 for the realization of the
            event and 0 else).

        See also
        --------
        getRealization

        Examples
        --------
        >>> import openturns as ot
        >>> distribution = ot.Normal([0., 0.], [1., 1.], ot.CorrelationMatrix(2))
        >>> randomVector = ot.RandomVector(distribution)
        >>> ot.RandomGenerator.SetSeed(0)
        >>> print(randomVector.getSample(3))
            [ marginal 1 marginal 2 ]
        0 : [  0.608202  -1.26617   ]
        1 : [ -0.438266   1.20548   ]
        2 : [ -2.18139    0.350042  ]
        """
        return _metamodel.RandomVector_getSample(self, *args)

    def getMarginal(self, *args):
        """
        Accessor to the random vector corresponding to the i^{th} marginal component(s).

        Parameters
        ----------
        i : int or list of ints, :math:`0\\leq i < dim`
            Indicates the component(s) concerned. :math:`dim` is the dimension of the
            RandomVector.

        Returns
        -------
        vector :  :class:`~openturns.RandomVector`
            RandomVector restricted to the concerned components.

        Notes
        -----
        Let's note :math:`\\underline{Y}=(Y_1,\\dots,Y_n)^t` a random vector and
        :math:`I \\in [1,n]` a set of indices. If :math:`\\underline{Y}` is a
        :class:`~openturns.UsualRandomVector`, the subvector is defined by
        :math:`\\tilde{\\underline{Y}}=(Y_i)_{i \\in I}^t`. If :math:`\\underline{Y}` is a
        :class:`~openturns.CompositeRandomVector`, defined by
        :math:`\\underline{Y}=f(\\underline{X})` with :math:`f=(f_1,\\dots,f_n)`,
        :math:`f_i` some scalar functions, the subvector is
        :math:`\\tilde{\\underline{Y}}=(f_i(\\underline{X}))_{i \\in I}`.

        Examples
        --------
        >>> import openturns as ot
        >>> distribution = ot.Normal([0., 0.], [1., 1.], ot.CorrelationMatrix(2))
        >>> randomVector = ot.RandomVector(distribution)
        >>> ot.RandomGenerator.SetSeed(0)
        >>> print(randomVector.getMarginal(1).getRealization())
        [0.608202]
        >>> print(randomVector.getMarginal(1).getDistribution())
        Normal(mu = 0, sigma = 1)
        """
        return _metamodel.RandomVector_getMarginal(self, *args)

    def getMean(self):
        """
        Accessor to the mean of the RandomVector.

        Returns
        -------
        mean : float sequence
            Mean of the considered :class:`~openturns.UsualRandomVector`.

        Examples
        --------
        >>> import openturns as ot
        >>> distribution = ot.Normal([0., 0.5], [1., 1.5], ot.CorrelationMatrix(2))
        >>> randomVector = ot.RandomVector(distribution)
        >>> ot.RandomGenerator.SetSeed(0)
        >>> print(randomVector.getMean())
        [0,0.5]
        """
        return _metamodel.RandomVector_getMean(self)

    def getCovariance(self):
        """
        Accessor to the covariance of the RandomVector.

        Returns
        -------
        covariance : :class:`~openturns.CovarianceMatrix`
            Covariance of the considered :class:`~openturns.UsualRandomVector`.

        Examples
        --------
        >>> import openturns as ot
        >>> distribution = ot.Normal([0., 0.5], [1., 1.5], ot.CorrelationMatrix(2))
        >>> randomVector = ot.RandomVector(distribution)
        >>> ot.RandomGenerator.SetSeed(0)
        >>> print(randomVector.getCovariance())
        [[ 1    0    ]
         [ 0    2.25 ]]
        """
        return _metamodel.RandomVector_getCovariance(self)

    def getAntecedent(self):
        """
        Accessor to the antecedent RandomVector in case of a composite RandomVector.

        Returns
        -------
        antecedent : :class:`~openturns.RandomVector`
            Antecedent RandomVector :math:`\\underline{X}` in case of a
            :class:`~openturns.CompositeRandomVector` such as:
            :math:`\\underline{Y}=f(\\underline{X})`.
        """
        return _metamodel.RandomVector_getAntecedent(self)

    def getFunction(self):
        """
        Accessor to the NumericalMathFunction in case of a composite RandomVector.

        Returns
        -------
        function : :class:`~openturns.NumericalMathFunction`
            Function used to define a :class:`~openturns.CompositeRandomVector` as the
            image through this function of the antecedent :math:`\\underline{X}`:
            :math:`\\underline{Y}=f(\\underline{X})`.
        """
        return _metamodel.RandomVector_getFunction(self)

    def getDistribution(self):
        """
        Accessor to the distribution of the RandomVector.

        Returns
        -------
        distribution : :class:`~openturns.Distribution`
            Distribution of the considered :class:`~openturns.UsualRandomVector`.

        Examples
        --------
        >>> import openturns as ot
        >>> distribution = ot.Normal([0., 0.], [1., 1.], ot.CorrelationMatrix(2))
        >>> randomVector = ot.RandomVector(distribution)
        >>> ot.RandomGenerator.SetSeed(0)
        >>> print(randomVector.getDistribution())
        Normal(mu = [0,0], sigma = [1,1], R = [[ 1 0 ]
         [ 0 1 ]])
        """
        return _metamodel.RandomVector_getDistribution(self)

    def getOperator(self):
        """
        Accessor to the comparaison operator of the Event.

        Returns
        -------
        operator : :class:`~openturns.ComparisonOperator`
            Comparaison operator used to define the :class:`~openturns.Event`.
        """
        return _metamodel.RandomVector_getOperator(self)

    def getThreshold(self):
        """
        Accessor to the threshold of the Event.

        Returns
        -------
        threshold : float
            Threshold of the :class:`~openturns.Event`.
        """
        return _metamodel.RandomVector_getThreshold(self)

    def __init__(self, *args): 
        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)

class CompositeRandomVector(openturns.randomvector.RandomVectorImplementation):
    __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(self):
        """
        Accessor to the object's name.

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

    def __repr__(self): return _metamodel.CompositeRandomVector___repr__(self)
    def isComposite(self):
        """
        Accessor to know if the RandomVector is a composite one.

        Returns
        -------
        isComposite : Bool
            Indicates if the RandomVector is of type Composite or not.
        """
        return _metamodel.CompositeRandomVector_isComposite(self)

    def getDimension(self):
        """
        Accessor to the dimension of the RandomVector.

        Returns
        -------
        dimension : positive int
            Dimension of the RandomVector.
        """
        return _metamodel.CompositeRandomVector_getDimension(self)

    def getRealization(self):
        """
        Compute one realization of the RandomVector.

        Returns
        -------
        aRealization : float sequence
            Sequence of values randomly determined from the RandomVector definition.
            In the case of an event: one realization of the event (considered as a
            Bernoulli variable) which is a boolean value (1 for the realization of the
            event and 0 else).

        See also
        --------
        getSample

        Examples
        --------
        >>> import openturns as ot
        >>> distribution = ot.Normal([0., 0.], [1., 1.], ot.CorrelationMatrix(2))
        >>> randomVector = ot.RandomVector(distribution)
        >>> ot.RandomGenerator.SetSeed(0)
        >>> print(randomVector.getRealization())
        [0.608202,-1.26617]
        >>> print(randomVector.getRealization())
        [-0.438266,1.20548]
        """
        return _metamodel.CompositeRandomVector_getRealization(self)

    def getSample(self, *args):
        """
        Compute realizations of the RandomVector.

        Parameters
        ----------
        n : int, :math:`n \\geq 0`
            Number of realizations needed.

        Returns
        -------
        realizations : 2D float sequence
            n sequences of values randomly determined from the RandomVector definition.
            In the case of an event: n realizations of the event (considered as a
            Bernoulli variable) which are boolean values (1 for the realization of the
            event and 0 else).

        See also
        --------
        getRealization

        Examples
        --------
        >>> import openturns as ot
        >>> distribution = ot.Normal([0., 0.], [1., 1.], ot.CorrelationMatrix(2))
        >>> randomVector = ot.RandomVector(distribution)
        >>> ot.RandomGenerator.SetSeed(0)
        >>> print(randomVector.getSample(3))
            [ marginal 1 marginal 2 ]
        0 : [  0.608202  -1.26617   ]
        1 : [ -0.438266   1.20548   ]
        2 : [ -2.18139    0.350042  ]
        """
        return _metamodel.CompositeRandomVector_getSample(self, *args)

    def getMean(self):
        """
        Accessor to the mean of the RandomVector.

        Returns
        -------
        mean : float sequence
            Mean of the considered :class:`~openturns.UsualRandomVector`.

        Examples
        --------
        >>> import openturns as ot
        >>> distribution = ot.Normal([0., 0.5], [1., 1.5], ot.CorrelationMatrix(2))
        >>> randomVector = ot.RandomVector(distribution)
        >>> ot.RandomGenerator.SetSeed(0)
        >>> print(randomVector.getMean())
        [0,0.5]
        """
        return _metamodel.CompositeRandomVector_getMean(self)

    def getCovariance(self):
        """
        Accessor to the covariance of the RandomVector.

        Returns
        -------
        covariance : :class:`~openturns.CovarianceMatrix`
            Covariance of the considered :class:`~openturns.UsualRandomVector`.

        Examples
        --------
        >>> import openturns as ot
        >>> distribution = ot.Normal([0., 0.5], [1., 1.5], ot.CorrelationMatrix(2))
        >>> randomVector = ot.RandomVector(distribution)
        >>> ot.RandomGenerator.SetSeed(0)
        >>> print(randomVector.getCovariance())
        [[ 1    0    ]
         [ 0    2.25 ]]
        """
        return _metamodel.CompositeRandomVector_getCovariance(self)

    def getMarginal(self, *args):
        """
        Accessor to the random vector corresponding to the i^{th} marginal component(s).

        Parameters
        ----------
        i : int or list of ints, :math:`0\\leq i < dim`
            Indicates the component(s) concerned. :math:`dim` is the dimension of the
            RandomVector.

        Returns
        -------
        vector :  :class:`~openturns.RandomVector`
            RandomVector restricted to the concerned components.

        Notes
        -----
        Let's note :math:`\\underline{Y}=(Y_1,\\dots,Y_n)^t` a random vector and
        :math:`I \\in [1,n]` a set of indices. If :math:`\\underline{Y}` is a
        :class:`~openturns.UsualRandomVector`, the subvector is defined by
        :math:`\\tilde{\\underline{Y}}=(Y_i)_{i \\in I}^t`. If :math:`\\underline{Y}` is a
        :class:`~openturns.CompositeRandomVector`, defined by
        :math:`\\underline{Y}=f(\\underline{X})` with :math:`f=(f_1,\\dots,f_n)`,
        :math:`f_i` some scalar functions, the subvector is
        :math:`\\tilde{\\underline{Y}}=(f_i(\\underline{X}))_{i \\in I}`.

        Examples
        --------
        >>> import openturns as ot
        >>> distribution = ot.Normal([0., 0.], [1., 1.], ot.CorrelationMatrix(2))
        >>> randomVector = ot.RandomVector(distribution)
        >>> ot.RandomGenerator.SetSeed(0)
        >>> print(randomVector.getMarginal(1).getRealization())
        [0.608202]
        >>> print(randomVector.getMarginal(1).getDistribution())
        Normal(mu = 0, sigma = 1)
        """
        return _metamodel.CompositeRandomVector_getMarginal(self, *args)

    def getAntecedent(self):
        """
        Accessor to the antecedent RandomVector in case of a composite RandomVector.

        Returns
        -------
        antecedent : :class:`~openturns.RandomVector`
            Antecedent RandomVector :math:`\\underline{X}` in case of a
            :class:`~openturns.CompositeRandomVector` such as:
            :math:`\\underline{Y}=f(\\underline{X})`.
        """
        return _metamodel.CompositeRandomVector_getAntecedent(self)

    def getFunction(self):
        """
        Accessor to the NumericalMathFunction in case of a composite RandomVector.

        Returns
        -------
        function : :class:`~openturns.NumericalMathFunction`
            Function used to define a :class:`~openturns.CompositeRandomVector` as the
            image through this function of the antecedent :math:`\\underline{X}`:
            :math:`\\underline{Y}=f(\\underline{X})`.
        """
        return _metamodel.CompositeRandomVector_getFunction(self)

    def getDistribution(self):
        """
        Accessor to the distribution of the RandomVector.

        Returns
        -------
        distribution : :class:`~openturns.Distribution`
            Distribution of the considered :class:`~openturns.UsualRandomVector`.

        Examples
        --------
        >>> import openturns as ot
        >>> distribution = ot.Normal([0., 0.], [1., 1.], ot.CorrelationMatrix(2))
        >>> randomVector = ot.RandomVector(distribution)
        >>> ot.RandomGenerator.SetSeed(0)
        >>> print(randomVector.getDistribution())
        Normal(mu = [0,0], sigma = [1,1], R = [[ 1 0 ]
         [ 0 1 ]])
        """
        return _metamodel.CompositeRandomVector_getDistribution(self)

    def __init__(self, *args): 
        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)

class EventRandomVectorImplementation(CompositeRandomVector):
    __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(self):
        """
        Accessor to the object's name.

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

    def __repr__(self): return _metamodel.EventRandomVectorImplementation___repr__(self)
    def getDimension(self):
        """
        Accessor to the dimension of the RandomVector.

        Returns
        -------
        dimension : positive int
            Dimension of the RandomVector.
        """
        return _metamodel.EventRandomVectorImplementation_getDimension(self)

    def getOperator(self):
        """
        Accessor to the comparaison operator of the Event.

        Returns
        -------
        operator : :class:`~openturns.ComparisonOperator`
            Comparaison operator used to define the :class:`~openturns.Event`.
        """
        return _metamodel.EventRandomVectorImplementation_getOperator(self)

    def getThreshold(self):
        """
        Accessor to the threshold of the Event.

        Returns
        -------
        threshold : float
            Threshold of the :class:`~openturns.Event`.
        """
        return _metamodel.EventRandomVectorImplementation_getThreshold(self)

    def getRealization(self):
        """
        Compute one realization of the RandomVector.

        Returns
        -------
        aRealization : float sequence
            Sequence of values randomly determined from the RandomVector definition.
            In the case of an event: one realization of the event (considered as a
            Bernoulli variable) which is a boolean value (1 for the realization of the
            event and 0 else).

        See also
        --------
        getSample

        Examples
        --------
        >>> import openturns as ot
        >>> distribution = ot.Normal([0., 0.], [1., 1.], ot.CorrelationMatrix(2))
        >>> randomVector = ot.RandomVector(distribution)
        >>> ot.RandomGenerator.SetSeed(0)
        >>> print(randomVector.getRealization())
        [0.608202,-1.26617]
        >>> print(randomVector.getRealization())
        [-0.438266,1.20548]
        """
        return _metamodel.EventRandomVectorImplementation_getRealization(self)

    def getSample(self, *args):
        """
        Compute realizations of the RandomVector.

        Parameters
        ----------
        n : int, :math:`n \\geq 0`
            Number of realizations needed.

        Returns
        -------
        realizations : 2D float sequence
            n sequences of values randomly determined from the RandomVector definition.
            In the case of an event: n realizations of the event (considered as a
            Bernoulli variable) which are boolean values (1 for the realization of the
            event and 0 else).

        See also
        --------
        getRealization

        Examples
        --------
        >>> import openturns as ot
        >>> distribution = ot.Normal([0., 0.], [1., 1.], ot.CorrelationMatrix(2))
        >>> randomVector = ot.RandomVector(distribution)
        >>> ot.RandomGenerator.SetSeed(0)
        >>> print(randomVector.getSample(3))
            [ marginal 1 marginal 2 ]
        0 : [  0.608202  -1.26617   ]
        1 : [ -0.438266   1.20548   ]
        2 : [ -2.18139    0.350042  ]
        """
        return _metamodel.EventRandomVectorImplementation_getSample(self, *args)

    def __init__(self, *args): 
        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)

class EventDomainImplementation(CompositeRandomVector):
    __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(self):
        """
        Accessor to the object's name.

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

    def __repr__(self): return _metamodel.EventDomainImplementation___repr__(self)
    def getDimension(self):
        """
        Accessor to the dimension of the RandomVector.

        Returns
        -------
        dimension : positive int
            Dimension of the RandomVector.
        """
        return _metamodel.EventDomainImplementation_getDimension(self)

    def getDomain(self): return _metamodel.EventDomainImplementation_getDomain(self)
    def getRealization(self):
        """
        Compute one realization of the RandomVector.

        Returns
        -------
        aRealization : float sequence
            Sequence of values randomly determined from the RandomVector definition.
            In the case of an event: one realization of the event (considered as a
            Bernoulli variable) which is a boolean value (1 for the realization of the
            event and 0 else).

        See also
        --------
        getSample

        Examples
        --------
        >>> import openturns as ot
        >>> distribution = ot.Normal([0., 0.], [1., 1.], ot.CorrelationMatrix(2))
        >>> randomVector = ot.RandomVector(distribution)
        >>> ot.RandomGenerator.SetSeed(0)
        >>> print(randomVector.getRealization())
        [0.608202,-1.26617]
        >>> print(randomVector.getRealization())
        [-0.438266,1.20548]
        """
        return _metamodel.EventDomainImplementation_getRealization(self)

    def getSample(self, *args):
        """
        Compute realizations of the RandomVector.

        Parameters
        ----------
        n : int, :math:`n \\geq 0`
            Number of realizations needed.

        Returns
        -------
        realizations : 2D float sequence
            n sequences of values randomly determined from the RandomVector definition.
            In the case of an event: n realizations of the event (considered as a
            Bernoulli variable) which are boolean values (1 for the realization of the
            event and 0 else).

        See also
        --------
        getRealization

        Examples
        --------
        >>> import openturns as ot
        >>> distribution = ot.Normal([0., 0.], [1., 1.], ot.CorrelationMatrix(2))
        >>> randomVector = ot.RandomVector(distribution)
        >>> ot.RandomGenerator.SetSeed(0)
        >>> print(randomVector.getSample(3))
            [ marginal 1 marginal 2 ]
        0 : [  0.608202  -1.26617   ]
        1 : [ -0.438266   1.20548   ]
        2 : [ -2.18139    0.350042  ]
        """
        return _metamodel.EventDomainImplementation_getSample(self, *args)

    def __init__(self, *args): 
        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)

class EventProcess(openturns.randomvector.RandomVectorImplementation):
    __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(self):
        """
        Accessor to the object's name.

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

    def __repr__(self): return _metamodel.EventProcess___repr__(self)
    def getDimension(self):
        """
        Accessor to the dimension of the RandomVector.

        Returns
        -------
        dimension : positive int
            Dimension of the RandomVector.
        """
        return _metamodel.EventProcess_getDimension(self)

    def getDomain(self): return _metamodel.EventProcess_getDomain(self)
    def getProcess(self): return _metamodel.EventProcess_getProcess(self)
    def getRealization(self):
        """
        Compute one realization of the RandomVector.

        Returns
        -------
        aRealization : float sequence
            Sequence of values randomly determined from the RandomVector definition.
            In the case of an event: one realization of the event (considered as a
            Bernoulli variable) which is a boolean value (1 for the realization of the
            event and 0 else).

        See also
        --------
        getSample

        Examples
        --------
        >>> import openturns as ot
        >>> distribution = ot.Normal([0., 0.], [1., 1.], ot.CorrelationMatrix(2))
        >>> randomVector = ot.RandomVector(distribution)
        >>> ot.RandomGenerator.SetSeed(0)
        >>> print(randomVector.getRealization())
        [0.608202,-1.26617]
        >>> print(randomVector.getRealization())
        [-0.438266,1.20548]
        """
        return _metamodel.EventProcess_getRealization(self)

    def __init__(self, *args): 
        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)

class ConditionalRandomVector(openturns.randomvector.RandomVectorImplementation):
    """
    Conditional random vector.

    Helper class for defining the random vector :math:`\\vect{X}` such that  :math:`\\vect{X}|\\vect{\\Theta}` follows the distribution :math:`\\mathcal{L}_{\\vect{X}|\\vect{\\Theta}}`, with :math:`\\vect{\\Theta}` a random vector of dimension the dimension of :math:`\\vect{\\Theta}`.

    Available constructors:
       ConditionalRandomVector(*conditionedDist, randomParameters*)

    Parameters
    ----------

    conditionedDist : :class:`~openturns.Distribution`, the distribution of :math:`\\vect{X}|\\vect{\\Theta}`, whose parameters will be overwritten by :math:`\\vect{\\Theta}`.
        
    randomParameters : :class:`~openturns.RandomVector`, the random parameters :math:`\\vect{\\Theta}` of the `conditionedDist` distribution. 

    Notes
    -----
    Its probability density function is defined as:

    .. math::

        f_{\\vect{X}}(\\vect{x}) = \\int f_{\\vect{X}|\\vect{\\Theta}=\\vect{\\theta}}(\\vect{x}|\\vect{\\theta}) f_{\\vect{\\Theta}}(\\vect{\\theta})\\, d\\vect{\\theta}

    with  :math:`f_{\\vect{X}|\\vect{\\Theta}=\\vect{\\theta}}` the PDF of the distribution of :math:`\\vect{X}|\\vect{\\Theta}`, where :math:`\\vect{\\Theta}` has been replaced by :math:`\\vect{\\theta}`, :math:`f_{\\vect{\\Theta}}` the PDF of :math:`\\vect{\\Theta}`.

    Note that there exist other (quasi) equivalent modellings using a combination of the classes :class:`~openturns.ConditionalDistribution` and :class:`~openturns.RandomVector` (see the Use Cases Guide).

    Examples
    --------
    Create a random vector:

    >>> import openturns as ot
    >>> conditionedDist = ot.Normal()
    >>> linkFunc = ot.NumericalMathFunction(['y'], ['m', 's'], ['y', 'y^2'])
    >>> rvTheta = ot.CompositeRandomVector(linkFunc, ot.RandomVector(ot.Normal()))
    >>> finalDist = ot.ConditionalRandomVector(conditionedDist, rvTheta)

    Draw a sample:

    >>> sample = finalDist.getSample(10)

    """
    __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(self):
        """
        Accessor to the object's name.

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

    def __repr__(self): return _metamodel.ConditionalRandomVector___repr__(self)
    def getDimension(self):
        """
        Accessor to the dimension of the RandomVector.

        Returns
        -------
        dimension : positive int
            Dimension of the RandomVector.
        """
        return _metamodel.ConditionalRandomVector_getDimension(self)

    def getRealization(self, *args):
        """
        Compute one realization of the RandomVector.

        Returns
        -------
        aRealization : float sequence
            Sequence of values randomly determined from the RandomVector definition.
            In the case of an event: one realization of the event (considered as a
            Bernoulli variable) which is a boolean value (1 for the realization of the
            event and 0 else).

        See also
        --------
        getSample

        Examples
        --------
        >>> import openturns as ot
        >>> distribution = ot.Normal([0., 0.], [1., 1.], ot.CorrelationMatrix(2))
        >>> randomVector = ot.RandomVector(distribution)
        >>> ot.RandomGenerator.SetSeed(0)
        >>> print(randomVector.getRealization())
        [0.608202,-1.26617]
        >>> print(randomVector.getRealization())
        [-0.438266,1.20548]
        """
        return _metamodel.ConditionalRandomVector_getRealization(self, *args)

    def getDistribution(self):
        """
        Accessor to the distribution's conditioned distribution parameter `conditionedDistribution`.

        Returns
        -------
        conditionedDistribution : :class:`~openturns.Distribution`, the distribution of :math:`\\vect{X}|\\vect{\\Theta}=\\vect{\\theta}`, where the parameters :math:`\\vect{\\theta}` are equal to the  values used to generate the last realization of :math:`\\vect{X}`.

        """
        return _metamodel.ConditionalRandomVector_getDistribution(self)

    def getRandomParameters(self):
        """
        Accessor to the distribution's random parameter `randomParameters`.

        Returns
        -------
        randomParameters : :class:`~openturns.RandomVector`, the random parameters :math:`\\vect{\\Theta}`.

        """
        return _metamodel.ConditionalRandomVector_getRandomParameters(self)

    def __init__(self, *args): 
        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)

class Event(RandomVector):
    """
    Event.

    Available constructor:
        Event()

        Event(*antecedent, comparisonOperator, threshold*)

        Event(*antecedent, domain*)

        Event(*process, domain*)

    Parameters
    ----------
    antecedent : :class:`~openturns.RandomVector` of dimension 1
        Output variable of interest.
    comparisonOperator : :class:`~openturns.ComparisonOperator`
        Comparison operator used to compare *antecedent* with *threshold*.
    threshold : float
        *threshold* we want to compare to *antecedent*.
    domain : :class:`~openturns.Domain`
        Domain failure.
    process : :class:`~openturns.Process`
        Stochastic process.

    Notes
    -----
    An event is defined as follows:

    .. math::

        \\cD_f = \\{\\vect{X} \\in \\Rset^n \\, / \\, g(\\vect{X},\\vect{d}) \\le 0\\}

    where :math:`\\vect{X}` denotes a random input vector, representing the sources
    of uncertainties, :math:`\\vect{d}` is a determinist vector, representing the
    fixed variables and :math:`g(\\vect{X},\\vect{d})` is the limit state function of
    the model.
    The probability content of the event :math:`\\cD_f` is :math:`P_f`:

    .. math::

        P_f = \\int_{g(\\vect{X},\\vect{d})\\le 0}f_\\vect{X}(\\vect{x})d\\vect{x}

    Here, the event considered is explicited directly from the limit state function
    :math:`g(\\vect{X}\\,,\\,\\vect{d})` : this is the classical structural reliability
    formulation. However, if the event is a threshold exceedance, it is useful to
    explicite the variable of interest :math:`Z=\\tilde{g}(\\vect{X}\\,,\\,\\vect{d})`,
    evaluated from the model :math:`\\tilde{g}(.)`. In that case, the event
    considered, associated to the threshold :math:`z_s` has the formulation:

    .. math::

        \\cD_f = \\{ \\vect{X} \\in \\Rset^n \\, / \\, Z=\\tilde{g}(\\vect{X}\\,,\\,\\vect{d}) > z_s \\}

    and the limit state function is:

    .. math::

        g(\\vect{X}\\,,\\,\\vect{d}) &= z_s - Z \\\\
                                 &= z_s - \\tilde{g}(\\vect{X}\\,,\\,\\vect{d})

    :math:`P_f` is the threshold exceedance probability, defined as:

    .. math::

        P_f &= P(Z \\geq z_s) \\\\
            &= \\int_{g(\\vect{X}\\,,\\,\\vect{d}) \\le 0}  \\pdf\\, d\\vect{x}

    Examples
    --------
    An event created from a limit state function:

    >>> import openturns as ot
    >>> myFunction = ot.NumericalMathFunction(['E', 'F', 'L', 'I'], ['d'], ['-F*L^3/(3*E*I)'])
    >>> myDistribution = ot.Normal([50., 1., 10., 5.], [1.]*4, ot.IdentityMatrix(4))
    >>> vect = ot.RandomVector(myDistribution)
    >>> output = ot.RandomVector(myFunction, vect)
    >>> myEvent = ot.Event(output, ot.Less(), -3.0)

    A composite random vector based event:

    >>> X = ot.RandomVector(ot.Normal(2))
    >>> model = ot.NumericalMathFunction(['x0', 'x1'], ['x0', 'x1'])
    >>> Y = ot.RandomVector(model, X)
    >>> # The domain: [0, 1]^2
    >>> domain = ot.Interval(2)
    >>> # The event
    >>> event = ot.Event(Y, domain)

    A process based event:

    >>> # The input process
    >>> X = ot.WhiteNoise(ot.Normal(2))
    >>> # The domain: [0, 1]^2
    >>> domain = ot.Interval(2)
    >>> # The event
    >>> event = ot.Event(X, domain)

    """
    __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(self):
        """
        Accessor to the object's name.

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

    def __repr__(self): return _metamodel.Event___repr__(self)
    def __str__(self, offset=""): return _metamodel.Event___str__(self, offset)
    def __init__(self, *args): 
        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)

class StandardEvent(Event):
    __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(self):
        """
        Accessor to the object's name.

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

    def __init__(self, *args): 
        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)

class FunctionalChaosRandomVector(CompositeRandomVector):
    __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(self):
        """
        Accessor to the object's name.

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

    def __repr__(self): return _metamodel.FunctionalChaosRandomVector___repr__(self)
    def getMean(self):
        """
        Accessor to the mean of the RandomVector.

        Returns
        -------
        mean : float sequence
            Mean of the considered :class:`~openturns.UsualRandomVector`.

        Examples
        --------
        >>> import openturns as ot
        >>> distribution = ot.Normal([0., 0.5], [1., 1.5], ot.CorrelationMatrix(2))
        >>> randomVector = ot.RandomVector(distribution)
        >>> ot.RandomGenerator.SetSeed(0)
        >>> print(randomVector.getMean())
        [0,0.5]
        """
        return _metamodel.FunctionalChaosRandomVector_getMean(self)

    def getCovariance(self):
        """
        Accessor to the covariance of the RandomVector.

        Returns
        -------
        covariance : :class:`~openturns.CovarianceMatrix`
            Covariance of the considered :class:`~openturns.UsualRandomVector`.

        Examples
        --------
        >>> import openturns as ot
        >>> distribution = ot.Normal([0., 0.5], [1., 1.5], ot.CorrelationMatrix(2))
        >>> randomVector = ot.RandomVector(distribution)
        >>> ot.RandomGenerator.SetSeed(0)
        >>> print(randomVector.getCovariance())
        [[ 1    0    ]
         [ 0    2.25 ]]
        """
        return _metamodel.FunctionalChaosRandomVector_getCovariance(self)

    def getSobolIndex(self, *args): return _metamodel.FunctionalChaosRandomVector_getSobolIndex(self, *args)
    def getSobolTotalIndex(self, *args): return _metamodel.FunctionalChaosRandomVector_getSobolTotalIndex(self, *args)
    def getFunctionalChaoResult(self): return _metamodel.FunctionalChaosRandomVector_getFunctionalChaoResult(self)
    def __init__(self, *args): 
        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)

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