python3-openturns 1.5-7build2 / usr / lib / python3 / dist-packages / openturns / simulation.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.




"""
Simulation uncertainty propagation algorithms.
"""


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('_simulation', [dirname(__file__)])
        except ImportError:
            import _simulation
            return _simulation
        if fp is not None:
            try:
                _mod = imp.load_module('_simulation', fp, pathname, description)
            finally:
                fp.close()
            return _mod
    _simulation = swig_import_helper()
    del swig_import_helper
else:
    import _simulation
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__ = _simulation.delete_SwigPyIterator
    __del__ = lambda self : None;
    def value(self): return _simulation.SwigPyIterator_value(self)
    def incr(self, n=1): return _simulation.SwigPyIterator_incr(self, n)
    def decr(self, n=1): return _simulation.SwigPyIterator_decr(self, n)
    def distance(self, *args): return _simulation.SwigPyIterator_distance(self, *args)
    def equal(self, *args): return _simulation.SwigPyIterator_equal(self, *args)
    def copy(self): return _simulation.SwigPyIterator_copy(self)
    def next(self): return _simulation.SwigPyIterator_next(self)
    def __next__(self): return _simulation.SwigPyIterator___next__(self)
    def previous(self): return _simulation.SwigPyIterator_previous(self)
    def advance(self, *args): return _simulation.SwigPyIterator_advance(self, *args)
    def __eq__(self, *args): return _simulation.SwigPyIterator___eq__(self, *args)
    def __ne__(self, *args): return _simulation.SwigPyIterator___ne__(self, *args)
    def __iadd__(self, *args): return _simulation.SwigPyIterator___iadd__(self, *args)
    def __isub__(self, *args): return _simulation.SwigPyIterator___isub__(self, *args)
    def __add__(self, *args): return _simulation.SwigPyIterator___add__(self, *args)
    def __sub__(self, *args): return _simulation.SwigPyIterator___sub__(self, *args)
    def __iter__(self): return self
SwigPyIterator_swigregister = _simulation.SwigPyIterator_swigregister
SwigPyIterator_swigregister(SwigPyIterator)

GCC_VERSION = _simulation.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.transformation
import openturns.analytical
import openturns.metamodel
import openturns.weightedexperiment
import openturns.orthogonalbasis
import openturns.randomvector
class SimulationResultImplementation(openturns.common.PersistentObject):
    """
    Simulation result.

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

    Examples
    --------
    >>> import openturns as ot
    >>> ot.RandomGenerator.SetSeed(0)
    >>> limitState = ot.NumericalMathFunction(['E', 'F', 'L', 'I'], ['y'], ['-F*L^3/(3.*E*I)'])
    >>> # Enable the history mecanism in order to use the getImportanceFactors method
    >>> limitState.enableHistory()
    >>> myDistribution = ot.Normal([50., 1., 10., 5.], [1.]*4, ot.IdentityMatrix(4))
    >>> output = ot.RandomVector(limitState, ot.RandomVector(myDistribution))
    >>> myEvent = ot.Event(output, ot.Less(), -3.0)
    >>> myLHS = ot.LHS(myEvent)
    >>> myLHS.run()
    >>> SimulationLHSResult = myLHS.getResult()
    >>> print(SimulationLHSResult.getImportanceFactors())
    [marginal 1 : 0.000722617, marginal 2 : 0.635094, marginal 3 : 0.275692, marginal 4 : 0.0884917]
    """
    __swig_setmethods__ = {}
    for _s in [openturns.common.PersistentObject]: __swig_setmethods__.update(getattr(_s,'__swig_setmethods__',{}))
    __setattr__ = lambda self, name, value: _swig_setattr(self, SimulationResultImplementation, name, value)
    __swig_getmethods__ = {}
    for _s in [openturns.common.PersistentObject]: __swig_getmethods__.update(getattr(_s,'__swig_getmethods__',{}))
    __getattr__ = lambda self, name: _swig_getattr(self, SimulationResultImplementation, name)
    def getClassName(self):
        """
        Accessor to the object's name.

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

    def getEvent(self):
        """
        Accessor to the event.

        Returns
        -------
        event : :class:`~openturns.Event`
            Event we want to evaluate the probability.
        """
        return _simulation.SimulationResultImplementation_getEvent(self)

    def setEvent(self, *args): return _simulation.SimulationResultImplementation_setEvent(self, *args)
    def getProbabilityEstimate(self):
        """
        Accessor to the probability estimate.

        Returns
        -------
        probaEstimate : float
            Estimate of the event probability.
        """
        return _simulation.SimulationResultImplementation_getProbabilityEstimate(self)

    def setProbabilityEstimate(self, *args):
        """
        Accessor to the probability estimate.

        Parameters
        ----------
        probaEstimate : float, :math:`0 \\leq P_e \\leq 1`
            Estimate of the event probability.
        """
        return _simulation.SimulationResultImplementation_setProbabilityEstimate(self, *args)

    def getVarianceEstimate(self):
        """
        Accessor to the variance estimate.

        Returns
        -------
        varianceEstimate : float
            Variance estimate.
        """
        return _simulation.SimulationResultImplementation_getVarianceEstimate(self)

    def setVarianceEstimate(self, *args):
        """
        Accessor to the variance estimate.

        Parameters
        ----------
        varianceEstimate : float, :math:`Var_e \\geq 0`
            Variance estimate.
        """
        return _simulation.SimulationResultImplementation_setVarianceEstimate(self, *args)

    def getCoefficientOfVariation(self):
        """
        Accessor to the coefficient of variation.

        Returns
        -------
        coefficient : float
            Coefficient of variation of the simulated sample which is equal to
            :math:`\\sqrt{Var_e} / P_e` with :math:`Var_e` the variance estimate and
            :math:`P_e` the probability estimate.
        """
        return _simulation.SimulationResultImplementation_getCoefficientOfVariation(self)

    def getStandardDeviation(self):
        """
        Accessor to the standard deviation.

        Returns
        -------
        sigma : float
            Standard deviation of the estimator at the end of the simulation.
        """
        return _simulation.SimulationResultImplementation_getStandardDeviation(self)

    def getMeanPointInEventDomain(self):
        """
        Accessor to the mean point conditioned to the event realization.

        Returns
        -------
        meanPoint : float sequence
            Mean point in the physical space of all the simulations generated by the
            :class:`~openturns.Simulation` algorithm that failed into the event domain.

        Notes
        -----
        .. warning::
            This notion is only available if the history mecanism of the model is
            activated (see :meth:`~openturns.NumericalMathFunction.enableHistory`).
        """
        return _simulation.SimulationResultImplementation_getMeanPointInEventDomain(self)

    def getImportanceFactors(self):
        """
        Accessor to the importance factors.

        Returns
        -------
        importanceFactors : float sequence with description for each component
            Importance factors.

        Notes
        -----
        The importance factors :math:`\\alpha_i` are evaluated from the coordinates of
        the mean point of event domain :math:`\\vect{X}^*_{event}`, mapped into the
        standard space as follows:

        .. math::

          \\alpha_i = \\displaystyle \\frac{\\left(U_{i}^*\\right)^2}{||\\vect{U}^*||^2}

        where :math:`\\vect{U}^* = T(\\vect{X}^*_{event})`
        with :math:`T` the iso-probabilistic transformation and the mean point
        :math:`\\vect{X}^*_{event} = \\displaystyle \\frac{1}{n} \\sum_{i=1}^{n} \\vect{X}_i 1_{event}(\\vect{X}_i)`.

        .. warning::
            This notion is only available if the history mecanism of the model is
            activated (see :meth:`~openturns.NumericalMathFunction.enableHistory`).

        See also
        --------
        drawImportanceFactors
        """
        return _simulation.SimulationResultImplementation_getImportanceFactors(self)

    def drawImportanceFactors(self):
        """
        Draw the importance factors as an OpenTURNS :class:`~openturns.Graph`.

        .. warning::
            It is necessary to enable the history of the model to perform this analysis
            (see :meth:`~openturns.NumericalMathFunction.enableHistory`).

        See also
        --------
        getImportanceFactors
        """
        return _simulation.SimulationResultImplementation_drawImportanceFactors(self)

    def getOuterSampling(self):
        """
        Accessor to the outer sampling.

        Returns
        -------
        outerSampling : int
            Number of groups of terms in the probability simulation estimator.
        """
        return _simulation.SimulationResultImplementation_getOuterSampling(self)

    def setOuterSampling(self, *args):
        """
        Accessor to the outer sampling.

        Parameters
        ----------
        outerSampling : int, :math:`outerSampling \\geq 0`
            Number of groups of terms in the probability simulation estimator.
        """
        return _simulation.SimulationResultImplementation_setOuterSampling(self, *args)

    def getBlockSize(self):
        """
        Accessor to the block size.

        Returns
        -------
        blockSize : int
            Number of terms in the probability simulation estimator grouped together.
        """
        return _simulation.SimulationResultImplementation_getBlockSize(self)

    def setBlockSize(self, *args):
        """
        Accessor to the block size.

        Parameters
        ----------
        blockSize : int, :math:`blockSize \\geq 0`
            Number of terms in the probability simulation estimator grouped together.
        """
        return _simulation.SimulationResultImplementation_setBlockSize(self, *args)

    def getConfidenceLength(self, *args):
        """
        Accessor to the confidence length.

        Parameters
        ----------
        level : float, :math:`level \\in ]0, 1[`
            Confidence level. By default, it is :math:`0.95`.

        Returns
        -------
        confidenceLength : float
            Length of the confidence interval at the confidence level *level*.
        """
        return _simulation.SimulationResultImplementation_getConfidenceLength(self, *args)

    def __repr__(self): return _simulation.SimulationResultImplementation___repr__(self)
    def __init__(self, *args): 
        this = _simulation.new_SimulationResultImplementation(*args)
        try: self.this.append(this)
        except: self.this = this
    __swig_destroy__ = _simulation.delete_SimulationResultImplementation
    __del__ = lambda self : None;
SimulationResultImplementation_swigregister = _simulation.SimulationResultImplementation_swigregister
SimulationResultImplementation_swigregister(SimulationResultImplementation)

class SimulationResultImplementationTypedInterfaceObject(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, SimulationResultImplementationTypedInterfaceObject, name, value)
    __swig_getmethods__ = {}
    for _s in [openturns.common.InterfaceObject]: __swig_getmethods__.update(getattr(_s,'__swig_getmethods__',{}))
    __getattr__ = lambda self, name: _swig_getattr(self, SimulationResultImplementationTypedInterfaceObject, name)
    __repr__ = _swig_repr
    def __init__(self, *args): 
        this = _simulation.new_SimulationResultImplementationTypedInterfaceObject(*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 _simulation.SimulationResultImplementationTypedInterfaceObject_getImplementation(self, *args)

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

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

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

        Returns
        -------
        name : string
            The name of the object.
        """
        return _simulation.SimulationResultImplementationTypedInterfaceObject_getName(self)

    def __eq__(self, *args): return _simulation.SimulationResultImplementationTypedInterfaceObject___eq__(self, *args)
    __swig_destroy__ = _simulation.delete_SimulationResultImplementationTypedInterfaceObject
    __del__ = lambda self : None;
SimulationResultImplementationTypedInterfaceObject_swigregister = _simulation.SimulationResultImplementationTypedInterfaceObject_swigregister
SimulationResultImplementationTypedInterfaceObject_swigregister(SimulationResultImplementationTypedInterfaceObject)

class SimulationResult(SimulationResultImplementationTypedInterfaceObject):
    """
    Simulation result.

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

    Examples
    --------
    >>> import openturns as ot
    >>> ot.RandomGenerator.SetSeed(0)
    >>> limitState = ot.NumericalMathFunction(['E', 'F', 'L', 'I'], ['y'], ['-F*L^3/(3.*E*I)'])
    >>> # Enable the history mecanism in order to use the getImportanceFactors method
    >>> limitState.enableHistory()
    >>> myDistribution = ot.Normal([50., 1., 10., 5.], [1.]*4, ot.IdentityMatrix(4))
    >>> output = ot.RandomVector(limitState, ot.RandomVector(myDistribution))
    >>> myEvent = ot.Event(output, ot.Less(), -3.0)
    >>> myLHS = ot.LHS(myEvent)
    >>> myLHS.run()
    >>> SimulationLHSResult = myLHS.getResult()
    >>> print(SimulationLHSResult.getImportanceFactors())
    [marginal 1 : 0.000722617, marginal 2 : 0.635094, marginal 3 : 0.275692, marginal 4 : 0.0884917]
    """
    __swig_setmethods__ = {}
    for _s in [SimulationResultImplementationTypedInterfaceObject]: __swig_setmethods__.update(getattr(_s,'__swig_setmethods__',{}))
    __setattr__ = lambda self, name, value: _swig_setattr(self, SimulationResult, name, value)
    __swig_getmethods__ = {}
    for _s in [SimulationResultImplementationTypedInterfaceObject]: __swig_getmethods__.update(getattr(_s,'__swig_getmethods__',{}))
    __getattr__ = lambda self, name: _swig_getattr(self, SimulationResult, name)
    def getClassName(self):
        """
        Accessor to the object's name.

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

    def getEvent(self):
        """
        Accessor to the event.

        Returns
        -------
        event : :class:`~openturns.Event`
            Event we want to evaluate the probability.
        """
        return _simulation.SimulationResult_getEvent(self)

    def getProbabilityEstimate(self):
        """
        Accessor to the probability estimate.

        Returns
        -------
        probaEstimate : float
            Estimate of the event probability.
        """
        return _simulation.SimulationResult_getProbabilityEstimate(self)

    def setProbabilityEstimate(self, *args):
        """
        Accessor to the probability estimate.

        Parameters
        ----------
        probaEstimate : float, :math:`0 \\leq P_e \\leq 1`
            Estimate of the event probability.
        """
        return _simulation.SimulationResult_setProbabilityEstimate(self, *args)

    def getVarianceEstimate(self):
        """
        Accessor to the variance estimate.

        Returns
        -------
        varianceEstimate : float
            Variance estimate.
        """
        return _simulation.SimulationResult_getVarianceEstimate(self)

    def setVarianceEstimate(self, *args):
        """
        Accessor to the variance estimate.

        Parameters
        ----------
        varianceEstimate : float, :math:`Var_e \\geq 0`
            Variance estimate.
        """
        return _simulation.SimulationResult_setVarianceEstimate(self, *args)

    def getCoefficientOfVariation(self):
        """
        Accessor to the coefficient of variation.

        Returns
        -------
        coefficient : float
            Coefficient of variation of the simulated sample which is equal to
            :math:`\\sqrt{Var_e} / P_e` with :math:`Var_e` the variance estimate and
            :math:`P_e` the probability estimate.
        """
        return _simulation.SimulationResult_getCoefficientOfVariation(self)

    def getStandardDeviation(self):
        """
        Accessor to the standard deviation.

        Returns
        -------
        sigma : float
            Standard deviation of the estimator at the end of the simulation.
        """
        return _simulation.SimulationResult_getStandardDeviation(self)

    def getMeanPointInEventDomain(self):
        """
        Accessor to the mean point conditioned to the event realization.

        Returns
        -------
        meanPoint : float sequence
            Mean point in the physical space of all the simulations generated by the
            :class:`~openturns.Simulation` algorithm that failed into the event domain.

        Notes
        -----
        .. warning::
            This notion is only available if the history mecanism of the model is
            activated (see :meth:`~openturns.NumericalMathFunction.enableHistory`).
        """
        return _simulation.SimulationResult_getMeanPointInEventDomain(self)

    def getImportanceFactors(self):
        """
        Accessor to the importance factors.

        Returns
        -------
        importanceFactors : float sequence with description for each component
            Importance factors.

        Notes
        -----
        The importance factors :math:`\\alpha_i` are evaluated from the coordinates of
        the mean point of event domain :math:`\\vect{X}^*_{event}`, mapped into the
        standard space as follows:

        .. math::

          \\alpha_i = \\displaystyle \\frac{\\left(U_{i}^*\\right)^2}{||\\vect{U}^*||^2}

        where :math:`\\vect{U}^* = T(\\vect{X}^*_{event})`
        with :math:`T` the iso-probabilistic transformation and the mean point
        :math:`\\vect{X}^*_{event} = \\displaystyle \\frac{1}{n} \\sum_{i=1}^{n} \\vect{X}_i 1_{event}(\\vect{X}_i)`.

        .. warning::
            This notion is only available if the history mecanism of the model is
            activated (see :meth:`~openturns.NumericalMathFunction.enableHistory`).

        See also
        --------
        drawImportanceFactors
        """
        return _simulation.SimulationResult_getImportanceFactors(self)

    def drawImportanceFactors(self):
        """
        Draw the importance factors as an OpenTURNS :class:`~openturns.Graph`.

        .. warning::
            It is necessary to enable the history of the model to perform this analysis
            (see :meth:`~openturns.NumericalMathFunction.enableHistory`).

        See also
        --------
        getImportanceFactors
        """
        return _simulation.SimulationResult_drawImportanceFactors(self)

    def getOuterSampling(self):
        """
        Accessor to the outer sampling.

        Returns
        -------
        outerSampling : int
            Number of groups of terms in the probability simulation estimator.
        """
        return _simulation.SimulationResult_getOuterSampling(self)

    def setOuterSampling(self, *args):
        """
        Accessor to the outer sampling.

        Parameters
        ----------
        outerSampling : int, :math:`outerSampling \\geq 0`
            Number of groups of terms in the probability simulation estimator.
        """
        return _simulation.SimulationResult_setOuterSampling(self, *args)

    def getBlockSize(self):
        """
        Accessor to the block size.

        Returns
        -------
        blockSize : int
            Number of terms in the probability simulation estimator grouped together.
        """
        return _simulation.SimulationResult_getBlockSize(self)

    def setBlockSize(self, *args):
        """
        Accessor to the block size.

        Parameters
        ----------
        blockSize : int, :math:`blockSize \\geq 0`
            Number of terms in the probability simulation estimator grouped together.
        """
        return _simulation.SimulationResult_setBlockSize(self, *args)

    def getConfidenceLength(self, *args):
        """
        Accessor to the confidence length.

        Parameters
        ----------
        level : float, :math:`level \\in ]0, 1[`
            Confidence level. By default, it is :math:`0.95`.

        Returns
        -------
        confidenceLength : float
            Length of the confidence interval at the confidence level *level*.
        """
        return _simulation.SimulationResult_getConfidenceLength(self, *args)

    def __repr__(self): return _simulation.SimulationResult___repr__(self)
    def __init__(self, *args): 
        this = _simulation.new_SimulationResult(*args)
        try: self.this.append(this)
        except: self.this = this
    __swig_destroy__ = _simulation.delete_SimulationResult
    __del__ = lambda self : None;
SimulationResult_swigregister = _simulation.SimulationResult_swigregister
SimulationResult_swigregister(SimulationResult)

class Simulation(openturns.common.PersistentObject):
    """
    Base class for simulations.

    Available constructor:
        Simulation(*event, verbose=True, convergenceStrategy=ot.Compact()*)

    Parameters
    ----------
    event : :class:`~openturns.Event`
        The event we are computing the probability of.
    verbose : bool
        If *True*, make the computation verbose.
    convergenceStrategy : :class:`~openturns.HistoryStrategy`
        Storage strategy used to store the values of the probability estimator and
        its variance during the simulation algorithm.

    Notes
    -----
    A Simulation object can be created only through its derived classes:
    :class:`~openturns.DirectionalSampling`, :class:`~openturns.ImportanceSampling`,
    :class:`~openturns.LHS`, :class:`~openturns.MonteCarlo`,
    :class:`~openturns.PostAnalyticalControlledImportanceSampling`,
    :class:`~openturns.PostAnalyticalImportanceSampling`,
    :class:`~openturns.QuasiMonteCarlo`, :class:`~openturns.RandomizedLHS`,
    :class:`~openturns.RandomizedQuasiMonteCarlo`.

    See also
    --------
    SimulationResult
    """
    __swig_setmethods__ = {}
    for _s in [openturns.common.PersistentObject]: __swig_setmethods__.update(getattr(_s,'__swig_setmethods__',{}))
    __setattr__ = lambda self, name, value: _swig_setattr(self, Simulation, name, value)
    __swig_getmethods__ = {}
    for _s in [openturns.common.PersistentObject]: __swig_getmethods__.update(getattr(_s,'__swig_getmethods__',{}))
    __getattr__ = lambda self, name: _swig_getattr(self, Simulation, name)
    def getClassName(self):
        """
        Accessor to the object's name.

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

    def getEvent(self):
        """
        Accessor to the event.

        Returns
        -------
        event : :class:`~openturns.Event`
            Event we want to evaluate the probability.
        """
        return _simulation.Simulation_getEvent(self)

    def getResult(self):
        """
        Accessor to the results.

        Returns
        -------
        results : :class:`~openturns.SimulationResult`
            Structure containing all the results obtained after simulation and created
            by the method :py:meth:`run`.
        """
        return _simulation.Simulation_getResult(self)

    def setMaximumOuterSampling(self, *args):
        """
        Accessor to the maximum sample size.

        Parameters
        ----------
        outerSampling : int
            Maximum number of groups of terms in the probability simulation estimator.
        """
        return _simulation.Simulation_setMaximumOuterSampling(self, *args)

    def getMaximumOuterSampling(self):
        """
        Accessor to the maximum sample size.

        Returns
        -------
        outerSampling : int
            Maximum number of groups of terms in the probability simulation estimator.
        """
        return _simulation.Simulation_getMaximumOuterSampling(self)

    def setMaximumCoefficientOfVariation(self, *args):
        """
        Accessor to the maximum coefficient of variation.

        Parameters
        ----------
        coefficient : float
            Maximum coefficient of variation of the simulated sample.
        """
        return _simulation.Simulation_setMaximumCoefficientOfVariation(self, *args)

    def getMaximumCoefficientOfVariation(self):
        """
        Accessor to the maximum coefficient of variation.

        Returns
        -------
        coefficient : float
            Maximum coefficient of variation of the simulated sample.
        """
        return _simulation.Simulation_getMaximumCoefficientOfVariation(self)

    def setMaximumStandardDeviation(self, *args):
        """
        Accessor to the maximum standard deviation.

        Parameters
        ----------
        sigma : float, :math:`\\sigma > 0`
            Maximum standard deviation of the estimator.
        """
        return _simulation.Simulation_setMaximumStandardDeviation(self, *args)

    def getMaximumStandardDeviation(self):
        """
        Accessor to the maximum standard deviation.

        Returns
        -------
        sigma : float, :math:`\\sigma > 0`
            Maximum standard deviation of the estimator.
        """
        return _simulation.Simulation_getMaximumStandardDeviation(self)

    def setBlockSize(self, *args):
        """
        Accessor to the block size.

        Parameters
        ----------
        blockSize : int, :math:`blockSize \\geq 1`
            Number of terms in the probability simulation estimator grouped together.
            It is set by default to 1.

        Notes
        -----
        For Monte Carlo, LHS and Importance Sampling methods, this allows to save space
        while allowing multithreading, when available (wrapper function) we recommend
        to use the number of available CPUs; for the Directional Sampling, we recommend
        to set it to 1.
        """
        return _simulation.Simulation_setBlockSize(self, *args)

    def getBlockSize(self):
        """
        Accessor to the block size.

        Returns
        -------
        blockSize : int
            Number of terms in the probability simulation estimator grouped together.
            It is set by default to 1.
        """
        return _simulation.Simulation_getBlockSize(self)

    def setVerbose(self, *args):
        """
        Accessor to verbosity.

        Parameters
        ----------
        verbosity_enabled : bool
            If *True*, make the computation verbose. By default it is verbose.
        """
        return _simulation.Simulation_setVerbose(self, *args)

    def getVerbose(self):
        """
        Accessor to verbosity.

        Returns
        -------
        verbosity_enabled : bool
            If *True*, the computation is verbose. By default it is verbose.
        """
        return _simulation.Simulation_getVerbose(self)

    def setConvergenceStrategy(self, *args):
        """
        Accessor to the convergence strategy.

        Parameters
        ----------
        storage_strategy : :class:`~openturns.HistoryStrategy`
            Storage strategy used to store the values of the probability estimator
            and its variance during the simulation algorithm.
        """
        return _simulation.Simulation_setConvergenceStrategy(self, *args)

    def getConvergenceStrategy(self):
        """
        Accessor to the convergence strategy.

        Returns
        -------
        storage_strategy : :class:`~openturns.HistoryStrategy`
            Storage strategy used to store the values of the probability estimator
            and its variance during the simulation algorithm.
        """
        return _simulation.Simulation_getConvergenceStrategy(self)

    def __repr__(self): return _simulation.Simulation___repr__(self)
    def run(self):
        """
        Launch simulation.

        Notes
        -----
        It launches the simulation and creates a :class:`~openturns.SimulationResult`,
        structure containing all the results obtained after simulation.
        It computes the probability of occurence of the given event by computing the
        empirical mean of a sample of size at most *outerSampling * blockSize*,
        this sample being built by blocks of size *blockSize*. It allows to use
        efficiently the distribution of the computation as well as it allows to deal
        with a sample size :math:`> 2^{32}` by a combination of *blockSize* and
        *outerSampling*.

        see also
        --------
        setBlockSize, setMaximumOuterSampling, ResourceMap, SimulationResult
        """
        return _simulation.Simulation_run(self)

    def drawProbabilityConvergence(self, *args):
        """
        Draw the probability convergence at a given level.

        Parameters
        ----------
        level : float, optional
            The probability convergence is drawn at this given confidence length
            *level*. By default *level* is 0.95.

        Returns
        -------
        graph : a :class:`~openturns.Graph`
            probability convergence graph
        """
        return _simulation.Simulation_drawProbabilityConvergence(self, *args)

    def __init__(self, *args): 
        this = _simulation.new_Simulation(*args)
        try: self.this.append(this)
        except: self.this = this
    def setProgressCallback(self, *args):
        """
        Set up a progress callback.

        Parameters
        ----------
        callback : callable
            Takes a float as argument as percentage of progress.
        """
        return _simulation.Simulation_setProgressCallback(self, *args)

    def setStopCallback(self, *args):
        """
        Set up a stop callback.

        Parameters
        ----------
        callback : callable
            Returns an int deciding whether to stop or continue.
        """
        return _simulation.Simulation_setStopCallback(self, *args)

    __swig_destroy__ = _simulation.delete_Simulation
    __del__ = lambda self : None;
Simulation_swigregister = _simulation.Simulation_swigregister
Simulation_swigregister(Simulation)

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

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

    def getAnalyticalResult(self): return _simulation.PostAnalyticalSimulation_getAnalyticalResult(self)
    def getControlProbability(self): return _simulation.PostAnalyticalSimulation_getControlProbability(self)
    def __repr__(self): return _simulation.PostAnalyticalSimulation___repr__(self)
    def __init__(self, *args): 
        this = _simulation.new_PostAnalyticalSimulation(*args)
        try: self.this.append(this)
        except: self.this = this
    __swig_destroy__ = _simulation.delete_PostAnalyticalSimulation
    __del__ = lambda self : None;
PostAnalyticalSimulation_swigregister = _simulation.PostAnalyticalSimulation_swigregister
PostAnalyticalSimulation_swigregister(PostAnalyticalSimulation)

class Wilks(_object):
    __swig_setmethods__ = {}
    __setattr__ = lambda self, name, value: _swig_setattr(self, Wilks, name, value)
    __swig_getmethods__ = {}
    __getattr__ = lambda self, name: _swig_getattr(self, Wilks, name)
    __repr__ = _swig_repr
    __swig_getmethods__["ComputeSampleSize"] = lambda x: _simulation.Wilks_ComputeSampleSize
    if _newclass:ComputeSampleSize = staticmethod(_simulation.Wilks_ComputeSampleSize)
    def computeQuantileBound(self, *args): return _simulation.Wilks_computeQuantileBound(self, *args)
    def __init__(self, *args): 
        this = _simulation.new_Wilks(*args)
        try: self.this.append(this)
        except: self.this = this
    __swig_destroy__ = _simulation.delete_Wilks
    __del__ = lambda self : None;
Wilks_swigregister = _simulation.Wilks_swigregister
Wilks_swigregister(Wilks)

def Wilks_ComputeSampleSize(*args):
  return _simulation.Wilks_ComputeSampleSize(*args)
Wilks_ComputeSampleSize = _simulation.Wilks_ComputeSampleSize

class MonteCarlo(Simulation):
    """
    Monte Carlo method.

    Available constructors:
        MonteCarlo(*event=ot.Event()*)

    Parameters
    ----------
    event : :class:`~openturns.Event`
        Event we are computing the probability of.

    Notes
    -----
    Using the probability distribution of a random vector :math:`\\vect{X}`, we seek
    to evaluate the following probability:

    .. math::

        P_f = \\Prob{g\\left( \\vect{X},\\vect{d} \\right) \\leq 0}

    Here, :math:`\\vect{X}` is a random vector, :math:`\\vect{d}` a deterministic
    vector, :math:`g(\\vect{X},\\vect{d})` the function known as 'limit state function'
    which enables the definition of the event
    :math:`\\cD_f = \\{\\vect{X} \\in \\Rset^n \\, / \\, g(\\vect{X},\\vect{d}) \\le 0\\}`.

    If we have the set :math:`\\left\\{ \\vect{x}_1,\\ldots,\\vect{x}_N \\right\\}` of
    :math:`N` independent samples of the random vector :math:`\\vect{X}`, we can
    estimate :math:`\\widehat{P}_f` as follows:

    .. math::

        \\widehat{P}_f = \\frac{1}{N} \\sum_{i=1}^N \\mathbf{1}_{ \\left\\{ g(\\vect{x}_i,\\vect{d}) \\leq 0 \\right\\} }

    where :math:`\\mathbf{1}_{ \\left\\{ g(\\vect{x}_i,\\vect{d}) \\leq 0 \\right\\} }`
    describes the indicator function equal to 1 if
    :math:`g(\\vect{x}_i,\\vect{d}) \\leq 0` and equal to 0 otherwise;
    the idea here is in fact to estimate the required probability by the proportion
    of cases, among the :math:`N` samples of :math:`\\vect{X}`, for which the event
    :math:`\\cD_f` occurs.

    By the law of large numbers, we know that this estimation converges to the
    required value :math:`P_f` as the sample size :math:`N` tends to infinity.

    The Central Limit Theorem allows to build an asymptotic confidence interval
    using the normal limit distribution as follows:

    .. math::

        \\lim_{N\\rightarrow\\infty}\\Prob{P_f\\in[\\widehat{P}_{f,\\inf},\\widehat{P}_{f,\\sup}]}=\\alpha

    with :math:`\\widehat{P}_{f,\\inf}=\\widehat{P}_f - q_{\\alpha}\\sqrt{\\frac{\\widehat{P}_f(1-\\widehat{P}_f)}{N}}`,
    :math:`\\widehat{P}_{f,\\sup}=\\widehat{P}_f + q_{\\alpha}\\sqrt{\\frac{\\widehat{P}_f(1-\\widehat{P}_f)}{N}}`
    and :math:`q_\\alpha` is the :math:`(1+\\alpha)/2`-quantile of the standard
    normal distribution.

    Examples
    --------
    >>> import openturns as ot
    >>> ot.RandomGenerator.SetSeed(0)
    >>> myFunction = ot.NumericalMathFunction(['E', 'F', 'L', 'I'], ['d'], ['-F*L^3/(3*E*I)'])
    >>> myDistribution = ot.Normal([50., 1., 10., 5.], [1., 1., 1., 1.], ot.IdentityMatrix(4))
    >>> # We create a 'usual' RandomVector from the Distribution
    >>> vect = ot.RandomVector(myDistribution)
    >>> # We create a composite random vector
    >>> output = ot.RandomVector(myFunction, vect)
    >>> # We create an Event from this RandomVector
    >>> myEvent = ot.Event(output, ot.Less(), -3.0)
    >>> # We create a Monte Carlo algorithm
    >>> myAlgo = ot.MonteCarlo(myEvent)
    >>> myAlgo.setMaximumOuterSampling(250)
    >>> myAlgo.setBlockSize(4)
    >>> myAlgo.setMaximumCoefficientOfVariation(0.1)
    >>> # Perform the simulation
    >>> myAlgo.run()
    >>> print('Probability estimate=%.6f' % myAlgo.getResult().getProbabilityEstimate())
    Probability estimate=0.146505
    """
    __swig_setmethods__ = {}
    for _s in [Simulation]: __swig_setmethods__.update(getattr(_s,'__swig_setmethods__',{}))
    __setattr__ = lambda self, name, value: _swig_setattr(self, MonteCarlo, name, value)
    __swig_getmethods__ = {}
    for _s in [Simulation]: __swig_getmethods__.update(getattr(_s,'__swig_getmethods__',{}))
    __getattr__ = lambda self, name: _swig_getattr(self, MonteCarlo, name)
    def getClassName(self):
        """
        Accessor to the object's name.

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

    def __repr__(self): return _simulation.MonteCarlo___repr__(self)
    def __init__(self, *args): 
        this = _simulation.new_MonteCarlo(*args)
        try: self.this.append(this)
        except: self.this = this
    __swig_destroy__ = _simulation.delete_MonteCarlo
    __del__ = lambda self : None;
MonteCarlo_swigregister = _simulation.MonteCarlo_swigregister
MonteCarlo_swigregister(MonteCarlo)

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

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

    def run(self):
        """
        Launch simulation.

        Notes
        -----
        It launches the simulation and creates a :class:`~openturns.SimulationResult`,
        structure containing all the results obtained after simulation.
        It computes the probability of occurence of the given event by computing the
        empirical mean of a sample of size at most *outerSampling * blockSize*,
        this sample being built by blocks of size *blockSize*. It allows to use
        efficiently the distribution of the computation as well as it allows to deal
        with a sample size :math:`> 2^{32}` by a combination of *blockSize* and
        *outerSampling*.

        see also
        --------
        setBlockSize, setMaximumOuterSampling, ResourceMap, SimulationResult
        """
        return _simulation.LHS_run(self)

    def __repr__(self): return _simulation.LHS___repr__(self)
    def __init__(self, *args): 
        this = _simulation.new_LHS(*args)
        try: self.this.append(this)
        except: self.this = this
    __swig_destroy__ = _simulation.delete_LHS
    __del__ = lambda self : None;
LHS_swigregister = _simulation.LHS_swigregister
LHS_swigregister(LHS)

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

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

    def __repr__(self): return _simulation.RandomizedLHS___repr__(self)
    def __init__(self, *args): 
        this = _simulation.new_RandomizedLHS(*args)
        try: self.this.append(this)
        except: self.this = this
    __swig_destroy__ = _simulation.delete_RandomizedLHS
    __del__ = lambda self : None;
RandomizedLHS_swigregister = _simulation.RandomizedLHS_swigregister
RandomizedLHS_swigregister(RandomizedLHS)

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

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

    def getImportanceDistribution(self): return _simulation.ImportanceSampling_getImportanceDistribution(self)
    def __repr__(self): return _simulation.ImportanceSampling___repr__(self)
    def __init__(self, *args): 
        this = _simulation.new_ImportanceSampling(*args)
        try: self.this.append(this)
        except: self.this = this
    __swig_destroy__ = _simulation.delete_ImportanceSampling
    __del__ = lambda self : None;
ImportanceSampling_swigregister = _simulation.ImportanceSampling_swigregister
ImportanceSampling_swigregister(ImportanceSampling)

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

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

    def __repr__(self): return _simulation.PostAnalyticalControlledImportanceSampling___repr__(self)
    def computeBlockSample(self): return _simulation.PostAnalyticalControlledImportanceSampling_computeBlockSample(self)
    def __init__(self, *args): 
        this = _simulation.new_PostAnalyticalControlledImportanceSampling(*args)
        try: self.this.append(this)
        except: self.this = this
    __swig_destroy__ = _simulation.delete_PostAnalyticalControlledImportanceSampling
    __del__ = lambda self : None;
PostAnalyticalControlledImportanceSampling_swigregister = _simulation.PostAnalyticalControlledImportanceSampling_swigregister
PostAnalyticalControlledImportanceSampling_swigregister(PostAnalyticalControlledImportanceSampling)

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

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

    def __repr__(self): return _simulation.PostAnalyticalImportanceSampling___repr__(self)
    def __init__(self, *args): 
        this = _simulation.new_PostAnalyticalImportanceSampling(*args)
        try: self.this.append(this)
        except: self.this = this
    __swig_destroy__ = _simulation.delete_PostAnalyticalImportanceSampling
    __del__ = lambda self : None;
PostAnalyticalImportanceSampling_swigregister = _simulation.PostAnalyticalImportanceSampling_swigregister
PostAnalyticalImportanceSampling_swigregister(PostAnalyticalImportanceSampling)

class RootStrategyImplementation(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, RootStrategyImplementation, name, value)
    __swig_getmethods__ = {}
    for _s in [openturns.common.PersistentObject]: __swig_getmethods__.update(getattr(_s,'__swig_getmethods__',{}))
    __getattr__ = lambda self, name: _swig_getattr(self, RootStrategyImplementation, name)
    def getClassName(self):
        """
        Accessor to the object's name.

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

    def solve(self, *args): return _simulation.RootStrategyImplementation_solve(self, *args)
    def setSolver(self, *args): return _simulation.RootStrategyImplementation_setSolver(self, *args)
    def getSolver(self): return _simulation.RootStrategyImplementation_getSolver(self)
    def setMaximumDistance(self, *args): return _simulation.RootStrategyImplementation_setMaximumDistance(self, *args)
    def getMaximumDistance(self): return _simulation.RootStrategyImplementation_getMaximumDistance(self)
    def setStepSize(self, *args): return _simulation.RootStrategyImplementation_setStepSize(self, *args)
    def getStepSize(self): return _simulation.RootStrategyImplementation_getStepSize(self)
    def setOriginValue(self, *args): return _simulation.RootStrategyImplementation_setOriginValue(self, *args)
    def getOriginValue(self): return _simulation.RootStrategyImplementation_getOriginValue(self)
    def __repr__(self): return _simulation.RootStrategyImplementation___repr__(self)
    def __init__(self, *args): 
        this = _simulation.new_RootStrategyImplementation(*args)
        try: self.this.append(this)
        except: self.this = this
    __swig_destroy__ = _simulation.delete_RootStrategyImplementation
    __del__ = lambda self : None;
RootStrategyImplementation_swigregister = _simulation.RootStrategyImplementation_swigregister
RootStrategyImplementation_swigregister(RootStrategyImplementation)

class RootStrategyImplementationTypedInterfaceObject(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, RootStrategyImplementationTypedInterfaceObject, name, value)
    __swig_getmethods__ = {}
    for _s in [openturns.common.InterfaceObject]: __swig_getmethods__.update(getattr(_s,'__swig_getmethods__',{}))
    __getattr__ = lambda self, name: _swig_getattr(self, RootStrategyImplementationTypedInterfaceObject, name)
    __repr__ = _swig_repr
    def __init__(self, *args): 
        this = _simulation.new_RootStrategyImplementationTypedInterfaceObject(*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 _simulation.RootStrategyImplementationTypedInterfaceObject_getImplementation(self, *args)

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

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

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

        Returns
        -------
        name : string
            The name of the object.
        """
        return _simulation.RootStrategyImplementationTypedInterfaceObject_getName(self)

    def __eq__(self, *args): return _simulation.RootStrategyImplementationTypedInterfaceObject___eq__(self, *args)
    __swig_destroy__ = _simulation.delete_RootStrategyImplementationTypedInterfaceObject
    __del__ = lambda self : None;
RootStrategyImplementationTypedInterfaceObject_swigregister = _simulation.RootStrategyImplementationTypedInterfaceObject_swigregister
RootStrategyImplementationTypedInterfaceObject_swigregister(RootStrategyImplementationTypedInterfaceObject)

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

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

    def solve(self, *args): return _simulation.RootStrategy_solve(self, *args)
    def setSolver(self, *args): return _simulation.RootStrategy_setSolver(self, *args)
    def getSolver(self): return _simulation.RootStrategy_getSolver(self)
    def setMaximumDistance(self, *args): return _simulation.RootStrategy_setMaximumDistance(self, *args)
    def getMaximumDistance(self): return _simulation.RootStrategy_getMaximumDistance(self)
    def setStepSize(self, *args): return _simulation.RootStrategy_setStepSize(self, *args)
    def getStepSize(self): return _simulation.RootStrategy_getStepSize(self)
    def setOriginValue(self, *args): return _simulation.RootStrategy_setOriginValue(self, *args)
    def getOriginValue(self): return _simulation.RootStrategy_getOriginValue(self)
    def __repr__(self): return _simulation.RootStrategy___repr__(self)
    def __init__(self, *args): 
        this = _simulation.new_RootStrategy(*args)
        try: self.this.append(this)
        except: self.this = this
    __swig_destroy__ = _simulation.delete_RootStrategy
    __del__ = lambda self : None;
RootStrategy_swigregister = _simulation.RootStrategy_swigregister
RootStrategy_swigregister(RootStrategy)

class SamplingStrategyImplementation(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, SamplingStrategyImplementation, name, value)
    __swig_getmethods__ = {}
    for _s in [openturns.common.PersistentObject]: __swig_getmethods__.update(getattr(_s,'__swig_getmethods__',{}))
    __getattr__ = lambda self, name: _swig_getattr(self, SamplingStrategyImplementation, name)
    def getClassName(self):
        """
        Accessor to the object's name.

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

    def generate(self): return _simulation.SamplingStrategyImplementation_generate(self)
    def getUniformUnitVectorRealization(self, *args): return _simulation.SamplingStrategyImplementation_getUniformUnitVectorRealization(self, *args)
    def setDimension(self, *args): return _simulation.SamplingStrategyImplementation_setDimension(self, *args)
    def getDimension(self): return _simulation.SamplingStrategyImplementation_getDimension(self)
    def __repr__(self): return _simulation.SamplingStrategyImplementation___repr__(self)
    def __init__(self, *args): 
        this = _simulation.new_SamplingStrategyImplementation(*args)
        try: self.this.append(this)
        except: self.this = this
    __swig_destroy__ = _simulation.delete_SamplingStrategyImplementation
    __del__ = lambda self : None;
SamplingStrategyImplementation_swigregister = _simulation.SamplingStrategyImplementation_swigregister
SamplingStrategyImplementation_swigregister(SamplingStrategyImplementation)

class SamplingStrategyImplementationTypedInterfaceObject(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, SamplingStrategyImplementationTypedInterfaceObject, name, value)
    __swig_getmethods__ = {}
    for _s in [openturns.common.InterfaceObject]: __swig_getmethods__.update(getattr(_s,'__swig_getmethods__',{}))
    __getattr__ = lambda self, name: _swig_getattr(self, SamplingStrategyImplementationTypedInterfaceObject, name)
    __repr__ = _swig_repr
    def __init__(self, *args): 
        this = _simulation.new_SamplingStrategyImplementationTypedInterfaceObject(*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 _simulation.SamplingStrategyImplementationTypedInterfaceObject_getImplementation(self, *args)

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

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

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

        Returns
        -------
        name : string
            The name of the object.
        """
        return _simulation.SamplingStrategyImplementationTypedInterfaceObject_getName(self)

    def __eq__(self, *args): return _simulation.SamplingStrategyImplementationTypedInterfaceObject___eq__(self, *args)
    __swig_destroy__ = _simulation.delete_SamplingStrategyImplementationTypedInterfaceObject
    __del__ = lambda self : None;
SamplingStrategyImplementationTypedInterfaceObject_swigregister = _simulation.SamplingStrategyImplementationTypedInterfaceObject_swigregister
SamplingStrategyImplementationTypedInterfaceObject_swigregister(SamplingStrategyImplementationTypedInterfaceObject)

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

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

    def generate(self): return _simulation.SamplingStrategy_generate(self)
    def setDimension(self, *args): return _simulation.SamplingStrategy_setDimension(self, *args)
    def getDimension(self): return _simulation.SamplingStrategy_getDimension(self)
    def __repr__(self): return _simulation.SamplingStrategy___repr__(self)
    def __init__(self, *args): 
        this = _simulation.new_SamplingStrategy(*args)
        try: self.this.append(this)
        except: self.this = this
    __swig_destroy__ = _simulation.delete_SamplingStrategy
    __del__ = lambda self : None;
SamplingStrategy_swigregister = _simulation.SamplingStrategy_swigregister
SamplingStrategy_swigregister(SamplingStrategy)

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

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

    def setRootStrategy(self, *args): return _simulation.DirectionalSampling_setRootStrategy(self, *args)
    def getRootStrategy(self): return _simulation.DirectionalSampling_getRootStrategy(self)
    def setSamplingStrategy(self, *args): return _simulation.DirectionalSampling_setSamplingStrategy(self, *args)
    def getSamplingStrategy(self): return _simulation.DirectionalSampling_getSamplingStrategy(self)
    def __repr__(self): return _simulation.DirectionalSampling___repr__(self)
    def __init__(self, *args): 
        this = _simulation.new_DirectionalSampling(*args)
        try: self.this.append(this)
        except: self.this = this
    __swig_destroy__ = _simulation.delete_DirectionalSampling
    __del__ = lambda self : None;
DirectionalSampling_swigregister = _simulation.DirectionalSampling_swigregister
DirectionalSampling_swigregister(DirectionalSampling)

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

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

    def generate(self): return _simulation.OrthogonalDirection_generate(self)
    def __repr__(self): return _simulation.OrthogonalDirection___repr__(self)
    def getUniformOrientationRealization(self): return _simulation.OrthogonalDirection_getUniformOrientationRealization(self)
    def __init__(self, *args): 
        this = _simulation.new_OrthogonalDirection(*args)
        try: self.this.append(this)
        except: self.this = this
    __swig_destroy__ = _simulation.delete_OrthogonalDirection
    __del__ = lambda self : None;
OrthogonalDirection_swigregister = _simulation.OrthogonalDirection_swigregister
OrthogonalDirection_swigregister(OrthogonalDirection)

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

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

    def generate(self): return _simulation.RandomDirection_generate(self)
    def __repr__(self): return _simulation.RandomDirection___repr__(self)
    def __init__(self, *args): 
        this = _simulation.new_RandomDirection(*args)
        try: self.this.append(this)
        except: self.this = this
    __swig_destroy__ = _simulation.delete_RandomDirection
    __del__ = lambda self : None;
RandomDirection_swigregister = _simulation.RandomDirection_swigregister
RandomDirection_swigregister(RandomDirection)

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

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

    def solve(self, *args): return _simulation.MediumSafe_solve(self, *args)
    def __repr__(self): return _simulation.MediumSafe___repr__(self)
    def __init__(self, *args): 
        this = _simulation.new_MediumSafe(*args)
        try: self.this.append(this)
        except: self.this = this
    __swig_destroy__ = _simulation.delete_MediumSafe
    __del__ = lambda self : None;
MediumSafe_swigregister = _simulation.MediumSafe_swigregister
MediumSafe_swigregister(MediumSafe)

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

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

    def solve(self, *args): return _simulation.RiskyAndFast_solve(self, *args)
    def __repr__(self): return _simulation.RiskyAndFast___repr__(self)
    def __init__(self, *args): 
        this = _simulation.new_RiskyAndFast(*args)
        try: self.this.append(this)
        except: self.this = this
    __swig_destroy__ = _simulation.delete_RiskyAndFast
    __del__ = lambda self : None;
RiskyAndFast_swigregister = _simulation.RiskyAndFast_swigregister
RiskyAndFast_swigregister(RiskyAndFast)

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

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

    def solve(self, *args): return _simulation.SafeAndSlow_solve(self, *args)
    def __repr__(self): return _simulation.SafeAndSlow___repr__(self)
    def __init__(self, *args): 
        this = _simulation.new_SafeAndSlow(*args)
        try: self.this.append(this)
        except: self.this = this
    __swig_destroy__ = _simulation.delete_SafeAndSlow
    __del__ = lambda self : None;
SafeAndSlow_swigregister = _simulation.SafeAndSlow_swigregister
SafeAndSlow_swigregister(SafeAndSlow)

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

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

    def __repr__(self): return _simulation.QuasiMonteCarlo___repr__(self)
    def __init__(self, *args): 
        this = _simulation.new_QuasiMonteCarlo(*args)
        try: self.this.append(this)
        except: self.this = this
    __swig_destroy__ = _simulation.delete_QuasiMonteCarlo
    __del__ = lambda self : None;
QuasiMonteCarlo_swigregister = _simulation.QuasiMonteCarlo_swigregister
QuasiMonteCarlo_swigregister(QuasiMonteCarlo)

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

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

    def __repr__(self): return _simulation.RandomizedQuasiMonteCarlo___repr__(self)
    def __init__(self, *args): 
        this = _simulation.new_RandomizedQuasiMonteCarlo(*args)
        try: self.this.append(this)
        except: self.this = this
    __swig_destroy__ = _simulation.delete_RandomizedQuasiMonteCarlo
    __del__ = lambda self : None;
RandomizedQuasiMonteCarlo_swigregister = _simulation.RandomizedQuasiMonteCarlo_swigregister
RandomizedQuasiMonteCarlo_swigregister(RandomizedQuasiMonteCarlo)

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

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

    def getCoefficientOfVariation(self):
        """
        Accessor to the coefficient of variation.

        Returns
        -------
        coefficient : float
            Coefficient of variation of the simulated sample which is equal to
            :math:`\\sqrt{Var_e} / P_e` with :math:`Var_e` the variance estimate and
            :math:`P_e` the probability estimate.
        """
        return _simulation.QuasiMonteCarloResult_getCoefficientOfVariation(self)

    def getStandardDeviation(self):
        """
        Accessor to the standard deviation.

        Returns
        -------
        sigma : float
            Standard deviation of the estimator at the end of the simulation.
        """
        return _simulation.QuasiMonteCarloResult_getStandardDeviation(self)

    def getConfidenceLength(self, *args):
        """
        Accessor to the confidence length.

        Parameters
        ----------
        level : float, :math:`level \\in ]0, 1[`
            Confidence level. By default, it is :math:`0.95`.

        Returns
        -------
        confidenceLength : float
            Length of the confidence interval at the confidence level *level*.
        """
        return _simulation.QuasiMonteCarloResult_getConfidenceLength(self, *args)

    def __repr__(self): return _simulation.QuasiMonteCarloResult___repr__(self)
    def __init__(self, *args): 
        this = _simulation.new_QuasiMonteCarloResult(*args)
        try: self.this.append(this)
        except: self.this = this
    __swig_destroy__ = _simulation.delete_QuasiMonteCarloResult
    __del__ = lambda self : None;
QuasiMonteCarloResult_swigregister = _simulation.QuasiMonteCarloResult_swigregister
QuasiMonteCarloResult_swigregister(QuasiMonteCarloResult)

class SimulationSensitivityAnalysis(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, SimulationSensitivityAnalysis, name, value)
    __swig_getmethods__ = {}
    for _s in [openturns.common.PersistentObject]: __swig_getmethods__.update(getattr(_s,'__swig_getmethods__',{}))
    __getattr__ = lambda self, name: _swig_getattr(self, SimulationSensitivityAnalysis, name)
    def getClassName(self):
        """
        Accessor to the object's name.

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

    def computeMeanPointInEventDomain(self, *args): return _simulation.SimulationSensitivityAnalysis_computeMeanPointInEventDomain(self, *args)
    def computeImportanceFactors(self, *args): return _simulation.SimulationSensitivityAnalysis_computeImportanceFactors(self, *args)
    def drawImportanceFactors(self): return _simulation.SimulationSensitivityAnalysis_drawImportanceFactors(self)
    def drawImportanceFactorsRange(self, *args): return _simulation.SimulationSensitivityAnalysis_drawImportanceFactorsRange(self, *args)
    def getInputSample(self): return _simulation.SimulationSensitivityAnalysis_getInputSample(self)
    def getOutputSample(self): return _simulation.SimulationSensitivityAnalysis_getOutputSample(self)
    def getThreshold(self): return _simulation.SimulationSensitivityAnalysis_getThreshold(self)
    def setThreshold(self, *args): return _simulation.SimulationSensitivityAnalysis_setThreshold(self, *args)
    def getTransformation(self): return _simulation.SimulationSensitivityAnalysis_getTransformation(self)
    def getComparisonOperator(self): return _simulation.SimulationSensitivityAnalysis_getComparisonOperator(self)
    def setComparisonOperator(self, *args): return _simulation.SimulationSensitivityAnalysis_setComparisonOperator(self, *args)
    def __repr__(self): return _simulation.SimulationSensitivityAnalysis___repr__(self)
    def __init__(self, *args): 
        this = _simulation.new_SimulationSensitivityAnalysis(*args)
        try: self.this.append(this)
        except: self.this = this
    __swig_destroy__ = _simulation.delete_SimulationSensitivityAnalysis
    __del__ = lambda self : None;
SimulationSensitivityAnalysis_swigregister = _simulation.SimulationSensitivityAnalysis_swigregister
SimulationSensitivityAnalysis_swigregister(SimulationSensitivityAnalysis)

class RootStrategyImplementationPointer(_object):
    __swig_setmethods__ = {}
    __setattr__ = lambda self, name, value: _swig_setattr(self, RootStrategyImplementationPointer, name, value)
    __swig_getmethods__ = {}
    __getattr__ = lambda self, name: _swig_getattr(self, RootStrategyImplementationPointer, name)
    __swig_setmethods__["ptr_"] = _simulation.RootStrategyImplementationPointer_ptr__set
    __swig_getmethods__["ptr_"] = _simulation.RootStrategyImplementationPointer_ptr__get
    if _newclass:ptr_ = _swig_property(_simulation.RootStrategyImplementationPointer_ptr__get, _simulation.RootStrategyImplementationPointer_ptr__set)
    def __init__(self, *args): 
        this = _simulation.new_RootStrategyImplementationPointer(*args)
        try: self.this.append(this)
        except: self.this = this
    __swig_destroy__ = _simulation.delete_RootStrategyImplementationPointer
    __del__ = lambda self : None;
    def reset(self): return _simulation.RootStrategyImplementationPointer_reset(self)
    def __ref__(self, *args): return _simulation.RootStrategyImplementationPointer___ref__(self, *args)
    def __deref__(self): return _simulation.RootStrategyImplementationPointer___deref__(self)
    def isNull(self): return _simulation.RootStrategyImplementationPointer_isNull(self)
    def __nonzero__(self):
        return _simulation.RootStrategyImplementationPointer___nonzero__(self)
    __bool__ = __nonzero__


    def get(self): return _simulation.RootStrategyImplementationPointer_get(self)
    def getImplementation(self): return _simulation.RootStrategyImplementationPointer_getImplementation(self)
    def unique(self): return _simulation.RootStrategyImplementationPointer_unique(self)
    def use_count(self): return _simulation.RootStrategyImplementationPointer_use_count(self)
    def swap(self, *args): return _simulation.RootStrategyImplementationPointer_swap(self, *args)
    def getClassName(self):
        """
        Accessor to the object's name.

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

    def solve(self, *args): return _simulation.RootStrategyImplementationPointer_solve(self, *args)
    def setSolver(self, *args): return _simulation.RootStrategyImplementationPointer_setSolver(self, *args)
    def getSolver(self): return _simulation.RootStrategyImplementationPointer_getSolver(self)
    def setMaximumDistance(self, *args): return _simulation.RootStrategyImplementationPointer_setMaximumDistance(self, *args)
    def getMaximumDistance(self): return _simulation.RootStrategyImplementationPointer_getMaximumDistance(self)
    def setStepSize(self, *args): return _simulation.RootStrategyImplementationPointer_setStepSize(self, *args)
    def getStepSize(self): return _simulation.RootStrategyImplementationPointer_getStepSize(self)
    def setOriginValue(self, *args): return _simulation.RootStrategyImplementationPointer_setOriginValue(self, *args)
    def getOriginValue(self): return _simulation.RootStrategyImplementationPointer_getOriginValue(self)
    def __repr__(self): return _simulation.RootStrategyImplementationPointer___repr__(self)
    def __eq__(self, *args): return _simulation.RootStrategyImplementationPointer___eq__(self, *args)
    def __ne__(self, *args): return _simulation.RootStrategyImplementationPointer___ne__(self, *args)
    def __str__(self, offset=""): return _simulation.RootStrategyImplementationPointer___str__(self, offset)
    def getId(self):
        """
        Accessor to the object's id.

        Returns
        -------
        id : int
           Internal unique identifier.
        """
        return _simulation.RootStrategyImplementationPointer_getId(self)

    def setShadowedId(self, *args):
        """
        Accessor to the object's shadowed id.

        Parameters
        ----------
        id : int
            Internal unique identifier.
        """
        return _simulation.RootStrategyImplementationPointer_setShadowedId(self, *args)

    def getShadowedId(self):
        """
        Accessor to the object's shadowed id.

        Returns
        -------
        id : int
            Internal unique identifier.
        """
        return _simulation.RootStrategyImplementationPointer_getShadowedId(self)

    def setVisibility(self, *args):
        """
        Accessor to the object's visibility state.

        Parameters
        ----------
        visible : bool
            Visibility flag.
        """
        return _simulation.RootStrategyImplementationPointer_setVisibility(self, *args)

    def getVisibility(self):
        """
        Accessor to the object's visibility state.

        Returns
        -------
        visible : bool
            Visibility flag.
        """
        return _simulation.RootStrategyImplementationPointer_getVisibility(self)

    def hasName(self):
        """
        Test if the object is named.

        Returns
        -------
        hasName : bool
            True if the name is not empty.
        """
        return _simulation.RootStrategyImplementationPointer_hasName(self)

    def hasVisibleName(self):
        """
        Test if the object has a distinghishable name.

        Returns
        -------
        hasVisibleName : bool
            True if the name is not empty and not the default one.
        """
        return _simulation.RootStrategyImplementationPointer_hasVisibleName(self)

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

        Returns
        -------
        name : string
            The name of the object.
        """
        return _simulation.RootStrategyImplementationPointer_getName(self)

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

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

RootStrategyImplementationPointer_swigregister = _simulation.RootStrategyImplementationPointer_swigregister
RootStrategyImplementationPointer_swigregister(RootStrategyImplementationPointer)

class SamplingStrategyImplementationPointer(_object):
    __swig_setmethods__ = {}
    __setattr__ = lambda self, name, value: _swig_setattr(self, SamplingStrategyImplementationPointer, name, value)
    __swig_getmethods__ = {}
    __getattr__ = lambda self, name: _swig_getattr(self, SamplingStrategyImplementationPointer, name)
    __swig_setmethods__["ptr_"] = _simulation.SamplingStrategyImplementationPointer_ptr__set
    __swig_getmethods__["ptr_"] = _simulation.SamplingStrategyImplementationPointer_ptr__get
    if _newclass:ptr_ = _swig_property(_simulation.SamplingStrategyImplementationPointer_ptr__get, _simulation.SamplingStrategyImplementationPointer_ptr__set)
    def __init__(self, *args): 
        this = _simulation.new_SamplingStrategyImplementationPointer(*args)
        try: self.this.append(this)
        except: self.this = this
    __swig_destroy__ = _simulation.delete_SamplingStrategyImplementationPointer
    __del__ = lambda self : None;
    def reset(self): return _simulation.SamplingStrategyImplementationPointer_reset(self)
    def __ref__(self, *args): return _simulation.SamplingStrategyImplementationPointer___ref__(self, *args)
    def __deref__(self): return _simulation.SamplingStrategyImplementationPointer___deref__(self)
    def isNull(self): return _simulation.SamplingStrategyImplementationPointer_isNull(self)
    def __nonzero__(self):
        return _simulation.SamplingStrategyImplementationPointer___nonzero__(self)
    __bool__ = __nonzero__


    def get(self): return _simulation.SamplingStrategyImplementationPointer_get(self)
    def getImplementation(self): return _simulation.SamplingStrategyImplementationPointer_getImplementation(self)
    def unique(self): return _simulation.SamplingStrategyImplementationPointer_unique(self)
    def use_count(self): return _simulation.SamplingStrategyImplementationPointer_use_count(self)
    def swap(self, *args): return _simulation.SamplingStrategyImplementationPointer_swap(self, *args)
    def getClassName(self):
        """
        Accessor to the object's name.

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

    def generate(self): return _simulation.SamplingStrategyImplementationPointer_generate(self)
    def getUniformUnitVectorRealization(self, *args): return _simulation.SamplingStrategyImplementationPointer_getUniformUnitVectorRealization(self, *args)
    def setDimension(self, *args): return _simulation.SamplingStrategyImplementationPointer_setDimension(self, *args)
    def getDimension(self): return _simulation.SamplingStrategyImplementationPointer_getDimension(self)
    def __repr__(self): return _simulation.SamplingStrategyImplementationPointer___repr__(self)
    def __eq__(self, *args): return _simulation.SamplingStrategyImplementationPointer___eq__(self, *args)
    def __ne__(self, *args): return _simulation.SamplingStrategyImplementationPointer___ne__(self, *args)
    def __str__(self, offset=""): return _simulation.SamplingStrategyImplementationPointer___str__(self, offset)
    def getId(self):
        """
        Accessor to the object's id.

        Returns
        -------
        id : int
           Internal unique identifier.
        """
        return _simulation.SamplingStrategyImplementationPointer_getId(self)

    def setShadowedId(self, *args):
        """
        Accessor to the object's shadowed id.

        Parameters
        ----------
        id : int
            Internal unique identifier.
        """
        return _simulation.SamplingStrategyImplementationPointer_setShadowedId(self, *args)

    def getShadowedId(self):
        """
        Accessor to the object's shadowed id.

        Returns
        -------
        id : int
            Internal unique identifier.
        """
        return _simulation.SamplingStrategyImplementationPointer_getShadowedId(self)

    def setVisibility(self, *args):
        """
        Accessor to the object's visibility state.

        Parameters
        ----------
        visible : bool
            Visibility flag.
        """
        return _simulation.SamplingStrategyImplementationPointer_setVisibility(self, *args)

    def getVisibility(self):
        """
        Accessor to the object's visibility state.

        Returns
        -------
        visible : bool
            Visibility flag.
        """
        return _simulation.SamplingStrategyImplementationPointer_getVisibility(self)

    def hasName(self):
        """
        Test if the object is named.

        Returns
        -------
        hasName : bool
            True if the name is not empty.
        """
        return _simulation.SamplingStrategyImplementationPointer_hasName(self)

    def hasVisibleName(self):
        """
        Test if the object has a distinghishable name.

        Returns
        -------
        hasVisibleName : bool
            True if the name is not empty and not the default one.
        """
        return _simulation.SamplingStrategyImplementationPointer_hasVisibleName(self)

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

        Returns
        -------
        name : string
            The name of the object.
        """
        return _simulation.SamplingStrategyImplementationPointer_getName(self)

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

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

SamplingStrategyImplementationPointer_swigregister = _simulation.SamplingStrategyImplementationPointer_swigregister
SamplingStrategyImplementationPointer_swigregister(SamplingStrategyImplementationPointer)

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