python-openturns 1.3-3 / usr / lib / python2.7 / 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):
    """Proxy of C++ swig::SwigPyIterator class"""
    __swig_setmethods__ = {}
    __setattr__ = lambda self, name, value: _swig_setattr(self, SwigPyIterator, name, value)
    __swig_getmethods__ = {}
    __getattr__ = lambda self, name: _swig_getattr(self, SwigPyIterator, name)
    def __init__(self, *args, **kwargs): raise AttributeError("No constructor defined - class is abstract")
    __repr__ = _swig_repr
    __swig_destroy__ = _simulation.delete_SwigPyIterator
    __del__ = lambda self : None;
    def value(self):
        """value(SwigPyIterator self) -> PyObject *"""
        return _simulation.SwigPyIterator_value(self)

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

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

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

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

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

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

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

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

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

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

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

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

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

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

    def __sub__(self, *args):
        """
        __sub__(SwigPyIterator self, ptrdiff_t n) -> SwigPyIterator
        __sub__(SwigPyIterator self, SwigPyIterator x) -> ptrdiff_t
        """
        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.common
import openturns.typ
import openturns.wrapper
class TestResult(openturns.common.PersistentObject):
    """Proxy of C++ OT::TestResult class"""
    __swig_setmethods__ = {}
    for _s in [openturns.common.PersistentObject]: __swig_setmethods__.update(getattr(_s,'__swig_setmethods__',{}))
    __setattr__ = lambda self, name, value: _swig_setattr(self, TestResult, name, value)
    __swig_getmethods__ = {}
    for _s in [openturns.common.PersistentObject]: __swig_getmethods__.update(getattr(_s,'__swig_getmethods__',{}))
    __getattr__ = lambda self, name: _swig_getattr(self, TestResult, name)
    def GetClassName():
        """GetClassName() -> OT::String"""
        return _simulation.TestResult_GetClassName()

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

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

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

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

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

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

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

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

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

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

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

import openturns.base
import openturns.statistics
import openturns.graph
import openturns.func
import openturns.geom
import openturns.diff
import openturns.optim
import openturns.solver
import openturns.algo
import openturns.experiment
import openturns.model_copula
import openturns.transformation
import openturns.analytical
import openturns.metamodel
import openturns.weightedexperiment
import openturns.orthogonalbasis
import openturns.randomvector
class SimulationResultImplementation(openturns.common.PersistentObject):
    """Proxy of C++ OT::SimulationResultImplementation class"""
    __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():
        """GetClassName() -> OT::String"""
        return _simulation.SimulationResultImplementation_GetClassName()

    if _newclass:GetClassName = staticmethod(GetClassName)
    __swig_getmethods__["GetClassName"] = lambda x: GetClassName
    def getClassName(self):
        """getClassName(SimulationResultImplementation self) -> OT::String"""
        return _simulation.SimulationResultImplementation_getClassName(self)

    def getEvent(self):
        """getEvent(SimulationResultImplementation self) -> Event"""
        return _simulation.SimulationResultImplementation_getEvent(self)

    def setEvent(self, *args):
        """setEvent(SimulationResultImplementation self, Event event)"""
        return _simulation.SimulationResultImplementation_setEvent(self, *args)

    def getProbabilityEstimate(self):
        """getProbabilityEstimate(SimulationResultImplementation self) -> OT::NumericalScalar"""
        return _simulation.SimulationResultImplementation_getProbabilityEstimate(self)

    def setProbabilityEstimate(self, *args):
        """setProbabilityEstimate(SimulationResultImplementation self, OT::NumericalScalar const probabilityEstimate)"""
        return _simulation.SimulationResultImplementation_setProbabilityEstimate(self, *args)

    def getVarianceEstimate(self):
        """getVarianceEstimate(SimulationResultImplementation self) -> OT::NumericalScalar"""
        return _simulation.SimulationResultImplementation_getVarianceEstimate(self)

    def setVarianceEstimate(self, *args):
        """setVarianceEstimate(SimulationResultImplementation self, OT::NumericalScalar const varianceEstimate)"""
        return _simulation.SimulationResultImplementation_setVarianceEstimate(self, *args)

    def getCoefficientOfVariation(self):
        """getCoefficientOfVariation(SimulationResultImplementation self) -> OT::NumericalScalar"""
        return _simulation.SimulationResultImplementation_getCoefficientOfVariation(self)

    def getStandardDeviation(self):
        """getStandardDeviation(SimulationResultImplementation self) -> OT::NumericalScalar"""
        return _simulation.SimulationResultImplementation_getStandardDeviation(self)

    def getMeanPointInEventDomain(self):
        """getMeanPointInEventDomain(SimulationResultImplementation self) -> NumericalPoint"""
        return _simulation.SimulationResultImplementation_getMeanPointInEventDomain(self)

    def getImportanceFactors(self):
        """getImportanceFactors(SimulationResultImplementation self) -> NumericalPointWithDescription"""
        return _simulation.SimulationResultImplementation_getImportanceFactors(self)

    def drawImportanceFactors(self):
        """drawImportanceFactors(SimulationResultImplementation self) -> Graph"""
        return _simulation.SimulationResultImplementation_drawImportanceFactors(self)

    def getOuterSampling(self):
        """getOuterSampling(SimulationResultImplementation self) -> OT::UnsignedLong"""
        return _simulation.SimulationResultImplementation_getOuterSampling(self)

    def setOuterSampling(self, *args):
        """setOuterSampling(SimulationResultImplementation self, OT::UnsignedLong const outerSampling)"""
        return _simulation.SimulationResultImplementation_setOuterSampling(self, *args)

    def getBlockSize(self):
        """getBlockSize(SimulationResultImplementation self) -> OT::UnsignedLong"""
        return _simulation.SimulationResultImplementation_getBlockSize(self)

    def setBlockSize(self, *args):
        """setBlockSize(SimulationResultImplementation self, OT::UnsignedLong const blockSize)"""
        return _simulation.SimulationResultImplementation_setBlockSize(self, *args)

    def getConfidenceLength(self, *args):
        """
        getConfidenceLength(SimulationResultImplementation self, OT::NumericalScalar const level=OT::ResourceMap::GetAsNumericalScalar( "SimulationResultImplementation-DefaultConfidenceLevel" )) -> OT::NumericalScalar
        getConfidenceLength(SimulationResultImplementation self) -> OT::NumericalScalar
        """
        return _simulation.SimulationResultImplementation_getConfidenceLength(self, *args)

    def __repr__(self):
        """__repr__(SimulationResultImplementation self) -> OT::String"""
        return _simulation.SimulationResultImplementation___repr__(self)

    def __init__(self, *args): 
        """
        __init__(OT::SimulationResultImplementation self) -> SimulationResultImplementation
        __init__(OT::SimulationResultImplementation self, Event event, OT::NumericalScalar const probabilityEstimate, OT::NumericalScalar const varianceEstimate, 
            OT::UnsignedLong const outerSampling, OT::UnsignedLong const blockSize) -> SimulationResultImplementation
        __init__(OT::SimulationResultImplementation self, SimulationResultImplementation other) -> SimulationResultImplementation
        """
        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)

def SimulationResultImplementation_GetClassName():
  """SimulationResultImplementation_GetClassName() -> OT::String"""
  return _simulation.SimulationResultImplementation_GetClassName()

class SimulationResultImplementationTypedInterfaceObject(openturns.common.InterfaceObject):
    """Proxy of C++ OT::TypedInterfaceObject<(OT::SimulationResultImplementation)> class"""
    __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): 
        """
        __init__(OT::TypedInterfaceObject<(OT::SimulationResultImplementation)> self) -> SimulationResultImplementationTypedInterfaceObject
        __init__(OT::TypedInterfaceObject<(OT::SimulationResultImplementation)> self, OT::TypedInterfaceObject< OT::SimulationResultImplementation >::Implementation const & impl) -> SimulationResultImplementationTypedInterfaceObject
        """
        this = _simulation.new_SimulationResultImplementationTypedInterfaceObject(*args)
        try: self.this.append(this)
        except: self.this = this
    def getImplementation(self, *args):
        """
        getImplementation(SimulationResultImplementationTypedInterfaceObject self) -> OT::TypedInterfaceObject< OT::SimulationResultImplementation >::Implementation
        getImplementation(SimulationResultImplementationTypedInterfaceObject self) -> OT::TypedInterfaceObject< OT::SimulationResultImplementation >::Implementation const &
        """
        return _simulation.SimulationResultImplementationTypedInterfaceObject_getImplementation(self, *args)

    def getImplementationAsPersistentObject(self):
        """getImplementationAsPersistentObject(SimulationResultImplementationTypedInterfaceObject self) -> PersistentObjectPointer"""
        return _simulation.SimulationResultImplementationTypedInterfaceObject_getImplementationAsPersistentObject(self)

    def setImplementationAsPersistentObject(self, *args):
        """setImplementationAsPersistentObject(SimulationResultImplementationTypedInterfaceObject self, PersistentObjectPointer obj)"""
        return _simulation.SimulationResultImplementationTypedInterfaceObject_setImplementationAsPersistentObject(self, *args)

    def swap(self, *args):
        """swap(SimulationResultImplementationTypedInterfaceObject self, SimulationResultImplementationTypedInterfaceObject other)"""
        return _simulation.SimulationResultImplementationTypedInterfaceObject_swap(self, *args)

    def setName(self, *args):
        """setName(SimulationResultImplementationTypedInterfaceObject self, OT::String const & name)"""
        return _simulation.SimulationResultImplementationTypedInterfaceObject_setName(self, *args)

    def getName(self):
        """getName(SimulationResultImplementationTypedInterfaceObject self) -> OT::String"""
        return _simulation.SimulationResultImplementationTypedInterfaceObject_getName(self)

    def __eq__(self, *args):
        """__eq__(SimulationResultImplementationTypedInterfaceObject self, SimulationResultImplementationTypedInterfaceObject other) -> OT::Bool"""
        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):
    """Proxy of C++ OT::SimulationResult class"""
    __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():
        """GetClassName() -> OT::String"""
        return _simulation.SimulationResult_GetClassName()

    if _newclass:GetClassName = staticmethod(GetClassName)
    __swig_getmethods__["GetClassName"] = lambda x: GetClassName
    def getClassName(self):
        """getClassName(SimulationResult self) -> OT::String"""
        return _simulation.SimulationResult_getClassName(self)

    def getEvent(self):
        """getEvent(SimulationResult self) -> Event"""
        return _simulation.SimulationResult_getEvent(self)

    def getProbabilityEstimate(self):
        """getProbabilityEstimate(SimulationResult self) -> OT::NumericalScalar"""
        return _simulation.SimulationResult_getProbabilityEstimate(self)

    def setProbabilityEstimate(self, *args):
        """setProbabilityEstimate(SimulationResult self, OT::NumericalScalar const probabilityEstimate)"""
        return _simulation.SimulationResult_setProbabilityEstimate(self, *args)

    def getVarianceEstimate(self):
        """getVarianceEstimate(SimulationResult self) -> OT::NumericalScalar"""
        return _simulation.SimulationResult_getVarianceEstimate(self)

    def setVarianceEstimate(self, *args):
        """setVarianceEstimate(SimulationResult self, OT::NumericalScalar const varianceEstimate)"""
        return _simulation.SimulationResult_setVarianceEstimate(self, *args)

    def getCoefficientOfVariation(self):
        """getCoefficientOfVariation(SimulationResult self) -> OT::NumericalScalar"""
        return _simulation.SimulationResult_getCoefficientOfVariation(self)

    def getStandardDeviation(self):
        """getStandardDeviation(SimulationResult self) -> OT::NumericalScalar"""
        return _simulation.SimulationResult_getStandardDeviation(self)

    def getMeanPointInEventDomain(self):
        """getMeanPointInEventDomain(SimulationResult self) -> NumericalPoint"""
        return _simulation.SimulationResult_getMeanPointInEventDomain(self)

    def getImportanceFactors(self):
        """getImportanceFactors(SimulationResult self) -> NumericalPointWithDescription"""
        return _simulation.SimulationResult_getImportanceFactors(self)

    def drawImportanceFactors(self):
        """drawImportanceFactors(SimulationResult self) -> Graph"""
        return _simulation.SimulationResult_drawImportanceFactors(self)

    def getOuterSampling(self):
        """getOuterSampling(SimulationResult self) -> OT::UnsignedLong"""
        return _simulation.SimulationResult_getOuterSampling(self)

    def setOuterSampling(self, *args):
        """setOuterSampling(SimulationResult self, OT::UnsignedLong const outerSampling)"""
        return _simulation.SimulationResult_setOuterSampling(self, *args)

    def getBlockSize(self):
        """getBlockSize(SimulationResult self) -> OT::UnsignedLong"""
        return _simulation.SimulationResult_getBlockSize(self)

    def setBlockSize(self, *args):
        """setBlockSize(SimulationResult self, OT::UnsignedLong const blockSize)"""
        return _simulation.SimulationResult_setBlockSize(self, *args)

    def getConfidenceLength(self, *args):
        """
        getConfidenceLength(SimulationResult self, OT::NumericalScalar const level=OT::ResourceMap::GetAsNumericalScalar( "SimulationResultImplementation-DefaultConfidenceLevel" )) -> OT::NumericalScalar
        getConfidenceLength(SimulationResult self) -> OT::NumericalScalar
        """
        return _simulation.SimulationResult_getConfidenceLength(self, *args)

    def __repr__(self):
        """__repr__(SimulationResult self) -> OT::String"""
        return _simulation.SimulationResult___repr__(self)

    def __init__(self, *args): 
        """
        __init__(OT::SimulationResult self) -> SimulationResult
        __init__(OT::SimulationResult self, Event event, OT::NumericalScalar const probabilityEstimate, OT::NumericalScalar const varianceEstimate, 
            OT::UnsignedLong const outerSampling, OT::UnsignedLong const blockSize) -> SimulationResult
        __init__(OT::SimulationResult self, SimulationResultImplementation implementation) -> SimulationResult
        __init__(OT::SimulationResult self, OT::SimulationResult::Implementation & p_implementation) -> SimulationResult
        __init__(OT::SimulationResult self, SimulationResult other) -> SimulationResult
        """
        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)

def SimulationResult_GetClassName():
  """SimulationResult_GetClassName() -> OT::String"""
  return _simulation.SimulationResult_GetClassName()

class Simulation(openturns.common.PersistentObject):
    """Proxy of C++ OT::Simulation class"""
    __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():
        """GetClassName() -> OT::String"""
        return _simulation.Simulation_GetClassName()

    if _newclass:GetClassName = staticmethod(GetClassName)
    __swig_getmethods__["GetClassName"] = lambda x: GetClassName
    def getClassName(self):
        """getClassName(Simulation self) -> OT::String"""
        return _simulation.Simulation_getClassName(self)

    def getEvent(self):
        """getEvent(Simulation self) -> Event"""
        return _simulation.Simulation_getEvent(self)

    def getResult(self):
        """getResult(Simulation self) -> SimulationResult"""
        return _simulation.Simulation_getResult(self)

    def setMaximumOuterSampling(self, *args):
        """setMaximumOuterSampling(Simulation self, OT::UnsignedLong const maximumOuterSampling)"""
        return _simulation.Simulation_setMaximumOuterSampling(self, *args)

    def getMaximumOuterSampling(self):
        """getMaximumOuterSampling(Simulation self) -> OT::UnsignedLong"""
        return _simulation.Simulation_getMaximumOuterSampling(self)

    def setMaximumCoefficientOfVariation(self, *args):
        """setMaximumCoefficientOfVariation(Simulation self, OT::NumericalScalar const maximumCoefficientOfVariation)"""
        return _simulation.Simulation_setMaximumCoefficientOfVariation(self, *args)

    def getMaximumCoefficientOfVariation(self):
        """getMaximumCoefficientOfVariation(Simulation self) -> OT::NumericalScalar"""
        return _simulation.Simulation_getMaximumCoefficientOfVariation(self)

    def setMaximumStandardDeviation(self, *args):
        """setMaximumStandardDeviation(Simulation self, OT::NumericalScalar const maximumStandardDeviation)"""
        return _simulation.Simulation_setMaximumStandardDeviation(self, *args)

    def getMaximumStandardDeviation(self):
        """getMaximumStandardDeviation(Simulation self) -> OT::NumericalScalar"""
        return _simulation.Simulation_getMaximumStandardDeviation(self)

    def setBlockSize(self, *args):
        """setBlockSize(Simulation self, OT::UnsignedLong const blockSize)"""
        return _simulation.Simulation_setBlockSize(self, *args)

    def getBlockSize(self):
        """getBlockSize(Simulation self) -> OT::UnsignedLong"""
        return _simulation.Simulation_getBlockSize(self)

    def setVerbose(self, *args):
        """setVerbose(Simulation self, OT::Bool const verbose)"""
        return _simulation.Simulation_setVerbose(self, *args)

    def getVerbose(self):
        """getVerbose(Simulation self) -> OT::Bool"""
        return _simulation.Simulation_getVerbose(self)

    def setConvergenceStrategy(self, *args):
        """setConvergenceStrategy(Simulation self, HistoryStrategy convergenceStrategy)"""
        return _simulation.Simulation_setConvergenceStrategy(self, *args)

    def getConvergenceStrategy(self):
        """getConvergenceStrategy(Simulation self) -> HistoryStrategy"""
        return _simulation.Simulation_getConvergenceStrategy(self)

    def __repr__(self):
        """__repr__(Simulation self) -> OT::String"""
        return _simulation.Simulation___repr__(self)

    def run(self):
        """run(Simulation self)"""
        return _simulation.Simulation_run(self)

    def drawProbabilityConvergence(self, *args):
        """
        drawProbabilityConvergence(Simulation self, OT::NumericalScalar const level=OT::ResourceMap::GetAsNumericalScalar( "SimulationResultImplementation-DefaultConfidenceLevel" )) -> Graph
        drawProbabilityConvergence(Simulation self) -> Graph
        """
        return _simulation.Simulation_drawProbabilityConvergence(self, *args)

    def __init__(self, *args): 
        """
        __init__(OT::Simulation self, Event event, OT::Bool const verbose=True, HistoryStrategy convergenceStrategy=OT::Compact()) -> Simulation
        __init__(OT::Simulation self, Event event, OT::Bool const verbose=True) -> Simulation
        __init__(OT::Simulation self, Event event) -> Simulation
        __init__(OT::Simulation self, Simulation other) -> Simulation
        """
        this = _simulation.new_Simulation(*args)
        try: self.this.append(this)
        except: self.this = this
    __swig_destroy__ = _simulation.delete_Simulation
    __del__ = lambda self : None;
Simulation_swigregister = _simulation.Simulation_swigregister
Simulation_swigregister(Simulation)

def Simulation_GetClassName():
  """Simulation_GetClassName() -> OT::String"""
  return _simulation.Simulation_GetClassName()

class PostAnalyticalSimulation(Simulation):
    """Proxy of C++ OT::PostAnalyticalSimulation class"""
    __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():
        """GetClassName() -> OT::String"""
        return _simulation.PostAnalyticalSimulation_GetClassName()

    if _newclass:GetClassName = staticmethod(GetClassName)
    __swig_getmethods__["GetClassName"] = lambda x: GetClassName
    def getClassName(self):
        """getClassName(PostAnalyticalSimulation self) -> OT::String"""
        return _simulation.PostAnalyticalSimulation_getClassName(self)

    def getAnalyticalResult(self):
        """getAnalyticalResult(PostAnalyticalSimulation self) -> AnalyticalResult"""
        return _simulation.PostAnalyticalSimulation_getAnalyticalResult(self)

    def getControlProbability(self):
        """getControlProbability(PostAnalyticalSimulation self) -> OT::NumericalScalar"""
        return _simulation.PostAnalyticalSimulation_getControlProbability(self)

    def __repr__(self):
        """__repr__(PostAnalyticalSimulation self) -> OT::String"""
        return _simulation.PostAnalyticalSimulation___repr__(self)

    def __init__(self, *args): 
        """
        __init__(OT::PostAnalyticalSimulation self, AnalyticalResult analyticalResult) -> PostAnalyticalSimulation
        __init__(OT::PostAnalyticalSimulation self, PostAnalyticalSimulation other) -> PostAnalyticalSimulation
        """
        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)

def PostAnalyticalSimulation_GetClassName():
  """PostAnalyticalSimulation_GetClassName() -> OT::String"""
  return _simulation.PostAnalyticalSimulation_GetClassName()

class Wilks(_object):
    """Proxy of C++ OT::Wilks class"""
    __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
    def ComputeSampleSize(*args):
        """
        ComputeSampleSize(OT::NumericalScalar const quantileLevel, OT::NumericalScalar const confidenceLevel, 
            OT::UnsignedLong const marginIndex=0) -> OT::UnsignedLong
        ComputeSampleSize(OT::NumericalScalar const quantileLevel, OT::NumericalScalar const confidenceLevel) -> OT::UnsignedLong
        """
        return _simulation.Wilks_ComputeSampleSize(*args)

    if _newclass:ComputeSampleSize = staticmethod(ComputeSampleSize)
    __swig_getmethods__["ComputeSampleSize"] = lambda x: ComputeSampleSize
    def computeQuantileBound(self, *args):
        """
        computeQuantileBound(Wilks self, OT::NumericalScalar const quantileLevel, OT::NumericalScalar const confidenceLevel, 
            OT::UnsignedLong const marginIndex=0) -> NumericalPoint
        computeQuantileBound(Wilks self, OT::NumericalScalar const quantileLevel, OT::NumericalScalar const confidenceLevel) -> NumericalPoint
        """
        return _simulation.Wilks_computeQuantileBound(self, *args)

    def __init__(self, *args): 
        """
        __init__(OT::Wilks self, RandomVector vector) -> Wilks
        __init__(OT::Wilks self, Wilks other) -> Wilks
        """
        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):
  """
    ComputeSampleSize(OT::NumericalScalar const quantileLevel, OT::NumericalScalar const confidenceLevel, 
        OT::UnsignedLong const marginIndex=0) -> OT::UnsignedLong
    Wilks_ComputeSampleSize(OT::NumericalScalar const quantileLevel, OT::NumericalScalar const confidenceLevel) -> OT::UnsignedLong
    """
  return _simulation.Wilks_ComputeSampleSize(*args)

class MonteCarlo(Simulation):
    """Proxy of C++ OT::MonteCarlo class"""
    __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():
        """GetClassName() -> OT::String"""
        return _simulation.MonteCarlo_GetClassName()

    if _newclass:GetClassName = staticmethod(GetClassName)
    __swig_getmethods__["GetClassName"] = lambda x: GetClassName
    def getClassName(self):
        """getClassName(MonteCarlo self) -> OT::String"""
        return _simulation.MonteCarlo_getClassName(self)

    def __repr__(self):
        """__repr__(MonteCarlo self) -> OT::String"""
        return _simulation.MonteCarlo___repr__(self)

    def __init__(self, *args): 
        """
        __init__(OT::MonteCarlo self, Event event) -> MonteCarlo
        __init__(OT::MonteCarlo self) -> MonteCarlo
        __init__(OT::MonteCarlo self, MonteCarlo other) -> MonteCarlo
        """
        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)

def MonteCarlo_GetClassName():
  """MonteCarlo_GetClassName() -> OT::String"""
  return _simulation.MonteCarlo_GetClassName()

class LHS(Simulation):
    """Proxy of C++ OT::LHS class"""
    __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():
        """GetClassName() -> OT::String"""
        return _simulation.LHS_GetClassName()

    if _newclass:GetClassName = staticmethod(GetClassName)
    __swig_getmethods__["GetClassName"] = lambda x: GetClassName
    def getClassName(self):
        """getClassName(LHS self) -> OT::String"""
        return _simulation.LHS_getClassName(self)

    def run(self):
        """run(LHS self)"""
        return _simulation.LHS_run(self)

    def __repr__(self):
        """__repr__(LHS self) -> OT::String"""
        return _simulation.LHS___repr__(self)

    def __init__(self, *args): 
        """
        __init__(OT::LHS self) -> LHS
        __init__(OT::LHS self, Event event) -> LHS
        __init__(OT::LHS self, LHS other) -> LHS
        """
        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)

def LHS_GetClassName():
  """LHS_GetClassName() -> OT::String"""
  return _simulation.LHS_GetClassName()

class RandomizedLHS(Simulation):
    """Proxy of C++ OT::RandomizedLHS class"""
    __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():
        """GetClassName() -> OT::String"""
        return _simulation.RandomizedLHS_GetClassName()

    if _newclass:GetClassName = staticmethod(GetClassName)
    __swig_getmethods__["GetClassName"] = lambda x: GetClassName
    def getClassName(self):
        """getClassName(RandomizedLHS self) -> OT::String"""
        return _simulation.RandomizedLHS_getClassName(self)

    def __repr__(self):
        """__repr__(RandomizedLHS self) -> OT::String"""
        return _simulation.RandomizedLHS___repr__(self)

    def __init__(self, *args): 
        """
        __init__(OT::RandomizedLHS self) -> RandomizedLHS
        __init__(OT::RandomizedLHS self, Event event) -> RandomizedLHS
        __init__(OT::RandomizedLHS self, RandomizedLHS other) -> RandomizedLHS
        """
        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)

def RandomizedLHS_GetClassName():
  """RandomizedLHS_GetClassName() -> OT::String"""
  return _simulation.RandomizedLHS_GetClassName()

class ImportanceSampling(Simulation):
    """Proxy of C++ OT::ImportanceSampling class"""
    __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():
        """GetClassName() -> OT::String"""
        return _simulation.ImportanceSampling_GetClassName()

    if _newclass:GetClassName = staticmethod(GetClassName)
    __swig_getmethods__["GetClassName"] = lambda x: GetClassName
    def getClassName(self):
        """getClassName(ImportanceSampling self) -> OT::String"""
        return _simulation.ImportanceSampling_getClassName(self)

    def getImportanceDistribution(self):
        """getImportanceDistribution(ImportanceSampling self) -> Distribution"""
        return _simulation.ImportanceSampling_getImportanceDistribution(self)

    def __repr__(self):
        """__repr__(ImportanceSampling self) -> OT::String"""
        return _simulation.ImportanceSampling___repr__(self)

    def __init__(self, *args): 
        """
        __init__(OT::ImportanceSampling self, Event event, Distribution importanceDistribution) -> ImportanceSampling
        __init__(OT::ImportanceSampling self, ImportanceSampling other) -> ImportanceSampling
        """
        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)

def ImportanceSampling_GetClassName():
  """ImportanceSampling_GetClassName() -> OT::String"""
  return _simulation.ImportanceSampling_GetClassName()

class PostAnalyticalControlledImportanceSampling(PostAnalyticalSimulation):
    """Proxy of C++ OT::PostAnalyticalControlledImportanceSampling class"""
    __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():
        """GetClassName() -> OT::String"""
        return _simulation.PostAnalyticalControlledImportanceSampling_GetClassName()

    if _newclass:GetClassName = staticmethod(GetClassName)
    __swig_getmethods__["GetClassName"] = lambda x: GetClassName
    def getClassName(self):
        """getClassName(PostAnalyticalControlledImportanceSampling self) -> OT::String"""
        return _simulation.PostAnalyticalControlledImportanceSampling_getClassName(self)

    def __repr__(self):
        """__repr__(PostAnalyticalControlledImportanceSampling self) -> OT::String"""
        return _simulation.PostAnalyticalControlledImportanceSampling___repr__(self)

    def computeBlockSample(self):
        """computeBlockSample(PostAnalyticalControlledImportanceSampling self) -> NumericalSample"""
        return _simulation.PostAnalyticalControlledImportanceSampling_computeBlockSample(self)

    def __init__(self, *args): 
        """
        __init__(OT::PostAnalyticalControlledImportanceSampling self, AnalyticalResult AnalyticalResult) -> PostAnalyticalControlledImportanceSampling
        __init__(OT::PostAnalyticalControlledImportanceSampling self, PostAnalyticalControlledImportanceSampling other) -> PostAnalyticalControlledImportanceSampling
        """
        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)

def PostAnalyticalControlledImportanceSampling_GetClassName():
  """PostAnalyticalControlledImportanceSampling_GetClassName() -> OT::String"""
  return _simulation.PostAnalyticalControlledImportanceSampling_GetClassName()

class PostAnalyticalImportanceSampling(PostAnalyticalSimulation):
    """Proxy of C++ OT::PostAnalyticalImportanceSampling class"""
    __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():
        """GetClassName() -> OT::String"""
        return _simulation.PostAnalyticalImportanceSampling_GetClassName()

    if _newclass:GetClassName = staticmethod(GetClassName)
    __swig_getmethods__["GetClassName"] = lambda x: GetClassName
    def getClassName(self):
        """getClassName(PostAnalyticalImportanceSampling self) -> OT::String"""
        return _simulation.PostAnalyticalImportanceSampling_getClassName(self)

    def __repr__(self):
        """__repr__(PostAnalyticalImportanceSampling self) -> OT::String"""
        return _simulation.PostAnalyticalImportanceSampling___repr__(self)

    def __init__(self, *args): 
        """
        __init__(OT::PostAnalyticalImportanceSampling self, AnalyticalResult AnalyticalResult) -> PostAnalyticalImportanceSampling
        __init__(OT::PostAnalyticalImportanceSampling self, PostAnalyticalImportanceSampling other) -> PostAnalyticalImportanceSampling
        """
        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)

def PostAnalyticalImportanceSampling_GetClassName():
  """PostAnalyticalImportanceSampling_GetClassName() -> OT::String"""
  return _simulation.PostAnalyticalImportanceSampling_GetClassName()

class RootStrategyImplementation(openturns.common.PersistentObject):
    """Proxy of C++ OT::RootStrategyImplementation class"""
    __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():
        """GetClassName() -> OT::String"""
        return _simulation.RootStrategyImplementation_GetClassName()

    if _newclass:GetClassName = staticmethod(GetClassName)
    __swig_getmethods__["GetClassName"] = lambda x: GetClassName
    def getClassName(self):
        """getClassName(RootStrategyImplementation self) -> OT::String"""
        return _simulation.RootStrategyImplementation_getClassName(self)

    def solve(self, *args):
        """solve(RootStrategyImplementation self, NumericalMathFunction function, OT::NumericalScalar const value) -> NumericalScalarCollection"""
        return _simulation.RootStrategyImplementation_solve(self, *args)

    def setSolver(self, *args):
        """setSolver(RootStrategyImplementation self, Solver solver)"""
        return _simulation.RootStrategyImplementation_setSolver(self, *args)

    def getSolver(self):
        """getSolver(RootStrategyImplementation self) -> Solver"""
        return _simulation.RootStrategyImplementation_getSolver(self)

    def setMaximumDistance(self, *args):
        """setMaximumDistance(RootStrategyImplementation self, OT::NumericalScalar const maximumDistance)"""
        return _simulation.RootStrategyImplementation_setMaximumDistance(self, *args)

    def getMaximumDistance(self):
        """getMaximumDistance(RootStrategyImplementation self) -> OT::NumericalScalar"""
        return _simulation.RootStrategyImplementation_getMaximumDistance(self)

    def setStepSize(self, *args):
        """setStepSize(RootStrategyImplementation self, OT::NumericalScalar const stepSize)"""
        return _simulation.RootStrategyImplementation_setStepSize(self, *args)

    def getStepSize(self):
        """getStepSize(RootStrategyImplementation self) -> OT::NumericalScalar"""
        return _simulation.RootStrategyImplementation_getStepSize(self)

    def setOriginValue(self, *args):
        """setOriginValue(RootStrategyImplementation self, OT::NumericalScalar const originValue)"""
        return _simulation.RootStrategyImplementation_setOriginValue(self, *args)

    def getOriginValue(self):
        """getOriginValue(RootStrategyImplementation self) -> OT::NumericalScalar"""
        return _simulation.RootStrategyImplementation_getOriginValue(self)

    def __repr__(self):
        """__repr__(RootStrategyImplementation self) -> OT::String"""
        return _simulation.RootStrategyImplementation___repr__(self)

    def __init__(self, *args): 
        """
        __init__(OT::RootStrategyImplementation self) -> RootStrategyImplementation
        __init__(OT::RootStrategyImplementation self, Solver solver) -> RootStrategyImplementation
        __init__(OT::RootStrategyImplementation self, Solver solver, OT::NumericalScalar const maximumDistance, OT::NumericalScalar const stepSize) -> RootStrategyImplementation
        __init__(OT::RootStrategyImplementation self, RootStrategyImplementation other) -> RootStrategyImplementation
        """
        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)

def RootStrategyImplementation_GetClassName():
  """RootStrategyImplementation_GetClassName() -> OT::String"""
  return _simulation.RootStrategyImplementation_GetClassName()

class RootStrategyImplementationTypedInterfaceObject(openturns.common.InterfaceObject):
    """Proxy of C++ OT::TypedInterfaceObject<(OT::RootStrategyImplementation)> class"""
    __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): 
        """
        __init__(OT::TypedInterfaceObject<(OT::RootStrategyImplementation)> self) -> RootStrategyImplementationTypedInterfaceObject
        __init__(OT::TypedInterfaceObject<(OT::RootStrategyImplementation)> self, RootStrategyImplementationPointer impl) -> RootStrategyImplementationTypedInterfaceObject
        """
        this = _simulation.new_RootStrategyImplementationTypedInterfaceObject(*args)
        try: self.this.append(this)
        except: self.this = this
    def getImplementation(self, *args):
        """
        getImplementation(RootStrategyImplementationTypedInterfaceObject self) -> RootStrategyImplementationPointer
        getImplementation(RootStrategyImplementationTypedInterfaceObject self) -> RootStrategyImplementationPointer
        """
        return _simulation.RootStrategyImplementationTypedInterfaceObject_getImplementation(self, *args)

    def getImplementationAsPersistentObject(self):
        """getImplementationAsPersistentObject(RootStrategyImplementationTypedInterfaceObject self) -> PersistentObjectPointer"""
        return _simulation.RootStrategyImplementationTypedInterfaceObject_getImplementationAsPersistentObject(self)

    def setImplementationAsPersistentObject(self, *args):
        """setImplementationAsPersistentObject(RootStrategyImplementationTypedInterfaceObject self, PersistentObjectPointer obj)"""
        return _simulation.RootStrategyImplementationTypedInterfaceObject_setImplementationAsPersistentObject(self, *args)

    def swap(self, *args):
        """swap(RootStrategyImplementationTypedInterfaceObject self, RootStrategyImplementationTypedInterfaceObject other)"""
        return _simulation.RootStrategyImplementationTypedInterfaceObject_swap(self, *args)

    def setName(self, *args):
        """setName(RootStrategyImplementationTypedInterfaceObject self, OT::String const & name)"""
        return _simulation.RootStrategyImplementationTypedInterfaceObject_setName(self, *args)

    def getName(self):
        """getName(RootStrategyImplementationTypedInterfaceObject self) -> OT::String"""
        return _simulation.RootStrategyImplementationTypedInterfaceObject_getName(self)

    def __eq__(self, *args):
        """__eq__(RootStrategyImplementationTypedInterfaceObject self, RootStrategyImplementationTypedInterfaceObject other) -> OT::Bool"""
        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):
    """Proxy of C++ OT::RootStrategy class"""
    __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():
        """GetClassName() -> OT::String"""
        return _simulation.RootStrategy_GetClassName()

    if _newclass:GetClassName = staticmethod(GetClassName)
    __swig_getmethods__["GetClassName"] = lambda x: GetClassName
    def getClassName(self):
        """getClassName(RootStrategy self) -> OT::String"""
        return _simulation.RootStrategy_getClassName(self)

    def solve(self, *args):
        """solve(RootStrategy self, NumericalMathFunction function, OT::NumericalScalar const value) -> NumericalScalarCollection"""
        return _simulation.RootStrategy_solve(self, *args)

    def setSolver(self, *args):
        """setSolver(RootStrategy self, Solver solver)"""
        return _simulation.RootStrategy_setSolver(self, *args)

    def getSolver(self):
        """getSolver(RootStrategy self) -> Solver"""
        return _simulation.RootStrategy_getSolver(self)

    def setMaximumDistance(self, *args):
        """setMaximumDistance(RootStrategy self, OT::NumericalScalar const maximumDistance)"""
        return _simulation.RootStrategy_setMaximumDistance(self, *args)

    def getMaximumDistance(self):
        """getMaximumDistance(RootStrategy self) -> OT::NumericalScalar"""
        return _simulation.RootStrategy_getMaximumDistance(self)

    def setStepSize(self, *args):
        """setStepSize(RootStrategy self, OT::NumericalScalar const stepSize)"""
        return _simulation.RootStrategy_setStepSize(self, *args)

    def getStepSize(self):
        """getStepSize(RootStrategy self) -> OT::NumericalScalar"""
        return _simulation.RootStrategy_getStepSize(self)

    def setOriginValue(self, *args):
        """setOriginValue(RootStrategy self, OT::NumericalScalar const originValue)"""
        return _simulation.RootStrategy_setOriginValue(self, *args)

    def getOriginValue(self):
        """getOriginValue(RootStrategy self) -> OT::NumericalScalar"""
        return _simulation.RootStrategy_getOriginValue(self)

    def __repr__(self):
        """__repr__(RootStrategy self) -> OT::String"""
        return _simulation.RootStrategy___repr__(self)

    def __init__(self, *args): 
        """
        __init__(OT::RootStrategy self, RootStrategyImplementation implementation) -> RootStrategy
        __init__(OT::RootStrategy self, RootStrategyImplementationPointer p_implementation) -> RootStrategy
        __init__(OT::RootStrategy self) -> RootStrategy
        __init__(OT::RootStrategy self, RootStrategy other) -> RootStrategy
        """
        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)

def RootStrategy_GetClassName():
  """RootStrategy_GetClassName() -> OT::String"""
  return _simulation.RootStrategy_GetClassName()

class SamplingStrategyImplementation(openturns.common.PersistentObject):
    """Proxy of C++ OT::SamplingStrategyImplementation class"""
    __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():
        """GetClassName() -> OT::String"""
        return _simulation.SamplingStrategyImplementation_GetClassName()

    if _newclass:GetClassName = staticmethod(GetClassName)
    __swig_getmethods__["GetClassName"] = lambda x: GetClassName
    def getClassName(self):
        """getClassName(SamplingStrategyImplementation self) -> OT::String"""
        return _simulation.SamplingStrategyImplementation_getClassName(self)

    def generate(self):
        """generate(SamplingStrategyImplementation self) -> NumericalSample"""
        return _simulation.SamplingStrategyImplementation_generate(self)

    def getUniformUnitVectorRealization(self, *args):
        """
        getUniformUnitVectorRealization(SamplingStrategyImplementation self, OT::UnsignedLong const dimension) -> NumericalPoint
        getUniformUnitVectorRealization(SamplingStrategyImplementation self) -> NumericalPoint
        """
        return _simulation.SamplingStrategyImplementation_getUniformUnitVectorRealization(self, *args)

    def setDimension(self, *args):
        """setDimension(SamplingStrategyImplementation self, OT::UnsignedLong const dimension)"""
        return _simulation.SamplingStrategyImplementation_setDimension(self, *args)

    def getDimension(self):
        """getDimension(SamplingStrategyImplementation self) -> OT::UnsignedLong"""
        return _simulation.SamplingStrategyImplementation_getDimension(self)

    def __repr__(self):
        """__repr__(SamplingStrategyImplementation self) -> OT::String"""
        return _simulation.SamplingStrategyImplementation___repr__(self)

    def __init__(self, *args): 
        """
        __init__(OT::SamplingStrategyImplementation self, OT::UnsignedLong const dimension) -> SamplingStrategyImplementation
        __init__(OT::SamplingStrategyImplementation self, SamplingStrategyImplementation other) -> SamplingStrategyImplementation
        """
        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)

def SamplingStrategyImplementation_GetClassName():
  """SamplingStrategyImplementation_GetClassName() -> OT::String"""
  return _simulation.SamplingStrategyImplementation_GetClassName()

class SamplingStrategyImplementationTypedInterfaceObject(openturns.common.InterfaceObject):
    """Proxy of C++ OT::TypedInterfaceObject<(OT::SamplingStrategyImplementation)> class"""
    __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): 
        """
        __init__(OT::TypedInterfaceObject<(OT::SamplingStrategyImplementation)> self) -> SamplingStrategyImplementationTypedInterfaceObject
        __init__(OT::TypedInterfaceObject<(OT::SamplingStrategyImplementation)> self, SamplingStrategyImplementationPointer impl) -> SamplingStrategyImplementationTypedInterfaceObject
        """
        this = _simulation.new_SamplingStrategyImplementationTypedInterfaceObject(*args)
        try: self.this.append(this)
        except: self.this = this
    def getImplementation(self, *args):
        """
        getImplementation(SamplingStrategyImplementationTypedInterfaceObject self) -> SamplingStrategyImplementationPointer
        getImplementation(SamplingStrategyImplementationTypedInterfaceObject self) -> SamplingStrategyImplementationPointer
        """
        return _simulation.SamplingStrategyImplementationTypedInterfaceObject_getImplementation(self, *args)

    def getImplementationAsPersistentObject(self):
        """getImplementationAsPersistentObject(SamplingStrategyImplementationTypedInterfaceObject self) -> PersistentObjectPointer"""
        return _simulation.SamplingStrategyImplementationTypedInterfaceObject_getImplementationAsPersistentObject(self)

    def setImplementationAsPersistentObject(self, *args):
        """setImplementationAsPersistentObject(SamplingStrategyImplementationTypedInterfaceObject self, PersistentObjectPointer obj)"""
        return _simulation.SamplingStrategyImplementationTypedInterfaceObject_setImplementationAsPersistentObject(self, *args)

    def swap(self, *args):
        """swap(SamplingStrategyImplementationTypedInterfaceObject self, SamplingStrategyImplementationTypedInterfaceObject other)"""
        return _simulation.SamplingStrategyImplementationTypedInterfaceObject_swap(self, *args)

    def setName(self, *args):
        """setName(SamplingStrategyImplementationTypedInterfaceObject self, OT::String const & name)"""
        return _simulation.SamplingStrategyImplementationTypedInterfaceObject_setName(self, *args)

    def getName(self):
        """getName(SamplingStrategyImplementationTypedInterfaceObject self) -> OT::String"""
        return _simulation.SamplingStrategyImplementationTypedInterfaceObject_getName(self)

    def __eq__(self, *args):
        """__eq__(SamplingStrategyImplementationTypedInterfaceObject self, SamplingStrategyImplementationTypedInterfaceObject other) -> OT::Bool"""
        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):
    """Proxy of C++ OT::SamplingStrategy class"""
    __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():
        """GetClassName() -> OT::String"""
        return _simulation.SamplingStrategy_GetClassName()

    if _newclass:GetClassName = staticmethod(GetClassName)
    __swig_getmethods__["GetClassName"] = lambda x: GetClassName
    def getClassName(self):
        """getClassName(SamplingStrategy self) -> OT::String"""
        return _simulation.SamplingStrategy_getClassName(self)

    def generate(self):
        """generate(SamplingStrategy self) -> NumericalSample"""
        return _simulation.SamplingStrategy_generate(self)

    def setDimension(self, *args):
        """setDimension(SamplingStrategy self, OT::UnsignedLong const dimension)"""
        return _simulation.SamplingStrategy_setDimension(self, *args)

    def getDimension(self):
        """getDimension(SamplingStrategy self) -> OT::UnsignedLong"""
        return _simulation.SamplingStrategy_getDimension(self)

    def __repr__(self):
        """__repr__(SamplingStrategy self) -> OT::String"""
        return _simulation.SamplingStrategy___repr__(self)

    def __init__(self, *args): 
        """
        __init__(OT::SamplingStrategy self) -> SamplingStrategy
        __init__(OT::SamplingStrategy self, SamplingStrategyImplementation implementation) -> SamplingStrategy
        __init__(OT::SamplingStrategy self, SamplingStrategyImplementationPointer p_implementation) -> SamplingStrategy
        __init__(OT::SamplingStrategy self, OT::UnsignedLong const dimension) -> SamplingStrategy
        __init__(OT::SamplingStrategy self, SamplingStrategy other) -> SamplingStrategy
        """
        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)

def SamplingStrategy_GetClassName():
  """SamplingStrategy_GetClassName() -> OT::String"""
  return _simulation.SamplingStrategy_GetClassName()

class DirectionalSampling(Simulation):
    """Proxy of C++ OT::DirectionalSampling class"""
    __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():
        """GetClassName() -> OT::String"""
        return _simulation.DirectionalSampling_GetClassName()

    if _newclass:GetClassName = staticmethod(GetClassName)
    __swig_getmethods__["GetClassName"] = lambda x: GetClassName
    def getClassName(self):
        """getClassName(DirectionalSampling self) -> OT::String"""
        return _simulation.DirectionalSampling_getClassName(self)

    def setRootStrategy(self, *args):
        """setRootStrategy(DirectionalSampling self, RootStrategy rootStrategy)"""
        return _simulation.DirectionalSampling_setRootStrategy(self, *args)

    def getRootStrategy(self):
        """getRootStrategy(DirectionalSampling self) -> RootStrategy"""
        return _simulation.DirectionalSampling_getRootStrategy(self)

    def setSamplingStrategy(self, *args):
        """setSamplingStrategy(DirectionalSampling self, SamplingStrategy samplingStrategy)"""
        return _simulation.DirectionalSampling_setSamplingStrategy(self, *args)

    def getSamplingStrategy(self):
        """getSamplingStrategy(DirectionalSampling self) -> SamplingStrategy"""
        return _simulation.DirectionalSampling_getSamplingStrategy(self)

    def __repr__(self):
        """__repr__(DirectionalSampling self) -> OT::String"""
        return _simulation.DirectionalSampling___repr__(self)

    def __init__(self, *args): 
        """
        __init__(OT::DirectionalSampling self, Event event) -> DirectionalSampling
        __init__(OT::DirectionalSampling self, Event event, RootStrategy rootStrategy, SamplingStrategy samplingStrategy) -> DirectionalSampling
        __init__(OT::DirectionalSampling self, DirectionalSampling other) -> DirectionalSampling
        """
        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)

def DirectionalSampling_GetClassName():
  """DirectionalSampling_GetClassName() -> OT::String"""
  return _simulation.DirectionalSampling_GetClassName()

class OrthogonalDirection(SamplingStrategyImplementation):
    """Proxy of C++ OT::OrthogonalDirection class"""
    __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():
        """GetClassName() -> OT::String"""
        return _simulation.OrthogonalDirection_GetClassName()

    if _newclass:GetClassName = staticmethod(GetClassName)
    __swig_getmethods__["GetClassName"] = lambda x: GetClassName
    def getClassName(self):
        """getClassName(OrthogonalDirection self) -> OT::String"""
        return _simulation.OrthogonalDirection_getClassName(self)

    def generate(self):
        """generate(OrthogonalDirection self) -> NumericalSample"""
        return _simulation.OrthogonalDirection_generate(self)

    def __repr__(self):
        """__repr__(OrthogonalDirection self) -> OT::String"""
        return _simulation.OrthogonalDirection___repr__(self)

    def getUniformOrientationRealization(self):
        """getUniformOrientationRealization(OrthogonalDirection self) -> Matrix"""
        return _simulation.OrthogonalDirection_getUniformOrientationRealization(self)

    def __init__(self, *args): 
        """
        __init__(OT::OrthogonalDirection self) -> OrthogonalDirection
        __init__(OT::OrthogonalDirection self, OT::UnsignedLong const dimension, OT::UnsignedLong const size) -> OrthogonalDirection
        __init__(OT::OrthogonalDirection self, OrthogonalDirection other) -> OrthogonalDirection
        """
        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)

def OrthogonalDirection_GetClassName():
  """OrthogonalDirection_GetClassName() -> OT::String"""
  return _simulation.OrthogonalDirection_GetClassName()

class RandomDirection(SamplingStrategyImplementation):
    """Proxy of C++ OT::RandomDirection class"""
    __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():
        """GetClassName() -> OT::String"""
        return _simulation.RandomDirection_GetClassName()

    if _newclass:GetClassName = staticmethod(GetClassName)
    __swig_getmethods__["GetClassName"] = lambda x: GetClassName
    def getClassName(self):
        """getClassName(RandomDirection self) -> OT::String"""
        return _simulation.RandomDirection_getClassName(self)

    def generate(self):
        """generate(RandomDirection self) -> NumericalSample"""
        return _simulation.RandomDirection_generate(self)

    def __repr__(self):
        """__repr__(RandomDirection self) -> OT::String"""
        return _simulation.RandomDirection___repr__(self)

    def __init__(self, *args): 
        """
        __init__(OT::RandomDirection self) -> RandomDirection
        __init__(OT::RandomDirection self, OT::UnsignedLong const dimension) -> RandomDirection
        __init__(OT::RandomDirection self, RandomDirection other) -> RandomDirection
        """
        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)

def RandomDirection_GetClassName():
  """RandomDirection_GetClassName() -> OT::String"""
  return _simulation.RandomDirection_GetClassName()

class MediumSafe(RootStrategyImplementation):
    """Proxy of C++ OT::MediumSafe class"""
    __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():
        """GetClassName() -> OT::String"""
        return _simulation.MediumSafe_GetClassName()

    if _newclass:GetClassName = staticmethod(GetClassName)
    __swig_getmethods__["GetClassName"] = lambda x: GetClassName
    def getClassName(self):
        """getClassName(MediumSafe self) -> OT::String"""
        return _simulation.MediumSafe_getClassName(self)

    def solve(self, *args):
        """solve(MediumSafe self, NumericalMathFunction function, OT::NumericalScalar const value) -> NumericalScalarCollection"""
        return _simulation.MediumSafe_solve(self, *args)

    def __repr__(self):
        """__repr__(MediumSafe self) -> OT::String"""
        return _simulation.MediumSafe___repr__(self)

    def __init__(self, *args): 
        """
        __init__(OT::MediumSafe self) -> MediumSafe
        __init__(OT::MediumSafe self, Solver solver) -> MediumSafe
        __init__(OT::MediumSafe self, Solver solver, OT::NumericalScalar const maximumDistance, OT::NumericalScalar const stepSize) -> MediumSafe
        __init__(OT::MediumSafe self, MediumSafe other) -> MediumSafe
        """
        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)

def MediumSafe_GetClassName():
  """MediumSafe_GetClassName() -> OT::String"""
  return _simulation.MediumSafe_GetClassName()

class RiskyAndFast(RootStrategyImplementation):
    """Proxy of C++ OT::RiskyAndFast class"""
    __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():
        """GetClassName() -> OT::String"""
        return _simulation.RiskyAndFast_GetClassName()

    if _newclass:GetClassName = staticmethod(GetClassName)
    __swig_getmethods__["GetClassName"] = lambda x: GetClassName
    def getClassName(self):
        """getClassName(RiskyAndFast self) -> OT::String"""
        return _simulation.RiskyAndFast_getClassName(self)

    def solve(self, *args):
        """solve(RiskyAndFast self, NumericalMathFunction function, OT::NumericalScalar const value) -> NumericalScalarCollection"""
        return _simulation.RiskyAndFast_solve(self, *args)

    def __repr__(self):
        """__repr__(RiskyAndFast self) -> OT::String"""
        return _simulation.RiskyAndFast___repr__(self)

    def __init__(self, *args): 
        """
        __init__(OT::RiskyAndFast self) -> RiskyAndFast
        __init__(OT::RiskyAndFast self, Solver solver) -> RiskyAndFast
        __init__(OT::RiskyAndFast self, Solver solver, OT::NumericalScalar const maximumDistance) -> RiskyAndFast
        __init__(OT::RiskyAndFast self, RiskyAndFast other) -> RiskyAndFast
        """
        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)

def RiskyAndFast_GetClassName():
  """RiskyAndFast_GetClassName() -> OT::String"""
  return _simulation.RiskyAndFast_GetClassName()

class SafeAndSlow(RootStrategyImplementation):
    """Proxy of C++ OT::SafeAndSlow class"""
    __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():
        """GetClassName() -> OT::String"""
        return _simulation.SafeAndSlow_GetClassName()

    if _newclass:GetClassName = staticmethod(GetClassName)
    __swig_getmethods__["GetClassName"] = lambda x: GetClassName
    def getClassName(self):
        """getClassName(SafeAndSlow self) -> OT::String"""
        return _simulation.SafeAndSlow_getClassName(self)

    def solve(self, *args):
        """solve(SafeAndSlow self, NumericalMathFunction function, OT::NumericalScalar const value) -> NumericalScalarCollection"""
        return _simulation.SafeAndSlow_solve(self, *args)

    def __repr__(self):
        """__repr__(SafeAndSlow self) -> OT::String"""
        return _simulation.SafeAndSlow___repr__(self)

    def __init__(self, *args): 
        """
        __init__(OT::SafeAndSlow self) -> SafeAndSlow
        __init__(OT::SafeAndSlow self, Solver solver) -> SafeAndSlow
        __init__(OT::SafeAndSlow self, Solver solver, OT::NumericalScalar const maximumDistance, OT::NumericalScalar const stepSize) -> SafeAndSlow
        __init__(OT::SafeAndSlow self, SafeAndSlow other) -> SafeAndSlow
        """
        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)

def SafeAndSlow_GetClassName():
  """SafeAndSlow_GetClassName() -> OT::String"""
  return _simulation.SafeAndSlow_GetClassName()

class QuasiMonteCarlo(Simulation):
    """Proxy of C++ OT::QuasiMonteCarlo class"""
    __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():
        """GetClassName() -> OT::String"""
        return _simulation.QuasiMonteCarlo_GetClassName()

    if _newclass:GetClassName = staticmethod(GetClassName)
    __swig_getmethods__["GetClassName"] = lambda x: GetClassName
    def getClassName(self):
        """getClassName(QuasiMonteCarlo self) -> OT::String"""
        return _simulation.QuasiMonteCarlo_getClassName(self)

    def __repr__(self):
        """__repr__(QuasiMonteCarlo self) -> OT::String"""
        return _simulation.QuasiMonteCarlo___repr__(self)

    def __init__(self, *args): 
        """
        __init__(OT::QuasiMonteCarlo self) -> QuasiMonteCarlo
        __init__(OT::QuasiMonteCarlo self, Event event, LowDiscrepancySequence lowDiscrepancySequence=OT::SobolSequence()) -> QuasiMonteCarlo
        __init__(OT::QuasiMonteCarlo self, Event event) -> QuasiMonteCarlo
        __init__(OT::QuasiMonteCarlo self, QuasiMonteCarlo other) -> QuasiMonteCarlo
        """
        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)

def QuasiMonteCarlo_GetClassName():
  """QuasiMonteCarlo_GetClassName() -> OT::String"""
  return _simulation.QuasiMonteCarlo_GetClassName()

class RandomizedQuasiMonteCarlo(Simulation):
    """Proxy of C++ OT::RandomizedQuasiMonteCarlo class"""
    __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():
        """GetClassName() -> OT::String"""
        return _simulation.RandomizedQuasiMonteCarlo_GetClassName()

    if _newclass:GetClassName = staticmethod(GetClassName)
    __swig_getmethods__["GetClassName"] = lambda x: GetClassName
    def getClassName(self):
        """getClassName(RandomizedQuasiMonteCarlo self) -> OT::String"""
        return _simulation.RandomizedQuasiMonteCarlo_getClassName(self)

    def __repr__(self):
        """__repr__(RandomizedQuasiMonteCarlo self) -> OT::String"""
        return _simulation.RandomizedQuasiMonteCarlo___repr__(self)

    def __init__(self, *args): 
        """
        __init__(OT::RandomizedQuasiMonteCarlo self) -> RandomizedQuasiMonteCarlo
        __init__(OT::RandomizedQuasiMonteCarlo self, Event event, LowDiscrepancySequence lowDiscrepancySequence=OT::SobolSequence()) -> RandomizedQuasiMonteCarlo
        __init__(OT::RandomizedQuasiMonteCarlo self, Event event) -> RandomizedQuasiMonteCarlo
        __init__(OT::RandomizedQuasiMonteCarlo self, RandomizedQuasiMonteCarlo other) -> RandomizedQuasiMonteCarlo
        """
        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)

def RandomizedQuasiMonteCarlo_GetClassName():
  """RandomizedQuasiMonteCarlo_GetClassName() -> OT::String"""
  return _simulation.RandomizedQuasiMonteCarlo_GetClassName()

class QuasiMonteCarloResult(SimulationResultImplementation):
    """Proxy of C++ OT::QuasiMonteCarloResult class"""
    __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():
        """GetClassName() -> OT::String"""
        return _simulation.QuasiMonteCarloResult_GetClassName()

    if _newclass:GetClassName = staticmethod(GetClassName)
    __swig_getmethods__["GetClassName"] = lambda x: GetClassName
    def getClassName(self):
        """getClassName(QuasiMonteCarloResult self) -> OT::String"""
        return _simulation.QuasiMonteCarloResult_getClassName(self)

    def getCoefficientOfVariation(self):
        """getCoefficientOfVariation(QuasiMonteCarloResult self) -> OT::NumericalScalar"""
        return _simulation.QuasiMonteCarloResult_getCoefficientOfVariation(self)

    def getStandardDeviation(self):
        """getStandardDeviation(QuasiMonteCarloResult self) -> OT::NumericalScalar"""
        return _simulation.QuasiMonteCarloResult_getStandardDeviation(self)

    def getConfidenceLength(self, *args):
        """
        getConfidenceLength(QuasiMonteCarloResult self, OT::NumericalScalar const level=OT::ResourceMap::GetAsNumericalScalar( "SimulationResultImplementation-DefaultConfidenceLevel" )) -> OT::NumericalScalar
        getConfidenceLength(QuasiMonteCarloResult self) -> OT::NumericalScalar
        """
        return _simulation.QuasiMonteCarloResult_getConfidenceLength(self, *args)

    def __repr__(self):
        """__repr__(QuasiMonteCarloResult self) -> OT::String"""
        return _simulation.QuasiMonteCarloResult___repr__(self)

    def __init__(self, *args): 
        """
        __init__(OT::QuasiMonteCarloResult self) -> QuasiMonteCarloResult
        __init__(OT::QuasiMonteCarloResult self, Event event, OT::NumericalScalar const probabilityEstimate, OT::NumericalScalar const varianceEstimate, 
            OT::UnsignedLong const outerSampling, OT::UnsignedLong const blockSize) -> QuasiMonteCarloResult
        __init__(OT::QuasiMonteCarloResult self, QuasiMonteCarloResult other) -> QuasiMonteCarloResult
        """
        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)

def QuasiMonteCarloResult_GetClassName():
  """QuasiMonteCarloResult_GetClassName() -> OT::String"""
  return _simulation.QuasiMonteCarloResult_GetClassName()

class SimulationSensitivityAnalysis(openturns.common.PersistentObject):
    """Proxy of C++ OT::SimulationSensitivityAnalysis class"""
    __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():
        """GetClassName() -> OT::String"""
        return _simulation.SimulationSensitivityAnalysis_GetClassName()

    if _newclass:GetClassName = staticmethod(GetClassName)
    __swig_getmethods__["GetClassName"] = lambda x: GetClassName
    def getClassName(self):
        """getClassName(SimulationSensitivityAnalysis self) -> OT::String"""
        return _simulation.SimulationSensitivityAnalysis_getClassName(self)

    def computeMeanPointInEventDomain(self, *args):
        """
        computeMeanPointInEventDomain(SimulationSensitivityAnalysis self) -> NumericalPoint
        computeMeanPointInEventDomain(SimulationSensitivityAnalysis self, OT::NumericalScalar const threshold) -> NumericalPoint
        """
        return _simulation.SimulationSensitivityAnalysis_computeMeanPointInEventDomain(self, *args)

    def computeImportanceFactors(self, *args):
        """
        computeImportanceFactors(SimulationSensitivityAnalysis self) -> NumericalPointWithDescription
        computeImportanceFactors(SimulationSensitivityAnalysis self, OT::NumericalScalar const threshold) -> NumericalPointWithDescription
        """
        return _simulation.SimulationSensitivityAnalysis_computeImportanceFactors(self, *args)

    def drawImportanceFactors(self):
        """drawImportanceFactors(SimulationSensitivityAnalysis self) -> Graph"""
        return _simulation.SimulationSensitivityAnalysis_drawImportanceFactors(self)

    def drawImportanceFactorsRange(self, *args):
        """
        drawImportanceFactorsRange(SimulationSensitivityAnalysis self, OT::Bool const probabilityScale=True, OT::NumericalScalar const lower=-SpecFunc::MaxNumericalScalar, 
            OT::NumericalScalar const upper=MaxNumericalScalar) -> Graph
        drawImportanceFactorsRange(SimulationSensitivityAnalysis self, OT::Bool const probabilityScale=True, OT::NumericalScalar const lower=-SpecFunc::MaxNumericalScalar) -> Graph
        drawImportanceFactorsRange(SimulationSensitivityAnalysis self, OT::Bool const probabilityScale=True) -> Graph
        drawImportanceFactorsRange(SimulationSensitivityAnalysis self) -> Graph
        """
        return _simulation.SimulationSensitivityAnalysis_drawImportanceFactorsRange(self, *args)

    def getInputSample(self):
        """getInputSample(SimulationSensitivityAnalysis self) -> NumericalSample"""
        return _simulation.SimulationSensitivityAnalysis_getInputSample(self)

    def getOutputSample(self):
        """getOutputSample(SimulationSensitivityAnalysis self) -> NumericalSample"""
        return _simulation.SimulationSensitivityAnalysis_getOutputSample(self)

    def getThreshold(self):
        """getThreshold(SimulationSensitivityAnalysis self) -> OT::NumericalScalar"""
        return _simulation.SimulationSensitivityAnalysis_getThreshold(self)

    def setThreshold(self, *args):
        """setThreshold(SimulationSensitivityAnalysis self, OT::NumericalScalar const threshold)"""
        return _simulation.SimulationSensitivityAnalysis_setThreshold(self, *args)

    def getTransformation(self):
        """getTransformation(SimulationSensitivityAnalysis self) -> NumericalMathFunction"""
        return _simulation.SimulationSensitivityAnalysis_getTransformation(self)

    def getComparisonOperator(self):
        """getComparisonOperator(SimulationSensitivityAnalysis self) -> ComparisonOperator"""
        return _simulation.SimulationSensitivityAnalysis_getComparisonOperator(self)

    def setComparisonOperator(self, *args):
        """setComparisonOperator(SimulationSensitivityAnalysis self, ComparisonOperator comparisonOperator)"""
        return _simulation.SimulationSensitivityAnalysis_setComparisonOperator(self, *args)

    def __repr__(self):
        """__repr__(SimulationSensitivityAnalysis self) -> OT::String"""
        return _simulation.SimulationSensitivityAnalysis___repr__(self)

    def __init__(self, *args): 
        """
        __init__(OT::SimulationSensitivityAnalysis self) -> SimulationSensitivityAnalysis
        __init__(OT::SimulationSensitivityAnalysis self, NumericalSample inputSample, NumericalSample outputSample, NumericalMathFunction transformation, 
            ComparisonOperator comparisonOperator, OT::NumericalScalar const threshold) -> SimulationSensitivityAnalysis
        __init__(OT::SimulationSensitivityAnalysis self, Event event) -> SimulationSensitivityAnalysis
        __init__(OT::SimulationSensitivityAnalysis self, SimulationResult result) -> SimulationSensitivityAnalysis
        __init__(OT::SimulationSensitivityAnalysis self, SimulationSensitivityAnalysis other) -> SimulationSensitivityAnalysis
        """
        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)

def SimulationSensitivityAnalysis_GetClassName():
  """SimulationSensitivityAnalysis_GetClassName() -> OT::String"""
  return _simulation.SimulationSensitivityAnalysis_GetClassName()

class RootStrategyImplementationPointer(_object):
    """Proxy of C++ OT::Pointer<(OT::RootStrategyImplementation)> class"""
    __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): 
        """
        __init__(OT::Pointer<(OT::RootStrategyImplementation)> self) -> RootStrategyImplementationPointer
        __init__(OT::Pointer<(OT::RootStrategyImplementation)> self, RootStrategyImplementation ptr) -> RootStrategyImplementationPointer
        """
        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):
        """reset(RootStrategyImplementationPointer self)"""
        return _simulation.RootStrategyImplementationPointer_reset(self)

    def __ref__(self, *args):
        """
        __ref__(RootStrategyImplementationPointer self) -> RootStrategyImplementation
        __ref__(RootStrategyImplementationPointer self) -> RootStrategyImplementation
        """
        return _simulation.RootStrategyImplementationPointer___ref__(self, *args)

    def __deref__(self):
        """__deref__(RootStrategyImplementationPointer self) -> RootStrategyImplementation"""
        return _simulation.RootStrategyImplementationPointer___deref__(self)

    def isNull(self):
        """isNull(RootStrategyImplementationPointer self) -> OT::Bool"""
        return _simulation.RootStrategyImplementationPointer_isNull(self)

    def __nonzero__(self):
        return _simulation.RootStrategyImplementationPointer___nonzero__(self)
    __bool__ = __nonzero__


    def get(self):
        """get(RootStrategyImplementationPointer self) -> RootStrategyImplementation"""
        return _simulation.RootStrategyImplementationPointer_get(self)

    def getImplementation(self):
        """getImplementation(RootStrategyImplementationPointer self) -> OT::Pointer< OT::RootStrategyImplementation >::pointer_type const &"""
        return _simulation.RootStrategyImplementationPointer_getImplementation(self)

    def unique(self):
        """unique(RootStrategyImplementationPointer self) -> OT::Bool"""
        return _simulation.RootStrategyImplementationPointer_unique(self)

    def use_count(self):
        """use_count(RootStrategyImplementationPointer self) -> OT::UnsignedLong"""
        return _simulation.RootStrategyImplementationPointer_use_count(self)

    def swap(self, *args):
        """swap(RootStrategyImplementationPointer self, RootStrategyImplementationPointer other)"""
        return _simulation.RootStrategyImplementationPointer_swap(self, *args)

    def GetClassName(self):
        """GetClassName(RootStrategyImplementationPointer self) -> OT::String"""
        return _simulation.RootStrategyImplementationPointer_GetClassName(self)

    def getClassName(self):
        """getClassName(RootStrategyImplementationPointer self) -> OT::String"""
        return _simulation.RootStrategyImplementationPointer_getClassName(self)

    def solve(self, *args):
        """solve(RootStrategyImplementationPointer self, NumericalMathFunction function, OT::NumericalScalar const value) -> NumericalScalarCollection"""
        return _simulation.RootStrategyImplementationPointer_solve(self, *args)

    def setSolver(self, *args):
        """setSolver(RootStrategyImplementationPointer self, Solver solver)"""
        return _simulation.RootStrategyImplementationPointer_setSolver(self, *args)

    def getSolver(self):
        """getSolver(RootStrategyImplementationPointer self) -> Solver"""
        return _simulation.RootStrategyImplementationPointer_getSolver(self)

    def setMaximumDistance(self, *args):
        """setMaximumDistance(RootStrategyImplementationPointer self, OT::NumericalScalar const maximumDistance)"""
        return _simulation.RootStrategyImplementationPointer_setMaximumDistance(self, *args)

    def getMaximumDistance(self):
        """getMaximumDistance(RootStrategyImplementationPointer self) -> OT::NumericalScalar"""
        return _simulation.RootStrategyImplementationPointer_getMaximumDistance(self)

    def setStepSize(self, *args):
        """setStepSize(RootStrategyImplementationPointer self, OT::NumericalScalar const stepSize)"""
        return _simulation.RootStrategyImplementationPointer_setStepSize(self, *args)

    def getStepSize(self):
        """getStepSize(RootStrategyImplementationPointer self) -> OT::NumericalScalar"""
        return _simulation.RootStrategyImplementationPointer_getStepSize(self)

    def setOriginValue(self, *args):
        """setOriginValue(RootStrategyImplementationPointer self, OT::NumericalScalar const originValue)"""
        return _simulation.RootStrategyImplementationPointer_setOriginValue(self, *args)

    def getOriginValue(self):
        """getOriginValue(RootStrategyImplementationPointer self) -> OT::NumericalScalar"""
        return _simulation.RootStrategyImplementationPointer_getOriginValue(self)

    def __repr__(self):
        """__repr__(RootStrategyImplementationPointer self) -> OT::String"""
        return _simulation.RootStrategyImplementationPointer___repr__(self)

    def __eq__(self, *args):
        """__eq__(RootStrategyImplementationPointer self, PersistentObject other) -> OT::Bool"""
        return _simulation.RootStrategyImplementationPointer___eq__(self, *args)

    def Is(self, *args):
        """Is(RootStrategyImplementationPointer self, PersistentObject other) -> OT::Bool"""
        return _simulation.RootStrategyImplementationPointer_Is(self, *args)

    def __str__(self, offset=""):
        """
        __str__(RootStrategyImplementationPointer self, OT::String const & offset="") -> OT::String
        __str__(RootStrategyImplementationPointer self) -> OT::String
        """
        return _simulation.RootStrategyImplementationPointer___str__(self, offset)

    def getId(self):
        """getId(RootStrategyImplementationPointer self) -> OT::Id"""
        return _simulation.RootStrategyImplementationPointer_getId(self)

    def setShadowedId(self, *args):
        """setShadowedId(RootStrategyImplementationPointer self, OT::Id id)"""
        return _simulation.RootStrategyImplementationPointer_setShadowedId(self, *args)

    def getShadowedId(self):
        """getShadowedId(RootStrategyImplementationPointer self) -> OT::Id"""
        return _simulation.RootStrategyImplementationPointer_getShadowedId(self)

    def setVisibility(self, *args):
        """setVisibility(RootStrategyImplementationPointer self, OT::Bool visible)"""
        return _simulation.RootStrategyImplementationPointer_setVisibility(self, *args)

    def getVisibility(self):
        """getVisibility(RootStrategyImplementationPointer self) -> OT::Bool"""
        return _simulation.RootStrategyImplementationPointer_getVisibility(self)

    def hasName(self):
        """hasName(RootStrategyImplementationPointer self) -> OT::Bool"""
        return _simulation.RootStrategyImplementationPointer_hasName(self)

    def hasVisibleName(self):
        """hasVisibleName(RootStrategyImplementationPointer self) -> OT::Bool"""
        return _simulation.RootStrategyImplementationPointer_hasVisibleName(self)

    def getName(self):
        """getName(RootStrategyImplementationPointer self) -> OT::String"""
        return _simulation.RootStrategyImplementationPointer_getName(self)

    def setName(self, *args):
        """setName(RootStrategyImplementationPointer self, OT::String const & name)"""
        return _simulation.RootStrategyImplementationPointer_setName(self, *args)

RootStrategyImplementationPointer_swigregister = _simulation.RootStrategyImplementationPointer_swigregister
RootStrategyImplementationPointer_swigregister(RootStrategyImplementationPointer)

class SamplingStrategyImplementationPointer(_object):
    """Proxy of C++ OT::Pointer<(OT::SamplingStrategyImplementation)> class"""
    __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): 
        """
        __init__(OT::Pointer<(OT::SamplingStrategyImplementation)> self) -> SamplingStrategyImplementationPointer
        __init__(OT::Pointer<(OT::SamplingStrategyImplementation)> self, SamplingStrategyImplementation ptr) -> SamplingStrategyImplementationPointer
        """
        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):
        """reset(SamplingStrategyImplementationPointer self)"""
        return _simulation.SamplingStrategyImplementationPointer_reset(self)

    def __ref__(self, *args):
        """
        __ref__(SamplingStrategyImplementationPointer self) -> SamplingStrategyImplementation
        __ref__(SamplingStrategyImplementationPointer self) -> SamplingStrategyImplementation
        """
        return _simulation.SamplingStrategyImplementationPointer___ref__(self, *args)

    def __deref__(self):
        """__deref__(SamplingStrategyImplementationPointer self) -> SamplingStrategyImplementation"""
        return _simulation.SamplingStrategyImplementationPointer___deref__(self)

    def isNull(self):
        """isNull(SamplingStrategyImplementationPointer self) -> OT::Bool"""
        return _simulation.SamplingStrategyImplementationPointer_isNull(self)

    def __nonzero__(self):
        return _simulation.SamplingStrategyImplementationPointer___nonzero__(self)
    __bool__ = __nonzero__


    def get(self):
        """get(SamplingStrategyImplementationPointer self) -> SamplingStrategyImplementation"""
        return _simulation.SamplingStrategyImplementationPointer_get(self)

    def getImplementation(self):
        """getImplementation(SamplingStrategyImplementationPointer self) -> OT::Pointer< OT::SamplingStrategyImplementation >::pointer_type const &"""
        return _simulation.SamplingStrategyImplementationPointer_getImplementation(self)

    def unique(self):
        """unique(SamplingStrategyImplementationPointer self) -> OT::Bool"""
        return _simulation.SamplingStrategyImplementationPointer_unique(self)

    def use_count(self):
        """use_count(SamplingStrategyImplementationPointer self) -> OT::UnsignedLong"""
        return _simulation.SamplingStrategyImplementationPointer_use_count(self)

    def swap(self, *args):
        """swap(SamplingStrategyImplementationPointer self, SamplingStrategyImplementationPointer other)"""
        return _simulation.SamplingStrategyImplementationPointer_swap(self, *args)

    def GetClassName(self):
        """GetClassName(SamplingStrategyImplementationPointer self) -> OT::String"""
        return _simulation.SamplingStrategyImplementationPointer_GetClassName(self)

    def getClassName(self):
        """getClassName(SamplingStrategyImplementationPointer self) -> OT::String"""
        return _simulation.SamplingStrategyImplementationPointer_getClassName(self)

    def generate(self):
        """generate(SamplingStrategyImplementationPointer self) -> NumericalSample"""
        return _simulation.SamplingStrategyImplementationPointer_generate(self)

    def getUniformUnitVectorRealization(self, *args):
        """
        getUniformUnitVectorRealization(SamplingStrategyImplementationPointer self, OT::UnsignedLong const dimension) -> NumericalPoint
        getUniformUnitVectorRealization(SamplingStrategyImplementationPointer self) -> NumericalPoint
        """
        return _simulation.SamplingStrategyImplementationPointer_getUniformUnitVectorRealization(self, *args)

    def setDimension(self, *args):
        """setDimension(SamplingStrategyImplementationPointer self, OT::UnsignedLong const dimension)"""
        return _simulation.SamplingStrategyImplementationPointer_setDimension(self, *args)

    def getDimension(self):
        """getDimension(SamplingStrategyImplementationPointer self) -> OT::UnsignedLong"""
        return _simulation.SamplingStrategyImplementationPointer_getDimension(self)

    def __repr__(self):
        """__repr__(SamplingStrategyImplementationPointer self) -> OT::String"""
        return _simulation.SamplingStrategyImplementationPointer___repr__(self)

    def __eq__(self, *args):
        """__eq__(SamplingStrategyImplementationPointer self, PersistentObject other) -> OT::Bool"""
        return _simulation.SamplingStrategyImplementationPointer___eq__(self, *args)

    def Is(self, *args):
        """Is(SamplingStrategyImplementationPointer self, PersistentObject other) -> OT::Bool"""
        return _simulation.SamplingStrategyImplementationPointer_Is(self, *args)

    def __str__(self, offset=""):
        """
        __str__(SamplingStrategyImplementationPointer self, OT::String const & offset="") -> OT::String
        __str__(SamplingStrategyImplementationPointer self) -> OT::String
        """
        return _simulation.SamplingStrategyImplementationPointer___str__(self, offset)

    def getId(self):
        """getId(SamplingStrategyImplementationPointer self) -> OT::Id"""
        return _simulation.SamplingStrategyImplementationPointer_getId(self)

    def setShadowedId(self, *args):
        """setShadowedId(SamplingStrategyImplementationPointer self, OT::Id id)"""
        return _simulation.SamplingStrategyImplementationPointer_setShadowedId(self, *args)

    def getShadowedId(self):
        """getShadowedId(SamplingStrategyImplementationPointer self) -> OT::Id"""
        return _simulation.SamplingStrategyImplementationPointer_getShadowedId(self)

    def setVisibility(self, *args):
        """setVisibility(SamplingStrategyImplementationPointer self, OT::Bool visible)"""
        return _simulation.SamplingStrategyImplementationPointer_setVisibility(self, *args)

    def getVisibility(self):
        """getVisibility(SamplingStrategyImplementationPointer self) -> OT::Bool"""
        return _simulation.SamplingStrategyImplementationPointer_getVisibility(self)

    def hasName(self):
        """hasName(SamplingStrategyImplementationPointer self) -> OT::Bool"""
        return _simulation.SamplingStrategyImplementationPointer_hasName(self)

    def hasVisibleName(self):
        """hasVisibleName(SamplingStrategyImplementationPointer self) -> OT::Bool"""
        return _simulation.SamplingStrategyImplementationPointer_hasVisibleName(self)

    def getName(self):
        """getName(SamplingStrategyImplementationPointer self) -> OT::String"""
        return _simulation.SamplingStrategyImplementationPointer_getName(self)

    def setName(self, *args):
        """setName(SamplingStrategyImplementationPointer self, OT::String const & name)"""
        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.