python-openturns 1.2-2 / usr / share / pyshared / openturns / experiment.py

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


"""
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('_experiment', [dirname(__file__)])
        except ImportError:
            import _experiment
            return _experiment
        if fp is not None:
            try:
                _mod = imp.load_module('_experiment', fp, pathname, description)
            finally:
                fp.close()
            return _mod
    _experiment = swig_import_helper()
    del swig_import_helper
else:
    import _experiment
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__ = _experiment.delete_SwigPyIterator
    __del__ = lambda self : None;
    def value(self):
        """value(SwigPyIterator self) -> PyObject *"""
        return _experiment.SwigPyIterator_value(self)

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

GCC_VERSION = _experiment.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
import openturns.statistics
import openturns.graph
import openturns.func
import openturns.geom
class ExperimentImplementation(openturns.common.PersistentObject):
    """Proxy of C++ OT::ExperimentImplementation class"""
    __swig_setmethods__ = {}
    for _s in [openturns.common.PersistentObject]: __swig_setmethods__.update(getattr(_s,'__swig_setmethods__',{}))
    __setattr__ = lambda self, name, value: _swig_setattr(self, ExperimentImplementation, name, value)
    __swig_getmethods__ = {}
    for _s in [openturns.common.PersistentObject]: __swig_getmethods__.update(getattr(_s,'__swig_getmethods__',{}))
    __getattr__ = lambda self, name: _swig_getattr(self, ExperimentImplementation, name)
    def GetClassName():
        """GetClassName() -> OT::String"""
        return _experiment.ExperimentImplementation_GetClassName()

    if _newclass:GetClassName = staticmethod(GetClassName)
    __swig_getmethods__["GetClassName"] = lambda x: GetClassName
    def getClassName(self):
        """getClassName(ExperimentImplementation self) -> OT::String"""
        return _experiment.ExperimentImplementation_getClassName(self)

    def __repr__(self):
        """__repr__(ExperimentImplementation self) -> OT::String"""
        return _experiment.ExperimentImplementation___repr__(self)

    def generate(self):
        """generate(ExperimentImplementation self) -> NumericalSample"""
        return _experiment.ExperimentImplementation_generate(self)

    def __init__(self, *args): 
        """
        __init__(OT::ExperimentImplementation self, OT::String const & name=DefaultName) -> ExperimentImplementation
        __init__(OT::ExperimentImplementation self) -> ExperimentImplementation
        __init__(OT::ExperimentImplementation self, ExperimentImplementation other) -> ExperimentImplementation
        """
        this = _experiment.new_ExperimentImplementation(*args)
        try: self.this.append(this)
        except: self.this = this
    __swig_destroy__ = _experiment.delete_ExperimentImplementation
    __del__ = lambda self : None;
ExperimentImplementation_swigregister = _experiment.ExperimentImplementation_swigregister
ExperimentImplementation_swigregister(ExperimentImplementation)

def ExperimentImplementation_GetClassName():
  """ExperimentImplementation_GetClassName() -> OT::String"""
  return _experiment.ExperimentImplementation_GetClassName()

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

    if _newclass:GetClassName = staticmethod(GetClassName)
    __swig_getmethods__["GetClassName"] = lambda x: GetClassName
    def getClassName(self):
        """getClassName(StratifiedExperiment self) -> OT::String"""
        return _experiment.StratifiedExperiment_getClassName(self)

    def __repr__(self):
        """__repr__(StratifiedExperiment self) -> OT::String"""
        return _experiment.StratifiedExperiment___repr__(self)

    def setCenter(self, *args):
        """setCenter(StratifiedExperiment self, NumericalPoint center)"""
        return _experiment.StratifiedExperiment_setCenter(self, *args)

    def getCenter(self):
        """getCenter(StratifiedExperiment self) -> NumericalPoint"""
        return _experiment.StratifiedExperiment_getCenter(self)

    def setLevels(self, *args):
        """setLevels(StratifiedExperiment self, NumericalPoint levels)"""
        return _experiment.StratifiedExperiment_setLevels(self, *args)

    def getLevels(self):
        """getLevels(StratifiedExperiment self) -> NumericalPoint"""
        return _experiment.StratifiedExperiment_getLevels(self)

    def __init__(self, *args): 
        """
        __init__(OT::StratifiedExperiment self, OT::String const & name=DefaultName) -> StratifiedExperiment
        __init__(OT::StratifiedExperiment self) -> StratifiedExperiment
        __init__(OT::StratifiedExperiment self, NumericalPoint center, NumericalPoint levels, OT::String const & name=DefaultName) -> StratifiedExperiment
        __init__(OT::StratifiedExperiment self, NumericalPoint center, NumericalPoint levels) -> StratifiedExperiment
        __init__(OT::StratifiedExperiment self, StratifiedExperiment other) -> StratifiedExperiment
        """
        this = _experiment.new_StratifiedExperiment(*args)
        try: self.this.append(this)
        except: self.this = this
    __swig_destroy__ = _experiment.delete_StratifiedExperiment
    __del__ = lambda self : None;
StratifiedExperiment_swigregister = _experiment.StratifiedExperiment_swigregister
StratifiedExperiment_swigregister(StratifiedExperiment)

def StratifiedExperiment_GetClassName():
  """StratifiedExperiment_GetClassName() -> OT::String"""
  return _experiment.StratifiedExperiment_GetClassName()

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

    def getImplementationAsPersistentObject(self):
        """getImplementationAsPersistentObject(ExperimentImplementationTypedInterfaceObject self) -> PersistentObjectPointer"""
        return _experiment.ExperimentImplementationTypedInterfaceObject_getImplementationAsPersistentObject(self)

    def setImplementationAsPersistentObject(self, *args):
        """setImplementationAsPersistentObject(ExperimentImplementationTypedInterfaceObject self, PersistentObjectPointer obj)"""
        return _experiment.ExperimentImplementationTypedInterfaceObject_setImplementationAsPersistentObject(self, *args)

    def swap(self, *args):
        """swap(ExperimentImplementationTypedInterfaceObject self, ExperimentImplementationTypedInterfaceObject other)"""
        return _experiment.ExperimentImplementationTypedInterfaceObject_swap(self, *args)

    def setName(self, *args):
        """setName(ExperimentImplementationTypedInterfaceObject self, OT::String const & name)"""
        return _experiment.ExperimentImplementationTypedInterfaceObject_setName(self, *args)

    def getName(self):
        """getName(ExperimentImplementationTypedInterfaceObject self) -> OT::String"""
        return _experiment.ExperimentImplementationTypedInterfaceObject_getName(self)

    def __eq__(self, *args):
        """__eq__(ExperimentImplementationTypedInterfaceObject self, ExperimentImplementationTypedInterfaceObject other) -> OT::Bool"""
        return _experiment.ExperimentImplementationTypedInterfaceObject___eq__(self, *args)

    __swig_destroy__ = _experiment.delete_ExperimentImplementationTypedInterfaceObject
    __del__ = lambda self : None;
ExperimentImplementationTypedInterfaceObject_swigregister = _experiment.ExperimentImplementationTypedInterfaceObject_swigregister
ExperimentImplementationTypedInterfaceObject_swigregister(ExperimentImplementationTypedInterfaceObject)

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

    if _newclass:GetClassName = staticmethod(GetClassName)
    __swig_getmethods__["GetClassName"] = lambda x: GetClassName
    def getClassName(self):
        """getClassName(Experiment self) -> OT::String"""
        return _experiment.Experiment_getClassName(self)

    def __repr__(self):
        """__repr__(Experiment self) -> OT::String"""
        return _experiment.Experiment___repr__(self)

    def generate(self):
        """generate(Experiment self) -> NumericalSample"""
        return _experiment.Experiment_generate(self)

    def setImplementation(self, *args):
        """setImplementation(Experiment self, OT::TypedInterfaceObject< OT::ExperimentImplementation >::Implementation const & p_implementation)"""
        return _experiment.Experiment_setImplementation(self, *args)

    def __init__(self, *args): 
        """
        __init__(OT::Experiment self, OT::String const & name=DefaultName) -> Experiment
        __init__(OT::Experiment self) -> Experiment
        __init__(OT::Experiment self, ExperimentImplementation implementation, OT::String const & name=DefaultName) -> Experiment
        __init__(OT::Experiment self, ExperimentImplementation implementation) -> Experiment
        __init__(OT::Experiment self, Experiment other) -> Experiment
        """
        this = _experiment.new_Experiment(*args)
        try: self.this.append(this)
        except: self.this = this
    __swig_destroy__ = _experiment.delete_Experiment
    __del__ = lambda self : None;
Experiment_swigregister = _experiment.Experiment_swigregister
Experiment_swigregister(Experiment)

def Experiment_GetClassName():
  """Experiment_GetClassName() -> OT::String"""
  return _experiment.Experiment_GetClassName()

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

    if _newclass:GetClassName = staticmethod(GetClassName)
    __swig_getmethods__["GetClassName"] = lambda x: GetClassName
    def getClassName(self):
        """getClassName(Axial self) -> OT::String"""
        return _experiment.Axial_getClassName(self)

    def generate(self):
        """generate(Axial self) -> NumericalSample"""
        return _experiment.Axial_generate(self)

    def __repr__(self):
        """__repr__(Axial self) -> OT::String"""
        return _experiment.Axial___repr__(self)

    def __init__(self, *args): 
        """
        __init__(OT::Axial self, OT::String const & name=DefaultName) -> Axial
        __init__(OT::Axial self) -> Axial
        __init__(OT::Axial self, NumericalPoint center, NumericalPoint levels, OT::String const & name=DefaultName) -> Axial
        __init__(OT::Axial self, NumericalPoint center, NumericalPoint levels) -> Axial
        __init__(OT::Axial self, OT::UnsignedLong const dimension, NumericalPoint levels, OT::String const & name=DefaultName) -> Axial
        __init__(OT::Axial self, OT::UnsignedLong const dimension, NumericalPoint levels) -> Axial
        __init__(OT::Axial self, Axial other) -> Axial
        """
        this = _experiment.new_Axial(*args)
        try: self.this.append(this)
        except: self.this = this
    __swig_destroy__ = _experiment.delete_Axial
    __del__ = lambda self : None;
Axial_swigregister = _experiment.Axial_swigregister
Axial_swigregister(Axial)

def Axial_GetClassName():
  """Axial_GetClassName() -> OT::String"""
  return _experiment.Axial_GetClassName()

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

    if _newclass:GetClassName = staticmethod(GetClassName)
    __swig_getmethods__["GetClassName"] = lambda x: GetClassName
    def getClassName(self):
        """getClassName(Composite self) -> OT::String"""
        return _experiment.Composite_getClassName(self)

    def generate(self):
        """generate(Composite self) -> NumericalSample"""
        return _experiment.Composite_generate(self)

    def __repr__(self):
        """__repr__(Composite self) -> OT::String"""
        return _experiment.Composite___repr__(self)

    def __init__(self, *args): 
        """
        __init__(OT::Composite self, OT::String const & name=DefaultName) -> Composite
        __init__(OT::Composite self) -> Composite
        __init__(OT::Composite self, NumericalPoint center, NumericalPoint levels, OT::String const & name=DefaultName) -> Composite
        __init__(OT::Composite self, NumericalPoint center, NumericalPoint levels) -> Composite
        __init__(OT::Composite self, OT::UnsignedLong const dimension, NumericalPoint levels, OT::String const & name=DefaultName) -> Composite
        __init__(OT::Composite self, OT::UnsignedLong const dimension, NumericalPoint levels) -> Composite
        __init__(OT::Composite self, Composite other) -> Composite
        """
        this = _experiment.new_Composite(*args)
        try: self.this.append(this)
        except: self.this = this
    __swig_destroy__ = _experiment.delete_Composite
    __del__ = lambda self : None;
Composite_swigregister = _experiment.Composite_swigregister
Composite_swigregister(Composite)

def Composite_GetClassName():
  """Composite_GetClassName() -> OT::String"""
  return _experiment.Composite_GetClassName()

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

    if _newclass:GetClassName = staticmethod(GetClassName)
    __swig_getmethods__["GetClassName"] = lambda x: GetClassName
    def getClassName(self):
        """getClassName(Factorial self) -> OT::String"""
        return _experiment.Factorial_getClassName(self)

    def generate(self):
        """generate(Factorial self) -> NumericalSample"""
        return _experiment.Factorial_generate(self)

    def __repr__(self):
        """__repr__(Factorial self) -> OT::String"""
        return _experiment.Factorial___repr__(self)

    def __init__(self, *args): 
        """
        __init__(OT::Factorial self, OT::String const & name=DefaultName) -> Factorial
        __init__(OT::Factorial self) -> Factorial
        __init__(OT::Factorial self, NumericalPoint center, NumericalPoint levels, OT::String const & name=DefaultName) -> Factorial
        __init__(OT::Factorial self, NumericalPoint center, NumericalPoint levels) -> Factorial
        __init__(OT::Factorial self, OT::UnsignedLong const dimension, NumericalPoint levels, OT::String const & name=DefaultName) -> Factorial
        __init__(OT::Factorial self, OT::UnsignedLong const dimension, NumericalPoint levels) -> Factorial
        __init__(OT::Factorial self, Factorial other) -> Factorial
        """
        this = _experiment.new_Factorial(*args)
        try: self.this.append(this)
        except: self.this = this
    __swig_destroy__ = _experiment.delete_Factorial
    __del__ = lambda self : None;
Factorial_swigregister = _experiment.Factorial_swigregister
Factorial_swigregister(Factorial)

def Factorial_GetClassName():
  """Factorial_GetClassName() -> OT::String"""
  return _experiment.Factorial_GetClassName()

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

    if _newclass:GetClassName = staticmethod(GetClassName)
    __swig_getmethods__["GetClassName"] = lambda x: GetClassName
    def getClassName(self):
        """getClassName(Box self) -> OT::String"""
        return _experiment.Box_getClassName(self)

    def generate(self):
        """generate(Box self) -> NumericalSample"""
        return _experiment.Box_generate(self)

    def __repr__(self):
        """__repr__(Box self) -> OT::String"""
        return _experiment.Box___repr__(self)

    def setLevels(self, *args):
        """setLevels(Box self, NumericalPoint levels)"""
        return _experiment.Box_setLevels(self, *args)

    def __init__(self, *args): 
        """
        __init__(OT::Box self, OT::String const & name=DefaultName) -> Box
        __init__(OT::Box self) -> Box
        __init__(OT::Box self, NumericalPoint levels, OT::String const & name=DefaultName) -> Box
        __init__(OT::Box self, NumericalPoint levels) -> Box
        __init__(OT::Box self, Indices levels, OT::String const & name=DefaultName) -> Box
        __init__(OT::Box self, Indices levels) -> Box
        __init__(OT::Box self, Box other) -> Box
        """
        this = _experiment.new_Box(*args)
        try: self.this.append(this)
        except: self.this = this
    __swig_destroy__ = _experiment.delete_Box
    __del__ = lambda self : None;
Box_swigregister = _experiment.Box_swigregister
Box_swigregister(Box)

def Box_GetClassName():
  """Box_GetClassName() -> OT::String"""
  return _experiment.Box_GetClassName()

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

    if _newclass:GetClassName = staticmethod(GetClassName)
    __swig_getmethods__["GetClassName"] = lambda x: GetClassName
    def getClassName(self):
        """getClassName(CombinatorialGeneratorImplementation self) -> OT::String"""
        return _experiment.CombinatorialGeneratorImplementation_getClassName(self)

    def __repr__(self):
        """__repr__(CombinatorialGeneratorImplementation self) -> OT::String"""
        return _experiment.CombinatorialGeneratorImplementation___repr__(self)

    def generate(self):
        """generate(CombinatorialGeneratorImplementation self) -> IndicesCollection"""
        return _experiment.CombinatorialGeneratorImplementation_generate(self)

    def __init__(self, *args): 
        """
        __init__(OT::CombinatorialGeneratorImplementation self) -> CombinatorialGeneratorImplementation
        __init__(OT::CombinatorialGeneratorImplementation self, CombinatorialGeneratorImplementation other) -> CombinatorialGeneratorImplementation
        """
        this = _experiment.new_CombinatorialGeneratorImplementation(*args)
        try: self.this.append(this)
        except: self.this = this
    __swig_destroy__ = _experiment.delete_CombinatorialGeneratorImplementation
    __del__ = lambda self : None;
CombinatorialGeneratorImplementation_swigregister = _experiment.CombinatorialGeneratorImplementation_swigregister
CombinatorialGeneratorImplementation_swigregister(CombinatorialGeneratorImplementation)

def CombinatorialGeneratorImplementation_GetClassName():
  """CombinatorialGeneratorImplementation_GetClassName() -> OT::String"""
  return _experiment.CombinatorialGeneratorImplementation_GetClassName()

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

    def getImplementationAsPersistentObject(self):
        """getImplementationAsPersistentObject(CombinatorialGeneratorImplementationTypedInterfaceObject self) -> PersistentObjectPointer"""
        return _experiment.CombinatorialGeneratorImplementationTypedInterfaceObject_getImplementationAsPersistentObject(self)

    def setImplementationAsPersistentObject(self, *args):
        """setImplementationAsPersistentObject(CombinatorialGeneratorImplementationTypedInterfaceObject self, PersistentObjectPointer obj)"""
        return _experiment.CombinatorialGeneratorImplementationTypedInterfaceObject_setImplementationAsPersistentObject(self, *args)

    def swap(self, *args):
        """swap(CombinatorialGeneratorImplementationTypedInterfaceObject self, CombinatorialGeneratorImplementationTypedInterfaceObject other)"""
        return _experiment.CombinatorialGeneratorImplementationTypedInterfaceObject_swap(self, *args)

    def setName(self, *args):
        """setName(CombinatorialGeneratorImplementationTypedInterfaceObject self, OT::String const & name)"""
        return _experiment.CombinatorialGeneratorImplementationTypedInterfaceObject_setName(self, *args)

    def getName(self):
        """getName(CombinatorialGeneratorImplementationTypedInterfaceObject self) -> OT::String"""
        return _experiment.CombinatorialGeneratorImplementationTypedInterfaceObject_getName(self)

    def __eq__(self, *args):
        """__eq__(CombinatorialGeneratorImplementationTypedInterfaceObject self, CombinatorialGeneratorImplementationTypedInterfaceObject other) -> OT::Bool"""
        return _experiment.CombinatorialGeneratorImplementationTypedInterfaceObject___eq__(self, *args)

    __swig_destroy__ = _experiment.delete_CombinatorialGeneratorImplementationTypedInterfaceObject
    __del__ = lambda self : None;
CombinatorialGeneratorImplementationTypedInterfaceObject_swigregister = _experiment.CombinatorialGeneratorImplementationTypedInterfaceObject_swigregister
CombinatorialGeneratorImplementationTypedInterfaceObject_swigregister(CombinatorialGeneratorImplementationTypedInterfaceObject)

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

    if _newclass:GetClassName = staticmethod(GetClassName)
    __swig_getmethods__["GetClassName"] = lambda x: GetClassName
    def getClassName(self):
        """getClassName(CombinatorialGenerator self) -> OT::String"""
        return _experiment.CombinatorialGenerator_getClassName(self)

    def __repr__(self):
        """__repr__(CombinatorialGenerator self) -> OT::String"""
        return _experiment.CombinatorialGenerator___repr__(self)

    def generate(self):
        """generate(CombinatorialGenerator self) -> IndicesCollection"""
        return _experiment.CombinatorialGenerator_generate(self)

    def setImplementation(self, *args):
        """setImplementation(CombinatorialGenerator self, OT::TypedInterfaceObject< OT::CombinatorialGeneratorImplementation >::Implementation const & p_implementation)"""
        return _experiment.CombinatorialGenerator_setImplementation(self, *args)

    def __init__(self, *args): 
        """
        __init__(OT::CombinatorialGenerator self) -> CombinatorialGenerator
        __init__(OT::CombinatorialGenerator self, CombinatorialGeneratorImplementation implementation) -> CombinatorialGenerator
        __init__(OT::CombinatorialGenerator self, CombinatorialGenerator other) -> CombinatorialGenerator
        """
        this = _experiment.new_CombinatorialGenerator(*args)
        try: self.this.append(this)
        except: self.this = this
    __swig_destroy__ = _experiment.delete_CombinatorialGenerator
    __del__ = lambda self : None;
CombinatorialGenerator_swigregister = _experiment.CombinatorialGenerator_swigregister
CombinatorialGenerator_swigregister(CombinatorialGenerator)

def CombinatorialGenerator_GetClassName():
  """CombinatorialGenerator_GetClassName() -> OT::String"""
  return _experiment.CombinatorialGenerator_GetClassName()

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

    if _newclass:GetClassName = staticmethod(GetClassName)
    __swig_getmethods__["GetClassName"] = lambda x: GetClassName
    def getClassName(self):
        """getClassName(Combinations self) -> OT::String"""
        return _experiment.Combinations_getClassName(self)

    def generate(self):
        """generate(Combinations self) -> IndicesCollection"""
        return _experiment.Combinations_generate(self)

    def __repr__(self):
        """__repr__(Combinations self) -> OT::String"""
        return _experiment.Combinations___repr__(self)

    def setK(self, *args):
        """setK(Combinations self, OT::UnsignedLong const k)"""
        return _experiment.Combinations_setK(self, *args)

    def getK(self):
        """getK(Combinations self) -> OT::UnsignedLong"""
        return _experiment.Combinations_getK(self)

    def setN(self, *args):
        """setN(Combinations self, OT::UnsignedLong const n)"""
        return _experiment.Combinations_setN(self, *args)

    def getN(self):
        """getN(Combinations self) -> OT::UnsignedLong"""
        return _experiment.Combinations_getN(self)

    def __init__(self, *args): 
        """
        __init__(OT::Combinations self) -> Combinations
        __init__(OT::Combinations self, OT::UnsignedLong const k, OT::UnsignedLong const n) -> Combinations
        __init__(OT::Combinations self, Combinations other) -> Combinations
        """
        this = _experiment.new_Combinations(*args)
        try: self.this.append(this)
        except: self.this = this
    __swig_destroy__ = _experiment.delete_Combinations
    __del__ = lambda self : None;
Combinations_swigregister = _experiment.Combinations_swigregister
Combinations_swigregister(Combinations)

def Combinations_GetClassName():
  """Combinations_GetClassName() -> OT::String"""
  return _experiment.Combinations_GetClassName()

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

    if _newclass:GetClassName = staticmethod(GetClassName)
    __swig_getmethods__["GetClassName"] = lambda x: GetClassName
    def getClassName(self):
        """getClassName(KPermutations self) -> OT::String"""
        return _experiment.KPermutations_getClassName(self)

    def generate(self):
        """generate(KPermutations self) -> IndicesCollection"""
        return _experiment.KPermutations_generate(self)

    def __repr__(self):
        """__repr__(KPermutations self) -> OT::String"""
        return _experiment.KPermutations___repr__(self)

    def setK(self, *args):
        """setK(KPermutations self, OT::UnsignedLong const k)"""
        return _experiment.KPermutations_setK(self, *args)

    def getK(self):
        """getK(KPermutations self) -> OT::UnsignedLong"""
        return _experiment.KPermutations_getK(self)

    def setN(self, *args):
        """setN(KPermutations self, OT::UnsignedLong const n)"""
        return _experiment.KPermutations_setN(self, *args)

    def getN(self):
        """getN(KPermutations self) -> OT::UnsignedLong"""
        return _experiment.KPermutations_getN(self)

    def __init__(self, *args): 
        """
        __init__(OT::KPermutations self) -> KPermutations
        __init__(OT::KPermutations self, OT::UnsignedLong const n) -> KPermutations
        __init__(OT::KPermutations self, OT::UnsignedLong const k, OT::UnsignedLong const n) -> KPermutations
        __init__(OT::KPermutations self, KPermutations other) -> KPermutations
        """
        this = _experiment.new_KPermutations(*args)
        try: self.this.append(this)
        except: self.this = this
    __swig_destroy__ = _experiment.delete_KPermutations
    __del__ = lambda self : None;
KPermutations_swigregister = _experiment.KPermutations_swigregister
KPermutations_swigregister(KPermutations)

def KPermutations_GetClassName():
  """KPermutations_GetClassName() -> OT::String"""
  return _experiment.KPermutations_GetClassName()

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

    if _newclass:GetClassName = staticmethod(GetClassName)
    __swig_getmethods__["GetClassName"] = lambda x: GetClassName
    def getClassName(self):
        """getClassName(Tuples self) -> OT::String"""
        return _experiment.Tuples_getClassName(self)

    def generate(self):
        """generate(Tuples self) -> IndicesCollection"""
        return _experiment.Tuples_generate(self)

    def __repr__(self):
        """__repr__(Tuples self) -> OT::String"""
        return _experiment.Tuples___repr__(self)

    def setBounds(self, *args):
        """setBounds(Tuples self, Indices bounds)"""
        return _experiment.Tuples_setBounds(self, *args)

    def getBounds(self):
        """getBounds(Tuples self) -> Indices"""
        return _experiment.Tuples_getBounds(self)

    def __init__(self, *args): 
        """
        __init__(OT::Tuples self) -> Tuples
        __init__(OT::Tuples self, Indices bounds) -> Tuples
        __init__(OT::Tuples self, Tuples other) -> Tuples
        """
        this = _experiment.new_Tuples(*args)
        try: self.this.append(this)
        except: self.this = this
    __swig_destroy__ = _experiment.delete_Tuples
    __del__ = lambda self : None;
Tuples_swigregister = _experiment.Tuples_swigregister
Tuples_swigregister(Tuples)

def Tuples_GetClassName():
  """Tuples_GetClassName() -> OT::String"""
  return _experiment.Tuples_GetClassName()

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