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




"""
Weighted designs of experiments.
"""


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

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

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

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

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


class SwigPyIterator(_object):
    __swig_setmethods__ = {}
    __setattr__ = lambda self, name, value: _swig_setattr(self, SwigPyIterator, name, value)
    __swig_getmethods__ = {}
    __getattr__ = lambda self, name: _swig_getattr(self, SwigPyIterator, name)
    def __init__(self, *args, **kwargs): raise AttributeError("No constructor defined - class is abstract")
    __repr__ = _swig_repr
    __swig_destroy__ = _weightedexperiment.delete_SwigPyIterator
    __del__ = lambda self : None;
    def value(self): return _weightedexperiment.SwigPyIterator_value(self)
    def incr(self, n=1): return _weightedexperiment.SwigPyIterator_incr(self, n)
    def decr(self, n=1): return _weightedexperiment.SwigPyIterator_decr(self, n)
    def distance(self, *args): return _weightedexperiment.SwigPyIterator_distance(self, *args)
    def equal(self, *args): return _weightedexperiment.SwigPyIterator_equal(self, *args)
    def copy(self): return _weightedexperiment.SwigPyIterator_copy(self)
    def next(self): return _weightedexperiment.SwigPyIterator_next(self)
    def __next__(self): return _weightedexperiment.SwigPyIterator___next__(self)
    def previous(self): return _weightedexperiment.SwigPyIterator_previous(self)
    def advance(self, *args): return _weightedexperiment.SwigPyIterator_advance(self, *args)
    def __eq__(self, *args): return _weightedexperiment.SwigPyIterator___eq__(self, *args)
    def __ne__(self, *args): return _weightedexperiment.SwigPyIterator___ne__(self, *args)
    def __iadd__(self, *args): return _weightedexperiment.SwigPyIterator___iadd__(self, *args)
    def __isub__(self, *args): return _weightedexperiment.SwigPyIterator___isub__(self, *args)
    def __add__(self, *args): return _weightedexperiment.SwigPyIterator___add__(self, *args)
    def __sub__(self, *args): return _weightedexperiment.SwigPyIterator___sub__(self, *args)
    def __iter__(self): return self
SwigPyIterator_swigregister = _weightedexperiment.SwigPyIterator_swigregister
SwigPyIterator_swigregister(SwigPyIterator)

GCC_VERSION = _weightedexperiment.GCC_VERSION
class TestFailed:
    """TestFailed is used to raise an uniform exception in tests."""

    __type = "TestFailed"

    def __init__(self, reason=""):
        self.reason = reason

    def type(self):
        return TestFailed.__type

    def what(self):
        return self.reason

    def __str__(self):
        return TestFailed.__type + ": " + self.reason

    def __lshift__(self, ch):
        self.reason += ch
        return self

import openturns.base
import openturns.common
import openturns.wrapper
import openturns.typ
import openturns.statistics
import openturns.graph
import openturns.func
import openturns.geom
import openturns.diff
import openturns.optim
import openturns.solver
import openturns.algo
import openturns.experiment
import openturns.model_copula
class WeightedExperiment(openturns.experiment.ExperimentImplementation):
    """
    Weighted experiment.

    Available constructor:
        WeightedExperiment(`distribution=ot.Uniform(), size=100`)

    Parameters
    ----------
    distribution : :class:`~openturns.Distribution`
        Distribution :math:`\\mu` used to generate the set of input data.
    size : positive int
        Number :math:`cardI` of points that will be generated in the experiment.

    Notes
    -----
    WeightedExperiment is used to generate the points :math:`\\Xi_i` so that the
    mean :math:`E_{\\mu}` is approximated as follows:

    .. math::

        E_{\\mu} \\left[ f(\\vect{Z}) \\right] \\simeq \\sum_{i \\in I} \\omega_i f(\\Xi_i)

    where :math:`\\mu` is a distribution, :math:`f` is a function :math:`L_1(\\mu)`
    and :math:`\\omega_i` are the weights associated with the points. By default,
    all the weights are equal to :math:`1/cardI`.

    A WeightedExperiment object can be created only through its derived classes
    which are distributed in three groups:

    1. The first category is made up of the random patterns, where the set of input
       data is generated from the joint distribution of the input random vector,
       according to these sampling techniques:

       - :class:`Monte Carlo <openturns.MonteCarloExperiment>`

       - :class:`LHS <openturns.LHSExperiment>`

       - :class:`Bootstrap <openturns.BootstrapExperiment>`

       - :class:`Importance Sampling <openturns.ImportanceSamplingExperiment>`

    2. The second category contains the :class:`low discrepancy sequences
       <openturns.LowDiscrepancySequence>`. OpenTURNS proposes the Faure, Halton,
       Haselgrove, Reverse Halton and Sobol sequences.

    3. The third category consists of deterministic patterns:

       - :class:`Gauss product <openturns.GaussProductExperiment>`

       - :class:`~openturns.FixedExperiment`

       - :class:`~openturns.LowDiscrepancyExperiment`
    """
    __swig_setmethods__ = {}
    for _s in [openturns.experiment.ExperimentImplementation]: __swig_setmethods__.update(getattr(_s,'__swig_setmethods__',{}))
    __setattr__ = lambda self, name, value: _swig_setattr(self, WeightedExperiment, name, value)
    __swig_getmethods__ = {}
    for _s in [openturns.experiment.ExperimentImplementation]: __swig_getmethods__.update(getattr(_s,'__swig_getmethods__',{}))
    __getattr__ = lambda self, name: _swig_getattr(self, WeightedExperiment, name)
    def getClassName(self):
        """
        Accessor to the object's name.

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

    def __repr__(self): return _weightedexperiment.WeightedExperiment___repr__(self)
    def setDistribution(self, *args):
        """
        Accessor to the distribution.

        Parameters
        ----------
        distribution : :class:`~openturns.Distribution`
            Distribution used to generate the set of input data.
        """
        return _weightedexperiment.WeightedExperiment_setDistribution(self, *args)

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

        Returns
        -------
        distribution : :class:`~openturns.Distribution`
            Distribution used to generate the set of input data.
        """
        return _weightedexperiment.WeightedExperiment_getDistribution(self)

    def setSize(self, *args):
        """
        Accessor to the size of the generated sample.

        Parameters
        ----------
        size : positive int
            Number :math:`cardI` of points constituting the design of experiments.
        """
        return _weightedexperiment.WeightedExperiment_setSize(self, *args)

    def getSize(self):
        """
        Accessor to the size of the generated sample.

        Returns
        -------
        size : positive int
            Number :math:`cardI` of points constituting the design of experiments.
        """
        return _weightedexperiment.WeightedExperiment_getSize(self)

    def generate(self):
        """
        Generate points according to the type of the experiment.

        Returns
        -------
        sample : 2D float sequence
            Points :math:`(\\Xi_i)_{i \\in I}` which constitute the design of experiments
            with :math:`card I = size`. The sampling method is defined by the nature of
            the weighted experiment.

        Examples
        --------
        >>> import openturns as ot
        >>> ot.RandomGenerator.SetSeed(0)
        >>> myExperiment = ot.MonteCarloExperiment(ot.Normal(2), 5)
        >>> sample = myExperiment.generate()
        >>> print(sample)
            [ marginal 1 marginal 2 ]
        0 : [  0.608202  -1.26617   ]
        1 : [ -0.438266   1.20548   ]
        2 : [ -2.18139    0.350042  ]
        3 : [ -0.355007   1.43725   ]
        4 : [  0.810668   0.793156  ]
        """
        return _weightedexperiment.WeightedExperiment_generate(self)

    def generateWithWeights(self):
        """
        Generate points and their associated weight according to the type of the experiment.

        Returns
        -------
        sample : 2D float sequence
            The points which constitute the design of experiments. The sampling method
            is defined by the nature of the experiment.
        weights : float sequence of size :math:`cardI`
            Weights :math:`(\\omega_i)_{i \\in I}` associated with the points. By default,
            all the weights are equal to :math:`1/cardI`.

        Examples
        --------
        >>> import openturns as ot
        >>> ot.RandomGenerator.SetSeed(0)
        >>> myExperiment = ot.MonteCarloExperiment(ot.Normal(2), 5)
        >>> sample, weights = myExperiment.generateWithWeights()
        >>> print(sample)
            [ marginal 1 marginal 2 ]
        0 : [  0.608202  -1.26617   ]
        1 : [ -0.438266   1.20548   ]
        2 : [ -2.18139    0.350042  ]
        3 : [ -0.355007   1.43725   ]
        4 : [  0.810668   0.793156  ]
        >>> print(weights)
        [0.2,0.2,0.2,0.2,0.2]
        """
        return _weightedexperiment.WeightedExperiment_generateWithWeights(self)

    def getWeight(self):
        """
        Accessor to the weights associated with the points.

        Returns
        -------
        weights : float sequence of size :math:`cardI`
            Weights :math:`(\\omega_i)_{i \\in I}` associated with the points. By default,
            all the weights are equal to :math:`1/cardI`.
        """
        return _weightedexperiment.WeightedExperiment_getWeight(self)

    def __init__(self, *args): 
        this = _weightedexperiment.new_WeightedExperiment(*args)
        try: self.this.append(this)
        except: self.this = this
    __swig_destroy__ = _weightedexperiment.delete_WeightedExperiment
    __del__ = lambda self : None;
WeightedExperiment_swigregister = _weightedexperiment.WeightedExperiment_swigregister
WeightedExperiment_swigregister(WeightedExperiment)

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

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

    def __repr__(self): return _weightedexperiment.BootstrapExperiment___repr__(self)
    def generate(self):
        """
        Generate points according to the type of the experiment.

        Returns
        -------
        sample : 2D float sequence
            Points :math:`(\\Xi_i)_{i \\in I}` which constitute the design of experiments
            with :math:`card I = size`. The sampling method is defined by the nature of
            the weighted experiment.

        Examples
        --------
        >>> import openturns as ot
        >>> ot.RandomGenerator.SetSeed(0)
        >>> myExperiment = ot.MonteCarloExperiment(ot.Normal(2), 5)
        >>> sample = myExperiment.generate()
        >>> print(sample)
            [ marginal 1 marginal 2 ]
        0 : [  0.608202  -1.26617   ]
        1 : [ -0.438266   1.20548   ]
        2 : [ -2.18139    0.350042  ]
        3 : [ -0.355007   1.43725   ]
        4 : [  0.810668   0.793156  ]
        """
        return _weightedexperiment.BootstrapExperiment_generate(self)

    def __init__(self, *args): 
        this = _weightedexperiment.new_BootstrapExperiment(*args)
        try: self.this.append(this)
        except: self.this = this
    __swig_destroy__ = _weightedexperiment.delete_BootstrapExperiment
    __del__ = lambda self : None;
BootstrapExperiment_swigregister = _weightedexperiment.BootstrapExperiment_swigregister
BootstrapExperiment_swigregister(BootstrapExperiment)

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

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

    def __repr__(self): return _weightedexperiment.FixedExperiment___repr__(self)
    def setDistribution(self, *args):
        """
        Accessor to the distribution.

        Parameters
        ----------
        distribution : :class:`~openturns.Distribution`
            Distribution used to generate the set of input data.
        """
        return _weightedexperiment.FixedExperiment_setDistribution(self, *args)

    def generate(self):
        """
        Generate points according to the type of the experiment.

        Returns
        -------
        sample : 2D float sequence
            Points :math:`(\\Xi_i)_{i \\in I}` which constitute the design of experiments
            with :math:`card I = size`. The sampling method is defined by the nature of
            the weighted experiment.

        Examples
        --------
        >>> import openturns as ot
        >>> ot.RandomGenerator.SetSeed(0)
        >>> myExperiment = ot.MonteCarloExperiment(ot.Normal(2), 5)
        >>> sample = myExperiment.generate()
        >>> print(sample)
            [ marginal 1 marginal 2 ]
        0 : [  0.608202  -1.26617   ]
        1 : [ -0.438266   1.20548   ]
        2 : [ -2.18139    0.350042  ]
        3 : [ -0.355007   1.43725   ]
        4 : [  0.810668   0.793156  ]
        """
        return _weightedexperiment.FixedExperiment_generate(self)

    def __init__(self, *args): 
        this = _weightedexperiment.new_FixedExperiment(*args)
        try: self.this.append(this)
        except: self.this = this
    __swig_destroy__ = _weightedexperiment.delete_FixedExperiment
    __del__ = lambda self : None;
FixedExperiment_swigregister = _weightedexperiment.FixedExperiment_swigregister
FixedExperiment_swigregister(FixedExperiment)

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

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

    def __repr__(self): return _weightedexperiment.GaussProductExperiment___repr__(self)
    def generate(self):
        """
        Generate points according to the type of the experiment.

        Returns
        -------
        sample : 2D float sequence
            Points :math:`(\\Xi_i)_{i \\in I}` which constitute the design of experiments
            with :math:`card I = size`. The sampling method is defined by the nature of
            the weighted experiment.

        Examples
        --------
        >>> import openturns as ot
        >>> ot.RandomGenerator.SetSeed(0)
        >>> myExperiment = ot.MonteCarloExperiment(ot.Normal(2), 5)
        >>> sample = myExperiment.generate()
        >>> print(sample)
            [ marginal 1 marginal 2 ]
        0 : [  0.608202  -1.26617   ]
        1 : [ -0.438266   1.20548   ]
        2 : [ -2.18139    0.350042  ]
        3 : [ -0.355007   1.43725   ]
        4 : [  0.810668   0.793156  ]
        """
        return _weightedexperiment.GaussProductExperiment_generate(self)

    def setMarginalDegrees(self, *args): return _weightedexperiment.GaussProductExperiment_setMarginalDegrees(self, *args)
    def getMarginalDegrees(self): return _weightedexperiment.GaussProductExperiment_getMarginalDegrees(self)
    def setDistribution(self, *args):
        """
        Accessor to the distribution.

        Parameters
        ----------
        distribution : :class:`~openturns.Distribution`
            Distribution used to generate the set of input data.
        """
        return _weightedexperiment.GaussProductExperiment_setDistribution(self, *args)

    def __init__(self, *args): 
        this = _weightedexperiment.new_GaussProductExperiment(*args)
        try: self.this.append(this)
        except: self.this = this
    __swig_destroy__ = _weightedexperiment.delete_GaussProductExperiment
    __del__ = lambda self : None;
GaussProductExperiment_swigregister = _weightedexperiment.GaussProductExperiment_swigregister
GaussProductExperiment_swigregister(GaussProductExperiment)

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

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

    def getImportanceDistribution(self): return _weightedexperiment.ImportanceSamplingExperiment_getImportanceDistribution(self)
    def __repr__(self): return _weightedexperiment.ImportanceSamplingExperiment___repr__(self)
    def generate(self, *args):
        """
        Generate points according to the type of the experiment.

        Returns
        -------
        sample : 2D float sequence
            Points :math:`(\\Xi_i)_{i \\in I}` which constitute the design of experiments
            with :math:`card I = size`. The sampling method is defined by the nature of
            the weighted experiment.

        Examples
        --------
        >>> import openturns as ot
        >>> ot.RandomGenerator.SetSeed(0)
        >>> myExperiment = ot.MonteCarloExperiment(ot.Normal(2), 5)
        >>> sample = myExperiment.generate()
        >>> print(sample)
            [ marginal 1 marginal 2 ]
        0 : [  0.608202  -1.26617   ]
        1 : [ -0.438266   1.20548   ]
        2 : [ -2.18139    0.350042  ]
        3 : [ -0.355007   1.43725   ]
        4 : [  0.810668   0.793156  ]
        """
        return _weightedexperiment.ImportanceSamplingExperiment_generate(self, *args)

    def __init__(self, *args): 
        this = _weightedexperiment.new_ImportanceSamplingExperiment(*args)
        try: self.this.append(this)
        except: self.this = this
    __swig_destroy__ = _weightedexperiment.delete_ImportanceSamplingExperiment
    __del__ = lambda self : None;
ImportanceSamplingExperiment_swigregister = _weightedexperiment.ImportanceSamplingExperiment_swigregister
ImportanceSamplingExperiment_swigregister(ImportanceSamplingExperiment)

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

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

    def __repr__(self): return _weightedexperiment.LHSExperiment___repr__(self)
    def generate(self):
        """
        Generate points according to the type of the experiment.

        Returns
        -------
        sample : 2D float sequence
            Points :math:`(\\Xi_i)_{i \\in I}` which constitute the design of experiments
            with :math:`card I = size`. The sampling method is defined by the nature of
            the weighted experiment.

        Examples
        --------
        >>> import openturns as ot
        >>> ot.RandomGenerator.SetSeed(0)
        >>> myExperiment = ot.MonteCarloExperiment(ot.Normal(2), 5)
        >>> sample = myExperiment.generate()
        >>> print(sample)
            [ marginal 1 marginal 2 ]
        0 : [  0.608202  -1.26617   ]
        1 : [ -0.438266   1.20548   ]
        2 : [ -2.18139    0.350042  ]
        3 : [ -0.355007   1.43725   ]
        4 : [  0.810668   0.793156  ]
        """
        return _weightedexperiment.LHSExperiment_generate(self)

    __swig_getmethods__["ComputeShuffle"] = lambda x: _weightedexperiment.LHSExperiment_ComputeShuffle
    if _newclass:ComputeShuffle = staticmethod(_weightedexperiment.LHSExperiment_ComputeShuffle)
    def getShuffle(self): return _weightedexperiment.LHSExperiment_getShuffle(self)
    def setDistribution(self, *args):
        """
        Accessor to the distribution.

        Parameters
        ----------
        distribution : :class:`~openturns.Distribution`
            Distribution used to generate the set of input data.
        """
        return _weightedexperiment.LHSExperiment_setDistribution(self, *args)

    def __init__(self, *args): 
        this = _weightedexperiment.new_LHSExperiment(*args)
        try: self.this.append(this)
        except: self.this = this
    __swig_destroy__ = _weightedexperiment.delete_LHSExperiment
    __del__ = lambda self : None;
LHSExperiment_swigregister = _weightedexperiment.LHSExperiment_swigregister
LHSExperiment_swigregister(LHSExperiment)

def LHSExperiment_ComputeShuffle(*args):
  return _weightedexperiment.LHSExperiment_ComputeShuffle(*args)
LHSExperiment_ComputeShuffle = _weightedexperiment.LHSExperiment_ComputeShuffle

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

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

    def __repr__(self): return _weightedexperiment.LowDiscrepancyExperiment___repr__(self)
    def setDistribution(self, *args):
        """
        Accessor to the distribution.

        Parameters
        ----------
        distribution : :class:`~openturns.Distribution`
            Distribution used to generate the set of input data.
        """
        return _weightedexperiment.LowDiscrepancyExperiment_setDistribution(self, *args)

    def getSequence(self): return _weightedexperiment.LowDiscrepancyExperiment_getSequence(self)
    def generate(self):
        """
        Generate points according to the type of the experiment.

        Returns
        -------
        sample : 2D float sequence
            Points :math:`(\\Xi_i)_{i \\in I}` which constitute the design of experiments
            with :math:`card I = size`. The sampling method is defined by the nature of
            the weighted experiment.

        Examples
        --------
        >>> import openturns as ot
        >>> ot.RandomGenerator.SetSeed(0)
        >>> myExperiment = ot.MonteCarloExperiment(ot.Normal(2), 5)
        >>> sample = myExperiment.generate()
        >>> print(sample)
            [ marginal 1 marginal 2 ]
        0 : [  0.608202  -1.26617   ]
        1 : [ -0.438266   1.20548   ]
        2 : [ -2.18139    0.350042  ]
        3 : [ -0.355007   1.43725   ]
        4 : [  0.810668   0.793156  ]
        """
        return _weightedexperiment.LowDiscrepancyExperiment_generate(self)

    def __init__(self, *args): 
        this = _weightedexperiment.new_LowDiscrepancyExperiment(*args)
        try: self.this.append(this)
        except: self.this = this
    __swig_destroy__ = _weightedexperiment.delete_LowDiscrepancyExperiment
    __del__ = lambda self : None;
LowDiscrepancyExperiment_swigregister = _weightedexperiment.LowDiscrepancyExperiment_swigregister
LowDiscrepancyExperiment_swigregister(LowDiscrepancyExperiment)

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

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

    def __repr__(self): return _weightedexperiment.MonteCarloExperiment___repr__(self)
    def generate(self):
        """
        Generate points according to the type of the experiment.

        Returns
        -------
        sample : 2D float sequence
            Points :math:`(\\Xi_i)_{i \\in I}` which constitute the design of experiments
            with :math:`card I = size`. The sampling method is defined by the nature of
            the weighted experiment.

        Examples
        --------
        >>> import openturns as ot
        >>> ot.RandomGenerator.SetSeed(0)
        >>> myExperiment = ot.MonteCarloExperiment(ot.Normal(2), 5)
        >>> sample = myExperiment.generate()
        >>> print(sample)
            [ marginal 1 marginal 2 ]
        0 : [  0.608202  -1.26617   ]
        1 : [ -0.438266   1.20548   ]
        2 : [ -2.18139    0.350042  ]
        3 : [ -0.355007   1.43725   ]
        4 : [  0.810668   0.793156  ]
        """
        return _weightedexperiment.MonteCarloExperiment_generate(self)

    def __init__(self, *args): 
        this = _weightedexperiment.new_MonteCarloExperiment(*args)
        try: self.this.append(this)
        except: self.this = this
    __swig_destroy__ = _weightedexperiment.delete_MonteCarloExperiment
    __del__ = lambda self : None;
MonteCarloExperiment_swigregister = _weightedexperiment.MonteCarloExperiment_swigregister
MonteCarloExperiment_swigregister(MonteCarloExperiment)

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