python-openturns 1.2-2 / usr / share / pyshared / openturns / dist_bundle1.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.


"""
Probabilistic distributions.
"""


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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

GCC_VERSION = _dist_bundle1.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 _dist_bundle1.TestResult_GetClassName()

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

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

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

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

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

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

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

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

    def __eq__(self, *args):
        """__eq__(TestResult self, TestResult other) -> OT::Bool"""
        return _dist_bundle1.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 = _dist_bundle1.new_TestResult(*args)
        try: self.this.append(this)
        except: self.this = this
    __swig_destroy__ = _dist_bundle1.delete_TestResult
    __del__ = lambda self : None;
TestResult_swigregister = _dist_bundle1.TestResult_swigregister
TestResult_swigregister(TestResult)

def TestResult_GetClassName():
  """TestResult_GetClassName() -> OT::String"""
  return _dist_bundle1.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
class DistFunc(_object):
    """Proxy of C++ OT::DistFunc class"""
    __swig_setmethods__ = {}
    __setattr__ = lambda self, name, value: _swig_setattr(self, DistFunc, name, value)
    __swig_getmethods__ = {}
    __getattr__ = lambda self, name: _swig_getattr(self, DistFunc, name)
    __repr__ = _swig_repr
    def pBeta(*args):
        """
        pBeta(OT::NumericalScalar const p1, OT::NumericalScalar const p2, OT::NumericalScalar const x, 
            OT::Bool const tail=False) -> OT::NumericalScalar
        pBeta(OT::NumericalScalar const p1, OT::NumericalScalar const p2, OT::NumericalScalar const x) -> OT::NumericalScalar
        """
        return _dist_bundle1.DistFunc_pBeta(*args)

    if _newclass:pBeta = staticmethod(pBeta)
    __swig_getmethods__["pBeta"] = lambda x: pBeta
    def qBeta(*args):
        """
        qBeta(OT::NumericalScalar const p1, OT::NumericalScalar const p2, OT::NumericalScalar const q, 
            OT::Bool const tail=False) -> OT::NumericalScalar
        qBeta(OT::NumericalScalar const p1, OT::NumericalScalar const p2, OT::NumericalScalar const q) -> OT::NumericalScalar
        """
        return _dist_bundle1.DistFunc_qBeta(*args)

    if _newclass:qBeta = staticmethod(qBeta)
    __swig_getmethods__["qBeta"] = lambda x: qBeta
    def rBeta(*args):
        """rBeta(OT::NumericalScalar const p1, OT::NumericalScalar const p2) -> OT::NumericalScalar"""
        return _dist_bundle1.DistFunc_rBeta(*args)

    if _newclass:rBeta = staticmethod(rBeta)
    __swig_getmethods__["rBeta"] = lambda x: rBeta
    def rBinomial(*args):
        """rBinomial(OT::UnsignedLong const n, OT::NumericalScalar const p) -> OT::UnsignedLong"""
        return _dist_bundle1.DistFunc_rBinomial(*args)

    if _newclass:rBinomial = staticmethod(rBinomial)
    __swig_getmethods__["rBinomial"] = lambda x: rBinomial
    def pGamma(*args):
        """
        pGamma(OT::NumericalScalar const k, OT::NumericalScalar const x, OT::Bool const tail=False) -> OT::NumericalScalar
        pGamma(OT::NumericalScalar const k, OT::NumericalScalar const x) -> OT::NumericalScalar
        """
        return _dist_bundle1.DistFunc_pGamma(*args)

    if _newclass:pGamma = staticmethod(pGamma)
    __swig_getmethods__["pGamma"] = lambda x: pGamma
    def qGamma(*args):
        """
        qGamma(OT::NumericalScalar const k, OT::NumericalScalar const q, OT::Bool const tail=False) -> OT::NumericalScalar
        qGamma(OT::NumericalScalar const k, OT::NumericalScalar const q) -> OT::NumericalScalar
        """
        return _dist_bundle1.DistFunc_qGamma(*args)

    if _newclass:qGamma = staticmethod(qGamma)
    __swig_getmethods__["qGamma"] = lambda x: qGamma
    def rGamma(*args):
        """rGamma(OT::NumericalScalar const k) -> OT::NumericalScalar"""
        return _dist_bundle1.DistFunc_rGamma(*args)

    if _newclass:rGamma = staticmethod(rGamma)
    __swig_getmethods__["rGamma"] = lambda x: rGamma
    def pKolmogorov(*args):
        """
        pKolmogorov(OT::UnsignedLong const n, OT::NumericalScalar const x, OT::Bool const tail=False) -> OT::NumericalScalar
        pKolmogorov(OT::UnsignedLong const n, OT::NumericalScalar const x) -> OT::NumericalScalar
        """
        return _dist_bundle1.DistFunc_pKolmogorov(*args)

    if _newclass:pKolmogorov = staticmethod(pKolmogorov)
    __swig_getmethods__["pKolmogorov"] = lambda x: pKolmogorov
    def dNonCentralChiSquare(*args):
        """dNonCentralChiSquare(OT::NumericalScalar const nu, OT::NumericalScalar const _lambda, OT::NumericalScalar const x) -> OT::NumericalScalar"""
        return _dist_bundle1.DistFunc_dNonCentralChiSquare(*args)

    if _newclass:dNonCentralChiSquare = staticmethod(dNonCentralChiSquare)
    __swig_getmethods__["dNonCentralChiSquare"] = lambda x: dNonCentralChiSquare
    def pNonCentralChiSquare(*args):
        """
        pNonCentralChiSquare(OT::NumericalScalar const nu, OT::NumericalScalar const _lambda, OT::NumericalScalar const x, 
            OT::Bool const tail=False) -> OT::NumericalScalar
        pNonCentralChiSquare(OT::NumericalScalar const nu, OT::NumericalScalar const _lambda, OT::NumericalScalar const x) -> OT::NumericalScalar
        """
        return _dist_bundle1.DistFunc_pNonCentralChiSquare(*args)

    if _newclass:pNonCentralChiSquare = staticmethod(pNonCentralChiSquare)
    __swig_getmethods__["pNonCentralChiSquare"] = lambda x: pNonCentralChiSquare
    def rNonCentralChiSquare(*args):
        """rNonCentralChiSquare(OT::NumericalScalar const nu, OT::NumericalScalar const _lambda) -> OT::NumericalScalar"""
        return _dist_bundle1.DistFunc_rNonCentralChiSquare(*args)

    if _newclass:rNonCentralChiSquare = staticmethod(rNonCentralChiSquare)
    __swig_getmethods__["rNonCentralChiSquare"] = lambda x: rNonCentralChiSquare
    def dNonCentralStudent(*args):
        """dNonCentralStudent(OT::NumericalScalar const nu, OT::NumericalScalar const delta, OT::NumericalScalar const x) -> OT::NumericalScalar"""
        return _dist_bundle1.DistFunc_dNonCentralStudent(*args)

    if _newclass:dNonCentralStudent = staticmethod(dNonCentralStudent)
    __swig_getmethods__["dNonCentralStudent"] = lambda x: dNonCentralStudent
    def pNonCentralStudent(*args):
        """
        pNonCentralStudent(OT::NumericalScalar const nu, OT::NumericalScalar const delta, OT::NumericalScalar const x, 
            OT::Bool const tail=False) -> OT::NumericalScalar
        pNonCentralStudent(OT::NumericalScalar const nu, OT::NumericalScalar const delta, OT::NumericalScalar const x) -> OT::NumericalScalar
        """
        return _dist_bundle1.DistFunc_pNonCentralStudent(*args)

    if _newclass:pNonCentralStudent = staticmethod(pNonCentralStudent)
    __swig_getmethods__["pNonCentralStudent"] = lambda x: pNonCentralStudent
    def pNonCentralStudentAlt(*args):
        """
        pNonCentralStudentAlt(OT::NumericalScalar const nu, OT::NumericalScalar const delta, OT::NumericalScalar const x, 
            OT::Bool const tail=False) -> OT::NumericalScalar
        pNonCentralStudentAlt(OT::NumericalScalar const nu, OT::NumericalScalar const delta, OT::NumericalScalar const x) -> OT::NumericalScalar
        """
        return _dist_bundle1.DistFunc_pNonCentralStudentAlt(*args)

    if _newclass:pNonCentralStudentAlt = staticmethod(pNonCentralStudentAlt)
    __swig_getmethods__["pNonCentralStudentAlt"] = lambda x: pNonCentralStudentAlt
    def rNonCentralStudent(*args):
        """rNonCentralStudent(OT::NumericalScalar const nu, OT::NumericalScalar const delta) -> OT::NumericalScalar"""
        return _dist_bundle1.DistFunc_rNonCentralStudent(*args)

    if _newclass:rNonCentralStudent = staticmethod(rNonCentralStudent)
    __swig_getmethods__["rNonCentralStudent"] = lambda x: rNonCentralStudent
    def pNormal(*args):
        """
        pNormal(OT::NumericalScalar const x, OT::Bool const tail=False) -> OT::NumericalScalar
        pNormal(OT::NumericalScalar const x) -> OT::NumericalScalar
        """
        return _dist_bundle1.DistFunc_pNormal(*args)

    if _newclass:pNormal = staticmethod(pNormal)
    __swig_getmethods__["pNormal"] = lambda x: pNormal
    def pNormal2D(*args):
        """
        pNormal2D(OT::NumericalScalar const x1, OT::NumericalScalar const x2, OT::NumericalScalar const rho, 
            OT::Bool const tail=False, OT::Bool const newAlgo=True) -> OT::NumericalScalar
        pNormal2D(OT::NumericalScalar const x1, OT::NumericalScalar const x2, OT::NumericalScalar const rho, 
            OT::Bool const tail=False) -> OT::NumericalScalar
        pNormal2D(OT::NumericalScalar const x1, OT::NumericalScalar const x2, OT::NumericalScalar const rho) -> OT::NumericalScalar
        """
        return _dist_bundle1.DistFunc_pNormal2D(*args)

    if _newclass:pNormal2D = staticmethod(pNormal2D)
    __swig_getmethods__["pNormal2D"] = lambda x: pNormal2D
    def pNormal3D(*args):
        """
        pNormal3D(OT::NumericalScalar const x1, OT::NumericalScalar const x2, OT::NumericalScalar const x3, 
            OT::NumericalScalar const rho12, OT::NumericalScalar const rho13, 
            OT::NumericalScalar const rho23, OT::Bool const tail=False, OT::Bool const newAlgo=True) -> OT::NumericalScalar
        pNormal3D(OT::NumericalScalar const x1, OT::NumericalScalar const x2, OT::NumericalScalar const x3, 
            OT::NumericalScalar const rho12, OT::NumericalScalar const rho13, 
            OT::NumericalScalar const rho23, OT::Bool const tail=False) -> OT::NumericalScalar
        pNormal3D(OT::NumericalScalar const x1, OT::NumericalScalar const x2, OT::NumericalScalar const x3, 
            OT::NumericalScalar const rho12, OT::NumericalScalar const rho13, 
            OT::NumericalScalar const rho23) -> OT::NumericalScalar
        """
        return _dist_bundle1.DistFunc_pNormal3D(*args)

    if _newclass:pNormal3D = staticmethod(pNormal3D)
    __swig_getmethods__["pNormal3D"] = lambda x: pNormal3D
    def qNormal(*args):
        """
        qNormal(OT::NumericalScalar const q, OT::Bool const tail=False) -> OT::NumericalScalar
        qNormal(OT::NumericalScalar const q) -> OT::NumericalScalar
        """
        return _dist_bundle1.DistFunc_qNormal(*args)

    if _newclass:qNormal = staticmethod(qNormal)
    __swig_getmethods__["qNormal"] = lambda x: qNormal
    def rNormal():
        """rNormal() -> OT::NumericalScalar"""
        return _dist_bundle1.DistFunc_rNormal()

    if _newclass:rNormal = staticmethod(rNormal)
    __swig_getmethods__["rNormal"] = lambda x: rNormal
    def rPoisson(*args):
        """rPoisson(OT::NumericalScalar const _lambda) -> OT::NumericalScalar"""
        return _dist_bundle1.DistFunc_rPoisson(*args)

    if _newclass:rPoisson = staticmethod(rPoisson)
    __swig_getmethods__["rPoisson"] = lambda x: rPoisson
    def pStudent(*args):
        """
        pStudent(OT::NumericalScalar const nu, OT::NumericalScalar const x, OT::Bool const tail=False) -> OT::NumericalScalar
        pStudent(OT::NumericalScalar const nu, OT::NumericalScalar const x) -> OT::NumericalScalar
        """
        return _dist_bundle1.DistFunc_pStudent(*args)

    if _newclass:pStudent = staticmethod(pStudent)
    __swig_getmethods__["pStudent"] = lambda x: pStudent
    def qStudent(*args):
        """
        qStudent(OT::NumericalScalar const nu, OT::NumericalScalar const q, OT::Bool const tail=False) -> OT::NumericalScalar
        qStudent(OT::NumericalScalar const nu, OT::NumericalScalar const q) -> OT::NumericalScalar
        """
        return _dist_bundle1.DistFunc_qStudent(*args)

    if _newclass:qStudent = staticmethod(qStudent)
    __swig_getmethods__["qStudent"] = lambda x: qStudent
    def rStudent(*args):
        """rStudent(OT::NumericalScalar const nu) -> OT::NumericalScalar"""
        return _dist_bundle1.DistFunc_rStudent(*args)

    if _newclass:rStudent = staticmethod(rStudent)
    __swig_getmethods__["rStudent"] = lambda x: rStudent
    def eZ1(*args):
        """eZ1(OT::UnsignedLong const n) -> OT::NumericalScalar"""
        return _dist_bundle1.DistFunc_eZ1(*args)

    if _newclass:eZ1 = staticmethod(eZ1)
    __swig_getmethods__["eZ1"] = lambda x: eZ1
    def pDickeyFullerTrend(*args):
        """
        pDickeyFullerTrend(OT::NumericalScalar const x, OT::Bool tail=False) -> OT::NumericalScalar
        pDickeyFullerTrend(OT::NumericalScalar const x) -> OT::NumericalScalar
        """
        return _dist_bundle1.DistFunc_pDickeyFullerTrend(*args)

    if _newclass:pDickeyFullerTrend = staticmethod(pDickeyFullerTrend)
    __swig_getmethods__["pDickeyFullerTrend"] = lambda x: pDickeyFullerTrend
    def pDickeyFullerConstant(*args):
        """
        pDickeyFullerConstant(OT::NumericalScalar const x, OT::Bool tail=False) -> OT::NumericalScalar
        pDickeyFullerConstant(OT::NumericalScalar const x) -> OT::NumericalScalar
        """
        return _dist_bundle1.DistFunc_pDickeyFullerConstant(*args)

    if _newclass:pDickeyFullerConstant = staticmethod(pDickeyFullerConstant)
    __swig_getmethods__["pDickeyFullerConstant"] = lambda x: pDickeyFullerConstant
    def pDickeyFullerNoConstant(*args):
        """
        pDickeyFullerNoConstant(OT::NumericalScalar const x, OT::Bool tail=False) -> OT::NumericalScalar
        pDickeyFullerNoConstant(OT::NumericalScalar const x) -> OT::NumericalScalar
        """
        return _dist_bundle1.DistFunc_pDickeyFullerNoConstant(*args)

    if _newclass:pDickeyFullerNoConstant = staticmethod(pDickeyFullerNoConstant)
    __swig_getmethods__["pDickeyFullerNoConstant"] = lambda x: pDickeyFullerNoConstant
    def qDickeyFullerTrend(*args):
        """
        qDickeyFullerTrend(OT::NumericalScalar const q, OT::Bool tail=False) -> OT::NumericalScalar
        qDickeyFullerTrend(OT::NumericalScalar const q) -> OT::NumericalScalar
        """
        return _dist_bundle1.DistFunc_qDickeyFullerTrend(*args)

    if _newclass:qDickeyFullerTrend = staticmethod(qDickeyFullerTrend)
    __swig_getmethods__["qDickeyFullerTrend"] = lambda x: qDickeyFullerTrend
    def qDickeyFullerConstant(*args):
        """
        qDickeyFullerConstant(OT::NumericalScalar const q, OT::Bool tail=False) -> OT::NumericalScalar
        qDickeyFullerConstant(OT::NumericalScalar const q) -> OT::NumericalScalar
        """
        return _dist_bundle1.DistFunc_qDickeyFullerConstant(*args)

    if _newclass:qDickeyFullerConstant = staticmethod(qDickeyFullerConstant)
    __swig_getmethods__["qDickeyFullerConstant"] = lambda x: qDickeyFullerConstant
    def qDickeyFullerNoConstant(*args):
        """
        qDickeyFullerNoConstant(OT::NumericalScalar const q, OT::Bool tail=False) -> OT::NumericalScalar
        qDickeyFullerNoConstant(OT::NumericalScalar const q) -> OT::NumericalScalar
        """
        return _dist_bundle1.DistFunc_qDickeyFullerNoConstant(*args)

    if _newclass:qDickeyFullerNoConstant = staticmethod(qDickeyFullerNoConstant)
    __swig_getmethods__["qDickeyFullerNoConstant"] = lambda x: qDickeyFullerNoConstant
    def __init__(self, *args): 
        """__init__(OT::DistFunc self, DistFunc other) -> DistFunc"""
        this = _dist_bundle1.new_DistFunc(*args)
        try: self.this.append(this)
        except: self.this = this
    __swig_destroy__ = _dist_bundle1.delete_DistFunc
    __del__ = lambda self : None;
DistFunc_swigregister = _dist_bundle1.DistFunc_swigregister
DistFunc_swigregister(DistFunc)
cvar = _dist_bundle1.cvar
DistFunc.NumberOfBandNormalZigurrat = _dist_bundle1.cvar.DistFunc_NumberOfBandNormalZigurrat
DistFunc.NormalZigguratTail = _dist_bundle1.cvar.DistFunc_NormalZigguratTail
DistFunc.NormalZigguratAbscissa = _dist_bundle1.cvar.DistFunc_NormalZigguratAbscissa
DistFunc.NormalZigguratRatio = _dist_bundle1.cvar.DistFunc_NormalZigguratRatio

def DistFunc_pBeta(*args):
  """
    pBeta(OT::NumericalScalar const p1, OT::NumericalScalar const p2, OT::NumericalScalar const x, 
        OT::Bool const tail=False) -> OT::NumericalScalar
    DistFunc_pBeta(OT::NumericalScalar const p1, OT::NumericalScalar const p2, OT::NumericalScalar const x) -> OT::NumericalScalar
    """
  return _dist_bundle1.DistFunc_pBeta(*args)

def DistFunc_qBeta(*args):
  """
    qBeta(OT::NumericalScalar const p1, OT::NumericalScalar const p2, OT::NumericalScalar const q, 
        OT::Bool const tail=False) -> OT::NumericalScalar
    DistFunc_qBeta(OT::NumericalScalar const p1, OT::NumericalScalar const p2, OT::NumericalScalar const q) -> OT::NumericalScalar
    """
  return _dist_bundle1.DistFunc_qBeta(*args)

def DistFunc_rBeta(*args):
  """DistFunc_rBeta(OT::NumericalScalar const p1, OT::NumericalScalar const p2) -> OT::NumericalScalar"""
  return _dist_bundle1.DistFunc_rBeta(*args)

def DistFunc_rBinomial(*args):
  """DistFunc_rBinomial(OT::UnsignedLong const n, OT::NumericalScalar const p) -> OT::UnsignedLong"""
  return _dist_bundle1.DistFunc_rBinomial(*args)

def DistFunc_pGamma(*args):
  """
    pGamma(OT::NumericalScalar const k, OT::NumericalScalar const x, OT::Bool const tail=False) -> OT::NumericalScalar
    DistFunc_pGamma(OT::NumericalScalar const k, OT::NumericalScalar const x) -> OT::NumericalScalar
    """
  return _dist_bundle1.DistFunc_pGamma(*args)

def DistFunc_qGamma(*args):
  """
    qGamma(OT::NumericalScalar const k, OT::NumericalScalar const q, OT::Bool const tail=False) -> OT::NumericalScalar
    DistFunc_qGamma(OT::NumericalScalar const k, OT::NumericalScalar const q) -> OT::NumericalScalar
    """
  return _dist_bundle1.DistFunc_qGamma(*args)

def DistFunc_rGamma(*args):
  """DistFunc_rGamma(OT::NumericalScalar const k) -> OT::NumericalScalar"""
  return _dist_bundle1.DistFunc_rGamma(*args)

def DistFunc_pKolmogorov(*args):
  """
    pKolmogorov(OT::UnsignedLong const n, OT::NumericalScalar const x, OT::Bool const tail=False) -> OT::NumericalScalar
    DistFunc_pKolmogorov(OT::UnsignedLong const n, OT::NumericalScalar const x) -> OT::NumericalScalar
    """
  return _dist_bundle1.DistFunc_pKolmogorov(*args)

def DistFunc_dNonCentralChiSquare(*args):
  """DistFunc_dNonCentralChiSquare(OT::NumericalScalar const nu, OT::NumericalScalar const _lambda, OT::NumericalScalar const x) -> OT::NumericalScalar"""
  return _dist_bundle1.DistFunc_dNonCentralChiSquare(*args)

def DistFunc_pNonCentralChiSquare(*args):
  """
    pNonCentralChiSquare(OT::NumericalScalar const nu, OT::NumericalScalar const _lambda, OT::NumericalScalar const x, 
        OT::Bool const tail=False) -> OT::NumericalScalar
    DistFunc_pNonCentralChiSquare(OT::NumericalScalar const nu, OT::NumericalScalar const _lambda, OT::NumericalScalar const x) -> OT::NumericalScalar
    """
  return _dist_bundle1.DistFunc_pNonCentralChiSquare(*args)

def DistFunc_rNonCentralChiSquare(*args):
  """DistFunc_rNonCentralChiSquare(OT::NumericalScalar const nu, OT::NumericalScalar const _lambda) -> OT::NumericalScalar"""
  return _dist_bundle1.DistFunc_rNonCentralChiSquare(*args)

def DistFunc_dNonCentralStudent(*args):
  """DistFunc_dNonCentralStudent(OT::NumericalScalar const nu, OT::NumericalScalar const delta, OT::NumericalScalar const x) -> OT::NumericalScalar"""
  return _dist_bundle1.DistFunc_dNonCentralStudent(*args)

def DistFunc_pNonCentralStudent(*args):
  """
    pNonCentralStudent(OT::NumericalScalar const nu, OT::NumericalScalar const delta, OT::NumericalScalar const x, 
        OT::Bool const tail=False) -> OT::NumericalScalar
    DistFunc_pNonCentralStudent(OT::NumericalScalar const nu, OT::NumericalScalar const delta, OT::NumericalScalar const x) -> OT::NumericalScalar
    """
  return _dist_bundle1.DistFunc_pNonCentralStudent(*args)

def DistFunc_pNonCentralStudentAlt(*args):
  """
    pNonCentralStudentAlt(OT::NumericalScalar const nu, OT::NumericalScalar const delta, OT::NumericalScalar const x, 
        OT::Bool const tail=False) -> OT::NumericalScalar
    DistFunc_pNonCentralStudentAlt(OT::NumericalScalar const nu, OT::NumericalScalar const delta, OT::NumericalScalar const x) -> OT::NumericalScalar
    """
  return _dist_bundle1.DistFunc_pNonCentralStudentAlt(*args)

def DistFunc_rNonCentralStudent(*args):
  """DistFunc_rNonCentralStudent(OT::NumericalScalar const nu, OT::NumericalScalar const delta) -> OT::NumericalScalar"""
  return _dist_bundle1.DistFunc_rNonCentralStudent(*args)

def DistFunc_pNormal(*args):
  """
    pNormal(OT::NumericalScalar const x, OT::Bool const tail=False) -> OT::NumericalScalar
    DistFunc_pNormal(OT::NumericalScalar const x) -> OT::NumericalScalar
    """
  return _dist_bundle1.DistFunc_pNormal(*args)

def DistFunc_pNormal2D(*args):
  """
    pNormal2D(OT::NumericalScalar const x1, OT::NumericalScalar const x2, OT::NumericalScalar const rho, 
        OT::Bool const tail=False, OT::Bool const newAlgo=True) -> OT::NumericalScalar
    pNormal2D(OT::NumericalScalar const x1, OT::NumericalScalar const x2, OT::NumericalScalar const rho, 
        OT::Bool const tail=False) -> OT::NumericalScalar
    DistFunc_pNormal2D(OT::NumericalScalar const x1, OT::NumericalScalar const x2, OT::NumericalScalar const rho) -> OT::NumericalScalar
    """
  return _dist_bundle1.DistFunc_pNormal2D(*args)

def DistFunc_pNormal3D(*args):
  """
    pNormal3D(OT::NumericalScalar const x1, OT::NumericalScalar const x2, OT::NumericalScalar const x3, 
        OT::NumericalScalar const rho12, OT::NumericalScalar const rho13, 
        OT::NumericalScalar const rho23, OT::Bool const tail=False, OT::Bool const newAlgo=True) -> OT::NumericalScalar
    pNormal3D(OT::NumericalScalar const x1, OT::NumericalScalar const x2, OT::NumericalScalar const x3, 
        OT::NumericalScalar const rho12, OT::NumericalScalar const rho13, 
        OT::NumericalScalar const rho23, OT::Bool const tail=False) -> OT::NumericalScalar
    DistFunc_pNormal3D(OT::NumericalScalar const x1, OT::NumericalScalar const x2, OT::NumericalScalar const x3, 
        OT::NumericalScalar const rho12, OT::NumericalScalar const rho13, 
        OT::NumericalScalar const rho23) -> OT::NumericalScalar
    """
  return _dist_bundle1.DistFunc_pNormal3D(*args)

def DistFunc_qNormal(*args):
  """
    qNormal(OT::NumericalScalar const q, OT::Bool const tail=False) -> OT::NumericalScalar
    DistFunc_qNormal(OT::NumericalScalar const q) -> OT::NumericalScalar
    """
  return _dist_bundle1.DistFunc_qNormal(*args)

def DistFunc_rNormal():
  """DistFunc_rNormal() -> OT::NumericalScalar"""
  return _dist_bundle1.DistFunc_rNormal()

def DistFunc_rPoisson(*args):
  """DistFunc_rPoisson(OT::NumericalScalar const _lambda) -> OT::NumericalScalar"""
  return _dist_bundle1.DistFunc_rPoisson(*args)

def DistFunc_pStudent(*args):
  """
    pStudent(OT::NumericalScalar const nu, OT::NumericalScalar const x, OT::Bool const tail=False) -> OT::NumericalScalar
    DistFunc_pStudent(OT::NumericalScalar const nu, OT::NumericalScalar const x) -> OT::NumericalScalar
    """
  return _dist_bundle1.DistFunc_pStudent(*args)

def DistFunc_qStudent(*args):
  """
    qStudent(OT::NumericalScalar const nu, OT::NumericalScalar const q, OT::Bool const tail=False) -> OT::NumericalScalar
    DistFunc_qStudent(OT::NumericalScalar const nu, OT::NumericalScalar const q) -> OT::NumericalScalar
    """
  return _dist_bundle1.DistFunc_qStudent(*args)

def DistFunc_rStudent(*args):
  """DistFunc_rStudent(OT::NumericalScalar const nu) -> OT::NumericalScalar"""
  return _dist_bundle1.DistFunc_rStudent(*args)

def DistFunc_eZ1(*args):
  """DistFunc_eZ1(OT::UnsignedLong const n) -> OT::NumericalScalar"""
  return _dist_bundle1.DistFunc_eZ1(*args)

def DistFunc_pDickeyFullerTrend(*args):
  """
    pDickeyFullerTrend(OT::NumericalScalar const x, OT::Bool tail=False) -> OT::NumericalScalar
    DistFunc_pDickeyFullerTrend(OT::NumericalScalar const x) -> OT::NumericalScalar
    """
  return _dist_bundle1.DistFunc_pDickeyFullerTrend(*args)

def DistFunc_pDickeyFullerConstant(*args):
  """
    pDickeyFullerConstant(OT::NumericalScalar const x, OT::Bool tail=False) -> OT::NumericalScalar
    DistFunc_pDickeyFullerConstant(OT::NumericalScalar const x) -> OT::NumericalScalar
    """
  return _dist_bundle1.DistFunc_pDickeyFullerConstant(*args)

def DistFunc_pDickeyFullerNoConstant(*args):
  """
    pDickeyFullerNoConstant(OT::NumericalScalar const x, OT::Bool tail=False) -> OT::NumericalScalar
    DistFunc_pDickeyFullerNoConstant(OT::NumericalScalar const x) -> OT::NumericalScalar
    """
  return _dist_bundle1.DistFunc_pDickeyFullerNoConstant(*args)

def DistFunc_qDickeyFullerTrend(*args):
  """
    qDickeyFullerTrend(OT::NumericalScalar const q, OT::Bool tail=False) -> OT::NumericalScalar
    DistFunc_qDickeyFullerTrend(OT::NumericalScalar const q) -> OT::NumericalScalar
    """
  return _dist_bundle1.DistFunc_qDickeyFullerTrend(*args)

def DistFunc_qDickeyFullerConstant(*args):
  """
    qDickeyFullerConstant(OT::NumericalScalar const q, OT::Bool tail=False) -> OT::NumericalScalar
    DistFunc_qDickeyFullerConstant(OT::NumericalScalar const q) -> OT::NumericalScalar
    """
  return _dist_bundle1.DistFunc_qDickeyFullerConstant(*args)

def DistFunc_qDickeyFullerNoConstant(*args):
  """
    qDickeyFullerNoConstant(OT::NumericalScalar const q, OT::Bool tail=False) -> OT::NumericalScalar
    DistFunc_qDickeyFullerNoConstant(OT::NumericalScalar const q) -> OT::NumericalScalar
    """
  return _dist_bundle1.DistFunc_qDickeyFullerNoConstant(*args)

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

    if _newclass:GetClassName = staticmethod(GetClassName)
    __swig_getmethods__["GetClassName"] = lambda x: GetClassName
    def getClassName(self):
        """getClassName(Arcsine self) -> OT::String"""
        return _dist_bundle1.Arcsine_getClassName(self)

    AB = _dist_bundle1.Arcsine_AB
    MUSIGMA = _dist_bundle1.Arcsine_MUSIGMA
    def __eq__(self, *args):
        """__eq__(Arcsine self, Arcsine other) -> OT::Bool"""
        return _dist_bundle1.Arcsine___eq__(self, *args)

    def __repr__(self):
        """__repr__(Arcsine self) -> OT::String"""
        return _dist_bundle1.Arcsine___repr__(self)

    def __str__(self, offset=""):
        """
        __str__(Arcsine self, OT::String const & offset="") -> OT::String
        __str__(Arcsine self) -> OT::String
        """
        return _dist_bundle1.Arcsine___str__(self, offset)

    def getRealization(self):
        """getRealization(Arcsine self) -> NumericalPoint"""
        return _dist_bundle1.Arcsine_getRealization(self)

    def computeDDF(self, *args):
        """
        computeDDF(Arcsine self, OT::NumericalScalar const scalar) -> OT::NumericalScalar
        computeDDF(Arcsine self, NumericalPoint point) -> NumericalPoint
        computeDDF(Arcsine self, NumericalSample sample) -> NumericalSample
        computeDDF(Arcsine self, NumericalPoint point) -> NumericalPoint
        """
        return _dist_bundle1.Arcsine_computeDDF(self, *args)

    def computePDF(self, *args):
        """
        computePDF(Arcsine self, OT::NumericalScalar const scalar) -> OT::NumericalScalar
        computePDF(Arcsine self, NumericalPoint point) -> OT::NumericalScalar
        computePDF(Arcsine self, NumericalSample sample) -> NumericalSample
        computePDF(Arcsine self, OT::NumericalScalar const xMin, OT::NumericalScalar const xMax, OT::UnsignedLong const pointNumber, 
            NumericalSample grid, OT::NumericalScalar const precision=OT::ResourceMap::GetAsNumericalScalar("DistributionImplementation-DefaultPDFEpsilon")) -> NumericalSample
        computePDF(Arcsine self, OT::NumericalScalar const xMin, OT::NumericalScalar const xMax, OT::UnsignedLong const pointNumber, 
            NumericalSample grid) -> NumericalSample
        computePDF(Arcsine self, NumericalPoint xMin, NumericalPoint xMax, Indices pointNumber, NumericalSample grid, 
            OT::NumericalScalar const precision=OT::ResourceMap::GetAsNumericalScalar("DistributionImplementation-DefaultPDFEpsilon")) -> NumericalSample
        computePDF(Arcsine self, NumericalPoint xMin, NumericalPoint xMax, Indices pointNumber, NumericalSample grid) -> NumericalSample
        computePDF(Arcsine self, NumericalPoint point) -> OT::NumericalScalar
        """
        return _dist_bundle1.Arcsine_computePDF(self, *args)

    def computeLogPDF(self, *args):
        """
        computeLogPDF(Arcsine self, OT::NumericalScalar const scalar) -> OT::NumericalScalar
        computeLogPDF(Arcsine self, NumericalPoint point) -> OT::NumericalScalar
        computeLogPDF(Arcsine self, NumericalSample sample) -> NumericalSample
        computeLogPDF(Arcsine self, NumericalPoint point) -> OT::NumericalScalar
        """
        return _dist_bundle1.Arcsine_computeLogPDF(self, *args)

    def computeCDF(self, *args):
        """
        computeCDF(Arcsine self, OT::NumericalScalar const scalar, OT::Bool const tail) -> OT::NumericalScalar
        computeCDF(Arcsine self, OT::NumericalScalar const scalar) -> OT::NumericalScalar
        computeCDF(Arcsine self, NumericalPoint point, OT::Bool const tail) -> OT::NumericalScalar
        computeCDF(Arcsine self, NumericalPoint point) -> OT::NumericalScalar
        computeCDF(Arcsine self, NumericalSample sample, OT::Bool const tail) -> NumericalSample
        computeCDF(Arcsine self, NumericalSample sample) -> NumericalSample
        computeCDF(Arcsine self, OT::NumericalScalar const xMin, OT::NumericalScalar const xMax, OT::UnsignedLong const pointNumber, 
            NumericalSample grid, OT::NumericalScalar const precision=OT::ResourceMap::GetAsNumericalScalar("DistributionImplementation-DefaultCDFEpsilon")) -> NumericalSample
        computeCDF(Arcsine self, OT::NumericalScalar const xMin, OT::NumericalScalar const xMax, OT::UnsignedLong const pointNumber, 
            NumericalSample grid) -> NumericalSample
        computeCDF(Arcsine self, NumericalPoint xMin, NumericalPoint xMax, Indices pointNumber, NumericalSample grid, 
            OT::NumericalScalar const precision=OT::ResourceMap::GetAsNumericalScalar("DistributionImplementation-DefaultCDFEpsilon")) -> NumericalSample
        computeCDF(Arcsine self, NumericalPoint xMin, NumericalPoint xMax, Indices pointNumber, NumericalSample grid) -> NumericalSample
        computeCDF(Arcsine self, NumericalPoint point) -> OT::NumericalScalar
        """
        return _dist_bundle1.Arcsine_computeCDF(self, *args)

    def computeComplementaryCDF(self, *args):
        """
        computeComplementaryCDF(Arcsine self, OT::NumericalScalar const scalar) -> OT::NumericalScalar
        computeComplementaryCDF(Arcsine self, NumericalPoint point) -> OT::NumericalScalar
        computeComplementaryCDF(Arcsine self, NumericalSample sample) -> NumericalSample
        computeComplementaryCDF(Arcsine self, OT::NumericalScalar const xMin, OT::NumericalScalar const xMax, OT::UnsignedLong const pointNumber, 
            NumericalSample grid, OT::NumericalScalar const precision=OT::ResourceMap::GetAsNumericalScalar("DistributionImplementation-DefaultCDFEpsilon")) -> NumericalSample
        computeComplementaryCDF(Arcsine self, OT::NumericalScalar const xMin, OT::NumericalScalar const xMax, OT::UnsignedLong const pointNumber, 
            NumericalSample grid) -> NumericalSample
        computeComplementaryCDF(Arcsine self, NumericalPoint point) -> OT::NumericalScalar
        """
        return _dist_bundle1.Arcsine_computeComplementaryCDF(self, *args)

    def computePDFGradient(self, *args):
        """computePDFGradient(Arcsine self, NumericalPoint point) -> NumericalPoint"""
        return _dist_bundle1.Arcsine_computePDFGradient(self, *args)

    def computeCDFGradient(self, *args):
        """computeCDFGradient(Arcsine self, NumericalPoint point) -> NumericalPoint"""
        return _dist_bundle1.Arcsine_computeCDFGradient(self, *args)

    def computeScalarQuantile(self, *args):
        """
        computeScalarQuantile(Arcsine self, OT::NumericalScalar const prob, OT::Bool const tail=False, OT::NumericalScalar const precision=OT::ResourceMap::GetAsNumericalScalar("DistributionImplementation-DefaultQuantileEpsilon")) -> OT::NumericalScalar
        computeScalarQuantile(Arcsine self, OT::NumericalScalar const prob, OT::Bool const tail=False) -> OT::NumericalScalar
        computeScalarQuantile(Arcsine self, OT::NumericalScalar const prob) -> OT::NumericalScalar
        """
        return _dist_bundle1.Arcsine_computeScalarQuantile(self, *args)

    def getRoughness(self):
        """getRoughness(Arcsine self) -> OT::NumericalScalar"""
        return _dist_bundle1.Arcsine_getRoughness(self)

    def getStandardDeviation(self):
        """getStandardDeviation(Arcsine self) -> NumericalPoint"""
        return _dist_bundle1.Arcsine_getStandardDeviation(self)

    def getSkewness(self):
        """getSkewness(Arcsine self) -> NumericalPoint"""
        return _dist_bundle1.Arcsine_getSkewness(self)

    def getKurtosis(self):
        """getKurtosis(Arcsine self) -> NumericalPoint"""
        return _dist_bundle1.Arcsine_getKurtosis(self)

    def getStandardMoment(self, *args):
        """getStandardMoment(Arcsine self, OT::UnsignedLong const n) -> NumericalPoint"""
        return _dist_bundle1.Arcsine_getStandardMoment(self, *args)

    def getStandardRepresentative(self):
        """getStandardRepresentative(Arcsine self) -> DistributionImplementationPointer"""
        return _dist_bundle1.Arcsine_getStandardRepresentative(self)

    def getParametersCollection(self):
        """getParametersCollection(Arcsine self) -> NumericalPointWithDescriptionCollection"""
        return _dist_bundle1.Arcsine_getParametersCollection(self)

    def setParametersCollection(self, *args):
        """
        setParametersCollection(Arcsine self, NumericalPointWithDescriptionCollection parametersCollection)
        setParametersCollection(Arcsine self, NumericalPointCollection parametersCollection)
        setParametersCollection(Arcsine self, NumericalPoint parameters)
        setParametersCollection(Arcsine self, NumericalPointCollection parametersCollection)
        """
        return _dist_bundle1.Arcsine_setParametersCollection(self, *args)

    def setA(self, *args):
        """setA(Arcsine self, OT::NumericalScalar const a)"""
        return _dist_bundle1.Arcsine_setA(self, *args)

    def getA(self):
        """getA(Arcsine self) -> OT::NumericalScalar"""
        return _dist_bundle1.Arcsine_getA(self)

    def setB(self, *args):
        """setB(Arcsine self, OT::NumericalScalar const b)"""
        return _dist_bundle1.Arcsine_setB(self, *args)

    def getB(self):
        """getB(Arcsine self) -> OT::NumericalScalar"""
        return _dist_bundle1.Arcsine_getB(self)

    def setMu(self, *args):
        """setMu(Arcsine self, OT::NumericalScalar const mu)"""
        return _dist_bundle1.Arcsine_setMu(self, *args)

    def getMu(self):
        """getMu(Arcsine self) -> OT::NumericalScalar"""
        return _dist_bundle1.Arcsine_getMu(self)

    def setSigma(self, *args):
        """setSigma(Arcsine self, OT::NumericalScalar const sigma)"""
        return _dist_bundle1.Arcsine_setSigma(self, *args)

    def getSigma(self):
        """getSigma(Arcsine self) -> OT::NumericalScalar"""
        return _dist_bundle1.Arcsine_getSigma(self)

    def __init__(self, *args): 
        """
        __init__(OT::Arcsine self) -> Arcsine
        __init__(OT::Arcsine self, OT::NumericalScalar const arg1, OT::NumericalScalar const arg2, OT::Arcsine::ParameterSet const set=AB) -> Arcsine
        __init__(OT::Arcsine self, OT::NumericalScalar const arg1, OT::NumericalScalar const arg2) -> Arcsine
        __init__(OT::Arcsine self, Arcsine other) -> Arcsine
        """
        this = _dist_bundle1.new_Arcsine(*args)
        try: self.this.append(this)
        except: self.this = this
    __swig_destroy__ = _dist_bundle1.delete_Arcsine
    __del__ = lambda self : None;
Arcsine_swigregister = _dist_bundle1.Arcsine_swigregister
Arcsine_swigregister(Arcsine)

def Arcsine_GetClassName():
  """Arcsine_GetClassName() -> OT::String"""
  return _dist_bundle1.Arcsine_GetClassName()

class ArcsineFactory(openturns.model_copula.DistributionImplementationFactory):
    """Proxy of C++ OT::ArcsineFactory class"""
    __swig_setmethods__ = {}
    for _s in [openturns.model_copula.DistributionImplementationFactory]: __swig_setmethods__.update(getattr(_s,'__swig_setmethods__',{}))
    __setattr__ = lambda self, name, value: _swig_setattr(self, ArcsineFactory, name, value)
    __swig_getmethods__ = {}
    for _s in [openturns.model_copula.DistributionImplementationFactory]: __swig_getmethods__.update(getattr(_s,'__swig_getmethods__',{}))
    __getattr__ = lambda self, name: _swig_getattr(self, ArcsineFactory, name)
    __repr__ = _swig_repr
    def GetClassName():
        """GetClassName() -> OT::String"""
        return _dist_bundle1.ArcsineFactory_GetClassName()

    if _newclass:GetClassName = staticmethod(GetClassName)
    __swig_getmethods__["GetClassName"] = lambda x: GetClassName
    def getClassName(self):
        """getClassName(ArcsineFactory self) -> OT::String"""
        return _dist_bundle1.ArcsineFactory_getClassName(self)

    def build(self, *args):
        """
        build(ArcsineFactory self, NumericalSample sample) -> DistributionImplementationPointer
        build(ArcsineFactory self, NumericalSample sample, CovarianceMatrix covariance) -> DistributionImplementationPointer
        build(ArcsineFactory self, NumericalPointCollection parameters) -> DistributionImplementationPointer
        build(ArcsineFactory self, NumericalPointWithDescriptionCollection parameters) -> DistributionImplementationPointer
        build(ArcsineFactory self, NumericalSample sample) -> DistributionImplementationPointer
        build(ArcsineFactory self, NumericalPointCollection parameters) -> DistributionImplementationPointer
        build(ArcsineFactory self) -> DistributionImplementationPointer
        """
        return _dist_bundle1.ArcsineFactory_build(self, *args)

    def buildAsArcsine(self, *args):
        """
        buildAsArcsine(ArcsineFactory self, NumericalSample sample) -> Arcsine
        buildAsArcsine(ArcsineFactory self, NumericalPointCollection parameters) -> Arcsine
        buildAsArcsine(ArcsineFactory self, NumericalPointWithDescriptionCollection parameters) -> Arcsine
        buildAsArcsine(ArcsineFactory self) -> Arcsine
        """
        return _dist_bundle1.ArcsineFactory_buildAsArcsine(self, *args)

    def __init__(self, *args): 
        """
        __init__(OT::ArcsineFactory self) -> ArcsineFactory
        __init__(OT::ArcsineFactory self, ArcsineFactory other) -> ArcsineFactory
        """
        this = _dist_bundle1.new_ArcsineFactory(*args)
        try: self.this.append(this)
        except: self.this = this
    __swig_destroy__ = _dist_bundle1.delete_ArcsineFactory
    __del__ = lambda self : None;
ArcsineFactory_swigregister = _dist_bundle1.ArcsineFactory_swigregister
ArcsineFactory_swigregister(ArcsineFactory)

def ArcsineFactory_GetClassName():
  """ArcsineFactory_GetClassName() -> OT::String"""
  return _dist_bundle1.ArcsineFactory_GetClassName()

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

    if _newclass:GetClassName = staticmethod(GetClassName)
    __swig_getmethods__["GetClassName"] = lambda x: GetClassName
    def getClassName(self):
        """getClassName(Bernoulli self) -> OT::String"""
        return _dist_bundle1.Bernoulli_getClassName(self)

    def __eq__(self, *args):
        """__eq__(Bernoulli self, Bernoulli other) -> OT::Bool"""
        return _dist_bundle1.Bernoulli___eq__(self, *args)

    def __repr__(self):
        """__repr__(Bernoulli self) -> OT::String"""
        return _dist_bundle1.Bernoulli___repr__(self)

    def __str__(self, offset=""):
        """
        __str__(Bernoulli self, OT::String const & offset="") -> OT::String
        __str__(Bernoulli self) -> OT::String
        """
        return _dist_bundle1.Bernoulli___str__(self, offset)

    def getRealization(self):
        """getRealization(Bernoulli self) -> NumericalPoint"""
        return _dist_bundle1.Bernoulli_getRealization(self)

    def computePDF(self, *args):
        """
        computePDF(Bernoulli self, OT::NumericalScalar const scalar) -> OT::NumericalScalar
        computePDF(Bernoulli self, NumericalPoint point) -> OT::NumericalScalar
        computePDF(Bernoulli self, NumericalSample sample) -> NumericalSample
        computePDF(Bernoulli self, OT::NumericalScalar const xMin, OT::NumericalScalar const xMax, OT::UnsignedLong const pointNumber, 
            NumericalSample grid, OT::NumericalScalar const precision=OT::ResourceMap::GetAsNumericalScalar("DistributionImplementation-DefaultPDFEpsilon")) -> NumericalSample
        computePDF(Bernoulli self, OT::NumericalScalar const xMin, OT::NumericalScalar const xMax, OT::UnsignedLong const pointNumber, 
            NumericalSample grid) -> NumericalSample
        computePDF(Bernoulli self, NumericalPoint xMin, NumericalPoint xMax, Indices pointNumber, NumericalSample grid, 
            OT::NumericalScalar const precision=OT::ResourceMap::GetAsNumericalScalar("DistributionImplementation-DefaultPDFEpsilon")) -> NumericalSample
        computePDF(Bernoulli self, NumericalPoint xMin, NumericalPoint xMax, Indices pointNumber, NumericalSample grid) -> NumericalSample
        computePDF(Bernoulli self, NumericalPoint point) -> OT::NumericalScalar
        """
        return _dist_bundle1.Bernoulli_computePDF(self, *args)

    def computeCDF(self, *args):
        """
        computeCDF(Bernoulli self, OT::NumericalScalar const scalar, OT::Bool const tail) -> OT::NumericalScalar
        computeCDF(Bernoulli self, OT::NumericalScalar const scalar) -> OT::NumericalScalar
        computeCDF(Bernoulli self, NumericalPoint point, OT::Bool const tail) -> OT::NumericalScalar
        computeCDF(Bernoulli self, NumericalPoint point) -> OT::NumericalScalar
        computeCDF(Bernoulli self, NumericalSample sample, OT::Bool const tail) -> NumericalSample
        computeCDF(Bernoulli self, NumericalSample sample) -> NumericalSample
        computeCDF(Bernoulli self, OT::NumericalScalar const xMin, OT::NumericalScalar const xMax, OT::UnsignedLong const pointNumber, 
            NumericalSample grid, OT::NumericalScalar const precision=OT::ResourceMap::GetAsNumericalScalar("DistributionImplementation-DefaultCDFEpsilon")) -> NumericalSample
        computeCDF(Bernoulli self, OT::NumericalScalar const xMin, OT::NumericalScalar const xMax, OT::UnsignedLong const pointNumber, 
            NumericalSample grid) -> NumericalSample
        computeCDF(Bernoulli self, NumericalPoint xMin, NumericalPoint xMax, Indices pointNumber, NumericalSample grid, 
            OT::NumericalScalar const precision=OT::ResourceMap::GetAsNumericalScalar("DistributionImplementation-DefaultCDFEpsilon")) -> NumericalSample
        computeCDF(Bernoulli self, NumericalPoint xMin, NumericalPoint xMax, Indices pointNumber, NumericalSample grid) -> NumericalSample
        computeCDF(Bernoulli self, NumericalPoint point) -> OT::NumericalScalar
        """
        return _dist_bundle1.Bernoulli_computeCDF(self, *args)

    def computePDFGradient(self, *args):
        """computePDFGradient(Bernoulli self, NumericalPoint point) -> NumericalPoint"""
        return _dist_bundle1.Bernoulli_computePDFGradient(self, *args)

    def computeCDFGradient(self, *args):
        """computeCDFGradient(Bernoulli self, NumericalPoint point) -> NumericalPoint"""
        return _dist_bundle1.Bernoulli_computeCDFGradient(self, *args)

    def computeCharacteristicFunction(self, *args):
        """computeCharacteristicFunction(Bernoulli self, OT::NumericalScalar const x) -> OT::NumericalComplex"""
        return _dist_bundle1.Bernoulli_computeCharacteristicFunction(self, *args)

    def computeGeneratingFunction(self, *args):
        """computeGeneratingFunction(Bernoulli self, OT::NumericalComplex const & z) -> OT::NumericalComplex"""
        return _dist_bundle1.Bernoulli_computeGeneratingFunction(self, *args)

    def getSupport(self, *args):
        """
        getSupport(Bernoulli self, Interval interval) -> NumericalSample
        getSupport(Bernoulli self) -> NumericalSample
        getSupport(Bernoulli self, Interval interval) -> NumericalSample
        """
        return _dist_bundle1.Bernoulli_getSupport(self, *args)

    def getStandardDeviation(self):
        """getStandardDeviation(Bernoulli self) -> NumericalPoint"""
        return _dist_bundle1.Bernoulli_getStandardDeviation(self)

    def getSkewness(self):
        """getSkewness(Bernoulli self) -> NumericalPoint"""
        return _dist_bundle1.Bernoulli_getSkewness(self)

    def getKurtosis(self):
        """getKurtosis(Bernoulli self) -> NumericalPoint"""
        return _dist_bundle1.Bernoulli_getKurtosis(self)

    def getStandardMoment(self, *args):
        """getStandardMoment(Bernoulli self, OT::UnsignedLong const n) -> NumericalPoint"""
        return _dist_bundle1.Bernoulli_getStandardMoment(self, *args)

    def getParametersCollection(self):
        """getParametersCollection(Bernoulli self) -> NumericalPointWithDescriptionCollection"""
        return _dist_bundle1.Bernoulli_getParametersCollection(self)

    def setParametersCollection(self, *args):
        """
        setParametersCollection(Bernoulli self, NumericalPointWithDescriptionCollection parametersCollection)
        setParametersCollection(Bernoulli self, NumericalPointCollection parametersCollection)
        setParametersCollection(Bernoulli self, NumericalPoint parameters)
        setParametersCollection(Bernoulli self, NumericalPointCollection parametersCollection)
        """
        return _dist_bundle1.Bernoulli_setParametersCollection(self, *args)

    def setP(self, *args):
        """setP(Bernoulli self, OT::NumericalScalar const p)"""
        return _dist_bundle1.Bernoulli_setP(self, *args)

    def getP(self):
        """getP(Bernoulli self) -> OT::NumericalScalar"""
        return _dist_bundle1.Bernoulli_getP(self)

    def __init__(self, *args): 
        """
        __init__(OT::Bernoulli self) -> Bernoulli
        __init__(OT::Bernoulli self, OT::NumericalScalar const p) -> Bernoulli
        __init__(OT::Bernoulli self, Bernoulli other) -> Bernoulli
        """
        this = _dist_bundle1.new_Bernoulli(*args)
        try: self.this.append(this)
        except: self.this = this
    __swig_destroy__ = _dist_bundle1.delete_Bernoulli
    __del__ = lambda self : None;
Bernoulli_swigregister = _dist_bundle1.Bernoulli_swigregister
Bernoulli_swigregister(Bernoulli)

def Bernoulli_GetClassName():
  """Bernoulli_GetClassName() -> OT::String"""
  return _dist_bundle1.Bernoulli_GetClassName()

class BernoulliFactory(openturns.model_copula.DistributionImplementationFactory):
    """Proxy of C++ OT::BernoulliFactory class"""
    __swig_setmethods__ = {}
    for _s in [openturns.model_copula.DistributionImplementationFactory]: __swig_setmethods__.update(getattr(_s,'__swig_setmethods__',{}))
    __setattr__ = lambda self, name, value: _swig_setattr(self, BernoulliFactory, name, value)
    __swig_getmethods__ = {}
    for _s in [openturns.model_copula.DistributionImplementationFactory]: __swig_getmethods__.update(getattr(_s,'__swig_getmethods__',{}))
    __getattr__ = lambda self, name: _swig_getattr(self, BernoulliFactory, name)
    __repr__ = _swig_repr
    def GetClassName():
        """GetClassName() -> OT::String"""
        return _dist_bundle1.BernoulliFactory_GetClassName()

    if _newclass:GetClassName = staticmethod(GetClassName)
    __swig_getmethods__["GetClassName"] = lambda x: GetClassName
    def getClassName(self):
        """getClassName(BernoulliFactory self) -> OT::String"""
        return _dist_bundle1.BernoulliFactory_getClassName(self)

    def build(self, *args):
        """
        build(BernoulliFactory self, NumericalSample sample) -> DistributionImplementationPointer
        build(BernoulliFactory self, NumericalSample sample, CovarianceMatrix covariance) -> DistributionImplementationPointer
        build(BernoulliFactory self, NumericalPointCollection parameters) -> DistributionImplementationPointer
        build(BernoulliFactory self, NumericalPointWithDescriptionCollection parameters) -> DistributionImplementationPointer
        build(BernoulliFactory self, NumericalSample sample) -> DistributionImplementationPointer
        build(BernoulliFactory self, NumericalPointCollection parameters) -> DistributionImplementationPointer
        build(BernoulliFactory self) -> DistributionImplementationPointer
        """
        return _dist_bundle1.BernoulliFactory_build(self, *args)

    def buildAsBernoulli(self, *args):
        """
        buildAsBernoulli(BernoulliFactory self, NumericalSample sample) -> Bernoulli
        buildAsBernoulli(BernoulliFactory self, NumericalPointCollection parameters) -> Bernoulli
        buildAsBernoulli(BernoulliFactory self, NumericalPointWithDescriptionCollection parameters) -> Bernoulli
        buildAsBernoulli(BernoulliFactory self) -> Bernoulli
        """
        return _dist_bundle1.BernoulliFactory_buildAsBernoulli(self, *args)

    def __init__(self, *args): 
        """
        __init__(OT::BernoulliFactory self) -> BernoulliFactory
        __init__(OT::BernoulliFactory self, BernoulliFactory other) -> BernoulliFactory
        """
        this = _dist_bundle1.new_BernoulliFactory(*args)
        try: self.this.append(this)
        except: self.this = this
    __swig_destroy__ = _dist_bundle1.delete_BernoulliFactory
    __del__ = lambda self : None;
BernoulliFactory_swigregister = _dist_bundle1.BernoulliFactory_swigregister
BernoulliFactory_swigregister(BernoulliFactory)

def BernoulliFactory_GetClassName():
  """BernoulliFactory_GetClassName() -> OT::String"""
  return _dist_bundle1.BernoulliFactory_GetClassName()

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

    if _newclass:GetClassName = staticmethod(GetClassName)
    __swig_getmethods__["GetClassName"] = lambda x: GetClassName
    def getClassName(self):
        """getClassName(Beta self) -> OT::String"""
        return _dist_bundle1.Beta_getClassName(self)

    RT = _dist_bundle1.Beta_RT
    MUSIGMA = _dist_bundle1.Beta_MUSIGMA
    def __eq__(self, *args):
        """__eq__(Beta self, Beta other) -> OT::Bool"""
        return _dist_bundle1.Beta___eq__(self, *args)

    def __repr__(self):
        """__repr__(Beta self) -> OT::String"""
        return _dist_bundle1.Beta___repr__(self)

    def __str__(self, offset=""):
        """
        __str__(Beta self, OT::String const & offset="") -> OT::String
        __str__(Beta self) -> OT::String
        """
        return _dist_bundle1.Beta___str__(self, offset)

    def getRealization(self):
        """getRealization(Beta self) -> NumericalPoint"""
        return _dist_bundle1.Beta_getRealization(self)

    def computeDDF(self, *args):
        """
        computeDDF(Beta self, OT::NumericalScalar const scalar) -> OT::NumericalScalar
        computeDDF(Beta self, NumericalPoint point) -> NumericalPoint
        computeDDF(Beta self, NumericalSample sample) -> NumericalSample
        computeDDF(Beta self, NumericalPoint point) -> NumericalPoint
        """
        return _dist_bundle1.Beta_computeDDF(self, *args)

    def computePDF(self, *args):
        """
        computePDF(Beta self, OT::NumericalScalar const scalar) -> OT::NumericalScalar
        computePDF(Beta self, NumericalPoint point) -> OT::NumericalScalar
        computePDF(Beta self, NumericalSample sample) -> NumericalSample
        computePDF(Beta self, OT::NumericalScalar const xMin, OT::NumericalScalar const xMax, OT::UnsignedLong const pointNumber, 
            NumericalSample grid, OT::NumericalScalar const precision=OT::ResourceMap::GetAsNumericalScalar("DistributionImplementation-DefaultPDFEpsilon")) -> NumericalSample
        computePDF(Beta self, OT::NumericalScalar const xMin, OT::NumericalScalar const xMax, OT::UnsignedLong const pointNumber, 
            NumericalSample grid) -> NumericalSample
        computePDF(Beta self, NumericalPoint xMin, NumericalPoint xMax, Indices pointNumber, NumericalSample grid, 
            OT::NumericalScalar const precision=OT::ResourceMap::GetAsNumericalScalar("DistributionImplementation-DefaultPDFEpsilon")) -> NumericalSample
        computePDF(Beta self, NumericalPoint xMin, NumericalPoint xMax, Indices pointNumber, NumericalSample grid) -> NumericalSample
        computePDF(Beta self, NumericalPoint point) -> OT::NumericalScalar
        """
        return _dist_bundle1.Beta_computePDF(self, *args)

    def computeLogPDF(self, *args):
        """
        computeLogPDF(Beta self, OT::NumericalScalar const scalar) -> OT::NumericalScalar
        computeLogPDF(Beta self, NumericalPoint point) -> OT::NumericalScalar
        computeLogPDF(Beta self, NumericalSample sample) -> NumericalSample
        computeLogPDF(Beta self, NumericalPoint point) -> OT::NumericalScalar
        """
        return _dist_bundle1.Beta_computeLogPDF(self, *args)

    def computeCDF(self, *args):
        """
        computeCDF(Beta self, OT::NumericalScalar const scalar, OT::Bool const tail) -> OT::NumericalScalar
        computeCDF(Beta self, OT::NumericalScalar const scalar) -> OT::NumericalScalar
        computeCDF(Beta self, NumericalPoint point, OT::Bool const tail) -> OT::NumericalScalar
        computeCDF(Beta self, NumericalPoint point) -> OT::NumericalScalar
        computeCDF(Beta self, NumericalSample sample, OT::Bool const tail) -> NumericalSample
        computeCDF(Beta self, NumericalSample sample) -> NumericalSample
        computeCDF(Beta self, OT::NumericalScalar const xMin, OT::NumericalScalar const xMax, OT::UnsignedLong const pointNumber, 
            NumericalSample grid, OT::NumericalScalar const precision=OT::ResourceMap::GetAsNumericalScalar("DistributionImplementation-DefaultCDFEpsilon")) -> NumericalSample
        computeCDF(Beta self, OT::NumericalScalar const xMin, OT::NumericalScalar const xMax, OT::UnsignedLong const pointNumber, 
            NumericalSample grid) -> NumericalSample
        computeCDF(Beta self, NumericalPoint xMin, NumericalPoint xMax, Indices pointNumber, NumericalSample grid, 
            OT::NumericalScalar const precision=OT::ResourceMap::GetAsNumericalScalar("DistributionImplementation-DefaultCDFEpsilon")) -> NumericalSample
        computeCDF(Beta self, NumericalPoint xMin, NumericalPoint xMax, Indices pointNumber, NumericalSample grid) -> NumericalSample
        computeCDF(Beta self, NumericalPoint point) -> OT::NumericalScalar
        """
        return _dist_bundle1.Beta_computeCDF(self, *args)

    def computePDFGradient(self, *args):
        """computePDFGradient(Beta self, NumericalPoint point) -> NumericalPoint"""
        return _dist_bundle1.Beta_computePDFGradient(self, *args)

    def computeCDFGradient(self, *args):
        """computeCDFGradient(Beta self, NumericalPoint point) -> NumericalPoint"""
        return _dist_bundle1.Beta_computeCDFGradient(self, *args)

    def computeCharacteristicFunction(self, *args):
        """computeCharacteristicFunction(Beta self, OT::NumericalScalar const x) -> OT::NumericalComplex"""
        return _dist_bundle1.Beta_computeCharacteristicFunction(self, *args)

    def getRoughness(self):
        """getRoughness(Beta self) -> OT::NumericalScalar"""
        return _dist_bundle1.Beta_getRoughness(self)

    def getStandardDeviation(self):
        """getStandardDeviation(Beta self) -> NumericalPoint"""
        return _dist_bundle1.Beta_getStandardDeviation(self)

    def getSkewness(self):
        """getSkewness(Beta self) -> NumericalPoint"""
        return _dist_bundle1.Beta_getSkewness(self)

    def getKurtosis(self):
        """getKurtosis(Beta self) -> NumericalPoint"""
        return _dist_bundle1.Beta_getKurtosis(self)

    def getStandardMoment(self, *args):
        """getStandardMoment(Beta self, OT::UnsignedLong const n) -> NumericalPoint"""
        return _dist_bundle1.Beta_getStandardMoment(self, *args)

    def getStandardRepresentative(self):
        """getStandardRepresentative(Beta self) -> DistributionImplementationPointer"""
        return _dist_bundle1.Beta_getStandardRepresentative(self)

    def getParametersCollection(self):
        """getParametersCollection(Beta self) -> NumericalPointWithDescriptionCollection"""
        return _dist_bundle1.Beta_getParametersCollection(self)

    def setParametersCollection(self, *args):
        """
        setParametersCollection(Beta self, NumericalPointWithDescriptionCollection parametersCollection)
        setParametersCollection(Beta self, NumericalPointCollection parametersCollection)
        setParametersCollection(Beta self, NumericalPoint parameters)
        setParametersCollection(Beta self, NumericalPointCollection parametersCollection)
        """
        return _dist_bundle1.Beta_setParametersCollection(self, *args)

    def isElliptical(self):
        """isElliptical(Beta self) -> OT::Bool"""
        return _dist_bundle1.Beta_isElliptical(self)

    def setR(self, *args):
        """setR(Beta self, OT::NumericalScalar const r)"""
        return _dist_bundle1.Beta_setR(self, *args)

    def getR(self):
        """getR(Beta self) -> OT::NumericalScalar"""
        return _dist_bundle1.Beta_getR(self)

    def setT(self, *args):
        """setT(Beta self, OT::NumericalScalar const t)"""
        return _dist_bundle1.Beta_setT(self, *args)

    def getT(self):
        """getT(Beta self) -> OT::NumericalScalar"""
        return _dist_bundle1.Beta_getT(self)

    def setMuSigma(self, *args):
        """setMuSigma(Beta self, OT::NumericalScalar const mu, OT::NumericalScalar const sigma)"""
        return _dist_bundle1.Beta_setMuSigma(self, *args)

    def getMu(self):
        """getMu(Beta self) -> OT::NumericalScalar"""
        return _dist_bundle1.Beta_getMu(self)

    def getSigma(self):
        """getSigma(Beta self) -> OT::NumericalScalar"""
        return _dist_bundle1.Beta_getSigma(self)

    def setA(self, *args):
        """setA(Beta self, OT::NumericalScalar const a)"""
        return _dist_bundle1.Beta_setA(self, *args)

    def getA(self):
        """getA(Beta self) -> OT::NumericalScalar"""
        return _dist_bundle1.Beta_getA(self)

    def setB(self, *args):
        """setB(Beta self, OT::NumericalScalar const b)"""
        return _dist_bundle1.Beta_setB(self, *args)

    def getB(self):
        """getB(Beta self) -> OT::NumericalScalar"""
        return _dist_bundle1.Beta_getB(self)

    def __init__(self, *args): 
        """
        __init__(OT::Beta self) -> Beta
        __init__(OT::Beta self, OT::NumericalScalar const arg1, OT::NumericalScalar const arg2, OT::NumericalScalar const a, 
            OT::NumericalScalar const b, OT::Beta::ParameterSet const set=RT) -> Beta
        __init__(OT::Beta self, OT::NumericalScalar const arg1, OT::NumericalScalar const arg2, OT::NumericalScalar const a, 
            OT::NumericalScalar const b) -> Beta
        __init__(OT::Beta self, Beta other) -> Beta
        """
        this = _dist_bundle1.new_Beta(*args)
        try: self.this.append(this)
        except: self.this = this
    __swig_destroy__ = _dist_bundle1.delete_Beta
    __del__ = lambda self : None;
Beta_swigregister = _dist_bundle1.Beta_swigregister
Beta_swigregister(Beta)

def Beta_GetClassName():
  """Beta_GetClassName() -> OT::String"""
  return _dist_bundle1.Beta_GetClassName()

class BetaFactory(openturns.model_copula.DistributionImplementationFactory):
    """Proxy of C++ OT::BetaFactory class"""
    __swig_setmethods__ = {}
    for _s in [openturns.model_copula.DistributionImplementationFactory]: __swig_setmethods__.update(getattr(_s,'__swig_setmethods__',{}))
    __setattr__ = lambda self, name, value: _swig_setattr(self, BetaFactory, name, value)
    __swig_getmethods__ = {}
    for _s in [openturns.model_copula.DistributionImplementationFactory]: __swig_getmethods__.update(getattr(_s,'__swig_getmethods__',{}))
    __getattr__ = lambda self, name: _swig_getattr(self, BetaFactory, name)
    __repr__ = _swig_repr
    def GetClassName():
        """GetClassName() -> OT::String"""
        return _dist_bundle1.BetaFactory_GetClassName()

    if _newclass:GetClassName = staticmethod(GetClassName)
    __swig_getmethods__["GetClassName"] = lambda x: GetClassName
    def getClassName(self):
        """getClassName(BetaFactory self) -> OT::String"""
        return _dist_bundle1.BetaFactory_getClassName(self)

    def build(self, *args):
        """
        build(BetaFactory self, NumericalSample sample) -> DistributionImplementationPointer
        build(BetaFactory self, NumericalSample sample, CovarianceMatrix covariance) -> DistributionImplementationPointer
        build(BetaFactory self, NumericalPointCollection parameters) -> DistributionImplementationPointer
        build(BetaFactory self, NumericalPointWithDescriptionCollection parameters) -> DistributionImplementationPointer
        build(BetaFactory self, NumericalSample sample) -> DistributionImplementationPointer
        build(BetaFactory self, NumericalPointCollection parameters) -> DistributionImplementationPointer
        build(BetaFactory self) -> DistributionImplementationPointer
        """
        return _dist_bundle1.BetaFactory_build(self, *args)

    def buildAsBeta(self, *args):
        """
        buildAsBeta(BetaFactory self, NumericalSample sample) -> Beta
        buildAsBeta(BetaFactory self, NumericalPointCollection parameters) -> Beta
        buildAsBeta(BetaFactory self, NumericalPointWithDescriptionCollection parameters) -> Beta
        buildAsBeta(BetaFactory self) -> Beta
        """
        return _dist_bundle1.BetaFactory_buildAsBeta(self, *args)

    def __init__(self, *args): 
        """
        __init__(OT::BetaFactory self) -> BetaFactory
        __init__(OT::BetaFactory self, BetaFactory other) -> BetaFactory
        """
        this = _dist_bundle1.new_BetaFactory(*args)
        try: self.this.append(this)
        except: self.this = this
    __swig_destroy__ = _dist_bundle1.delete_BetaFactory
    __del__ = lambda self : None;
BetaFactory_swigregister = _dist_bundle1.BetaFactory_swigregister
BetaFactory_swigregister(BetaFactory)

def BetaFactory_GetClassName():
  """BetaFactory_GetClassName() -> OT::String"""
  return _dist_bundle1.BetaFactory_GetClassName()

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

    if _newclass:GetClassName = staticmethod(GetClassName)
    __swig_getmethods__["GetClassName"] = lambda x: GetClassName
    def getClassName(self):
        """getClassName(Binomial self) -> OT::String"""
        return _dist_bundle1.Binomial_getClassName(self)

    def __eq__(self, *args):
        """__eq__(Binomial self, Binomial other) -> OT::Bool"""
        return _dist_bundle1.Binomial___eq__(self, *args)

    def __repr__(self):
        """__repr__(Binomial self) -> OT::String"""
        return _dist_bundle1.Binomial___repr__(self)

    def __str__(self, offset=""):
        """
        __str__(Binomial self, OT::String const & offset="") -> OT::String
        __str__(Binomial self) -> OT::String
        """
        return _dist_bundle1.Binomial___str__(self, offset)

    def getRealization(self):
        """getRealization(Binomial self) -> NumericalPoint"""
        return _dist_bundle1.Binomial_getRealization(self)

    def computePDF(self, *args):
        """
        computePDF(Binomial self, OT::NumericalScalar const scalar) -> OT::NumericalScalar
        computePDF(Binomial self, NumericalPoint point) -> OT::NumericalScalar
        computePDF(Binomial self, NumericalSample sample) -> NumericalSample
        computePDF(Binomial self, OT::NumericalScalar const xMin, OT::NumericalScalar const xMax, OT::UnsignedLong const pointNumber, 
            NumericalSample grid, OT::NumericalScalar const precision=OT::ResourceMap::GetAsNumericalScalar("DistributionImplementation-DefaultPDFEpsilon")) -> NumericalSample
        computePDF(Binomial self, OT::NumericalScalar const xMin, OT::NumericalScalar const xMax, OT::UnsignedLong const pointNumber, 
            NumericalSample grid) -> NumericalSample
        computePDF(Binomial self, NumericalPoint xMin, NumericalPoint xMax, Indices pointNumber, NumericalSample grid, 
            OT::NumericalScalar const precision=OT::ResourceMap::GetAsNumericalScalar("DistributionImplementation-DefaultPDFEpsilon")) -> NumericalSample
        computePDF(Binomial self, NumericalPoint xMin, NumericalPoint xMax, Indices pointNumber, NumericalSample grid) -> NumericalSample
        computePDF(Binomial self, NumericalPoint point) -> OT::NumericalScalar
        """
        return _dist_bundle1.Binomial_computePDF(self, *args)

    def computeCDF(self, *args):
        """
        computeCDF(Binomial self, OT::NumericalScalar const scalar, OT::Bool const tail) -> OT::NumericalScalar
        computeCDF(Binomial self, OT::NumericalScalar const scalar) -> OT::NumericalScalar
        computeCDF(Binomial self, NumericalPoint point, OT::Bool const tail) -> OT::NumericalScalar
        computeCDF(Binomial self, NumericalPoint point) -> OT::NumericalScalar
        computeCDF(Binomial self, NumericalSample sample, OT::Bool const tail) -> NumericalSample
        computeCDF(Binomial self, NumericalSample sample) -> NumericalSample
        computeCDF(Binomial self, OT::NumericalScalar const xMin, OT::NumericalScalar const xMax, OT::UnsignedLong const pointNumber, 
            NumericalSample grid, OT::NumericalScalar const precision=OT::ResourceMap::GetAsNumericalScalar("DistributionImplementation-DefaultCDFEpsilon")) -> NumericalSample
        computeCDF(Binomial self, OT::NumericalScalar const xMin, OT::NumericalScalar const xMax, OT::UnsignedLong const pointNumber, 
            NumericalSample grid) -> NumericalSample
        computeCDF(Binomial self, NumericalPoint xMin, NumericalPoint xMax, Indices pointNumber, NumericalSample grid, 
            OT::NumericalScalar const precision=OT::ResourceMap::GetAsNumericalScalar("DistributionImplementation-DefaultCDFEpsilon")) -> NumericalSample
        computeCDF(Binomial self, NumericalPoint xMin, NumericalPoint xMax, Indices pointNumber, NumericalSample grid) -> NumericalSample
        computeCDF(Binomial self, NumericalPoint point) -> OT::NumericalScalar
        """
        return _dist_bundle1.Binomial_computeCDF(self, *args)

    def computeComplementaryCDF(self, *args):
        """
        computeComplementaryCDF(Binomial self, OT::NumericalScalar const scalar) -> OT::NumericalScalar
        computeComplementaryCDF(Binomial self, NumericalPoint point) -> OT::NumericalScalar
        computeComplementaryCDF(Binomial self, NumericalSample sample) -> NumericalSample
        computeComplementaryCDF(Binomial self, OT::NumericalScalar const xMin, OT::NumericalScalar const xMax, OT::UnsignedLong const pointNumber, 
            NumericalSample grid, OT::NumericalScalar const precision=OT::ResourceMap::GetAsNumericalScalar("DistributionImplementation-DefaultCDFEpsilon")) -> NumericalSample
        computeComplementaryCDF(Binomial self, OT::NumericalScalar const xMin, OT::NumericalScalar const xMax, OT::UnsignedLong const pointNumber, 
            NumericalSample grid) -> NumericalSample
        computeComplementaryCDF(Binomial self, NumericalPoint point) -> OT::NumericalScalar
        """
        return _dist_bundle1.Binomial_computeComplementaryCDF(self, *args)

    def computePDFGradient(self, *args):
        """computePDFGradient(Binomial self, NumericalPoint point) -> NumericalPoint"""
        return _dist_bundle1.Binomial_computePDFGradient(self, *args)

    def computeCDFGradient(self, *args):
        """computeCDFGradient(Binomial self, NumericalPoint point) -> NumericalPoint"""
        return _dist_bundle1.Binomial_computeCDFGradient(self, *args)

    def computeCharacteristicFunction(self, *args):
        """computeCharacteristicFunction(Binomial self, OT::NumericalScalar const x) -> OT::NumericalComplex"""
        return _dist_bundle1.Binomial_computeCharacteristicFunction(self, *args)

    def computeLogCharacteristicFunction(self, *args):
        """computeLogCharacteristicFunction(Binomial self, OT::NumericalScalar const x) -> OT::NumericalComplex"""
        return _dist_bundle1.Binomial_computeLogCharacteristicFunction(self, *args)

    def computeGeneratingFunction(self, *args):
        """computeGeneratingFunction(Binomial self, OT::NumericalComplex const & z) -> OT::NumericalComplex"""
        return _dist_bundle1.Binomial_computeGeneratingFunction(self, *args)

    def computeLogGeneratingFunction(self, *args):
        """computeLogGeneratingFunction(Binomial self, OT::NumericalComplex const & z) -> OT::NumericalComplex"""
        return _dist_bundle1.Binomial_computeLogGeneratingFunction(self, *args)

    def getSupport(self, *args):
        """
        getSupport(Binomial self, Interval interval) -> NumericalSample
        getSupport(Binomial self) -> NumericalSample
        getSupport(Binomial self, Interval interval) -> NumericalSample
        """
        return _dist_bundle1.Binomial_getSupport(self, *args)

    def getStandardDeviation(self):
        """getStandardDeviation(Binomial self) -> NumericalPoint"""
        return _dist_bundle1.Binomial_getStandardDeviation(self)

    def getSkewness(self):
        """getSkewness(Binomial self) -> NumericalPoint"""
        return _dist_bundle1.Binomial_getSkewness(self)

    def getKurtosis(self):
        """getKurtosis(Binomial self) -> NumericalPoint"""
        return _dist_bundle1.Binomial_getKurtosis(self)

    def getParametersCollection(self):
        """getParametersCollection(Binomial self) -> NumericalPointWithDescriptionCollection"""
        return _dist_bundle1.Binomial_getParametersCollection(self)

    def setParametersCollection(self, *args):
        """
        setParametersCollection(Binomial self, NumericalPointWithDescriptionCollection parametersCollection)
        setParametersCollection(Binomial self, NumericalPointCollection parametersCollection)
        setParametersCollection(Binomial self, NumericalPoint parameters)
        setParametersCollection(Binomial self, NumericalPointCollection parametersCollection)
        """
        return _dist_bundle1.Binomial_setParametersCollection(self, *args)

    def setP(self, *args):
        """setP(Binomial self, OT::NumericalScalar const p)"""
        return _dist_bundle1.Binomial_setP(self, *args)

    def getP(self):
        """getP(Binomial self) -> OT::NumericalScalar"""
        return _dist_bundle1.Binomial_getP(self)

    def setN(self, *args):
        """setN(Binomial self, OT::UnsignedLong const n)"""
        return _dist_bundle1.Binomial_setN(self, *args)

    def getN(self):
        """getN(Binomial self) -> OT::UnsignedLong"""
        return _dist_bundle1.Binomial_getN(self)

    def __init__(self, *args): 
        """
        __init__(OT::Binomial self) -> Binomial
        __init__(OT::Binomial self, OT::UnsignedLong const n, OT::NumericalScalar const p) -> Binomial
        __init__(OT::Binomial self, Binomial other) -> Binomial
        """
        this = _dist_bundle1.new_Binomial(*args)
        try: self.this.append(this)
        except: self.this = this
    __swig_destroy__ = _dist_bundle1.delete_Binomial
    __del__ = lambda self : None;
Binomial_swigregister = _dist_bundle1.Binomial_swigregister
Binomial_swigregister(Binomial)

def Binomial_GetClassName():
  """Binomial_GetClassName() -> OT::String"""
  return _dist_bundle1.Binomial_GetClassName()

class BinomialFactory(openturns.model_copula.DistributionImplementationFactory):
    """Proxy of C++ OT::BinomialFactory class"""
    __swig_setmethods__ = {}
    for _s in [openturns.model_copula.DistributionImplementationFactory]: __swig_setmethods__.update(getattr(_s,'__swig_setmethods__',{}))
    __setattr__ = lambda self, name, value: _swig_setattr(self, BinomialFactory, name, value)
    __swig_getmethods__ = {}
    for _s in [openturns.model_copula.DistributionImplementationFactory]: __swig_getmethods__.update(getattr(_s,'__swig_getmethods__',{}))
    __getattr__ = lambda self, name: _swig_getattr(self, BinomialFactory, name)
    __repr__ = _swig_repr
    def GetClassName():
        """GetClassName() -> OT::String"""
        return _dist_bundle1.BinomialFactory_GetClassName()

    if _newclass:GetClassName = staticmethod(GetClassName)
    __swig_getmethods__["GetClassName"] = lambda x: GetClassName
    def getClassName(self):
        """getClassName(BinomialFactory self) -> OT::String"""
        return _dist_bundle1.BinomialFactory_getClassName(self)

    def build(self, *args):
        """
        build(BinomialFactory self, NumericalSample sample) -> DistributionImplementationPointer
        build(BinomialFactory self, NumericalSample sample, CovarianceMatrix covariance) -> DistributionImplementationPointer
        build(BinomialFactory self, NumericalPointCollection parameters) -> DistributionImplementationPointer
        build(BinomialFactory self, NumericalPointWithDescriptionCollection parameters) -> DistributionImplementationPointer
        build(BinomialFactory self, NumericalSample sample) -> DistributionImplementationPointer
        build(BinomialFactory self, NumericalPointCollection parameters) -> DistributionImplementationPointer
        build(BinomialFactory self) -> DistributionImplementationPointer
        """
        return _dist_bundle1.BinomialFactory_build(self, *args)

    def buildAsBinomial(self, *args):
        """
        buildAsBinomial(BinomialFactory self, NumericalSample sample) -> Binomial
        buildAsBinomial(BinomialFactory self, NumericalPointCollection parameters) -> Binomial
        buildAsBinomial(BinomialFactory self, NumericalPointWithDescriptionCollection parameters) -> Binomial
        buildAsBinomial(BinomialFactory self) -> Binomial
        """
        return _dist_bundle1.BinomialFactory_buildAsBinomial(self, *args)

    def ComputeLogLikelihood(*args):
        """ComputeLogLikelihood(OT::UnsignedLong const n, OT::NumericalScalar const p, NumericalSample sample) -> OT::NumericalScalar"""
        return _dist_bundle1.BinomialFactory_ComputeLogLikelihood(*args)

    if _newclass:ComputeLogLikelihood = staticmethod(ComputeLogLikelihood)
    __swig_getmethods__["ComputeLogLikelihood"] = lambda x: ComputeLogLikelihood
    def __init__(self, *args): 
        """
        __init__(OT::BinomialFactory self) -> BinomialFactory
        __init__(OT::BinomialFactory self, BinomialFactory other) -> BinomialFactory
        """
        this = _dist_bundle1.new_BinomialFactory(*args)
        try: self.this.append(this)
        except: self.this = this
    __swig_destroy__ = _dist_bundle1.delete_BinomialFactory
    __del__ = lambda self : None;
BinomialFactory_swigregister = _dist_bundle1.BinomialFactory_swigregister
BinomialFactory_swigregister(BinomialFactory)

def BinomialFactory_GetClassName():
  """BinomialFactory_GetClassName() -> OT::String"""
  return _dist_bundle1.BinomialFactory_GetClassName()

def BinomialFactory_ComputeLogLikelihood(*args):
  """BinomialFactory_ComputeLogLikelihood(OT::UnsignedLong const n, OT::NumericalScalar const p, NumericalSample sample) -> OT::NumericalScalar"""
  return _dist_bundle1.BinomialFactory_ComputeLogLikelihood(*args)

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

    if _newclass:GetClassName = staticmethod(GetClassName)
    __swig_getmethods__["GetClassName"] = lambda x: GetClassName
    def getClassName(self):
        """getClassName(Burr self) -> OT::String"""
        return _dist_bundle1.Burr_getClassName(self)

    def __eq__(self, *args):
        """__eq__(Burr self, Burr other) -> OT::Bool"""
        return _dist_bundle1.Burr___eq__(self, *args)

    def __repr__(self):
        """__repr__(Burr self) -> OT::String"""
        return _dist_bundle1.Burr___repr__(self)

    def __str__(self, offset=""):
        """
        __str__(Burr self, OT::String const & offset="") -> OT::String
        __str__(Burr self) -> OT::String
        """
        return _dist_bundle1.Burr___str__(self, offset)

    def getRealization(self):
        """getRealization(Burr self) -> NumericalPoint"""
        return _dist_bundle1.Burr_getRealization(self)

    def computeDDF(self, *args):
        """
        computeDDF(Burr self, OT::NumericalScalar const scalar) -> OT::NumericalScalar
        computeDDF(Burr self, NumericalPoint point) -> NumericalPoint
        computeDDF(Burr self, NumericalSample sample) -> NumericalSample
        computeDDF(Burr self, NumericalPoint point) -> NumericalPoint
        """
        return _dist_bundle1.Burr_computeDDF(self, *args)

    def computePDF(self, *args):
        """
        computePDF(Burr self, OT::NumericalScalar const scalar) -> OT::NumericalScalar
        computePDF(Burr self, NumericalPoint point) -> OT::NumericalScalar
        computePDF(Burr self, NumericalSample sample) -> NumericalSample
        computePDF(Burr self, OT::NumericalScalar const xMin, OT::NumericalScalar const xMax, OT::UnsignedLong const pointNumber, 
            NumericalSample grid, OT::NumericalScalar const precision=OT::ResourceMap::GetAsNumericalScalar("DistributionImplementation-DefaultPDFEpsilon")) -> NumericalSample
        computePDF(Burr self, OT::NumericalScalar const xMin, OT::NumericalScalar const xMax, OT::UnsignedLong const pointNumber, 
            NumericalSample grid) -> NumericalSample
        computePDF(Burr self, NumericalPoint xMin, NumericalPoint xMax, Indices pointNumber, NumericalSample grid, 
            OT::NumericalScalar const precision=OT::ResourceMap::GetAsNumericalScalar("DistributionImplementation-DefaultPDFEpsilon")) -> NumericalSample
        computePDF(Burr self, NumericalPoint xMin, NumericalPoint xMax, Indices pointNumber, NumericalSample grid) -> NumericalSample
        computePDF(Burr self, NumericalPoint point) -> OT::NumericalScalar
        """
        return _dist_bundle1.Burr_computePDF(self, *args)

    def computeLogPDF(self, *args):
        """
        computeLogPDF(Burr self, OT::NumericalScalar const scalar) -> OT::NumericalScalar
        computeLogPDF(Burr self, NumericalPoint point) -> OT::NumericalScalar
        computeLogPDF(Burr self, NumericalSample sample) -> NumericalSample
        computeLogPDF(Burr self, NumericalPoint point) -> OT::NumericalScalar
        """
        return _dist_bundle1.Burr_computeLogPDF(self, *args)

    def computeCDF(self, *args):
        """
        computeCDF(Burr self, OT::NumericalScalar const scalar, OT::Bool const tail) -> OT::NumericalScalar
        computeCDF(Burr self, OT::NumericalScalar const scalar) -> OT::NumericalScalar
        computeCDF(Burr self, NumericalPoint point, OT::Bool const tail) -> OT::NumericalScalar
        computeCDF(Burr self, NumericalPoint point) -> OT::NumericalScalar
        computeCDF(Burr self, NumericalSample sample, OT::Bool const tail) -> NumericalSample
        computeCDF(Burr self, NumericalSample sample) -> NumericalSample
        computeCDF(Burr self, OT::NumericalScalar const xMin, OT::NumericalScalar const xMax, OT::UnsignedLong const pointNumber, 
            NumericalSample grid, OT::NumericalScalar const precision=OT::ResourceMap::GetAsNumericalScalar("DistributionImplementation-DefaultCDFEpsilon")) -> NumericalSample
        computeCDF(Burr self, OT::NumericalScalar const xMin, OT::NumericalScalar const xMax, OT::UnsignedLong const pointNumber, 
            NumericalSample grid) -> NumericalSample
        computeCDF(Burr self, NumericalPoint xMin, NumericalPoint xMax, Indices pointNumber, NumericalSample grid, 
            OT::NumericalScalar const precision=OT::ResourceMap::GetAsNumericalScalar("DistributionImplementation-DefaultCDFEpsilon")) -> NumericalSample
        computeCDF(Burr self, NumericalPoint xMin, NumericalPoint xMax, Indices pointNumber, NumericalSample grid) -> NumericalSample
        computeCDF(Burr self, NumericalPoint point) -> OT::NumericalScalar
        """
        return _dist_bundle1.Burr_computeCDF(self, *args)

    def computePDFGradient(self, *args):
        """computePDFGradient(Burr self, NumericalPoint point) -> NumericalPoint"""
        return _dist_bundle1.Burr_computePDFGradient(self, *args)

    def computeCDFGradient(self, *args):
        """computeCDFGradient(Burr self, NumericalPoint point) -> NumericalPoint"""
        return _dist_bundle1.Burr_computeCDFGradient(self, *args)

    def getStandardDeviation(self):
        """getStandardDeviation(Burr self) -> NumericalPoint"""
        return _dist_bundle1.Burr_getStandardDeviation(self)

    def getSkewness(self):
        """getSkewness(Burr self) -> NumericalPoint"""
        return _dist_bundle1.Burr_getSkewness(self)

    def getKurtosis(self):
        """getKurtosis(Burr self) -> NumericalPoint"""
        return _dist_bundle1.Burr_getKurtosis(self)

    def getStandardMoment(self, *args):
        """getStandardMoment(Burr self, OT::UnsignedLong const n) -> NumericalPoint"""
        return _dist_bundle1.Burr_getStandardMoment(self, *args)

    def getParametersCollection(self):
        """getParametersCollection(Burr self) -> NumericalPointWithDescriptionCollection"""
        return _dist_bundle1.Burr_getParametersCollection(self)

    def setParametersCollection(self, *args):
        """
        setParametersCollection(Burr self, NumericalPointWithDescriptionCollection parametersCollection)
        setParametersCollection(Burr self, NumericalPointCollection parametersCollection)
        setParametersCollection(Burr self, NumericalPoint parameters)
        setParametersCollection(Burr self, NumericalPointCollection parametersCollection)
        """
        return _dist_bundle1.Burr_setParametersCollection(self, *args)

    def setC(self, *args):
        """setC(Burr self, OT::NumericalScalar const c)"""
        return _dist_bundle1.Burr_setC(self, *args)

    def getC(self):
        """getC(Burr self) -> OT::NumericalScalar"""
        return _dist_bundle1.Burr_getC(self)

    def setK(self, *args):
        """setK(Burr self, OT::NumericalScalar const k)"""
        return _dist_bundle1.Burr_setK(self, *args)

    def getK(self):
        """getK(Burr self) -> OT::NumericalScalar"""
        return _dist_bundle1.Burr_getK(self)

    def __init__(self, *args): 
        """
        __init__(OT::Burr self) -> Burr
        __init__(OT::Burr self, OT::NumericalScalar const c, OT::NumericalScalar const k) -> Burr
        __init__(OT::Burr self, Burr other) -> Burr
        """
        this = _dist_bundle1.new_Burr(*args)
        try: self.this.append(this)
        except: self.this = this
    __swig_destroy__ = _dist_bundle1.delete_Burr
    __del__ = lambda self : None;
Burr_swigregister = _dist_bundle1.Burr_swigregister
Burr_swigregister(Burr)

def Burr_GetClassName():
  """Burr_GetClassName() -> OT::String"""
  return _dist_bundle1.Burr_GetClassName()

class BurrFactory(openturns.model_copula.DistributionImplementationFactory):
    """Proxy of C++ OT::BurrFactory class"""
    __swig_setmethods__ = {}
    for _s in [openturns.model_copula.DistributionImplementationFactory]: __swig_setmethods__.update(getattr(_s,'__swig_setmethods__',{}))
    __setattr__ = lambda self, name, value: _swig_setattr(self, BurrFactory, name, value)
    __swig_getmethods__ = {}
    for _s in [openturns.model_copula.DistributionImplementationFactory]: __swig_getmethods__.update(getattr(_s,'__swig_getmethods__',{}))
    __getattr__ = lambda self, name: _swig_getattr(self, BurrFactory, name)
    __repr__ = _swig_repr
    def GetClassName():
        """GetClassName() -> OT::String"""
        return _dist_bundle1.BurrFactory_GetClassName()

    if _newclass:GetClassName = staticmethod(GetClassName)
    __swig_getmethods__["GetClassName"] = lambda x: GetClassName
    def getClassName(self):
        """getClassName(BurrFactory self) -> OT::String"""
        return _dist_bundle1.BurrFactory_getClassName(self)

    def build(self, *args):
        """
        build(BurrFactory self, NumericalSample sample) -> DistributionImplementationPointer
        build(BurrFactory self, NumericalSample sample, CovarianceMatrix covariance) -> DistributionImplementationPointer
        build(BurrFactory self, NumericalPointCollection parameters) -> DistributionImplementationPointer
        build(BurrFactory self, NumericalPointWithDescriptionCollection parameters) -> DistributionImplementationPointer
        build(BurrFactory self, NumericalSample sample) -> DistributionImplementationPointer
        build(BurrFactory self, NumericalPointCollection parameters) -> DistributionImplementationPointer
        build(BurrFactory self) -> DistributionImplementationPointer
        """
        return _dist_bundle1.BurrFactory_build(self, *args)

    def buildAsBurr(self, *args):
        """
        buildAsBurr(BurrFactory self, NumericalSample sample) -> Burr
        buildAsBurr(BurrFactory self, NumericalPointCollection parameters) -> Burr
        buildAsBurr(BurrFactory self, NumericalPointWithDescriptionCollection parameters) -> Burr
        buildAsBurr(BurrFactory self) -> Burr
        """
        return _dist_bundle1.BurrFactory_buildAsBurr(self, *args)

    def __init__(self, *args): 
        """
        __init__(OT::BurrFactory self) -> BurrFactory
        __init__(OT::BurrFactory self, BurrFactory other) -> BurrFactory
        """
        this = _dist_bundle1.new_BurrFactory(*args)
        try: self.this.append(this)
        except: self.this = this
    __swig_destroy__ = _dist_bundle1.delete_BurrFactory
    __del__ = lambda self : None;
BurrFactory_swigregister = _dist_bundle1.BurrFactory_swigregister
BurrFactory_swigregister(BurrFactory)

def BurrFactory_GetClassName():
  """BurrFactory_GetClassName() -> OT::String"""
  return _dist_bundle1.BurrFactory_GetClassName()

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

    if _newclass:GetClassName = staticmethod(GetClassName)
    __swig_getmethods__["GetClassName"] = lambda x: GetClassName
    def getClassName(self):
        """getClassName(Chi self) -> OT::String"""
        return _dist_bundle1.Chi_getClassName(self)

    def __eq__(self, *args):
        """__eq__(Chi self, Chi other) -> OT::Bool"""
        return _dist_bundle1.Chi___eq__(self, *args)

    def __repr__(self):
        """__repr__(Chi self) -> OT::String"""
        return _dist_bundle1.Chi___repr__(self)

    def __str__(self, offset=""):
        """
        __str__(Chi self, OT::String const & offset="") -> OT::String
        __str__(Chi self) -> OT::String
        """
        return _dist_bundle1.Chi___str__(self, offset)

    def getRealization(self):
        """getRealization(Chi self) -> NumericalPoint"""
        return _dist_bundle1.Chi_getRealization(self)

    def computeDDF(self, *args):
        """
        computeDDF(Chi self, OT::NumericalScalar const scalar) -> OT::NumericalScalar
        computeDDF(Chi self, NumericalPoint point) -> NumericalPoint
        computeDDF(Chi self, NumericalSample sample) -> NumericalSample
        computeDDF(Chi self, NumericalPoint point) -> NumericalPoint
        """
        return _dist_bundle1.Chi_computeDDF(self, *args)

    def computePDF(self, *args):
        """
        computePDF(Chi self, OT::NumericalScalar const scalar) -> OT::NumericalScalar
        computePDF(Chi self, NumericalPoint point) -> OT::NumericalScalar
        computePDF(Chi self, NumericalSample sample) -> NumericalSample
        computePDF(Chi self, OT::NumericalScalar const xMin, OT::NumericalScalar const xMax, OT::UnsignedLong const pointNumber, 
            NumericalSample grid, OT::NumericalScalar const precision=OT::ResourceMap::GetAsNumericalScalar("DistributionImplementation-DefaultPDFEpsilon")) -> NumericalSample
        computePDF(Chi self, OT::NumericalScalar const xMin, OT::NumericalScalar const xMax, OT::UnsignedLong const pointNumber, 
            NumericalSample grid) -> NumericalSample
        computePDF(Chi self, NumericalPoint xMin, NumericalPoint xMax, Indices pointNumber, NumericalSample grid, 
            OT::NumericalScalar const precision=OT::ResourceMap::GetAsNumericalScalar("DistributionImplementation-DefaultPDFEpsilon")) -> NumericalSample
        computePDF(Chi self, NumericalPoint xMin, NumericalPoint xMax, Indices pointNumber, NumericalSample grid) -> NumericalSample
        computePDF(Chi self, NumericalPoint point) -> OT::NumericalScalar
        """
        return _dist_bundle1.Chi_computePDF(self, *args)

    def computeLogPDF(self, *args):
        """
        computeLogPDF(Chi self, OT::NumericalScalar const scalar) -> OT::NumericalScalar
        computeLogPDF(Chi self, NumericalPoint point) -> OT::NumericalScalar
        computeLogPDF(Chi self, NumericalSample sample) -> NumericalSample
        computeLogPDF(Chi self, NumericalPoint point) -> OT::NumericalScalar
        """
        return _dist_bundle1.Chi_computeLogPDF(self, *args)

    def computeCDF(self, *args):
        """
        computeCDF(Chi self, OT::NumericalScalar const scalar, OT::Bool const tail) -> OT::NumericalScalar
        computeCDF(Chi self, OT::NumericalScalar const scalar) -> OT::NumericalScalar
        computeCDF(Chi self, NumericalPoint point, OT::Bool const tail) -> OT::NumericalScalar
        computeCDF(Chi self, NumericalPoint point) -> OT::NumericalScalar
        computeCDF(Chi self, NumericalSample sample, OT::Bool const tail) -> NumericalSample
        computeCDF(Chi self, NumericalSample sample) -> NumericalSample
        computeCDF(Chi self, OT::NumericalScalar const xMin, OT::NumericalScalar const xMax, OT::UnsignedLong const pointNumber, 
            NumericalSample grid, OT::NumericalScalar const precision=OT::ResourceMap::GetAsNumericalScalar("DistributionImplementation-DefaultCDFEpsilon")) -> NumericalSample
        computeCDF(Chi self, OT::NumericalScalar const xMin, OT::NumericalScalar const xMax, OT::UnsignedLong const pointNumber, 
            NumericalSample grid) -> NumericalSample
        computeCDF(Chi self, NumericalPoint xMin, NumericalPoint xMax, Indices pointNumber, NumericalSample grid, 
            OT::NumericalScalar const precision=OT::ResourceMap::GetAsNumericalScalar("DistributionImplementation-DefaultCDFEpsilon")) -> NumericalSample
        computeCDF(Chi self, NumericalPoint xMin, NumericalPoint xMax, Indices pointNumber, NumericalSample grid) -> NumericalSample
        computeCDF(Chi self, NumericalPoint point) -> OT::NumericalScalar
        """
        return _dist_bundle1.Chi_computeCDF(self, *args)

    def computeComplementaryCDF(self, *args):
        """
        computeComplementaryCDF(Chi self, OT::NumericalScalar const scalar) -> OT::NumericalScalar
        computeComplementaryCDF(Chi self, NumericalPoint point) -> OT::NumericalScalar
        computeComplementaryCDF(Chi self, NumericalSample sample) -> NumericalSample
        computeComplementaryCDF(Chi self, OT::NumericalScalar const xMin, OT::NumericalScalar const xMax, OT::UnsignedLong const pointNumber, 
            NumericalSample grid, OT::NumericalScalar const precision=OT::ResourceMap::GetAsNumericalScalar("DistributionImplementation-DefaultCDFEpsilon")) -> NumericalSample
        computeComplementaryCDF(Chi self, OT::NumericalScalar const xMin, OT::NumericalScalar const xMax, OT::UnsignedLong const pointNumber, 
            NumericalSample grid) -> NumericalSample
        computeComplementaryCDF(Chi self, NumericalPoint point) -> OT::NumericalScalar
        """
        return _dist_bundle1.Chi_computeComplementaryCDF(self, *args)

    def computeCharacteristicFunction(self, *args):
        """computeCharacteristicFunction(Chi self, OT::NumericalScalar const x) -> OT::NumericalComplex"""
        return _dist_bundle1.Chi_computeCharacteristicFunction(self, *args)

    def computePDFGradient(self, *args):
        """computePDFGradient(Chi self, NumericalPoint point) -> NumericalPoint"""
        return _dist_bundle1.Chi_computePDFGradient(self, *args)

    def computeCDFGradient(self, *args):
        """computeCDFGradient(Chi self, NumericalPoint point) -> NumericalPoint"""
        return _dist_bundle1.Chi_computeCDFGradient(self, *args)

    def computeScalarQuantile(self, *args):
        """
        computeScalarQuantile(Chi self, OT::NumericalScalar const prob, OT::Bool const tail=False, OT::NumericalScalar const precision=OT::ResourceMap::GetAsNumericalScalar("DistributionImplementation-DefaultQuantileEpsilon")) -> OT::NumericalScalar
        computeScalarQuantile(Chi self, OT::NumericalScalar const prob, OT::Bool const tail=False) -> OT::NumericalScalar
        computeScalarQuantile(Chi self, OT::NumericalScalar const prob) -> OT::NumericalScalar
        """
        return _dist_bundle1.Chi_computeScalarQuantile(self, *args)

    def getStandardDeviation(self):
        """getStandardDeviation(Chi self) -> NumericalPoint"""
        return _dist_bundle1.Chi_getStandardDeviation(self)

    def getSkewness(self):
        """getSkewness(Chi self) -> NumericalPoint"""
        return _dist_bundle1.Chi_getSkewness(self)

    def getKurtosis(self):
        """getKurtosis(Chi self) -> NumericalPoint"""
        return _dist_bundle1.Chi_getKurtosis(self)

    def getStandardMoment(self, *args):
        """getStandardMoment(Chi self, OT::UnsignedLong const n) -> NumericalPoint"""
        return _dist_bundle1.Chi_getStandardMoment(self, *args)

    def getParametersCollection(self):
        """getParametersCollection(Chi self) -> NumericalPointWithDescriptionCollection"""
        return _dist_bundle1.Chi_getParametersCollection(self)

    def setParametersCollection(self, *args):
        """
        setParametersCollection(Chi self, NumericalPointWithDescriptionCollection parametersCollection)
        setParametersCollection(Chi self, NumericalPointCollection parametersCollection)
        setParametersCollection(Chi self, NumericalPoint parameters)
        setParametersCollection(Chi self, NumericalPointCollection parametersCollection)
        """
        return _dist_bundle1.Chi_setParametersCollection(self, *args)

    def setNu(self, *args):
        """setNu(Chi self, OT::NumericalScalar const nu)"""
        return _dist_bundle1.Chi_setNu(self, *args)

    def getNu(self):
        """getNu(Chi self) -> OT::NumericalScalar"""
        return _dist_bundle1.Chi_getNu(self)

    def __init__(self, *args): 
        """
        __init__(OT::Chi self) -> Chi
        __init__(OT::Chi self, OT::NumericalScalar const nu_) -> Chi
        __init__(OT::Chi self, Chi other) -> Chi
        """
        this = _dist_bundle1.new_Chi(*args)
        try: self.this.append(this)
        except: self.this = this
    __swig_destroy__ = _dist_bundle1.delete_Chi
    __del__ = lambda self : None;
Chi_swigregister = _dist_bundle1.Chi_swigregister
Chi_swigregister(Chi)

def Chi_GetClassName():
  """Chi_GetClassName() -> OT::String"""
  return _dist_bundle1.Chi_GetClassName()

class ChiFactory(openturns.model_copula.DistributionImplementationFactory):
    """Proxy of C++ OT::ChiFactory class"""
    __swig_setmethods__ = {}
    for _s in [openturns.model_copula.DistributionImplementationFactory]: __swig_setmethods__.update(getattr(_s,'__swig_setmethods__',{}))
    __setattr__ = lambda self, name, value: _swig_setattr(self, ChiFactory, name, value)
    __swig_getmethods__ = {}
    for _s in [openturns.model_copula.DistributionImplementationFactory]: __swig_getmethods__.update(getattr(_s,'__swig_getmethods__',{}))
    __getattr__ = lambda self, name: _swig_getattr(self, ChiFactory, name)
    __repr__ = _swig_repr
    def GetClassName():
        """GetClassName() -> OT::String"""
        return _dist_bundle1.ChiFactory_GetClassName()

    if _newclass:GetClassName = staticmethod(GetClassName)
    __swig_getmethods__["GetClassName"] = lambda x: GetClassName
    def getClassName(self):
        """getClassName(ChiFactory self) -> OT::String"""
        return _dist_bundle1.ChiFactory_getClassName(self)

    def build(self, *args):
        """
        build(ChiFactory self, NumericalSample sample) -> DistributionImplementationPointer
        build(ChiFactory self, NumericalSample sample, CovarianceMatrix covariance) -> DistributionImplementationPointer
        build(ChiFactory self, NumericalPointCollection parameters) -> DistributionImplementationPointer
        build(ChiFactory self, NumericalPointWithDescriptionCollection parameters) -> DistributionImplementationPointer
        build(ChiFactory self, NumericalSample sample) -> DistributionImplementationPointer
        build(ChiFactory self, NumericalPointCollection parameters) -> DistributionImplementationPointer
        build(ChiFactory self) -> DistributionImplementationPointer
        """
        return _dist_bundle1.ChiFactory_build(self, *args)

    def buildAsChi(self, *args):
        """
        buildAsChi(ChiFactory self, NumericalSample sample) -> Chi
        buildAsChi(ChiFactory self, NumericalPointCollection parameters) -> Chi
        buildAsChi(ChiFactory self, NumericalPointWithDescriptionCollection parameters) -> Chi
        buildAsChi(ChiFactory self) -> Chi
        """
        return _dist_bundle1.ChiFactory_buildAsChi(self, *args)

    def __init__(self, *args): 
        """
        __init__(OT::ChiFactory self) -> ChiFactory
        __init__(OT::ChiFactory self, ChiFactory other) -> ChiFactory
        """
        this = _dist_bundle1.new_ChiFactory(*args)
        try: self.this.append(this)
        except: self.this = this
    __swig_destroy__ = _dist_bundle1.delete_ChiFactory
    __del__ = lambda self : None;
ChiFactory_swigregister = _dist_bundle1.ChiFactory_swigregister
ChiFactory_swigregister(ChiFactory)

def ChiFactory_GetClassName():
  """ChiFactory_GetClassName() -> OT::String"""
  return _dist_bundle1.ChiFactory_GetClassName()

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

    if _newclass:GetClassName = staticmethod(GetClassName)
    __swig_getmethods__["GetClassName"] = lambda x: GetClassName
    def getClassName(self):
        """getClassName(ChiSquare self) -> OT::String"""
        return _dist_bundle1.ChiSquare_getClassName(self)

    def __eq__(self, *args):
        """__eq__(ChiSquare self, ChiSquare other) -> OT::Bool"""
        return _dist_bundle1.ChiSquare___eq__(self, *args)

    def __repr__(self):
        """__repr__(ChiSquare self) -> OT::String"""
        return _dist_bundle1.ChiSquare___repr__(self)

    def __str__(self, offset=""):
        """
        __str__(ChiSquare self, OT::String const & offset="") -> OT::String
        __str__(ChiSquare self) -> OT::String
        """
        return _dist_bundle1.ChiSquare___str__(self, offset)

    def getRealization(self):
        """getRealization(ChiSquare self) -> NumericalPoint"""
        return _dist_bundle1.ChiSquare_getRealization(self)

    def computeDDF(self, *args):
        """
        computeDDF(ChiSquare self, OT::NumericalScalar const scalar) -> OT::NumericalScalar
        computeDDF(ChiSquare self, NumericalPoint point) -> NumericalPoint
        computeDDF(ChiSquare self, NumericalSample sample) -> NumericalSample
        computeDDF(ChiSquare self, NumericalPoint point) -> NumericalPoint
        """
        return _dist_bundle1.ChiSquare_computeDDF(self, *args)

    def computePDF(self, *args):
        """
        computePDF(ChiSquare self, OT::NumericalScalar const scalar) -> OT::NumericalScalar
        computePDF(ChiSquare self, NumericalPoint point) -> OT::NumericalScalar
        computePDF(ChiSquare self, NumericalSample sample) -> NumericalSample
        computePDF(ChiSquare self, OT::NumericalScalar const xMin, OT::NumericalScalar const xMax, OT::UnsignedLong const pointNumber, 
            NumericalSample grid, OT::NumericalScalar const precision=OT::ResourceMap::GetAsNumericalScalar("DistributionImplementation-DefaultPDFEpsilon")) -> NumericalSample
        computePDF(ChiSquare self, OT::NumericalScalar const xMin, OT::NumericalScalar const xMax, OT::UnsignedLong const pointNumber, 
            NumericalSample grid) -> NumericalSample
        computePDF(ChiSquare self, NumericalPoint xMin, NumericalPoint xMax, Indices pointNumber, NumericalSample grid, 
            OT::NumericalScalar const precision=OT::ResourceMap::GetAsNumericalScalar("DistributionImplementation-DefaultPDFEpsilon")) -> NumericalSample
        computePDF(ChiSquare self, NumericalPoint xMin, NumericalPoint xMax, Indices pointNumber, NumericalSample grid) -> NumericalSample
        computePDF(ChiSquare self, NumericalPoint point) -> OT::NumericalScalar
        """
        return _dist_bundle1.ChiSquare_computePDF(self, *args)

    def computeLogPDF(self, *args):
        """
        computeLogPDF(ChiSquare self, OT::NumericalScalar const scalar) -> OT::NumericalScalar
        computeLogPDF(ChiSquare self, NumericalPoint point) -> OT::NumericalScalar
        computeLogPDF(ChiSquare self, NumericalSample sample) -> NumericalSample
        computeLogPDF(ChiSquare self, NumericalPoint point) -> OT::NumericalScalar
        """
        return _dist_bundle1.ChiSquare_computeLogPDF(self, *args)

    def computeCDF(self, *args):
        """
        computeCDF(ChiSquare self, OT::NumericalScalar const scalar, OT::Bool const tail) -> OT::NumericalScalar
        computeCDF(ChiSquare self, OT::NumericalScalar const scalar) -> OT::NumericalScalar
        computeCDF(ChiSquare self, NumericalPoint point, OT::Bool const tail) -> OT::NumericalScalar
        computeCDF(ChiSquare self, NumericalPoint point) -> OT::NumericalScalar
        computeCDF(ChiSquare self, NumericalSample sample, OT::Bool const tail) -> NumericalSample
        computeCDF(ChiSquare self, NumericalSample sample) -> NumericalSample
        computeCDF(ChiSquare self, OT::NumericalScalar const xMin, OT::NumericalScalar const xMax, OT::UnsignedLong const pointNumber, 
            NumericalSample grid, OT::NumericalScalar const precision=OT::ResourceMap::GetAsNumericalScalar("DistributionImplementation-DefaultCDFEpsilon")) -> NumericalSample
        computeCDF(ChiSquare self, OT::NumericalScalar const xMin, OT::NumericalScalar const xMax, OT::UnsignedLong const pointNumber, 
            NumericalSample grid) -> NumericalSample
        computeCDF(ChiSquare self, NumericalPoint xMin, NumericalPoint xMax, Indices pointNumber, NumericalSample grid, 
            OT::NumericalScalar const precision=OT::ResourceMap::GetAsNumericalScalar("DistributionImplementation-DefaultCDFEpsilon")) -> NumericalSample
        computeCDF(ChiSquare self, NumericalPoint xMin, NumericalPoint xMax, Indices pointNumber, NumericalSample grid) -> NumericalSample
        computeCDF(ChiSquare self, NumericalPoint point) -> OT::NumericalScalar
        """
        return _dist_bundle1.ChiSquare_computeCDF(self, *args)

    def computeComplementaryCDF(self, *args):
        """
        computeComplementaryCDF(ChiSquare self, OT::NumericalScalar const scalar) -> OT::NumericalScalar
        computeComplementaryCDF(ChiSquare self, NumericalPoint point) -> OT::NumericalScalar
        computeComplementaryCDF(ChiSquare self, NumericalSample sample) -> NumericalSample
        computeComplementaryCDF(ChiSquare self, OT::NumericalScalar const xMin, OT::NumericalScalar const xMax, OT::UnsignedLong const pointNumber, 
            NumericalSample grid, OT::NumericalScalar const precision=OT::ResourceMap::GetAsNumericalScalar("DistributionImplementation-DefaultCDFEpsilon")) -> NumericalSample
        computeComplementaryCDF(ChiSquare self, OT::NumericalScalar const xMin, OT::NumericalScalar const xMax, OT::UnsignedLong const pointNumber, 
            NumericalSample grid) -> NumericalSample
        computeComplementaryCDF(ChiSquare self, NumericalPoint point) -> OT::NumericalScalar
        """
        return _dist_bundle1.ChiSquare_computeComplementaryCDF(self, *args)

    def computeCharacteristicFunction(self, *args):
        """computeCharacteristicFunction(ChiSquare self, OT::NumericalScalar const x) -> OT::NumericalComplex"""
        return _dist_bundle1.ChiSquare_computeCharacteristicFunction(self, *args)

    def computeLogCharacteristicFunction(self, *args):
        """computeLogCharacteristicFunction(ChiSquare self, OT::NumericalScalar const x) -> OT::NumericalComplex"""
        return _dist_bundle1.ChiSquare_computeLogCharacteristicFunction(self, *args)

    def computePDFGradient(self, *args):
        """computePDFGradient(ChiSquare self, NumericalPoint point) -> NumericalPoint"""
        return _dist_bundle1.ChiSquare_computePDFGradient(self, *args)

    def computeCDFGradient(self, *args):
        """computeCDFGradient(ChiSquare self, NumericalPoint point) -> NumericalPoint"""
        return _dist_bundle1.ChiSquare_computeCDFGradient(self, *args)

    def getStandardDeviation(self):
        """getStandardDeviation(ChiSquare self) -> NumericalPoint"""
        return _dist_bundle1.ChiSquare_getStandardDeviation(self)

    def getSkewness(self):
        """getSkewness(ChiSquare self) -> NumericalPoint"""
        return _dist_bundle1.ChiSquare_getSkewness(self)

    def getKurtosis(self):
        """getKurtosis(ChiSquare self) -> NumericalPoint"""
        return _dist_bundle1.ChiSquare_getKurtosis(self)

    def getStandardMoment(self, *args):
        """getStandardMoment(ChiSquare self, OT::UnsignedLong const n) -> NumericalPoint"""
        return _dist_bundle1.ChiSquare_getStandardMoment(self, *args)

    def getParametersCollection(self):
        """getParametersCollection(ChiSquare self) -> NumericalPointWithDescriptionCollection"""
        return _dist_bundle1.ChiSquare_getParametersCollection(self)

    def setParametersCollection(self, *args):
        """
        setParametersCollection(ChiSquare self, NumericalPointWithDescriptionCollection parametersCollection)
        setParametersCollection(ChiSquare self, NumericalPointCollection parametersCollection)
        setParametersCollection(ChiSquare self, NumericalPoint parameters)
        setParametersCollection(ChiSquare self, NumericalPointCollection parametersCollection)
        """
        return _dist_bundle1.ChiSquare_setParametersCollection(self, *args)

    def setNu(self, *args):
        """setNu(ChiSquare self, OT::NumericalScalar const nu)"""
        return _dist_bundle1.ChiSquare_setNu(self, *args)

    def getNu(self):
        """getNu(ChiSquare self) -> OT::NumericalScalar"""
        return _dist_bundle1.ChiSquare_getNu(self)

    def __init__(self, *args): 
        """
        __init__(OT::ChiSquare self) -> ChiSquare
        __init__(OT::ChiSquare self, OT::NumericalScalar const nu_) -> ChiSquare
        __init__(OT::ChiSquare self, ChiSquare other) -> ChiSquare
        """
        this = _dist_bundle1.new_ChiSquare(*args)
        try: self.this.append(this)
        except: self.this = this
    __swig_destroy__ = _dist_bundle1.delete_ChiSquare
    __del__ = lambda self : None;
ChiSquare_swigregister = _dist_bundle1.ChiSquare_swigregister
ChiSquare_swigregister(ChiSquare)

def ChiSquare_GetClassName():
  """ChiSquare_GetClassName() -> OT::String"""
  return _dist_bundle1.ChiSquare_GetClassName()

class ChiSquareFactory(openturns.model_copula.DistributionImplementationFactory):
    """Proxy of C++ OT::ChiSquareFactory class"""
    __swig_setmethods__ = {}
    for _s in [openturns.model_copula.DistributionImplementationFactory]: __swig_setmethods__.update(getattr(_s,'__swig_setmethods__',{}))
    __setattr__ = lambda self, name, value: _swig_setattr(self, ChiSquareFactory, name, value)
    __swig_getmethods__ = {}
    for _s in [openturns.model_copula.DistributionImplementationFactory]: __swig_getmethods__.update(getattr(_s,'__swig_getmethods__',{}))
    __getattr__ = lambda self, name: _swig_getattr(self, ChiSquareFactory, name)
    __repr__ = _swig_repr
    def GetClassName():
        """GetClassName() -> OT::String"""
        return _dist_bundle1.ChiSquareFactory_GetClassName()

    if _newclass:GetClassName = staticmethod(GetClassName)
    __swig_getmethods__["GetClassName"] = lambda x: GetClassName
    def getClassName(self):
        """getClassName(ChiSquareFactory self) -> OT::String"""
        return _dist_bundle1.ChiSquareFactory_getClassName(self)

    def build(self, *args):
        """
        build(ChiSquareFactory self, NumericalSample sample) -> DistributionImplementationPointer
        build(ChiSquareFactory self, NumericalSample sample, CovarianceMatrix covariance) -> DistributionImplementationPointer
        build(ChiSquareFactory self, NumericalPointCollection parameters) -> DistributionImplementationPointer
        build(ChiSquareFactory self, NumericalPointWithDescriptionCollection parameters) -> DistributionImplementationPointer
        build(ChiSquareFactory self, NumericalSample sample) -> DistributionImplementationPointer
        build(ChiSquareFactory self, NumericalPointCollection parameters) -> DistributionImplementationPointer
        build(ChiSquareFactory self) -> DistributionImplementationPointer
        """
        return _dist_bundle1.ChiSquareFactory_build(self, *args)

    def buildAsChiSquare(self, *args):
        """
        buildAsChiSquare(ChiSquareFactory self, NumericalSample sample) -> ChiSquare
        buildAsChiSquare(ChiSquareFactory self, NumericalPointCollection parameters) -> ChiSquare
        buildAsChiSquare(ChiSquareFactory self, NumericalPointWithDescriptionCollection parameters) -> ChiSquare
        buildAsChiSquare(ChiSquareFactory self) -> ChiSquare
        """
        return _dist_bundle1.ChiSquareFactory_buildAsChiSquare(self, *args)

    def __init__(self, *args): 
        """
        __init__(OT::ChiSquareFactory self) -> ChiSquareFactory
        __init__(OT::ChiSquareFactory self, ChiSquareFactory other) -> ChiSquareFactory
        """
        this = _dist_bundle1.new_ChiSquareFactory(*args)
        try: self.this.append(this)
        except: self.this = this
    __swig_destroy__ = _dist_bundle1.delete_ChiSquareFactory
    __del__ = lambda self : None;
ChiSquareFactory_swigregister = _dist_bundle1.ChiSquareFactory_swigregister
ChiSquareFactory_swigregister(ChiSquareFactory)

def ChiSquareFactory_GetClassName():
  """ChiSquareFactory_GetClassName() -> OT::String"""
  return _dist_bundle1.ChiSquareFactory_GetClassName()

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

    if _newclass:GetClassName = staticmethod(GetClassName)
    __swig_getmethods__["GetClassName"] = lambda x: GetClassName
    def getClassName(self):
        """getClassName(Dirac self) -> OT::String"""
        return _dist_bundle1.Dirac_getClassName(self)

    def __eq__(self, *args):
        """__eq__(Dirac self, Dirac other) -> OT::Bool"""
        return _dist_bundle1.Dirac___eq__(self, *args)

    def __repr__(self):
        """__repr__(Dirac self) -> OT::String"""
        return _dist_bundle1.Dirac___repr__(self)

    def __str__(self, offset=""):
        """
        __str__(Dirac self, OT::String const & offset="") -> OT::String
        __str__(Dirac self) -> OT::String
        """
        return _dist_bundle1.Dirac___str__(self, offset)

    def getRealization(self):
        """getRealization(Dirac self) -> NumericalPoint"""
        return _dist_bundle1.Dirac_getRealization(self)

    def computePDF(self, *args):
        """
        computePDF(Dirac self, OT::NumericalScalar const scalar) -> OT::NumericalScalar
        computePDF(Dirac self, NumericalPoint point) -> OT::NumericalScalar
        computePDF(Dirac self, NumericalSample sample) -> NumericalSample
        computePDF(Dirac self, OT::NumericalScalar const xMin, OT::NumericalScalar const xMax, OT::UnsignedLong const pointNumber, 
            NumericalSample grid, OT::NumericalScalar const precision=OT::ResourceMap::GetAsNumericalScalar("DistributionImplementation-DefaultPDFEpsilon")) -> NumericalSample
        computePDF(Dirac self, OT::NumericalScalar const xMin, OT::NumericalScalar const xMax, OT::UnsignedLong const pointNumber, 
            NumericalSample grid) -> NumericalSample
        computePDF(Dirac self, NumericalPoint xMin, NumericalPoint xMax, Indices pointNumber, NumericalSample grid, 
            OT::NumericalScalar const precision=OT::ResourceMap::GetAsNumericalScalar("DistributionImplementation-DefaultPDFEpsilon")) -> NumericalSample
        computePDF(Dirac self, NumericalPoint xMin, NumericalPoint xMax, Indices pointNumber, NumericalSample grid) -> NumericalSample
        computePDF(Dirac self, NumericalPoint point) -> OT::NumericalScalar
        """
        return _dist_bundle1.Dirac_computePDF(self, *args)

    def computeCDF(self, *args):
        """
        computeCDF(Dirac self, OT::NumericalScalar const scalar, OT::Bool const tail) -> OT::NumericalScalar
        computeCDF(Dirac self, OT::NumericalScalar const scalar) -> OT::NumericalScalar
        computeCDF(Dirac self, NumericalPoint point, OT::Bool const tail) -> OT::NumericalScalar
        computeCDF(Dirac self, NumericalPoint point) -> OT::NumericalScalar
        computeCDF(Dirac self, NumericalSample sample, OT::Bool const tail) -> NumericalSample
        computeCDF(Dirac self, NumericalSample sample) -> NumericalSample
        computeCDF(Dirac self, OT::NumericalScalar const xMin, OT::NumericalScalar const xMax, OT::UnsignedLong const pointNumber, 
            NumericalSample grid, OT::NumericalScalar const precision=OT::ResourceMap::GetAsNumericalScalar("DistributionImplementation-DefaultCDFEpsilon")) -> NumericalSample
        computeCDF(Dirac self, OT::NumericalScalar const xMin, OT::NumericalScalar const xMax, OT::UnsignedLong const pointNumber, 
            NumericalSample grid) -> NumericalSample
        computeCDF(Dirac self, NumericalPoint xMin, NumericalPoint xMax, Indices pointNumber, NumericalSample grid, 
            OT::NumericalScalar const precision=OT::ResourceMap::GetAsNumericalScalar("DistributionImplementation-DefaultCDFEpsilon")) -> NumericalSample
        computeCDF(Dirac self, NumericalPoint xMin, NumericalPoint xMax, Indices pointNumber, NumericalSample grid) -> NumericalSample
        computeCDF(Dirac self, NumericalPoint point) -> OT::NumericalScalar
        """
        return _dist_bundle1.Dirac_computeCDF(self, *args)

    def computeQuantile(self, *args):
        """
        computeQuantile(Dirac self, OT::NumericalScalar const prob, OT::Bool const tail=False) -> NumericalPoint
        computeQuantile(Dirac self, OT::NumericalScalar const prob) -> NumericalPoint
        """
        return _dist_bundle1.Dirac_computeQuantile(self, *args)

    def computePDFGradient(self, *args):
        """computePDFGradient(Dirac self, NumericalPoint point) -> NumericalPoint"""
        return _dist_bundle1.Dirac_computePDFGradient(self, *args)

    def computeCDFGradient(self, *args):
        """computeCDFGradient(Dirac self, NumericalPoint point) -> NumericalPoint"""
        return _dist_bundle1.Dirac_computeCDFGradient(self, *args)

    def computeCharacteristicFunction(self, *args):
        """computeCharacteristicFunction(Dirac self, OT::NumericalScalar const x) -> OT::NumericalComplex"""
        return _dist_bundle1.Dirac_computeCharacteristicFunction(self, *args)

    def computeLogCharacteristicFunction(self, *args):
        """computeLogCharacteristicFunction(Dirac self, OT::NumericalScalar const x) -> OT::NumericalComplex"""
        return _dist_bundle1.Dirac_computeLogCharacteristicFunction(self, *args)

    def computeGeneratingFunction(self, *args):
        """computeGeneratingFunction(Dirac self, OT::NumericalComplex const & z) -> OT::NumericalComplex"""
        return _dist_bundle1.Dirac_computeGeneratingFunction(self, *args)

    def computeLogGeneratingFunction(self, *args):
        """computeLogGeneratingFunction(Dirac self, OT::NumericalComplex const & z) -> OT::NumericalComplex"""
        return _dist_bundle1.Dirac_computeLogGeneratingFunction(self, *args)

    def getSupport(self, *args):
        """
        getSupport(Dirac self, Interval interval) -> NumericalSample
        getSupport(Dirac self) -> NumericalSample
        getSupport(Dirac self, Interval interval) -> NumericalSample
        """
        return _dist_bundle1.Dirac_getSupport(self, *args)

    def getStandardDeviation(self):
        """getStandardDeviation(Dirac self) -> NumericalPoint"""
        return _dist_bundle1.Dirac_getStandardDeviation(self)

    def getSkewness(self):
        """getSkewness(Dirac self) -> NumericalPoint"""
        return _dist_bundle1.Dirac_getSkewness(self)

    def getKurtosis(self):
        """getKurtosis(Dirac self) -> NumericalPoint"""
        return _dist_bundle1.Dirac_getKurtosis(self)

    def getStandardMoment(self, *args):
        """getStandardMoment(Dirac self, OT::UnsignedLong const n) -> NumericalPoint"""
        return _dist_bundle1.Dirac_getStandardMoment(self, *args)

    def getParametersCollection(self):
        """getParametersCollection(Dirac self) -> NumericalPointWithDescriptionCollection"""
        return _dist_bundle1.Dirac_getParametersCollection(self)

    def setParametersCollection(self, *args):
        """
        setParametersCollection(Dirac self, NumericalPointWithDescriptionCollection parametersCollection)
        setParametersCollection(Dirac self, NumericalPointCollection parametersCollection)
        setParametersCollection(Dirac self, NumericalPoint parameters)
        setParametersCollection(Dirac self, NumericalPointCollection parametersCollection)
        """
        return _dist_bundle1.Dirac_setParametersCollection(self, *args)

    def setPoint(self, *args):
        """setPoint(Dirac self, NumericalPoint point)"""
        return _dist_bundle1.Dirac_setPoint(self, *args)

    def getPoint(self):
        """getPoint(Dirac self) -> NumericalPoint"""
        return _dist_bundle1.Dirac_getPoint(self)

    def getMarginal(self, *args):
        """
        getMarginal(Dirac self, OT::UnsignedLong const i) -> DistributionImplementationPointer
        getMarginal(Dirac self, Indices indices) -> DistributionImplementationPointer
        """
        return _dist_bundle1.Dirac_getMarginal(self, *args)

    def __init__(self, *args): 
        """
        __init__(OT::Dirac self) -> Dirac
        __init__(OT::Dirac self, OT::NumericalScalar const p) -> Dirac
        __init__(OT::Dirac self, NumericalPoint point) -> Dirac
        __init__(OT::Dirac self, Dirac other) -> Dirac
        """
        this = _dist_bundle1.new_Dirac(*args)
        try: self.this.append(this)
        except: self.this = this
    __swig_destroy__ = _dist_bundle1.delete_Dirac
    __del__ = lambda self : None;
Dirac_swigregister = _dist_bundle1.Dirac_swigregister
Dirac_swigregister(Dirac)

def Dirac_GetClassName():
  """Dirac_GetClassName() -> OT::String"""
  return _dist_bundle1.Dirac_GetClassName()

class DiracFactory(openturns.model_copula.DistributionImplementationFactory):
    """Proxy of C++ OT::DiracFactory class"""
    __swig_setmethods__ = {}
    for _s in [openturns.model_copula.DistributionImplementationFactory]: __swig_setmethods__.update(getattr(_s,'__swig_setmethods__',{}))
    __setattr__ = lambda self, name, value: _swig_setattr(self, DiracFactory, name, value)
    __swig_getmethods__ = {}
    for _s in [openturns.model_copula.DistributionImplementationFactory]: __swig_getmethods__.update(getattr(_s,'__swig_getmethods__',{}))
    __getattr__ = lambda self, name: _swig_getattr(self, DiracFactory, name)
    __repr__ = _swig_repr
    def GetClassName():
        """GetClassName() -> OT::String"""
        return _dist_bundle1.DiracFactory_GetClassName()

    if _newclass:GetClassName = staticmethod(GetClassName)
    __swig_getmethods__["GetClassName"] = lambda x: GetClassName
    def getClassName(self):
        """getClassName(DiracFactory self) -> OT::String"""
        return _dist_bundle1.DiracFactory_getClassName(self)

    def build(self, *args):
        """
        build(DiracFactory self, NumericalSample sample) -> DistributionImplementationPointer
        build(DiracFactory self, NumericalSample sample, CovarianceMatrix covariance) -> DistributionImplementationPointer
        build(DiracFactory self, NumericalPointCollection parameters) -> DistributionImplementationPointer
        build(DiracFactory self, NumericalPointWithDescriptionCollection parameters) -> DistributionImplementationPointer
        build(DiracFactory self, NumericalSample sample) -> DistributionImplementationPointer
        build(DiracFactory self, NumericalPointCollection parameters) -> DistributionImplementationPointer
        build(DiracFactory self) -> DistributionImplementationPointer
        """
        return _dist_bundle1.DiracFactory_build(self, *args)

    def buildAsDirac(self, *args):
        """
        buildAsDirac(DiracFactory self, NumericalSample sample) -> Dirac
        buildAsDirac(DiracFactory self, NumericalPointCollection parameters) -> Dirac
        buildAsDirac(DiracFactory self, NumericalPointWithDescriptionCollection parameters) -> Dirac
        buildAsDirac(DiracFactory self) -> Dirac
        """
        return _dist_bundle1.DiracFactory_buildAsDirac(self, *args)

    def __init__(self, *args): 
        """
        __init__(OT::DiracFactory self) -> DiracFactory
        __init__(OT::DiracFactory self, DiracFactory other) -> DiracFactory
        """
        this = _dist_bundle1.new_DiracFactory(*args)
        try: self.this.append(this)
        except: self.this = this
    __swig_destroy__ = _dist_bundle1.delete_DiracFactory
    __del__ = lambda self : None;
DiracFactory_swigregister = _dist_bundle1.DiracFactory_swigregister
DiracFactory_swigregister(DiracFactory)

def DiracFactory_GetClassName():
  """DiracFactory_GetClassName() -> OT::String"""
  return _dist_bundle1.DiracFactory_GetClassName()

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

    if _newclass:GetClassName = staticmethod(GetClassName)
    __swig_getmethods__["GetClassName"] = lambda x: GetClassName
    def getClassName(self):
        """getClassName(Dirichlet self) -> OT::String"""
        return _dist_bundle1.Dirichlet_getClassName(self)

    def __eq__(self, *args):
        """__eq__(Dirichlet self, Dirichlet other) -> OT::Bool"""
        return _dist_bundle1.Dirichlet___eq__(self, *args)

    def __repr__(self):
        """__repr__(Dirichlet self) -> OT::String"""
        return _dist_bundle1.Dirichlet___repr__(self)

    def __str__(self, offset=""):
        """
        __str__(Dirichlet self, OT::String const & offset="") -> OT::String
        __str__(Dirichlet self) -> OT::String
        """
        return _dist_bundle1.Dirichlet___str__(self, offset)

    def getRealization(self):
        """getRealization(Dirichlet self) -> NumericalPoint"""
        return _dist_bundle1.Dirichlet_getRealization(self)

    def computePDF(self, *args):
        """
        computePDF(Dirichlet self, OT::NumericalScalar const scalar) -> OT::NumericalScalar
        computePDF(Dirichlet self, NumericalPoint point) -> OT::NumericalScalar
        computePDF(Dirichlet self, NumericalSample sample) -> NumericalSample
        computePDF(Dirichlet self, OT::NumericalScalar const xMin, OT::NumericalScalar const xMax, OT::UnsignedLong const pointNumber, 
            NumericalSample grid, OT::NumericalScalar const precision=OT::ResourceMap::GetAsNumericalScalar("DistributionImplementation-DefaultPDFEpsilon")) -> NumericalSample
        computePDF(Dirichlet self, OT::NumericalScalar const xMin, OT::NumericalScalar const xMax, OT::UnsignedLong const pointNumber, 
            NumericalSample grid) -> NumericalSample
        computePDF(Dirichlet self, NumericalPoint xMin, NumericalPoint xMax, Indices pointNumber, NumericalSample grid, 
            OT::NumericalScalar const precision=OT::ResourceMap::GetAsNumericalScalar("DistributionImplementation-DefaultPDFEpsilon")) -> NumericalSample
        computePDF(Dirichlet self, NumericalPoint xMin, NumericalPoint xMax, Indices pointNumber, NumericalSample grid) -> NumericalSample
        computePDF(Dirichlet self, NumericalPoint point) -> OT::NumericalScalar
        """
        return _dist_bundle1.Dirichlet_computePDF(self, *args)

    def computeLogPDF(self, *args):
        """
        computeLogPDF(Dirichlet self, OT::NumericalScalar const scalar) -> OT::NumericalScalar
        computeLogPDF(Dirichlet self, NumericalPoint point) -> OT::NumericalScalar
        computeLogPDF(Dirichlet self, NumericalSample sample) -> NumericalSample
        computeLogPDF(Dirichlet self, NumericalPoint point) -> OT::NumericalScalar
        """
        return _dist_bundle1.Dirichlet_computeLogPDF(self, *args)

    def computeCDF(self, *args):
        """
        computeCDF(Dirichlet self, OT::NumericalScalar const scalar, OT::Bool const tail) -> OT::NumericalScalar
        computeCDF(Dirichlet self, OT::NumericalScalar const scalar) -> OT::NumericalScalar
        computeCDF(Dirichlet self, NumericalPoint point, OT::Bool const tail) -> OT::NumericalScalar
        computeCDF(Dirichlet self, NumericalPoint point) -> OT::NumericalScalar
        computeCDF(Dirichlet self, NumericalSample sample, OT::Bool const tail) -> NumericalSample
        computeCDF(Dirichlet self, NumericalSample sample) -> NumericalSample
        computeCDF(Dirichlet self, OT::NumericalScalar const xMin, OT::NumericalScalar const xMax, OT::UnsignedLong const pointNumber, 
            NumericalSample grid, OT::NumericalScalar const precision=OT::ResourceMap::GetAsNumericalScalar("DistributionImplementation-DefaultCDFEpsilon")) -> NumericalSample
        computeCDF(Dirichlet self, OT::NumericalScalar const xMin, OT::NumericalScalar const xMax, OT::UnsignedLong const pointNumber, 
            NumericalSample grid) -> NumericalSample
        computeCDF(Dirichlet self, NumericalPoint xMin, NumericalPoint xMax, Indices pointNumber, NumericalSample grid, 
            OT::NumericalScalar const precision=OT::ResourceMap::GetAsNumericalScalar("DistributionImplementation-DefaultCDFEpsilon")) -> NumericalSample
        computeCDF(Dirichlet self, NumericalPoint xMin, NumericalPoint xMax, Indices pointNumber, NumericalSample grid) -> NumericalSample
        computeCDF(Dirichlet self, NumericalPoint point) -> OT::NumericalScalar
        """
        return _dist_bundle1.Dirichlet_computeCDF(self, *args)

    def computeComplementaryCDF(self, *args):
        """
        computeComplementaryCDF(Dirichlet self, OT::NumericalScalar const scalar) -> OT::NumericalScalar
        computeComplementaryCDF(Dirichlet self, NumericalPoint point) -> OT::NumericalScalar
        computeComplementaryCDF(Dirichlet self, NumericalSample sample) -> NumericalSample
        computeComplementaryCDF(Dirichlet self, OT::NumericalScalar const xMin, OT::NumericalScalar const xMax, OT::UnsignedLong const pointNumber, 
            NumericalSample grid, OT::NumericalScalar const precision=OT::ResourceMap::GetAsNumericalScalar("DistributionImplementation-DefaultCDFEpsilon")) -> NumericalSample
        computeComplementaryCDF(Dirichlet self, OT::NumericalScalar const xMin, OT::NumericalScalar const xMax, OT::UnsignedLong const pointNumber, 
            NumericalSample grid) -> NumericalSample
        computeComplementaryCDF(Dirichlet self, NumericalPoint point) -> OT::NumericalScalar
        """
        return _dist_bundle1.Dirichlet_computeComplementaryCDF(self, *args)

    def getStandardDeviation(self):
        """getStandardDeviation(Dirichlet self) -> NumericalPoint"""
        return _dist_bundle1.Dirichlet_getStandardDeviation(self)

    def getSkewness(self):
        """getSkewness(Dirichlet self) -> NumericalPoint"""
        return _dist_bundle1.Dirichlet_getSkewness(self)

    def getKurtosis(self):
        """getKurtosis(Dirichlet self) -> NumericalPoint"""
        return _dist_bundle1.Dirichlet_getKurtosis(self)

    def getParametersCollection(self):
        """getParametersCollection(Dirichlet self) -> NumericalPointWithDescriptionCollection"""
        return _dist_bundle1.Dirichlet_getParametersCollection(self)

    def setParametersCollection(self, *args):
        """
        setParametersCollection(Dirichlet self, NumericalPointWithDescriptionCollection parametersCollection)
        setParametersCollection(Dirichlet self, NumericalPointCollection parametersCollection)
        setParametersCollection(Dirichlet self, NumericalPoint parameters)
        setParametersCollection(Dirichlet self, NumericalPointCollection parametersCollection)
        """
        return _dist_bundle1.Dirichlet_setParametersCollection(self, *args)

    def setTheta(self, *args):
        """setTheta(Dirichlet self, NumericalPoint theta)"""
        return _dist_bundle1.Dirichlet_setTheta(self, *args)

    def getTheta(self):
        """getTheta(Dirichlet self) -> NumericalPoint"""
        return _dist_bundle1.Dirichlet_getTheta(self)

    def computeConditionalPDF(self, *args):
        """computeConditionalPDF(Dirichlet self, OT::NumericalScalar const x, NumericalPoint y) -> OT::NumericalScalar"""
        return _dist_bundle1.Dirichlet_computeConditionalPDF(self, *args)

    def computeConditionalCDF(self, *args):
        """computeConditionalCDF(Dirichlet self, OT::NumericalScalar const x, NumericalPoint y) -> OT::NumericalScalar"""
        return _dist_bundle1.Dirichlet_computeConditionalCDF(self, *args)

    def computeConditionalQuantile(self, *args):
        """computeConditionalQuantile(Dirichlet self, OT::NumericalScalar const q, NumericalPoint y) -> OT::NumericalScalar"""
        return _dist_bundle1.Dirichlet_computeConditionalQuantile(self, *args)

    def getMarginal(self, *args):
        """
        getMarginal(Dirichlet self, OT::UnsignedLong const i) -> DistributionImplementationPointer
        getMarginal(Dirichlet self, Indices indices) -> DistributionImplementationPointer
        """
        return _dist_bundle1.Dirichlet_getMarginal(self, *args)

    def __init__(self, *args): 
        """
        __init__(OT::Dirichlet self) -> Dirichlet
        __init__(OT::Dirichlet self, NumericalPoint theta) -> Dirichlet
        __init__(OT::Dirichlet self, Dirichlet other) -> Dirichlet
        """
        this = _dist_bundle1.new_Dirichlet(*args)
        try: self.this.append(this)
        except: self.this = this
    __swig_destroy__ = _dist_bundle1.delete_Dirichlet
    __del__ = lambda self : None;
Dirichlet_swigregister = _dist_bundle1.Dirichlet_swigregister
Dirichlet_swigregister(Dirichlet)

def Dirichlet_GetClassName():
  """Dirichlet_GetClassName() -> OT::String"""
  return _dist_bundle1.Dirichlet_GetClassName()

class DirichletFactory(openturns.model_copula.DistributionImplementationFactory):
    """Proxy of C++ OT::DirichletFactory class"""
    __swig_setmethods__ = {}
    for _s in [openturns.model_copula.DistributionImplementationFactory]: __swig_setmethods__.update(getattr(_s,'__swig_setmethods__',{}))
    __setattr__ = lambda self, name, value: _swig_setattr(self, DirichletFactory, name, value)
    __swig_getmethods__ = {}
    for _s in [openturns.model_copula.DistributionImplementationFactory]: __swig_getmethods__.update(getattr(_s,'__swig_getmethods__',{}))
    __getattr__ = lambda self, name: _swig_getattr(self, DirichletFactory, name)
    __repr__ = _swig_repr
    def GetClassName():
        """GetClassName() -> OT::String"""
        return _dist_bundle1.DirichletFactory_GetClassName()

    if _newclass:GetClassName = staticmethod(GetClassName)
    __swig_getmethods__["GetClassName"] = lambda x: GetClassName
    def getClassName(self):
        """getClassName(DirichletFactory self) -> OT::String"""
        return _dist_bundle1.DirichletFactory_getClassName(self)

    def build(self, *args):
        """
        build(DirichletFactory self, NumericalSample sample) -> DistributionImplementationPointer
        build(DirichletFactory self, NumericalSample sample, CovarianceMatrix covariance) -> DistributionImplementationPointer
        build(DirichletFactory self, NumericalPointCollection parameters) -> DistributionImplementationPointer
        build(DirichletFactory self, NumericalPointWithDescriptionCollection parameters) -> DistributionImplementationPointer
        build(DirichletFactory self, NumericalSample sample) -> DistributionImplementationPointer
        build(DirichletFactory self, NumericalPointCollection parameters) -> DistributionImplementationPointer
        build(DirichletFactory self) -> DistributionImplementationPointer
        """
        return _dist_bundle1.DirichletFactory_build(self, *args)

    def buildAsDirichlet(self, *args):
        """
        buildAsDirichlet(DirichletFactory self, NumericalSample sample) -> Dirichlet
        buildAsDirichlet(DirichletFactory self, NumericalPointCollection parameters) -> Dirichlet
        buildAsDirichlet(DirichletFactory self, NumericalPointWithDescriptionCollection parameters) -> Dirichlet
        buildAsDirichlet(DirichletFactory self) -> Dirichlet
        """
        return _dist_bundle1.DirichletFactory_buildAsDirichlet(self, *args)

    def __init__(self, *args): 
        """
        __init__(OT::DirichletFactory self) -> DirichletFactory
        __init__(OT::DirichletFactory self, DirichletFactory other) -> DirichletFactory
        """
        this = _dist_bundle1.new_DirichletFactory(*args)
        try: self.this.append(this)
        except: self.this = this
    __swig_destroy__ = _dist_bundle1.delete_DirichletFactory
    __del__ = lambda self : None;
DirichletFactory_swigregister = _dist_bundle1.DirichletFactory_swigregister
DirichletFactory_swigregister(DirichletFactory)

def DirichletFactory_GetClassName():
  """DirichletFactory_GetClassName() -> OT::String"""
  return _dist_bundle1.DirichletFactory_GetClassName()

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

    if _newclass:GetClassName = staticmethod(GetClassName)
    __swig_getmethods__["GetClassName"] = lambda x: GetClassName
    def getClassName(self):
        """getClassName(Epanechnikov self) -> OT::String"""
        return _dist_bundle1.Epanechnikov_getClassName(self)

    RT = _dist_bundle1.Epanechnikov_RT
    MUSIGMA = _dist_bundle1.Epanechnikov_MUSIGMA
    def __eq__(self, *args):
        """__eq__(Epanechnikov self, Epanechnikov other) -> OT::Bool"""
        return _dist_bundle1.Epanechnikov___eq__(self, *args)

    def __repr__(self):
        """__repr__(Epanechnikov self) -> OT::String"""
        return _dist_bundle1.Epanechnikov___repr__(self)

    def __str__(self, offset=""):
        """
        __str__(Epanechnikov self, OT::String const & offset="") -> OT::String
        __str__(Epanechnikov self) -> OT::String
        """
        return _dist_bundle1.Epanechnikov___str__(self, offset)

    def computeDDF(self, *args):
        """
        computeDDF(Epanechnikov self, OT::NumericalScalar const scalar) -> OT::NumericalScalar
        computeDDF(Epanechnikov self, NumericalPoint point) -> NumericalPoint
        computeDDF(Epanechnikov self, NumericalSample sample) -> NumericalSample
        computeDDF(Epanechnikov self, NumericalPoint point) -> NumericalPoint
        """
        return _dist_bundle1.Epanechnikov_computeDDF(self, *args)

    def computePDF(self, *args):
        """
        computePDF(Epanechnikov self, OT::NumericalScalar const scalar) -> OT::NumericalScalar
        computePDF(Epanechnikov self, NumericalPoint point) -> OT::NumericalScalar
        computePDF(Epanechnikov self, NumericalSample sample) -> NumericalSample
        computePDF(Epanechnikov self, OT::NumericalScalar const xMin, OT::NumericalScalar const xMax, OT::UnsignedLong const pointNumber, 
            NumericalSample grid, OT::NumericalScalar const precision=OT::ResourceMap::GetAsNumericalScalar("DistributionImplementation-DefaultPDFEpsilon")) -> NumericalSample
        computePDF(Epanechnikov self, OT::NumericalScalar const xMin, OT::NumericalScalar const xMax, OT::UnsignedLong const pointNumber, 
            NumericalSample grid) -> NumericalSample
        computePDF(Epanechnikov self, NumericalPoint xMin, NumericalPoint xMax, Indices pointNumber, NumericalSample grid, 
            OT::NumericalScalar const precision=OT::ResourceMap::GetAsNumericalScalar("DistributionImplementation-DefaultPDFEpsilon")) -> NumericalSample
        computePDF(Epanechnikov self, NumericalPoint xMin, NumericalPoint xMax, Indices pointNumber, NumericalSample grid) -> NumericalSample
        computePDF(Epanechnikov self, NumericalPoint point) -> OT::NumericalScalar
        """
        return _dist_bundle1.Epanechnikov_computePDF(self, *args)

    def computeCDF(self, *args):
        """
        computeCDF(Epanechnikov self, OT::NumericalScalar const scalar, OT::Bool const tail) -> OT::NumericalScalar
        computeCDF(Epanechnikov self, OT::NumericalScalar const scalar) -> OT::NumericalScalar
        computeCDF(Epanechnikov self, NumericalPoint point, OT::Bool const tail) -> OT::NumericalScalar
        computeCDF(Epanechnikov self, NumericalPoint point) -> OT::NumericalScalar
        computeCDF(Epanechnikov self, NumericalSample sample, OT::Bool const tail) -> NumericalSample
        computeCDF(Epanechnikov self, NumericalSample sample) -> NumericalSample
        computeCDF(Epanechnikov self, OT::NumericalScalar const xMin, OT::NumericalScalar const xMax, OT::UnsignedLong const pointNumber, 
            NumericalSample grid, OT::NumericalScalar const precision=OT::ResourceMap::GetAsNumericalScalar("DistributionImplementation-DefaultCDFEpsilon")) -> NumericalSample
        computeCDF(Epanechnikov self, OT::NumericalScalar const xMin, OT::NumericalScalar const xMax, OT::UnsignedLong const pointNumber, 
            NumericalSample grid) -> NumericalSample
        computeCDF(Epanechnikov self, NumericalPoint xMin, NumericalPoint xMax, Indices pointNumber, NumericalSample grid, 
            OT::NumericalScalar const precision=OT::ResourceMap::GetAsNumericalScalar("DistributionImplementation-DefaultCDFEpsilon")) -> NumericalSample
        computeCDF(Epanechnikov self, NumericalPoint xMin, NumericalPoint xMax, Indices pointNumber, NumericalSample grid) -> NumericalSample
        computeCDF(Epanechnikov self, NumericalPoint point) -> OT::NumericalScalar
        """
        return _dist_bundle1.Epanechnikov_computeCDF(self, *args)

    def computeComplementaryCDF(self, *args):
        """
        computeComplementaryCDF(Epanechnikov self, OT::NumericalScalar const scalar) -> OT::NumericalScalar
        computeComplementaryCDF(Epanechnikov self, NumericalPoint point) -> OT::NumericalScalar
        computeComplementaryCDF(Epanechnikov self, NumericalSample sample) -> NumericalSample
        computeComplementaryCDF(Epanechnikov self, OT::NumericalScalar const xMin, OT::NumericalScalar const xMax, OT::UnsignedLong const pointNumber, 
            NumericalSample grid, OT::NumericalScalar const precision=OT::ResourceMap::GetAsNumericalScalar("DistributionImplementation-DefaultCDFEpsilon")) -> NumericalSample
        computeComplementaryCDF(Epanechnikov self, OT::NumericalScalar const xMin, OT::NumericalScalar const xMax, OT::UnsignedLong const pointNumber, 
            NumericalSample grid) -> NumericalSample
        computeComplementaryCDF(Epanechnikov self, NumericalPoint point) -> OT::NumericalScalar
        """
        return _dist_bundle1.Epanechnikov_computeComplementaryCDF(self, *args)

    def computePDFGradient(self, *args):
        """computePDFGradient(Epanechnikov self, NumericalPoint point) -> NumericalPoint"""
        return _dist_bundle1.Epanechnikov_computePDFGradient(self, *args)

    def computeCDFGradient(self, *args):
        """computeCDFGradient(Epanechnikov self, NumericalPoint point) -> NumericalPoint"""
        return _dist_bundle1.Epanechnikov_computeCDFGradient(self, *args)

    def getRoughness(self):
        """getRoughness(Epanechnikov self) -> OT::NumericalScalar"""
        return _dist_bundle1.Epanechnikov_getRoughness(self)

    def getStandardDeviation(self):
        """getStandardDeviation(Epanechnikov self) -> NumericalPoint"""
        return _dist_bundle1.Epanechnikov_getStandardDeviation(self)

    def getSkewness(self):
        """getSkewness(Epanechnikov self) -> NumericalPoint"""
        return _dist_bundle1.Epanechnikov_getSkewness(self)

    def getKurtosis(self):
        """getKurtosis(Epanechnikov self) -> NumericalPoint"""
        return _dist_bundle1.Epanechnikov_getKurtosis(self)

    def getStandardMoment(self, *args):
        """getStandardMoment(Epanechnikov self, OT::UnsignedLong const n) -> NumericalPoint"""
        return _dist_bundle1.Epanechnikov_getStandardMoment(self, *args)

    def getParametersCollection(self):
        """getParametersCollection(Epanechnikov self) -> NumericalPointWithDescriptionCollection"""
        return _dist_bundle1.Epanechnikov_getParametersCollection(self)

    def __init__(self, *args): 
        """
        __init__(OT::Epanechnikov self) -> Epanechnikov
        __init__(OT::Epanechnikov self, Epanechnikov other) -> Epanechnikov
        """
        this = _dist_bundle1.new_Epanechnikov(*args)
        try: self.this.append(this)
        except: self.this = this
    __swig_destroy__ = _dist_bundle1.delete_Epanechnikov
    __del__ = lambda self : None;
Epanechnikov_swigregister = _dist_bundle1.Epanechnikov_swigregister
Epanechnikov_swigregister(Epanechnikov)

def Epanechnikov_GetClassName():
  """Epanechnikov_GetClassName() -> OT::String"""
  return _dist_bundle1.Epanechnikov_GetClassName()

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

    if _newclass:GetClassName = staticmethod(GetClassName)
    __swig_getmethods__["GetClassName"] = lambda x: GetClassName
    def getClassName(self):
        """getClassName(Exponential self) -> OT::String"""
        return _dist_bundle1.Exponential_getClassName(self)

    def __eq__(self, *args):
        """__eq__(Exponential self, Exponential other) -> OT::Bool"""
        return _dist_bundle1.Exponential___eq__(self, *args)

    def __repr__(self):
        """__repr__(Exponential self) -> OT::String"""
        return _dist_bundle1.Exponential___repr__(self)

    def __str__(self, offset=""):
        """
        __str__(Exponential self, OT::String const & offset="") -> OT::String
        __str__(Exponential self) -> OT::String
        """
        return _dist_bundle1.Exponential___str__(self, offset)

    def getRealization(self):
        """getRealization(Exponential self) -> NumericalPoint"""
        return _dist_bundle1.Exponential_getRealization(self)

    def computeDDF(self, *args):
        """
        computeDDF(Exponential self, OT::NumericalScalar const scalar) -> OT::NumericalScalar
        computeDDF(Exponential self, NumericalPoint point) -> NumericalPoint
        computeDDF(Exponential self, NumericalSample sample) -> NumericalSample
        computeDDF(Exponential self, NumericalPoint point) -> NumericalPoint
        """
        return _dist_bundle1.Exponential_computeDDF(self, *args)

    def computePDF(self, *args):
        """
        computePDF(Exponential self, OT::NumericalScalar const scalar) -> OT::NumericalScalar
        computePDF(Exponential self, NumericalPoint point) -> OT::NumericalScalar
        computePDF(Exponential self, NumericalSample sample) -> NumericalSample
        computePDF(Exponential self, OT::NumericalScalar const xMin, OT::NumericalScalar const xMax, OT::UnsignedLong const pointNumber, 
            NumericalSample grid, OT::NumericalScalar const precision=OT::ResourceMap::GetAsNumericalScalar("DistributionImplementation-DefaultPDFEpsilon")) -> NumericalSample
        computePDF(Exponential self, OT::NumericalScalar const xMin, OT::NumericalScalar const xMax, OT::UnsignedLong const pointNumber, 
            NumericalSample grid) -> NumericalSample
        computePDF(Exponential self, NumericalPoint xMin, NumericalPoint xMax, Indices pointNumber, NumericalSample grid, 
            OT::NumericalScalar const precision=OT::ResourceMap::GetAsNumericalScalar("DistributionImplementation-DefaultPDFEpsilon")) -> NumericalSample
        computePDF(Exponential self, NumericalPoint xMin, NumericalPoint xMax, Indices pointNumber, NumericalSample grid) -> NumericalSample
        computePDF(Exponential self, NumericalPoint point) -> OT::NumericalScalar
        """
        return _dist_bundle1.Exponential_computePDF(self, *args)

    def computeLogPDF(self, *args):
        """
        computeLogPDF(Exponential self, OT::NumericalScalar const scalar) -> OT::NumericalScalar
        computeLogPDF(Exponential self, NumericalPoint point) -> OT::NumericalScalar
        computeLogPDF(Exponential self, NumericalSample sample) -> NumericalSample
        computeLogPDF(Exponential self, NumericalPoint point) -> OT::NumericalScalar
        """
        return _dist_bundle1.Exponential_computeLogPDF(self, *args)

    def computeCDF(self, *args):
        """
        computeCDF(Exponential self, OT::NumericalScalar const scalar, OT::Bool const tail) -> OT::NumericalScalar
        computeCDF(Exponential self, OT::NumericalScalar const scalar) -> OT::NumericalScalar
        computeCDF(Exponential self, NumericalPoint point, OT::Bool const tail) -> OT::NumericalScalar
        computeCDF(Exponential self, NumericalPoint point) -> OT::NumericalScalar
        computeCDF(Exponential self, NumericalSample sample, OT::Bool const tail) -> NumericalSample
        computeCDF(Exponential self, NumericalSample sample) -> NumericalSample
        computeCDF(Exponential self, OT::NumericalScalar const xMin, OT::NumericalScalar const xMax, OT::UnsignedLong const pointNumber, 
            NumericalSample grid, OT::NumericalScalar const precision=OT::ResourceMap::GetAsNumericalScalar("DistributionImplementation-DefaultCDFEpsilon")) -> NumericalSample
        computeCDF(Exponential self, OT::NumericalScalar const xMin, OT::NumericalScalar const xMax, OT::UnsignedLong const pointNumber, 
            NumericalSample grid) -> NumericalSample
        computeCDF(Exponential self, NumericalPoint xMin, NumericalPoint xMax, Indices pointNumber, NumericalSample grid, 
            OT::NumericalScalar const precision=OT::ResourceMap::GetAsNumericalScalar("DistributionImplementation-DefaultCDFEpsilon")) -> NumericalSample
        computeCDF(Exponential self, NumericalPoint xMin, NumericalPoint xMax, Indices pointNumber, NumericalSample grid) -> NumericalSample
        computeCDF(Exponential self, NumericalPoint point) -> OT::NumericalScalar
        """
        return _dist_bundle1.Exponential_computeCDF(self, *args)

    def computeCharacteristicFunction(self, *args):
        """computeCharacteristicFunction(Exponential self, OT::NumericalScalar const x) -> OT::NumericalComplex"""
        return _dist_bundle1.Exponential_computeCharacteristicFunction(self, *args)

    def computeLogCharacteristicFunction(self, *args):
        """computeLogCharacteristicFunction(Exponential self, OT::NumericalScalar const x) -> OT::NumericalComplex"""
        return _dist_bundle1.Exponential_computeLogCharacteristicFunction(self, *args)

    def computePDFGradient(self, *args):
        """computePDFGradient(Exponential self, NumericalPoint point) -> NumericalPoint"""
        return _dist_bundle1.Exponential_computePDFGradient(self, *args)

    def computeCDFGradient(self, *args):
        """computeCDFGradient(Exponential self, NumericalPoint point) -> NumericalPoint"""
        return _dist_bundle1.Exponential_computeCDFGradient(self, *args)

    def getStandardDeviation(self):
        """getStandardDeviation(Exponential self) -> NumericalPoint"""
        return _dist_bundle1.Exponential_getStandardDeviation(self)

    def getSkewness(self):
        """getSkewness(Exponential self) -> NumericalPoint"""
        return _dist_bundle1.Exponential_getSkewness(self)

    def getKurtosis(self):
        """getKurtosis(Exponential self) -> NumericalPoint"""
        return _dist_bundle1.Exponential_getKurtosis(self)

    def getStandardMoment(self, *args):
        """getStandardMoment(Exponential self, OT::UnsignedLong const n) -> NumericalPoint"""
        return _dist_bundle1.Exponential_getStandardMoment(self, *args)

    def getStandardRepresentative(self):
        """getStandardRepresentative(Exponential self) -> DistributionImplementationPointer"""
        return _dist_bundle1.Exponential_getStandardRepresentative(self)

    def getParametersCollection(self):
        """getParametersCollection(Exponential self) -> NumericalPointWithDescriptionCollection"""
        return _dist_bundle1.Exponential_getParametersCollection(self)

    def setParametersCollection(self, *args):
        """
        setParametersCollection(Exponential self, NumericalPointWithDescriptionCollection parametersCollection)
        setParametersCollection(Exponential self, NumericalPointCollection parametersCollection)
        setParametersCollection(Exponential self, NumericalPoint parameters)
        setParametersCollection(Exponential self, NumericalPointCollection parametersCollection)
        """
        return _dist_bundle1.Exponential_setParametersCollection(self, *args)

    def setLambda(self, *args):
        """setLambda(Exponential self, OT::NumericalScalar const _lambda)"""
        return _dist_bundle1.Exponential_setLambda(self, *args)

    def getLambda(self):
        """getLambda(Exponential self) -> OT::NumericalScalar"""
        return _dist_bundle1.Exponential_getLambda(self)

    def setGamma(self, *args):
        """setGamma(Exponential self, OT::NumericalScalar const gamma)"""
        return _dist_bundle1.Exponential_setGamma(self, *args)

    def getGamma(self):
        """getGamma(Exponential self) -> OT::NumericalScalar"""
        return _dist_bundle1.Exponential_getGamma(self)

    def __init__(self, *args): 
        """
        __init__(OT::Exponential self) -> Exponential
        __init__(OT::Exponential self, OT::NumericalScalar const _lambda, OT::NumericalScalar const gamma=0.0) -> Exponential
        __init__(OT::Exponential self, OT::NumericalScalar const _lambda) -> Exponential
        __init__(OT::Exponential self, Exponential other) -> Exponential
        """
        this = _dist_bundle1.new_Exponential(*args)
        try: self.this.append(this)
        except: self.this = this
    __swig_destroy__ = _dist_bundle1.delete_Exponential
    __del__ = lambda self : None;
Exponential_swigregister = _dist_bundle1.Exponential_swigregister
Exponential_swigregister(Exponential)

def Exponential_GetClassName():
  """Exponential_GetClassName() -> OT::String"""
  return _dist_bundle1.Exponential_GetClassName()

class ExponentialFactory(openturns.model_copula.DistributionImplementationFactory):
    """Proxy of C++ OT::ExponentialFactory class"""
    __swig_setmethods__ = {}
    for _s in [openturns.model_copula.DistributionImplementationFactory]: __swig_setmethods__.update(getattr(_s,'__swig_setmethods__',{}))
    __setattr__ = lambda self, name, value: _swig_setattr(self, ExponentialFactory, name, value)
    __swig_getmethods__ = {}
    for _s in [openturns.model_copula.DistributionImplementationFactory]: __swig_getmethods__.update(getattr(_s,'__swig_getmethods__',{}))
    __getattr__ = lambda self, name: _swig_getattr(self, ExponentialFactory, name)
    __repr__ = _swig_repr
    def GetClassName():
        """GetClassName() -> OT::String"""
        return _dist_bundle1.ExponentialFactory_GetClassName()

    if _newclass:GetClassName = staticmethod(GetClassName)
    __swig_getmethods__["GetClassName"] = lambda x: GetClassName
    def getClassName(self):
        """getClassName(ExponentialFactory self) -> OT::String"""
        return _dist_bundle1.ExponentialFactory_getClassName(self)

    def build(self, *args):
        """
        build(ExponentialFactory self, NumericalSample sample) -> DistributionImplementationPointer
        build(ExponentialFactory self, NumericalSample sample, CovarianceMatrix covariance) -> DistributionImplementationPointer
        build(ExponentialFactory self, NumericalPointCollection parameters) -> DistributionImplementationPointer
        build(ExponentialFactory self, NumericalPointWithDescriptionCollection parameters) -> DistributionImplementationPointer
        build(ExponentialFactory self, NumericalSample sample) -> DistributionImplementationPointer
        build(ExponentialFactory self, NumericalPointCollection parameters) -> DistributionImplementationPointer
        build(ExponentialFactory self) -> DistributionImplementationPointer
        """
        return _dist_bundle1.ExponentialFactory_build(self, *args)

    def buildAsExponential(self, *args):
        """
        buildAsExponential(ExponentialFactory self, NumericalSample sample) -> Exponential
        buildAsExponential(ExponentialFactory self, NumericalPointCollection parameters) -> Exponential
        buildAsExponential(ExponentialFactory self, NumericalPointWithDescriptionCollection parameters) -> Exponential
        buildAsExponential(ExponentialFactory self) -> Exponential
        """
        return _dist_bundle1.ExponentialFactory_buildAsExponential(self, *args)

    def __init__(self, *args): 
        """
        __init__(OT::ExponentialFactory self) -> ExponentialFactory
        __init__(OT::ExponentialFactory self, ExponentialFactory other) -> ExponentialFactory
        """
        this = _dist_bundle1.new_ExponentialFactory(*args)
        try: self.this.append(this)
        except: self.this = this
    __swig_destroy__ = _dist_bundle1.delete_ExponentialFactory
    __del__ = lambda self : None;
ExponentialFactory_swigregister = _dist_bundle1.ExponentialFactory_swigregister
ExponentialFactory_swigregister(ExponentialFactory)

def ExponentialFactory_GetClassName():
  """ExponentialFactory_GetClassName() -> OT::String"""
  return _dist_bundle1.ExponentialFactory_GetClassName()

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

    if _newclass:GetClassName = staticmethod(GetClassName)
    __swig_getmethods__["GetClassName"] = lambda x: GetClassName
    def getClassName(self):
        """getClassName(FisherSnedecor self) -> OT::String"""
        return _dist_bundle1.FisherSnedecor_getClassName(self)

    def __eq__(self, *args):
        """__eq__(FisherSnedecor self, FisherSnedecor other) -> OT::Bool"""
        return _dist_bundle1.FisherSnedecor___eq__(self, *args)

    def __repr__(self):
        """__repr__(FisherSnedecor self) -> OT::String"""
        return _dist_bundle1.FisherSnedecor___repr__(self)

    def __str__(self, offset=""):
        """
        __str__(FisherSnedecor self, OT::String const & offset="") -> OT::String
        __str__(FisherSnedecor self) -> OT::String
        """
        return _dist_bundle1.FisherSnedecor___str__(self, offset)

    def getRealization(self):
        """getRealization(FisherSnedecor self) -> NumericalPoint"""
        return _dist_bundle1.FisherSnedecor_getRealization(self)

    def computePDF(self, *args):
        """
        computePDF(FisherSnedecor self, OT::NumericalScalar const scalar) -> OT::NumericalScalar
        computePDF(FisherSnedecor self, NumericalPoint point) -> OT::NumericalScalar
        computePDF(FisherSnedecor self, NumericalSample sample) -> NumericalSample
        computePDF(FisherSnedecor self, OT::NumericalScalar const xMin, OT::NumericalScalar const xMax, OT::UnsignedLong const pointNumber, 
            NumericalSample grid, OT::NumericalScalar const precision=OT::ResourceMap::GetAsNumericalScalar("DistributionImplementation-DefaultPDFEpsilon")) -> NumericalSample
        computePDF(FisherSnedecor self, OT::NumericalScalar const xMin, OT::NumericalScalar const xMax, OT::UnsignedLong const pointNumber, 
            NumericalSample grid) -> NumericalSample
        computePDF(FisherSnedecor self, NumericalPoint xMin, NumericalPoint xMax, Indices pointNumber, NumericalSample grid, 
            OT::NumericalScalar const precision=OT::ResourceMap::GetAsNumericalScalar("DistributionImplementation-DefaultPDFEpsilon")) -> NumericalSample
        computePDF(FisherSnedecor self, NumericalPoint xMin, NumericalPoint xMax, Indices pointNumber, NumericalSample grid) -> NumericalSample
        computePDF(FisherSnedecor self, NumericalPoint point) -> OT::NumericalScalar
        """
        return _dist_bundle1.FisherSnedecor_computePDF(self, *args)

    def computeLogPDF(self, *args):
        """
        computeLogPDF(FisherSnedecor self, OT::NumericalScalar const scalar) -> OT::NumericalScalar
        computeLogPDF(FisherSnedecor self, NumericalPoint point) -> OT::NumericalScalar
        computeLogPDF(FisherSnedecor self, NumericalSample sample) -> NumericalSample
        computeLogPDF(FisherSnedecor self, NumericalPoint point) -> OT::NumericalScalar
        """
        return _dist_bundle1.FisherSnedecor_computeLogPDF(self, *args)

    def computeCDF(self, *args):
        """
        computeCDF(FisherSnedecor self, OT::NumericalScalar const scalar, OT::Bool const tail) -> OT::NumericalScalar
        computeCDF(FisherSnedecor self, OT::NumericalScalar const scalar) -> OT::NumericalScalar
        computeCDF(FisherSnedecor self, NumericalPoint point, OT::Bool const tail) -> OT::NumericalScalar
        computeCDF(FisherSnedecor self, NumericalPoint point) -> OT::NumericalScalar
        computeCDF(FisherSnedecor self, NumericalSample sample, OT::Bool const tail) -> NumericalSample
        computeCDF(FisherSnedecor self, NumericalSample sample) -> NumericalSample
        computeCDF(FisherSnedecor self, OT::NumericalScalar const xMin, OT::NumericalScalar const xMax, OT::UnsignedLong const pointNumber, 
            NumericalSample grid, OT::NumericalScalar const precision=OT::ResourceMap::GetAsNumericalScalar("DistributionImplementation-DefaultCDFEpsilon")) -> NumericalSample
        computeCDF(FisherSnedecor self, OT::NumericalScalar const xMin, OT::NumericalScalar const xMax, OT::UnsignedLong const pointNumber, 
            NumericalSample grid) -> NumericalSample
        computeCDF(FisherSnedecor self, NumericalPoint xMin, NumericalPoint xMax, Indices pointNumber, NumericalSample grid, 
            OT::NumericalScalar const precision=OT::ResourceMap::GetAsNumericalScalar("DistributionImplementation-DefaultCDFEpsilon")) -> NumericalSample
        computeCDF(FisherSnedecor self, NumericalPoint xMin, NumericalPoint xMax, Indices pointNumber, NumericalSample grid) -> NumericalSample
        computeCDF(FisherSnedecor self, NumericalPoint point) -> OT::NumericalScalar
        """
        return _dist_bundle1.FisherSnedecor_computeCDF(self, *args)

    def getStandardDeviation(self):
        """getStandardDeviation(FisherSnedecor self) -> NumericalPoint"""
        return _dist_bundle1.FisherSnedecor_getStandardDeviation(self)

    def getSkewness(self):
        """getSkewness(FisherSnedecor self) -> NumericalPoint"""
        return _dist_bundle1.FisherSnedecor_getSkewness(self)

    def getKurtosis(self):
        """getKurtosis(FisherSnedecor self) -> NumericalPoint"""
        return _dist_bundle1.FisherSnedecor_getKurtosis(self)

    def getStandardMoment(self, *args):
        """getStandardMoment(FisherSnedecor self, OT::UnsignedLong const n) -> NumericalPoint"""
        return _dist_bundle1.FisherSnedecor_getStandardMoment(self, *args)

    def getParametersCollection(self):
        """getParametersCollection(FisherSnedecor self) -> NumericalPointWithDescriptionCollection"""
        return _dist_bundle1.FisherSnedecor_getParametersCollection(self)

    def setParametersCollection(self, *args):
        """
        setParametersCollection(FisherSnedecor self, NumericalPointWithDescriptionCollection parametersCollection)
        setParametersCollection(FisherSnedecor self, NumericalPointCollection parametersCollection)
        setParametersCollection(FisherSnedecor self, NumericalPoint parameters)
        setParametersCollection(FisherSnedecor self, NumericalPointCollection parametersCollection)
        """
        return _dist_bundle1.FisherSnedecor_setParametersCollection(self, *args)

    def setD1(self, *args):
        """setD1(FisherSnedecor self, OT::NumericalScalar const d1)"""
        return _dist_bundle1.FisherSnedecor_setD1(self, *args)

    def getD1(self):
        """getD1(FisherSnedecor self) -> OT::NumericalScalar"""
        return _dist_bundle1.FisherSnedecor_getD1(self)

    def setD2(self, *args):
        """setD2(FisherSnedecor self, OT::NumericalScalar const d2)"""
        return _dist_bundle1.FisherSnedecor_setD2(self, *args)

    def getD2(self):
        """getD2(FisherSnedecor self) -> OT::NumericalScalar"""
        return _dist_bundle1.FisherSnedecor_getD2(self)

    def __init__(self, *args): 
        """
        __init__(OT::FisherSnedecor self) -> FisherSnedecor
        __init__(OT::FisherSnedecor self, OT::NumericalScalar const d1, OT::NumericalScalar const d2) -> FisherSnedecor
        __init__(OT::FisherSnedecor self, FisherSnedecor other) -> FisherSnedecor
        """
        this = _dist_bundle1.new_FisherSnedecor(*args)
        try: self.this.append(this)
        except: self.this = this
    __swig_destroy__ = _dist_bundle1.delete_FisherSnedecor
    __del__ = lambda self : None;
FisherSnedecor_swigregister = _dist_bundle1.FisherSnedecor_swigregister
FisherSnedecor_swigregister(FisherSnedecor)

def FisherSnedecor_GetClassName():
  """FisherSnedecor_GetClassName() -> OT::String"""
  return _dist_bundle1.FisherSnedecor_GetClassName()

class FisherSnedecorFactory(openturns.model_copula.DistributionImplementationFactory):
    """Proxy of C++ OT::FisherSnedecorFactory class"""
    __swig_setmethods__ = {}
    for _s in [openturns.model_copula.DistributionImplementationFactory]: __swig_setmethods__.update(getattr(_s,'__swig_setmethods__',{}))
    __setattr__ = lambda self, name, value: _swig_setattr(self, FisherSnedecorFactory, name, value)
    __swig_getmethods__ = {}
    for _s in [openturns.model_copula.DistributionImplementationFactory]: __swig_getmethods__.update(getattr(_s,'__swig_getmethods__',{}))
    __getattr__ = lambda self, name: _swig_getattr(self, FisherSnedecorFactory, name)
    __repr__ = _swig_repr
    def GetClassName():
        """GetClassName() -> OT::String"""
        return _dist_bundle1.FisherSnedecorFactory_GetClassName()

    if _newclass:GetClassName = staticmethod(GetClassName)
    __swig_getmethods__["GetClassName"] = lambda x: GetClassName
    def getClassName(self):
        """getClassName(FisherSnedecorFactory self) -> OT::String"""
        return _dist_bundle1.FisherSnedecorFactory_getClassName(self)

    def build(self, *args):
        """
        build(FisherSnedecorFactory self, NumericalSample sample) -> DistributionImplementationPointer
        build(FisherSnedecorFactory self, NumericalSample sample, CovarianceMatrix covariance) -> DistributionImplementationPointer
        build(FisherSnedecorFactory self, NumericalPointCollection parameters) -> DistributionImplementationPointer
        build(FisherSnedecorFactory self, NumericalPointWithDescriptionCollection parameters) -> DistributionImplementationPointer
        build(FisherSnedecorFactory self, NumericalSample sample) -> DistributionImplementationPointer
        build(FisherSnedecorFactory self, NumericalPointCollection parameters) -> DistributionImplementationPointer
        build(FisherSnedecorFactory self) -> DistributionImplementationPointer
        """
        return _dist_bundle1.FisherSnedecorFactory_build(self, *args)

    def buildAsFisherSnedecor(self, *args):
        """
        buildAsFisherSnedecor(FisherSnedecorFactory self, NumericalSample sample) -> FisherSnedecor
        buildAsFisherSnedecor(FisherSnedecorFactory self, NumericalPointCollection parameters) -> FisherSnedecor
        buildAsFisherSnedecor(FisherSnedecorFactory self, NumericalPointWithDescriptionCollection parameters) -> FisherSnedecor
        buildAsFisherSnedecor(FisherSnedecorFactory self) -> FisherSnedecor
        """
        return _dist_bundle1.FisherSnedecorFactory_buildAsFisherSnedecor(self, *args)

    def __init__(self, *args): 
        """
        __init__(OT::FisherSnedecorFactory self) -> FisherSnedecorFactory
        __init__(OT::FisherSnedecorFactory self, FisherSnedecorFactory other) -> FisherSnedecorFactory
        """
        this = _dist_bundle1.new_FisherSnedecorFactory(*args)
        try: self.this.append(this)
        except: self.this = this
    __swig_destroy__ = _dist_bundle1.delete_FisherSnedecorFactory
    __del__ = lambda self : None;
FisherSnedecorFactory_swigregister = _dist_bundle1.FisherSnedecorFactory_swigregister
FisherSnedecorFactory_swigregister(FisherSnedecorFactory)

def FisherSnedecorFactory_GetClassName():
  """FisherSnedecorFactory_GetClassName() -> OT::String"""
  return _dist_bundle1.FisherSnedecorFactory_GetClassName()

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

    if _newclass:GetClassName = staticmethod(GetClassName)
    __swig_getmethods__["GetClassName"] = lambda x: GetClassName
    def getClassName(self):
        """getClassName(Gamma self) -> OT::String"""
        return _dist_bundle1.Gamma_getClassName(self)

    KLAMBDA = _dist_bundle1.Gamma_KLAMBDA
    MUSIGMA = _dist_bundle1.Gamma_MUSIGMA
    def __eq__(self, *args):
        """__eq__(Gamma self, Gamma other) -> OT::Bool"""
        return _dist_bundle1.Gamma___eq__(self, *args)

    def __repr__(self):
        """__repr__(Gamma self) -> OT::String"""
        return _dist_bundle1.Gamma___repr__(self)

    def __str__(self, offset=""):
        """
        __str__(Gamma self, OT::String const & offset="") -> OT::String
        __str__(Gamma self) -> OT::String
        """
        return _dist_bundle1.Gamma___str__(self, offset)

    def getRealization(self):
        """getRealization(Gamma self) -> NumericalPoint"""
        return _dist_bundle1.Gamma_getRealization(self)

    def computeDDF(self, *args):
        """
        computeDDF(Gamma self, OT::NumericalScalar const scalar) -> OT::NumericalScalar
        computeDDF(Gamma self, NumericalPoint point) -> NumericalPoint
        computeDDF(Gamma self, NumericalSample sample) -> NumericalSample
        computeDDF(Gamma self, NumericalPoint point) -> NumericalPoint
        """
        return _dist_bundle1.Gamma_computeDDF(self, *args)

    def computePDF(self, *args):
        """
        computePDF(Gamma self, OT::NumericalScalar const scalar) -> OT::NumericalScalar
        computePDF(Gamma self, NumericalPoint point) -> OT::NumericalScalar
        computePDF(Gamma self, NumericalSample sample) -> NumericalSample
        computePDF(Gamma self, OT::NumericalScalar const xMin, OT::NumericalScalar const xMax, OT::UnsignedLong const pointNumber, 
            NumericalSample grid, OT::NumericalScalar const precision=OT::ResourceMap::GetAsNumericalScalar("DistributionImplementation-DefaultPDFEpsilon")) -> NumericalSample
        computePDF(Gamma self, OT::NumericalScalar const xMin, OT::NumericalScalar const xMax, OT::UnsignedLong const pointNumber, 
            NumericalSample grid) -> NumericalSample
        computePDF(Gamma self, NumericalPoint xMin, NumericalPoint xMax, Indices pointNumber, NumericalSample grid, 
            OT::NumericalScalar const precision=OT::ResourceMap::GetAsNumericalScalar("DistributionImplementation-DefaultPDFEpsilon")) -> NumericalSample
        computePDF(Gamma self, NumericalPoint xMin, NumericalPoint xMax, Indices pointNumber, NumericalSample grid) -> NumericalSample
        computePDF(Gamma self, NumericalPoint point) -> OT::NumericalScalar
        """
        return _dist_bundle1.Gamma_computePDF(self, *args)

    def computeLogPDF(self, *args):
        """
        computeLogPDF(Gamma self, OT::NumericalScalar const scalar) -> OT::NumericalScalar
        computeLogPDF(Gamma self, NumericalPoint point) -> OT::NumericalScalar
        computeLogPDF(Gamma self, NumericalSample sample) -> NumericalSample
        computeLogPDF(Gamma self, NumericalPoint point) -> OT::NumericalScalar
        """
        return _dist_bundle1.Gamma_computeLogPDF(self, *args)

    def computeCDF(self, *args):
        """
        computeCDF(Gamma self, OT::NumericalScalar const scalar, OT::Bool const tail) -> OT::NumericalScalar
        computeCDF(Gamma self, OT::NumericalScalar const scalar) -> OT::NumericalScalar
        computeCDF(Gamma self, NumericalPoint point, OT::Bool const tail) -> OT::NumericalScalar
        computeCDF(Gamma self, NumericalPoint point) -> OT::NumericalScalar
        computeCDF(Gamma self, NumericalSample sample, OT::Bool const tail) -> NumericalSample
        computeCDF(Gamma self, NumericalSample sample) -> NumericalSample
        computeCDF(Gamma self, OT::NumericalScalar const xMin, OT::NumericalScalar const xMax, OT::UnsignedLong const pointNumber, 
            NumericalSample grid, OT::NumericalScalar const precision=OT::ResourceMap::GetAsNumericalScalar("DistributionImplementation-DefaultCDFEpsilon")) -> NumericalSample
        computeCDF(Gamma self, OT::NumericalScalar const xMin, OT::NumericalScalar const xMax, OT::UnsignedLong const pointNumber, 
            NumericalSample grid) -> NumericalSample
        computeCDF(Gamma self, NumericalPoint xMin, NumericalPoint xMax, Indices pointNumber, NumericalSample grid, 
            OT::NumericalScalar const precision=OT::ResourceMap::GetAsNumericalScalar("DistributionImplementation-DefaultCDFEpsilon")) -> NumericalSample
        computeCDF(Gamma self, NumericalPoint xMin, NumericalPoint xMax, Indices pointNumber, NumericalSample grid) -> NumericalSample
        computeCDF(Gamma self, NumericalPoint point) -> OT::NumericalScalar
        """
        return _dist_bundle1.Gamma_computeCDF(self, *args)

    def computeComplementaryCDF(self, *args):
        """
        computeComplementaryCDF(Gamma self, OT::NumericalScalar const scalar) -> OT::NumericalScalar
        computeComplementaryCDF(Gamma self, NumericalPoint point) -> OT::NumericalScalar
        computeComplementaryCDF(Gamma self, NumericalSample sample) -> NumericalSample
        computeComplementaryCDF(Gamma self, OT::NumericalScalar const xMin, OT::NumericalScalar const xMax, OT::UnsignedLong const pointNumber, 
            NumericalSample grid, OT::NumericalScalar const precision=OT::ResourceMap::GetAsNumericalScalar("DistributionImplementation-DefaultCDFEpsilon")) -> NumericalSample
        computeComplementaryCDF(Gamma self, OT::NumericalScalar const xMin, OT::NumericalScalar const xMax, OT::UnsignedLong const pointNumber, 
            NumericalSample grid) -> NumericalSample
        computeComplementaryCDF(Gamma self, NumericalPoint point) -> OT::NumericalScalar
        """
        return _dist_bundle1.Gamma_computeComplementaryCDF(self, *args)

    def computeCharacteristicFunction(self, *args):
        """computeCharacteristicFunction(Gamma self, OT::NumericalScalar const x) -> OT::NumericalComplex"""
        return _dist_bundle1.Gamma_computeCharacteristicFunction(self, *args)

    def computeLogCharacteristicFunction(self, *args):
        """computeLogCharacteristicFunction(Gamma self, OT::NumericalScalar const x) -> OT::NumericalComplex"""
        return _dist_bundle1.Gamma_computeLogCharacteristicFunction(self, *args)

    def computePDFGradient(self, *args):
        """computePDFGradient(Gamma self, NumericalPoint point) -> NumericalPoint"""
        return _dist_bundle1.Gamma_computePDFGradient(self, *args)

    def computeCDFGradient(self, *args):
        """computeCDFGradient(Gamma self, NumericalPoint point) -> NumericalPoint"""
        return _dist_bundle1.Gamma_computeCDFGradient(self, *args)

    def getStandardDeviation(self):
        """getStandardDeviation(Gamma self) -> NumericalPoint"""
        return _dist_bundle1.Gamma_getStandardDeviation(self)

    def getSkewness(self):
        """getSkewness(Gamma self) -> NumericalPoint"""
        return _dist_bundle1.Gamma_getSkewness(self)

    def getKurtosis(self):
        """getKurtosis(Gamma self) -> NumericalPoint"""
        return _dist_bundle1.Gamma_getKurtosis(self)

    def getStandardMoment(self, *args):
        """getStandardMoment(Gamma self, OT::UnsignedLong const n) -> NumericalPoint"""
        return _dist_bundle1.Gamma_getStandardMoment(self, *args)

    def getStandardRepresentative(self):
        """getStandardRepresentative(Gamma self) -> DistributionImplementationPointer"""
        return _dist_bundle1.Gamma_getStandardRepresentative(self)

    def getParametersCollection(self):
        """getParametersCollection(Gamma self) -> NumericalPointWithDescriptionCollection"""
        return _dist_bundle1.Gamma_getParametersCollection(self)

    def setParametersCollection(self, *args):
        """
        setParametersCollection(Gamma self, NumericalPointWithDescriptionCollection parametersCollection)
        setParametersCollection(Gamma self, NumericalPointCollection parametersCollection)
        setParametersCollection(Gamma self, NumericalPoint parameters)
        setParametersCollection(Gamma self, NumericalPointCollection parametersCollection)
        """
        return _dist_bundle1.Gamma_setParametersCollection(self, *args)

    def setK(self, *args):
        """setK(Gamma self, OT::NumericalScalar const k)"""
        return _dist_bundle1.Gamma_setK(self, *args)

    def getK(self):
        """getK(Gamma self) -> OT::NumericalScalar"""
        return _dist_bundle1.Gamma_getK(self)

    def setLambda(self, *args):
        """setLambda(Gamma self, OT::NumericalScalar const _lambda)"""
        return _dist_bundle1.Gamma_setLambda(self, *args)

    def getLambda(self):
        """getLambda(Gamma self) -> OT::NumericalScalar"""
        return _dist_bundle1.Gamma_getLambda(self)

    def setKLambda(self, *args):
        """setKLambda(Gamma self, OT::NumericalScalar const k, OT::NumericalScalar const _lambda)"""
        return _dist_bundle1.Gamma_setKLambda(self, *args)

    def setMuSigma(self, *args):
        """setMuSigma(Gamma self, OT::NumericalScalar const mu, OT::NumericalScalar const sigma)"""
        return _dist_bundle1.Gamma_setMuSigma(self, *args)

    def getMu(self):
        """getMu(Gamma self) -> OT::NumericalScalar"""
        return _dist_bundle1.Gamma_getMu(self)

    def getSigma(self):
        """getSigma(Gamma self) -> OT::NumericalScalar"""
        return _dist_bundle1.Gamma_getSigma(self)

    def setGamma(self, *args):
        """setGamma(Gamma self, OT::NumericalScalar const gamma)"""
        return _dist_bundle1.Gamma_setGamma(self, *args)

    def getGamma(self):
        """getGamma(Gamma self) -> OT::NumericalScalar"""
        return _dist_bundle1.Gamma_getGamma(self)

    def __init__(self, *args): 
        """
        __init__(OT::Gamma self) -> Gamma
        __init__(OT::Gamma self, OT::NumericalScalar const arg1, OT::NumericalScalar const arg2, OT::NumericalScalar const gamma=0.0, 
            OT::Gamma::ParameterSet const set=KLAMBDA) -> Gamma
        __init__(OT::Gamma self, OT::NumericalScalar const arg1, OT::NumericalScalar const arg2, OT::NumericalScalar const gamma=0.0) -> Gamma
        __init__(OT::Gamma self, OT::NumericalScalar const arg1, OT::NumericalScalar const arg2) -> Gamma
        __init__(OT::Gamma self, Gamma other) -> Gamma
        """
        this = _dist_bundle1.new_Gamma(*args)
        try: self.this.append(this)
        except: self.this = this
    __swig_destroy__ = _dist_bundle1.delete_Gamma
    __del__ = lambda self : None;
Gamma_swigregister = _dist_bundle1.Gamma_swigregister
Gamma_swigregister(Gamma)

def Gamma_GetClassName():
  """Gamma_GetClassName() -> OT::String"""
  return _dist_bundle1.Gamma_GetClassName()

class GammaFactory(openturns.model_copula.DistributionImplementationFactory):
    """Proxy of C++ OT::GammaFactory class"""
    __swig_setmethods__ = {}
    for _s in [openturns.model_copula.DistributionImplementationFactory]: __swig_setmethods__.update(getattr(_s,'__swig_setmethods__',{}))
    __setattr__ = lambda self, name, value: _swig_setattr(self, GammaFactory, name, value)
    __swig_getmethods__ = {}
    for _s in [openturns.model_copula.DistributionImplementationFactory]: __swig_getmethods__.update(getattr(_s,'__swig_getmethods__',{}))
    __getattr__ = lambda self, name: _swig_getattr(self, GammaFactory, name)
    __repr__ = _swig_repr
    def GetClassName():
        """GetClassName() -> OT::String"""
        return _dist_bundle1.GammaFactory_GetClassName()

    if _newclass:GetClassName = staticmethod(GetClassName)
    __swig_getmethods__["GetClassName"] = lambda x: GetClassName
    def getClassName(self):
        """getClassName(GammaFactory self) -> OT::String"""
        return _dist_bundle1.GammaFactory_getClassName(self)

    def build(self, *args):
        """
        build(GammaFactory self, NumericalSample sample) -> DistributionImplementationPointer
        build(GammaFactory self, NumericalSample sample, CovarianceMatrix covariance) -> DistributionImplementationPointer
        build(GammaFactory self, NumericalPointCollection parameters) -> DistributionImplementationPointer
        build(GammaFactory self, NumericalPointWithDescriptionCollection parameters) -> DistributionImplementationPointer
        build(GammaFactory self, NumericalSample sample) -> DistributionImplementationPointer
        build(GammaFactory self, NumericalPointCollection parameters) -> DistributionImplementationPointer
        build(GammaFactory self) -> DistributionImplementationPointer
        """
        return _dist_bundle1.GammaFactory_build(self, *args)

    def buildAsGamma(self, *args):
        """
        buildAsGamma(GammaFactory self, NumericalSample sample) -> Gamma
        buildAsGamma(GammaFactory self, NumericalPointCollection parameters) -> Gamma
        buildAsGamma(GammaFactory self, NumericalPointWithDescriptionCollection parameters) -> Gamma
        buildAsGamma(GammaFactory self) -> Gamma
        """
        return _dist_bundle1.GammaFactory_buildAsGamma(self, *args)

    def __init__(self, *args): 
        """
        __init__(OT::GammaFactory self) -> GammaFactory
        __init__(OT::GammaFactory self, GammaFactory other) -> GammaFactory
        """
        this = _dist_bundle1.new_GammaFactory(*args)
        try: self.this.append(this)
        except: self.this = this
    __swig_destroy__ = _dist_bundle1.delete_GammaFactory
    __del__ = lambda self : None;
GammaFactory_swigregister = _dist_bundle1.GammaFactory_swigregister
GammaFactory_swigregister(GammaFactory)

def GammaFactory_GetClassName():
  """GammaFactory_GetClassName() -> OT::String"""
  return _dist_bundle1.GammaFactory_GetClassName()

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

    if _newclass:GetClassName = staticmethod(GetClassName)
    __swig_getmethods__["GetClassName"] = lambda x: GetClassName
    def getClassName(self):
        """getClassName(GeneralizedPareto self) -> OT::String"""
        return _dist_bundle1.GeneralizedPareto_getClassName(self)

    def __eq__(self, *args):
        """__eq__(GeneralizedPareto self, GeneralizedPareto other) -> OT::Bool"""
        return _dist_bundle1.GeneralizedPareto___eq__(self, *args)

    def __repr__(self):
        """__repr__(GeneralizedPareto self) -> OT::String"""
        return _dist_bundle1.GeneralizedPareto___repr__(self)

    def __str__(self, offset=""):
        """
        __str__(GeneralizedPareto self, OT::String const & offset="") -> OT::String
        __str__(GeneralizedPareto self) -> OT::String
        """
        return _dist_bundle1.GeneralizedPareto___str__(self, offset)

    def getRealization(self):
        """getRealization(GeneralizedPareto self) -> NumericalPoint"""
        return _dist_bundle1.GeneralizedPareto_getRealization(self)

    def computeDDF(self, *args):
        """
        computeDDF(GeneralizedPareto self, OT::NumericalScalar const scalar) -> OT::NumericalScalar
        computeDDF(GeneralizedPareto self, NumericalPoint point) -> NumericalPoint
        computeDDF(GeneralizedPareto self, NumericalSample sample) -> NumericalSample
        computeDDF(GeneralizedPareto self, NumericalPoint point) -> NumericalPoint
        """
        return _dist_bundle1.GeneralizedPareto_computeDDF(self, *args)

    def computePDF(self, *args):
        """
        computePDF(GeneralizedPareto self, OT::NumericalScalar const scalar) -> OT::NumericalScalar
        computePDF(GeneralizedPareto self, NumericalPoint point) -> OT::NumericalScalar
        computePDF(GeneralizedPareto self, NumericalSample sample) -> NumericalSample
        computePDF(GeneralizedPareto self, OT::NumericalScalar const xMin, OT::NumericalScalar const xMax, OT::UnsignedLong const pointNumber, 
            NumericalSample grid, OT::NumericalScalar const precision=OT::ResourceMap::GetAsNumericalScalar("DistributionImplementation-DefaultPDFEpsilon")) -> NumericalSample
        computePDF(GeneralizedPareto self, OT::NumericalScalar const xMin, OT::NumericalScalar const xMax, OT::UnsignedLong const pointNumber, 
            NumericalSample grid) -> NumericalSample
        computePDF(GeneralizedPareto self, NumericalPoint xMin, NumericalPoint xMax, Indices pointNumber, NumericalSample grid, 
            OT::NumericalScalar const precision=OT::ResourceMap::GetAsNumericalScalar("DistributionImplementation-DefaultPDFEpsilon")) -> NumericalSample
        computePDF(GeneralizedPareto self, NumericalPoint xMin, NumericalPoint xMax, Indices pointNumber, NumericalSample grid) -> NumericalSample
        computePDF(GeneralizedPareto self, NumericalPoint point) -> OT::NumericalScalar
        """
        return _dist_bundle1.GeneralizedPareto_computePDF(self, *args)

    def computeLogPDF(self, *args):
        """
        computeLogPDF(GeneralizedPareto self, OT::NumericalScalar const scalar) -> OT::NumericalScalar
        computeLogPDF(GeneralizedPareto self, NumericalPoint point) -> OT::NumericalScalar
        computeLogPDF(GeneralizedPareto self, NumericalSample sample) -> NumericalSample
        computeLogPDF(GeneralizedPareto self, NumericalPoint point) -> OT::NumericalScalar
        """
        return _dist_bundle1.GeneralizedPareto_computeLogPDF(self, *args)

    def computeCDF(self, *args):
        """
        computeCDF(GeneralizedPareto self, OT::NumericalScalar const scalar, OT::Bool const tail) -> OT::NumericalScalar
        computeCDF(GeneralizedPareto self, OT::NumericalScalar const scalar) -> OT::NumericalScalar
        computeCDF(GeneralizedPareto self, NumericalPoint point, OT::Bool const tail) -> OT::NumericalScalar
        computeCDF(GeneralizedPareto self, NumericalPoint point) -> OT::NumericalScalar
        computeCDF(GeneralizedPareto self, NumericalSample sample, OT::Bool const tail) -> NumericalSample
        computeCDF(GeneralizedPareto self, NumericalSample sample) -> NumericalSample
        computeCDF(GeneralizedPareto self, OT::NumericalScalar const xMin, OT::NumericalScalar const xMax, OT::UnsignedLong const pointNumber, 
            NumericalSample grid, OT::NumericalScalar const precision=OT::ResourceMap::GetAsNumericalScalar("DistributionImplementation-DefaultCDFEpsilon")) -> NumericalSample
        computeCDF(GeneralizedPareto self, OT::NumericalScalar const xMin, OT::NumericalScalar const xMax, OT::UnsignedLong const pointNumber, 
            NumericalSample grid) -> NumericalSample
        computeCDF(GeneralizedPareto self, NumericalPoint xMin, NumericalPoint xMax, Indices pointNumber, NumericalSample grid, 
            OT::NumericalScalar const precision=OT::ResourceMap::GetAsNumericalScalar("DistributionImplementation-DefaultCDFEpsilon")) -> NumericalSample
        computeCDF(GeneralizedPareto self, NumericalPoint xMin, NumericalPoint xMax, Indices pointNumber, NumericalSample grid) -> NumericalSample
        computeCDF(GeneralizedPareto self, NumericalPoint point) -> OT::NumericalScalar
        """
        return _dist_bundle1.GeneralizedPareto_computeCDF(self, *args)

    def computeComplementaryCDF(self, *args):
        """
        computeComplementaryCDF(GeneralizedPareto self, OT::NumericalScalar const scalar) -> OT::NumericalScalar
        computeComplementaryCDF(GeneralizedPareto self, NumericalPoint point) -> OT::NumericalScalar
        computeComplementaryCDF(GeneralizedPareto self, NumericalSample sample) -> NumericalSample
        computeComplementaryCDF(GeneralizedPareto self, OT::NumericalScalar const xMin, OT::NumericalScalar const xMax, OT::UnsignedLong const pointNumber, 
            NumericalSample grid, OT::NumericalScalar const precision=OT::ResourceMap::GetAsNumericalScalar("DistributionImplementation-DefaultCDFEpsilon")) -> NumericalSample
        computeComplementaryCDF(GeneralizedPareto self, OT::NumericalScalar const xMin, OT::NumericalScalar const xMax, OT::UnsignedLong const pointNumber, 
            NumericalSample grid) -> NumericalSample
        computeComplementaryCDF(GeneralizedPareto self, NumericalPoint point) -> OT::NumericalScalar
        """
        return _dist_bundle1.GeneralizedPareto_computeComplementaryCDF(self, *args)

    def computeCharacteristicFunction(self, *args):
        """computeCharacteristicFunction(GeneralizedPareto self, OT::NumericalScalar const x) -> OT::NumericalComplex"""
        return _dist_bundle1.GeneralizedPareto_computeCharacteristicFunction(self, *args)

    def computeLogCharacteristicFunction(self, *args):
        """computeLogCharacteristicFunction(GeneralizedPareto self, OT::NumericalScalar const x) -> OT::NumericalComplex"""
        return _dist_bundle1.GeneralizedPareto_computeLogCharacteristicFunction(self, *args)

    def computePDFGradient(self, *args):
        """computePDFGradient(GeneralizedPareto self, NumericalPoint point) -> NumericalPoint"""
        return _dist_bundle1.GeneralizedPareto_computePDFGradient(self, *args)

    def computeCDFGradient(self, *args):
        """computeCDFGradient(GeneralizedPareto self, NumericalPoint point) -> NumericalPoint"""
        return _dist_bundle1.GeneralizedPareto_computeCDFGradient(self, *args)

    def getStandardDeviation(self):
        """getStandardDeviation(GeneralizedPareto self) -> NumericalPoint"""
        return _dist_bundle1.GeneralizedPareto_getStandardDeviation(self)

    def getSkewness(self):
        """getSkewness(GeneralizedPareto self) -> NumericalPoint"""
        return _dist_bundle1.GeneralizedPareto_getSkewness(self)

    def getKurtosis(self):
        """getKurtosis(GeneralizedPareto self) -> NumericalPoint"""
        return _dist_bundle1.GeneralizedPareto_getKurtosis(self)

    def getStandardMoment(self, *args):
        """getStandardMoment(GeneralizedPareto self, OT::UnsignedLong const n) -> NumericalPoint"""
        return _dist_bundle1.GeneralizedPareto_getStandardMoment(self, *args)

    def getStandardRepresentative(self):
        """getStandardRepresentative(GeneralizedPareto self) -> DistributionImplementationPointer"""
        return _dist_bundle1.GeneralizedPareto_getStandardRepresentative(self)

    def getParametersCollection(self):
        """getParametersCollection(GeneralizedPareto self) -> NumericalPointWithDescriptionCollection"""
        return _dist_bundle1.GeneralizedPareto_getParametersCollection(self)

    def setParametersCollection(self, *args):
        """
        setParametersCollection(GeneralizedPareto self, NumericalPointWithDescriptionCollection parametersCollection)
        setParametersCollection(GeneralizedPareto self, NumericalPointCollection parametersCollection)
        setParametersCollection(GeneralizedPareto self, NumericalPoint parameters)
        setParametersCollection(GeneralizedPareto self, NumericalPointCollection parametersCollection)
        """
        return _dist_bundle1.GeneralizedPareto_setParametersCollection(self, *args)

    def setSigma(self, *args):
        """setSigma(GeneralizedPareto self, OT::NumericalScalar const sigma)"""
        return _dist_bundle1.GeneralizedPareto_setSigma(self, *args)

    def getSigma(self):
        """getSigma(GeneralizedPareto self) -> OT::NumericalScalar"""
        return _dist_bundle1.GeneralizedPareto_getSigma(self)

    def setXi(self, *args):
        """setXi(GeneralizedPareto self, OT::NumericalScalar const xi)"""
        return _dist_bundle1.GeneralizedPareto_setXi(self, *args)

    def getXi(self):
        """getXi(GeneralizedPareto self) -> OT::NumericalScalar"""
        return _dist_bundle1.GeneralizedPareto_getXi(self)

    def __init__(self, *args): 
        """
        __init__(OT::GeneralizedPareto self) -> GeneralizedPareto
        __init__(OT::GeneralizedPareto self, OT::NumericalScalar const sigma, OT::NumericalScalar const xi) -> GeneralizedPareto
        __init__(OT::GeneralizedPareto self, GeneralizedPareto other) -> GeneralizedPareto
        """
        this = _dist_bundle1.new_GeneralizedPareto(*args)
        try: self.this.append(this)
        except: self.this = this
    __swig_destroy__ = _dist_bundle1.delete_GeneralizedPareto
    __del__ = lambda self : None;
GeneralizedPareto_swigregister = _dist_bundle1.GeneralizedPareto_swigregister
GeneralizedPareto_swigregister(GeneralizedPareto)

def GeneralizedPareto_GetClassName():
  """GeneralizedPareto_GetClassName() -> OT::String"""
  return _dist_bundle1.GeneralizedPareto_GetClassName()

class GeneralizedParetoFactory(openturns.model_copula.DistributionImplementationFactory):
    """Proxy of C++ OT::GeneralizedParetoFactory class"""
    __swig_setmethods__ = {}
    for _s in [openturns.model_copula.DistributionImplementationFactory]: __swig_setmethods__.update(getattr(_s,'__swig_setmethods__',{}))
    __setattr__ = lambda self, name, value: _swig_setattr(self, GeneralizedParetoFactory, name, value)
    __swig_getmethods__ = {}
    for _s in [openturns.model_copula.DistributionImplementationFactory]: __swig_getmethods__.update(getattr(_s,'__swig_getmethods__',{}))
    __getattr__ = lambda self, name: _swig_getattr(self, GeneralizedParetoFactory, name)
    __repr__ = _swig_repr
    def GetClassName():
        """GetClassName() -> OT::String"""
        return _dist_bundle1.GeneralizedParetoFactory_GetClassName()

    if _newclass:GetClassName = staticmethod(GetClassName)
    __swig_getmethods__["GetClassName"] = lambda x: GetClassName
    def getClassName(self):
        """getClassName(GeneralizedParetoFactory self) -> OT::String"""
        return _dist_bundle1.GeneralizedParetoFactory_getClassName(self)

    def build(self, *args):
        """
        build(GeneralizedParetoFactory self, NumericalSample sample) -> DistributionImplementationPointer
        build(GeneralizedParetoFactory self, NumericalSample sample, CovarianceMatrix covariance) -> DistributionImplementationPointer
        build(GeneralizedParetoFactory self, NumericalPointCollection parameters) -> DistributionImplementationPointer
        build(GeneralizedParetoFactory self, NumericalPointWithDescriptionCollection parameters) -> DistributionImplementationPointer
        build(GeneralizedParetoFactory self, NumericalSample sample) -> DistributionImplementationPointer
        build(GeneralizedParetoFactory self, NumericalPointCollection parameters) -> DistributionImplementationPointer
        build(GeneralizedParetoFactory self) -> DistributionImplementationPointer
        """
        return _dist_bundle1.GeneralizedParetoFactory_build(self, *args)

    def buildAsGeneralizedPareto(self, *args):
        """
        buildAsGeneralizedPareto(GeneralizedParetoFactory self, NumericalSample sample) -> GeneralizedPareto
        buildAsGeneralizedPareto(GeneralizedParetoFactory self, NumericalPointCollection parameters) -> GeneralizedPareto
        buildAsGeneralizedPareto(GeneralizedParetoFactory self, NumericalPointWithDescriptionCollection parameters) -> GeneralizedPareto
        buildAsGeneralizedPareto(GeneralizedParetoFactory self) -> GeneralizedPareto
        """
        return _dist_bundle1.GeneralizedParetoFactory_buildAsGeneralizedPareto(self, *args)

    def buildMethodOfMoments(self, *args):
        """buildMethodOfMoments(GeneralizedParetoFactory self, NumericalSample sample) -> GeneralizedPareto"""
        return _dist_bundle1.GeneralizedParetoFactory_buildMethodOfMoments(self, *args)

    def buildMethodOfExponentialRegression(self, *args):
        """buildMethodOfExponentialRegression(GeneralizedParetoFactory self, NumericalSample sample) -> GeneralizedPareto"""
        return _dist_bundle1.GeneralizedParetoFactory_buildMethodOfExponentialRegression(self, *args)

    def buildMethodOfProbabilityWeightedMoments(self, *args):
        """buildMethodOfProbabilityWeightedMoments(GeneralizedParetoFactory self, NumericalSample sample) -> GeneralizedPareto"""
        return _dist_bundle1.GeneralizedParetoFactory_buildMethodOfProbabilityWeightedMoments(self, *args)

    def __init__(self, *args): 
        """
        __init__(OT::GeneralizedParetoFactory self) -> GeneralizedParetoFactory
        __init__(OT::GeneralizedParetoFactory self, GeneralizedParetoFactory other) -> GeneralizedParetoFactory
        """
        this = _dist_bundle1.new_GeneralizedParetoFactory(*args)
        try: self.this.append(this)
        except: self.this = this
    __swig_destroy__ = _dist_bundle1.delete_GeneralizedParetoFactory
    __del__ = lambda self : None;
GeneralizedParetoFactory_swigregister = _dist_bundle1.GeneralizedParetoFactory_swigregister
GeneralizedParetoFactory_swigregister(GeneralizedParetoFactory)

def GeneralizedParetoFactory_GetClassName():
  """GeneralizedParetoFactory_GetClassName() -> OT::String"""
  return _dist_bundle1.GeneralizedParetoFactory_GetClassName()

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

    if _newclass:GetClassName = staticmethod(GetClassName)
    __swig_getmethods__["GetClassName"] = lambda x: GetClassName
    def getClassName(self):
        """getClassName(Geometric self) -> OT::String"""
        return _dist_bundle1.Geometric_getClassName(self)

    def __eq__(self, *args):
        """__eq__(Geometric self, Geometric other) -> OT::Bool"""
        return _dist_bundle1.Geometric___eq__(self, *args)

    def __repr__(self):
        """__repr__(Geometric self) -> OT::String"""
        return _dist_bundle1.Geometric___repr__(self)

    def __str__(self, offset=""):
        """
        __str__(Geometric self, OT::String const & offset="") -> OT::String
        __str__(Geometric self) -> OT::String
        """
        return _dist_bundle1.Geometric___str__(self, offset)

    def getRealization(self):
        """getRealization(Geometric self) -> NumericalPoint"""
        return _dist_bundle1.Geometric_getRealization(self)

    def computePDF(self, *args):
        """
        computePDF(Geometric self, OT::NumericalScalar const scalar) -> OT::NumericalScalar
        computePDF(Geometric self, NumericalPoint point) -> OT::NumericalScalar
        computePDF(Geometric self, NumericalSample sample) -> NumericalSample
        computePDF(Geometric self, OT::NumericalScalar const xMin, OT::NumericalScalar const xMax, OT::UnsignedLong const pointNumber, 
            NumericalSample grid, OT::NumericalScalar const precision=OT::ResourceMap::GetAsNumericalScalar("DistributionImplementation-DefaultPDFEpsilon")) -> NumericalSample
        computePDF(Geometric self, OT::NumericalScalar const xMin, OT::NumericalScalar const xMax, OT::UnsignedLong const pointNumber, 
            NumericalSample grid) -> NumericalSample
        computePDF(Geometric self, NumericalPoint xMin, NumericalPoint xMax, Indices pointNumber, NumericalSample grid, 
            OT::NumericalScalar const precision=OT::ResourceMap::GetAsNumericalScalar("DistributionImplementation-DefaultPDFEpsilon")) -> NumericalSample
        computePDF(Geometric self, NumericalPoint xMin, NumericalPoint xMax, Indices pointNumber, NumericalSample grid) -> NumericalSample
        computePDF(Geometric self, NumericalPoint point) -> OT::NumericalScalar
        """
        return _dist_bundle1.Geometric_computePDF(self, *args)

    def computeCDF(self, *args):
        """
        computeCDF(Geometric self, OT::NumericalScalar const scalar, OT::Bool const tail) -> OT::NumericalScalar
        computeCDF(Geometric self, OT::NumericalScalar const scalar) -> OT::NumericalScalar
        computeCDF(Geometric self, NumericalPoint point, OT::Bool const tail) -> OT::NumericalScalar
        computeCDF(Geometric self, NumericalPoint point) -> OT::NumericalScalar
        computeCDF(Geometric self, NumericalSample sample, OT::Bool const tail) -> NumericalSample
        computeCDF(Geometric self, NumericalSample sample) -> NumericalSample
        computeCDF(Geometric self, OT::NumericalScalar const xMin, OT::NumericalScalar const xMax, OT::UnsignedLong const pointNumber, 
            NumericalSample grid, OT::NumericalScalar const precision=OT::ResourceMap::GetAsNumericalScalar("DistributionImplementation-DefaultCDFEpsilon")) -> NumericalSample
        computeCDF(Geometric self, OT::NumericalScalar const xMin, OT::NumericalScalar const xMax, OT::UnsignedLong const pointNumber, 
            NumericalSample grid) -> NumericalSample
        computeCDF(Geometric self, NumericalPoint xMin, NumericalPoint xMax, Indices pointNumber, NumericalSample grid, 
            OT::NumericalScalar const precision=OT::ResourceMap::GetAsNumericalScalar("DistributionImplementation-DefaultCDFEpsilon")) -> NumericalSample
        computeCDF(Geometric self, NumericalPoint xMin, NumericalPoint xMax, Indices pointNumber, NumericalSample grid) -> NumericalSample
        computeCDF(Geometric self, NumericalPoint point) -> OT::NumericalScalar
        """
        return _dist_bundle1.Geometric_computeCDF(self, *args)

    def computeComplementaryCDF(self, *args):
        """
        computeComplementaryCDF(Geometric self, OT::NumericalScalar const scalar) -> OT::NumericalScalar
        computeComplementaryCDF(Geometric self, NumericalPoint point) -> OT::NumericalScalar
        computeComplementaryCDF(Geometric self, NumericalSample sample) -> NumericalSample
        computeComplementaryCDF(Geometric self, OT::NumericalScalar const xMin, OT::NumericalScalar const xMax, OT::UnsignedLong const pointNumber, 
            NumericalSample grid, OT::NumericalScalar const precision=OT::ResourceMap::GetAsNumericalScalar("DistributionImplementation-DefaultCDFEpsilon")) -> NumericalSample
        computeComplementaryCDF(Geometric self, OT::NumericalScalar const xMin, OT::NumericalScalar const xMax, OT::UnsignedLong const pointNumber, 
            NumericalSample grid) -> NumericalSample
        computeComplementaryCDF(Geometric self, NumericalPoint point) -> OT::NumericalScalar
        """
        return _dist_bundle1.Geometric_computeComplementaryCDF(self, *args)

    def computePDFGradient(self, *args):
        """computePDFGradient(Geometric self, NumericalPoint point) -> NumericalPoint"""
        return _dist_bundle1.Geometric_computePDFGradient(self, *args)

    def computeCDFGradient(self, *args):
        """computeCDFGradient(Geometric self, NumericalPoint point) -> NumericalPoint"""
        return _dist_bundle1.Geometric_computeCDFGradient(self, *args)

    def computeCharacteristicFunction(self, *args):
        """computeCharacteristicFunction(Geometric self, OT::NumericalScalar const x) -> OT::NumericalComplex"""
        return _dist_bundle1.Geometric_computeCharacteristicFunction(self, *args)

    def computeGeneratingFunction(self, *args):
        """computeGeneratingFunction(Geometric self, OT::NumericalComplex const & z) -> OT::NumericalComplex"""
        return _dist_bundle1.Geometric_computeGeneratingFunction(self, *args)

    def getSupport(self, *args):
        """
        getSupport(Geometric self, Interval interval) -> NumericalSample
        getSupport(Geometric self) -> NumericalSample
        getSupport(Geometric self, Interval interval) -> NumericalSample
        """
        return _dist_bundle1.Geometric_getSupport(self, *args)

    def getStandardDeviation(self):
        """getStandardDeviation(Geometric self) -> NumericalPoint"""
        return _dist_bundle1.Geometric_getStandardDeviation(self)

    def getSkewness(self):
        """getSkewness(Geometric self) -> NumericalPoint"""
        return _dist_bundle1.Geometric_getSkewness(self)

    def getKurtosis(self):
        """getKurtosis(Geometric self) -> NumericalPoint"""
        return _dist_bundle1.Geometric_getKurtosis(self)

    def getParametersCollection(self):
        """getParametersCollection(Geometric self) -> NumericalPointWithDescriptionCollection"""
        return _dist_bundle1.Geometric_getParametersCollection(self)

    def setParametersCollection(self, *args):
        """
        setParametersCollection(Geometric self, NumericalPointWithDescriptionCollection parametersCollection)
        setParametersCollection(Geometric self, NumericalPointCollection parametersCollection)
        setParametersCollection(Geometric self, NumericalPoint parameters)
        setParametersCollection(Geometric self, NumericalPointCollection parametersCollection)
        """
        return _dist_bundle1.Geometric_setParametersCollection(self, *args)

    def setP(self, *args):
        """setP(Geometric self, OT::NumericalScalar const p)"""
        return _dist_bundle1.Geometric_setP(self, *args)

    def getP(self):
        """getP(Geometric self) -> OT::NumericalScalar"""
        return _dist_bundle1.Geometric_getP(self)

    def __init__(self, *args): 
        """
        __init__(OT::Geometric self) -> Geometric
        __init__(OT::Geometric self, OT::NumericalScalar const p) -> Geometric
        __init__(OT::Geometric self, Geometric other) -> Geometric
        """
        this = _dist_bundle1.new_Geometric(*args)
        try: self.this.append(this)
        except: self.this = this
    __swig_destroy__ = _dist_bundle1.delete_Geometric
    __del__ = lambda self : None;
Geometric_swigregister = _dist_bundle1.Geometric_swigregister
Geometric_swigregister(Geometric)

def Geometric_GetClassName():
  """Geometric_GetClassName() -> OT::String"""
  return _dist_bundle1.Geometric_GetClassName()

class GeometricFactory(openturns.model_copula.DistributionImplementationFactory):
    """Proxy of C++ OT::GeometricFactory class"""
    __swig_setmethods__ = {}
    for _s in [openturns.model_copula.DistributionImplementationFactory]: __swig_setmethods__.update(getattr(_s,'__swig_setmethods__',{}))
    __setattr__ = lambda self, name, value: _swig_setattr(self, GeometricFactory, name, value)
    __swig_getmethods__ = {}
    for _s in [openturns.model_copula.DistributionImplementationFactory]: __swig_getmethods__.update(getattr(_s,'__swig_getmethods__',{}))
    __getattr__ = lambda self, name: _swig_getattr(self, GeometricFactory, name)
    __repr__ = _swig_repr
    def GetClassName():
        """GetClassName() -> OT::String"""
        return _dist_bundle1.GeometricFactory_GetClassName()

    if _newclass:GetClassName = staticmethod(GetClassName)
    __swig_getmethods__["GetClassName"] = lambda x: GetClassName
    def getClassName(self):
        """getClassName(GeometricFactory self) -> OT::String"""
        return _dist_bundle1.GeometricFactory_getClassName(self)

    def build(self, *args):
        """
        build(GeometricFactory self, NumericalSample sample) -> DistributionImplementationPointer
        build(GeometricFactory self, NumericalSample sample, CovarianceMatrix covariance) -> DistributionImplementationPointer
        build(GeometricFactory self, NumericalPointCollection parameters) -> DistributionImplementationPointer
        build(GeometricFactory self, NumericalPointWithDescriptionCollection parameters) -> DistributionImplementationPointer
        build(GeometricFactory self, NumericalSample sample) -> DistributionImplementationPointer
        build(GeometricFactory self, NumericalPointCollection parameters) -> DistributionImplementationPointer
        build(GeometricFactory self) -> DistributionImplementationPointer
        """
        return _dist_bundle1.GeometricFactory_build(self, *args)

    def buildAsGeometric(self, *args):
        """
        buildAsGeometric(GeometricFactory self, NumericalSample sample) -> Geometric
        buildAsGeometric(GeometricFactory self, NumericalPointCollection parameters) -> Geometric
        buildAsGeometric(GeometricFactory self, NumericalPointWithDescriptionCollection parameters) -> Geometric
        buildAsGeometric(GeometricFactory self) -> Geometric
        """
        return _dist_bundle1.GeometricFactory_buildAsGeometric(self, *args)

    def __init__(self, *args): 
        """
        __init__(OT::GeometricFactory self) -> GeometricFactory
        __init__(OT::GeometricFactory self, GeometricFactory other) -> GeometricFactory
        """
        this = _dist_bundle1.new_GeometricFactory(*args)
        try: self.this.append(this)
        except: self.this = this
    __swig_destroy__ = _dist_bundle1.delete_GeometricFactory
    __del__ = lambda self : None;
GeometricFactory_swigregister = _dist_bundle1.GeometricFactory_swigregister
GeometricFactory_swigregister(GeometricFactory)

def GeometricFactory_GetClassName():
  """GeometricFactory_GetClassName() -> OT::String"""
  return _dist_bundle1.GeometricFactory_GetClassName()

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

    if _newclass:GetClassName = staticmethod(GetClassName)
    __swig_getmethods__["GetClassName"] = lambda x: GetClassName
    def getClassName(self):
        """getClassName(Gumbel self) -> OT::String"""
        return _dist_bundle1.Gumbel_getClassName(self)

    ALPHABETA = _dist_bundle1.Gumbel_ALPHABETA
    MUSIGMA = _dist_bundle1.Gumbel_MUSIGMA
    AB = _dist_bundle1.Gumbel_AB
    def __eq__(self, *args):
        """__eq__(Gumbel self, Gumbel other) -> OT::Bool"""
        return _dist_bundle1.Gumbel___eq__(self, *args)

    def __repr__(self):
        """__repr__(Gumbel self) -> OT::String"""
        return _dist_bundle1.Gumbel___repr__(self)

    def __str__(self, offset=""):
        """
        __str__(Gumbel self, OT::String const & offset="") -> OT::String
        __str__(Gumbel self) -> OT::String
        """
        return _dist_bundle1.Gumbel___str__(self, offset)

    def getRealization(self):
        """getRealization(Gumbel self) -> NumericalPoint"""
        return _dist_bundle1.Gumbel_getRealization(self)

    def computeDDF(self, *args):
        """
        computeDDF(Gumbel self, OT::NumericalScalar const scalar) -> OT::NumericalScalar
        computeDDF(Gumbel self, NumericalPoint point) -> NumericalPoint
        computeDDF(Gumbel self, NumericalSample sample) -> NumericalSample
        computeDDF(Gumbel self, NumericalPoint point) -> NumericalPoint
        """
        return _dist_bundle1.Gumbel_computeDDF(self, *args)

    def computePDF(self, *args):
        """
        computePDF(Gumbel self, OT::NumericalScalar const scalar) -> OT::NumericalScalar
        computePDF(Gumbel self, NumericalPoint point) -> OT::NumericalScalar
        computePDF(Gumbel self, NumericalSample sample) -> NumericalSample
        computePDF(Gumbel self, OT::NumericalScalar const xMin, OT::NumericalScalar const xMax, OT::UnsignedLong const pointNumber, 
            NumericalSample grid, OT::NumericalScalar const precision=OT::ResourceMap::GetAsNumericalScalar("DistributionImplementation-DefaultPDFEpsilon")) -> NumericalSample
        computePDF(Gumbel self, OT::NumericalScalar const xMin, OT::NumericalScalar const xMax, OT::UnsignedLong const pointNumber, 
            NumericalSample grid) -> NumericalSample
        computePDF(Gumbel self, NumericalPoint xMin, NumericalPoint xMax, Indices pointNumber, NumericalSample grid, 
            OT::NumericalScalar const precision=OT::ResourceMap::GetAsNumericalScalar("DistributionImplementation-DefaultPDFEpsilon")) -> NumericalSample
        computePDF(Gumbel self, NumericalPoint xMin, NumericalPoint xMax, Indices pointNumber, NumericalSample grid) -> NumericalSample
        computePDF(Gumbel self, NumericalPoint point) -> OT::NumericalScalar
        """
        return _dist_bundle1.Gumbel_computePDF(self, *args)

    def computeLogPDF(self, *args):
        """
        computeLogPDF(Gumbel self, OT::NumericalScalar const scalar) -> OT::NumericalScalar
        computeLogPDF(Gumbel self, NumericalPoint point) -> OT::NumericalScalar
        computeLogPDF(Gumbel self, NumericalSample sample) -> NumericalSample
        computeLogPDF(Gumbel self, NumericalPoint point) -> OT::NumericalScalar
        """
        return _dist_bundle1.Gumbel_computeLogPDF(self, *args)

    def computeCDF(self, *args):
        """
        computeCDF(Gumbel self, OT::NumericalScalar const scalar, OT::Bool const tail) -> OT::NumericalScalar
        computeCDF(Gumbel self, OT::NumericalScalar const scalar) -> OT::NumericalScalar
        computeCDF(Gumbel self, NumericalPoint point, OT::Bool const tail) -> OT::NumericalScalar
        computeCDF(Gumbel self, NumericalPoint point) -> OT::NumericalScalar
        computeCDF(Gumbel self, NumericalSample sample, OT::Bool const tail) -> NumericalSample
        computeCDF(Gumbel self, NumericalSample sample) -> NumericalSample
        computeCDF(Gumbel self, OT::NumericalScalar const xMin, OT::NumericalScalar const xMax, OT::UnsignedLong const pointNumber, 
            NumericalSample grid, OT::NumericalScalar const precision=OT::ResourceMap::GetAsNumericalScalar("DistributionImplementation-DefaultCDFEpsilon")) -> NumericalSample
        computeCDF(Gumbel self, OT::NumericalScalar const xMin, OT::NumericalScalar const xMax, OT::UnsignedLong const pointNumber, 
            NumericalSample grid) -> NumericalSample
        computeCDF(Gumbel self, NumericalPoint xMin, NumericalPoint xMax, Indices pointNumber, NumericalSample grid, 
            OT::NumericalScalar const precision=OT::ResourceMap::GetAsNumericalScalar("DistributionImplementation-DefaultCDFEpsilon")) -> NumericalSample
        computeCDF(Gumbel self, NumericalPoint xMin, NumericalPoint xMax, Indices pointNumber, NumericalSample grid) -> NumericalSample
        computeCDF(Gumbel self, NumericalPoint point) -> OT::NumericalScalar
        """
        return _dist_bundle1.Gumbel_computeCDF(self, *args)

    def computeComplementaryCDF(self, *args):
        """
        computeComplementaryCDF(Gumbel self, OT::NumericalScalar const scalar) -> OT::NumericalScalar
        computeComplementaryCDF(Gumbel self, NumericalPoint point) -> OT::NumericalScalar
        computeComplementaryCDF(Gumbel self, NumericalSample sample) -> NumericalSample
        computeComplementaryCDF(Gumbel self, OT::NumericalScalar const xMin, OT::NumericalScalar const xMax, OT::UnsignedLong const pointNumber, 
            NumericalSample grid, OT::NumericalScalar const precision=OT::ResourceMap::GetAsNumericalScalar("DistributionImplementation-DefaultCDFEpsilon")) -> NumericalSample
        computeComplementaryCDF(Gumbel self, OT::NumericalScalar const xMin, OT::NumericalScalar const xMax, OT::UnsignedLong const pointNumber, 
            NumericalSample grid) -> NumericalSample
        computeComplementaryCDF(Gumbel self, NumericalPoint point) -> OT::NumericalScalar
        """
        return _dist_bundle1.Gumbel_computeComplementaryCDF(self, *args)

    def computeCharacteristicFunction(self, *args):
        """computeCharacteristicFunction(Gumbel self, OT::NumericalScalar const x) -> OT::NumericalComplex"""
        return _dist_bundle1.Gumbel_computeCharacteristicFunction(self, *args)

    def computeLogCharacteristicFunction(self, *args):
        """computeLogCharacteristicFunction(Gumbel self, OT::NumericalScalar const x) -> OT::NumericalComplex"""
        return _dist_bundle1.Gumbel_computeLogCharacteristicFunction(self, *args)

    def computePDFGradient(self, *args):
        """computePDFGradient(Gumbel self, NumericalPoint point) -> NumericalPoint"""
        return _dist_bundle1.Gumbel_computePDFGradient(self, *args)

    def computeCDFGradient(self, *args):
        """computeCDFGradient(Gumbel self, NumericalPoint point) -> NumericalPoint"""
        return _dist_bundle1.Gumbel_computeCDFGradient(self, *args)

    def getStandardDeviation(self):
        """getStandardDeviation(Gumbel self) -> NumericalPoint"""
        return _dist_bundle1.Gumbel_getStandardDeviation(self)

    def getSkewness(self):
        """getSkewness(Gumbel self) -> NumericalPoint"""
        return _dist_bundle1.Gumbel_getSkewness(self)

    def getKurtosis(self):
        """getKurtosis(Gumbel self) -> NumericalPoint"""
        return _dist_bundle1.Gumbel_getKurtosis(self)

    def getStandardRepresentative(self):
        """getStandardRepresentative(Gumbel self) -> DistributionImplementationPointer"""
        return _dist_bundle1.Gumbel_getStandardRepresentative(self)

    def getParametersCollection(self):
        """getParametersCollection(Gumbel self) -> NumericalPointWithDescriptionCollection"""
        return _dist_bundle1.Gumbel_getParametersCollection(self)

    def setParametersCollection(self, *args):
        """
        setParametersCollection(Gumbel self, NumericalPointWithDescriptionCollection parametersCollection)
        setParametersCollection(Gumbel self, NumericalPointCollection parametersCollection)
        setParametersCollection(Gumbel self, NumericalPoint parameters)
        setParametersCollection(Gumbel self, NumericalPointCollection parametersCollection)
        """
        return _dist_bundle1.Gumbel_setParametersCollection(self, *args)

    def setAlpha(self, *args):
        """setAlpha(Gumbel self, OT::NumericalScalar const alpha)"""
        return _dist_bundle1.Gumbel_setAlpha(self, *args)

    def getAlpha(self):
        """getAlpha(Gumbel self) -> OT::NumericalScalar"""
        return _dist_bundle1.Gumbel_getAlpha(self)

    def setBeta(self, *args):
        """setBeta(Gumbel self, OT::NumericalScalar const beta)"""
        return _dist_bundle1.Gumbel_setBeta(self, *args)

    def getBeta(self):
        """getBeta(Gumbel self) -> OT::NumericalScalar"""
        return _dist_bundle1.Gumbel_getBeta(self)

    def setMuSigma(self, *args):
        """setMuSigma(Gumbel self, OT::NumericalScalar const mu, OT::NumericalScalar const sigma)"""
        return _dist_bundle1.Gumbel_setMuSigma(self, *args)

    def getMu(self):
        """getMu(Gumbel self) -> OT::NumericalScalar"""
        return _dist_bundle1.Gumbel_getMu(self)

    def getSigma(self):
        """getSigma(Gumbel self) -> OT::NumericalScalar"""
        return _dist_bundle1.Gumbel_getSigma(self)

    def setAB(self, *args):
        """setAB(Gumbel self, OT::NumericalScalar const a, OT::NumericalScalar const b)"""
        return _dist_bundle1.Gumbel_setAB(self, *args)

    def getA(self):
        """getA(Gumbel self) -> OT::NumericalScalar"""
        return _dist_bundle1.Gumbel_getA(self)

    def getB(self):
        """getB(Gumbel self) -> OT::NumericalScalar"""
        return _dist_bundle1.Gumbel_getB(self)

    def __init__(self, *args): 
        """
        __init__(OT::Gumbel self) -> Gumbel
        __init__(OT::Gumbel self, OT::NumericalScalar const arg1, OT::NumericalScalar const arg2, OT::Gumbel::ParameterSet const set=ALPHABETA) -> Gumbel
        __init__(OT::Gumbel self, OT::NumericalScalar const arg1, OT::NumericalScalar const arg2) -> Gumbel
        __init__(OT::Gumbel self, Gumbel other) -> Gumbel
        """
        this = _dist_bundle1.new_Gumbel(*args)
        try: self.this.append(this)
        except: self.this = this
    __swig_destroy__ = _dist_bundle1.delete_Gumbel
    __del__ = lambda self : None;
Gumbel_swigregister = _dist_bundle1.Gumbel_swigregister
Gumbel_swigregister(Gumbel)

def Gumbel_GetClassName():
  """Gumbel_GetClassName() -> OT::String"""
  return _dist_bundle1.Gumbel_GetClassName()

class GumbelFactory(openturns.model_copula.DistributionImplementationFactory):
    """Proxy of C++ OT::GumbelFactory class"""
    __swig_setmethods__ = {}
    for _s in [openturns.model_copula.DistributionImplementationFactory]: __swig_setmethods__.update(getattr(_s,'__swig_setmethods__',{}))
    __setattr__ = lambda self, name, value: _swig_setattr(self, GumbelFactory, name, value)
    __swig_getmethods__ = {}
    for _s in [openturns.model_copula.DistributionImplementationFactory]: __swig_getmethods__.update(getattr(_s,'__swig_getmethods__',{}))
    __getattr__ = lambda self, name: _swig_getattr(self, GumbelFactory, name)
    __repr__ = _swig_repr
    def GetClassName():
        """GetClassName() -> OT::String"""
        return _dist_bundle1.GumbelFactory_GetClassName()

    if _newclass:GetClassName = staticmethod(GetClassName)
    __swig_getmethods__["GetClassName"] = lambda x: GetClassName
    def getClassName(self):
        """getClassName(GumbelFactory self) -> OT::String"""
        return _dist_bundle1.GumbelFactory_getClassName(self)

    def build(self, *args):
        """
        build(GumbelFactory self, NumericalSample sample) -> DistributionImplementationPointer
        build(GumbelFactory self, NumericalSample sample, CovarianceMatrix covariance) -> DistributionImplementationPointer
        build(GumbelFactory self, NumericalPointCollection parameters) -> DistributionImplementationPointer
        build(GumbelFactory self, NumericalPointWithDescriptionCollection parameters) -> DistributionImplementationPointer
        build(GumbelFactory self, NumericalSample sample) -> DistributionImplementationPointer
        build(GumbelFactory self, NumericalPointCollection parameters) -> DistributionImplementationPointer
        build(GumbelFactory self) -> DistributionImplementationPointer
        """
        return _dist_bundle1.GumbelFactory_build(self, *args)

    def buildAsGumbel(self, *args):
        """
        buildAsGumbel(GumbelFactory self, NumericalSample sample) -> Gumbel
        buildAsGumbel(GumbelFactory self, NumericalPointCollection parameters) -> Gumbel
        buildAsGumbel(GumbelFactory self, NumericalPointWithDescriptionCollection parameters) -> Gumbel
        buildAsGumbel(GumbelFactory self) -> Gumbel
        """
        return _dist_bundle1.GumbelFactory_buildAsGumbel(self, *args)

    def __init__(self, *args): 
        """
        __init__(OT::GumbelFactory self) -> GumbelFactory
        __init__(OT::GumbelFactory self, GumbelFactory other) -> GumbelFactory
        """
        this = _dist_bundle1.new_GumbelFactory(*args)
        try: self.this.append(this)
        except: self.this = this
    __swig_destroy__ = _dist_bundle1.delete_GumbelFactory
    __del__ = lambda self : None;
GumbelFactory_swigregister = _dist_bundle1.GumbelFactory_swigregister
GumbelFactory_swigregister(GumbelFactory)

def GumbelFactory_GetClassName():
  """GumbelFactory_GetClassName() -> OT::String"""
  return _dist_bundle1.GumbelFactory_GetClassName()

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