python-openturns 1.2-2 / usr / share / pyshared / openturns / dist_bundle2.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_bundle2', [dirname(__file__)])
        except ImportError:
            import _dist_bundle2
            return _dist_bundle2
        if fp is not None:
            try:
                _mod = imp.load_module('_dist_bundle2', fp, pathname, description)
            finally:
                fp.close()
            return _mod
    _dist_bundle2 = swig_import_helper()
    del swig_import_helper
else:
    import _dist_bundle2
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_bundle2.delete_SwigPyIterator
    __del__ = lambda self : None;
    def value(self):
        """value(SwigPyIterator self) -> PyObject *"""
        return _dist_bundle2.SwigPyIterator_value(self)

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

def TestResult_GetClassName():
  """TestResult_GetClassName() -> OT::String"""
  return _dist_bundle2.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 HistogramPair(openturns.common.PersistentObject):
    """Proxy of C++ OT::HistogramPair class"""
    __swig_setmethods__ = {}
    for _s in [openturns.common.PersistentObject]: __swig_setmethods__.update(getattr(_s,'__swig_setmethods__',{}))
    __setattr__ = lambda self, name, value: _swig_setattr(self, HistogramPair, name, value)
    __swig_getmethods__ = {}
    for _s in [openturns.common.PersistentObject]: __swig_getmethods__.update(getattr(_s,'__swig_getmethods__',{}))
    __getattr__ = lambda self, name: _swig_getattr(self, HistogramPair, name)
    def GetClassName():
        """GetClassName() -> OT::String"""
        return _dist_bundle2.HistogramPair_GetClassName()

    if _newclass:GetClassName = staticmethod(GetClassName)
    __swig_getmethods__["GetClassName"] = lambda x: GetClassName
    def getClassName(self):
        """getClassName(HistogramPair self) -> OT::String"""
        return _dist_bundle2.HistogramPair_getClassName(self)

    def __eq__(self, *args):
        """__eq__(HistogramPair self, HistogramPair other) -> OT::Bool"""
        return _dist_bundle2.HistogramPair___eq__(self, *args)

    def setWidth(self, *args):
        """setWidth(HistogramPair self, OT::NumericalScalar const width)"""
        return _dist_bundle2.HistogramPair_setWidth(self, *args)

    def setHeight(self, *args):
        """setHeight(HistogramPair self, OT::NumericalScalar const height)"""
        return _dist_bundle2.HistogramPair_setHeight(self, *args)

    def getWidth(self):
        """getWidth(HistogramPair self) -> OT::NumericalScalar"""
        return _dist_bundle2.HistogramPair_getWidth(self)

    def getHeight(self):
        """getHeight(HistogramPair self) -> OT::NumericalScalar"""
        return _dist_bundle2.HistogramPair_getHeight(self)

    def getSurface(self):
        """getSurface(HistogramPair self) -> OT::NumericalScalar"""
        return _dist_bundle2.HistogramPair_getSurface(self)

    def __repr__(self):
        """__repr__(HistogramPair self) -> OT::String"""
        return _dist_bundle2.HistogramPair___repr__(self)

    def __init__(self, *args): 
        """
        __init__(OT::HistogramPair self) -> HistogramPair
        __init__(OT::HistogramPair self, OT::NumericalScalar const width, OT::NumericalScalar const height) -> HistogramPair
        __init__(OT::HistogramPair self, HistogramPair other) -> HistogramPair
        """
        this = _dist_bundle2.new_HistogramPair(*args)
        try: self.this.append(this)
        except: self.this = this
    __swig_destroy__ = _dist_bundle2.delete_HistogramPair
    __del__ = lambda self : None;
HistogramPair_swigregister = _dist_bundle2.HistogramPair_swigregister
HistogramPair_swigregister(HistogramPair)

def HistogramPair_GetClassName():
  """HistogramPair_GetClassName() -> OT::String"""
  return _dist_bundle2.HistogramPair_GetClassName()

class Histogram(openturns.model_copula.NonEllipticalDistribution):
    """Proxy of C++ OT::Histogram 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, Histogram, 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, Histogram, name)
    def GetClassName():
        """GetClassName() -> OT::String"""
        return _dist_bundle2.Histogram_GetClassName()

    if _newclass:GetClassName = staticmethod(GetClassName)
    __swig_getmethods__["GetClassName"] = lambda x: GetClassName
    def getClassName(self):
        """getClassName(Histogram self) -> OT::String"""
        return _dist_bundle2.Histogram_getClassName(self)

    def __eq__(self, *args):
        """__eq__(Histogram self, Histogram other) -> OT::Bool"""
        return _dist_bundle2.Histogram___eq__(self, *args)

    def __repr__(self):
        """__repr__(Histogram self) -> OT::String"""
        return _dist_bundle2.Histogram___repr__(self)

    def __str__(self, offset=""):
        """
        __str__(Histogram self, OT::String const & offset="") -> OT::String
        __str__(Histogram self) -> OT::String
        """
        return _dist_bundle2.Histogram___str__(self, offset)

    def getRealization(self):
        """getRealization(Histogram self) -> NumericalPoint"""
        return _dist_bundle2.Histogram_getRealization(self)

    def computeDDF(self, *args):
        """
        computeDDF(Histogram self, OT::NumericalScalar const scalar) -> OT::NumericalScalar
        computeDDF(Histogram self, NumericalPoint point) -> NumericalPoint
        computeDDF(Histogram self, NumericalSample sample) -> NumericalSample
        computeDDF(Histogram self, NumericalPoint point) -> NumericalPoint
        """
        return _dist_bundle2.Histogram_computeDDF(self, *args)

    def computePDF(self, *args):
        """
        computePDF(Histogram self, OT::NumericalScalar const scalar) -> OT::NumericalScalar
        computePDF(Histogram self, NumericalPoint point) -> OT::NumericalScalar
        computePDF(Histogram self, NumericalSample sample) -> NumericalSample
        computePDF(Histogram 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(Histogram self, OT::NumericalScalar const xMin, OT::NumericalScalar const xMax, OT::UnsignedLong const pointNumber, 
            NumericalSample grid) -> NumericalSample
        computePDF(Histogram self, NumericalPoint xMin, NumericalPoint xMax, Indices pointNumber, NumericalSample grid, 
            OT::NumericalScalar const precision=OT::ResourceMap::GetAsNumericalScalar("DistributionImplementation-DefaultPDFEpsilon")) -> NumericalSample
        computePDF(Histogram self, NumericalPoint xMin, NumericalPoint xMax, Indices pointNumber, NumericalSample grid) -> NumericalSample
        computePDF(Histogram self, NumericalPoint point) -> OT::NumericalScalar
        """
        return _dist_bundle2.Histogram_computePDF(self, *args)

    def computeCDF(self, *args):
        """
        computeCDF(Histogram self, OT::NumericalScalar const scalar, OT::Bool const tail) -> OT::NumericalScalar
        computeCDF(Histogram self, OT::NumericalScalar const scalar) -> OT::NumericalScalar
        computeCDF(Histogram self, NumericalPoint point, OT::Bool const tail) -> OT::NumericalScalar
        computeCDF(Histogram self, NumericalPoint point) -> OT::NumericalScalar
        computeCDF(Histogram self, NumericalSample sample, OT::Bool const tail) -> NumericalSample
        computeCDF(Histogram self, NumericalSample sample) -> NumericalSample
        computeCDF(Histogram 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(Histogram self, OT::NumericalScalar const xMin, OT::NumericalScalar const xMax, OT::UnsignedLong const pointNumber, 
            NumericalSample grid) -> NumericalSample
        computeCDF(Histogram self, NumericalPoint xMin, NumericalPoint xMax, Indices pointNumber, NumericalSample grid, 
            OT::NumericalScalar const precision=OT::ResourceMap::GetAsNumericalScalar("DistributionImplementation-DefaultCDFEpsilon")) -> NumericalSample
        computeCDF(Histogram self, NumericalPoint xMin, NumericalPoint xMax, Indices pointNumber, NumericalSample grid) -> NumericalSample
        computeCDF(Histogram self, NumericalPoint point) -> OT::NumericalScalar
        """
        return _dist_bundle2.Histogram_computeCDF(self, *args)

    def computePDFGradient(self, *args):
        """computePDFGradient(Histogram self, NumericalPoint point) -> NumericalPoint"""
        return _dist_bundle2.Histogram_computePDFGradient(self, *args)

    def computeCDFGradient(self, *args):
        """computeCDFGradient(Histogram self, NumericalPoint point) -> NumericalPoint"""
        return _dist_bundle2.Histogram_computeCDFGradient(self, *args)

    def getParametersCollection(self):
        """getParametersCollection(Histogram self) -> NumericalPointWithDescriptionCollection"""
        return _dist_bundle2.Histogram_getParametersCollection(self)

    def setFirst(self, *args):
        """setFirst(Histogram self, OT::NumericalScalar const first)"""
        return _dist_bundle2.Histogram_setFirst(self, *args)

    def getFirst(self):
        """getFirst(Histogram self) -> OT::NumericalScalar"""
        return _dist_bundle2.Histogram_getFirst(self)

    def setPairCollection(self, *args):
        """setPairCollection(Histogram self, HistogramPairCollection collection)"""
        return _dist_bundle2.Histogram_setPairCollection(self, *args)

    def getPairCollection(self):
        """getPairCollection(Histogram self) -> HistogramPairCollection"""
        return _dist_bundle2.Histogram_getPairCollection(self)

    def drawPDF(self, *args):
        """
        drawPDF(Histogram self) -> Graph
        drawPDF(Histogram self, OT::NumericalScalar const xMin, OT::NumericalScalar const xMax, OT::UnsignedLong const pointNumber=OT::ResourceMap::GetAsUnsignedLong("DistributionImplementation-DefaultPointNumber")) -> Graph
        drawPDF(Histogram self, OT::NumericalScalar const xMin, OT::NumericalScalar const xMax) -> Graph
        """
        return _dist_bundle2.Histogram_drawPDF(self, *args)

    def __init__(self, *args): 
        """
        __init__(OT::Histogram self) -> Histogram
        __init__(OT::Histogram self, OT::NumericalScalar const first, HistogramPairCollection collection) -> Histogram
        __init__(OT::Histogram self, OT::NumericalScalar first, HistogramPairCollection collection) -> Histogram
        __init__(OT::Histogram self, Histogram other) -> Histogram
        """
        this = _dist_bundle2.new_Histogram(*args)
        try: self.this.append(this)
        except: self.this = this
    __swig_destroy__ = _dist_bundle2.delete_Histogram
    __del__ = lambda self : None;
Histogram_swigregister = _dist_bundle2.Histogram_swigregister
Histogram_swigregister(Histogram)

def Histogram_GetClassName():
  """Histogram_GetClassName() -> OT::String"""
  return _dist_bundle2.Histogram_GetClassName()

class HistogramPairCollection(_object):
    """Proxy of C++ OT::Collection<(OT::HistogramPair)> class"""
    __swig_setmethods__ = {}
    __setattr__ = lambda self, name, value: _swig_setattr(self, HistogramPairCollection, name, value)
    __swig_getmethods__ = {}
    __getattr__ = lambda self, name: _swig_getattr(self, HistogramPairCollection, name)
    __swig_destroy__ = _dist_bundle2.delete_HistogramPairCollection
    __del__ = lambda self : None;
    def clear(self):
        """clear(HistogramPairCollection self)"""
        return _dist_bundle2.HistogramPairCollection_clear(self)

    def __len__(self):
        """__len__(HistogramPairCollection self) -> OT::UnsignedLong"""
        return _dist_bundle2.HistogramPairCollection___len__(self)

    def __eq__(self, *args):
        """__eq__(HistogramPairCollection self, HistogramPairCollection rhs) -> OT::Bool"""
        return _dist_bundle2.HistogramPairCollection___eq__(self, *args)

    def __contains__(self, *args):
        """__contains__(HistogramPairCollection self, HistogramPair val) -> OT::Bool"""
        return _dist_bundle2.HistogramPairCollection___contains__(self, *args)

    def __getitem__(self, *args):
        """__getitem__(HistogramPairCollection self, OT::UnsignedLong const i) -> HistogramPair"""
        return _dist_bundle2.HistogramPairCollection___getitem__(self, *args)

    def __setitem__(self, *args):
        """__setitem__(HistogramPairCollection self, OT::UnsignedLong const i, HistogramPair val)"""
        return _dist_bundle2.HistogramPairCollection___setitem__(self, *args)

    def __delitem__(self, *args):
        """__delitem__(HistogramPairCollection self, OT::UnsignedLong const i)"""
        return _dist_bundle2.HistogramPairCollection___delitem__(self, *args)

    def at(self, *args):
        """
        at(HistogramPairCollection self, OT::UnsignedLong const i) -> HistogramPair
        at(HistogramPairCollection self, OT::UnsignedLong const i) -> HistogramPair
        """
        return _dist_bundle2.HistogramPairCollection_at(self, *args)

    def add(self, *args):
        """
        add(HistogramPairCollection self, HistogramPair elt)
        add(HistogramPairCollection self, HistogramPairCollection coll)
        """
        return _dist_bundle2.HistogramPairCollection_add(self, *args)

    def getSize(self):
        """getSize(HistogramPairCollection self) -> OT::UnsignedLong"""
        return _dist_bundle2.HistogramPairCollection_getSize(self)

    def resize(self, *args):
        """resize(HistogramPairCollection self, OT::UnsignedLong const newSize)"""
        return _dist_bundle2.HistogramPairCollection_resize(self, *args)

    def isEmpty(self):
        """isEmpty(HistogramPairCollection self) -> OT::Bool"""
        return _dist_bundle2.HistogramPairCollection_isEmpty(self)

    def __repr__(self):
        """__repr__(HistogramPairCollection self) -> OT::String"""
        return _dist_bundle2.HistogramPairCollection___repr__(self)

    def __str__(self, offset=""):
        """
        __str__(HistogramPairCollection self, OT::String const & offset="") -> OT::String
        __str__(HistogramPairCollection self) -> OT::String
        """
        return _dist_bundle2.HistogramPairCollection___str__(self, offset)

    def __init__(self, *args): 
        """
        __init__(OT::Collection<(OT::HistogramPair)> self) -> HistogramPairCollection
        __init__(OT::Collection<(OT::HistogramPair)> self, OT::UnsignedLong const size) -> HistogramPairCollection
        __init__(OT::Collection<(OT::HistogramPair)> self, OT::UnsignedLong const size, HistogramPair value) -> HistogramPairCollection
        __init__(OT::Collection<(OT::HistogramPair)> self, PyObject * pyObj) -> HistogramPairCollection
        __init__(OT::Collection<(OT::HistogramPair)> self, HistogramPairCollection other) -> HistogramPairCollection
        """
        this = _dist_bundle2.new_HistogramPairCollection(*args)
        try: self.this.append(this)
        except: self.this = this
HistogramPairCollection_swigregister = _dist_bundle2.HistogramPairCollection_swigregister
HistogramPairCollection_swigregister(HistogramPairCollection)

class HistogramFactory(openturns.model_copula.DistributionImplementationFactory):
    """Proxy of C++ OT::HistogramFactory 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, HistogramFactory, 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, HistogramFactory, name)
    __repr__ = _swig_repr
    def GetClassName():
        """GetClassName() -> OT::String"""
        return _dist_bundle2.HistogramFactory_GetClassName()

    if _newclass:GetClassName = staticmethod(GetClassName)
    __swig_getmethods__["GetClassName"] = lambda x: GetClassName
    def getClassName(self):
        """getClassName(HistogramFactory self) -> OT::String"""
        return _dist_bundle2.HistogramFactory_getClassName(self)

    def build(self, *args):
        """
        build(HistogramFactory self, NumericalSample sample) -> DistributionImplementationPointer
        build(HistogramFactory self, NumericalSample sample, CovarianceMatrix covariance) -> DistributionImplementationPointer
        build(HistogramFactory self, NumericalPointCollection parameters) -> DistributionImplementationPointer
        build(HistogramFactory self, NumericalPointWithDescriptionCollection parameters) -> DistributionImplementationPointer
        build(HistogramFactory self, NumericalSample sample) -> DistributionImplementationPointer
        build(HistogramFactory self) -> DistributionImplementationPointer
        """
        return _dist_bundle2.HistogramFactory_build(self, *args)

    def buildAsHistogram(self, *args):
        """
        buildAsHistogram(HistogramFactory self, NumericalSample sample) -> Histogram
        buildAsHistogram(HistogramFactory self) -> Histogram
        """
        return _dist_bundle2.HistogramFactory_buildAsHistogram(self, *args)

    def __init__(self, *args): 
        """
        __init__(OT::HistogramFactory self) -> HistogramFactory
        __init__(OT::HistogramFactory self, HistogramFactory other) -> HistogramFactory
        """
        this = _dist_bundle2.new_HistogramFactory(*args)
        try: self.this.append(this)
        except: self.this = this
    __swig_destroy__ = _dist_bundle2.delete_HistogramFactory
    __del__ = lambda self : None;
HistogramFactory_swigregister = _dist_bundle2.HistogramFactory_swigregister
HistogramFactory_swigregister(HistogramFactory)

def HistogramFactory_GetClassName():
  """HistogramFactory_GetClassName() -> OT::String"""
  return _dist_bundle2.HistogramFactory_GetClassName()

class InverseNormal(openturns.model_copula.NonEllipticalDistribution):
    """Proxy of C++ OT::InverseNormal 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, InverseNormal, 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, InverseNormal, name)
    def GetClassName():
        """GetClassName() -> OT::String"""
        return _dist_bundle2.InverseNormal_GetClassName()

    if _newclass:GetClassName = staticmethod(GetClassName)
    __swig_getmethods__["GetClassName"] = lambda x: GetClassName
    def getClassName(self):
        """getClassName(InverseNormal self) -> OT::String"""
        return _dist_bundle2.InverseNormal_getClassName(self)

    def __eq__(self, *args):
        """__eq__(InverseNormal self, InverseNormal other) -> OT::Bool"""
        return _dist_bundle2.InverseNormal___eq__(self, *args)

    def __repr__(self):
        """__repr__(InverseNormal self) -> OT::String"""
        return _dist_bundle2.InverseNormal___repr__(self)

    def __str__(self, offset=""):
        """
        __str__(InverseNormal self, OT::String const & offset="") -> OT::String
        __str__(InverseNormal self) -> OT::String
        """
        return _dist_bundle2.InverseNormal___str__(self, offset)

    def getRealization(self):
        """getRealization(InverseNormal self) -> NumericalPoint"""
        return _dist_bundle2.InverseNormal_getRealization(self)

    def computePDF(self, *args):
        """
        computePDF(InverseNormal self, OT::NumericalScalar const scalar) -> OT::NumericalScalar
        computePDF(InverseNormal self, NumericalPoint point) -> OT::NumericalScalar
        computePDF(InverseNormal self, NumericalSample sample) -> NumericalSample
        computePDF(InverseNormal 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(InverseNormal self, OT::NumericalScalar const xMin, OT::NumericalScalar const xMax, OT::UnsignedLong const pointNumber, 
            NumericalSample grid) -> NumericalSample
        computePDF(InverseNormal self, NumericalPoint xMin, NumericalPoint xMax, Indices pointNumber, NumericalSample grid, 
            OT::NumericalScalar const precision=OT::ResourceMap::GetAsNumericalScalar("DistributionImplementation-DefaultPDFEpsilon")) -> NumericalSample
        computePDF(InverseNormal self, NumericalPoint xMin, NumericalPoint xMax, Indices pointNumber, NumericalSample grid) -> NumericalSample
        computePDF(InverseNormal self, NumericalPoint point) -> OT::NumericalScalar
        """
        return _dist_bundle2.InverseNormal_computePDF(self, *args)

    def computeLogPDF(self, *args):
        """
        computeLogPDF(InverseNormal self, OT::NumericalScalar const scalar) -> OT::NumericalScalar
        computeLogPDF(InverseNormal self, NumericalPoint point) -> OT::NumericalScalar
        computeLogPDF(InverseNormal self, NumericalSample sample) -> NumericalSample
        computeLogPDF(InverseNormal self, NumericalPoint point) -> OT::NumericalScalar
        """
        return _dist_bundle2.InverseNormal_computeLogPDF(self, *args)

    def computeCDF(self, *args):
        """
        computeCDF(InverseNormal self, OT::NumericalScalar const scalar, OT::Bool const tail) -> OT::NumericalScalar
        computeCDF(InverseNormal self, OT::NumericalScalar const scalar) -> OT::NumericalScalar
        computeCDF(InverseNormal self, NumericalPoint point, OT::Bool const tail) -> OT::NumericalScalar
        computeCDF(InverseNormal self, NumericalPoint point) -> OT::NumericalScalar
        computeCDF(InverseNormal self, NumericalSample sample, OT::Bool const tail) -> NumericalSample
        computeCDF(InverseNormal self, NumericalSample sample) -> NumericalSample
        computeCDF(InverseNormal 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(InverseNormal self, OT::NumericalScalar const xMin, OT::NumericalScalar const xMax, OT::UnsignedLong const pointNumber, 
            NumericalSample grid) -> NumericalSample
        computeCDF(InverseNormal self, NumericalPoint xMin, NumericalPoint xMax, Indices pointNumber, NumericalSample grid, 
            OT::NumericalScalar const precision=OT::ResourceMap::GetAsNumericalScalar("DistributionImplementation-DefaultCDFEpsilon")) -> NumericalSample
        computeCDF(InverseNormal self, NumericalPoint xMin, NumericalPoint xMax, Indices pointNumber, NumericalSample grid) -> NumericalSample
        computeCDF(InverseNormal self, NumericalPoint point) -> OT::NumericalScalar
        """
        return _dist_bundle2.InverseNormal_computeCDF(self, *args)

    def computeCharacteristicFunction(self, *args):
        """computeCharacteristicFunction(InverseNormal self, OT::NumericalScalar const x) -> OT::NumericalComplex"""
        return _dist_bundle2.InverseNormal_computeCharacteristicFunction(self, *args)

    def computeLogCharacteristicFunction(self, *args):
        """computeLogCharacteristicFunction(InverseNormal self, OT::NumericalScalar const x) -> OT::NumericalComplex"""
        return _dist_bundle2.InverseNormal_computeLogCharacteristicFunction(self, *args)

    def getStandardDeviation(self):
        """getStandardDeviation(InverseNormal self) -> NumericalPoint"""
        return _dist_bundle2.InverseNormal_getStandardDeviation(self)

    def getSkewness(self):
        """getSkewness(InverseNormal self) -> NumericalPoint"""
        return _dist_bundle2.InverseNormal_getSkewness(self)

    def getKurtosis(self):
        """getKurtosis(InverseNormal self) -> NumericalPoint"""
        return _dist_bundle2.InverseNormal_getKurtosis(self)

    def getStandardMoment(self, *args):
        """getStandardMoment(InverseNormal self, OT::UnsignedLong const n) -> NumericalPoint"""
        return _dist_bundle2.InverseNormal_getStandardMoment(self, *args)

    def setLambdaMu(self, *args):
        """setLambdaMu(InverseNormal self, OT::NumericalScalar const _lambda, OT::NumericalScalar const mu)"""
        return _dist_bundle2.InverseNormal_setLambdaMu(self, *args)

    def getLambda(self):
        """getLambda(InverseNormal self) -> OT::NumericalScalar"""
        return _dist_bundle2.InverseNormal_getLambda(self)

    def getMu(self):
        """getMu(InverseNormal self) -> OT::NumericalScalar"""
        return _dist_bundle2.InverseNormal_getMu(self)

    def getParametersCollection(self):
        """getParametersCollection(InverseNormal self) -> NumericalPointWithDescriptionCollection"""
        return _dist_bundle2.InverseNormal_getParametersCollection(self)

    def setParametersCollection(self, *args):
        """
        setParametersCollection(InverseNormal self, NumericalPointWithDescriptionCollection parametersCollection)
        setParametersCollection(InverseNormal self, NumericalPointCollection parametersCollection)
        setParametersCollection(InverseNormal self, NumericalPoint parameters)
        setParametersCollection(InverseNormal self, NumericalPointCollection parametersCollection)
        """
        return _dist_bundle2.InverseNormal_setParametersCollection(self, *args)

    def __init__(self, *args): 
        """
        __init__(OT::InverseNormal self) -> InverseNormal
        __init__(OT::InverseNormal self, OT::NumericalScalar const _lambda, OT::NumericalScalar const mu) -> InverseNormal
        __init__(OT::InverseNormal self, InverseNormal other) -> InverseNormal
        """
        this = _dist_bundle2.new_InverseNormal(*args)
        try: self.this.append(this)
        except: self.this = this
    __swig_destroy__ = _dist_bundle2.delete_InverseNormal
    __del__ = lambda self : None;
InverseNormal_swigregister = _dist_bundle2.InverseNormal_swigregister
InverseNormal_swigregister(InverseNormal)

def InverseNormal_GetClassName():
  """InverseNormal_GetClassName() -> OT::String"""
  return _dist_bundle2.InverseNormal_GetClassName()

class InverseNormalFactory(openturns.model_copula.DistributionImplementationFactory):
    """Proxy of C++ OT::InverseNormalFactory 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, InverseNormalFactory, 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, InverseNormalFactory, name)
    __repr__ = _swig_repr
    def GetClassName():
        """GetClassName() -> OT::String"""
        return _dist_bundle2.InverseNormalFactory_GetClassName()

    if _newclass:GetClassName = staticmethod(GetClassName)
    __swig_getmethods__["GetClassName"] = lambda x: GetClassName
    def getClassName(self):
        """getClassName(InverseNormalFactory self) -> OT::String"""
        return _dist_bundle2.InverseNormalFactory_getClassName(self)

    def build(self, *args):
        """
        build(InverseNormalFactory self, NumericalSample sample) -> DistributionImplementationPointer
        build(InverseNormalFactory self, NumericalSample sample, CovarianceMatrix covariance) -> DistributionImplementationPointer
        build(InverseNormalFactory self, NumericalPointCollection parameters) -> DistributionImplementationPointer
        build(InverseNormalFactory self, NumericalPointWithDescriptionCollection parameters) -> DistributionImplementationPointer
        build(InverseNormalFactory self, NumericalSample sample) -> DistributionImplementationPointer
        build(InverseNormalFactory self, NumericalPointCollection parameters) -> DistributionImplementationPointer
        build(InverseNormalFactory self) -> DistributionImplementationPointer
        """
        return _dist_bundle2.InverseNormalFactory_build(self, *args)

    def buildAsInverseNormal(self, *args):
        """
        buildAsInverseNormal(InverseNormalFactory self, NumericalSample sample) -> InverseNormal
        buildAsInverseNormal(InverseNormalFactory self, NumericalPointCollection parameters) -> InverseNormal
        buildAsInverseNormal(InverseNormalFactory self, NumericalPointWithDescriptionCollection parameters) -> InverseNormal
        buildAsInverseNormal(InverseNormalFactory self) -> InverseNormal
        """
        return _dist_bundle2.InverseNormalFactory_buildAsInverseNormal(self, *args)

    def __init__(self, *args): 
        """
        __init__(OT::InverseNormalFactory self) -> InverseNormalFactory
        __init__(OT::InverseNormalFactory self, InverseNormalFactory other) -> InverseNormalFactory
        """
        this = _dist_bundle2.new_InverseNormalFactory(*args)
        try: self.this.append(this)
        except: self.this = this
    __swig_destroy__ = _dist_bundle2.delete_InverseNormalFactory
    __del__ = lambda self : None;
InverseNormalFactory_swigregister = _dist_bundle2.InverseNormalFactory_swigregister
InverseNormalFactory_swigregister(InverseNormalFactory)

def InverseNormalFactory_GetClassName():
  """InverseNormalFactory_GetClassName() -> OT::String"""
  return _dist_bundle2.InverseNormalFactory_GetClassName()

class KPermutationsDistribution(openturns.model_copula.DiscreteDistribution):
    """Proxy of C++ OT::KPermutationsDistribution 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, KPermutationsDistribution, 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, KPermutationsDistribution, name)
    def GetClassName():
        """GetClassName() -> OT::String"""
        return _dist_bundle2.KPermutationsDistribution_GetClassName()

    if _newclass:GetClassName = staticmethod(GetClassName)
    __swig_getmethods__["GetClassName"] = lambda x: GetClassName
    def getClassName(self):
        """getClassName(KPermutationsDistribution self) -> OT::String"""
        return _dist_bundle2.KPermutationsDistribution_getClassName(self)

    def __eq__(self, *args):
        """__eq__(KPermutationsDistribution self, KPermutationsDistribution other) -> OT::Bool"""
        return _dist_bundle2.KPermutationsDistribution___eq__(self, *args)

    def __repr__(self):
        """__repr__(KPermutationsDistribution self) -> OT::String"""
        return _dist_bundle2.KPermutationsDistribution___repr__(self)

    def __str__(self, offset=""):
        """
        __str__(KPermutationsDistribution self, OT::String const & offset="") -> OT::String
        __str__(KPermutationsDistribution self) -> OT::String
        """
        return _dist_bundle2.KPermutationsDistribution___str__(self, offset)

    def getRealization(self):
        """getRealization(KPermutationsDistribution self) -> NumericalPoint"""
        return _dist_bundle2.KPermutationsDistribution_getRealization(self)

    def computePDF(self, *args):
        """
        computePDF(KPermutationsDistribution self, OT::NumericalScalar const scalar) -> OT::NumericalScalar
        computePDF(KPermutationsDistribution self, NumericalPoint point) -> OT::NumericalScalar
        computePDF(KPermutationsDistribution self, NumericalSample sample) -> NumericalSample
        computePDF(KPermutationsDistribution 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(KPermutationsDistribution self, OT::NumericalScalar const xMin, OT::NumericalScalar const xMax, OT::UnsignedLong const pointNumber, 
            NumericalSample grid) -> NumericalSample
        computePDF(KPermutationsDistribution self, NumericalPoint xMin, NumericalPoint xMax, Indices pointNumber, NumericalSample grid, 
            OT::NumericalScalar const precision=OT::ResourceMap::GetAsNumericalScalar("DistributionImplementation-DefaultPDFEpsilon")) -> NumericalSample
        computePDF(KPermutationsDistribution self, NumericalPoint xMin, NumericalPoint xMax, Indices pointNumber, NumericalSample grid) -> NumericalSample
        computePDF(KPermutationsDistribution self, NumericalPoint point) -> OT::NumericalScalar
        """
        return _dist_bundle2.KPermutationsDistribution_computePDF(self, *args)

    def computeLogPDF(self, *args):
        """
        computeLogPDF(KPermutationsDistribution self, OT::NumericalScalar const scalar) -> OT::NumericalScalar
        computeLogPDF(KPermutationsDistribution self, NumericalPoint point) -> OT::NumericalScalar
        computeLogPDF(KPermutationsDistribution self, NumericalSample sample) -> NumericalSample
        computeLogPDF(KPermutationsDistribution self, NumericalPoint point) -> OT::NumericalScalar
        """
        return _dist_bundle2.KPermutationsDistribution_computeLogPDF(self, *args)

    def computeCDF(self, *args):
        """
        computeCDF(KPermutationsDistribution self, OT::NumericalScalar const scalar, OT::Bool const tail) -> OT::NumericalScalar
        computeCDF(KPermutationsDistribution self, OT::NumericalScalar const scalar) -> OT::NumericalScalar
        computeCDF(KPermutationsDistribution self, NumericalPoint point, OT::Bool const tail) -> OT::NumericalScalar
        computeCDF(KPermutationsDistribution self, NumericalPoint point) -> OT::NumericalScalar
        computeCDF(KPermutationsDistribution self, NumericalSample sample, OT::Bool const tail) -> NumericalSample
        computeCDF(KPermutationsDistribution self, NumericalSample sample) -> NumericalSample
        computeCDF(KPermutationsDistribution 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(KPermutationsDistribution self, OT::NumericalScalar const xMin, OT::NumericalScalar const xMax, OT::UnsignedLong const pointNumber, 
            NumericalSample grid) -> NumericalSample
        computeCDF(KPermutationsDistribution self, NumericalPoint xMin, NumericalPoint xMax, Indices pointNumber, NumericalSample grid, 
            OT::NumericalScalar const precision=OT::ResourceMap::GetAsNumericalScalar("DistributionImplementation-DefaultCDFEpsilon")) -> NumericalSample
        computeCDF(KPermutationsDistribution self, NumericalPoint xMin, NumericalPoint xMax, Indices pointNumber, NumericalSample grid) -> NumericalSample
        computeCDF(KPermutationsDistribution self, NumericalPoint point) -> OT::NumericalScalar
        """
        return _dist_bundle2.KPermutationsDistribution_computeCDF(self, *args)

    def getMarginal(self, *args):
        """
        getMarginal(KPermutationsDistribution self, OT::UnsignedLong const i) -> DistributionImplementationPointer
        getMarginal(KPermutationsDistribution self, Indices indices) -> DistributionImplementationPointer
        getMarginal(KPermutationsDistribution self, OT::UnsignedLong const i) -> DistributionImplementationPointer
        getMarginal(KPermutationsDistribution self, Indices indices) -> DistributionImplementationPointer
        """
        return _dist_bundle2.KPermutationsDistribution_getMarginal(self, *args)

    def getSupport(self, *args):
        """
        getSupport(KPermutationsDistribution self, Interval interval) -> NumericalSample
        getSupport(KPermutationsDistribution self) -> NumericalSample
        getSupport(KPermutationsDistribution self, Interval interval) -> NumericalSample
        """
        return _dist_bundle2.KPermutationsDistribution_getSupport(self, *args)

    def getParametersCollection(self):
        """getParametersCollection(KPermutationsDistribution self) -> NumericalPointWithDescriptionCollection"""
        return _dist_bundle2.KPermutationsDistribution_getParametersCollection(self)

    def setK(self, *args):
        """setK(KPermutationsDistribution self, OT::UnsignedLong const k)"""
        return _dist_bundle2.KPermutationsDistribution_setK(self, *args)

    def getK(self):
        """getK(KPermutationsDistribution self) -> OT::UnsignedLong"""
        return _dist_bundle2.KPermutationsDistribution_getK(self)

    def setN(self, *args):
        """setN(KPermutationsDistribution self, OT::UnsignedLong const n)"""
        return _dist_bundle2.KPermutationsDistribution_setN(self, *args)

    def getN(self):
        """getN(KPermutationsDistribution self) -> OT::UnsignedLong"""
        return _dist_bundle2.KPermutationsDistribution_getN(self)

    def __init__(self, *args): 
        """
        __init__(OT::KPermutationsDistribution self) -> KPermutationsDistribution
        __init__(OT::KPermutationsDistribution self, OT::UnsignedLong const k, OT::UnsignedLong const n) -> KPermutationsDistribution
        __init__(OT::KPermutationsDistribution self, KPermutationsDistribution other) -> KPermutationsDistribution
        """
        this = _dist_bundle2.new_KPermutationsDistribution(*args)
        try: self.this.append(this)
        except: self.this = this
    __swig_destroy__ = _dist_bundle2.delete_KPermutationsDistribution
    __del__ = lambda self : None;
KPermutationsDistribution_swigregister = _dist_bundle2.KPermutationsDistribution_swigregister
KPermutationsDistribution_swigregister(KPermutationsDistribution)

def KPermutationsDistribution_GetClassName():
  """KPermutationsDistribution_GetClassName() -> OT::String"""
  return _dist_bundle2.KPermutationsDistribution_GetClassName()

class KernelMixture(openturns.model_copula.NonEllipticalDistribution):
    """Proxy of C++ OT::KernelMixture 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, KernelMixture, 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, KernelMixture, name)
    def GetClassName():
        """GetClassName() -> OT::String"""
        return _dist_bundle2.KernelMixture_GetClassName()

    if _newclass:GetClassName = staticmethod(GetClassName)
    __swig_getmethods__["GetClassName"] = lambda x: GetClassName
    def getClassName(self):
        """getClassName(KernelMixture self) -> OT::String"""
        return _dist_bundle2.KernelMixture_getClassName(self)

    def __eq__(self, *args):
        """__eq__(KernelMixture self, KernelMixture other) -> OT::Bool"""
        return _dist_bundle2.KernelMixture___eq__(self, *args)

    def __repr__(self):
        """__repr__(KernelMixture self) -> OT::String"""
        return _dist_bundle2.KernelMixture___repr__(self)

    def __str__(self, offset=""):
        """
        __str__(KernelMixture self, OT::String const & offset="") -> OT::String
        __str__(KernelMixture self) -> OT::String
        """
        return _dist_bundle2.KernelMixture___str__(self, offset)

    def setKernel(self, *args):
        """setKernel(KernelMixture self, Distribution kernel)"""
        return _dist_bundle2.KernelMixture_setKernel(self, *args)

    def getKernel(self):
        """getKernel(KernelMixture self) -> Distribution"""
        return _dist_bundle2.KernelMixture_getKernel(self)

    def setBandwidth(self, *args):
        """setBandwidth(KernelMixture self, NumericalPoint bandwidth)"""
        return _dist_bundle2.KernelMixture_setBandwidth(self, *args)

    def getBandwidth(self):
        """getBandwidth(KernelMixture self) -> NumericalPoint"""
        return _dist_bundle2.KernelMixture_getBandwidth(self)

    def setInternalSample(self, *args):
        """setInternalSample(KernelMixture self, NumericalSample sample)"""
        return _dist_bundle2.KernelMixture_setInternalSample(self, *args)

    def getInternalSample(self):
        """getInternalSample(KernelMixture self) -> NumericalSample"""
        return _dist_bundle2.KernelMixture_getInternalSample(self)

    def getRealization(self):
        """getRealization(KernelMixture self) -> NumericalPoint"""
        return _dist_bundle2.KernelMixture_getRealization(self)

    def computeDDF(self, *args):
        """
        computeDDF(KernelMixture self, OT::NumericalScalar const scalar) -> OT::NumericalScalar
        computeDDF(KernelMixture self, NumericalPoint point) -> NumericalPoint
        computeDDF(KernelMixture self, NumericalSample sample) -> NumericalSample
        computeDDF(KernelMixture self, NumericalPoint point) -> NumericalPoint
        """
        return _dist_bundle2.KernelMixture_computeDDF(self, *args)

    def computePDF(self, *args):
        """
        computePDF(KernelMixture self, OT::NumericalScalar const scalar) -> OT::NumericalScalar
        computePDF(KernelMixture self, NumericalPoint point) -> OT::NumericalScalar
        computePDF(KernelMixture self, NumericalSample sample) -> NumericalSample
        computePDF(KernelMixture 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(KernelMixture self, OT::NumericalScalar const xMin, OT::NumericalScalar const xMax, OT::UnsignedLong const pointNumber, 
            NumericalSample grid) -> NumericalSample
        computePDF(KernelMixture self, NumericalPoint xMin, NumericalPoint xMax, Indices pointNumber, NumericalSample grid, 
            OT::NumericalScalar const precision=OT::ResourceMap::GetAsNumericalScalar("DistributionImplementation-DefaultPDFEpsilon")) -> NumericalSample
        computePDF(KernelMixture self, NumericalPoint xMin, NumericalPoint xMax, Indices pointNumber, NumericalSample grid) -> NumericalSample
        computePDF(KernelMixture self, NumericalPoint point) -> OT::NumericalScalar
        """
        return _dist_bundle2.KernelMixture_computePDF(self, *args)

    def computeCDF(self, *args):
        """
        computeCDF(KernelMixture self, OT::NumericalScalar const scalar, OT::Bool const tail) -> OT::NumericalScalar
        computeCDF(KernelMixture self, OT::NumericalScalar const scalar) -> OT::NumericalScalar
        computeCDF(KernelMixture self, NumericalPoint point, OT::Bool const tail) -> OT::NumericalScalar
        computeCDF(KernelMixture self, NumericalPoint point) -> OT::NumericalScalar
        computeCDF(KernelMixture self, NumericalSample sample, OT::Bool const tail) -> NumericalSample
        computeCDF(KernelMixture self, NumericalSample sample) -> NumericalSample
        computeCDF(KernelMixture 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(KernelMixture self, OT::NumericalScalar const xMin, OT::NumericalScalar const xMax, OT::UnsignedLong const pointNumber, 
            NumericalSample grid) -> NumericalSample
        computeCDF(KernelMixture self, NumericalPoint xMin, NumericalPoint xMax, Indices pointNumber, NumericalSample grid, 
            OT::NumericalScalar const precision=OT::ResourceMap::GetAsNumericalScalar("DistributionImplementation-DefaultCDFEpsilon")) -> NumericalSample
        computeCDF(KernelMixture self, NumericalPoint xMin, NumericalPoint xMax, Indices pointNumber, NumericalSample grid) -> NumericalSample
        computeCDF(KernelMixture self, NumericalPoint point) -> OT::NumericalScalar
        """
        return _dist_bundle2.KernelMixture_computeCDF(self, *args)

    def computeCharacteristicFunction(self, *args):
        """computeCharacteristicFunction(KernelMixture self, OT::NumericalScalar const x) -> OT::NumericalComplex"""
        return _dist_bundle2.KernelMixture_computeCharacteristicFunction(self, *args)

    def computePDFGradient(self, *args):
        """computePDFGradient(KernelMixture self, NumericalPoint point) -> NumericalPoint"""
        return _dist_bundle2.KernelMixture_computePDFGradient(self, *args)

    def computeCDFGradient(self, *args):
        """computeCDFGradient(KernelMixture self, NumericalPoint point) -> NumericalPoint"""
        return _dist_bundle2.KernelMixture_computeCDFGradient(self, *args)

    def getMarginal(self, *args):
        """
        getMarginal(KernelMixture self, OT::UnsignedLong const i) -> DistributionImplementationPointer
        getMarginal(KernelMixture self, Indices indices) -> DistributionImplementationPointer
        """
        return _dist_bundle2.KernelMixture_getMarginal(self, *args)

    def getStandardDeviation(self):
        """getStandardDeviation(KernelMixture self) -> NumericalPoint"""
        return _dist_bundle2.KernelMixture_getStandardDeviation(self)

    def getSkewness(self):
        """getSkewness(KernelMixture self) -> NumericalPoint"""
        return _dist_bundle2.KernelMixture_getSkewness(self)

    def getKurtosis(self):
        """getKurtosis(KernelMixture self) -> NumericalPoint"""
        return _dist_bundle2.KernelMixture_getKurtosis(self)

    def getParametersCollection(self):
        """getParametersCollection(KernelMixture self) -> NumericalPointWithDescriptionCollection"""
        return _dist_bundle2.KernelMixture_getParametersCollection(self)

    def isElliptical(self):
        """isElliptical(KernelMixture self) -> OT::Bool"""
        return _dist_bundle2.KernelMixture_isElliptical(self)

    def isContinuous(self):
        """isContinuous(KernelMixture self) -> OT::Bool"""
        return _dist_bundle2.KernelMixture_isContinuous(self)

    def hasEllipticalCopula(self):
        """hasEllipticalCopula(KernelMixture self) -> OT::Bool"""
        return _dist_bundle2.KernelMixture_hasEllipticalCopula(self)

    def hasIndependentCopula(self):
        """hasIndependentCopula(KernelMixture self) -> OT::Bool"""
        return _dist_bundle2.KernelMixture_hasIndependentCopula(self)

    def __init__(self, *args): 
        """
        __init__(OT::KernelMixture self, Distribution kernel, NumericalPoint bandwidth, NumericalSample sample) -> KernelMixture
        __init__(OT::KernelMixture self, KernelMixture other) -> KernelMixture
        __init__(OT::KernelMixture self, DistributionImplementation kernel, NumericalPoint bandwidth, NumericalSample sample) -> KernelMixture
        """
        this = _dist_bundle2.new_KernelMixture(*args)
        try: self.this.append(this)
        except: self.this = this
    __swig_destroy__ = _dist_bundle2.delete_KernelMixture
    __del__ = lambda self : None;
KernelMixture_swigregister = _dist_bundle2.KernelMixture_swigregister
KernelMixture_swigregister(KernelMixture)

def KernelMixture_GetClassName():
  """KernelMixture_GetClassName() -> OT::String"""
  return _dist_bundle2.KernelMixture_GetClassName()

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

    if _newclass:GetClassName = staticmethod(GetClassName)
    __swig_getmethods__["GetClassName"] = lambda x: GetClassName
    def getClassName(self):
        """getClassName(KernelSmoothing self) -> OT::String"""
        return _dist_bundle2.KernelSmoothing_getClassName(self)

    def build(self, *args):
        """
        build(KernelSmoothing self, NumericalSample sample, OT::Bool const boundaryCorrection=False) -> Distribution
        build(KernelSmoothing self, NumericalSample sample) -> Distribution
        build(KernelSmoothing self, NumericalSample sample, NumericalPoint bandwidth, OT::Bool const boundaryCorrection=False) -> Distribution
        build(KernelSmoothing self, NumericalSample sample, NumericalPoint bandwidth) -> Distribution
        """
        return _dist_bundle2.KernelSmoothing_build(self, *args)

    def getBandwidth(self):
        """getBandwidth(KernelSmoothing self) -> NumericalPoint"""
        return _dist_bundle2.KernelSmoothing_getBandwidth(self)

    def getKernel(self):
        """getKernel(KernelSmoothing self) -> Distribution"""
        return _dist_bundle2.KernelSmoothing_getKernel(self)

    def computeSilvermanBandwidth(self, *args):
        """computeSilvermanBandwidth(KernelSmoothing self, NumericalSample sample) -> NumericalPoint"""
        return _dist_bundle2.KernelSmoothing_computeSilvermanBandwidth(self, *args)

    def computePluginBandwidth(self, *args):
        """computePluginBandwidth(KernelSmoothing self, NumericalSample sample) -> NumericalPoint"""
        return _dist_bundle2.KernelSmoothing_computePluginBandwidth(self, *args)

    def computeMixedBandwidth(self, *args):
        """computeMixedBandwidth(KernelSmoothing self, NumericalSample sample) -> NumericalPoint"""
        return _dist_bundle2.KernelSmoothing_computeMixedBandwidth(self, *args)

    def __init__(self, *args): 
        """
        __init__(OT::KernelSmoothing self, OT::String const & name="KernelSmoothing") -> KernelSmoothing
        __init__(OT::KernelSmoothing self) -> KernelSmoothing
        __init__(OT::KernelSmoothing self, Distribution kernel, OT::Bool const & bined=True, OT::UnsignedLong const binNumber=OT::ResourceMap::GetAsUnsignedLong( "KernelSmoothing-BinNumber" ), 
            OT::String const & name="KernelSmoothing") -> KernelSmoothing
        __init__(OT::KernelSmoothing self, Distribution kernel, OT::Bool const & bined=True, OT::UnsignedLong const binNumber=OT::ResourceMap::GetAsUnsignedLong( "KernelSmoothing-BinNumber" )) -> KernelSmoothing
        __init__(OT::KernelSmoothing self, Distribution kernel, OT::Bool const & bined=True) -> KernelSmoothing
        __init__(OT::KernelSmoothing self, Distribution kernel) -> KernelSmoothing
        __init__(OT::KernelSmoothing self, KernelSmoothing other) -> KernelSmoothing
        """
        this = _dist_bundle2.new_KernelSmoothing(*args)
        try: self.this.append(this)
        except: self.this = this
    __swig_destroy__ = _dist_bundle2.delete_KernelSmoothing
    __del__ = lambda self : None;
KernelSmoothing_swigregister = _dist_bundle2.KernelSmoothing_swigregister
KernelSmoothing_swigregister(KernelSmoothing)

def KernelSmoothing_GetClassName():
  """KernelSmoothing_GetClassName() -> OT::String"""
  return _dist_bundle2.KernelSmoothing_GetClassName()

class Laplace(openturns.model_copula.NonEllipticalDistribution):
    """Proxy of C++ OT::Laplace 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, Laplace, 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, Laplace, name)
    def GetClassName():
        """GetClassName() -> OT::String"""
        return _dist_bundle2.Laplace_GetClassName()

    if _newclass:GetClassName = staticmethod(GetClassName)
    __swig_getmethods__["GetClassName"] = lambda x: GetClassName
    def getClassName(self):
        """getClassName(Laplace self) -> OT::String"""
        return _dist_bundle2.Laplace_getClassName(self)

    def __eq__(self, *args):
        """__eq__(Laplace self, Laplace other) -> OT::Bool"""
        return _dist_bundle2.Laplace___eq__(self, *args)

    def __repr__(self):
        """__repr__(Laplace self) -> OT::String"""
        return _dist_bundle2.Laplace___repr__(self)

    def __str__(self, offset=""):
        """
        __str__(Laplace self, OT::String const & offset="") -> OT::String
        __str__(Laplace self) -> OT::String
        """
        return _dist_bundle2.Laplace___str__(self, offset)

    def getRealization(self):
        """getRealization(Laplace self) -> NumericalPoint"""
        return _dist_bundle2.Laplace_getRealization(self)

    def computeDDF(self, *args):
        """
        computeDDF(Laplace self, OT::NumericalScalar const scalar) -> OT::NumericalScalar
        computeDDF(Laplace self, NumericalPoint point) -> NumericalPoint
        computeDDF(Laplace self, NumericalSample sample) -> NumericalSample
        computeDDF(Laplace self, NumericalPoint point) -> NumericalPoint
        """
        return _dist_bundle2.Laplace_computeDDF(self, *args)

    def computePDF(self, *args):
        """
        computePDF(Laplace self, OT::NumericalScalar const scalar) -> OT::NumericalScalar
        computePDF(Laplace self, NumericalPoint point) -> OT::NumericalScalar
        computePDF(Laplace self, NumericalSample sample) -> NumericalSample
        computePDF(Laplace 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(Laplace self, OT::NumericalScalar const xMin, OT::NumericalScalar const xMax, OT::UnsignedLong const pointNumber, 
            NumericalSample grid) -> NumericalSample
        computePDF(Laplace self, NumericalPoint xMin, NumericalPoint xMax, Indices pointNumber, NumericalSample grid, 
            OT::NumericalScalar const precision=OT::ResourceMap::GetAsNumericalScalar("DistributionImplementation-DefaultPDFEpsilon")) -> NumericalSample
        computePDF(Laplace self, NumericalPoint xMin, NumericalPoint xMax, Indices pointNumber, NumericalSample grid) -> NumericalSample
        computePDF(Laplace self, NumericalPoint point) -> OT::NumericalScalar
        """
        return _dist_bundle2.Laplace_computePDF(self, *args)

    def computeLogPDF(self, *args):
        """
        computeLogPDF(Laplace self, OT::NumericalScalar const scalar) -> OT::NumericalScalar
        computeLogPDF(Laplace self, NumericalPoint point) -> OT::NumericalScalar
        computeLogPDF(Laplace self, NumericalSample sample) -> NumericalSample
        computeLogPDF(Laplace self, NumericalPoint point) -> OT::NumericalScalar
        """
        return _dist_bundle2.Laplace_computeLogPDF(self, *args)

    def computeCDF(self, *args):
        """
        computeCDF(Laplace self, OT::NumericalScalar const scalar, OT::Bool const tail) -> OT::NumericalScalar
        computeCDF(Laplace self, OT::NumericalScalar const scalar) -> OT::NumericalScalar
        computeCDF(Laplace self, NumericalPoint point, OT::Bool const tail) -> OT::NumericalScalar
        computeCDF(Laplace self, NumericalPoint point) -> OT::NumericalScalar
        computeCDF(Laplace self, NumericalSample sample, OT::Bool const tail) -> NumericalSample
        computeCDF(Laplace self, NumericalSample sample) -> NumericalSample
        computeCDF(Laplace 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(Laplace self, OT::NumericalScalar const xMin, OT::NumericalScalar const xMax, OT::UnsignedLong const pointNumber, 
            NumericalSample grid) -> NumericalSample
        computeCDF(Laplace self, NumericalPoint xMin, NumericalPoint xMax, Indices pointNumber, NumericalSample grid, 
            OT::NumericalScalar const precision=OT::ResourceMap::GetAsNumericalScalar("DistributionImplementation-DefaultCDFEpsilon")) -> NumericalSample
        computeCDF(Laplace self, NumericalPoint xMin, NumericalPoint xMax, Indices pointNumber, NumericalSample grid) -> NumericalSample
        computeCDF(Laplace self, NumericalPoint point) -> OT::NumericalScalar
        """
        return _dist_bundle2.Laplace_computeCDF(self, *args)

    def computeCharacteristicFunction(self, *args):
        """computeCharacteristicFunction(Laplace self, OT::NumericalScalar const x) -> OT::NumericalComplex"""
        return _dist_bundle2.Laplace_computeCharacteristicFunction(self, *args)

    def computeLogCharacteristicFunction(self, *args):
        """computeLogCharacteristicFunction(Laplace self, OT::NumericalScalar const x) -> OT::NumericalComplex"""
        return _dist_bundle2.Laplace_computeLogCharacteristicFunction(self, *args)

    def computePDFGradient(self, *args):
        """computePDFGradient(Laplace self, NumericalPoint point) -> NumericalPoint"""
        return _dist_bundle2.Laplace_computePDFGradient(self, *args)

    def computeCDFGradient(self, *args):
        """computeCDFGradient(Laplace self, NumericalPoint point) -> NumericalPoint"""
        return _dist_bundle2.Laplace_computeCDFGradient(self, *args)

    def getStandardDeviation(self):
        """getStandardDeviation(Laplace self) -> NumericalPoint"""
        return _dist_bundle2.Laplace_getStandardDeviation(self)

    def getSkewness(self):
        """getSkewness(Laplace self) -> NumericalPoint"""
        return _dist_bundle2.Laplace_getSkewness(self)

    def getKurtosis(self):
        """getKurtosis(Laplace self) -> NumericalPoint"""
        return _dist_bundle2.Laplace_getKurtosis(self)

    def getStandardMoment(self, *args):
        """getStandardMoment(Laplace self, OT::UnsignedLong const n) -> NumericalPoint"""
        return _dist_bundle2.Laplace_getStandardMoment(self, *args)

    def getStandardRepresentative(self):
        """getStandardRepresentative(Laplace self) -> DistributionImplementationPointer"""
        return _dist_bundle2.Laplace_getStandardRepresentative(self)

    def getParametersCollection(self):
        """getParametersCollection(Laplace self) -> NumericalPointWithDescriptionCollection"""
        return _dist_bundle2.Laplace_getParametersCollection(self)

    def setParametersCollection(self, *args):
        """
        setParametersCollection(Laplace self, NumericalPointWithDescriptionCollection parametersCollection)
        setParametersCollection(Laplace self, NumericalPointCollection parametersCollection)
        setParametersCollection(Laplace self, NumericalPoint parameters)
        setParametersCollection(Laplace self, NumericalPointCollection parametersCollection)
        """
        return _dist_bundle2.Laplace_setParametersCollection(self, *args)

    def setMu(self, *args):
        """setMu(Laplace self, OT::NumericalScalar const mu)"""
        return _dist_bundle2.Laplace_setMu(self, *args)

    def getMu(self):
        """getMu(Laplace self) -> OT::NumericalScalar"""
        return _dist_bundle2.Laplace_getMu(self)

    def setLambda(self, *args):
        """setLambda(Laplace self, OT::NumericalScalar const _lambda)"""
        return _dist_bundle2.Laplace_setLambda(self, *args)

    def getLambda(self):
        """getLambda(Laplace self) -> OT::NumericalScalar"""
        return _dist_bundle2.Laplace_getLambda(self)

    def __init__(self, *args): 
        """
        __init__(OT::Laplace self) -> Laplace
        __init__(OT::Laplace self, OT::NumericalScalar const _lambda, OT::NumericalScalar const mu=0.0) -> Laplace
        __init__(OT::Laplace self, OT::NumericalScalar const _lambda) -> Laplace
        __init__(OT::Laplace self, Laplace other) -> Laplace
        """
        this = _dist_bundle2.new_Laplace(*args)
        try: self.this.append(this)
        except: self.this = this
    __swig_destroy__ = _dist_bundle2.delete_Laplace
    __del__ = lambda self : None;
Laplace_swigregister = _dist_bundle2.Laplace_swigregister
Laplace_swigregister(Laplace)

def Laplace_GetClassName():
  """Laplace_GetClassName() -> OT::String"""
  return _dist_bundle2.Laplace_GetClassName()

class LaplaceFactory(openturns.model_copula.DistributionImplementationFactory):
    """Proxy of C++ OT::LaplaceFactory 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, LaplaceFactory, 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, LaplaceFactory, name)
    __repr__ = _swig_repr
    def GetClassName():
        """GetClassName() -> OT::String"""
        return _dist_bundle2.LaplaceFactory_GetClassName()

    if _newclass:GetClassName = staticmethod(GetClassName)
    __swig_getmethods__["GetClassName"] = lambda x: GetClassName
    def getClassName(self):
        """getClassName(LaplaceFactory self) -> OT::String"""
        return _dist_bundle2.LaplaceFactory_getClassName(self)

    def build(self, *args):
        """
        build(LaplaceFactory self, NumericalSample sample) -> DistributionImplementationPointer
        build(LaplaceFactory self, NumericalSample sample, CovarianceMatrix covariance) -> DistributionImplementationPointer
        build(LaplaceFactory self, NumericalPointCollection parameters) -> DistributionImplementationPointer
        build(LaplaceFactory self, NumericalPointWithDescriptionCollection parameters) -> DistributionImplementationPointer
        build(LaplaceFactory self, NumericalSample sample) -> DistributionImplementationPointer
        build(LaplaceFactory self, NumericalPointCollection parameters) -> DistributionImplementationPointer
        build(LaplaceFactory self) -> DistributionImplementationPointer
        """
        return _dist_bundle2.LaplaceFactory_build(self, *args)

    def buildAsLaplace(self, *args):
        """
        buildAsLaplace(LaplaceFactory self, NumericalSample sample) -> Laplace
        buildAsLaplace(LaplaceFactory self, NumericalPointCollection parameters) -> Laplace
        buildAsLaplace(LaplaceFactory self, NumericalPointWithDescriptionCollection parameters) -> Laplace
        buildAsLaplace(LaplaceFactory self) -> Laplace
        """
        return _dist_bundle2.LaplaceFactory_buildAsLaplace(self, *args)

    def __init__(self, *args): 
        """
        __init__(OT::LaplaceFactory self) -> LaplaceFactory
        __init__(OT::LaplaceFactory self, LaplaceFactory other) -> LaplaceFactory
        """
        this = _dist_bundle2.new_LaplaceFactory(*args)
        try: self.this.append(this)
        except: self.this = this
    __swig_destroy__ = _dist_bundle2.delete_LaplaceFactory
    __del__ = lambda self : None;
LaplaceFactory_swigregister = _dist_bundle2.LaplaceFactory_swigregister
LaplaceFactory_swigregister(LaplaceFactory)

def LaplaceFactory_GetClassName():
  """LaplaceFactory_GetClassName() -> OT::String"""
  return _dist_bundle2.LaplaceFactory_GetClassName()

class Logistic(openturns.model_copula.NonEllipticalDistribution):
    """Proxy of C++ OT::Logistic 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, Logistic, 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, Logistic, name)
    def GetClassName():
        """GetClassName() -> OT::String"""
        return _dist_bundle2.Logistic_GetClassName()

    if _newclass:GetClassName = staticmethod(GetClassName)
    __swig_getmethods__["GetClassName"] = lambda x: GetClassName
    def getClassName(self):
        """getClassName(Logistic self) -> OT::String"""
        return _dist_bundle2.Logistic_getClassName(self)

    def __eq__(self, *args):
        """__eq__(Logistic self, Logistic other) -> OT::Bool"""
        return _dist_bundle2.Logistic___eq__(self, *args)

    def __repr__(self):
        """__repr__(Logistic self) -> OT::String"""
        return _dist_bundle2.Logistic___repr__(self)

    def __str__(self, offset=""):
        """
        __str__(Logistic self, OT::String const & offset="") -> OT::String
        __str__(Logistic self) -> OT::String
        """
        return _dist_bundle2.Logistic___str__(self, offset)

    def getRealization(self):
        """getRealization(Logistic self) -> NumericalPoint"""
        return _dist_bundle2.Logistic_getRealization(self)

    def computeDDF(self, *args):
        """
        computeDDF(Logistic self, OT::NumericalScalar const scalar) -> OT::NumericalScalar
        computeDDF(Logistic self, NumericalPoint point) -> NumericalPoint
        computeDDF(Logistic self, NumericalSample sample) -> NumericalSample
        computeDDF(Logistic self, NumericalPoint point) -> NumericalPoint
        """
        return _dist_bundle2.Logistic_computeDDF(self, *args)

    def computePDF(self, *args):
        """
        computePDF(Logistic self, OT::NumericalScalar const scalar) -> OT::NumericalScalar
        computePDF(Logistic self, NumericalPoint point) -> OT::NumericalScalar
        computePDF(Logistic self, NumericalSample sample) -> NumericalSample
        computePDF(Logistic 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(Logistic self, OT::NumericalScalar const xMin, OT::NumericalScalar const xMax, OT::UnsignedLong const pointNumber, 
            NumericalSample grid) -> NumericalSample
        computePDF(Logistic self, NumericalPoint xMin, NumericalPoint xMax, Indices pointNumber, NumericalSample grid, 
            OT::NumericalScalar const precision=OT::ResourceMap::GetAsNumericalScalar("DistributionImplementation-DefaultPDFEpsilon")) -> NumericalSample
        computePDF(Logistic self, NumericalPoint xMin, NumericalPoint xMax, Indices pointNumber, NumericalSample grid) -> NumericalSample
        computePDF(Logistic self, NumericalPoint point) -> OT::NumericalScalar
        """
        return _dist_bundle2.Logistic_computePDF(self, *args)

    def computeLogPDF(self, *args):
        """
        computeLogPDF(Logistic self, OT::NumericalScalar const scalar) -> OT::NumericalScalar
        computeLogPDF(Logistic self, NumericalPoint point) -> OT::NumericalScalar
        computeLogPDF(Logistic self, NumericalSample sample) -> NumericalSample
        computeLogPDF(Logistic self, NumericalPoint point) -> OT::NumericalScalar
        """
        return _dist_bundle2.Logistic_computeLogPDF(self, *args)

    def computeCDF(self, *args):
        """
        computeCDF(Logistic self, OT::NumericalScalar const scalar, OT::Bool const tail) -> OT::NumericalScalar
        computeCDF(Logistic self, OT::NumericalScalar const scalar) -> OT::NumericalScalar
        computeCDF(Logistic self, NumericalPoint point, OT::Bool const tail) -> OT::NumericalScalar
        computeCDF(Logistic self, NumericalPoint point) -> OT::NumericalScalar
        computeCDF(Logistic self, NumericalSample sample, OT::Bool const tail) -> NumericalSample
        computeCDF(Logistic self, NumericalSample sample) -> NumericalSample
        computeCDF(Logistic 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(Logistic self, OT::NumericalScalar const xMin, OT::NumericalScalar const xMax, OT::UnsignedLong const pointNumber, 
            NumericalSample grid) -> NumericalSample
        computeCDF(Logistic self, NumericalPoint xMin, NumericalPoint xMax, Indices pointNumber, NumericalSample grid, 
            OT::NumericalScalar const precision=OT::ResourceMap::GetAsNumericalScalar("DistributionImplementation-DefaultCDFEpsilon")) -> NumericalSample
        computeCDF(Logistic self, NumericalPoint xMin, NumericalPoint xMax, Indices pointNumber, NumericalSample grid) -> NumericalSample
        computeCDF(Logistic self, NumericalPoint point) -> OT::NumericalScalar
        """
        return _dist_bundle2.Logistic_computeCDF(self, *args)

    def computeComplementaryCDF(self, *args):
        """
        computeComplementaryCDF(Logistic self, OT::NumericalScalar const scalar) -> OT::NumericalScalar
        computeComplementaryCDF(Logistic self, NumericalPoint point) -> OT::NumericalScalar
        computeComplementaryCDF(Logistic self, NumericalSample sample) -> NumericalSample
        computeComplementaryCDF(Logistic 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(Logistic self, OT::NumericalScalar const xMin, OT::NumericalScalar const xMax, OT::UnsignedLong const pointNumber, 
            NumericalSample grid) -> NumericalSample
        computeComplementaryCDF(Logistic self, NumericalPoint point) -> OT::NumericalScalar
        """
        return _dist_bundle2.Logistic_computeComplementaryCDF(self, *args)

    def computeCharacteristicFunction(self, *args):
        """computeCharacteristicFunction(Logistic self, OT::NumericalScalar const x) -> OT::NumericalComplex"""
        return _dist_bundle2.Logistic_computeCharacteristicFunction(self, *args)

    def computeLogCharacteristicFunction(self, *args):
        """computeLogCharacteristicFunction(Logistic self, OT::NumericalScalar const x) -> OT::NumericalComplex"""
        return _dist_bundle2.Logistic_computeLogCharacteristicFunction(self, *args)

    def computePDFGradient(self, *args):
        """computePDFGradient(Logistic self, NumericalPoint point) -> NumericalPoint"""
        return _dist_bundle2.Logistic_computePDFGradient(self, *args)

    def computeCDFGradient(self, *args):
        """computeCDFGradient(Logistic self, NumericalPoint point) -> NumericalPoint"""
        return _dist_bundle2.Logistic_computeCDFGradient(self, *args)

    def getRoughness(self):
        """getRoughness(Logistic self) -> OT::NumericalScalar"""
        return _dist_bundle2.Logistic_getRoughness(self)

    def getStandardDeviation(self):
        """getStandardDeviation(Logistic self) -> NumericalPoint"""
        return _dist_bundle2.Logistic_getStandardDeviation(self)

    def getSkewness(self):
        """getSkewness(Logistic self) -> NumericalPoint"""
        return _dist_bundle2.Logistic_getSkewness(self)

    def getKurtosis(self):
        """getKurtosis(Logistic self) -> NumericalPoint"""
        return _dist_bundle2.Logistic_getKurtosis(self)

    def getStandardMoment(self, *args):
        """getStandardMoment(Logistic self, OT::UnsignedLong const n) -> NumericalPoint"""
        return _dist_bundle2.Logistic_getStandardMoment(self, *args)

    def getStandardRepresentative(self):
        """getStandardRepresentative(Logistic self) -> DistributionImplementationPointer"""
        return _dist_bundle2.Logistic_getStandardRepresentative(self)

    def getParametersCollection(self):
        """getParametersCollection(Logistic self) -> NumericalPointWithDescriptionCollection"""
        return _dist_bundle2.Logistic_getParametersCollection(self)

    def setParametersCollection(self, *args):
        """
        setParametersCollection(Logistic self, NumericalPointWithDescriptionCollection parametersCollection)
        setParametersCollection(Logistic self, NumericalPointCollection parametersCollection)
        setParametersCollection(Logistic self, NumericalPoint parameters)
        setParametersCollection(Logistic self, NumericalPointCollection parametersCollection)
        """
        return _dist_bundle2.Logistic_setParametersCollection(self, *args)

    def setAlpha(self, *args):
        """setAlpha(Logistic self, OT::NumericalScalar const alpha)"""
        return _dist_bundle2.Logistic_setAlpha(self, *args)

    def getAlpha(self):
        """getAlpha(Logistic self) -> OT::NumericalScalar"""
        return _dist_bundle2.Logistic_getAlpha(self)

    def setBeta(self, *args):
        """setBeta(Logistic self, OT::NumericalScalar const beta)"""
        return _dist_bundle2.Logistic_setBeta(self, *args)

    def getBeta(self):
        """getBeta(Logistic self) -> OT::NumericalScalar"""
        return _dist_bundle2.Logistic_getBeta(self)

    def __init__(self, *args): 
        """
        __init__(OT::Logistic self) -> Logistic
        __init__(OT::Logistic self, OT::NumericalScalar const alpha, OT::NumericalScalar const beta) -> Logistic
        __init__(OT::Logistic self, Logistic other) -> Logistic
        """
        this = _dist_bundle2.new_Logistic(*args)
        try: self.this.append(this)
        except: self.this = this
    __swig_destroy__ = _dist_bundle2.delete_Logistic
    __del__ = lambda self : None;
Logistic_swigregister = _dist_bundle2.Logistic_swigregister
Logistic_swigregister(Logistic)

def Logistic_GetClassName():
  """Logistic_GetClassName() -> OT::String"""
  return _dist_bundle2.Logistic_GetClassName()

class LogisticFactory(openturns.model_copula.DistributionImplementationFactory):
    """Proxy of C++ OT::LogisticFactory 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, LogisticFactory, 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, LogisticFactory, name)
    __repr__ = _swig_repr
    def GetClassName():
        """GetClassName() -> OT::String"""
        return _dist_bundle2.LogisticFactory_GetClassName()

    if _newclass:GetClassName = staticmethod(GetClassName)
    __swig_getmethods__["GetClassName"] = lambda x: GetClassName
    def getClassName(self):
        """getClassName(LogisticFactory self) -> OT::String"""
        return _dist_bundle2.LogisticFactory_getClassName(self)

    def build(self, *args):
        """
        build(LogisticFactory self, NumericalSample sample) -> DistributionImplementationPointer
        build(LogisticFactory self, NumericalSample sample, CovarianceMatrix covariance) -> DistributionImplementationPointer
        build(LogisticFactory self, NumericalPointCollection parameters) -> DistributionImplementationPointer
        build(LogisticFactory self, NumericalPointWithDescriptionCollection parameters) -> DistributionImplementationPointer
        build(LogisticFactory self, NumericalSample sample) -> DistributionImplementationPointer
        build(LogisticFactory self, NumericalPointCollection parameters) -> DistributionImplementationPointer
        build(LogisticFactory self) -> DistributionImplementationPointer
        """
        return _dist_bundle2.LogisticFactory_build(self, *args)

    def buildAsLogistic(self, *args):
        """
        buildAsLogistic(LogisticFactory self, NumericalSample sample) -> Logistic
        buildAsLogistic(LogisticFactory self, NumericalPointCollection parameters) -> Logistic
        buildAsLogistic(LogisticFactory self, NumericalPointWithDescriptionCollection parameters) -> Logistic
        buildAsLogistic(LogisticFactory self) -> Logistic
        """
        return _dist_bundle2.LogisticFactory_buildAsLogistic(self, *args)

    def __init__(self, *args): 
        """
        __init__(OT::LogisticFactory self) -> LogisticFactory
        __init__(OT::LogisticFactory self, LogisticFactory other) -> LogisticFactory
        """
        this = _dist_bundle2.new_LogisticFactory(*args)
        try: self.this.append(this)
        except: self.this = this
    __swig_destroy__ = _dist_bundle2.delete_LogisticFactory
    __del__ = lambda self : None;
LogisticFactory_swigregister = _dist_bundle2.LogisticFactory_swigregister
LogisticFactory_swigregister(LogisticFactory)

def LogisticFactory_GetClassName():
  """LogisticFactory_GetClassName() -> OT::String"""
  return _dist_bundle2.LogisticFactory_GetClassName()

class LogNormal(openturns.model_copula.NonEllipticalDistribution):
    """Proxy of C++ OT::LogNormal 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, LogNormal, 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, LogNormal, name)
    def GetClassName():
        """GetClassName() -> OT::String"""
        return _dist_bundle2.LogNormal_GetClassName()

    if _newclass:GetClassName = staticmethod(GetClassName)
    __swig_getmethods__["GetClassName"] = lambda x: GetClassName
    def getClassName(self):
        """getClassName(LogNormal self) -> OT::String"""
        return _dist_bundle2.LogNormal_getClassName(self)

    MUSIGMA_LOG = _dist_bundle2.LogNormal_MUSIGMA_LOG
    MUSIGMA = _dist_bundle2.LogNormal_MUSIGMA
    MU_SIGMAOVERMU = _dist_bundle2.LogNormal_MU_SIGMAOVERMU
    def __eq__(self, *args):
        """__eq__(LogNormal self, LogNormal other) -> OT::Bool"""
        return _dist_bundle2.LogNormal___eq__(self, *args)

    def __repr__(self):
        """__repr__(LogNormal self) -> OT::String"""
        return _dist_bundle2.LogNormal___repr__(self)

    def __str__(self, offset=""):
        """
        __str__(LogNormal self, OT::String const & offset="") -> OT::String
        __str__(LogNormal self) -> OT::String
        """
        return _dist_bundle2.LogNormal___str__(self, offset)

    def getRealization(self):
        """getRealization(LogNormal self) -> NumericalPoint"""
        return _dist_bundle2.LogNormal_getRealization(self)

    def computeDDF(self, *args):
        """
        computeDDF(LogNormal self, OT::NumericalScalar const scalar) -> OT::NumericalScalar
        computeDDF(LogNormal self, NumericalPoint point) -> NumericalPoint
        computeDDF(LogNormal self, NumericalSample sample) -> NumericalSample
        computeDDF(LogNormal self, NumericalPoint point) -> NumericalPoint
        """
        return _dist_bundle2.LogNormal_computeDDF(self, *args)

    def computePDF(self, *args):
        """
        computePDF(LogNormal self, OT::NumericalScalar const scalar) -> OT::NumericalScalar
        computePDF(LogNormal self, NumericalPoint point) -> OT::NumericalScalar
        computePDF(LogNormal self, NumericalSample sample) -> NumericalSample
        computePDF(LogNormal 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(LogNormal self, OT::NumericalScalar const xMin, OT::NumericalScalar const xMax, OT::UnsignedLong const pointNumber, 
            NumericalSample grid) -> NumericalSample
        computePDF(LogNormal self, NumericalPoint xMin, NumericalPoint xMax, Indices pointNumber, NumericalSample grid, 
            OT::NumericalScalar const precision=OT::ResourceMap::GetAsNumericalScalar("DistributionImplementation-DefaultPDFEpsilon")) -> NumericalSample
        computePDF(LogNormal self, NumericalPoint xMin, NumericalPoint xMax, Indices pointNumber, NumericalSample grid) -> NumericalSample
        computePDF(LogNormal self, NumericalPoint point) -> OT::NumericalScalar
        """
        return _dist_bundle2.LogNormal_computePDF(self, *args)

    def computeLogPDF(self, *args):
        """
        computeLogPDF(LogNormal self, OT::NumericalScalar const scalar) -> OT::NumericalScalar
        computeLogPDF(LogNormal self, NumericalPoint point) -> OT::NumericalScalar
        computeLogPDF(LogNormal self, NumericalSample sample) -> NumericalSample
        computeLogPDF(LogNormal self, NumericalPoint point) -> OT::NumericalScalar
        """
        return _dist_bundle2.LogNormal_computeLogPDF(self, *args)

    def computeCDF(self, *args):
        """
        computeCDF(LogNormal self, OT::NumericalScalar const scalar, OT::Bool const tail) -> OT::NumericalScalar
        computeCDF(LogNormal self, OT::NumericalScalar const scalar) -> OT::NumericalScalar
        computeCDF(LogNormal self, NumericalPoint point, OT::Bool const tail) -> OT::NumericalScalar
        computeCDF(LogNormal self, NumericalPoint point) -> OT::NumericalScalar
        computeCDF(LogNormal self, NumericalSample sample, OT::Bool const tail) -> NumericalSample
        computeCDF(LogNormal self, NumericalSample sample) -> NumericalSample
        computeCDF(LogNormal 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(LogNormal self, OT::NumericalScalar const xMin, OT::NumericalScalar const xMax, OT::UnsignedLong const pointNumber, 
            NumericalSample grid) -> NumericalSample
        computeCDF(LogNormal self, NumericalPoint xMin, NumericalPoint xMax, Indices pointNumber, NumericalSample grid, 
            OT::NumericalScalar const precision=OT::ResourceMap::GetAsNumericalScalar("DistributionImplementation-DefaultCDFEpsilon")) -> NumericalSample
        computeCDF(LogNormal self, NumericalPoint xMin, NumericalPoint xMax, Indices pointNumber, NumericalSample grid) -> NumericalSample
        computeCDF(LogNormal self, NumericalPoint point) -> OT::NumericalScalar
        """
        return _dist_bundle2.LogNormal_computeCDF(self, *args)

    def computeComplementaryCDF(self, *args):
        """
        computeComplementaryCDF(LogNormal self, OT::NumericalScalar const scalar) -> OT::NumericalScalar
        computeComplementaryCDF(LogNormal self, NumericalPoint point) -> OT::NumericalScalar
        computeComplementaryCDF(LogNormal self, NumericalSample sample) -> NumericalSample
        computeComplementaryCDF(LogNormal 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(LogNormal self, OT::NumericalScalar const xMin, OT::NumericalScalar const xMax, OT::UnsignedLong const pointNumber, 
            NumericalSample grid) -> NumericalSample
        computeComplementaryCDF(LogNormal self, NumericalPoint point) -> OT::NumericalScalar
        """
        return _dist_bundle2.LogNormal_computeComplementaryCDF(self, *args)

    def computeCharacteristicFunction(self, *args):
        """computeCharacteristicFunction(LogNormal self, OT::NumericalScalar const x) -> OT::NumericalComplex"""
        return _dist_bundle2.LogNormal_computeCharacteristicFunction(self, *args)

    def computeLogCharacteristicFunction(self, *args):
        """computeLogCharacteristicFunction(LogNormal self, OT::NumericalScalar const x) -> OT::NumericalComplex"""
        return _dist_bundle2.LogNormal_computeLogCharacteristicFunction(self, *args)

    def computePDFGradient(self, *args):
        """computePDFGradient(LogNormal self, NumericalPoint point) -> NumericalPoint"""
        return _dist_bundle2.LogNormal_computePDFGradient(self, *args)

    def computeCDFGradient(self, *args):
        """computeCDFGradient(LogNormal self, NumericalPoint point) -> NumericalPoint"""
        return _dist_bundle2.LogNormal_computeCDFGradient(self, *args)

    def getStandardDeviation(self):
        """getStandardDeviation(LogNormal self) -> NumericalPoint"""
        return _dist_bundle2.LogNormal_getStandardDeviation(self)

    def getSkewness(self):
        """getSkewness(LogNormal self) -> NumericalPoint"""
        return _dist_bundle2.LogNormal_getSkewness(self)

    def getKurtosis(self):
        """getKurtosis(LogNormal self) -> NumericalPoint"""
        return _dist_bundle2.LogNormal_getKurtosis(self)

    def getStandardMoment(self, *args):
        """getStandardMoment(LogNormal self, OT::UnsignedLong const n) -> NumericalPoint"""
        return _dist_bundle2.LogNormal_getStandardMoment(self, *args)

    def getStandardRepresentative(self):
        """getStandardRepresentative(LogNormal self) -> DistributionImplementationPointer"""
        return _dist_bundle2.LogNormal_getStandardRepresentative(self)

    def getParametersCollection(self):
        """getParametersCollection(LogNormal self) -> NumericalPointWithDescriptionCollection"""
        return _dist_bundle2.LogNormal_getParametersCollection(self)

    def setParametersCollection(self, *args):
        """
        setParametersCollection(LogNormal self, NumericalPointWithDescriptionCollection parametersCollection)
        setParametersCollection(LogNormal self, NumericalPointCollection parametersCollection)
        setParametersCollection(LogNormal self, NumericalPoint parameters)
        setParametersCollection(LogNormal self, NumericalPointCollection parametersCollection)
        """
        return _dist_bundle2.LogNormal_setParametersCollection(self, *args)

    def setMuLog(self, *args):
        """setMuLog(LogNormal self, OT::NumericalScalar const muLog)"""
        return _dist_bundle2.LogNormal_setMuLog(self, *args)

    def getMuLog(self):
        """getMuLog(LogNormal self) -> OT::NumericalScalar"""
        return _dist_bundle2.LogNormal_getMuLog(self)

    def setSigmaLog(self, *args):
        """setSigmaLog(LogNormal self, OT::NumericalScalar const sigmaLog)"""
        return _dist_bundle2.LogNormal_setSigmaLog(self, *args)

    def getSigmaLog(self):
        """getSigmaLog(LogNormal self) -> OT::NumericalScalar"""
        return _dist_bundle2.LogNormal_getSigmaLog(self)

    def setMuSigma(self, *args):
        """setMuSigma(LogNormal self, OT::NumericalScalar const mu, OT::NumericalScalar const sigma)"""
        return _dist_bundle2.LogNormal_setMuSigma(self, *args)

    def getMu(self):
        """getMu(LogNormal self) -> OT::NumericalScalar"""
        return _dist_bundle2.LogNormal_getMu(self)

    def getSigma(self):
        """getSigma(LogNormal self) -> OT::NumericalScalar"""
        return _dist_bundle2.LogNormal_getSigma(self)

    def setGamma(self, *args):
        """setGamma(LogNormal self, OT::NumericalScalar const gamma)"""
        return _dist_bundle2.LogNormal_setGamma(self, *args)

    def getGamma(self):
        """getGamma(LogNormal self) -> OT::NumericalScalar"""
        return _dist_bundle2.LogNormal_getGamma(self)

    def getSigmaOverMu(self):
        """getSigmaOverMu(LogNormal self) -> OT::NumericalScalar"""
        return _dist_bundle2.LogNormal_getSigmaOverMu(self)

    def __init__(self, *args): 
        """
        __init__(OT::LogNormal self) -> LogNormal
        __init__(OT::LogNormal self, OT::NumericalScalar const arg1, OT::NumericalScalar const arg2, OT::NumericalScalar const gamma=0.0, 
            OT::LogNormal::ParameterSet const set=MUSIGMA_LOG) -> LogNormal
        __init__(OT::LogNormal self, OT::NumericalScalar const arg1, OT::NumericalScalar const arg2, OT::NumericalScalar const gamma=0.0) -> LogNormal
        __init__(OT::LogNormal self, OT::NumericalScalar const arg1, OT::NumericalScalar const arg2) -> LogNormal
        __init__(OT::LogNormal self, LogNormal other) -> LogNormal
        """
        this = _dist_bundle2.new_LogNormal(*args)
        try: self.this.append(this)
        except: self.this = this
    __swig_destroy__ = _dist_bundle2.delete_LogNormal
    __del__ = lambda self : None;
LogNormal_swigregister = _dist_bundle2.LogNormal_swigregister
LogNormal_swigregister(LogNormal)

def LogNormal_GetClassName():
  """LogNormal_GetClassName() -> OT::String"""
  return _dist_bundle2.LogNormal_GetClassName()

class LogNormalFactory(openturns.model_copula.DistributionImplementationFactory):
    """Proxy of C++ OT::LogNormalFactory 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, LogNormalFactory, 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, LogNormalFactory, name)
    __repr__ = _swig_repr
    def GetClassName():
        """GetClassName() -> OT::String"""
        return _dist_bundle2.LogNormalFactory_GetClassName()

    if _newclass:GetClassName = staticmethod(GetClassName)
    __swig_getmethods__["GetClassName"] = lambda x: GetClassName
    def getClassName(self):
        """getClassName(LogNormalFactory self) -> OT::String"""
        return _dist_bundle2.LogNormalFactory_getClassName(self)

    def build(self, *args):
        """
        build(LogNormalFactory self, NumericalSample sample) -> DistributionImplementationPointer
        build(LogNormalFactory self, NumericalSample sample, CovarianceMatrix covariance) -> DistributionImplementationPointer
        build(LogNormalFactory self, NumericalPointCollection parameters) -> DistributionImplementationPointer
        build(LogNormalFactory self, NumericalPointWithDescriptionCollection parameters) -> DistributionImplementationPointer
        build(LogNormalFactory self, NumericalSample sample) -> DistributionImplementationPointer
        build(LogNormalFactory self, NumericalSample sample, OT::UnsignedLong const method) -> DistributionImplementationPointer
        build(LogNormalFactory self, NumericalPointCollection parameters) -> DistributionImplementationPointer
        build(LogNormalFactory self) -> DistributionImplementationPointer
        """
        return _dist_bundle2.LogNormalFactory_build(self, *args)

    def buildAsLogNormal(self, *args):
        """
        buildAsLogNormal(LogNormalFactory self, NumericalSample sample) -> LogNormal
        buildAsLogNormal(LogNormalFactory self, NumericalSample sample, OT::UnsignedLong const method) -> LogNormal
        buildAsLogNormal(LogNormalFactory self, NumericalPointCollection parameters) -> LogNormal
        buildAsLogNormal(LogNormalFactory self, NumericalPointWithDescriptionCollection parameters) -> LogNormal
        buildAsLogNormal(LogNormalFactory self) -> LogNormal
        """
        return _dist_bundle2.LogNormalFactory_buildAsLogNormal(self, *args)

    def buildMethodOfMoments(self, *args):
        """buildMethodOfMoments(LogNormalFactory self, NumericalSample sample) -> LogNormal"""
        return _dist_bundle2.LogNormalFactory_buildMethodOfMoments(self, *args)

    def buildMethodOfLocalLikelihoodMaximization(self, *args):
        """buildMethodOfLocalLikelihoodMaximization(LogNormalFactory self, NumericalSample sample) -> LogNormal"""
        return _dist_bundle2.LogNormalFactory_buildMethodOfLocalLikelihoodMaximization(self, *args)

    def buildMethodOfModifiedMoments(self, *args):
        """buildMethodOfModifiedMoments(LogNormalFactory self, NumericalSample sample) -> LogNormal"""
        return _dist_bundle2.LogNormalFactory_buildMethodOfModifiedMoments(self, *args)

    def __init__(self, *args): 
        """
        __init__(OT::LogNormalFactory self) -> LogNormalFactory
        __init__(OT::LogNormalFactory self, LogNormalFactory other) -> LogNormalFactory
        """
        this = _dist_bundle2.new_LogNormalFactory(*args)
        try: self.this.append(this)
        except: self.this = this
    __swig_destroy__ = _dist_bundle2.delete_LogNormalFactory
    __del__ = lambda self : None;
LogNormalFactory_swigregister = _dist_bundle2.LogNormalFactory_swigregister
LogNormalFactory_swigregister(LogNormalFactory)

def LogNormalFactory_GetClassName():
  """LogNormalFactory_GetClassName() -> OT::String"""
  return _dist_bundle2.LogNormalFactory_GetClassName()

class LogUniform(openturns.model_copula.NonEllipticalDistribution):
    """Proxy of C++ OT::LogUniform 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, LogUniform, 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, LogUniform, name)
    def GetClassName():
        """GetClassName() -> OT::String"""
        return _dist_bundle2.LogUniform_GetClassName()

    if _newclass:GetClassName = staticmethod(GetClassName)
    __swig_getmethods__["GetClassName"] = lambda x: GetClassName
    def getClassName(self):
        """getClassName(LogUniform self) -> OT::String"""
        return _dist_bundle2.LogUniform_getClassName(self)

    def __eq__(self, *args):
        """__eq__(LogUniform self, LogUniform other) -> OT::Bool"""
        return _dist_bundle2.LogUniform___eq__(self, *args)

    def __repr__(self):
        """__repr__(LogUniform self) -> OT::String"""
        return _dist_bundle2.LogUniform___repr__(self)

    def __str__(self, offset=""):
        """
        __str__(LogUniform self, OT::String const & offset="") -> OT::String
        __str__(LogUniform self) -> OT::String
        """
        return _dist_bundle2.LogUniform___str__(self, offset)

    def getRealization(self):
        """getRealization(LogUniform self) -> NumericalPoint"""
        return _dist_bundle2.LogUniform_getRealization(self)

    def computeDDF(self, *args):
        """
        computeDDF(LogUniform self, OT::NumericalScalar const scalar) -> OT::NumericalScalar
        computeDDF(LogUniform self, NumericalPoint point) -> NumericalPoint
        computeDDF(LogUniform self, NumericalSample sample) -> NumericalSample
        computeDDF(LogUniform self, NumericalPoint point) -> NumericalPoint
        """
        return _dist_bundle2.LogUniform_computeDDF(self, *args)

    def computePDF(self, *args):
        """
        computePDF(LogUniform self, OT::NumericalScalar const scalar) -> OT::NumericalScalar
        computePDF(LogUniform self, NumericalPoint point) -> OT::NumericalScalar
        computePDF(LogUniform self, NumericalSample sample) -> NumericalSample
        computePDF(LogUniform 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(LogUniform self, OT::NumericalScalar const xMin, OT::NumericalScalar const xMax, OT::UnsignedLong const pointNumber, 
            NumericalSample grid) -> NumericalSample
        computePDF(LogUniform self, NumericalPoint xMin, NumericalPoint xMax, Indices pointNumber, NumericalSample grid, 
            OT::NumericalScalar const precision=OT::ResourceMap::GetAsNumericalScalar("DistributionImplementation-DefaultPDFEpsilon")) -> NumericalSample
        computePDF(LogUniform self, NumericalPoint xMin, NumericalPoint xMax, Indices pointNumber, NumericalSample grid) -> NumericalSample
        computePDF(LogUniform self, NumericalPoint point) -> OT::NumericalScalar
        """
        return _dist_bundle2.LogUniform_computePDF(self, *args)

    def computeCDF(self, *args):
        """
        computeCDF(LogUniform self, OT::NumericalScalar const scalar, OT::Bool const tail) -> OT::NumericalScalar
        computeCDF(LogUniform self, OT::NumericalScalar const scalar) -> OT::NumericalScalar
        computeCDF(LogUniform self, NumericalPoint point, OT::Bool const tail) -> OT::NumericalScalar
        computeCDF(LogUniform self, NumericalPoint point) -> OT::NumericalScalar
        computeCDF(LogUniform self, NumericalSample sample, OT::Bool const tail) -> NumericalSample
        computeCDF(LogUniform self, NumericalSample sample) -> NumericalSample
        computeCDF(LogUniform 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(LogUniform self, OT::NumericalScalar const xMin, OT::NumericalScalar const xMax, OT::UnsignedLong const pointNumber, 
            NumericalSample grid) -> NumericalSample
        computeCDF(LogUniform self, NumericalPoint xMin, NumericalPoint xMax, Indices pointNumber, NumericalSample grid, 
            OT::NumericalScalar const precision=OT::ResourceMap::GetAsNumericalScalar("DistributionImplementation-DefaultCDFEpsilon")) -> NumericalSample
        computeCDF(LogUniform self, NumericalPoint xMin, NumericalPoint xMax, Indices pointNumber, NumericalSample grid) -> NumericalSample
        computeCDF(LogUniform self, NumericalPoint point) -> OT::NumericalScalar
        """
        return _dist_bundle2.LogUniform_computeCDF(self, *args)

    def computeComplementaryCDF(self, *args):
        """
        computeComplementaryCDF(LogUniform self, OT::NumericalScalar const scalar) -> OT::NumericalScalar
        computeComplementaryCDF(LogUniform self, NumericalPoint point) -> OT::NumericalScalar
        computeComplementaryCDF(LogUniform self, NumericalSample sample) -> NumericalSample
        computeComplementaryCDF(LogUniform 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(LogUniform self, OT::NumericalScalar const xMin, OT::NumericalScalar const xMax, OT::UnsignedLong const pointNumber, 
            NumericalSample grid) -> NumericalSample
        computeComplementaryCDF(LogUniform self, NumericalPoint point) -> OT::NumericalScalar
        """
        return _dist_bundle2.LogUniform_computeComplementaryCDF(self, *args)

    def computePDFGradient(self, *args):
        """computePDFGradient(LogUniform self, NumericalPoint point) -> NumericalPoint"""
        return _dist_bundle2.LogUniform_computePDFGradient(self, *args)

    def computeCDFGradient(self, *args):
        """computeCDFGradient(LogUniform self, NumericalPoint point) -> NumericalPoint"""
        return _dist_bundle2.LogUniform_computeCDFGradient(self, *args)

    def getStandardDeviation(self):
        """getStandardDeviation(LogUniform self) -> NumericalPoint"""
        return _dist_bundle2.LogUniform_getStandardDeviation(self)

    def getSkewness(self):
        """getSkewness(LogUniform self) -> NumericalPoint"""
        return _dist_bundle2.LogUniform_getSkewness(self)

    def getKurtosis(self):
        """getKurtosis(LogUniform self) -> NumericalPoint"""
        return _dist_bundle2.LogUniform_getKurtosis(self)

    def getStandardMoment(self, *args):
        """getStandardMoment(LogUniform self, OT::UnsignedLong const n) -> NumericalPoint"""
        return _dist_bundle2.LogUniform_getStandardMoment(self, *args)

    def getParametersCollection(self):
        """getParametersCollection(LogUniform self) -> NumericalPointWithDescriptionCollection"""
        return _dist_bundle2.LogUniform_getParametersCollection(self)

    def setParametersCollection(self, *args):
        """
        setParametersCollection(LogUniform self, NumericalPointWithDescriptionCollection parametersCollection)
        setParametersCollection(LogUniform self, NumericalPointCollection parametersCollection)
        setParametersCollection(LogUniform self, NumericalPoint parameters)
        setParametersCollection(LogUniform self, NumericalPointCollection parametersCollection)
        """
        return _dist_bundle2.LogUniform_setParametersCollection(self, *args)

    def setALog(self, *args):
        """setALog(LogUniform self, OT::NumericalScalar const aLog)"""
        return _dist_bundle2.LogUniform_setALog(self, *args)

    def getALog(self):
        """getALog(LogUniform self) -> OT::NumericalScalar"""
        return _dist_bundle2.LogUniform_getALog(self)

    def setBLog(self, *args):
        """setBLog(LogUniform self, OT::NumericalScalar const bLog)"""
        return _dist_bundle2.LogUniform_setBLog(self, *args)

    def getBLog(self):
        """getBLog(LogUniform self) -> OT::NumericalScalar"""
        return _dist_bundle2.LogUniform_getBLog(self)

    def __init__(self, *args): 
        """
        __init__(OT::LogUniform self) -> LogUniform
        __init__(OT::LogUniform self, OT::NumericalScalar const aLog, OT::NumericalScalar const bLog) -> LogUniform
        __init__(OT::LogUniform self, LogUniform other) -> LogUniform
        """
        this = _dist_bundle2.new_LogUniform(*args)
        try: self.this.append(this)
        except: self.this = this
    __swig_destroy__ = _dist_bundle2.delete_LogUniform
    __del__ = lambda self : None;
LogUniform_swigregister = _dist_bundle2.LogUniform_swigregister
LogUniform_swigregister(LogUniform)

def LogUniform_GetClassName():
  """LogUniform_GetClassName() -> OT::String"""
  return _dist_bundle2.LogUniform_GetClassName()

class LogUniformFactory(openturns.model_copula.DistributionImplementationFactory):
    """Proxy of C++ OT::LogUniformFactory 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, LogUniformFactory, 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, LogUniformFactory, name)
    __repr__ = _swig_repr
    def GetClassName():
        """GetClassName() -> OT::String"""
        return _dist_bundle2.LogUniformFactory_GetClassName()

    if _newclass:GetClassName = staticmethod(GetClassName)
    __swig_getmethods__["GetClassName"] = lambda x: GetClassName
    def getClassName(self):
        """getClassName(LogUniformFactory self) -> OT::String"""
        return _dist_bundle2.LogUniformFactory_getClassName(self)

    def build(self, *args):
        """
        build(LogUniformFactory self, NumericalSample sample) -> DistributionImplementationPointer
        build(LogUniformFactory self, NumericalSample sample, CovarianceMatrix covariance) -> DistributionImplementationPointer
        build(LogUniformFactory self, NumericalPointCollection parameters) -> DistributionImplementationPointer
        build(LogUniformFactory self, NumericalPointWithDescriptionCollection parameters) -> DistributionImplementationPointer
        build(LogUniformFactory self, NumericalSample sample) -> DistributionImplementationPointer
        build(LogUniformFactory self, NumericalPointCollection parameters) -> DistributionImplementationPointer
        build(LogUniformFactory self) -> DistributionImplementationPointer
        """
        return _dist_bundle2.LogUniformFactory_build(self, *args)

    def buildAsLogUniform(self, *args):
        """
        buildAsLogUniform(LogUniformFactory self, NumericalSample sample) -> LogUniform
        buildAsLogUniform(LogUniformFactory self, NumericalPointCollection parameters) -> LogUniform
        buildAsLogUniform(LogUniformFactory self, NumericalPointWithDescriptionCollection parameters) -> LogUniform
        buildAsLogUniform(LogUniformFactory self) -> LogUniform
        """
        return _dist_bundle2.LogUniformFactory_buildAsLogUniform(self, *args)

    def __init__(self, *args): 
        """
        __init__(OT::LogUniformFactory self) -> LogUniformFactory
        __init__(OT::LogUniformFactory self, LogUniformFactory other) -> LogUniformFactory
        """
        this = _dist_bundle2.new_LogUniformFactory(*args)
        try: self.this.append(this)
        except: self.this = this
    __swig_destroy__ = _dist_bundle2.delete_LogUniformFactory
    __del__ = lambda self : None;
LogUniformFactory_swigregister = _dist_bundle2.LogUniformFactory_swigregister
LogUniformFactory_swigregister(LogUniformFactory)

def LogUniformFactory_GetClassName():
  """LogUniformFactory_GetClassName() -> OT::String"""
  return _dist_bundle2.LogUniformFactory_GetClassName()

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

    if _newclass:GetClassName = staticmethod(GetClassName)
    __swig_getmethods__["GetClassName"] = lambda x: GetClassName
    def getClassName(self):
        """getClassName(Mixture self) -> OT::String"""
        return _dist_bundle2.Mixture_getClassName(self)

    def __eq__(self, *args):
        """__eq__(Mixture self, Mixture other) -> OT::Bool"""
        return _dist_bundle2.Mixture___eq__(self, *args)

    def __repr__(self):
        """__repr__(Mixture self) -> OT::String"""
        return _dist_bundle2.Mixture___repr__(self)

    def __str__(self, offset=""):
        """
        __str__(Mixture self, OT::String const & offset="") -> OT::String
        __str__(Mixture self) -> OT::String
        """
        return _dist_bundle2.Mixture___str__(self, offset)

    def setDistributionCollection(self, *args):
        """setDistributionCollection(Mixture self, DistributionCollection coll)"""
        return _dist_bundle2.Mixture_setDistributionCollection(self, *args)

    def getDistributionCollection(self):
        """getDistributionCollection(Mixture self) -> DistributionCollection"""
        return _dist_bundle2.Mixture_getDistributionCollection(self)

    def getWeights(self):
        """getWeights(Mixture self) -> NumericalPoint"""
        return _dist_bundle2.Mixture_getWeights(self)

    def setWeights(self, *args):
        """setWeights(Mixture self, NumericalPoint weights)"""
        return _dist_bundle2.Mixture_setWeights(self, *args)

    def getRealization(self):
        """getRealization(Mixture self) -> NumericalPoint"""
        return _dist_bundle2.Mixture_getRealization(self)

    def computeDDF(self, *args):
        """
        computeDDF(Mixture self, OT::NumericalScalar const scalar) -> OT::NumericalScalar
        computeDDF(Mixture self, NumericalPoint point) -> NumericalPoint
        computeDDF(Mixture self, NumericalSample sample) -> NumericalSample
        computeDDF(Mixture self, NumericalPoint point) -> NumericalPoint
        """
        return _dist_bundle2.Mixture_computeDDF(self, *args)

    def computePDF(self, *args):
        """
        computePDF(Mixture self, OT::NumericalScalar const scalar) -> OT::NumericalScalar
        computePDF(Mixture self, NumericalPoint point) -> OT::NumericalScalar
        computePDF(Mixture self, NumericalSample sample) -> NumericalSample
        computePDF(Mixture 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(Mixture self, OT::NumericalScalar const xMin, OT::NumericalScalar const xMax, OT::UnsignedLong const pointNumber, 
            NumericalSample grid) -> NumericalSample
        computePDF(Mixture self, NumericalPoint xMin, NumericalPoint xMax, Indices pointNumber, NumericalSample grid, 
            OT::NumericalScalar const precision=OT::ResourceMap::GetAsNumericalScalar("DistributionImplementation-DefaultPDFEpsilon")) -> NumericalSample
        computePDF(Mixture self, NumericalPoint xMin, NumericalPoint xMax, Indices pointNumber, NumericalSample grid) -> NumericalSample
        computePDF(Mixture self, NumericalPoint point) -> OT::NumericalScalar
        """
        return _dist_bundle2.Mixture_computePDF(self, *args)

    def computeCDF(self, *args):
        """
        computeCDF(Mixture self, OT::NumericalScalar const scalar, OT::Bool const tail) -> OT::NumericalScalar
        computeCDF(Mixture self, OT::NumericalScalar const scalar) -> OT::NumericalScalar
        computeCDF(Mixture self, NumericalPoint point, OT::Bool const tail) -> OT::NumericalScalar
        computeCDF(Mixture self, NumericalPoint point) -> OT::NumericalScalar
        computeCDF(Mixture self, NumericalSample sample, OT::Bool const tail) -> NumericalSample
        computeCDF(Mixture self, NumericalSample sample) -> NumericalSample
        computeCDF(Mixture 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(Mixture self, OT::NumericalScalar const xMin, OT::NumericalScalar const xMax, OT::UnsignedLong const pointNumber, 
            NumericalSample grid) -> NumericalSample
        computeCDF(Mixture self, NumericalPoint xMin, NumericalPoint xMax, Indices pointNumber, NumericalSample grid, 
            OT::NumericalScalar const precision=OT::ResourceMap::GetAsNumericalScalar("DistributionImplementation-DefaultCDFEpsilon")) -> NumericalSample
        computeCDF(Mixture self, NumericalPoint xMin, NumericalPoint xMax, Indices pointNumber, NumericalSample grid) -> NumericalSample
        computeCDF(Mixture self, NumericalPoint point) -> OT::NumericalScalar
        """
        return _dist_bundle2.Mixture_computeCDF(self, *args)

    def computeCharacteristicFunction(self, *args):
        """computeCharacteristicFunction(Mixture self, OT::NumericalScalar const x) -> OT::NumericalComplex"""
        return _dist_bundle2.Mixture_computeCharacteristicFunction(self, *args)

    def computePDFGradient(self, *args):
        """computePDFGradient(Mixture self, NumericalPoint point) -> NumericalPoint"""
        return _dist_bundle2.Mixture_computePDFGradient(self, *args)

    def computeCDFGradient(self, *args):
        """computeCDFGradient(Mixture self, NumericalPoint point) -> NumericalPoint"""
        return _dist_bundle2.Mixture_computeCDFGradient(self, *args)

    def getMarginal(self, *args):
        """
        getMarginal(Mixture self, OT::UnsignedLong const i) -> DistributionImplementationPointer
        getMarginal(Mixture self, Indices indices) -> DistributionImplementationPointer
        """
        return _dist_bundle2.Mixture_getMarginal(self, *args)

    def getParametersCollection(self):
        """getParametersCollection(Mixture self) -> NumericalPointWithDescriptionCollection"""
        return _dist_bundle2.Mixture_getParametersCollection(self)

    def isElliptical(self):
        """isElliptical(Mixture self) -> OT::Bool"""
        return _dist_bundle2.Mixture_isElliptical(self)

    def isContinuous(self):
        """isContinuous(Mixture self) -> OT::Bool"""
        return _dist_bundle2.Mixture_isContinuous(self)

    def isIntegral(self):
        """isIntegral(Mixture self) -> OT::Bool"""
        return _dist_bundle2.Mixture_isIntegral(self)

    def hasEllipticalCopula(self):
        """hasEllipticalCopula(Mixture self) -> OT::Bool"""
        return _dist_bundle2.Mixture_hasEllipticalCopula(self)

    def hasIndependentCopula(self):
        """hasIndependentCopula(Mixture self) -> OT::Bool"""
        return _dist_bundle2.Mixture_hasIndependentCopula(self)

    def __init__(self, *args): 
        """
        __init__(OT::Mixture self) -> Mixture
        __init__(OT::Mixture self, DistributionCollection coll) -> Mixture
        __init__(OT::Mixture self, DistributionCollection coll, NumericalPoint weights) -> Mixture
        __init__(OT::Mixture self, Mixture other) -> Mixture
        """
        this = _dist_bundle2.new_Mixture(*args)
        try: self.this.append(this)
        except: self.this = this
    __swig_destroy__ = _dist_bundle2.delete_Mixture
    __del__ = lambda self : None;
Mixture_swigregister = _dist_bundle2.Mixture_swigregister
Mixture_swigregister(Mixture)

def Mixture_GetClassName():
  """Mixture_GetClassName() -> OT::String"""
  return _dist_bundle2.Mixture_GetClassName()

class Multinomial(openturns.model_copula.DiscreteDistribution):
    """Proxy of C++ OT::Multinomial 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, Multinomial, 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, Multinomial, name)
    def GetClassName():
        """GetClassName() -> OT::String"""
        return _dist_bundle2.Multinomial_GetClassName()

    if _newclass:GetClassName = staticmethod(GetClassName)
    __swig_getmethods__["GetClassName"] = lambda x: GetClassName
    def getClassName(self):
        """getClassName(Multinomial self) -> OT::String"""
        return _dist_bundle2.Multinomial_getClassName(self)

    def __eq__(self, *args):
        """__eq__(Multinomial self, Multinomial other) -> OT::Bool"""
        return _dist_bundle2.Multinomial___eq__(self, *args)

    def __repr__(self):
        """__repr__(Multinomial self) -> OT::String"""
        return _dist_bundle2.Multinomial___repr__(self)

    def __str__(self, offset=""):
        """
        __str__(Multinomial self, OT::String const & offset="") -> OT::String
        __str__(Multinomial self) -> OT::String
        """
        return _dist_bundle2.Multinomial___str__(self, offset)

    def getRealization(self):
        """getRealization(Multinomial self) -> NumericalPoint"""
        return _dist_bundle2.Multinomial_getRealization(self)

    def computePDF(self, *args):
        """
        computePDF(Multinomial self, OT::NumericalScalar const scalar) -> OT::NumericalScalar
        computePDF(Multinomial self, NumericalPoint point) -> OT::NumericalScalar
        computePDF(Multinomial self, NumericalSample sample) -> NumericalSample
        computePDF(Multinomial 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(Multinomial self, OT::NumericalScalar const xMin, OT::NumericalScalar const xMax, OT::UnsignedLong const pointNumber, 
            NumericalSample grid) -> NumericalSample
        computePDF(Multinomial self, NumericalPoint xMin, NumericalPoint xMax, Indices pointNumber, NumericalSample grid, 
            OT::NumericalScalar const precision=OT::ResourceMap::GetAsNumericalScalar("DistributionImplementation-DefaultPDFEpsilon")) -> NumericalSample
        computePDF(Multinomial self, NumericalPoint xMin, NumericalPoint xMax, Indices pointNumber, NumericalSample grid) -> NumericalSample
        computePDF(Multinomial self, NumericalPoint point) -> OT::NumericalScalar
        """
        return _dist_bundle2.Multinomial_computePDF(self, *args)

    def computeCDF(self, *args):
        """
        computeCDF(Multinomial self, OT::NumericalScalar const scalar, OT::Bool const tail) -> OT::NumericalScalar
        computeCDF(Multinomial self, OT::NumericalScalar const scalar) -> OT::NumericalScalar
        computeCDF(Multinomial self, NumericalPoint point, OT::Bool const tail) -> OT::NumericalScalar
        computeCDF(Multinomial self, NumericalPoint point) -> OT::NumericalScalar
        computeCDF(Multinomial self, NumericalSample sample, OT::Bool const tail) -> NumericalSample
        computeCDF(Multinomial self, NumericalSample sample) -> NumericalSample
        computeCDF(Multinomial 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(Multinomial self, OT::NumericalScalar const xMin, OT::NumericalScalar const xMax, OT::UnsignedLong const pointNumber, 
            NumericalSample grid) -> NumericalSample
        computeCDF(Multinomial self, NumericalPoint xMin, NumericalPoint xMax, Indices pointNumber, NumericalSample grid, 
            OT::NumericalScalar const precision=OT::ResourceMap::GetAsNumericalScalar("DistributionImplementation-DefaultCDFEpsilon")) -> NumericalSample
        computeCDF(Multinomial self, NumericalPoint xMin, NumericalPoint xMax, Indices pointNumber, NumericalSample grid) -> NumericalSample
        computeCDF(Multinomial self, NumericalPoint point) -> OT::NumericalScalar
        """
        return _dist_bundle2.Multinomial_computeCDF(self, *args)

    def computeConditionalPDF(self, *args):
        """computeConditionalPDF(Multinomial self, OT::NumericalScalar const x, NumericalPoint y) -> OT::NumericalScalar"""
        return _dist_bundle2.Multinomial_computeConditionalPDF(self, *args)

    def computeConditionalCDF(self, *args):
        """computeConditionalCDF(Multinomial self, OT::NumericalScalar const x, NumericalPoint y) -> OT::NumericalScalar"""
        return _dist_bundle2.Multinomial_computeConditionalCDF(self, *args)

    def computeConditionalQuantile(self, *args):
        """computeConditionalQuantile(Multinomial self, OT::NumericalScalar const q, NumericalPoint y) -> OT::NumericalScalar"""
        return _dist_bundle2.Multinomial_computeConditionalQuantile(self, *args)

    def getMarginal(self, *args):
        """
        getMarginal(Multinomial self, OT::UnsignedLong const i) -> DistributionImplementationPointer
        getMarginal(Multinomial self, Indices indices) -> DistributionImplementationPointer
        getMarginal(Multinomial self, OT::UnsignedLong const i) -> DistributionImplementationPointer
        getMarginal(Multinomial self, Indices indices) -> DistributionImplementationPointer
        """
        return _dist_bundle2.Multinomial_getMarginal(self, *args)

    def getSupport(self, *args):
        """
        getSupport(Multinomial self, Interval interval) -> NumericalSample
        getSupport(Multinomial self, Interval interval) -> NumericalSample
        getSupport(Multinomial self) -> NumericalSample
        """
        return _dist_bundle2.Multinomial_getSupport(self, *args)

    def getParametersCollection(self):
        """getParametersCollection(Multinomial self) -> NumericalPointWithDescriptionCollection"""
        return _dist_bundle2.Multinomial_getParametersCollection(self)

    def setP(self, *args):
        """setP(Multinomial self, NumericalPoint p)"""
        return _dist_bundle2.Multinomial_setP(self, *args)

    def getP(self):
        """getP(Multinomial self) -> NumericalPoint"""
        return _dist_bundle2.Multinomial_getP(self)

    def setN(self, *args):
        """setN(Multinomial self, OT::UnsignedLong const n)"""
        return _dist_bundle2.Multinomial_setN(self, *args)

    def getN(self):
        """getN(Multinomial self) -> OT::UnsignedLong"""
        return _dist_bundle2.Multinomial_getN(self)

    def __init__(self, *args): 
        """
        __init__(OT::Multinomial self) -> Multinomial
        __init__(OT::Multinomial self, OT::UnsignedLong const n, NumericalPoint p) -> Multinomial
        __init__(OT::Multinomial self, Multinomial other) -> Multinomial
        """
        this = _dist_bundle2.new_Multinomial(*args)
        try: self.this.append(this)
        except: self.this = this
    __swig_destroy__ = _dist_bundle2.delete_Multinomial
    __del__ = lambda self : None;
Multinomial_swigregister = _dist_bundle2.Multinomial_swigregister
Multinomial_swigregister(Multinomial)

def Multinomial_GetClassName():
  """Multinomial_GetClassName() -> OT::String"""
  return _dist_bundle2.Multinomial_GetClassName()

class MultinomialFactory(openturns.model_copula.DistributionImplementationFactory):
    """Proxy of C++ OT::MultinomialFactory 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, MultinomialFactory, 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, MultinomialFactory, name)
    __repr__ = _swig_repr
    def GetClassName():
        """GetClassName() -> OT::String"""
        return _dist_bundle2.MultinomialFactory_GetClassName()

    if _newclass:GetClassName = staticmethod(GetClassName)
    __swig_getmethods__["GetClassName"] = lambda x: GetClassName
    def getClassName(self):
        """getClassName(MultinomialFactory self) -> OT::String"""
        return _dist_bundle2.MultinomialFactory_getClassName(self)

    def build(self, *args):
        """
        build(MultinomialFactory self, NumericalSample sample) -> DistributionImplementationPointer
        build(MultinomialFactory self, NumericalSample sample, CovarianceMatrix covariance) -> DistributionImplementationPointer
        build(MultinomialFactory self, NumericalPointCollection parameters) -> DistributionImplementationPointer
        build(MultinomialFactory self, NumericalPointWithDescriptionCollection parameters) -> DistributionImplementationPointer
        build(MultinomialFactory self, NumericalSample sample) -> DistributionImplementationPointer
        build(MultinomialFactory self) -> DistributionImplementationPointer
        """
        return _dist_bundle2.MultinomialFactory_build(self, *args)

    def buildAsMultinomial(self, *args):
        """
        buildAsMultinomial(MultinomialFactory self, NumericalSample sample) -> Multinomial
        buildAsMultinomial(MultinomialFactory self) -> Multinomial
        """
        return _dist_bundle2.MultinomialFactory_buildAsMultinomial(self, *args)

    def __init__(self, *args): 
        """
        __init__(OT::MultinomialFactory self) -> MultinomialFactory
        __init__(OT::MultinomialFactory self, MultinomialFactory other) -> MultinomialFactory
        """
        this = _dist_bundle2.new_MultinomialFactory(*args)
        try: self.this.append(this)
        except: self.this = this
    __swig_destroy__ = _dist_bundle2.delete_MultinomialFactory
    __del__ = lambda self : None;
MultinomialFactory_swigregister = _dist_bundle2.MultinomialFactory_swigregister
MultinomialFactory_swigregister(MultinomialFactory)

def MultinomialFactory_GetClassName():
  """MultinomialFactory_GetClassName() -> OT::String"""
  return _dist_bundle2.MultinomialFactory_GetClassName()

class NegativeBinomial(openturns.model_copula.DiscreteDistribution):
    """Proxy of C++ OT::NegativeBinomial 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, NegativeBinomial, 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, NegativeBinomial, name)
    def GetClassName():
        """GetClassName() -> OT::String"""
        return _dist_bundle2.NegativeBinomial_GetClassName()

    if _newclass:GetClassName = staticmethod(GetClassName)
    __swig_getmethods__["GetClassName"] = lambda x: GetClassName
    def getClassName(self):
        """getClassName(NegativeBinomial self) -> OT::String"""
        return _dist_bundle2.NegativeBinomial_getClassName(self)

    def __eq__(self, *args):
        """__eq__(NegativeBinomial self, NegativeBinomial other) -> OT::Bool"""
        return _dist_bundle2.NegativeBinomial___eq__(self, *args)

    def __repr__(self):
        """__repr__(NegativeBinomial self) -> OT::String"""
        return _dist_bundle2.NegativeBinomial___repr__(self)

    def __str__(self, offset=""):
        """
        __str__(NegativeBinomial self, OT::String const & offset="") -> OT::String
        __str__(NegativeBinomial self) -> OT::String
        """
        return _dist_bundle2.NegativeBinomial___str__(self, offset)

    def getRealization(self):
        """getRealization(NegativeBinomial self) -> NumericalPoint"""
        return _dist_bundle2.NegativeBinomial_getRealization(self)

    def computePDF(self, *args):
        """
        computePDF(NegativeBinomial self, OT::NumericalScalar const scalar) -> OT::NumericalScalar
        computePDF(NegativeBinomial self, NumericalPoint point) -> OT::NumericalScalar
        computePDF(NegativeBinomial self, NumericalSample sample) -> NumericalSample
        computePDF(NegativeBinomial 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(NegativeBinomial self, OT::NumericalScalar const xMin, OT::NumericalScalar const xMax, OT::UnsignedLong const pointNumber, 
            NumericalSample grid) -> NumericalSample
        computePDF(NegativeBinomial self, NumericalPoint xMin, NumericalPoint xMax, Indices pointNumber, NumericalSample grid, 
            OT::NumericalScalar const precision=OT::ResourceMap::GetAsNumericalScalar("DistributionImplementation-DefaultPDFEpsilon")) -> NumericalSample
        computePDF(NegativeBinomial self, NumericalPoint xMin, NumericalPoint xMax, Indices pointNumber, NumericalSample grid) -> NumericalSample
        computePDF(NegativeBinomial self, NumericalPoint point) -> OT::NumericalScalar
        """
        return _dist_bundle2.NegativeBinomial_computePDF(self, *args)

    def computeCDF(self, *args):
        """
        computeCDF(NegativeBinomial self, OT::NumericalScalar const scalar, OT::Bool const tail) -> OT::NumericalScalar
        computeCDF(NegativeBinomial self, OT::NumericalScalar const scalar) -> OT::NumericalScalar
        computeCDF(NegativeBinomial self, NumericalPoint point, OT::Bool const tail) -> OT::NumericalScalar
        computeCDF(NegativeBinomial self, NumericalPoint point) -> OT::NumericalScalar
        computeCDF(NegativeBinomial self, NumericalSample sample, OT::Bool const tail) -> NumericalSample
        computeCDF(NegativeBinomial self, NumericalSample sample) -> NumericalSample
        computeCDF(NegativeBinomial 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(NegativeBinomial self, OT::NumericalScalar const xMin, OT::NumericalScalar const xMax, OT::UnsignedLong const pointNumber, 
            NumericalSample grid) -> NumericalSample
        computeCDF(NegativeBinomial self, NumericalPoint xMin, NumericalPoint xMax, Indices pointNumber, NumericalSample grid, 
            OT::NumericalScalar const precision=OT::ResourceMap::GetAsNumericalScalar("DistributionImplementation-DefaultCDFEpsilon")) -> NumericalSample
        computeCDF(NegativeBinomial self, NumericalPoint xMin, NumericalPoint xMax, Indices pointNumber, NumericalSample grid) -> NumericalSample
        computeCDF(NegativeBinomial self, NumericalPoint point) -> OT::NumericalScalar
        """
        return _dist_bundle2.NegativeBinomial_computeCDF(self, *args)

    def computeComplementaryCDF(self, *args):
        """
        computeComplementaryCDF(NegativeBinomial self, OT::NumericalScalar const scalar) -> OT::NumericalScalar
        computeComplementaryCDF(NegativeBinomial self, NumericalPoint point) -> OT::NumericalScalar
        computeComplementaryCDF(NegativeBinomial self, NumericalSample sample) -> NumericalSample
        computeComplementaryCDF(NegativeBinomial 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(NegativeBinomial self, OT::NumericalScalar const xMin, OT::NumericalScalar const xMax, OT::UnsignedLong const pointNumber, 
            NumericalSample grid) -> NumericalSample
        computeComplementaryCDF(NegativeBinomial self, NumericalPoint point) -> OT::NumericalScalar
        """
        return _dist_bundle2.NegativeBinomial_computeComplementaryCDF(self, *args)

    def computePDFGradient(self, *args):
        """computePDFGradient(NegativeBinomial self, NumericalPoint point) -> NumericalPoint"""
        return _dist_bundle2.NegativeBinomial_computePDFGradient(self, *args)

    def computeCDFGradient(self, *args):
        """computeCDFGradient(NegativeBinomial self, NumericalPoint point) -> NumericalPoint"""
        return _dist_bundle2.NegativeBinomial_computeCDFGradient(self, *args)

    def computeCharacteristicFunction(self, *args):
        """computeCharacteristicFunction(NegativeBinomial self, OT::NumericalScalar const x) -> OT::NumericalComplex"""
        return _dist_bundle2.NegativeBinomial_computeCharacteristicFunction(self, *args)

    def computeLogCharacteristicFunction(self, *args):
        """computeLogCharacteristicFunction(NegativeBinomial self, OT::NumericalScalar const x) -> OT::NumericalComplex"""
        return _dist_bundle2.NegativeBinomial_computeLogCharacteristicFunction(self, *args)

    def computeGeneratingFunction(self, *args):
        """computeGeneratingFunction(NegativeBinomial self, OT::NumericalComplex const & z) -> OT::NumericalComplex"""
        return _dist_bundle2.NegativeBinomial_computeGeneratingFunction(self, *args)

    def computeLogGeneratingFunction(self, *args):
        """computeLogGeneratingFunction(NegativeBinomial self, OT::NumericalComplex const & z) -> OT::NumericalComplex"""
        return _dist_bundle2.NegativeBinomial_computeLogGeneratingFunction(self, *args)

    def getSupport(self, *args):
        """
        getSupport(NegativeBinomial self, Interval interval) -> NumericalSample
        getSupport(NegativeBinomial self) -> NumericalSample
        getSupport(NegativeBinomial self, Interval interval) -> NumericalSample
        """
        return _dist_bundle2.NegativeBinomial_getSupport(self, *args)

    def getStandardDeviation(self):
        """getStandardDeviation(NegativeBinomial self) -> NumericalPoint"""
        return _dist_bundle2.NegativeBinomial_getStandardDeviation(self)

    def getSkewness(self):
        """getSkewness(NegativeBinomial self) -> NumericalPoint"""
        return _dist_bundle2.NegativeBinomial_getSkewness(self)

    def getKurtosis(self):
        """getKurtosis(NegativeBinomial self) -> NumericalPoint"""
        return _dist_bundle2.NegativeBinomial_getKurtosis(self)

    def getParametersCollection(self):
        """getParametersCollection(NegativeBinomial self) -> NumericalPointWithDescriptionCollection"""
        return _dist_bundle2.NegativeBinomial_getParametersCollection(self)

    def setParametersCollection(self, *args):
        """
        setParametersCollection(NegativeBinomial self, NumericalPointWithDescriptionCollection parametersCollection)
        setParametersCollection(NegativeBinomial self, NumericalPointCollection parametersCollection)
        setParametersCollection(NegativeBinomial self, NumericalPoint parameters)
        setParametersCollection(NegativeBinomial self, NumericalPointCollection parametersCollection)
        """
        return _dist_bundle2.NegativeBinomial_setParametersCollection(self, *args)

    def setP(self, *args):
        """setP(NegativeBinomial self, OT::NumericalScalar const p)"""
        return _dist_bundle2.NegativeBinomial_setP(self, *args)

    def getP(self):
        """getP(NegativeBinomial self) -> OT::NumericalScalar"""
        return _dist_bundle2.NegativeBinomial_getP(self)

    def setR(self, *args):
        """setR(NegativeBinomial self, OT::NumericalScalar const r)"""
        return _dist_bundle2.NegativeBinomial_setR(self, *args)

    def getR(self):
        """getR(NegativeBinomial self) -> OT::NumericalScalar"""
        return _dist_bundle2.NegativeBinomial_getR(self)

    def __init__(self, *args): 
        """
        __init__(OT::NegativeBinomial self) -> NegativeBinomial
        __init__(OT::NegativeBinomial self, OT::NumericalScalar const r, OT::NumericalScalar const p) -> NegativeBinomial
        __init__(OT::NegativeBinomial self, NegativeBinomial other) -> NegativeBinomial
        """
        this = _dist_bundle2.new_NegativeBinomial(*args)
        try: self.this.append(this)
        except: self.this = this
    __swig_destroy__ = _dist_bundle2.delete_NegativeBinomial
    __del__ = lambda self : None;
NegativeBinomial_swigregister = _dist_bundle2.NegativeBinomial_swigregister
NegativeBinomial_swigregister(NegativeBinomial)

def NegativeBinomial_GetClassName():
  """NegativeBinomial_GetClassName() -> OT::String"""
  return _dist_bundle2.NegativeBinomial_GetClassName()

class NegativeBinomialFactory(openturns.model_copula.DistributionImplementationFactory):
    """Proxy of C++ OT::NegativeBinomialFactory 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, NegativeBinomialFactory, 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, NegativeBinomialFactory, name)
    __repr__ = _swig_repr
    def GetClassName():
        """GetClassName() -> OT::String"""
        return _dist_bundle2.NegativeBinomialFactory_GetClassName()

    if _newclass:GetClassName = staticmethod(GetClassName)
    __swig_getmethods__["GetClassName"] = lambda x: GetClassName
    def getClassName(self):
        """getClassName(NegativeBinomialFactory self) -> OT::String"""
        return _dist_bundle2.NegativeBinomialFactory_getClassName(self)

    def build(self, *args):
        """
        build(NegativeBinomialFactory self, NumericalSample sample) -> DistributionImplementationPointer
        build(NegativeBinomialFactory self, NumericalSample sample, CovarianceMatrix covariance) -> DistributionImplementationPointer
        build(NegativeBinomialFactory self, NumericalPointCollection parameters) -> DistributionImplementationPointer
        build(NegativeBinomialFactory self, NumericalPointWithDescriptionCollection parameters) -> DistributionImplementationPointer
        build(NegativeBinomialFactory self, NumericalSample sample) -> DistributionImplementationPointer
        build(NegativeBinomialFactory self, NumericalPointCollection parameters) -> DistributionImplementationPointer
        build(NegativeBinomialFactory self) -> DistributionImplementationPointer
        """
        return _dist_bundle2.NegativeBinomialFactory_build(self, *args)

    def buildAsNegativeBinomial(self, *args):
        """
        buildAsNegativeBinomial(NegativeBinomialFactory self, NumericalSample sample) -> NegativeBinomial
        buildAsNegativeBinomial(NegativeBinomialFactory self, NumericalPointCollection parameters) -> NegativeBinomial
        buildAsNegativeBinomial(NegativeBinomialFactory self, NumericalPointWithDescriptionCollection parameters) -> NegativeBinomial
        buildAsNegativeBinomial(NegativeBinomialFactory self) -> NegativeBinomial
        """
        return _dist_bundle2.NegativeBinomialFactory_buildAsNegativeBinomial(self, *args)

    def __init__(self, *args): 
        """
        __init__(OT::NegativeBinomialFactory self) -> NegativeBinomialFactory
        __init__(OT::NegativeBinomialFactory self, NegativeBinomialFactory other) -> NegativeBinomialFactory
        """
        this = _dist_bundle2.new_NegativeBinomialFactory(*args)
        try: self.this.append(this)
        except: self.this = this
    __swig_destroy__ = _dist_bundle2.delete_NegativeBinomialFactory
    __del__ = lambda self : None;
NegativeBinomialFactory_swigregister = _dist_bundle2.NegativeBinomialFactory_swigregister
NegativeBinomialFactory_swigregister(NegativeBinomialFactory)

def NegativeBinomialFactory_GetClassName():
  """NegativeBinomialFactory_GetClassName() -> OT::String"""
  return _dist_bundle2.NegativeBinomialFactory_GetClassName()

class NonCentralChiSquare(openturns.model_copula.NonEllipticalDistribution):
    """Proxy of C++ OT::NonCentralChiSquare 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, NonCentralChiSquare, 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, NonCentralChiSquare, name)
    def GetClassName():
        """GetClassName() -> OT::String"""
        return _dist_bundle2.NonCentralChiSquare_GetClassName()

    if _newclass:GetClassName = staticmethod(GetClassName)
    __swig_getmethods__["GetClassName"] = lambda x: GetClassName
    def getClassName(self):
        """getClassName(NonCentralChiSquare self) -> OT::String"""
        return _dist_bundle2.NonCentralChiSquare_getClassName(self)

    def __eq__(self, *args):
        """__eq__(NonCentralChiSquare self, NonCentralChiSquare other) -> OT::Bool"""
        return _dist_bundle2.NonCentralChiSquare___eq__(self, *args)

    def __repr__(self):
        """__repr__(NonCentralChiSquare self) -> OT::String"""
        return _dist_bundle2.NonCentralChiSquare___repr__(self)

    def __str__(self, offset=""):
        """
        __str__(NonCentralChiSquare self, OT::String const & offset="") -> OT::String
        __str__(NonCentralChiSquare self) -> OT::String
        """
        return _dist_bundle2.NonCentralChiSquare___str__(self, offset)

    def getRealization(self):
        """getRealization(NonCentralChiSquare self) -> NumericalPoint"""
        return _dist_bundle2.NonCentralChiSquare_getRealization(self)

    def computePDF(self, *args):
        """
        computePDF(NonCentralChiSquare self, OT::NumericalScalar const scalar) -> OT::NumericalScalar
        computePDF(NonCentralChiSquare self, NumericalPoint point) -> OT::NumericalScalar
        computePDF(NonCentralChiSquare self, NumericalSample sample) -> NumericalSample
        computePDF(NonCentralChiSquare 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(NonCentralChiSquare self, OT::NumericalScalar const xMin, OT::NumericalScalar const xMax, OT::UnsignedLong const pointNumber, 
            NumericalSample grid) -> NumericalSample
        computePDF(NonCentralChiSquare self, NumericalPoint xMin, NumericalPoint xMax, Indices pointNumber, NumericalSample grid, 
            OT::NumericalScalar const precision=OT::ResourceMap::GetAsNumericalScalar("DistributionImplementation-DefaultPDFEpsilon")) -> NumericalSample
        computePDF(NonCentralChiSquare self, NumericalPoint xMin, NumericalPoint xMax, Indices pointNumber, NumericalSample grid) -> NumericalSample
        computePDF(NonCentralChiSquare self, NumericalPoint point) -> OT::NumericalScalar
        """
        return _dist_bundle2.NonCentralChiSquare_computePDF(self, *args)

    def computeCDF(self, *args):
        """
        computeCDF(NonCentralChiSquare self, OT::NumericalScalar const scalar, OT::Bool const tail) -> OT::NumericalScalar
        computeCDF(NonCentralChiSquare self, OT::NumericalScalar const scalar) -> OT::NumericalScalar
        computeCDF(NonCentralChiSquare self, NumericalPoint point, OT::Bool const tail) -> OT::NumericalScalar
        computeCDF(NonCentralChiSquare self, NumericalPoint point) -> OT::NumericalScalar
        computeCDF(NonCentralChiSquare self, NumericalSample sample, OT::Bool const tail) -> NumericalSample
        computeCDF(NonCentralChiSquare self, NumericalSample sample) -> NumericalSample
        computeCDF(NonCentralChiSquare 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(NonCentralChiSquare self, OT::NumericalScalar const xMin, OT::NumericalScalar const xMax, OT::UnsignedLong const pointNumber, 
            NumericalSample grid) -> NumericalSample
        computeCDF(NonCentralChiSquare self, NumericalPoint xMin, NumericalPoint xMax, Indices pointNumber, NumericalSample grid, 
            OT::NumericalScalar const precision=OT::ResourceMap::GetAsNumericalScalar("DistributionImplementation-DefaultCDFEpsilon")) -> NumericalSample
        computeCDF(NonCentralChiSquare self, NumericalPoint xMin, NumericalPoint xMax, Indices pointNumber, NumericalSample grid) -> NumericalSample
        computeCDF(NonCentralChiSquare self, NumericalPoint point) -> OT::NumericalScalar
        """
        return _dist_bundle2.NonCentralChiSquare_computeCDF(self, *args)

    def computeCharacteristicFunction(self, *args):
        """computeCharacteristicFunction(NonCentralChiSquare self, OT::NumericalScalar const x) -> OT::NumericalComplex"""
        return _dist_bundle2.NonCentralChiSquare_computeCharacteristicFunction(self, *args)

    def computeLogCharacteristicFunction(self, *args):
        """computeLogCharacteristicFunction(NonCentralChiSquare self, OT::NumericalScalar const x) -> OT::NumericalComplex"""
        return _dist_bundle2.NonCentralChiSquare_computeLogCharacteristicFunction(self, *args)

    def computePDFGradient(self, *args):
        """computePDFGradient(NonCentralChiSquare self, NumericalPoint point) -> NumericalPoint"""
        return _dist_bundle2.NonCentralChiSquare_computePDFGradient(self, *args)

    def computeCDFGradient(self, *args):
        """computeCDFGradient(NonCentralChiSquare self, NumericalPoint point) -> NumericalPoint"""
        return _dist_bundle2.NonCentralChiSquare_computeCDFGradient(self, *args)

    def getStandardDeviation(self):
        """getStandardDeviation(NonCentralChiSquare self) -> NumericalPoint"""
        return _dist_bundle2.NonCentralChiSquare_getStandardDeviation(self)

    def getSkewness(self):
        """getSkewness(NonCentralChiSquare self) -> NumericalPoint"""
        return _dist_bundle2.NonCentralChiSquare_getSkewness(self)

    def getKurtosis(self):
        """getKurtosis(NonCentralChiSquare self) -> NumericalPoint"""
        return _dist_bundle2.NonCentralChiSquare_getKurtosis(self)

    def getStandardMoment(self, *args):
        """getStandardMoment(NonCentralChiSquare self, OT::UnsignedLong const n) -> NumericalPoint"""
        return _dist_bundle2.NonCentralChiSquare_getStandardMoment(self, *args)

    def getParametersCollection(self):
        """getParametersCollection(NonCentralChiSquare self) -> NumericalPointWithDescriptionCollection"""
        return _dist_bundle2.NonCentralChiSquare_getParametersCollection(self)

    def setParametersCollection(self, *args):
        """
        setParametersCollection(NonCentralChiSquare self, NumericalPointWithDescriptionCollection parametersCollection)
        setParametersCollection(NonCentralChiSquare self, NumericalPointCollection parametersCollection)
        setParametersCollection(NonCentralChiSquare self, NumericalPoint parameters)
        setParametersCollection(NonCentralChiSquare self, NumericalPointCollection parametersCollection)
        """
        return _dist_bundle2.NonCentralChiSquare_setParametersCollection(self, *args)

    def setNu(self, *args):
        """setNu(NonCentralChiSquare self, OT::NumericalScalar const nu)"""
        return _dist_bundle2.NonCentralChiSquare_setNu(self, *args)

    def setNuLambda(self, *args):
        """setNuLambda(NonCentralChiSquare self, OT::NumericalScalar const nu, OT::NumericalScalar const _lambda)"""
        return _dist_bundle2.NonCentralChiSquare_setNuLambda(self, *args)

    def getNu(self):
        """getNu(NonCentralChiSquare self) -> OT::NumericalScalar"""
        return _dist_bundle2.NonCentralChiSquare_getNu(self)

    def setLambda(self, *args):
        """setLambda(NonCentralChiSquare self, OT::NumericalScalar const _lambda)"""
        return _dist_bundle2.NonCentralChiSquare_setLambda(self, *args)

    def getLambda(self):
        """getLambda(NonCentralChiSquare self) -> OT::NumericalScalar"""
        return _dist_bundle2.NonCentralChiSquare_getLambda(self)

    def __init__(self, *args): 
        """
        __init__(OT::NonCentralChiSquare self, OT::NumericalScalar const nu=5.0, OT::NumericalScalar const _lambda=0.0) -> NonCentralChiSquare
        __init__(OT::NonCentralChiSquare self, OT::NumericalScalar const nu=5.0) -> NonCentralChiSquare
        __init__(OT::NonCentralChiSquare self) -> NonCentralChiSquare
        __init__(OT::NonCentralChiSquare self, NonCentralChiSquare other) -> NonCentralChiSquare
        """
        this = _dist_bundle2.new_NonCentralChiSquare(*args)
        try: self.this.append(this)
        except: self.this = this
    __swig_destroy__ = _dist_bundle2.delete_NonCentralChiSquare
    __del__ = lambda self : None;
NonCentralChiSquare_swigregister = _dist_bundle2.NonCentralChiSquare_swigregister
NonCentralChiSquare_swigregister(NonCentralChiSquare)

def NonCentralChiSquare_GetClassName():
  """NonCentralChiSquare_GetClassName() -> OT::String"""
  return _dist_bundle2.NonCentralChiSquare_GetClassName()

class NonCentralStudent(openturns.model_copula.NonEllipticalDistribution):
    """Proxy of C++ OT::NonCentralStudent 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, NonCentralStudent, 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, NonCentralStudent, name)
    def GetClassName():
        """GetClassName() -> OT::String"""
        return _dist_bundle2.NonCentralStudent_GetClassName()

    if _newclass:GetClassName = staticmethod(GetClassName)
    __swig_getmethods__["GetClassName"] = lambda x: GetClassName
    def getClassName(self):
        """getClassName(NonCentralStudent self) -> OT::String"""
        return _dist_bundle2.NonCentralStudent_getClassName(self)

    def __eq__(self, *args):
        """__eq__(NonCentralStudent self, NonCentralStudent other) -> OT::Bool"""
        return _dist_bundle2.NonCentralStudent___eq__(self, *args)

    def __repr__(self):
        """__repr__(NonCentralStudent self) -> OT::String"""
        return _dist_bundle2.NonCentralStudent___repr__(self)

    def __str__(self, offset=""):
        """
        __str__(NonCentralStudent self, OT::String const & offset="") -> OT::String
        __str__(NonCentralStudent self) -> OT::String
        """
        return _dist_bundle2.NonCentralStudent___str__(self, offset)

    def getRealization(self):
        """getRealization(NonCentralStudent self) -> NumericalPoint"""
        return _dist_bundle2.NonCentralStudent_getRealization(self)

    def computePDF(self, *args):
        """
        computePDF(NonCentralStudent self, OT::NumericalScalar const scalar) -> OT::NumericalScalar
        computePDF(NonCentralStudent self, NumericalPoint point) -> OT::NumericalScalar
        computePDF(NonCentralStudent self, NumericalSample sample) -> NumericalSample
        computePDF(NonCentralStudent 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(NonCentralStudent self, OT::NumericalScalar const xMin, OT::NumericalScalar const xMax, OT::UnsignedLong const pointNumber, 
            NumericalSample grid) -> NumericalSample
        computePDF(NonCentralStudent self, NumericalPoint xMin, NumericalPoint xMax, Indices pointNumber, NumericalSample grid, 
            OT::NumericalScalar const precision=OT::ResourceMap::GetAsNumericalScalar("DistributionImplementation-DefaultPDFEpsilon")) -> NumericalSample
        computePDF(NonCentralStudent self, NumericalPoint xMin, NumericalPoint xMax, Indices pointNumber, NumericalSample grid) -> NumericalSample
        computePDF(NonCentralStudent self, NumericalPoint point) -> OT::NumericalScalar
        """
        return _dist_bundle2.NonCentralStudent_computePDF(self, *args)

    def computeCDF(self, *args):
        """
        computeCDF(NonCentralStudent self, OT::NumericalScalar const scalar, OT::Bool const tail) -> OT::NumericalScalar
        computeCDF(NonCentralStudent self, OT::NumericalScalar const scalar) -> OT::NumericalScalar
        computeCDF(NonCentralStudent self, NumericalPoint point, OT::Bool const tail) -> OT::NumericalScalar
        computeCDF(NonCentralStudent self, NumericalPoint point) -> OT::NumericalScalar
        computeCDF(NonCentralStudent self, NumericalSample sample, OT::Bool const tail) -> NumericalSample
        computeCDF(NonCentralStudent self, NumericalSample sample) -> NumericalSample
        computeCDF(NonCentralStudent 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(NonCentralStudent self, OT::NumericalScalar const xMin, OT::NumericalScalar const xMax, OT::UnsignedLong const pointNumber, 
            NumericalSample grid) -> NumericalSample
        computeCDF(NonCentralStudent self, NumericalPoint xMin, NumericalPoint xMax, Indices pointNumber, NumericalSample grid, 
            OT::NumericalScalar const precision=OT::ResourceMap::GetAsNumericalScalar("DistributionImplementation-DefaultCDFEpsilon")) -> NumericalSample
        computeCDF(NonCentralStudent self, NumericalPoint xMin, NumericalPoint xMax, Indices pointNumber, NumericalSample grid) -> NumericalSample
        computeCDF(NonCentralStudent self, NumericalPoint point) -> OT::NumericalScalar
        """
        return _dist_bundle2.NonCentralStudent_computeCDF(self, *args)

    def computePDFGradient(self, *args):
        """computePDFGradient(NonCentralStudent self, NumericalPoint point) -> NumericalPoint"""
        return _dist_bundle2.NonCentralStudent_computePDFGradient(self, *args)

    def computeCDFGradient(self, *args):
        """computeCDFGradient(NonCentralStudent self, NumericalPoint point) -> NumericalPoint"""
        return _dist_bundle2.NonCentralStudent_computeCDFGradient(self, *args)

    def getStandardDeviation(self):
        """getStandardDeviation(NonCentralStudent self) -> NumericalPoint"""
        return _dist_bundle2.NonCentralStudent_getStandardDeviation(self)

    def getSkewness(self):
        """getSkewness(NonCentralStudent self) -> NumericalPoint"""
        return _dist_bundle2.NonCentralStudent_getSkewness(self)

    def getKurtosis(self):
        """getKurtosis(NonCentralStudent self) -> NumericalPoint"""
        return _dist_bundle2.NonCentralStudent_getKurtosis(self)

    def getStandardMoment(self, *args):
        """getStandardMoment(NonCentralStudent self, OT::UnsignedLong const n) -> NumericalPoint"""
        return _dist_bundle2.NonCentralStudent_getStandardMoment(self, *args)

    def getStandardRepresentative(self):
        """getStandardRepresentative(NonCentralStudent self) -> DistributionImplementationPointer"""
        return _dist_bundle2.NonCentralStudent_getStandardRepresentative(self)

    def getParametersCollection(self):
        """getParametersCollection(NonCentralStudent self) -> NumericalPointWithDescriptionCollection"""
        return _dist_bundle2.NonCentralStudent_getParametersCollection(self)

    def setParametersCollection(self, *args):
        """
        setParametersCollection(NonCentralStudent self, NumericalPointWithDescriptionCollection parametersCollection)
        setParametersCollection(NonCentralStudent self, NumericalPointCollection parametersCollection)
        setParametersCollection(NonCentralStudent self, NumericalPoint parameters)
        setParametersCollection(NonCentralStudent self, NumericalPointCollection parametersCollection)
        """
        return _dist_bundle2.NonCentralStudent_setParametersCollection(self, *args)

    def setNu(self, *args):
        """setNu(NonCentralStudent self, OT::NumericalScalar const nu)"""
        return _dist_bundle2.NonCentralStudent_setNu(self, *args)

    def getNu(self):
        """getNu(NonCentralStudent self) -> OT::NumericalScalar"""
        return _dist_bundle2.NonCentralStudent_getNu(self)

    def setDelta(self, *args):
        """setDelta(NonCentralStudent self, OT::NumericalScalar const delta)"""
        return _dist_bundle2.NonCentralStudent_setDelta(self, *args)

    def getDelta(self):
        """getDelta(NonCentralStudent self) -> OT::NumericalScalar"""
        return _dist_bundle2.NonCentralStudent_getDelta(self)

    def setGamma(self, *args):
        """setGamma(NonCentralStudent self, OT::NumericalScalar const gamma)"""
        return _dist_bundle2.NonCentralStudent_setGamma(self, *args)

    def getGamma(self):
        """getGamma(NonCentralStudent self) -> OT::NumericalScalar"""
        return _dist_bundle2.NonCentralStudent_getGamma(self)

    def __init__(self, *args): 
        """
        __init__(OT::NonCentralStudent self, OT::NumericalScalar const nu=5.0, OT::NumericalScalar const delta=0.0, OT::NumericalScalar const gamma=0.0) -> NonCentralStudent
        __init__(OT::NonCentralStudent self, OT::NumericalScalar const nu=5.0, OT::NumericalScalar const delta=0.0) -> NonCentralStudent
        __init__(OT::NonCentralStudent self, OT::NumericalScalar const nu=5.0) -> NonCentralStudent
        __init__(OT::NonCentralStudent self) -> NonCentralStudent
        __init__(OT::NonCentralStudent self, NonCentralStudent other) -> NonCentralStudent
        """
        this = _dist_bundle2.new_NonCentralStudent(*args)
        try: self.this.append(this)
        except: self.this = this
    __swig_destroy__ = _dist_bundle2.delete_NonCentralStudent
    __del__ = lambda self : None;
NonCentralStudent_swigregister = _dist_bundle2.NonCentralStudent_swigregister
NonCentralStudent_swigregister(NonCentralStudent)

def NonCentralStudent_GetClassName():
  """NonCentralStudent_GetClassName() -> OT::String"""
  return _dist_bundle2.NonCentralStudent_GetClassName()

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

    if _newclass:GetClassName = staticmethod(GetClassName)
    __swig_getmethods__["GetClassName"] = lambda x: GetClassName
    def getClassName(self):
        """getClassName(Normal self) -> OT::String"""
        return _dist_bundle2.Normal_getClassName(self)

    def __repr__(self):
        """__repr__(Normal self) -> OT::String"""
        return _dist_bundle2.Normal___repr__(self)

    def __str__(self, offset=""):
        """
        __str__(Normal self, OT::String const & offset="") -> OT::String
        __str__(Normal self) -> OT::String
        """
        return _dist_bundle2.Normal___str__(self, offset)

    def computeDensityGenerator(self, *args):
        """computeDensityGenerator(Normal self, OT::NumericalScalar const betaSquare) -> OT::NumericalScalar"""
        return _dist_bundle2.Normal_computeDensityGenerator(self, *args)

    def computeDensityGeneratorDerivative(self, *args):
        """computeDensityGeneratorDerivative(Normal self, OT::NumericalScalar const betaSquare) -> OT::NumericalScalar"""
        return _dist_bundle2.Normal_computeDensityGeneratorDerivative(self, *args)

    def computeDensityGeneratorSecondDerivative(self, *args):
        """computeDensityGeneratorSecondDerivative(Normal self, OT::NumericalScalar const betaSquare) -> OT::NumericalScalar"""
        return _dist_bundle2.Normal_computeDensityGeneratorSecondDerivative(self, *args)

    def getRealization(self):
        """getRealization(Normal self) -> NumericalPoint"""
        return _dist_bundle2.Normal_getRealization(self)

    def getSample(self, *args):
        """getSample(Normal self, OT::UnsignedLong const size) -> NumericalSample"""
        return _dist_bundle2.Normal_getSample(self, *args)

    def computeCDF(self, *args):
        """
        computeCDF(Normal self, OT::NumericalScalar const scalar, OT::Bool const tail) -> OT::NumericalScalar
        computeCDF(Normal self, OT::NumericalScalar const scalar) -> OT::NumericalScalar
        computeCDF(Normal self, NumericalPoint point, OT::Bool const tail) -> OT::NumericalScalar
        computeCDF(Normal self, NumericalPoint point) -> OT::NumericalScalar
        computeCDF(Normal self, NumericalSample sample, OT::Bool const tail) -> NumericalSample
        computeCDF(Normal self, NumericalSample sample) -> NumericalSample
        computeCDF(Normal 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(Normal self, OT::NumericalScalar const xMin, OT::NumericalScalar const xMax, OT::UnsignedLong const pointNumber, 
            NumericalSample grid) -> NumericalSample
        computeCDF(Normal self, NumericalPoint xMin, NumericalPoint xMax, Indices pointNumber, NumericalSample grid, 
            OT::NumericalScalar const precision=OT::ResourceMap::GetAsNumericalScalar("DistributionImplementation-DefaultCDFEpsilon")) -> NumericalSample
        computeCDF(Normal self, NumericalPoint xMin, NumericalPoint xMax, Indices pointNumber, NumericalSample grid) -> NumericalSample
        computeCDF(Normal self, NumericalPoint point) -> OT::NumericalScalar
        """
        return _dist_bundle2.Normal_computeCDF(self, *args)

    def computeComplementaryCDF(self, *args):
        """
        computeComplementaryCDF(Normal self, OT::NumericalScalar const scalar) -> OT::NumericalScalar
        computeComplementaryCDF(Normal self, NumericalPoint point) -> OT::NumericalScalar
        computeComplementaryCDF(Normal self, NumericalSample sample) -> NumericalSample
        computeComplementaryCDF(Normal 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(Normal self, OT::NumericalScalar const xMin, OT::NumericalScalar const xMax, OT::UnsignedLong const pointNumber, 
            NumericalSample grid) -> NumericalSample
        computeComplementaryCDF(Normal self, NumericalPoint point) -> OT::NumericalScalar
        """
        return _dist_bundle2.Normal_computeComplementaryCDF(self, *args)

    def computeCharacteristicFunction(self, *args):
        """
        computeCharacteristicFunction(Normal self, OT::NumericalScalar const x) -> OT::NumericalComplex
        computeCharacteristicFunction(Normal self, NumericalPoint x) -> OT::NumericalComplex
        """
        return _dist_bundle2.Normal_computeCharacteristicFunction(self, *args)

    def computeLogCharacteristicFunction(self, *args):
        """
        computeLogCharacteristicFunction(Normal self, OT::NumericalScalar const x) -> OT::NumericalComplex
        computeLogCharacteristicFunction(Normal self, NumericalPoint x) -> OT::NumericalComplex
        """
        return _dist_bundle2.Normal_computeLogCharacteristicFunction(self, *args)

    def computeProbability(self, *args):
        """computeProbability(Normal self, Interval interval) -> OT::NumericalScalar"""
        return _dist_bundle2.Normal_computeProbability(self, *args)

    def computeCDFGradient(self, *args):
        """computeCDFGradient(Normal self, NumericalPoint point) -> NumericalPoint"""
        return _dist_bundle2.Normal_computeCDFGradient(self, *args)

    def computeRadialDistributionCDF(self, *args):
        """
        computeRadialDistributionCDF(Normal self, OT::NumericalScalar const radius, OT::Bool const tail=False) -> OT::NumericalScalar
        computeRadialDistributionCDF(Normal self, OT::NumericalScalar const radius) -> OT::NumericalScalar
        """
        return _dist_bundle2.Normal_computeRadialDistributionCDF(self, *args)

    def computeConditionalPDF(self, *args):
        """computeConditionalPDF(Normal self, OT::NumericalScalar const x, NumericalPoint y) -> OT::NumericalScalar"""
        return _dist_bundle2.Normal_computeConditionalPDF(self, *args)

    def computeConditionalCDF(self, *args):
        """computeConditionalCDF(Normal self, OT::NumericalScalar const x, NumericalPoint y) -> OT::NumericalScalar"""
        return _dist_bundle2.Normal_computeConditionalCDF(self, *args)

    def computeConditionalQuantile(self, *args):
        """computeConditionalQuantile(Normal self, OT::NumericalScalar const q, NumericalPoint y) -> OT::NumericalScalar"""
        return _dist_bundle2.Normal_computeConditionalQuantile(self, *args)

    def getMarginal(self, *args):
        """
        getMarginal(Normal self, OT::UnsignedLong const i) -> DistributionImplementationPointer
        getMarginal(Normal self, Indices indices) -> DistributionImplementationPointer
        """
        return _dist_bundle2.Normal_getMarginal(self, *args)

    def getRoughness(self):
        """getRoughness(Normal self) -> OT::NumericalScalar"""
        return _dist_bundle2.Normal_getRoughness(self)

    def getSkewness(self):
        """getSkewness(Normal self) -> NumericalPoint"""
        return _dist_bundle2.Normal_getSkewness(self)

    def getKurtosis(self):
        """getKurtosis(Normal self) -> NumericalPoint"""
        return _dist_bundle2.Normal_getKurtosis(self)

    def getStandardMoment(self, *args):
        """getStandardMoment(Normal self, OT::UnsignedLong const n) -> NumericalPoint"""
        return _dist_bundle2.Normal_getStandardMoment(self, *args)

    def getStandardRepresentative(self):
        """getStandardRepresentative(Normal self) -> DistributionImplementationPointer"""
        return _dist_bundle2.Normal_getStandardRepresentative(self)

    def setCorrelation(self, *args):
        """setCorrelation(Normal self, CorrelationMatrix R)"""
        return _dist_bundle2.Normal_setCorrelation(self, *args)

    def getCopula(self):
        """getCopula(Normal self) -> DistributionImplementationPointer"""
        return _dist_bundle2.Normal_getCopula(self)

    def hasIndependentCopula(self):
        """hasIndependentCopula(Normal self) -> OT::Bool"""
        return _dist_bundle2.Normal_hasIndependentCopula(self)

    def __init__(self, *args): 
        """
        __init__(OT::Normal self, OT::UnsignedLong const dimension=1) -> Normal
        __init__(OT::Normal self) -> Normal
        __init__(OT::Normal self, OT::NumericalScalar const mu, OT::NumericalScalar const sd) -> Normal
        __init__(OT::Normal self, NumericalPoint mean, NumericalPoint sigma, CorrelationMatrix R) -> Normal
        __init__(OT::Normal self, NumericalPoint mean, CovarianceMatrix C) -> Normal
        __init__(OT::Normal self, Normal other) -> Normal
        """
        this = _dist_bundle2.new_Normal(*args)
        try: self.this.append(this)
        except: self.this = this
    __swig_destroy__ = _dist_bundle2.delete_Normal
    __del__ = lambda self : None;
Normal_swigregister = _dist_bundle2.Normal_swigregister
Normal_swigregister(Normal)

def Normal_GetClassName():
  """Normal_GetClassName() -> OT::String"""
  return _dist_bundle2.Normal_GetClassName()

class NormalFactory(openturns.model_copula.DistributionImplementationFactory):
    """Proxy of C++ OT::NormalFactory 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, NormalFactory, 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, NormalFactory, name)
    __repr__ = _swig_repr
    def GetClassName():
        """GetClassName() -> OT::String"""
        return _dist_bundle2.NormalFactory_GetClassName()

    if _newclass:GetClassName = staticmethod(GetClassName)
    __swig_getmethods__["GetClassName"] = lambda x: GetClassName
    def getClassName(self):
        """getClassName(NormalFactory self) -> OT::String"""
        return _dist_bundle2.NormalFactory_getClassName(self)

    def build(self, *args):
        """
        build(NormalFactory self, NumericalSample sample) -> DistributionImplementationPointer
        build(NormalFactory self, NumericalSample sample, CovarianceMatrix covariance) -> DistributionImplementationPointer
        build(NormalFactory self, NumericalPointCollection parameters) -> DistributionImplementationPointer
        build(NormalFactory self, NumericalPointWithDescriptionCollection parameters) -> DistributionImplementationPointer
        build(NormalFactory self, NumericalSample sample) -> DistributionImplementationPointer
        build(NormalFactory self, NumericalPointCollection parameters) -> DistributionImplementationPointer
        build(NormalFactory self) -> DistributionImplementationPointer
        """
        return _dist_bundle2.NormalFactory_build(self, *args)

    def buildAsNormal(self, *args):
        """
        buildAsNormal(NormalFactory self, NumericalSample sample) -> Normal
        buildAsNormal(NormalFactory self, NumericalPointCollection parameters) -> Normal
        buildAsNormal(NormalFactory self, NumericalPointWithDescriptionCollection parameters) -> Normal
        buildAsNormal(NormalFactory self) -> Normal
        """
        return _dist_bundle2.NormalFactory_buildAsNormal(self, *args)

    def __init__(self, *args): 
        """
        __init__(OT::NormalFactory self) -> NormalFactory
        __init__(OT::NormalFactory self, NormalFactory other) -> NormalFactory
        """
        this = _dist_bundle2.new_NormalFactory(*args)
        try: self.this.append(this)
        except: self.this = this
    __swig_destroy__ = _dist_bundle2.delete_NormalFactory
    __del__ = lambda self : None;
NormalFactory_swigregister = _dist_bundle2.NormalFactory_swigregister
NormalFactory_swigregister(NormalFactory)

def NormalFactory_GetClassName():
  """NormalFactory_GetClassName() -> OT::String"""
  return _dist_bundle2.NormalFactory_GetClassName()

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

    if _newclass:GetClassName = staticmethod(GetClassName)
    __swig_getmethods__["GetClassName"] = lambda x: GetClassName
    def getClassName(self):
        """getClassName(ConditionalDistribution self) -> OT::String"""
        return _dist_bundle2.ConditionalDistribution_getClassName(self)

    def __eq__(self, *args):
        """__eq__(ConditionalDistribution self, ConditionalDistribution other) -> OT::Bool"""
        return _dist_bundle2.ConditionalDistribution___eq__(self, *args)

    def __repr__(self):
        """__repr__(ConditionalDistribution self) -> OT::String"""
        return _dist_bundle2.ConditionalDistribution___repr__(self)

    def __str__(self, offset=""):
        """
        __str__(ConditionalDistribution self, OT::String const & offset="") -> OT::String
        __str__(ConditionalDistribution self) -> OT::String
        """
        return _dist_bundle2.ConditionalDistribution___str__(self, offset)

    def getRealization(self):
        """getRealization(ConditionalDistribution self) -> NumericalPoint"""
        return _dist_bundle2.ConditionalDistribution_getRealization(self)

    def getParametersCollection(self):
        """getParametersCollection(ConditionalDistribution self) -> NumericalPointWithDescriptionCollection"""
        return _dist_bundle2.ConditionalDistribution_getParametersCollection(self)

    def setParametersCollection(self, *args):
        """
        setParametersCollection(ConditionalDistribution self, NumericalPointWithDescriptionCollection parametersCollection)
        setParametersCollection(ConditionalDistribution self, NumericalPointCollection parametersCollection)
        setParametersCollection(ConditionalDistribution self, NumericalPoint parameters)
        setParametersCollection(ConditionalDistribution self, NumericalPointCollection parametersCollection)
        """
        return _dist_bundle2.ConditionalDistribution_setParametersCollection(self, *args)

    def setConditionedDistribution(self, *args):
        """setConditionedDistribution(ConditionalDistribution self, Distribution conditionedDistribution)"""
        return _dist_bundle2.ConditionalDistribution_setConditionedDistribution(self, *args)

    def getConditionedDistribution(self):
        """getConditionedDistribution(ConditionalDistribution self) -> Distribution"""
        return _dist_bundle2.ConditionalDistribution_getConditionedDistribution(self)

    def setConditioningDistribution(self, *args):
        """setConditioningDistribution(ConditionalDistribution self, Distribution conditioningDistribution)"""
        return _dist_bundle2.ConditionalDistribution_setConditioningDistribution(self, *args)

    def getConditioningDistribution(self):
        """getConditioningDistribution(ConditionalDistribution self) -> Distribution"""
        return _dist_bundle2.ConditionalDistribution_getConditioningDistribution(self)

    def getMarginal(self, *args):
        """
        getMarginal(ConditionalDistribution self, OT::UnsignedLong const i) -> DistributionImplementationPointer
        getMarginal(ConditionalDistribution self, Indices indices) -> DistributionImplementationPointer
        """
        return _dist_bundle2.ConditionalDistribution_getMarginal(self, *args)

    def __init__(self, *args): 
        """
        __init__(OT::ConditionalDistribution self) -> ConditionalDistribution
        __init__(OT::ConditionalDistribution self, Distribution conditionedDistribution, Distribution conditioningDistribution) -> ConditionalDistribution
        __init__(OT::ConditionalDistribution self, ConditionalDistribution other) -> ConditionalDistribution
        """
        this = _dist_bundle2.new_ConditionalDistribution(*args)
        try: self.this.append(this)
        except: self.this = this
    __swig_destroy__ = _dist_bundle2.delete_ConditionalDistribution
    __del__ = lambda self : None;
ConditionalDistribution_swigregister = _dist_bundle2.ConditionalDistribution_swigregister
ConditionalDistribution_swigregister(ConditionalDistribution)

def ConditionalDistribution_GetClassName():
  """ConditionalDistribution_GetClassName() -> OT::String"""
  return _dist_bundle2.ConditionalDistribution_GetClassName()

class PosteriorDistribution(openturns.model_copula.NonEllipticalDistribution):
    """Proxy of C++ OT::PosteriorDistribution 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, PosteriorDistribution, 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, PosteriorDistribution, name)
    def GetClassName():
        """GetClassName() -> OT::String"""
        return _dist_bundle2.PosteriorDistribution_GetClassName()

    if _newclass:GetClassName = staticmethod(GetClassName)
    __swig_getmethods__["GetClassName"] = lambda x: GetClassName
    def getClassName(self):
        """getClassName(PosteriorDistribution self) -> OT::String"""
        return _dist_bundle2.PosteriorDistribution_getClassName(self)

    def __eq__(self, *args):
        """__eq__(PosteriorDistribution self, PosteriorDistribution other) -> OT::Bool"""
        return _dist_bundle2.PosteriorDistribution___eq__(self, *args)

    def __repr__(self):
        """__repr__(PosteriorDistribution self) -> OT::String"""
        return _dist_bundle2.PosteriorDistribution___repr__(self)

    def __str__(self, offset=""):
        """
        __str__(PosteriorDistribution self, OT::String const & offset="") -> OT::String
        __str__(PosteriorDistribution self) -> OT::String
        """
        return _dist_bundle2.PosteriorDistribution___str__(self, offset)

    def computePDF(self, *args):
        """
        computePDF(PosteriorDistribution self, OT::NumericalScalar const scalar) -> OT::NumericalScalar
        computePDF(PosteriorDistribution self, NumericalPoint point) -> OT::NumericalScalar
        computePDF(PosteriorDistribution self, NumericalSample sample) -> NumericalSample
        computePDF(PosteriorDistribution 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(PosteriorDistribution self, OT::NumericalScalar const xMin, OT::NumericalScalar const xMax, OT::UnsignedLong const pointNumber, 
            NumericalSample grid) -> NumericalSample
        computePDF(PosteriorDistribution self, NumericalPoint xMin, NumericalPoint xMax, Indices pointNumber, NumericalSample grid, 
            OT::NumericalScalar const precision=OT::ResourceMap::GetAsNumericalScalar("DistributionImplementation-DefaultPDFEpsilon")) -> NumericalSample
        computePDF(PosteriorDistribution self, NumericalPoint xMin, NumericalPoint xMax, Indices pointNumber, NumericalSample grid) -> NumericalSample
        computePDF(PosteriorDistribution self, NumericalPoint point) -> OT::NumericalScalar
        """
        return _dist_bundle2.PosteriorDistribution_computePDF(self, *args)

    def computeCDF(self, *args):
        """
        computeCDF(PosteriorDistribution self, OT::NumericalScalar const scalar, OT::Bool const tail) -> OT::NumericalScalar
        computeCDF(PosteriorDistribution self, OT::NumericalScalar const scalar) -> OT::NumericalScalar
        computeCDF(PosteriorDistribution self, NumericalPoint point, OT::Bool const tail) -> OT::NumericalScalar
        computeCDF(PosteriorDistribution self, NumericalPoint point) -> OT::NumericalScalar
        computeCDF(PosteriorDistribution self, NumericalSample sample, OT::Bool const tail) -> NumericalSample
        computeCDF(PosteriorDistribution self, NumericalSample sample) -> NumericalSample
        computeCDF(PosteriorDistribution 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(PosteriorDistribution self, OT::NumericalScalar const xMin, OT::NumericalScalar const xMax, OT::UnsignedLong const pointNumber, 
            NumericalSample grid) -> NumericalSample
        computeCDF(PosteriorDistribution self, NumericalPoint xMin, NumericalPoint xMax, Indices pointNumber, NumericalSample grid, 
            OT::NumericalScalar const precision=OT::ResourceMap::GetAsNumericalScalar("DistributionImplementation-DefaultCDFEpsilon")) -> NumericalSample
        computeCDF(PosteriorDistribution self, NumericalPoint xMin, NumericalPoint xMax, Indices pointNumber, NumericalSample grid) -> NumericalSample
        computeCDF(PosteriorDistribution self, NumericalPoint point) -> OT::NumericalScalar
        """
        return _dist_bundle2.PosteriorDistribution_computeCDF(self, *args)

    def getParametersCollection(self):
        """getParametersCollection(PosteriorDistribution self) -> NumericalPointWithDescriptionCollection"""
        return _dist_bundle2.PosteriorDistribution_getParametersCollection(self)

    def setParametersCollection(self, *args):
        """
        setParametersCollection(PosteriorDistribution self, NumericalPointWithDescriptionCollection parametersCollection)
        setParametersCollection(PosteriorDistribution self, NumericalPointCollection parametersCollection)
        setParametersCollection(PosteriorDistribution self, NumericalPoint parameters)
        setParametersCollection(PosteriorDistribution self, NumericalPointCollection parametersCollection)
        """
        return _dist_bundle2.PosteriorDistribution_setParametersCollection(self, *args)

    def setConditionalDistribution(self, *args):
        """setConditionalDistribution(PosteriorDistribution self, ConditionalDistribution conditionalDistribution)"""
        return _dist_bundle2.PosteriorDistribution_setConditionalDistribution(self, *args)

    def getConditionalDistribution(self):
        """getConditionalDistribution(PosteriorDistribution self) -> ConditionalDistribution"""
        return _dist_bundle2.PosteriorDistribution_getConditionalDistribution(self)

    def setObservations(self, *args):
        """setObservations(PosteriorDistribution self, NumericalSample observations)"""
        return _dist_bundle2.PosteriorDistribution_setObservations(self, *args)

    def getObservations(self):
        """getObservations(PosteriorDistribution self) -> NumericalSample"""
        return _dist_bundle2.PosteriorDistribution_getObservations(self)

    def getLogNormalizationFactor(self):
        """getLogNormalizationFactor(PosteriorDistribution self) -> OT::NumericalScalar"""
        return _dist_bundle2.PosteriorDistribution_getLogNormalizationFactor(self)

    def getStandardDeviation(self):
        """getStandardDeviation(PosteriorDistribution self) -> NumericalPoint"""
        return _dist_bundle2.PosteriorDistribution_getStandardDeviation(self)

    def getSkewness(self):
        """getSkewness(PosteriorDistribution self) -> NumericalPoint"""
        return _dist_bundle2.PosteriorDistribution_getSkewness(self)

    def getKurtosis(self):
        """getKurtosis(PosteriorDistribution self) -> NumericalPoint"""
        return _dist_bundle2.PosteriorDistribution_getKurtosis(self)

    def computeLikelihood(self, *args):
        """computeLikelihood(PosteriorDistribution self, NumericalPoint theta) -> NumericalPoint"""
        return _dist_bundle2.PosteriorDistribution_computeLikelihood(self, *args)

    def __init__(self, *args): 
        """
        __init__(OT::PosteriorDistribution self) -> PosteriorDistribution
        __init__(OT::PosteriorDistribution self, ConditionalDistribution conditionalDistribution, NumericalSample observations) -> PosteriorDistribution
        __init__(OT::PosteriorDistribution self, PosteriorDistribution other) -> PosteriorDistribution
        """
        this = _dist_bundle2.new_PosteriorDistribution(*args)
        try: self.this.append(this)
        except: self.this = this
    __swig_destroy__ = _dist_bundle2.delete_PosteriorDistribution
    __del__ = lambda self : None;
PosteriorDistribution_swigregister = _dist_bundle2.PosteriorDistribution_swigregister
PosteriorDistribution_swigregister(PosteriorDistribution)

def PosteriorDistribution_GetClassName():
  """PosteriorDistribution_GetClassName() -> OT::String"""
  return _dist_bundle2.PosteriorDistribution_GetClassName()

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