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


"""
Bayesian algorithms.
"""


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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

import openturns.base
import openturns.statistics
import openturns.graph
import openturns.func
import openturns.geom
import openturns.diff
import openturns.optim
import openturns.solver
import openturns.algo
import openturns.experiment
import openturns.model_copula
import openturns.dist_bundle1
import openturns.dist_bundle2
import openturns.randomvector
class CalibrationStrategyImplementation(openturns.common.PersistentObject):
    """Proxy of C++ OT::CalibrationStrategyImplementation class"""
    __swig_setmethods__ = {}
    for _s in [openturns.common.PersistentObject]: __swig_setmethods__.update(getattr(_s,'__swig_setmethods__',{}))
    __setattr__ = lambda self, name, value: _swig_setattr(self, CalibrationStrategyImplementation, name, value)
    __swig_getmethods__ = {}
    for _s in [openturns.common.PersistentObject]: __swig_getmethods__.update(getattr(_s,'__swig_getmethods__',{}))
    __getattr__ = lambda self, name: _swig_getattr(self, CalibrationStrategyImplementation, name)
    def GetClassName():
        """GetClassName() -> OT::String"""
        return _bayesian.CalibrationStrategyImplementation_GetClassName()

    if _newclass:GetClassName = staticmethod(GetClassName)
    __swig_getmethods__["GetClassName"] = lambda x: GetClassName
    def getClassName(self):
        """getClassName(CalibrationStrategyImplementation self) -> OT::String"""
        return _bayesian.CalibrationStrategyImplementation_getClassName(self)

    def __repr__(self):
        """__repr__(CalibrationStrategyImplementation self) -> OT::String"""
        return _bayesian.CalibrationStrategyImplementation___repr__(self)

    def setRange(self, *args):
        """setRange(CalibrationStrategyImplementation self, Interval range)"""
        return _bayesian.CalibrationStrategyImplementation_setRange(self, *args)

    def getRange(self):
        """getRange(CalibrationStrategyImplementation self) -> Interval"""
        return _bayesian.CalibrationStrategyImplementation_getRange(self)

    def setExpansionFactor(self, *args):
        """setExpansionFactor(CalibrationStrategyImplementation self, OT::NumericalScalar expansionFactor)"""
        return _bayesian.CalibrationStrategyImplementation_setExpansionFactor(self, *args)

    def getExpansionFactor(self):
        """getExpansionFactor(CalibrationStrategyImplementation self) -> OT::NumericalScalar"""
        return _bayesian.CalibrationStrategyImplementation_getExpansionFactor(self)

    def setShrinkFactor(self, *args):
        """setShrinkFactor(CalibrationStrategyImplementation self, OT::NumericalScalar shrinkFactor)"""
        return _bayesian.CalibrationStrategyImplementation_setShrinkFactor(self, *args)

    def getShrinkFactor(self):
        """getShrinkFactor(CalibrationStrategyImplementation self) -> OT::NumericalScalar"""
        return _bayesian.CalibrationStrategyImplementation_getShrinkFactor(self)

    def setCalibrationStep(self, *args):
        """setCalibrationStep(CalibrationStrategyImplementation self, OT::UnsignedLong const calibrationStep)"""
        return _bayesian.CalibrationStrategyImplementation_setCalibrationStep(self, *args)

    def getCalibrationStep(self):
        """getCalibrationStep(CalibrationStrategyImplementation self) -> OT::UnsignedLong"""
        return _bayesian.CalibrationStrategyImplementation_getCalibrationStep(self)

    def computeUpdateFactor(self, *args):
        """computeUpdateFactor(CalibrationStrategyImplementation self, OT::NumericalScalar const rho) -> OT::NumericalScalar"""
        return _bayesian.CalibrationStrategyImplementation_computeUpdateFactor(self, *args)

    def __init__(self, *args): 
        """
        __init__(OT::CalibrationStrategyImplementation self, Interval range=OT::Interval(ResourceMap::GetAsNumericalScalar("CalibrationStrategyImplementation-DefaultLowerBound"),
                                            ResourceMap::GetAsNumericalScalar("CalibrationStrategyImplementation-DefaultUpperBound")), 
            OT::NumericalScalar const expansionFactor=OT::ResourceMap::GetAsNumericalScalar("CalibrationStrategyImplementation-DefaultExpansionFactor"), 
            OT::NumericalScalar const shrinkFactor=OT::ResourceMap::GetAsNumericalScalar("CalibrationStrategyImplementation-DefaultShrinkFactor"), 
            OT::UnsignedLong const calibrationStep=OT::ResourceMap::GetAsUnsignedLong("CalibrationStrategyImplementation-DefaultCalibrationStep")) -> CalibrationStrategyImplementation
        __init__(OT::CalibrationStrategyImplementation self, Interval range=OT::Interval(ResourceMap::GetAsNumericalScalar("CalibrationStrategyImplementation-DefaultLowerBound"),
                                            ResourceMap::GetAsNumericalScalar("CalibrationStrategyImplementation-DefaultUpperBound")), 
            OT::NumericalScalar const expansionFactor=OT::ResourceMap::GetAsNumericalScalar("CalibrationStrategyImplementation-DefaultExpansionFactor"), 
            OT::NumericalScalar const shrinkFactor=OT::ResourceMap::GetAsNumericalScalar("CalibrationStrategyImplementation-DefaultShrinkFactor")) -> CalibrationStrategyImplementation
        __init__(OT::CalibrationStrategyImplementation self, Interval range=OT::Interval(ResourceMap::GetAsNumericalScalar("CalibrationStrategyImplementation-DefaultLowerBound"),
                                            ResourceMap::GetAsNumericalScalar("CalibrationStrategyImplementation-DefaultUpperBound")), 
            OT::NumericalScalar const expansionFactor=OT::ResourceMap::GetAsNumericalScalar("CalibrationStrategyImplementation-DefaultExpansionFactor")) -> CalibrationStrategyImplementation
        __init__(OT::CalibrationStrategyImplementation self, Interval range=OT::Interval(ResourceMap::GetAsNumericalScalar("CalibrationStrategyImplementation-DefaultLowerBound"),
                                            ResourceMap::GetAsNumericalScalar("CalibrationStrategyImplementation-DefaultUpperBound"))) -> CalibrationStrategyImplementation
        __init__(OT::CalibrationStrategyImplementation self) -> CalibrationStrategyImplementation
        __init__(OT::CalibrationStrategyImplementation self, CalibrationStrategyImplementation other) -> CalibrationStrategyImplementation
        """
        this = _bayesian.new_CalibrationStrategyImplementation(*args)
        try: self.this.append(this)
        except: self.this = this
    __swig_destroy__ = _bayesian.delete_CalibrationStrategyImplementation
    __del__ = lambda self : None;
CalibrationStrategyImplementation_swigregister = _bayesian.CalibrationStrategyImplementation_swigregister
CalibrationStrategyImplementation_swigregister(CalibrationStrategyImplementation)

def CalibrationStrategyImplementation_GetClassName():
  """CalibrationStrategyImplementation_GetClassName() -> OT::String"""
  return _bayesian.CalibrationStrategyImplementation_GetClassName()

class CalibrationStrategyImplementationTypedInterfaceObject(openturns.common.InterfaceObject):
    """Proxy of C++ OT::TypedInterfaceObject<(OT::CalibrationStrategyImplementation)> class"""
    __swig_setmethods__ = {}
    for _s in [openturns.common.InterfaceObject]: __swig_setmethods__.update(getattr(_s,'__swig_setmethods__',{}))
    __setattr__ = lambda self, name, value: _swig_setattr(self, CalibrationStrategyImplementationTypedInterfaceObject, name, value)
    __swig_getmethods__ = {}
    for _s in [openturns.common.InterfaceObject]: __swig_getmethods__.update(getattr(_s,'__swig_getmethods__',{}))
    __getattr__ = lambda self, name: _swig_getattr(self, CalibrationStrategyImplementationTypedInterfaceObject, name)
    __repr__ = _swig_repr
    def __init__(self, *args): 
        """
        __init__(OT::TypedInterfaceObject<(OT::CalibrationStrategyImplementation)> self) -> CalibrationStrategyImplementationTypedInterfaceObject
        __init__(OT::TypedInterfaceObject<(OT::CalibrationStrategyImplementation)> self, CalibrationStrategyImplementationPointer impl) -> CalibrationStrategyImplementationTypedInterfaceObject
        """
        this = _bayesian.new_CalibrationStrategyImplementationTypedInterfaceObject(*args)
        try: self.this.append(this)
        except: self.this = this
    def getImplementation(self, *args):
        """
        getImplementation(CalibrationStrategyImplementationTypedInterfaceObject self) -> CalibrationStrategyImplementationPointer
        getImplementation(CalibrationStrategyImplementationTypedInterfaceObject self) -> CalibrationStrategyImplementationPointer
        """
        return _bayesian.CalibrationStrategyImplementationTypedInterfaceObject_getImplementation(self, *args)

    def getImplementationAsPersistentObject(self):
        """getImplementationAsPersistentObject(CalibrationStrategyImplementationTypedInterfaceObject self) -> PersistentObjectPointer"""
        return _bayesian.CalibrationStrategyImplementationTypedInterfaceObject_getImplementationAsPersistentObject(self)

    def setImplementationAsPersistentObject(self, *args):
        """setImplementationAsPersistentObject(CalibrationStrategyImplementationTypedInterfaceObject self, PersistentObjectPointer obj)"""
        return _bayesian.CalibrationStrategyImplementationTypedInterfaceObject_setImplementationAsPersistentObject(self, *args)

    def swap(self, *args):
        """swap(CalibrationStrategyImplementationTypedInterfaceObject self, CalibrationStrategyImplementationTypedInterfaceObject other)"""
        return _bayesian.CalibrationStrategyImplementationTypedInterfaceObject_swap(self, *args)

    def setName(self, *args):
        """setName(CalibrationStrategyImplementationTypedInterfaceObject self, OT::String const & name)"""
        return _bayesian.CalibrationStrategyImplementationTypedInterfaceObject_setName(self, *args)

    def getName(self):
        """getName(CalibrationStrategyImplementationTypedInterfaceObject self) -> OT::String"""
        return _bayesian.CalibrationStrategyImplementationTypedInterfaceObject_getName(self)

    def __eq__(self, *args):
        """__eq__(CalibrationStrategyImplementationTypedInterfaceObject self, CalibrationStrategyImplementationTypedInterfaceObject other) -> OT::Bool"""
        return _bayesian.CalibrationStrategyImplementationTypedInterfaceObject___eq__(self, *args)

    __swig_destroy__ = _bayesian.delete_CalibrationStrategyImplementationTypedInterfaceObject
    __del__ = lambda self : None;
CalibrationStrategyImplementationTypedInterfaceObject_swigregister = _bayesian.CalibrationStrategyImplementationTypedInterfaceObject_swigregister
CalibrationStrategyImplementationTypedInterfaceObject_swigregister(CalibrationStrategyImplementationTypedInterfaceObject)

class CalibrationStrategyCollection(_object):
    """Proxy of C++ OT::Collection<(OT::CalibrationStrategy)> class"""
    __swig_setmethods__ = {}
    __setattr__ = lambda self, name, value: _swig_setattr(self, CalibrationStrategyCollection, name, value)
    __swig_getmethods__ = {}
    __getattr__ = lambda self, name: _swig_getattr(self, CalibrationStrategyCollection, name)
    __swig_destroy__ = _bayesian.delete_CalibrationStrategyCollection
    __del__ = lambda self : None;
    def clear(self):
        """clear(CalibrationStrategyCollection self)"""
        return _bayesian.CalibrationStrategyCollection_clear(self)

    def __len__(self):
        """__len__(CalibrationStrategyCollection self) -> OT::UnsignedLong"""
        return _bayesian.CalibrationStrategyCollection___len__(self)

    def __eq__(self, *args):
        """__eq__(CalibrationStrategyCollection self, CalibrationStrategyCollection rhs) -> OT::Bool"""
        return _bayesian.CalibrationStrategyCollection___eq__(self, *args)

    def __contains__(self, *args):
        """__contains__(CalibrationStrategyCollection self, CalibrationStrategy val) -> OT::Bool"""
        return _bayesian.CalibrationStrategyCollection___contains__(self, *args)

    def __getitem__(self, *args):
        """__getitem__(CalibrationStrategyCollection self, OT::UnsignedLong const i) -> CalibrationStrategy"""
        return _bayesian.CalibrationStrategyCollection___getitem__(self, *args)

    def __setitem__(self, *args):
        """__setitem__(CalibrationStrategyCollection self, OT::UnsignedLong const i, CalibrationStrategy val)"""
        return _bayesian.CalibrationStrategyCollection___setitem__(self, *args)

    def __delitem__(self, *args):
        """__delitem__(CalibrationStrategyCollection self, OT::UnsignedLong const i)"""
        return _bayesian.CalibrationStrategyCollection___delitem__(self, *args)

    def at(self, *args):
        """
        at(CalibrationStrategyCollection self, OT::UnsignedLong const i) -> CalibrationStrategy
        at(CalibrationStrategyCollection self, OT::UnsignedLong const i) -> CalibrationStrategy
        """
        return _bayesian.CalibrationStrategyCollection_at(self, *args)

    def add(self, *args):
        """
        add(CalibrationStrategyCollection self, CalibrationStrategy elt)
        add(CalibrationStrategyCollection self, CalibrationStrategyCollection coll)
        """
        return _bayesian.CalibrationStrategyCollection_add(self, *args)

    def getSize(self):
        """getSize(CalibrationStrategyCollection self) -> OT::UnsignedLong"""
        return _bayesian.CalibrationStrategyCollection_getSize(self)

    def resize(self, *args):
        """resize(CalibrationStrategyCollection self, OT::UnsignedLong const newSize)"""
        return _bayesian.CalibrationStrategyCollection_resize(self, *args)

    def isEmpty(self):
        """isEmpty(CalibrationStrategyCollection self) -> OT::Bool"""
        return _bayesian.CalibrationStrategyCollection_isEmpty(self)

    def __repr__(self):
        """__repr__(CalibrationStrategyCollection self) -> OT::String"""
        return _bayesian.CalibrationStrategyCollection___repr__(self)

    def __str__(self, offset=""):
        """
        __str__(CalibrationStrategyCollection self, OT::String const & offset="") -> OT::String
        __str__(CalibrationStrategyCollection self) -> OT::String
        """
        return _bayesian.CalibrationStrategyCollection___str__(self, offset)

    def __init__(self, *args): 
        """
        __init__(OT::Collection<(OT::CalibrationStrategy)> self) -> CalibrationStrategyCollection
        __init__(OT::Collection<(OT::CalibrationStrategy)> self, OT::UnsignedLong const size) -> CalibrationStrategyCollection
        __init__(OT::Collection<(OT::CalibrationStrategy)> self, OT::UnsignedLong const size, CalibrationStrategy value) -> CalibrationStrategyCollection
        __init__(OT::Collection<(OT::CalibrationStrategy)> self, PyObject * pyObj) -> CalibrationStrategyCollection
        __init__(OT::Collection<(OT::CalibrationStrategy)> self, CalibrationStrategyCollection other) -> CalibrationStrategyCollection
        """
        this = _bayesian.new_CalibrationStrategyCollection(*args)
        try: self.this.append(this)
        except: self.this = this
CalibrationStrategyCollection_swigregister = _bayesian.CalibrationStrategyCollection_swigregister
CalibrationStrategyCollection_swigregister(CalibrationStrategyCollection)

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

    if _newclass:GetClassName = staticmethod(GetClassName)
    __swig_getmethods__["GetClassName"] = lambda x: GetClassName
    def getClassName(self):
        """getClassName(CalibrationStrategy self) -> OT::String"""
        return _bayesian.CalibrationStrategy_getClassName(self)

    def setRange(self, *args):
        """setRange(CalibrationStrategy self, Interval range)"""
        return _bayesian.CalibrationStrategy_setRange(self, *args)

    def getRange(self):
        """getRange(CalibrationStrategy self) -> Interval"""
        return _bayesian.CalibrationStrategy_getRange(self)

    def setExpansionFactor(self, *args):
        """setExpansionFactor(CalibrationStrategy self, OT::NumericalScalar const expansionFactor)"""
        return _bayesian.CalibrationStrategy_setExpansionFactor(self, *args)

    def getExpansionFactor(self):
        """getExpansionFactor(CalibrationStrategy self) -> OT::NumericalScalar"""
        return _bayesian.CalibrationStrategy_getExpansionFactor(self)

    def setShrinkFactor(self, *args):
        """setShrinkFactor(CalibrationStrategy self, OT::NumericalScalar const shrinkFactor)"""
        return _bayesian.CalibrationStrategy_setShrinkFactor(self, *args)

    def getShrinkFactor(self):
        """getShrinkFactor(CalibrationStrategy self) -> OT::NumericalScalar"""
        return _bayesian.CalibrationStrategy_getShrinkFactor(self)

    def setCalibrationStep(self, *args):
        """setCalibrationStep(CalibrationStrategy self, OT::UnsignedLong const calibrationStep)"""
        return _bayesian.CalibrationStrategy_setCalibrationStep(self, *args)

    def getCalibrationStep(self):
        """getCalibrationStep(CalibrationStrategy self) -> OT::UnsignedLong"""
        return _bayesian.CalibrationStrategy_getCalibrationStep(self)

    def computeUpdateFactor(self, *args):
        """computeUpdateFactor(CalibrationStrategy self, OT::NumericalScalar const rho) -> OT::NumericalScalar"""
        return _bayesian.CalibrationStrategy_computeUpdateFactor(self, *args)

    def __str__(self):
        """__str__(CalibrationStrategy self) -> OT::String const"""
        return _bayesian.CalibrationStrategy___str__(self)

    def __init__(self, *args): 
        """
        __init__(OT::CalibrationStrategy self) -> CalibrationStrategy
        __init__(OT::CalibrationStrategy self, Interval range) -> CalibrationStrategy
        __init__(OT::CalibrationStrategy self, Interval range, OT::NumericalScalar const expansionFactor, OT::NumericalScalar const shrinkFactor) -> CalibrationStrategy
        __init__(OT::CalibrationStrategy self, Interval range, OT::NumericalScalar const expansionFactor, OT::NumericalScalar const shrinkFactor, 
            OT::UnsignedLong const calibrationStep) -> CalibrationStrategy
        __init__(OT::CalibrationStrategy self, CalibrationStrategyImplementation op) -> CalibrationStrategy
        __init__(OT::CalibrationStrategy self, CalibrationStrategy other) -> CalibrationStrategy
        """
        this = _bayesian.new_CalibrationStrategy(*args)
        try: self.this.append(this)
        except: self.this = this
    __swig_destroy__ = _bayesian.delete_CalibrationStrategy
    __del__ = lambda self : None;
CalibrationStrategy_swigregister = _bayesian.CalibrationStrategy_swigregister
CalibrationStrategy_swigregister(CalibrationStrategy)

def CalibrationStrategy_GetClassName():
  """CalibrationStrategy_GetClassName() -> OT::String"""
  return _bayesian.CalibrationStrategy_GetClassName()

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

    if _newclass:GetClassName = staticmethod(GetClassName)
    __swig_getmethods__["GetClassName"] = lambda x: GetClassName
    def getClassName(self):
        """getClassName(SamplerImplementation self) -> OT::String"""
        return _bayesian.SamplerImplementation_getClassName(self)

    def setVerbose(self, *args):
        """setVerbose(SamplerImplementation self, OT::Bool const verbose)"""
        return _bayesian.SamplerImplementation_setVerbose(self, *args)

    def getVerbose(self):
        """getVerbose(SamplerImplementation self) -> OT::Bool"""
        return _bayesian.SamplerImplementation_getVerbose(self)

    def __repr__(self):
        """__repr__(SamplerImplementation self) -> OT::String"""
        return _bayesian.SamplerImplementation___repr__(self)

    def getDimension(self):
        """getDimension(SamplerImplementation self) -> OT::UnsignedLong"""
        return _bayesian.SamplerImplementation_getDimension(self)

    def getRealization(self):
        """getRealization(SamplerImplementation self) -> NumericalPoint"""
        return _bayesian.SamplerImplementation_getRealization(self)

    def getSample(self, *args):
        """getSample(SamplerImplementation self, OT::UnsignedLong const size) -> NumericalSample"""
        return _bayesian.SamplerImplementation_getSample(self, *args)

    def __init__(self, *args): 
        """
        __init__(OT::SamplerImplementation self) -> SamplerImplementation
        __init__(OT::SamplerImplementation self, SamplerImplementation other) -> SamplerImplementation
        """
        this = _bayesian.new_SamplerImplementation(*args)
        try: self.this.append(this)
        except: self.this = this
    __swig_destroy__ = _bayesian.delete_SamplerImplementation
    __del__ = lambda self : None;
SamplerImplementation_swigregister = _bayesian.SamplerImplementation_swigregister
SamplerImplementation_swigregister(SamplerImplementation)

def SamplerImplementation_GetClassName():
  """SamplerImplementation_GetClassName() -> OT::String"""
  return _bayesian.SamplerImplementation_GetClassName()

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

    def getImplementationAsPersistentObject(self):
        """getImplementationAsPersistentObject(SamplerImplementationTypedInterfaceObject self) -> PersistentObjectPointer"""
        return _bayesian.SamplerImplementationTypedInterfaceObject_getImplementationAsPersistentObject(self)

    def setImplementationAsPersistentObject(self, *args):
        """setImplementationAsPersistentObject(SamplerImplementationTypedInterfaceObject self, PersistentObjectPointer obj)"""
        return _bayesian.SamplerImplementationTypedInterfaceObject_setImplementationAsPersistentObject(self, *args)

    def swap(self, *args):
        """swap(SamplerImplementationTypedInterfaceObject self, SamplerImplementationTypedInterfaceObject other)"""
        return _bayesian.SamplerImplementationTypedInterfaceObject_swap(self, *args)

    def setName(self, *args):
        """setName(SamplerImplementationTypedInterfaceObject self, OT::String const & name)"""
        return _bayesian.SamplerImplementationTypedInterfaceObject_setName(self, *args)

    def getName(self):
        """getName(SamplerImplementationTypedInterfaceObject self) -> OT::String"""
        return _bayesian.SamplerImplementationTypedInterfaceObject_getName(self)

    def __eq__(self, *args):
        """__eq__(SamplerImplementationTypedInterfaceObject self, SamplerImplementationTypedInterfaceObject other) -> OT::Bool"""
        return _bayesian.SamplerImplementationTypedInterfaceObject___eq__(self, *args)

    __swig_destroy__ = _bayesian.delete_SamplerImplementationTypedInterfaceObject
    __del__ = lambda self : None;
SamplerImplementationTypedInterfaceObject_swigregister = _bayesian.SamplerImplementationTypedInterfaceObject_swigregister
SamplerImplementationTypedInterfaceObject_swigregister(SamplerImplementationTypedInterfaceObject)

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

    if _newclass:GetClassName = staticmethod(GetClassName)
    __swig_getmethods__["GetClassName"] = lambda x: GetClassName
    def getClassName(self):
        """getClassName(Sampler self) -> OT::String"""
        return _bayesian.Sampler_getClassName(self)

    def setVerbose(self, *args):
        """setVerbose(Sampler self, OT::Bool const verbose)"""
        return _bayesian.Sampler_setVerbose(self, *args)

    def getVerbose(self):
        """getVerbose(Sampler self) -> OT::Bool"""
        return _bayesian.Sampler_getVerbose(self)

    def getDimension(self):
        """getDimension(Sampler self) -> OT::UnsignedLong"""
        return _bayesian.Sampler_getDimension(self)

    def getRealization(self):
        """getRealization(Sampler self) -> NumericalPoint"""
        return _bayesian.Sampler_getRealization(self)

    def getSample(self, *args):
        """getSample(Sampler self, OT::UnsignedLong const size) -> NumericalSample"""
        return _bayesian.Sampler_getSample(self, *args)

    def __str__(self):
        """__str__(Sampler self) -> OT::String const"""
        return _bayesian.Sampler___str__(self)

    def __init__(self, *args): 
        """
        __init__(OT::Sampler self) -> Sampler
        __init__(OT::Sampler self, SamplerImplementation op) -> Sampler
        __init__(OT::Sampler self, Sampler other) -> Sampler
        """
        this = _bayesian.new_Sampler(*args)
        try: self.this.append(this)
        except: self.this = this
    __swig_destroy__ = _bayesian.delete_Sampler
    __del__ = lambda self : None;
Sampler_swigregister = _bayesian.Sampler_swigregister
Sampler_swigregister(Sampler)

def Sampler_GetClassName():
  """Sampler_GetClassName() -> OT::String"""
  return _bayesian.Sampler_GetClassName()

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

    if _newclass:GetClassName = staticmethod(GetClassName)
    __swig_getmethods__["GetClassName"] = lambda x: GetClassName
    def getClassName(self):
        """getClassName(MCMC self) -> OT::String"""
        return _bayesian.MCMC_getClassName(self)

    def __repr__(self):
        """__repr__(MCMC self) -> OT::String"""
        return _bayesian.MCMC___repr__(self)

    def computeLogLikelihood(self, *args):
        """computeLogLikelihood(MCMC self, NumericalPoint currentState) -> OT::NumericalScalar"""
        return _bayesian.MCMC_computeLogLikelihood(self, *args)

    def setPrior(self, *args):
        """setPrior(MCMC self, Distribution prior)"""
        return _bayesian.MCMC_setPrior(self, *args)

    def getPrior(self):
        """getPrior(MCMC self) -> Distribution"""
        return _bayesian.MCMC_getPrior(self)

    def getConditional(self):
        """getConditional(MCMC self) -> Distribution"""
        return _bayesian.MCMC_getConditional(self)

    def getModel(self):
        """getModel(MCMC self) -> NumericalMathFunction"""
        return _bayesian.MCMC_getModel(self)

    def setObservations(self, *args):
        """setObservations(MCMC self, NumericalSample observations)"""
        return _bayesian.MCMC_setObservations(self, *args)

    def getObservations(self):
        """getObservations(MCMC self) -> NumericalSample"""
        return _bayesian.MCMC_getObservations(self)

    def setBurnIn(self, *args):
        """setBurnIn(MCMC self, OT::UnsignedLong burnIn)"""
        return _bayesian.MCMC_setBurnIn(self, *args)

    def getBurnIn(self):
        """getBurnIn(MCMC self) -> OT::UnsignedLong"""
        return _bayesian.MCMC_getBurnIn(self)

    def setThinning(self, *args):
        """setThinning(MCMC self, OT::UnsignedLong thinning)"""
        return _bayesian.MCMC_setThinning(self, *args)

    def getThinning(self):
        """getThinning(MCMC self) -> OT::UnsignedLong"""
        return _bayesian.MCMC_getThinning(self)

    def getDimension(self):
        """getDimension(MCMC self) -> OT::UnsignedLong"""
        return _bayesian.MCMC_getDimension(self)

    def __init__(self, *args): 
        """
        __init__(OT::MCMC self) -> MCMC
        __init__(OT::MCMC self, Distribution prior, Distribution conditional, NumericalSample observations, NumericalPoint initialState) -> MCMC
        __init__(OT::MCMC self, Distribution prior, Distribution conditional, NumericalMathFunction model, NumericalSample observations, 
            NumericalPoint initialState) -> MCMC
        __init__(OT::MCMC self, MCMC other) -> MCMC
        """
        this = _bayesian.new_MCMC(*args)
        try: self.this.append(this)
        except: self.this = this
    __swig_destroy__ = _bayesian.delete_MCMC
    __del__ = lambda self : None;
MCMC_swigregister = _bayesian.MCMC_swigregister
MCMC_swigregister(MCMC)

def MCMC_GetClassName():
  """MCMC_GetClassName() -> OT::String"""
  return _bayesian.MCMC_GetClassName()

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

    if _newclass:GetClassName = staticmethod(GetClassName)
    __swig_getmethods__["GetClassName"] = lambda x: GetClassName
    def getClassName(self):
        """getClassName(RandomWalkMetropolisHastings self) -> OT::String"""
        return _bayesian.RandomWalkMetropolisHastings_getClassName(self)

    def __repr__(self):
        """__repr__(RandomWalkMetropolisHastings self) -> OT::String"""
        return _bayesian.RandomWalkMetropolisHastings___repr__(self)

    def getRealization(self):
        """getRealization(RandomWalkMetropolisHastings self) -> NumericalPoint"""
        return _bayesian.RandomWalkMetropolisHastings_getRealization(self)

    def setCalibrationStrategy(self, *args):
        """setCalibrationStrategy(RandomWalkMetropolisHastings self, CalibrationStrategy calibrationStrategy)"""
        return _bayesian.RandomWalkMetropolisHastings_setCalibrationStrategy(self, *args)

    def setCalibrationStrategyPerComponent(self, *args):
        """setCalibrationStrategyPerComponent(RandomWalkMetropolisHastings self, CalibrationStrategyCollection calibrationStrategy)"""
        return _bayesian.RandomWalkMetropolisHastings_setCalibrationStrategyPerComponent(self, *args)

    def getCalibrationStrategyPerComponent(self):
        """getCalibrationStrategyPerComponent(RandomWalkMetropolisHastings self) -> CalibrationStrategyCollection"""
        return _bayesian.RandomWalkMetropolisHastings_getCalibrationStrategyPerComponent(self)

    def setProposal(self, *args):
        """setProposal(RandomWalkMetropolisHastings self, DistributionCollection proposal)"""
        return _bayesian.RandomWalkMetropolisHastings_setProposal(self, *args)

    def getProposal(self):
        """getProposal(RandomWalkMetropolisHastings self) -> DistributionCollection"""
        return _bayesian.RandomWalkMetropolisHastings_getProposal(self)

    def getAcceptanceRate(self):
        """getAcceptanceRate(RandomWalkMetropolisHastings self) -> NumericalPoint"""
        return _bayesian.RandomWalkMetropolisHastings_getAcceptanceRate(self)

    def __init__(self, *args): 
        """
        __init__(OT::RandomWalkMetropolisHastings self) -> RandomWalkMetropolisHastings
        __init__(OT::RandomWalkMetropolisHastings self, Distribution prior, Distribution conditional, NumericalSample observations, NumericalPoint initialState, 
            DistributionCollection proposal) -> RandomWalkMetropolisHastings
        __init__(OT::RandomWalkMetropolisHastings self, Distribution prior, Distribution conditional, NumericalMathFunction model, NumericalSample observations, 
            NumericalPoint initialState, DistributionCollection proposal) -> RandomWalkMetropolisHastings
        __init__(OT::RandomWalkMetropolisHastings self, RandomWalkMetropolisHastings other) -> RandomWalkMetropolisHastings
        """
        this = _bayesian.new_RandomWalkMetropolisHastings(*args)
        try: self.this.append(this)
        except: self.this = this
    __swig_destroy__ = _bayesian.delete_RandomWalkMetropolisHastings
    __del__ = lambda self : None;
RandomWalkMetropolisHastings_swigregister = _bayesian.RandomWalkMetropolisHastings_swigregister
RandomWalkMetropolisHastings_swigregister(RandomWalkMetropolisHastings)

def RandomWalkMetropolisHastings_GetClassName():
  """RandomWalkMetropolisHastings_GetClassName() -> OT::String"""
  return _bayesian.RandomWalkMetropolisHastings_GetClassName()

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

    if _newclass:GetClassName = staticmethod(GetClassName)
    __swig_getmethods__["GetClassName"] = lambda x: GetClassName
    def getClassName(self):
        """getClassName(PosteriorRandomVector self) -> OT::String"""
        return _bayesian.PosteriorRandomVector_getClassName(self)

    def __repr__(self):
        """__repr__(PosteriorRandomVector self) -> OT::String"""
        return _bayesian.PosteriorRandomVector___repr__(self)

    def getSampler(self):
        """getSampler(PosteriorRandomVector self) -> Sampler"""
        return _bayesian.PosteriorRandomVector_getSampler(self)

    def getDimension(self):
        """getDimension(PosteriorRandomVector self) -> OT::UnsignedLong"""
        return _bayesian.PosteriorRandomVector_getDimension(self)

    def getRealization(self):
        """getRealization(PosteriorRandomVector self) -> NumericalPoint"""
        return _bayesian.PosteriorRandomVector_getRealization(self)

    def getSample(self, *args):
        """getSample(PosteriorRandomVector self, OT::UnsignedLong const size) -> NumericalSample"""
        return _bayesian.PosteriorRandomVector_getSample(self, *args)

    def __init__(self, *args): 
        """
        __init__(OT::PosteriorRandomVector self, Sampler sampler) -> PosteriorRandomVector
        __init__(OT::PosteriorRandomVector self, PosteriorRandomVector other) -> PosteriorRandomVector
        """
        this = _bayesian.new_PosteriorRandomVector(*args)
        try: self.this.append(this)
        except: self.this = this
    __swig_destroy__ = _bayesian.delete_PosteriorRandomVector
    __del__ = lambda self : None;
PosteriorRandomVector_swigregister = _bayesian.PosteriorRandomVector_swigregister
PosteriorRandomVector_swigregister(PosteriorRandomVector)

def PosteriorRandomVector_GetClassName():
  """PosteriorRandomVector_GetClassName() -> OT::String"""
  return _bayesian.PosteriorRandomVector_GetClassName()

class CalibrationStrategyImplementationPointer(_object):
    """Proxy of C++ OT::Pointer<(OT::CalibrationStrategyImplementation)> class"""
    __swig_setmethods__ = {}
    __setattr__ = lambda self, name, value: _swig_setattr(self, CalibrationStrategyImplementationPointer, name, value)
    __swig_getmethods__ = {}
    __getattr__ = lambda self, name: _swig_getattr(self, CalibrationStrategyImplementationPointer, name)
    __swig_setmethods__["ptr_"] = _bayesian.CalibrationStrategyImplementationPointer_ptr__set
    __swig_getmethods__["ptr_"] = _bayesian.CalibrationStrategyImplementationPointer_ptr__get
    if _newclass:ptr_ = _swig_property(_bayesian.CalibrationStrategyImplementationPointer_ptr__get, _bayesian.CalibrationStrategyImplementationPointer_ptr__set)
    def __init__(self, *args): 
        """
        __init__(OT::Pointer<(OT::CalibrationStrategyImplementation)> self) -> CalibrationStrategyImplementationPointer
        __init__(OT::Pointer<(OT::CalibrationStrategyImplementation)> self, CalibrationStrategyImplementation ptr) -> CalibrationStrategyImplementationPointer
        """
        this = _bayesian.new_CalibrationStrategyImplementationPointer(*args)
        try: self.this.append(this)
        except: self.this = this
    __swig_destroy__ = _bayesian.delete_CalibrationStrategyImplementationPointer
    __del__ = lambda self : None;
    def reset(self):
        """reset(CalibrationStrategyImplementationPointer self)"""
        return _bayesian.CalibrationStrategyImplementationPointer_reset(self)

    def __ref__(self, *args):
        """
        __ref__(CalibrationStrategyImplementationPointer self) -> CalibrationStrategyImplementation
        __ref__(CalibrationStrategyImplementationPointer self) -> CalibrationStrategyImplementation
        """
        return _bayesian.CalibrationStrategyImplementationPointer___ref__(self, *args)

    def __deref__(self):
        """__deref__(CalibrationStrategyImplementationPointer self) -> CalibrationStrategyImplementation"""
        return _bayesian.CalibrationStrategyImplementationPointer___deref__(self)

    def isNull(self):
        """isNull(CalibrationStrategyImplementationPointer self) -> OT::Bool"""
        return _bayesian.CalibrationStrategyImplementationPointer_isNull(self)

    def __nonzero__(self):
        return _bayesian.CalibrationStrategyImplementationPointer___nonzero__(self)
    __bool__ = __nonzero__


    def get(self):
        """get(CalibrationStrategyImplementationPointer self) -> CalibrationStrategyImplementation"""
        return _bayesian.CalibrationStrategyImplementationPointer_get(self)

    def getImplementation(self):
        """getImplementation(CalibrationStrategyImplementationPointer self) -> OT::Pointer< OT::CalibrationStrategyImplementation >::pointer_type const &"""
        return _bayesian.CalibrationStrategyImplementationPointer_getImplementation(self)

    def unique(self):
        """unique(CalibrationStrategyImplementationPointer self) -> OT::Bool"""
        return _bayesian.CalibrationStrategyImplementationPointer_unique(self)

    def use_count(self):
        """use_count(CalibrationStrategyImplementationPointer self) -> OT::UnsignedLong"""
        return _bayesian.CalibrationStrategyImplementationPointer_use_count(self)

    def swap(self, *args):
        """swap(CalibrationStrategyImplementationPointer self, CalibrationStrategyImplementationPointer other)"""
        return _bayesian.CalibrationStrategyImplementationPointer_swap(self, *args)

    def GetClassName(self):
        """GetClassName(CalibrationStrategyImplementationPointer self) -> OT::String"""
        return _bayesian.CalibrationStrategyImplementationPointer_GetClassName(self)

    def getClassName(self):
        """getClassName(CalibrationStrategyImplementationPointer self) -> OT::String"""
        return _bayesian.CalibrationStrategyImplementationPointer_getClassName(self)

    def __repr__(self):
        """__repr__(CalibrationStrategyImplementationPointer self) -> OT::String"""
        return _bayesian.CalibrationStrategyImplementationPointer___repr__(self)

    def setRange(self, *args):
        """setRange(CalibrationStrategyImplementationPointer self, Interval range)"""
        return _bayesian.CalibrationStrategyImplementationPointer_setRange(self, *args)

    def getRange(self):
        """getRange(CalibrationStrategyImplementationPointer self) -> Interval"""
        return _bayesian.CalibrationStrategyImplementationPointer_getRange(self)

    def setExpansionFactor(self, *args):
        """setExpansionFactor(CalibrationStrategyImplementationPointer self, OT::NumericalScalar expansionFactor)"""
        return _bayesian.CalibrationStrategyImplementationPointer_setExpansionFactor(self, *args)

    def getExpansionFactor(self):
        """getExpansionFactor(CalibrationStrategyImplementationPointer self) -> OT::NumericalScalar"""
        return _bayesian.CalibrationStrategyImplementationPointer_getExpansionFactor(self)

    def setShrinkFactor(self, *args):
        """setShrinkFactor(CalibrationStrategyImplementationPointer self, OT::NumericalScalar shrinkFactor)"""
        return _bayesian.CalibrationStrategyImplementationPointer_setShrinkFactor(self, *args)

    def getShrinkFactor(self):
        """getShrinkFactor(CalibrationStrategyImplementationPointer self) -> OT::NumericalScalar"""
        return _bayesian.CalibrationStrategyImplementationPointer_getShrinkFactor(self)

    def setCalibrationStep(self, *args):
        """setCalibrationStep(CalibrationStrategyImplementationPointer self, OT::UnsignedLong const calibrationStep)"""
        return _bayesian.CalibrationStrategyImplementationPointer_setCalibrationStep(self, *args)

    def getCalibrationStep(self):
        """getCalibrationStep(CalibrationStrategyImplementationPointer self) -> OT::UnsignedLong"""
        return _bayesian.CalibrationStrategyImplementationPointer_getCalibrationStep(self)

    def computeUpdateFactor(self, *args):
        """computeUpdateFactor(CalibrationStrategyImplementationPointer self, OT::NumericalScalar const rho) -> OT::NumericalScalar"""
        return _bayesian.CalibrationStrategyImplementationPointer_computeUpdateFactor(self, *args)

    def __eq__(self, *args):
        """__eq__(CalibrationStrategyImplementationPointer self, PersistentObject other) -> OT::Bool"""
        return _bayesian.CalibrationStrategyImplementationPointer___eq__(self, *args)

    def Is(self, *args):
        """Is(CalibrationStrategyImplementationPointer self, PersistentObject other) -> OT::Bool"""
        return _bayesian.CalibrationStrategyImplementationPointer_Is(self, *args)

    def __str__(self, offset=""):
        """
        __str__(CalibrationStrategyImplementationPointer self, OT::String const & offset="") -> OT::String
        __str__(CalibrationStrategyImplementationPointer self) -> OT::String
        """
        return _bayesian.CalibrationStrategyImplementationPointer___str__(self, offset)

    def getId(self):
        """getId(CalibrationStrategyImplementationPointer self) -> OT::Id"""
        return _bayesian.CalibrationStrategyImplementationPointer_getId(self)

    def setShadowedId(self, *args):
        """setShadowedId(CalibrationStrategyImplementationPointer self, OT::Id id)"""
        return _bayesian.CalibrationStrategyImplementationPointer_setShadowedId(self, *args)

    def getShadowedId(self):
        """getShadowedId(CalibrationStrategyImplementationPointer self) -> OT::Id"""
        return _bayesian.CalibrationStrategyImplementationPointer_getShadowedId(self)

    def setVisibility(self, *args):
        """setVisibility(CalibrationStrategyImplementationPointer self, OT::Bool visible)"""
        return _bayesian.CalibrationStrategyImplementationPointer_setVisibility(self, *args)

    def getVisibility(self):
        """getVisibility(CalibrationStrategyImplementationPointer self) -> OT::Bool"""
        return _bayesian.CalibrationStrategyImplementationPointer_getVisibility(self)

    def hasName(self):
        """hasName(CalibrationStrategyImplementationPointer self) -> OT::Bool"""
        return _bayesian.CalibrationStrategyImplementationPointer_hasName(self)

    def hasVisibleName(self):
        """hasVisibleName(CalibrationStrategyImplementationPointer self) -> OT::Bool"""
        return _bayesian.CalibrationStrategyImplementationPointer_hasVisibleName(self)

    def getName(self):
        """getName(CalibrationStrategyImplementationPointer self) -> OT::String"""
        return _bayesian.CalibrationStrategyImplementationPointer_getName(self)

    def setName(self, *args):
        """setName(CalibrationStrategyImplementationPointer self, OT::String const & name)"""
        return _bayesian.CalibrationStrategyImplementationPointer_setName(self, *args)

CalibrationStrategyImplementationPointer_swigregister = _bayesian.CalibrationStrategyImplementationPointer_swigregister
CalibrationStrategyImplementationPointer_swigregister(CalibrationStrategyImplementationPointer)

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