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


"""
Statistical classes.
"""


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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

    if _newclass:GetClassName = staticmethod(GetClassName)
    __swig_getmethods__["GetClassName"] = lambda x: GetClassName
    def getClassName(self):
        """getClassName(Compact self) -> OT::String"""
        return _statistics.Compact_getClassName(self)

    def store(self, *args):
        """
        store(Compact self, NumericalPoint point)
        store(Compact self, NumericalSample sample)
        store(Compact self, NumericalPoint point)
        """
        return _statistics.Compact_store(self, *args)

    def getSample(self):
        """getSample(Compact self) -> NumericalSample"""
        return _statistics.Compact_getSample(self)

    def getHalfMaximumSize(self):
        """getHalfMaximumSize(Compact self) -> OT::UnsignedLong"""
        return _statistics.Compact_getHalfMaximumSize(self)

    def getIndex(self):
        """getIndex(Compact self) -> OT::UnsignedLong"""
        return _statistics.Compact_getIndex(self)

    def __repr__(self):
        """__repr__(Compact self) -> OT::String"""
        return _statistics.Compact___repr__(self)

    def __init__(self, *args): 
        """
        __init__(OT::Compact self) -> Compact
        __init__(OT::Compact self, OT::UnsignedLong const halfMaximumSize) -> Compact
        __init__(OT::Compact self, Compact other) -> Compact
        """
        this = _statistics.new_Compact(*args)
        try: self.this.append(this)
        except: self.this = this
    __swig_destroy__ = _statistics.delete_Compact
    __del__ = lambda self : None;
Compact_swigregister = _statistics.Compact_swigregister
Compact_swigregister(Compact)

def Compact_GetClassName():
  """Compact_GetClassName() -> OT::String"""
  return _statistics.Compact_GetClassName()

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

    if _newclass:GetClassName = staticmethod(GetClassName)
    __swig_getmethods__["GetClassName"] = lambda x: GetClassName
    def getClassName(self):
        """getClassName(Full self) -> OT::String"""
        return _statistics.Full_getClassName(self)

    def store(self, *args):
        """
        store(Full self, NumericalPoint point)
        store(Full self, NumericalSample sample)
        """
        return _statistics.Full_store(self, *args)

    def __repr__(self):
        """__repr__(Full self) -> OT::String"""
        return _statistics.Full___repr__(self)

    def __init__(self, *args): 
        """
        __init__(OT::Full self) -> Full
        __init__(OT::Full self, Full other) -> Full
        """
        this = _statistics.new_Full(*args)
        try: self.this.append(this)
        except: self.this = this
    __swig_destroy__ = _statistics.delete_Full
    __del__ = lambda self : None;
Full_swigregister = _statistics.Full_swigregister
Full_swigregister(Full)

def Full_GetClassName():
  """Full_GetClassName() -> OT::String"""
  return _statistics.Full_GetClassName()

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

    if _newclass:GetClassName = staticmethod(GetClassName)
    __swig_getmethods__["GetClassName"] = lambda x: GetClassName
    def getClassName(self):
        """getClassName(Last self) -> OT::String"""
        return _statistics.Last_getClassName(self)

    def store(self, *args):
        """
        store(Last self, NumericalPoint point)
        store(Last self, NumericalSample sample)
        store(Last self, NumericalPoint point)
        """
        return _statistics.Last_store(self, *args)

    def getSample(self):
        """getSample(Last self) -> NumericalSample"""
        return _statistics.Last_getSample(self)

    def getMaximumSize(self):
        """getMaximumSize(Last self) -> OT::UnsignedLong"""
        return _statistics.Last_getMaximumSize(self)

    def getIndex(self):
        """getIndex(Last self) -> OT::UnsignedLong"""
        return _statistics.Last_getIndex(self)

    def getHasWrapped(self):
        """getHasWrapped(Last self) -> OT::Bool"""
        return _statistics.Last_getHasWrapped(self)

    def __repr__(self):
        """__repr__(Last self) -> OT::String"""
        return _statistics.Last___repr__(self)

    def __init__(self, *args): 
        """
        __init__(OT::Last self) -> Last
        __init__(OT::Last self, OT::UnsignedLong const maximumSize) -> Last
        __init__(OT::Last self, Last other) -> Last
        """
        this = _statistics.new_Last(*args)
        try: self.this.append(this)
        except: self.this = this
    __swig_destroy__ = _statistics.delete_Last
    __del__ = lambda self : None;
Last_swigregister = _statistics.Last_swigregister
Last_swigregister(Last)

def Last_GetClassName():
  """Last_GetClassName() -> OT::String"""
  return _statistics.Last_GetClassName()

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

    if _newclass:GetClassName = staticmethod(GetClassName)
    __swig_getmethods__["GetClassName"] = lambda x: GetClassName
    def getClassName(self):
        """getClassName(Null self) -> OT::String"""
        return _statistics.Null_getClassName(self)

    def store(self, *args):
        """
        store(Null self, NumericalPoint point)
        store(Null self, NumericalSample sample)
        """
        return _statistics.Null_store(self, *args)

    def __repr__(self):
        """__repr__(Null self) -> OT::String"""
        return _statistics.Null___repr__(self)

    def __init__(self, *args): 
        """
        __init__(OT::Null self) -> Null
        __init__(OT::Null self, Null other) -> Null
        """
        this = _statistics.new_Null(*args)
        try: self.this.append(this)
        except: self.this = this
    __swig_destroy__ = _statistics.delete_Null
    __del__ = lambda self : None;
Null_swigregister = _statistics.Null_swigregister
Null_swigregister(Null)

def Null_GetClassName():
  """Null_GetClassName() -> OT::String"""
  return _statistics.Null_GetClassName()

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

    if _newclass:GetClassName = staticmethod(GetClassName)
    __swig_getmethods__["GetClassName"] = lambda x: GetClassName
    def getClassName(self):
        """getClassName(ConfidenceInterval self) -> OT::String"""
        return _statistics.ConfidenceInterval_getClassName(self)

    def setDescription(self, *args):
        """setDescription(ConfidenceInterval self, Description description)"""
        return _statistics.ConfidenceInterval_setDescription(self, *args)

    def getDescription(self):
        """getDescription(ConfidenceInterval self) -> Description"""
        return _statistics.ConfidenceInterval_getDescription(self)

    def __repr__(self):
        """__repr__(ConfidenceInterval self) -> OT::String"""
        return _statistics.ConfidenceInterval___repr__(self)

    def setValues(self, *args):
        """setValues(ConfidenceInterval self, OT::NumericalScalar const firstPt, OT::NumericalScalar const lastPt)"""
        return _statistics.ConfidenceInterval_setValues(self, *args)

    def getFirst(self):
        """getFirst(ConfidenceInterval self) -> OT::NumericalScalar const &"""
        return _statistics.ConfidenceInterval_getFirst(self)

    def getLast(self):
        """getLast(ConfidenceInterval self) -> OT::NumericalScalar const &"""
        return _statistics.ConfidenceInterval_getLast(self)

    def __eq__(self, *args):
        """__eq__(ConfidenceInterval self, ConfidenceInterval rhs) -> OT::Bool"""
        return _statistics.ConfidenceInterval___eq__(self, *args)

    def __init__(self, *args): 
        """
        __init__(OT::ConfidenceInterval self, OT::NumericalScalar const firstPt=0.0, OT::NumericalScalar const lastPt=1.0) -> ConfidenceInterval
        __init__(OT::ConfidenceInterval self, OT::NumericalScalar const firstPt=0.0) -> ConfidenceInterval
        __init__(OT::ConfidenceInterval self) -> ConfidenceInterval
        __init__(OT::ConfidenceInterval self, ConfidenceInterval other) -> ConfidenceInterval
        __init__(OT::ConfidenceInterval self, PyObject * pyObj) -> ConfidenceInterval
        """
        this = _statistics.new_ConfidenceInterval(*args)
        try: self.this.append(this)
        except: self.this = this
    __swig_destroy__ = _statistics.delete_ConfidenceInterval
    __del__ = lambda self : None;
ConfidenceInterval_swigregister = _statistics.ConfidenceInterval_swigregister
ConfidenceInterval_swigregister(ConfidenceInterval)

def ConfidenceInterval_GetClassName():
  """ConfidenceInterval_GetClassName() -> OT::String"""
  return _statistics.ConfidenceInterval_GetClassName()

class ConfidenceIntervalCollection(_object):
    """Proxy of C++ OT::Collection<(OT::ConfidenceInterval)> class"""
    __swig_setmethods__ = {}
    __setattr__ = lambda self, name, value: _swig_setattr(self, ConfidenceIntervalCollection, name, value)
    __swig_getmethods__ = {}
    __getattr__ = lambda self, name: _swig_getattr(self, ConfidenceIntervalCollection, name)
    __swig_destroy__ = _statistics.delete_ConfidenceIntervalCollection
    __del__ = lambda self : None;
    def clear(self):
        """clear(ConfidenceIntervalCollection self)"""
        return _statistics.ConfidenceIntervalCollection_clear(self)

    def __len__(self):
        """__len__(ConfidenceIntervalCollection self) -> OT::UnsignedLong"""
        return _statistics.ConfidenceIntervalCollection___len__(self)

    def __eq__(self, *args):
        """__eq__(ConfidenceIntervalCollection self, ConfidenceIntervalCollection rhs) -> OT::Bool"""
        return _statistics.ConfidenceIntervalCollection___eq__(self, *args)

    def __contains__(self, *args):
        """__contains__(ConfidenceIntervalCollection self, ConfidenceInterval val) -> OT::Bool"""
        return _statistics.ConfidenceIntervalCollection___contains__(self, *args)

    def __getitem__(self, *args):
        """__getitem__(ConfidenceIntervalCollection self, OT::UnsignedLong const i) -> ConfidenceInterval"""
        return _statistics.ConfidenceIntervalCollection___getitem__(self, *args)

    def __setitem__(self, *args):
        """__setitem__(ConfidenceIntervalCollection self, OT::UnsignedLong const i, ConfidenceInterval val)"""
        return _statistics.ConfidenceIntervalCollection___setitem__(self, *args)

    def __delitem__(self, *args):
        """__delitem__(ConfidenceIntervalCollection self, OT::UnsignedLong const i)"""
        return _statistics.ConfidenceIntervalCollection___delitem__(self, *args)

    def at(self, *args):
        """
        at(ConfidenceIntervalCollection self, OT::UnsignedLong const i) -> ConfidenceInterval
        at(ConfidenceIntervalCollection self, OT::UnsignedLong const i) -> ConfidenceInterval
        """
        return _statistics.ConfidenceIntervalCollection_at(self, *args)

    def add(self, *args):
        """
        add(ConfidenceIntervalCollection self, ConfidenceInterval elt)
        add(ConfidenceIntervalCollection self, ConfidenceIntervalCollection coll)
        """
        return _statistics.ConfidenceIntervalCollection_add(self, *args)

    def getSize(self):
        """getSize(ConfidenceIntervalCollection self) -> OT::UnsignedLong"""
        return _statistics.ConfidenceIntervalCollection_getSize(self)

    def resize(self, *args):
        """resize(ConfidenceIntervalCollection self, OT::UnsignedLong const newSize)"""
        return _statistics.ConfidenceIntervalCollection_resize(self, *args)

    def isEmpty(self):
        """isEmpty(ConfidenceIntervalCollection self) -> OT::Bool"""
        return _statistics.ConfidenceIntervalCollection_isEmpty(self)

    def __repr__(self):
        """__repr__(ConfidenceIntervalCollection self) -> OT::String"""
        return _statistics.ConfidenceIntervalCollection___repr__(self)

    def __str__(self, offset=""):
        """
        __str__(ConfidenceIntervalCollection self, OT::String const & offset="") -> OT::String
        __str__(ConfidenceIntervalCollection self) -> OT::String
        """
        return _statistics.ConfidenceIntervalCollection___str__(self, offset)

    def __init__(self, *args): 
        """
        __init__(OT::Collection<(OT::ConfidenceInterval)> self) -> ConfidenceIntervalCollection
        __init__(OT::Collection<(OT::ConfidenceInterval)> self, OT::UnsignedLong const size) -> ConfidenceIntervalCollection
        __init__(OT::Collection<(OT::ConfidenceInterval)> self, OT::UnsignedLong const size, ConfidenceInterval value) -> ConfidenceIntervalCollection
        __init__(OT::Collection<(OT::ConfidenceInterval)> self, PyObject * pyObj) -> ConfidenceIntervalCollection
        __init__(OT::Collection<(OT::ConfidenceInterval)> self, ConfidenceIntervalCollection other) -> ConfidenceIntervalCollection
        """
        this = _statistics.new_ConfidenceIntervalCollection(*args)
        try: self.this.append(this)
        except: self.this = this
ConfidenceIntervalCollection_swigregister = _statistics.ConfidenceIntervalCollection_swigregister
ConfidenceIntervalCollection_swigregister(ConfidenceIntervalCollection)

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

    if _newclass:GetClassName = staticmethod(GetClassName)
    __swig_getmethods__["GetClassName"] = lambda x: GetClassName
    def getClassName(self):
        """getClassName(LinearModel self) -> OT::String"""
        return _statistics.LinearModel_getClassName(self)

    def __repr__(self):
        """__repr__(LinearModel self) -> OT::String"""
        return _statistics.LinearModel___repr__(self)

    def __str__(self, offset=""):
        """
        __str__(LinearModel self, OT::String const & offset="") -> OT::String
        __str__(LinearModel self) -> OT::String
        """
        return _statistics.LinearModel___str__(self, offset)

    def getRegression(self):
        """getRegression(LinearModel self) -> NumericalPoint"""
        return _statistics.LinearModel_getRegression(self)

    def getConfidenceIntervals(self):
        """getConfidenceIntervals(LinearModel self) -> ConfidenceIntervalCollection"""
        return _statistics.LinearModel_getConfidenceIntervals(self)

    def getPValues(self):
        """getPValues(LinearModel self) -> NumericalScalarCollection"""
        return _statistics.LinearModel_getPValues(self)

    def getPredicted(self, *args):
        """getPredicted(LinearModel self, NumericalSample predictor) -> NumericalSample"""
        return _statistics.LinearModel_getPredicted(self, *args)

    def getResidual(self, *args):
        """getResidual(LinearModel self, NumericalSample predictor, NumericalSample measured) -> NumericalSample"""
        return _statistics.LinearModel_getResidual(self, *args)

    def __init__(self, *args): 
        """
        __init__(OT::LinearModel self) -> LinearModel
        __init__(OT::LinearModel self, NumericalPoint vectorR, ConfidenceIntervalCollection intervalsColl, NumericalScalarCollection pValuesOfR) -> LinearModel
        __init__(OT::LinearModel self, NumericalPoint vectorR) -> LinearModel
        __init__(OT::LinearModel self, LinearModel other) -> LinearModel
        """
        this = _statistics.new_LinearModel(*args)
        try: self.this.append(this)
        except: self.this = this
    __swig_destroy__ = _statistics.delete_LinearModel
    __del__ = lambda self : None;
LinearModel_swigregister = _statistics.LinearModel_swigregister
LinearModel_swigregister(LinearModel)

def LinearModel_GetClassName():
  """LinearModel_GetClassName() -> OT::String"""
  return _statistics.LinearModel_GetClassName()


def LinearModel_operator___eq__(*args):
  """LinearModel_operator___eq__(LinearModel lhs, LinearModel rhs) -> OT::Bool"""
  return _statistics.LinearModel_operator___eq__(*args)
class LinearModelFactory(_object):
    """Proxy of C++ OT::LinearModelFactory class"""
    __swig_setmethods__ = {}
    __setattr__ = lambda self, name, value: _swig_setattr(self, LinearModelFactory, name, value)
    __swig_getmethods__ = {}
    __getattr__ = lambda self, name: _swig_getattr(self, LinearModelFactory, name)
    __repr__ = _swig_repr
    def build(self, *args):
        """
        build(LinearModelFactory self, NumericalSample samplePred, NumericalSample sampleLab, OT::NumericalScalar const levelValue=OT::ResourceMap::GetAsNumericalScalar( "LinearModelFactory-DefaultLevelValue" )) -> LinearModel
        build(LinearModelFactory self, NumericalSample samplePred, NumericalSample sampleLab) -> LinearModel
        """
        return _statistics.LinearModelFactory_build(self, *args)

    def __init__(self, *args): 
        """
        __init__(OT::LinearModelFactory self) -> LinearModelFactory
        __init__(OT::LinearModelFactory self, LinearModelFactory other) -> LinearModelFactory
        """
        this = _statistics.new_LinearModelFactory(*args)
        try: self.this.append(this)
        except: self.this = this
    __swig_destroy__ = _statistics.delete_LinearModelFactory
    __del__ = lambda self : None;
LinearModelFactory_swigregister = _statistics.LinearModelFactory_swigregister
LinearModelFactory_swigregister(LinearModelFactory)

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 _statistics.TestResult_GetClassName()

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

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

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

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

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

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

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

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

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

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

class RandomGeneratorState(_object):
    """Proxy of C++ OT::RandomGeneratorState class"""
    __swig_setmethods__ = {}
    __setattr__ = lambda self, name, value: _swig_setattr(self, RandomGeneratorState, name, value)
    __swig_getmethods__ = {}
    __getattr__ = lambda self, name: _swig_getattr(self, RandomGeneratorState, name)
    __swig_setmethods__["state_"] = _statistics.RandomGeneratorState_state__set
    __swig_getmethods__["state_"] = _statistics.RandomGeneratorState_state__get
    if _newclass:state_ = _swig_property(_statistics.RandomGeneratorState_state__get, _statistics.RandomGeneratorState_state__set)
    __swig_setmethods__["index_"] = _statistics.RandomGeneratorState_index__set
    __swig_getmethods__["index_"] = _statistics.RandomGeneratorState_index__get
    if _newclass:index_ = _swig_property(_statistics.RandomGeneratorState_index__get, _statistics.RandomGeneratorState_index__set)
    __swig_destroy__ = _statistics.delete_RandomGeneratorState
    __del__ = lambda self : None;
    def __repr__(self):
        """__repr__(RandomGeneratorState self) -> OT::String const"""
        return _statistics.RandomGeneratorState___repr__(self)

    def __str__(self, offset=""):
        """
        __str__(RandomGeneratorState self, OT::String const & offset="") -> OT::String const
        __str__(RandomGeneratorState self) -> OT::String const
        """
        return _statistics.RandomGeneratorState___str__(self, offset)

    def __init__(self, *args): 
        """
        __init__(OT::RandomGeneratorState self) -> RandomGeneratorState
        __init__(OT::RandomGeneratorState self, UnsignedLongCollection state, OT::UnsignedLong const index) -> RandomGeneratorState
        __init__(OT::RandomGeneratorState self, RandomGeneratorState other) -> RandomGeneratorState
        """
        this = _statistics.new_RandomGeneratorState(*args)
        try: self.this.append(this)
        except: self.this = this
RandomGeneratorState_swigregister = _statistics.RandomGeneratorState_swigregister
RandomGeneratorState_swigregister(RandomGeneratorState)

class RandomGenerator(_object):
    """Proxy of C++ OT::RandomGenerator class"""
    __swig_setmethods__ = {}
    __setattr__ = lambda self, name, value: _swig_setattr(self, RandomGenerator, name, value)
    __swig_getmethods__ = {}
    __getattr__ = lambda self, name: _swig_getattr(self, RandomGenerator, name)
    __repr__ = _swig_repr
    def SetSeed(*args):
        """SetSeed(OT::UnsignedLong const seed)"""
        return _statistics.RandomGenerator_SetSeed(*args)

    if _newclass:SetSeed = staticmethod(SetSeed)
    __swig_getmethods__["SetSeed"] = lambda x: SetSeed
    def SetState(*args):
        """SetState(RandomGeneratorState state)"""
        return _statistics.RandomGenerator_SetState(*args)

    if _newclass:SetState = staticmethod(SetState)
    __swig_getmethods__["SetState"] = lambda x: SetState
    def GetState():
        """GetState() -> RandomGeneratorState"""
        return _statistics.RandomGenerator_GetState()

    if _newclass:GetState = staticmethod(GetState)
    __swig_getmethods__["GetState"] = lambda x: GetState
    def Generate(*args):
        """
        Generate() -> OT::NumericalScalar
        Generate(OT::UnsignedLong const size) -> NumericalPoint
        """
        return _statistics.RandomGenerator_Generate(*args)

    if _newclass:Generate = staticmethod(Generate)
    __swig_getmethods__["Generate"] = lambda x: Generate
    def IntegerGenerate(*args):
        """
        IntegerGenerate(OT::UnsignedLong const n) -> OT::UnsignedLong
        IntegerGenerate(OT::UnsignedLong const size, OT::UnsignedLong const n) -> UnsignedLongCollection
        """
        return _statistics.RandomGenerator_IntegerGenerate(*args)

    if _newclass:IntegerGenerate = staticmethod(IntegerGenerate)
    __swig_getmethods__["IntegerGenerate"] = lambda x: IntegerGenerate
    def __init__(self, *args): 
        """
        __init__(OT::RandomGenerator self) -> RandomGenerator
        __init__(OT::RandomGenerator self, RandomGenerator other) -> RandomGenerator
        """
        this = _statistics.new_RandomGenerator(*args)
        try: self.this.append(this)
        except: self.this = this
    __swig_destroy__ = _statistics.delete_RandomGenerator
    __del__ = lambda self : None;
RandomGenerator_swigregister = _statistics.RandomGenerator_swigregister
RandomGenerator_swigregister(RandomGenerator)

def RandomGenerator_SetSeed(*args):
  """RandomGenerator_SetSeed(OT::UnsignedLong const seed)"""
  return _statistics.RandomGenerator_SetSeed(*args)

def RandomGenerator_SetState(*args):
  """RandomGenerator_SetState(RandomGeneratorState state)"""
  return _statistics.RandomGenerator_SetState(*args)

def RandomGenerator_GetState():
  """RandomGenerator_GetState() -> RandomGeneratorState"""
  return _statistics.RandomGenerator_GetState()

def RandomGenerator_Generate(*args):
  """
    Generate() -> OT::NumericalScalar
    RandomGenerator_Generate(OT::UnsignedLong const size) -> NumericalPoint
    """
  return _statistics.RandomGenerator_Generate(*args)

def RandomGenerator_IntegerGenerate(*args):
  """
    IntegerGenerate(OT::UnsignedLong const n) -> OT::UnsignedLong
    RandomGenerator_IntegerGenerate(OT::UnsignedLong const size, OT::UnsignedLong const n) -> UnsignedLongCollection
    """
  return _statistics.RandomGenerator_IntegerGenerate(*args)

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

    if _newclass:GetClassName = staticmethod(GetClassName)
    __swig_getmethods__["GetClassName"] = lambda x: GetClassName
    def getClassName(self):
        """getClassName(LowDiscrepancySequenceImplementation self) -> OT::String"""
        return _statistics.LowDiscrepancySequenceImplementation_getClassName(self)

    def initialize(self, *args):
        """initialize(LowDiscrepancySequenceImplementation self, OT::UnsignedLong const dimension)"""
        return _statistics.LowDiscrepancySequenceImplementation_initialize(self, *args)

    def getDimension(self):
        """getDimension(LowDiscrepancySequenceImplementation self) -> OT::UnsignedLong"""
        return _statistics.LowDiscrepancySequenceImplementation_getDimension(self)

    def generate(self, *args):
        """
        generate(LowDiscrepancySequenceImplementation self) -> NumericalPoint
        generate(LowDiscrepancySequenceImplementation self, OT::UnsignedLong const size) -> NumericalSample
        """
        return _statistics.LowDiscrepancySequenceImplementation_generate(self, *args)

    def ComputeStarDiscrepancy(*args):
        """ComputeStarDiscrepancy(NumericalSample sample) -> OT::NumericalScalar"""
        return _statistics.LowDiscrepancySequenceImplementation_ComputeStarDiscrepancy(*args)

    if _newclass:ComputeStarDiscrepancy = staticmethod(ComputeStarDiscrepancy)
    __swig_getmethods__["ComputeStarDiscrepancy"] = lambda x: ComputeStarDiscrepancy
    def __repr__(self):
        """__repr__(LowDiscrepancySequenceImplementation self) -> OT::String"""
        return _statistics.LowDiscrepancySequenceImplementation___repr__(self)

    def __init__(self, *args): 
        """
        __init__(OT::LowDiscrepancySequenceImplementation self, OT::UnsignedLong const dimension=1) -> LowDiscrepancySequenceImplementation
        __init__(OT::LowDiscrepancySequenceImplementation self) -> LowDiscrepancySequenceImplementation
        __init__(OT::LowDiscrepancySequenceImplementation self, LowDiscrepancySequenceImplementation other) -> LowDiscrepancySequenceImplementation
        """
        this = _statistics.new_LowDiscrepancySequenceImplementation(*args)
        try: self.this.append(this)
        except: self.this = this
    __swig_destroy__ = _statistics.delete_LowDiscrepancySequenceImplementation
    __del__ = lambda self : None;
LowDiscrepancySequenceImplementation_swigregister = _statistics.LowDiscrepancySequenceImplementation_swigregister
LowDiscrepancySequenceImplementation_swigregister(LowDiscrepancySequenceImplementation)

def LowDiscrepancySequenceImplementation_GetClassName():
  """LowDiscrepancySequenceImplementation_GetClassName() -> OT::String"""
  return _statistics.LowDiscrepancySequenceImplementation_GetClassName()

def LowDiscrepancySequenceImplementation_ComputeStarDiscrepancy(*args):
  """LowDiscrepancySequenceImplementation_ComputeStarDiscrepancy(NumericalSample sample) -> OT::NumericalScalar"""
  return _statistics.LowDiscrepancySequenceImplementation_ComputeStarDiscrepancy(*args)

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

    def getImplementationAsPersistentObject(self):
        """getImplementationAsPersistentObject(LowDiscrepancySequenceImplementationTypedInterfaceObject self) -> PersistentObjectPointer"""
        return _statistics.LowDiscrepancySequenceImplementationTypedInterfaceObject_getImplementationAsPersistentObject(self)

    def setImplementationAsPersistentObject(self, *args):
        """setImplementationAsPersistentObject(LowDiscrepancySequenceImplementationTypedInterfaceObject self, PersistentObjectPointer obj)"""
        return _statistics.LowDiscrepancySequenceImplementationTypedInterfaceObject_setImplementationAsPersistentObject(self, *args)

    def swap(self, *args):
        """swap(LowDiscrepancySequenceImplementationTypedInterfaceObject self, LowDiscrepancySequenceImplementationTypedInterfaceObject other)"""
        return _statistics.LowDiscrepancySequenceImplementationTypedInterfaceObject_swap(self, *args)

    def setName(self, *args):
        """setName(LowDiscrepancySequenceImplementationTypedInterfaceObject self, OT::String const & name)"""
        return _statistics.LowDiscrepancySequenceImplementationTypedInterfaceObject_setName(self, *args)

    def getName(self):
        """getName(LowDiscrepancySequenceImplementationTypedInterfaceObject self) -> OT::String"""
        return _statistics.LowDiscrepancySequenceImplementationTypedInterfaceObject_getName(self)

    def __eq__(self, *args):
        """__eq__(LowDiscrepancySequenceImplementationTypedInterfaceObject self, LowDiscrepancySequenceImplementationTypedInterfaceObject other) -> OT::Bool"""
        return _statistics.LowDiscrepancySequenceImplementationTypedInterfaceObject___eq__(self, *args)

    __swig_destroy__ = _statistics.delete_LowDiscrepancySequenceImplementationTypedInterfaceObject
    __del__ = lambda self : None;
LowDiscrepancySequenceImplementationTypedInterfaceObject_swigregister = _statistics.LowDiscrepancySequenceImplementationTypedInterfaceObject_swigregister
LowDiscrepancySequenceImplementationTypedInterfaceObject_swigregister(LowDiscrepancySequenceImplementationTypedInterfaceObject)

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

    if _newclass:GetClassName = staticmethod(GetClassName)
    __swig_getmethods__["GetClassName"] = lambda x: GetClassName
    def getClassName(self):
        """getClassName(LowDiscrepancySequence self) -> OT::String"""
        return _statistics.LowDiscrepancySequence_getClassName(self)

    def initialize(self, *args):
        """initialize(LowDiscrepancySequence self, OT::UnsignedLong const dimension)"""
        return _statistics.LowDiscrepancySequence_initialize(self, *args)

    def getDimension(self):
        """getDimension(LowDiscrepancySequence self) -> OT::UnsignedLong"""
        return _statistics.LowDiscrepancySequence_getDimension(self)

    def generate(self, *args):
        """
        generate(LowDiscrepancySequence self) -> NumericalPoint
        generate(LowDiscrepancySequence self, OT::UnsignedLong const size) -> NumericalSample
        """
        return _statistics.LowDiscrepancySequence_generate(self, *args)

    def computeStarDiscrepancy(self, *args):
        """computeStarDiscrepancy(LowDiscrepancySequence self, NumericalSample sample) -> OT::NumericalScalar"""
        return _statistics.LowDiscrepancySequence_computeStarDiscrepancy(self, *args)

    def __repr__(self):
        """__repr__(LowDiscrepancySequence self) -> OT::String"""
        return _statistics.LowDiscrepancySequence___repr__(self)

    def __init__(self, *args): 
        """
        __init__(OT::LowDiscrepancySequence self) -> LowDiscrepancySequence
        __init__(OT::LowDiscrepancySequence self, OT::UnsignedLong const dimension) -> LowDiscrepancySequence
        __init__(OT::LowDiscrepancySequence self, LowDiscrepancySequenceImplementation implementation) -> LowDiscrepancySequence
        __init__(OT::LowDiscrepancySequence self, OT::LowDiscrepancySequence::Implementation & p_implementation) -> LowDiscrepancySequence
        __init__(OT::LowDiscrepancySequence self, LowDiscrepancySequence other) -> LowDiscrepancySequence
        """
        this = _statistics.new_LowDiscrepancySequence(*args)
        try: self.this.append(this)
        except: self.this = this
    __swig_destroy__ = _statistics.delete_LowDiscrepancySequence
    __del__ = lambda self : None;
LowDiscrepancySequence_swigregister = _statistics.LowDiscrepancySequence_swigregister
LowDiscrepancySequence_swigregister(LowDiscrepancySequence)

def LowDiscrepancySequence_GetClassName():
  """LowDiscrepancySequence_GetClassName() -> OT::String"""
  return _statistics.LowDiscrepancySequence_GetClassName()

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

    if _newclass:GetClassName = staticmethod(GetClassName)
    __swig_getmethods__["GetClassName"] = lambda x: GetClassName
    def getClassName(self):
        """getClassName(SobolSequence self) -> OT::String"""
        return _statistics.SobolSequence_getClassName(self)

    def initialize(self, *args):
        """initialize(SobolSequence self, OT::UnsignedLong const dimension)"""
        return _statistics.SobolSequence_initialize(self, *args)

    def generate(self, *args):
        """
        generate(SobolSequence self, OT::UnsignedLong const size) -> NumericalSample
        generate(SobolSequence self) -> NumericalPoint
        """
        return _statistics.SobolSequence_generate(self, *args)

    def __repr__(self):
        """__repr__(SobolSequence self) -> OT::String"""
        return _statistics.SobolSequence___repr__(self)

    def __init__(self, *args): 
        """
        __init__(OT::SobolSequence self, OT::UnsignedLong const dimension=1) -> SobolSequence
        __init__(OT::SobolSequence self) -> SobolSequence
        __init__(OT::SobolSequence self, SobolSequence other) -> SobolSequence
        """
        this = _statistics.new_SobolSequence(*args)
        try: self.this.append(this)
        except: self.this = this
    __swig_destroy__ = _statistics.delete_SobolSequence
    __del__ = lambda self : None;
SobolSequence_swigregister = _statistics.SobolSequence_swigregister
SobolSequence_swigregister(SobolSequence)

def SobolSequence_GetClassName():
  """SobolSequence_GetClassName() -> OT::String"""
  return _statistics.SobolSequence_GetClassName()
cvar = _statistics.cvar
SobolSequence.MaximumNumberOfDimension = _statistics.cvar.SobolSequence_MaximumNumberOfDimension
SobolSequence.MaximumBase2Logarithm = _statistics.cvar.SobolSequence_MaximumBase2Logarithm
SobolSequence.Epsilon = _statistics.cvar.SobolSequence_Epsilon
SobolSequence.MaximumInitialDegree = _statistics.cvar.SobolSequence_MaximumInitialDegree
SobolSequence.InitialBase = _statistics.cvar.SobolSequence_InitialBase
SobolSequence.PrimitivePolynomial = _statistics.cvar.SobolSequence_PrimitivePolynomial

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

    if _newclass:GetClassName = staticmethod(GetClassName)
    __swig_getmethods__["GetClassName"] = lambda x: GetClassName
    def getClassName(self):
        """getClassName(FaureSequence self) -> OT::String"""
        return _statistics.FaureSequence_getClassName(self)

    def initialize(self, *args):
        """initialize(FaureSequence self, OT::UnsignedLong const dimension)"""
        return _statistics.FaureSequence_initialize(self, *args)

    def generate(self, *args):
        """
        generate(FaureSequence self, OT::UnsignedLong const size) -> NumericalSample
        generate(FaureSequence self) -> NumericalPoint
        """
        return _statistics.FaureSequence_generate(self, *args)

    def __repr__(self):
        """__repr__(FaureSequence self) -> OT::String"""
        return _statistics.FaureSequence___repr__(self)

    def __init__(self, *args): 
        """
        __init__(OT::FaureSequence self, OT::UnsignedLong const dimension=1) -> FaureSequence
        __init__(OT::FaureSequence self) -> FaureSequence
        __init__(OT::FaureSequence self, FaureSequence other) -> FaureSequence
        """
        this = _statistics.new_FaureSequence(*args)
        try: self.this.append(this)
        except: self.this = this
    __swig_destroy__ = _statistics.delete_FaureSequence
    __del__ = lambda self : None;
FaureSequence_swigregister = _statistics.FaureSequence_swigregister
FaureSequence_swigregister(FaureSequence)

def FaureSequence_GetClassName():
  """FaureSequence_GetClassName() -> OT::String"""
  return _statistics.FaureSequence_GetClassName()

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

    if _newclass:GetClassName = staticmethod(GetClassName)
    __swig_getmethods__["GetClassName"] = lambda x: GetClassName
    def getClassName(self):
        """getClassName(HaltonSequence self) -> OT::String"""
        return _statistics.HaltonSequence_getClassName(self)

    def initialize(self, *args):
        """initialize(HaltonSequence self, OT::UnsignedLong const dimension)"""
        return _statistics.HaltonSequence_initialize(self, *args)

    def generate(self, *args):
        """
        generate(HaltonSequence self, OT::UnsignedLong const size) -> NumericalSample
        generate(HaltonSequence self) -> NumericalPoint
        """
        return _statistics.HaltonSequence_generate(self, *args)

    def __repr__(self):
        """__repr__(HaltonSequence self) -> OT::String"""
        return _statistics.HaltonSequence___repr__(self)

    def __str__(self, offset=""):
        """
        __str__(HaltonSequence self, OT::String const & offset="") -> OT::String
        __str__(HaltonSequence self) -> OT::String
        """
        return _statistics.HaltonSequence___str__(self, offset)

    def __init__(self, *args): 
        """
        __init__(OT::HaltonSequence self, OT::UnsignedLong const dimension=1) -> HaltonSequence
        __init__(OT::HaltonSequence self) -> HaltonSequence
        __init__(OT::HaltonSequence self, HaltonSequence other) -> HaltonSequence
        """
        this = _statistics.new_HaltonSequence(*args)
        try: self.this.append(this)
        except: self.this = this
    __swig_destroy__ = _statistics.delete_HaltonSequence
    __del__ = lambda self : None;
HaltonSequence_swigregister = _statistics.HaltonSequence_swigregister
HaltonSequence_swigregister(HaltonSequence)

def HaltonSequence_GetClassName():
  """HaltonSequence_GetClassName() -> OT::String"""
  return _statistics.HaltonSequence_GetClassName()

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

    if _newclass:GetClassName = staticmethod(GetClassName)
    __swig_getmethods__["GetClassName"] = lambda x: GetClassName
    def getClassName(self):
        """getClassName(HaselgroveSequence self) -> OT::String"""
        return _statistics.HaselgroveSequence_getClassName(self)

    def initialize(self, *args):
        """initialize(HaselgroveSequence self, OT::UnsignedLong const dimension)"""
        return _statistics.HaselgroveSequence_initialize(self, *args)

    def generate(self, *args):
        """
        generate(HaselgroveSequence self, OT::UnsignedLong const size) -> NumericalSample
        generate(HaselgroveSequence self) -> NumericalPoint
        """
        return _statistics.HaselgroveSequence_generate(self, *args)

    def __repr__(self):
        """__repr__(HaselgroveSequence self) -> OT::String"""
        return _statistics.HaselgroveSequence___repr__(self)

    def __str__(self, offset=""):
        """
        __str__(HaselgroveSequence self, OT::String const & offset="") -> OT::String
        __str__(HaselgroveSequence self) -> OT::String
        """
        return _statistics.HaselgroveSequence___str__(self, offset)

    def __init__(self, *args): 
        """
        __init__(OT::HaselgroveSequence self, OT::UnsignedLong const dimension=1) -> HaselgroveSequence
        __init__(OT::HaselgroveSequence self) -> HaselgroveSequence
        __init__(OT::HaselgroveSequence self, NumericalPoint base) -> HaselgroveSequence
        __init__(OT::HaselgroveSequence self, HaselgroveSequence other) -> HaselgroveSequence
        """
        this = _statistics.new_HaselgroveSequence(*args)
        try: self.this.append(this)
        except: self.this = this
    __swig_destroy__ = _statistics.delete_HaselgroveSequence
    __del__ = lambda self : None;
HaselgroveSequence_swigregister = _statistics.HaselgroveSequence_swigregister
HaselgroveSequence_swigregister(HaselgroveSequence)

def HaselgroveSequence_GetClassName():
  """HaselgroveSequence_GetClassName() -> OT::String"""
  return _statistics.HaselgroveSequence_GetClassName()

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

    if _newclass:GetClassName = staticmethod(GetClassName)
    __swig_getmethods__["GetClassName"] = lambda x: GetClassName
    def getClassName(self):
        """getClassName(ReverseHaltonSequence self) -> OT::String"""
        return _statistics.ReverseHaltonSequence_getClassName(self)

    def initialize(self, *args):
        """initialize(ReverseHaltonSequence self, OT::UnsignedLong const dimension)"""
        return _statistics.ReverseHaltonSequence_initialize(self, *args)

    def generate(self, *args):
        """
        generate(ReverseHaltonSequence self, OT::UnsignedLong const size) -> NumericalSample
        generate(ReverseHaltonSequence self) -> NumericalPoint
        """
        return _statistics.ReverseHaltonSequence_generate(self, *args)

    def __repr__(self):
        """__repr__(ReverseHaltonSequence self) -> OT::String"""
        return _statistics.ReverseHaltonSequence___repr__(self)

    def __init__(self, *args): 
        """
        __init__(OT::ReverseHaltonSequence self, OT::UnsignedLong const dimension=1) -> ReverseHaltonSequence
        __init__(OT::ReverseHaltonSequence self) -> ReverseHaltonSequence
        __init__(OT::ReverseHaltonSequence self, ReverseHaltonSequence other) -> ReverseHaltonSequence
        """
        this = _statistics.new_ReverseHaltonSequence(*args)
        try: self.this.append(this)
        except: self.this = this
    __swig_destroy__ = _statistics.delete_ReverseHaltonSequence
    __del__ = lambda self : None;
ReverseHaltonSequence_swigregister = _statistics.ReverseHaltonSequence_swigregister
ReverseHaltonSequence_swigregister(ReverseHaltonSequence)

def ReverseHaltonSequence_GetClassName():
  """ReverseHaltonSequence_GetClassName() -> OT::String"""
  return _statistics.ReverseHaltonSequence_GetClassName()

class CorrelationAnalysis(_object):
    """Proxy of C++ OT::CorrelationAnalysis class"""
    __swig_setmethods__ = {}
    __setattr__ = lambda self, name, value: _swig_setattr(self, CorrelationAnalysis, name, value)
    __swig_getmethods__ = {}
    __getattr__ = lambda self, name: _swig_getattr(self, CorrelationAnalysis, name)
    __repr__ = _swig_repr
    def PearsonCorrelation(*args):
        """
        PearsonCorrelation(NumericalSample inputSample, NumericalSample outputSample, OT::UnsignedLong const index=0) -> OT::NumericalScalar
        PearsonCorrelation(NumericalSample inputSample, NumericalSample outputSample) -> OT::NumericalScalar
        """
        return _statistics.CorrelationAnalysis_PearsonCorrelation(*args)

    if _newclass:PearsonCorrelation = staticmethod(PearsonCorrelation)
    __swig_getmethods__["PearsonCorrelation"] = lambda x: PearsonCorrelation
    def SpearmanCorrelation(*args):
        """
        SpearmanCorrelation(NumericalSample inputSample, NumericalSample outputSample, OT::UnsignedLong const index=0) -> OT::NumericalScalar
        SpearmanCorrelation(NumericalSample inputSample, NumericalSample outputSample) -> OT::NumericalScalar
        """
        return _statistics.CorrelationAnalysis_SpearmanCorrelation(*args)

    if _newclass:SpearmanCorrelation = staticmethod(SpearmanCorrelation)
    __swig_getmethods__["SpearmanCorrelation"] = lambda x: SpearmanCorrelation
    def SRC(*args):
        """SRC(NumericalSample inputSample, NumericalSample outputSample) -> NumericalPoint"""
        return _statistics.CorrelationAnalysis_SRC(*args)

    if _newclass:SRC = staticmethod(SRC)
    __swig_getmethods__["SRC"] = lambda x: SRC
    def PCC(*args):
        """PCC(NumericalSample inputSample, NumericalSample outputSample) -> NumericalPoint"""
        return _statistics.CorrelationAnalysis_PCC(*args)

    if _newclass:PCC = staticmethod(PCC)
    __swig_getmethods__["PCC"] = lambda x: PCC
    def SRRC(*args):
        """SRRC(NumericalSample inputSample, NumericalSample outputSample) -> NumericalPoint"""
        return _statistics.CorrelationAnalysis_SRRC(*args)

    if _newclass:SRRC = staticmethod(SRRC)
    __swig_getmethods__["SRRC"] = lambda x: SRRC
    def PRCC(*args):
        """PRCC(NumericalSample inputSample, NumericalSample outputSample) -> NumericalPoint"""
        return _statistics.CorrelationAnalysis_PRCC(*args)

    if _newclass:PRCC = staticmethod(PRCC)
    __swig_getmethods__["PRCC"] = lambda x: PRCC
    def __init__(self, *args): 
        """
        __init__(OT::CorrelationAnalysis self) -> CorrelationAnalysis
        __init__(OT::CorrelationAnalysis self, CorrelationAnalysis other) -> CorrelationAnalysis
        """
        this = _statistics.new_CorrelationAnalysis(*args)
        try: self.this.append(this)
        except: self.this = this
    __swig_destroy__ = _statistics.delete_CorrelationAnalysis
    __del__ = lambda self : None;
CorrelationAnalysis_swigregister = _statistics.CorrelationAnalysis_swigregister
CorrelationAnalysis_swigregister(CorrelationAnalysis)

def CorrelationAnalysis_PearsonCorrelation(*args):
  """
    PearsonCorrelation(NumericalSample inputSample, NumericalSample outputSample, OT::UnsignedLong const index=0) -> OT::NumericalScalar
    CorrelationAnalysis_PearsonCorrelation(NumericalSample inputSample, NumericalSample outputSample) -> OT::NumericalScalar
    """
  return _statistics.CorrelationAnalysis_PearsonCorrelation(*args)

def CorrelationAnalysis_SpearmanCorrelation(*args):
  """
    SpearmanCorrelation(NumericalSample inputSample, NumericalSample outputSample, OT::UnsignedLong const index=0) -> OT::NumericalScalar
    CorrelationAnalysis_SpearmanCorrelation(NumericalSample inputSample, NumericalSample outputSample) -> OT::NumericalScalar
    """
  return _statistics.CorrelationAnalysis_SpearmanCorrelation(*args)

def CorrelationAnalysis_SRC(*args):
  """CorrelationAnalysis_SRC(NumericalSample inputSample, NumericalSample outputSample) -> NumericalPoint"""
  return _statistics.CorrelationAnalysis_SRC(*args)

def CorrelationAnalysis_PCC(*args):
  """CorrelationAnalysis_PCC(NumericalSample inputSample, NumericalSample outputSample) -> NumericalPoint"""
  return _statistics.CorrelationAnalysis_PCC(*args)

def CorrelationAnalysis_SRRC(*args):
  """CorrelationAnalysis_SRRC(NumericalSample inputSample, NumericalSample outputSample) -> NumericalPoint"""
  return _statistics.CorrelationAnalysis_SRRC(*args)

def CorrelationAnalysis_PRCC(*args):
  """CorrelationAnalysis_PRCC(NumericalSample inputSample, NumericalSample outputSample) -> NumericalPoint"""
  return _statistics.CorrelationAnalysis_PRCC(*args)

class SensitivityAnalysis(_object):
    """Proxy of C++ OT::SensitivityAnalysis class"""
    __swig_setmethods__ = {}
    __setattr__ = lambda self, name, value: _swig_setattr(self, SensitivityAnalysis, name, value)
    __swig_getmethods__ = {}
    __getattr__ = lambda self, name: _swig_getattr(self, SensitivityAnalysis, name)
    __repr__ = _swig_repr
    def getFirstOrderIndices(self, marginalIndex=0):
        """
        getFirstOrderIndices(SensitivityAnalysis self, OT::UnsignedLong const marginalIndex=0) -> NumericalPoint
        getFirstOrderIndices(SensitivityAnalysis self) -> NumericalPoint
        """
        return _statistics.SensitivityAnalysis_getFirstOrderIndices(self, marginalIndex)

    def getSecondOrderIndices(self, marginalIndex=0):
        """
        getSecondOrderIndices(SensitivityAnalysis self, OT::UnsignedLong const marginalIndex=0) -> SymmetricMatrix
        getSecondOrderIndices(SensitivityAnalysis self) -> SymmetricMatrix
        """
        return _statistics.SensitivityAnalysis_getSecondOrderIndices(self, marginalIndex)

    def getTotalOrderIndices(self, marginalIndex=0):
        """
        getTotalOrderIndices(SensitivityAnalysis self, OT::UnsignedLong marginalIndex=0) -> NumericalPoint
        getTotalOrderIndices(SensitivityAnalysis self) -> NumericalPoint
        """
        return _statistics.SensitivityAnalysis_getTotalOrderIndices(self, marginalIndex)

    def setBlockSize(self, *args):
        """setBlockSize(SensitivityAnalysis self, OT::UnsignedLong const blockSize)"""
        return _statistics.SensitivityAnalysis_setBlockSize(self, *args)

    def getBlockSize(self):
        """getBlockSize(SensitivityAnalysis self) -> OT::UnsignedLong"""
        return _statistics.SensitivityAnalysis_getBlockSize(self)

    def DrawImportanceFactors(*args):
        """
        DrawImportanceFactors(NumericalPointWithDescription importanceFactors, OT::String const & title="Importance Factors") -> Graph
        DrawImportanceFactors(NumericalPointWithDescription importanceFactors) -> Graph
        DrawImportanceFactors(NumericalPoint values, Description names, OT::String const & title="Importance Factors") -> Graph
        DrawImportanceFactors(NumericalPoint values, Description names) -> Graph
        """
        return _statistics.SensitivityAnalysis_DrawImportanceFactors(*args)

    if _newclass:DrawImportanceFactors = staticmethod(DrawImportanceFactors)
    __swig_getmethods__["DrawImportanceFactors"] = lambda x: DrawImportanceFactors
    def __init__(self, *args): 
        """
        __init__(OT::SensitivityAnalysis self, NumericalSample inputSample1, NumericalSample inputSample2, NumericalMathFunction model) -> SensitivityAnalysis
        __init__(OT::SensitivityAnalysis self, SensitivityAnalysis other) -> SensitivityAnalysis
        """
        this = _statistics.new_SensitivityAnalysis(*args)
        try: self.this.append(this)
        except: self.this = this
    __swig_destroy__ = _statistics.delete_SensitivityAnalysis
    __del__ = lambda self : None;
SensitivityAnalysis_swigregister = _statistics.SensitivityAnalysis_swigregister
SensitivityAnalysis_swigregister(SensitivityAnalysis)

def SensitivityAnalysis_DrawImportanceFactors(*args):
  """
    DrawImportanceFactors(NumericalPointWithDescription importanceFactors, OT::String const & title="Importance Factors") -> Graph
    DrawImportanceFactors(NumericalPointWithDescription importanceFactors) -> Graph
    DrawImportanceFactors(NumericalPoint values, Description names, OT::String const & title="Importance Factors") -> Graph
    SensitivityAnalysis_DrawImportanceFactors(NumericalPoint values, Description names) -> Graph
    """
  return _statistics.SensitivityAnalysis_DrawImportanceFactors(*args)

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

    if _newclass:GetClassName = staticmethod(GetClassName)
    __swig_getmethods__["GetClassName"] = lambda x: GetClassName
    def getClassName(self):
        """getClassName(FilteringWindowsImplementation self) -> OT::String"""
        return _statistics.FilteringWindowsImplementation_getClassName(self)

    def __call__(self, *args):
        """__call__(FilteringWindowsImplementation self, OT::NumericalScalar const t) -> OT::NumericalScalar"""
        return _statistics.FilteringWindowsImplementation___call__(self, *args)

    def __repr__(self):
        """__repr__(FilteringWindowsImplementation self) -> OT::String"""
        return _statistics.FilteringWindowsImplementation___repr__(self)

    def __str__(self, offset=""):
        """
        __str__(FilteringWindowsImplementation self, OT::String const & offset="") -> OT::String
        __str__(FilteringWindowsImplementation self) -> OT::String
        """
        return _statistics.FilteringWindowsImplementation___str__(self, offset)

    def __init__(self, *args): 
        """
        __init__(OT::FilteringWindowsImplementation self, OT::String const & name=DefaultName) -> FilteringWindowsImplementation
        __init__(OT::FilteringWindowsImplementation self) -> FilteringWindowsImplementation
        __init__(OT::FilteringWindowsImplementation self, FilteringWindowsImplementation other) -> FilteringWindowsImplementation
        """
        this = _statistics.new_FilteringWindowsImplementation(*args)
        try: self.this.append(this)
        except: self.this = this
    __swig_destroy__ = _statistics.delete_FilteringWindowsImplementation
    __del__ = lambda self : None;
FilteringWindowsImplementation_swigregister = _statistics.FilteringWindowsImplementation_swigregister
FilteringWindowsImplementation_swigregister(FilteringWindowsImplementation)

def FilteringWindowsImplementation_GetClassName():
  """FilteringWindowsImplementation_GetClassName() -> OT::String"""
  return _statistics.FilteringWindowsImplementation_GetClassName()

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

    def getImplementationAsPersistentObject(self):
        """getImplementationAsPersistentObject(FilteringWindowsImplementationTypedInterfaceObject self) -> PersistentObjectPointer"""
        return _statistics.FilteringWindowsImplementationTypedInterfaceObject_getImplementationAsPersistentObject(self)

    def setImplementationAsPersistentObject(self, *args):
        """setImplementationAsPersistentObject(FilteringWindowsImplementationTypedInterfaceObject self, PersistentObjectPointer obj)"""
        return _statistics.FilteringWindowsImplementationTypedInterfaceObject_setImplementationAsPersistentObject(self, *args)

    def swap(self, *args):
        """swap(FilteringWindowsImplementationTypedInterfaceObject self, FilteringWindowsImplementationTypedInterfaceObject other)"""
        return _statistics.FilteringWindowsImplementationTypedInterfaceObject_swap(self, *args)

    def setName(self, *args):
        """setName(FilteringWindowsImplementationTypedInterfaceObject self, OT::String const & name)"""
        return _statistics.FilteringWindowsImplementationTypedInterfaceObject_setName(self, *args)

    def getName(self):
        """getName(FilteringWindowsImplementationTypedInterfaceObject self) -> OT::String"""
        return _statistics.FilteringWindowsImplementationTypedInterfaceObject_getName(self)

    def __eq__(self, *args):
        """__eq__(FilteringWindowsImplementationTypedInterfaceObject self, FilteringWindowsImplementationTypedInterfaceObject other) -> OT::Bool"""
        return _statistics.FilteringWindowsImplementationTypedInterfaceObject___eq__(self, *args)

    __swig_destroy__ = _statistics.delete_FilteringWindowsImplementationTypedInterfaceObject
    __del__ = lambda self : None;
FilteringWindowsImplementationTypedInterfaceObject_swigregister = _statistics.FilteringWindowsImplementationTypedInterfaceObject_swigregister
FilteringWindowsImplementationTypedInterfaceObject_swigregister(FilteringWindowsImplementationTypedInterfaceObject)

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

    if _newclass:GetClassName = staticmethod(GetClassName)
    __swig_getmethods__["GetClassName"] = lambda x: GetClassName
    def getClassName(self):
        """getClassName(FilteringWindows self) -> OT::String"""
        return _statistics.FilteringWindows_getClassName(self)

    def __repr__(self):
        """__repr__(FilteringWindows self) -> OT::String"""
        return _statistics.FilteringWindows___repr__(self)

    def __str__(self, offset=""):
        """
        __str__(FilteringWindows self, OT::String const & offset="") -> OT::String
        __str__(FilteringWindows self) -> OT::String
        """
        return _statistics.FilteringWindows___str__(self, offset)

    def __call__(self, *args):
        """__call__(FilteringWindows self, OT::NumericalScalar const t) -> OT::NumericalScalar"""
        return _statistics.FilteringWindows___call__(self, *args)

    def __init__(self, *args): 
        """
        __init__(OT::FilteringWindows self) -> FilteringWindows
        __init__(OT::FilteringWindows self, FilteringWindowsImplementation implementation, OT::String const & name=DefaultName) -> FilteringWindows
        __init__(OT::FilteringWindows self, FilteringWindowsImplementation implementation) -> FilteringWindows
        __init__(OT::FilteringWindows self, OT::TypedInterfaceObject< OT::FilteringWindowsImplementation >::Implementation const & p_implementation, 
            OT::String const & name=DefaultName) -> FilteringWindows
        __init__(OT::FilteringWindows self, OT::TypedInterfaceObject< OT::FilteringWindowsImplementation >::Implementation const & p_implementation) -> FilteringWindows
        __init__(OT::FilteringWindows self, FilteringWindows other) -> FilteringWindows
        """
        this = _statistics.new_FilteringWindows(*args)
        try: self.this.append(this)
        except: self.this = this
    __swig_destroy__ = _statistics.delete_FilteringWindows
    __del__ = lambda self : None;
FilteringWindows_swigregister = _statistics.FilteringWindows_swigregister
FilteringWindows_swigregister(FilteringWindows)

def FilteringWindows_GetClassName():
  """FilteringWindows_GetClassName() -> OT::String"""
  return _statistics.FilteringWindows_GetClassName()

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

    if _newclass:GetClassName = staticmethod(GetClassName)
    __swig_getmethods__["GetClassName"] = lambda x: GetClassName
    def getClassName(self):
        """getClassName(Hamming self) -> OT::String"""
        return _statistics.Hamming_getClassName(self)

    def __repr__(self):
        """__repr__(Hamming self) -> OT::String"""
        return _statistics.Hamming___repr__(self)

    def __str__(self, offset=""):
        """
        __str__(Hamming self, OT::String const & offset="") -> OT::String
        __str__(Hamming self) -> OT::String
        """
        return _statistics.Hamming___str__(self, offset)

    def __call__(self, *args):
        """__call__(Hamming self, OT::NumericalScalar const t) -> OT::NumericalScalar"""
        return _statistics.Hamming___call__(self, *args)

    def __init__(self, *args): 
        """
        __init__(OT::Hamming self, OT::String const & name=DefaultName) -> Hamming
        __init__(OT::Hamming self) -> Hamming
        __init__(OT::Hamming self, Hamming other) -> Hamming
        """
        this = _statistics.new_Hamming(*args)
        try: self.this.append(this)
        except: self.this = this
    __swig_destroy__ = _statistics.delete_Hamming
    __del__ = lambda self : None;
Hamming_swigregister = _statistics.Hamming_swigregister
Hamming_swigregister(Hamming)

def Hamming_GetClassName():
  """Hamming_GetClassName() -> OT::String"""
  return _statistics.Hamming_GetClassName()

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

    if _newclass:GetClassName = staticmethod(GetClassName)
    __swig_getmethods__["GetClassName"] = lambda x: GetClassName
    def getClassName(self):
        """getClassName(Hanning self) -> OT::String"""
        return _statistics.Hanning_getClassName(self)

    def __repr__(self):
        """__repr__(Hanning self) -> OT::String"""
        return _statistics.Hanning___repr__(self)

    def __str__(self, offset=""):
        """
        __str__(Hanning self, OT::String const & offset="") -> OT::String
        __str__(Hanning self) -> OT::String
        """
        return _statistics.Hanning___str__(self, offset)

    def __call__(self, *args):
        """__call__(Hanning self, OT::NumericalScalar const t) -> OT::NumericalScalar"""
        return _statistics.Hanning___call__(self, *args)

    def __init__(self, *args): 
        """
        __init__(OT::Hanning self, OT::String const & name=DefaultName) -> Hanning
        __init__(OT::Hanning self) -> Hanning
        __init__(OT::Hanning self, Hanning other) -> Hanning
        """
        this = _statistics.new_Hanning(*args)
        try: self.this.append(this)
        except: self.this = this
    __swig_destroy__ = _statistics.delete_Hanning
    __del__ = lambda self : None;
Hanning_swigregister = _statistics.Hanning_swigregister
Hanning_swigregister(Hanning)

def Hanning_GetClassName():
  """Hanning_GetClassName() -> OT::String"""
  return _statistics.Hanning_GetClassName()

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

    if _newclass:GetClassName = staticmethod(GetClassName)
    __swig_getmethods__["GetClassName"] = lambda x: GetClassName
    def getClassName(self):
        """getClassName(FFTImplementation self) -> OT::String"""
        return _statistics.FFTImplementation_getClassName(self)

    def transform(self, *args):
        """
        transform(FFTImplementation self, NumericalScalarCollection collection) -> NumericalComplexCollection
        transform(FFTImplementation self, NumericalComplexCollection collection) -> NumericalComplexCollection
        transform(FFTImplementation self, NumericalComplexCollection collection, OT::UnsignedLong const first, OT::UnsignedLong const size) -> NumericalComplexCollection
        transform(FFTImplementation self, NumericalComplexCollection collection, OT::UnsignedLong const first, OT::UnsignedLong const step, 
            OT::UnsignedLong const last) -> NumericalComplexCollection
        """
        return _statistics.FFTImplementation_transform(self, *args)

    def inverseTransform(self, *args):
        """
        inverseTransform(FFTImplementation self, NumericalComplexCollection collection) -> NumericalComplexCollection
        inverseTransform(FFTImplementation self, NumericalComplexCollection collection, OT::UnsignedLong const first, OT::UnsignedLong const size) -> NumericalComplexCollection
        inverseTransform(FFTImplementation self, NumericalComplexCollection collection, OT::UnsignedLong const first, OT::UnsignedLong const step, 
            OT::UnsignedLong const last) -> NumericalComplexCollection
        """
        return _statistics.FFTImplementation_inverseTransform(self, *args)

    def __repr__(self):
        """__repr__(FFTImplementation self) -> OT::String"""
        return _statistics.FFTImplementation___repr__(self)

    def __str__(self, offset=""):
        """
        __str__(FFTImplementation self, OT::String const & offset="") -> OT::String
        __str__(FFTImplementation self) -> OT::String
        """
        return _statistics.FFTImplementation___str__(self, offset)

    def __init__(self, *args): 
        """
        __init__(OT::FFTImplementation self, OT::String const & name=DefaultName) -> FFTImplementation
        __init__(OT::FFTImplementation self) -> FFTImplementation
        __init__(OT::FFTImplementation self, FFTImplementation other) -> FFTImplementation
        """
        this = _statistics.new_FFTImplementation(*args)
        try: self.this.append(this)
        except: self.this = this
    __swig_destroy__ = _statistics.delete_FFTImplementation
    __del__ = lambda self : None;
FFTImplementation_swigregister = _statistics.FFTImplementation_swigregister
FFTImplementation_swigregister(FFTImplementation)

def FFTImplementation_GetClassName():
  """FFTImplementation_GetClassName() -> OT::String"""
  return _statistics.FFTImplementation_GetClassName()

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

    def getImplementationAsPersistentObject(self):
        """getImplementationAsPersistentObject(FFTImplementationTypedInterfaceObject self) -> PersistentObjectPointer"""
        return _statistics.FFTImplementationTypedInterfaceObject_getImplementationAsPersistentObject(self)

    def setImplementationAsPersistentObject(self, *args):
        """setImplementationAsPersistentObject(FFTImplementationTypedInterfaceObject self, PersistentObjectPointer obj)"""
        return _statistics.FFTImplementationTypedInterfaceObject_setImplementationAsPersistentObject(self, *args)

    def swap(self, *args):
        """swap(FFTImplementationTypedInterfaceObject self, FFTImplementationTypedInterfaceObject other)"""
        return _statistics.FFTImplementationTypedInterfaceObject_swap(self, *args)

    def setName(self, *args):
        """setName(FFTImplementationTypedInterfaceObject self, OT::String const & name)"""
        return _statistics.FFTImplementationTypedInterfaceObject_setName(self, *args)

    def getName(self):
        """getName(FFTImplementationTypedInterfaceObject self) -> OT::String"""
        return _statistics.FFTImplementationTypedInterfaceObject_getName(self)

    def __eq__(self, *args):
        """__eq__(FFTImplementationTypedInterfaceObject self, FFTImplementationTypedInterfaceObject other) -> OT::Bool"""
        return _statistics.FFTImplementationTypedInterfaceObject___eq__(self, *args)

    __swig_destroy__ = _statistics.delete_FFTImplementationTypedInterfaceObject
    __del__ = lambda self : None;
FFTImplementationTypedInterfaceObject_swigregister = _statistics.FFTImplementationTypedInterfaceObject_swigregister
FFTImplementationTypedInterfaceObject_swigregister(FFTImplementationTypedInterfaceObject)

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

    if _newclass:GetClassName = staticmethod(GetClassName)
    __swig_getmethods__["GetClassName"] = lambda x: GetClassName
    def getClassName(self):
        """getClassName(FFT self) -> OT::String"""
        return _statistics.FFT_getClassName(self)

    def transform(self, *args):
        """
        transform(FFT self, NumericalScalarCollection collection) -> NumericalComplexCollection
        transform(FFT self, NumericalComplexCollection collection) -> NumericalComplexCollection
        transform(FFT self, NumericalComplexCollection collection, OT::UnsignedLong const first, OT::UnsignedLong const size) -> NumericalComplexCollection
        transform(FFT self, NumericalComplexCollection collection, OT::UnsignedLong const first, OT::UnsignedLong const step, 
            OT::UnsignedLong const last) -> NumericalComplexCollection
        """
        return _statistics.FFT_transform(self, *args)

    def inverseTransform(self, *args):
        """
        inverseTransform(FFT self, NumericalComplexCollection collection) -> NumericalComplexCollection
        inverseTransform(FFT self, NumericalComplexCollection collection, OT::UnsignedLong const first, OT::UnsignedLong const size) -> NumericalComplexCollection
        inverseTransform(FFT self, NumericalComplexCollection collection, OT::UnsignedLong const first, OT::UnsignedLong const step, 
            OT::UnsignedLong const last) -> NumericalComplexCollection
        """
        return _statistics.FFT_inverseTransform(self, *args)

    def __repr__(self):
        """__repr__(FFT self) -> OT::String"""
        return _statistics.FFT___repr__(self)

    def __str__(self, offset=""):
        """
        __str__(FFT self, OT::String const & offset="") -> OT::String
        __str__(FFT self) -> OT::String
        """
        return _statistics.FFT___str__(self, offset)

    def __init__(self, *args): 
        """
        __init__(OT::FFT self) -> FFT
        __init__(OT::FFT self, FFTImplementation implementation, OT::String const & name=DefaultName) -> FFT
        __init__(OT::FFT self, FFTImplementation implementation) -> FFT
        __init__(OT::FFT self, OT::FFT::Implementation const & p_implementation, OT::String const & name=DefaultName) -> FFT
        __init__(OT::FFT self, OT::FFT::Implementation const & p_implementation) -> FFT
        __init__(OT::FFT self, FFT other) -> FFT
        """
        this = _statistics.new_FFT(*args)
        try: self.this.append(this)
        except: self.this = this
    __swig_destroy__ = _statistics.delete_FFT
    __del__ = lambda self : None;
FFT_swigregister = _statistics.FFT_swigregister
FFT_swigregister(FFT)

def FFT_GetClassName():
  """FFT_GetClassName() -> OT::String"""
  return _statistics.FFT_GetClassName()

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

    if _newclass:GetClassName = staticmethod(GetClassName)
    __swig_getmethods__["GetClassName"] = lambda x: GetClassName
    def getClassName(self):
        """getClassName(SpectralModelImplementation self) -> OT::String"""
        return _statistics.SpectralModelImplementation_getClassName(self)

    def getDimension(self):
        """getDimension(SpectralModelImplementation self) -> OT::UnsignedLong"""
        return _statistics.SpectralModelImplementation_getDimension(self)

    def setDimension(self, *args):
        """setDimension(SpectralModelImplementation self, OT::UnsignedLong const dimension)"""
        return _statistics.SpectralModelImplementation_setDimension(self, *args)

    def computeSpectralDensity(self, *args):
        """computeSpectralDensity(SpectralModelImplementation self, OT::NumericalScalar const frequency) -> HermitianMatrix"""
        return _statistics.SpectralModelImplementation_computeSpectralDensity(self, *args)

    def getFrequencyGrid(self):
        """getFrequencyGrid(SpectralModelImplementation self) -> RegularGrid"""
        return _statistics.SpectralModelImplementation_getFrequencyGrid(self)

    def setFrequencyGrid(self, *args):
        """setFrequencyGrid(SpectralModelImplementation self, RegularGrid frequencyGrid)"""
        return _statistics.SpectralModelImplementation_setFrequencyGrid(self, *args)

    def __repr__(self):
        """__repr__(SpectralModelImplementation self) -> OT::String"""
        return _statistics.SpectralModelImplementation___repr__(self)

    def __str__(self, offset=""):
        """
        __str__(SpectralModelImplementation self, OT::String const & offset="") -> OT::String
        __str__(SpectralModelImplementation self) -> OT::String
        """
        return _statistics.SpectralModelImplementation___str__(self, offset)

    def __init__(self, *args): 
        """
        __init__(OT::SpectralModelImplementation self, OT::String const & name=DefaultName) -> SpectralModelImplementation
        __init__(OT::SpectralModelImplementation self) -> SpectralModelImplementation
        __init__(OT::SpectralModelImplementation self, SpectralModelImplementation other) -> SpectralModelImplementation
        """
        this = _statistics.new_SpectralModelImplementation(*args)
        try: self.this.append(this)
        except: self.this = this
    __swig_destroy__ = _statistics.delete_SpectralModelImplementation
    __del__ = lambda self : None;
SpectralModelImplementation_swigregister = _statistics.SpectralModelImplementation_swigregister
SpectralModelImplementation_swigregister(SpectralModelImplementation)

def SpectralModelImplementation_GetClassName():
  """SpectralModelImplementation_GetClassName() -> OT::String"""
  return _statistics.SpectralModelImplementation_GetClassName()

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

    def getImplementationAsPersistentObject(self):
        """getImplementationAsPersistentObject(SpectralModelImplementationTypedInterfaceObject self) -> PersistentObjectPointer"""
        return _statistics.SpectralModelImplementationTypedInterfaceObject_getImplementationAsPersistentObject(self)

    def setImplementationAsPersistentObject(self, *args):
        """setImplementationAsPersistentObject(SpectralModelImplementationTypedInterfaceObject self, PersistentObjectPointer obj)"""
        return _statistics.SpectralModelImplementationTypedInterfaceObject_setImplementationAsPersistentObject(self, *args)

    def swap(self, *args):
        """swap(SpectralModelImplementationTypedInterfaceObject self, SpectralModelImplementationTypedInterfaceObject other)"""
        return _statistics.SpectralModelImplementationTypedInterfaceObject_swap(self, *args)

    def setName(self, *args):
        """setName(SpectralModelImplementationTypedInterfaceObject self, OT::String const & name)"""
        return _statistics.SpectralModelImplementationTypedInterfaceObject_setName(self, *args)

    def getName(self):
        """getName(SpectralModelImplementationTypedInterfaceObject self) -> OT::String"""
        return _statistics.SpectralModelImplementationTypedInterfaceObject_getName(self)

    def __eq__(self, *args):
        """__eq__(SpectralModelImplementationTypedInterfaceObject self, SpectralModelImplementationTypedInterfaceObject other) -> OT::Bool"""
        return _statistics.SpectralModelImplementationTypedInterfaceObject___eq__(self, *args)

    __swig_destroy__ = _statistics.delete_SpectralModelImplementationTypedInterfaceObject
    __del__ = lambda self : None;
SpectralModelImplementationTypedInterfaceObject_swigregister = _statistics.SpectralModelImplementationTypedInterfaceObject_swigregister
SpectralModelImplementationTypedInterfaceObject_swigregister(SpectralModelImplementationTypedInterfaceObject)

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

    if _newclass:GetClassName = staticmethod(GetClassName)
    __swig_getmethods__["GetClassName"] = lambda x: GetClassName
    def getClassName(self):
        """getClassName(SpectralModel self) -> OT::String"""
        return _statistics.SpectralModel_getClassName(self)

    def getDimension(self):
        """getDimension(SpectralModel self) -> OT::UnsignedLong"""
        return _statistics.SpectralModel_getDimension(self)

    def setDimension(self, *args):
        """setDimension(SpectralModel self, OT::UnsignedLong const dimension)"""
        return _statistics.SpectralModel_setDimension(self, *args)

    def computeSpectralDensity(self, *args):
        """computeSpectralDensity(SpectralModel self, OT::NumericalScalar const frequency) -> HermitianMatrix"""
        return _statistics.SpectralModel_computeSpectralDensity(self, *args)

    def getFrequencyGrid(self):
        """getFrequencyGrid(SpectralModel self) -> RegularGrid"""
        return _statistics.SpectralModel_getFrequencyGrid(self)

    def setFrequencyGrid(self, *args):
        """setFrequencyGrid(SpectralModel self, RegularGrid frequencyGrid)"""
        return _statistics.SpectralModel_setFrequencyGrid(self, *args)

    def __repr__(self):
        """__repr__(SpectralModel self) -> OT::String"""
        return _statistics.SpectralModel___repr__(self)

    def __str__(self, offset=""):
        """
        __str__(SpectralModel self, OT::String const & offset="") -> OT::String
        __str__(SpectralModel self) -> OT::String
        """
        return _statistics.SpectralModel___str__(self, offset)

    def __init__(self, *args): 
        """
        __init__(OT::SpectralModel self, OT::String const & name=DefaultName) -> SpectralModel
        __init__(OT::SpectralModel self) -> SpectralModel
        __init__(OT::SpectralModel self, SpectralModelImplementation implementation, OT::String const & name=DefaultName) -> SpectralModel
        __init__(OT::SpectralModel self, SpectralModelImplementation implementation) -> SpectralModel
        __init__(OT::SpectralModel self, SpectralModelImplementationPointer p_implementation, OT::String const & name=DefaultName) -> SpectralModel
        __init__(OT::SpectralModel self, SpectralModelImplementationPointer p_implementation) -> SpectralModel
        __init__(OT::SpectralModel self, SpectralModel other) -> SpectralModel
        """
        this = _statistics.new_SpectralModel(*args)
        try: self.this.append(this)
        except: self.this = this
    __swig_destroy__ = _statistics.delete_SpectralModel
    __del__ = lambda self : None;
SpectralModel_swigregister = _statistics.SpectralModel_swigregister
SpectralModel_swigregister(SpectralModel)

def SpectralModel_GetClassName():
  """SpectralModel_GetClassName() -> OT::String"""
  return _statistics.SpectralModel_GetClassName()

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

    if _newclass:GetClassName = staticmethod(GetClassName)
    __swig_getmethods__["GetClassName"] = lambda x: GetClassName
    def getClassName(self):
        """getClassName(CovarianceModelImplementation self) -> OT::String"""
        return _statistics.CovarianceModelImplementation_getClassName(self)

    def getDimension(self):
        """getDimension(CovarianceModelImplementation self) -> OT::UnsignedLong"""
        return _statistics.CovarianceModelImplementation_getDimension(self)

    def computeCovariance(self, *args):
        """
        computeCovariance(CovarianceModelImplementation self, OT::NumericalScalar const s, OT::NumericalScalar const t) -> CovarianceMatrix
        computeCovariance(CovarianceModelImplementation self, OT::NumericalScalar const tau) -> CovarianceMatrix
        """
        return _statistics.CovarianceModelImplementation_computeCovariance(self, *args)

    def discretizeCovariance(self, *args):
        """discretizeCovariance(CovarianceModelImplementation self, RegularGrid timeGrid) -> CovarianceMatrix"""
        return _statistics.CovarianceModelImplementation_discretizeCovariance(self, *args)

    def isStationary(self):
        """isStationary(CovarianceModelImplementation self) -> OT::Bool"""
        return _statistics.CovarianceModelImplementation_isStationary(self)

    def __repr__(self):
        """__repr__(CovarianceModelImplementation self) -> OT::String"""
        return _statistics.CovarianceModelImplementation___repr__(self)

    def __str__(self, offset=""):
        """
        __str__(CovarianceModelImplementation self, OT::String const & offset="") -> OT::String
        __str__(CovarianceModelImplementation self) -> OT::String
        """
        return _statistics.CovarianceModelImplementation___str__(self, offset)

    def __init__(self, *args): 
        """
        __init__(OT::CovarianceModelImplementation self, OT::String const & name=DefaultName) -> CovarianceModelImplementation
        __init__(OT::CovarianceModelImplementation self) -> CovarianceModelImplementation
        __init__(OT::CovarianceModelImplementation self, OT::UnsignedLong const dimension, OT::String const & name=DefaultName) -> CovarianceModelImplementation
        __init__(OT::CovarianceModelImplementation self, OT::UnsignedLong const dimension) -> CovarianceModelImplementation
        __init__(OT::CovarianceModelImplementation self, CovarianceModelImplementation other) -> CovarianceModelImplementation
        """
        this = _statistics.new_CovarianceModelImplementation(*args)
        try: self.this.append(this)
        except: self.this = this
    __swig_destroy__ = _statistics.delete_CovarianceModelImplementation
    __del__ = lambda self : None;
CovarianceModelImplementation_swigregister = _statistics.CovarianceModelImplementation_swigregister
CovarianceModelImplementation_swigregister(CovarianceModelImplementation)

def CovarianceModelImplementation_GetClassName():
  """CovarianceModelImplementation_GetClassName() -> OT::String"""
  return _statistics.CovarianceModelImplementation_GetClassName()

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

    def getImplementationAsPersistentObject(self):
        """getImplementationAsPersistentObject(CovarianceModelImplementationTypedInterfaceObject self) -> PersistentObjectPointer"""
        return _statistics.CovarianceModelImplementationTypedInterfaceObject_getImplementationAsPersistentObject(self)

    def setImplementationAsPersistentObject(self, *args):
        """setImplementationAsPersistentObject(CovarianceModelImplementationTypedInterfaceObject self, PersistentObjectPointer obj)"""
        return _statistics.CovarianceModelImplementationTypedInterfaceObject_setImplementationAsPersistentObject(self, *args)

    def swap(self, *args):
        """swap(CovarianceModelImplementationTypedInterfaceObject self, CovarianceModelImplementationTypedInterfaceObject other)"""
        return _statistics.CovarianceModelImplementationTypedInterfaceObject_swap(self, *args)

    def setName(self, *args):
        """setName(CovarianceModelImplementationTypedInterfaceObject self, OT::String const & name)"""
        return _statistics.CovarianceModelImplementationTypedInterfaceObject_setName(self, *args)

    def getName(self):
        """getName(CovarianceModelImplementationTypedInterfaceObject self) -> OT::String"""
        return _statistics.CovarianceModelImplementationTypedInterfaceObject_getName(self)

    def __eq__(self, *args):
        """__eq__(CovarianceModelImplementationTypedInterfaceObject self, CovarianceModelImplementationTypedInterfaceObject other) -> OT::Bool"""
        return _statistics.CovarianceModelImplementationTypedInterfaceObject___eq__(self, *args)

    __swig_destroy__ = _statistics.delete_CovarianceModelImplementationTypedInterfaceObject
    __del__ = lambda self : None;
CovarianceModelImplementationTypedInterfaceObject_swigregister = _statistics.CovarianceModelImplementationTypedInterfaceObject_swigregister
CovarianceModelImplementationTypedInterfaceObject_swigregister(CovarianceModelImplementationTypedInterfaceObject)

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

    if _newclass:GetClassName = staticmethod(GetClassName)
    __swig_getmethods__["GetClassName"] = lambda x: GetClassName
    def getClassName(self):
        """getClassName(CovarianceModel self) -> OT::String"""
        return _statistics.CovarianceModel_getClassName(self)

    def getDimension(self):
        """getDimension(CovarianceModel self) -> OT::UnsignedLong"""
        return _statistics.CovarianceModel_getDimension(self)

    def computeCovariance(self, *args):
        """
        computeCovariance(CovarianceModel self, OT::NumericalScalar const s, OT::NumericalScalar const t) -> CovarianceMatrix
        computeCovariance(CovarianceModel self, OT::NumericalScalar const tau) -> CovarianceMatrix
        """
        return _statistics.CovarianceModel_computeCovariance(self, *args)

    def discretizeCovariance(self, *args):
        """discretizeCovariance(CovarianceModel self, RegularGrid timeGrid) -> CovarianceMatrix"""
        return _statistics.CovarianceModel_discretizeCovariance(self, *args)

    def isStationary(self):
        """isStationary(CovarianceModel self) -> OT::Bool"""
        return _statistics.CovarianceModel_isStationary(self)

    def __repr__(self):
        """__repr__(CovarianceModel self) -> OT::String"""
        return _statistics.CovarianceModel___repr__(self)

    def __str__(self, offset=""):
        """
        __str__(CovarianceModel self, OT::String const & offset="") -> OT::String
        __str__(CovarianceModel self) -> OT::String
        """
        return _statistics.CovarianceModel___str__(self, offset)

    def __init__(self, *args): 
        """
        __init__(OT::CovarianceModel self, OT::String const & name=DefaultName) -> CovarianceModel
        __init__(OT::CovarianceModel self) -> CovarianceModel
        __init__(OT::CovarianceModel self, CovarianceModelImplementation implementation, OT::String const & name=DefaultName) -> CovarianceModel
        __init__(OT::CovarianceModel self, CovarianceModelImplementation implementation) -> CovarianceModel
        __init__(OT::CovarianceModel self, CovarianceModelImplementationPointer p_implementation, OT::String const & name=DefaultName) -> CovarianceModel
        __init__(OT::CovarianceModel self, CovarianceModelImplementationPointer p_implementation) -> CovarianceModel
        __init__(OT::CovarianceModel self, CovarianceModel other) -> CovarianceModel
        """
        this = _statistics.new_CovarianceModel(*args)
        try: self.this.append(this)
        except: self.this = this
    __swig_destroy__ = _statistics.delete_CovarianceModel
    __del__ = lambda self : None;
CovarianceModel_swigregister = _statistics.CovarianceModel_swigregister
CovarianceModel_swigregister(CovarianceModel)

def CovarianceModel_GetClassName():
  """CovarianceModel_GetClassName() -> OT::String"""
  return _statistics.CovarianceModel_GetClassName()

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

    if _newclass:GetClassName = staticmethod(GetClassName)
    __swig_getmethods__["GetClassName"] = lambda x: GetClassName
    def getClassName(self):
        """getClassName(StationaryCovarianceModel self) -> OT::String"""
        return _statistics.StationaryCovarianceModel_getClassName(self)

    def computeCovariance(self, *args):
        """
        computeCovariance(StationaryCovarianceModel self, OT::NumericalScalar const s, OT::NumericalScalar const t) -> CovarianceMatrix
        computeCovariance(StationaryCovarianceModel self, OT::NumericalScalar const tau) -> CovarianceMatrix
        """
        return _statistics.StationaryCovarianceModel_computeCovariance(self, *args)

    def discretizeCovariance(self, *args):
        """discretizeCovariance(StationaryCovarianceModel self, RegularGrid timeGrid) -> CovarianceMatrix"""
        return _statistics.StationaryCovarianceModel_discretizeCovariance(self, *args)

    def isStationary(self):
        """isStationary(StationaryCovarianceModel self) -> OT::Bool"""
        return _statistics.StationaryCovarianceModel_isStationary(self)

    def __repr__(self):
        """__repr__(StationaryCovarianceModel self) -> OT::String"""
        return _statistics.StationaryCovarianceModel___repr__(self)

    def __str__(self, offset=""):
        """
        __str__(StationaryCovarianceModel self, OT::String const & offset="") -> OT::String
        __str__(StationaryCovarianceModel self) -> OT::String
        """
        return _statistics.StationaryCovarianceModel___str__(self, offset)

    def __init__(self, *args): 
        """
        __init__(OT::StationaryCovarianceModel self, OT::String const & name=DefaultName) -> StationaryCovarianceModel
        __init__(OT::StationaryCovarianceModel self) -> StationaryCovarianceModel
        __init__(OT::StationaryCovarianceModel self, StationaryCovarianceModel other) -> StationaryCovarianceModel
        """
        this = _statistics.new_StationaryCovarianceModel(*args)
        try: self.this.append(this)
        except: self.this = this
    __swig_destroy__ = _statistics.delete_StationaryCovarianceModel
    __del__ = lambda self : None;
StationaryCovarianceModel_swigregister = _statistics.StationaryCovarianceModel_swigregister
StationaryCovarianceModel_swigregister(StationaryCovarianceModel)

def StationaryCovarianceModel_GetClassName():
  """StationaryCovarianceModel_GetClassName() -> OT::String"""
  return _statistics.StationaryCovarianceModel_GetClassName()

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

    if _newclass:GetClassName = staticmethod(GetClassName)
    __swig_getmethods__["GetClassName"] = lambda x: GetClassName
    def getClassName(self):
        """getClassName(SecondOrderModelImplementation self) -> OT::String"""
        return _statistics.SecondOrderModelImplementation_getClassName(self)

    def getDimension(self):
        """getDimension(SecondOrderModelImplementation self) -> OT::UnsignedLong"""
        return _statistics.SecondOrderModelImplementation_getDimension(self)

    def computeCovariance(self, *args):
        """
        computeCovariance(SecondOrderModelImplementation self, OT::NumericalScalar const s, OT::NumericalScalar const t) -> CovarianceMatrix
        computeCovariance(SecondOrderModelImplementation self, OT::NumericalScalar const tau) -> CovarianceMatrix
        """
        return _statistics.SecondOrderModelImplementation_computeCovariance(self, *args)

    def getSpectralModel(self):
        """getSpectralModel(SecondOrderModelImplementation self) -> SpectralModel"""
        return _statistics.SecondOrderModelImplementation_getSpectralModel(self)

    def getCovarianceModel(self):
        """getCovarianceModel(SecondOrderModelImplementation self) -> CovarianceModel"""
        return _statistics.SecondOrderModelImplementation_getCovarianceModel(self)

    def setModels(self, *args):
        """setModels(SecondOrderModelImplementation self, CovarianceModel covarianceModel, SpectralModel spectralModel)"""
        return _statistics.SecondOrderModelImplementation_setModels(self, *args)

    def discretizeCovariance(self, *args):
        """discretizeCovariance(SecondOrderModelImplementation self, RegularGrid timeGrid) -> CovarianceMatrix"""
        return _statistics.SecondOrderModelImplementation_discretizeCovariance(self, *args)

    def computeSpectralDensity(self, *args):
        """computeSpectralDensity(SecondOrderModelImplementation self, OT::NumericalScalar const frequency) -> HermitianMatrix"""
        return _statistics.SecondOrderModelImplementation_computeSpectralDensity(self, *args)

    def __repr__(self):
        """__repr__(SecondOrderModelImplementation self) -> OT::String"""
        return _statistics.SecondOrderModelImplementation___repr__(self)

    def __str__(self, offset=""):
        """
        __str__(SecondOrderModelImplementation self, OT::String const & offset="") -> OT::String
        __str__(SecondOrderModelImplementation self) -> OT::String
        """
        return _statistics.SecondOrderModelImplementation___str__(self, offset)

    def __init__(self, *args): 
        """
        __init__(OT::SecondOrderModelImplementation self, OT::String const & name=DefaultName) -> SecondOrderModelImplementation
        __init__(OT::SecondOrderModelImplementation self) -> SecondOrderModelImplementation
        __init__(OT::SecondOrderModelImplementation self, CovarianceModel covarianceModel, SpectralModel spectralModel, OT::String const & name=DefaultName) -> SecondOrderModelImplementation
        __init__(OT::SecondOrderModelImplementation self, CovarianceModel covarianceModel, SpectralModel spectralModel) -> SecondOrderModelImplementation
        __init__(OT::SecondOrderModelImplementation self, SecondOrderModelImplementation other) -> SecondOrderModelImplementation
        """
        this = _statistics.new_SecondOrderModelImplementation(*args)
        try: self.this.append(this)
        except: self.this = this
    __swig_destroy__ = _statistics.delete_SecondOrderModelImplementation
    __del__ = lambda self : None;
SecondOrderModelImplementation_swigregister = _statistics.SecondOrderModelImplementation_swigregister
SecondOrderModelImplementation_swigregister(SecondOrderModelImplementation)

def SecondOrderModelImplementation_GetClassName():
  """SecondOrderModelImplementation_GetClassName() -> OT::String"""
  return _statistics.SecondOrderModelImplementation_GetClassName()

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

    if _newclass:GetClassName = staticmethod(GetClassName)
    __swig_getmethods__["GetClassName"] = lambda x: GetClassName
    def getClassName(self):
        """getClassName(ExponentialCauchy self) -> OT::String"""
        return _statistics.ExponentialCauchy_getClassName(self)

    def __repr__(self):
        """__repr__(ExponentialCauchy self) -> OT::String"""
        return _statistics.ExponentialCauchy___repr__(self)

    def __str__(self, offset=""):
        """
        __str__(ExponentialCauchy self, OT::String const & offset="") -> OT::String
        __str__(ExponentialCauchy self) -> OT::String
        """
        return _statistics.ExponentialCauchy___str__(self, offset)

    def getAmplitude(self):
        """getAmplitude(ExponentialCauchy self) -> NumericalPoint"""
        return _statistics.ExponentialCauchy_getAmplitude(self)

    def getScale(self):
        """getScale(ExponentialCauchy self) -> NumericalPoint"""
        return _statistics.ExponentialCauchy_getScale(self)

    def getSpatialCorrelation(self):
        """getSpatialCorrelation(ExponentialCauchy self) -> CorrelationMatrix"""
        return _statistics.ExponentialCauchy_getSpatialCorrelation(self)

    def __init__(self, *args): 
        """
        __init__(OT::ExponentialCauchy self, OT::String const & name=DefaultName) -> ExponentialCauchy
        __init__(OT::ExponentialCauchy self) -> ExponentialCauchy
        __init__(OT::ExponentialCauchy self, NumericalPoint amplitude, NumericalPoint scale, OT::String const & name=DefaultName) -> ExponentialCauchy
        __init__(OT::ExponentialCauchy self, NumericalPoint amplitude, NumericalPoint scale) -> ExponentialCauchy
        __init__(OT::ExponentialCauchy self, NumericalPoint amplitude, NumericalPoint scale, CorrelationMatrix spatialCorrelation, 
            OT::String const & name=DefaultName) -> ExponentialCauchy
        __init__(OT::ExponentialCauchy self, NumericalPoint amplitude, NumericalPoint scale, CorrelationMatrix spatialCorrelation) -> ExponentialCauchy
        __init__(OT::ExponentialCauchy self, NumericalPoint scale, CovarianceMatrix spatialCovariance, OT::String const & name=DefaultName) -> ExponentialCauchy
        __init__(OT::ExponentialCauchy self, NumericalPoint scale, CovarianceMatrix spatialCovariance) -> ExponentialCauchy
        __init__(OT::ExponentialCauchy self, ExponentialCauchy other) -> ExponentialCauchy
        """
        this = _statistics.new_ExponentialCauchy(*args)
        try: self.this.append(this)
        except: self.this = this
    __swig_destroy__ = _statistics.delete_ExponentialCauchy
    __del__ = lambda self : None;
ExponentialCauchy_swigregister = _statistics.ExponentialCauchy_swigregister
ExponentialCauchy_swigregister(ExponentialCauchy)

def ExponentialCauchy_GetClassName():
  """ExponentialCauchy_GetClassName() -> OT::String"""
  return _statistics.ExponentialCauchy_GetClassName()

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

    def getImplementationAsPersistentObject(self):
        """getImplementationAsPersistentObject(SecondOrderModelImplementationTypedInterfaceObject self) -> PersistentObjectPointer"""
        return _statistics.SecondOrderModelImplementationTypedInterfaceObject_getImplementationAsPersistentObject(self)

    def setImplementationAsPersistentObject(self, *args):
        """setImplementationAsPersistentObject(SecondOrderModelImplementationTypedInterfaceObject self, PersistentObjectPointer obj)"""
        return _statistics.SecondOrderModelImplementationTypedInterfaceObject_setImplementationAsPersistentObject(self, *args)

    def swap(self, *args):
        """swap(SecondOrderModelImplementationTypedInterfaceObject self, SecondOrderModelImplementationTypedInterfaceObject other)"""
        return _statistics.SecondOrderModelImplementationTypedInterfaceObject_swap(self, *args)

    def setName(self, *args):
        """setName(SecondOrderModelImplementationTypedInterfaceObject self, OT::String const & name)"""
        return _statistics.SecondOrderModelImplementationTypedInterfaceObject_setName(self, *args)

    def getName(self):
        """getName(SecondOrderModelImplementationTypedInterfaceObject self) -> OT::String"""
        return _statistics.SecondOrderModelImplementationTypedInterfaceObject_getName(self)

    def __eq__(self, *args):
        """__eq__(SecondOrderModelImplementationTypedInterfaceObject self, SecondOrderModelImplementationTypedInterfaceObject other) -> OT::Bool"""
        return _statistics.SecondOrderModelImplementationTypedInterfaceObject___eq__(self, *args)

    __swig_destroy__ = _statistics.delete_SecondOrderModelImplementationTypedInterfaceObject
    __del__ = lambda self : None;
SecondOrderModelImplementationTypedInterfaceObject_swigregister = _statistics.SecondOrderModelImplementationTypedInterfaceObject_swigregister
SecondOrderModelImplementationTypedInterfaceObject_swigregister(SecondOrderModelImplementationTypedInterfaceObject)

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

    if _newclass:GetClassName = staticmethod(GetClassName)
    __swig_getmethods__["GetClassName"] = lambda x: GetClassName
    def getClassName(self):
        """getClassName(SecondOrderModel self) -> OT::String"""
        return _statistics.SecondOrderModel_getClassName(self)

    def getDimension(self):
        """getDimension(SecondOrderModel self) -> OT::UnsignedLong"""
        return _statistics.SecondOrderModel_getDimension(self)

    def getSpectralModel(self):
        """getSpectralModel(SecondOrderModel self) -> SpectralModel"""
        return _statistics.SecondOrderModel_getSpectralModel(self)

    def getCovarianceModel(self):
        """getCovarianceModel(SecondOrderModel self) -> CovarianceModel"""
        return _statistics.SecondOrderModel_getCovarianceModel(self)

    def setModels(self, *args):
        """setModels(SecondOrderModel self, CovarianceModel covarianceModel, SpectralModel spectralModel)"""
        return _statistics.SecondOrderModel_setModels(self, *args)

    def computeCovariance(self, *args):
        """
        computeCovariance(SecondOrderModel self, OT::NumericalScalar const s, OT::NumericalScalar const t) -> CovarianceMatrix
        computeCovariance(SecondOrderModel self, OT::NumericalScalar const tau) -> CovarianceMatrix
        """
        return _statistics.SecondOrderModel_computeCovariance(self, *args)

    def computeSpectralDensity(self, *args):
        """computeSpectralDensity(SecondOrderModel self, OT::NumericalScalar const frequency) -> HermitianMatrix"""
        return _statistics.SecondOrderModel_computeSpectralDensity(self, *args)

    def discretizeCovariance(self, *args):
        """discretizeCovariance(SecondOrderModel self, RegularGrid timeGrid) -> CovarianceMatrix"""
        return _statistics.SecondOrderModel_discretizeCovariance(self, *args)

    def __repr__(self):
        """__repr__(SecondOrderModel self) -> OT::String"""
        return _statistics.SecondOrderModel___repr__(self)

    def __str__(self, offset=""):
        """
        __str__(SecondOrderModel self, OT::String const & offset="") -> OT::String
        __str__(SecondOrderModel self) -> OT::String
        """
        return _statistics.SecondOrderModel___str__(self, offset)

    def __init__(self, *args): 
        """
        __init__(OT::SecondOrderModel self) -> SecondOrderModel
        __init__(OT::SecondOrderModel self, SecondOrderModelImplementation implementation, OT::String const & name=DefaultName) -> SecondOrderModel
        __init__(OT::SecondOrderModel self, SecondOrderModelImplementation implementation) -> SecondOrderModel
        __init__(OT::SecondOrderModel self, SecondOrderModelImplementationPointer p_implementation, OT::String const & name=DefaultName) -> SecondOrderModel
        __init__(OT::SecondOrderModel self, SecondOrderModelImplementationPointer p_implementation) -> SecondOrderModel
        __init__(OT::SecondOrderModel self, CovarianceModel covarianceModel, SpectralModel spectralModel, OT::String const & name=DefaultName) -> SecondOrderModel
        __init__(OT::SecondOrderModel self, CovarianceModel covarianceModel, SpectralModel spectralModel) -> SecondOrderModel
        __init__(OT::SecondOrderModel self, SecondOrderModel other) -> SecondOrderModel
        """
        this = _statistics.new_SecondOrderModel(*args)
        try: self.this.append(this)
        except: self.this = this
    __swig_destroy__ = _statistics.delete_SecondOrderModel
    __del__ = lambda self : None;
SecondOrderModel_swigregister = _statistics.SecondOrderModel_swigregister
SecondOrderModel_swigregister(SecondOrderModel)

def SecondOrderModel_GetClassName():
  """SecondOrderModel_GetClassName() -> OT::String"""
  return _statistics.SecondOrderModel_GetClassName()

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

    if _newclass:GetClassName = staticmethod(GetClassName)
    __swig_getmethods__["GetClassName"] = lambda x: GetClassName
    def getClassName(self):
        """getClassName(SpectralModelFactoryImplementation self) -> OT::String"""
        return _statistics.SpectralModelFactoryImplementation_getClassName(self)

    def getFrequencyGrid(self):
        """getFrequencyGrid(SpectralModelFactoryImplementation self) -> RegularGrid"""
        return _statistics.SpectralModelFactoryImplementation_getFrequencyGrid(self)

    def setFrequencyGrid(self, *args):
        """setFrequencyGrid(SpectralModelFactoryImplementation self, RegularGrid grid)"""
        return _statistics.SpectralModelFactoryImplementation_setFrequencyGrid(self, *args)

    def getFFTAlgorithm(self):
        """getFFTAlgorithm(SpectralModelFactoryImplementation self) -> FFT"""
        return _statistics.SpectralModelFactoryImplementation_getFFTAlgorithm(self)

    def setFFTAlgorithm(self, *args):
        """setFFTAlgorithm(SpectralModelFactoryImplementation self, FFT fft)"""
        return _statistics.SpectralModelFactoryImplementation_setFFTAlgorithm(self, *args)

    def __repr__(self):
        """__repr__(SpectralModelFactoryImplementation self) -> OT::String"""
        return _statistics.SpectralModelFactoryImplementation___repr__(self)

    def __str__(self, offset=""):
        """
        __str__(SpectralModelFactoryImplementation self, OT::String const & offset="") -> OT::String
        __str__(SpectralModelFactoryImplementation self) -> OT::String
        """
        return _statistics.SpectralModelFactoryImplementation___str__(self, offset)

    def build(self, *args):
        """
        build(SpectralModelFactoryImplementation self, ProcessSample sample) -> SpectralModelImplementation
        build(SpectralModelFactoryImplementation self, TimeSeries timeSerie) -> SpectralModelImplementation
        """
        return _statistics.SpectralModelFactoryImplementation_build(self, *args)

    def __init__(self, *args): 
        """
        __init__(OT::SpectralModelFactoryImplementation self, OT::String const & name=DefaultName) -> SpectralModelFactoryImplementation
        __init__(OT::SpectralModelFactoryImplementation self) -> SpectralModelFactoryImplementation
        __init__(OT::SpectralModelFactoryImplementation self, SpectralModelFactoryImplementation other) -> SpectralModelFactoryImplementation
        """
        this = _statistics.new_SpectralModelFactoryImplementation(*args)
        try: self.this.append(this)
        except: self.this = this
    __swig_destroy__ = _statistics.delete_SpectralModelFactoryImplementation
    __del__ = lambda self : None;
SpectralModelFactoryImplementation_swigregister = _statistics.SpectralModelFactoryImplementation_swigregister
SpectralModelFactoryImplementation_swigregister(SpectralModelFactoryImplementation)

def SpectralModelFactoryImplementation_GetClassName():
  """SpectralModelFactoryImplementation_GetClassName() -> OT::String"""
  return _statistics.SpectralModelFactoryImplementation_GetClassName()

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

    def getImplementationAsPersistentObject(self):
        """getImplementationAsPersistentObject(SpectralModelFactoryImplementationTypedInterfaceObject self) -> PersistentObjectPointer"""
        return _statistics.SpectralModelFactoryImplementationTypedInterfaceObject_getImplementationAsPersistentObject(self)

    def setImplementationAsPersistentObject(self, *args):
        """setImplementationAsPersistentObject(SpectralModelFactoryImplementationTypedInterfaceObject self, PersistentObjectPointer obj)"""
        return _statistics.SpectralModelFactoryImplementationTypedInterfaceObject_setImplementationAsPersistentObject(self, *args)

    def swap(self, *args):
        """swap(SpectralModelFactoryImplementationTypedInterfaceObject self, SpectralModelFactoryImplementationTypedInterfaceObject other)"""
        return _statistics.SpectralModelFactoryImplementationTypedInterfaceObject_swap(self, *args)

    def setName(self, *args):
        """setName(SpectralModelFactoryImplementationTypedInterfaceObject self, OT::String const & name)"""
        return _statistics.SpectralModelFactoryImplementationTypedInterfaceObject_setName(self, *args)

    def getName(self):
        """getName(SpectralModelFactoryImplementationTypedInterfaceObject self) -> OT::String"""
        return _statistics.SpectralModelFactoryImplementationTypedInterfaceObject_getName(self)

    def __eq__(self, *args):
        """__eq__(SpectralModelFactoryImplementationTypedInterfaceObject self, SpectralModelFactoryImplementationTypedInterfaceObject other) -> OT::Bool"""
        return _statistics.SpectralModelFactoryImplementationTypedInterfaceObject___eq__(self, *args)

    __swig_destroy__ = _statistics.delete_SpectralModelFactoryImplementationTypedInterfaceObject
    __del__ = lambda self : None;
SpectralModelFactoryImplementationTypedInterfaceObject_swigregister = _statistics.SpectralModelFactoryImplementationTypedInterfaceObject_swigregister
SpectralModelFactoryImplementationTypedInterfaceObject_swigregister(SpectralModelFactoryImplementationTypedInterfaceObject)

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

    if _newclass:GetClassName = staticmethod(GetClassName)
    __swig_getmethods__["GetClassName"] = lambda x: GetClassName
    def getClassName(self):
        """getClassName(SpectralModelFactory self) -> OT::String"""
        return _statistics.SpectralModelFactory_getClassName(self)

    def getFrequencyGrid(self):
        """getFrequencyGrid(SpectralModelFactory self) -> RegularGrid"""
        return _statistics.SpectralModelFactory_getFrequencyGrid(self)

    def setFrequencyGrid(self, *args):
        """setFrequencyGrid(SpectralModelFactory self, RegularGrid point)"""
        return _statistics.SpectralModelFactory_setFrequencyGrid(self, *args)

    def getFFTAlgorithm(self):
        """getFFTAlgorithm(SpectralModelFactory self) -> FFT"""
        return _statistics.SpectralModelFactory_getFFTAlgorithm(self)

    def setFFTAlgorithm(self, *args):
        """setFFTAlgorithm(SpectralModelFactory self, FFT fft)"""
        return _statistics.SpectralModelFactory_setFFTAlgorithm(self, *args)

    def __repr__(self):
        """__repr__(SpectralModelFactory self) -> OT::String"""
        return _statistics.SpectralModelFactory___repr__(self)

    def __str__(self, offset=""):
        """
        __str__(SpectralModelFactory self, OT::String const & offset="") -> OT::String
        __str__(SpectralModelFactory self) -> OT::String
        """
        return _statistics.SpectralModelFactory___str__(self, offset)

    def build(self, *args):
        """
        build(SpectralModelFactory self, ProcessSample sample) -> SpectralModel
        build(SpectralModelFactory self, TimeSeries timeSerie) -> SpectralModel
        """
        return _statistics.SpectralModelFactory_build(self, *args)

    def __init__(self, *args): 
        """
        __init__(OT::SpectralModelFactory self, OT::String const & name=DefaultName) -> SpectralModelFactory
        __init__(OT::SpectralModelFactory self) -> SpectralModelFactory
        __init__(OT::SpectralModelFactory self, SpectralModelFactoryImplementation implementation, OT::String const & name=DefaultName) -> SpectralModelFactory
        __init__(OT::SpectralModelFactory self, SpectralModelFactoryImplementation implementation) -> SpectralModelFactory
        __init__(OT::SpectralModelFactory self, OT::SpectralModelFactory::Implementation const & p_implementation, OT::String const & name=DefaultName) -> SpectralModelFactory
        __init__(OT::SpectralModelFactory self, OT::SpectralModelFactory::Implementation const & p_implementation) -> SpectralModelFactory
        __init__(OT::SpectralModelFactory self, SpectralModelFactory other) -> SpectralModelFactory
        """
        this = _statistics.new_SpectralModelFactory(*args)
        try: self.this.append(this)
        except: self.this = this
    __swig_destroy__ = _statistics.delete_SpectralModelFactory
    __del__ = lambda self : None;
SpectralModelFactory_swigregister = _statistics.SpectralModelFactory_swigregister
SpectralModelFactory_swigregister(SpectralModelFactory)

def SpectralModelFactory_GetClassName():
  """SpectralModelFactory_GetClassName() -> OT::String"""
  return _statistics.SpectralModelFactory_GetClassName()

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

    if _newclass:GetClassName = staticmethod(GetClassName)
    __swig_getmethods__["GetClassName"] = lambda x: GetClassName
    def getClassName(self):
        """getClassName(UserDefinedSpectralModel self) -> OT::String"""
        return _statistics.UserDefinedSpectralModel_getClassName(self)

    def computeSpectralDensity(self, *args):
        """computeSpectralDensity(UserDefinedSpectralModel self, OT::NumericalScalar const frequency) -> HermitianMatrix"""
        return _statistics.UserDefinedSpectralModel_computeSpectralDensity(self, *args)

    def __repr__(self):
        """__repr__(UserDefinedSpectralModel self) -> OT::String"""
        return _statistics.UserDefinedSpectralModel___repr__(self)

    def __str__(self, offset=""):
        """
        __str__(UserDefinedSpectralModel self, OT::String const & offset="") -> OT::String
        __str__(UserDefinedSpectralModel self) -> OT::String
        """
        return _statistics.UserDefinedSpectralModel___str__(self, offset)

    def __init__(self, *args): 
        """
        __init__(OT::UserDefinedSpectralModel self, OT::String const & name=DefaultName) -> UserDefinedSpectralModel
        __init__(OT::UserDefinedSpectralModel self) -> UserDefinedSpectralModel
        __init__(OT::UserDefinedSpectralModel self, RegularGrid frequencyGrid, HermitianMatrixCollection spectralFunction, OT::String const & name=DefaultName) -> UserDefinedSpectralModel
        __init__(OT::UserDefinedSpectralModel self, RegularGrid frequencyGrid, HermitianMatrixCollection spectralFunction) -> UserDefinedSpectralModel
        __init__(OT::UserDefinedSpectralModel self, UserDefinedSpectralModel other) -> UserDefinedSpectralModel
        """
        this = _statistics.new_UserDefinedSpectralModel(*args)
        try: self.this.append(this)
        except: self.this = this
    __swig_destroy__ = _statistics.delete_UserDefinedSpectralModel
    __del__ = lambda self : None;
UserDefinedSpectralModel_swigregister = _statistics.UserDefinedSpectralModel_swigregister
UserDefinedSpectralModel_swigregister(UserDefinedSpectralModel)

def UserDefinedSpectralModel_GetClassName():
  """UserDefinedSpectralModel_GetClassName() -> OT::String"""
  return _statistics.UserDefinedSpectralModel_GetClassName()

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

    if _newclass:GetClassName = staticmethod(GetClassName)
    __swig_getmethods__["GetClassName"] = lambda x: GetClassName
    def getClassName(self):
        """getClassName(WelchFactory self) -> OT::String"""
        return _statistics.WelchFactory_getClassName(self)

    def __repr__(self):
        """__repr__(WelchFactory self) -> OT::String"""
        return _statistics.WelchFactory___repr__(self)

    def __str__(self, offset=""):
        """
        __str__(WelchFactory self, OT::String const & offset="") -> OT::String
        __str__(WelchFactory self) -> OT::String
        """
        return _statistics.WelchFactory___str__(self, offset)

    def getFilteringWindows(self):
        """getFilteringWindows(WelchFactory self) -> FilteringWindows"""
        return _statistics.WelchFactory_getFilteringWindows(self)

    def setFilteringWindows(self, *args):
        """setFilteringWindows(WelchFactory self, FilteringWindows window)"""
        return _statistics.WelchFactory_setFilteringWindows(self, *args)

    def getBlockNumber(self):
        """getBlockNumber(WelchFactory self) -> OT::UnsignedLong"""
        return _statistics.WelchFactory_getBlockNumber(self)

    def setBlockNumber(self, *args):
        """setBlockNumber(WelchFactory self, OT::UnsignedLong const blockNumber)"""
        return _statistics.WelchFactory_setBlockNumber(self, *args)

    def getOverlap(self):
        """getOverlap(WelchFactory self) -> OT::NumericalScalar"""
        return _statistics.WelchFactory_getOverlap(self)

    def setOverlap(self, *args):
        """setOverlap(WelchFactory self, OT::NumericalScalar const overlap)"""
        return _statistics.WelchFactory_setOverlap(self, *args)

    def build(self, *args):
        """
        build(WelchFactory self, ProcessSample sample) -> UserDefinedSpectralModel
        build(WelchFactory self, TimeSeries timeSerie) -> UserDefinedSpectralModel
        """
        return _statistics.WelchFactory_build(self, *args)

    def __init__(self, *args): 
        """
        __init__(OT::WelchFactory self, OT::String const & name=DefaultName) -> WelchFactory
        __init__(OT::WelchFactory self) -> WelchFactory
        __init__(OT::WelchFactory self, FilteringWindows window, OT::UnsignedLong const blockNumber, OT::NumericalScalar const overlap=0.5, 
            OT::String const & name=DefaultName) -> WelchFactory
        __init__(OT::WelchFactory self, FilteringWindows window, OT::UnsignedLong const blockNumber, OT::NumericalScalar const overlap=0.5) -> WelchFactory
        __init__(OT::WelchFactory self, FilteringWindows window, OT::UnsignedLong const blockNumber) -> WelchFactory
        __init__(OT::WelchFactory self, WelchFactory other) -> WelchFactory
        """
        this = _statistics.new_WelchFactory(*args)
        try: self.this.append(this)
        except: self.this = this
    __swig_destroy__ = _statistics.delete_WelchFactory
    __del__ = lambda self : None;
WelchFactory_swigregister = _statistics.WelchFactory_swigregister
WelchFactory_swigregister(WelchFactory)

def WelchFactory_GetClassName():
  """WelchFactory_GetClassName() -> OT::String"""
  return _statistics.WelchFactory_GetClassName()

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

    if _newclass:GetClassName = staticmethod(GetClassName)
    __swig_getmethods__["GetClassName"] = lambda x: GetClassName
    def getClassName(self):
        """getClassName(ExponentialModel self) -> OT::String"""
        return _statistics.ExponentialModel_getClassName(self)

    def computeCovariance(self, *args):
        """
        computeCovariance(ExponentialModel self, OT::NumericalScalar const s, OT::NumericalScalar const t) -> CovarianceMatrix
        computeCovariance(ExponentialModel self, OT::NumericalScalar const tau) -> CovarianceMatrix
        computeCovariance(ExponentialModel self, OT::NumericalScalar const tau) -> CovarianceMatrix
        """
        return _statistics.ExponentialModel_computeCovariance(self, *args)

    def discretizeCovariance(self, *args):
        """discretizeCovariance(ExponentialModel self, RegularGrid timeGrid) -> CovarianceMatrix"""
        return _statistics.ExponentialModel_discretizeCovariance(self, *args)

    def isStationary(self):
        """isStationary(ExponentialModel self) -> OT::Bool"""
        return _statistics.ExponentialModel_isStationary(self)

    def __repr__(self):
        """__repr__(ExponentialModel self) -> OT::String"""
        return _statistics.ExponentialModel___repr__(self)

    def __str__(self, offset=""):
        """
        __str__(ExponentialModel self, OT::String const & offset="") -> OT::String
        __str__(ExponentialModel self) -> OT::String
        """
        return _statistics.ExponentialModel___str__(self, offset)

    def getAmplitude(self):
        """getAmplitude(ExponentialModel self) -> NumericalPoint"""
        return _statistics.ExponentialModel_getAmplitude(self)

    def getScale(self):
        """getScale(ExponentialModel self) -> NumericalPoint"""
        return _statistics.ExponentialModel_getScale(self)

    def getSpatialCorrelation(self):
        """getSpatialCorrelation(ExponentialModel self) -> CorrelationMatrix"""
        return _statistics.ExponentialModel_getSpatialCorrelation(self)

    def __init__(self, *args): 
        """
        __init__(OT::ExponentialModel self, OT::String const & name=DefaultName) -> ExponentialModel
        __init__(OT::ExponentialModel self) -> ExponentialModel
        __init__(OT::ExponentialModel self, NumericalPoint amplitude, NumericalPoint scale, OT::String const & name=DefaultName) -> ExponentialModel
        __init__(OT::ExponentialModel self, NumericalPoint amplitude, NumericalPoint scale) -> ExponentialModel
        __init__(OT::ExponentialModel self, NumericalPoint amplitude, NumericalPoint scale, CorrelationMatrix spatialCorrelation, 
            OT::String const & name=DefaultName) -> ExponentialModel
        __init__(OT::ExponentialModel self, NumericalPoint amplitude, NumericalPoint scale, CorrelationMatrix spatialCorrelation) -> ExponentialModel
        __init__(OT::ExponentialModel self, NumericalPoint scale, CovarianceMatrix spatialCovariance, OT::String const & name=DefaultName) -> ExponentialModel
        __init__(OT::ExponentialModel self, NumericalPoint scale, CovarianceMatrix spatialCovariance) -> ExponentialModel
        __init__(OT::ExponentialModel self, ExponentialModel other) -> ExponentialModel
        """
        this = _statistics.new_ExponentialModel(*args)
        try: self.this.append(this)
        except: self.this = this
    __swig_destroy__ = _statistics.delete_ExponentialModel
    __del__ = lambda self : None;
ExponentialModel_swigregister = _statistics.ExponentialModel_swigregister
ExponentialModel_swigregister(ExponentialModel)

def ExponentialModel_GetClassName():
  """ExponentialModel_GetClassName() -> OT::String"""
  return _statistics.ExponentialModel_GetClassName()

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

    if _newclass:GetClassName = staticmethod(GetClassName)
    __swig_getmethods__["GetClassName"] = lambda x: GetClassName
    def getClassName(self):
        """getClassName(CauchyModel self) -> OT::String"""
        return _statistics.CauchyModel_getClassName(self)

    def computeSpectralDensity(self, *args):
        """computeSpectralDensity(CauchyModel self, OT::NumericalScalar const frequency) -> HermitianMatrix"""
        return _statistics.CauchyModel_computeSpectralDensity(self, *args)

    def __repr__(self):
        """__repr__(CauchyModel self) -> OT::String"""
        return _statistics.CauchyModel___repr__(self)

    def __str__(self, offset=""):
        """
        __str__(CauchyModel self, OT::String const & offset="") -> OT::String
        __str__(CauchyModel self) -> OT::String
        """
        return _statistics.CauchyModel___str__(self, offset)

    def getAmplitude(self):
        """getAmplitude(CauchyModel self) -> NumericalPoint"""
        return _statistics.CauchyModel_getAmplitude(self)

    def getScale(self):
        """getScale(CauchyModel self) -> NumericalPoint"""
        return _statistics.CauchyModel_getScale(self)

    def getSpatialCorrelation(self):
        """getSpatialCorrelation(CauchyModel self) -> CorrelationMatrix"""
        return _statistics.CauchyModel_getSpatialCorrelation(self)

    def __init__(self, *args): 
        """
        __init__(OT::CauchyModel self, OT::String const & name=DefaultName) -> CauchyModel
        __init__(OT::CauchyModel self) -> CauchyModel
        __init__(OT::CauchyModel self, NumericalPoint amplitude, NumericalPoint scale, OT::String const & name=DefaultName) -> CauchyModel
        __init__(OT::CauchyModel self, NumericalPoint amplitude, NumericalPoint scale) -> CauchyModel
        __init__(OT::CauchyModel self, NumericalPoint amplitude, NumericalPoint scale, CorrelationMatrix spatialCorrelation, 
            OT::String const & name=DefaultName) -> CauchyModel
        __init__(OT::CauchyModel self, NumericalPoint amplitude, NumericalPoint scale, CorrelationMatrix spatialCorrelation) -> CauchyModel
        __init__(OT::CauchyModel self, NumericalPoint scale, CovarianceMatrix spatialCovariance, OT::String const & name=DefaultName) -> CauchyModel
        __init__(OT::CauchyModel self, NumericalPoint scale, CovarianceMatrix spatialCovariance) -> CauchyModel
        __init__(OT::CauchyModel self, CauchyModel other) -> CauchyModel
        """
        this = _statistics.new_CauchyModel(*args)
        try: self.this.append(this)
        except: self.this = this
    __swig_destroy__ = _statistics.delete_CauchyModel
    __del__ = lambda self : None;
CauchyModel_swigregister = _statistics.CauchyModel_swigregister
CauchyModel_swigregister(CauchyModel)

def CauchyModel_GetClassName():
  """CauchyModel_GetClassName() -> OT::String"""
  return _statistics.CauchyModel_GetClassName()

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

    if _newclass:GetClassName = staticmethod(GetClassName)
    __swig_getmethods__["GetClassName"] = lambda x: GetClassName
    def getClassName(self):
        """getClassName(CovarianceModelFactoryImplementation self) -> OT::String"""
        return _statistics.CovarianceModelFactoryImplementation_getClassName(self)

    def __repr__(self):
        """__repr__(CovarianceModelFactoryImplementation self) -> OT::String"""
        return _statistics.CovarianceModelFactoryImplementation___repr__(self)

    def __str__(self, offset=""):
        """
        __str__(CovarianceModelFactoryImplementation self, OT::String const & offset="") -> OT::String
        __str__(CovarianceModelFactoryImplementation self) -> OT::String
        """
        return _statistics.CovarianceModelFactoryImplementation___str__(self, offset)

    def build(self, *args):
        """
        build(CovarianceModelFactoryImplementation self, ProcessSample sample) -> CovarianceModelImplementation
        build(CovarianceModelFactoryImplementation self, TimeSeries timeSerie) -> CovarianceModelImplementation
        """
        return _statistics.CovarianceModelFactoryImplementation_build(self, *args)

    def __init__(self, *args): 
        """
        __init__(OT::CovarianceModelFactoryImplementation self, OT::String const & name=DefaultName) -> CovarianceModelFactoryImplementation
        __init__(OT::CovarianceModelFactoryImplementation self) -> CovarianceModelFactoryImplementation
        __init__(OT::CovarianceModelFactoryImplementation self, CovarianceModelFactoryImplementation other) -> CovarianceModelFactoryImplementation
        """
        this = _statistics.new_CovarianceModelFactoryImplementation(*args)
        try: self.this.append(this)
        except: self.this = this
    __swig_destroy__ = _statistics.delete_CovarianceModelFactoryImplementation
    __del__ = lambda self : None;
CovarianceModelFactoryImplementation_swigregister = _statistics.CovarianceModelFactoryImplementation_swigregister
CovarianceModelFactoryImplementation_swigregister(CovarianceModelFactoryImplementation)

def CovarianceModelFactoryImplementation_GetClassName():
  """CovarianceModelFactoryImplementation_GetClassName() -> OT::String"""
  return _statistics.CovarianceModelFactoryImplementation_GetClassName()

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

    def getImplementationAsPersistentObject(self):
        """getImplementationAsPersistentObject(CovarianceModelFactoryImplementationTypedInterfaceObject self) -> PersistentObjectPointer"""
        return _statistics.CovarianceModelFactoryImplementationTypedInterfaceObject_getImplementationAsPersistentObject(self)

    def setImplementationAsPersistentObject(self, *args):
        """setImplementationAsPersistentObject(CovarianceModelFactoryImplementationTypedInterfaceObject self, PersistentObjectPointer obj)"""
        return _statistics.CovarianceModelFactoryImplementationTypedInterfaceObject_setImplementationAsPersistentObject(self, *args)

    def swap(self, *args):
        """swap(CovarianceModelFactoryImplementationTypedInterfaceObject self, CovarianceModelFactoryImplementationTypedInterfaceObject other)"""
        return _statistics.CovarianceModelFactoryImplementationTypedInterfaceObject_swap(self, *args)

    def setName(self, *args):
        """setName(CovarianceModelFactoryImplementationTypedInterfaceObject self, OT::String const & name)"""
        return _statistics.CovarianceModelFactoryImplementationTypedInterfaceObject_setName(self, *args)

    def getName(self):
        """getName(CovarianceModelFactoryImplementationTypedInterfaceObject self) -> OT::String"""
        return _statistics.CovarianceModelFactoryImplementationTypedInterfaceObject_getName(self)

    def __eq__(self, *args):
        """__eq__(CovarianceModelFactoryImplementationTypedInterfaceObject self, CovarianceModelFactoryImplementationTypedInterfaceObject other) -> OT::Bool"""
        return _statistics.CovarianceModelFactoryImplementationTypedInterfaceObject___eq__(self, *args)

    __swig_destroy__ = _statistics.delete_CovarianceModelFactoryImplementationTypedInterfaceObject
    __del__ = lambda self : None;
CovarianceModelFactoryImplementationTypedInterfaceObject_swigregister = _statistics.CovarianceModelFactoryImplementationTypedInterfaceObject_swigregister
CovarianceModelFactoryImplementationTypedInterfaceObject_swigregister(CovarianceModelFactoryImplementationTypedInterfaceObject)

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

    if _newclass:GetClassName = staticmethod(GetClassName)
    __swig_getmethods__["GetClassName"] = lambda x: GetClassName
    def getClassName(self):
        """getClassName(CovarianceModelFactory self) -> OT::String"""
        return _statistics.CovarianceModelFactory_getClassName(self)

    def __repr__(self):
        """__repr__(CovarianceModelFactory self) -> OT::String"""
        return _statistics.CovarianceModelFactory___repr__(self)

    def __str__(self, offset=""):
        """
        __str__(CovarianceModelFactory self, OT::String const & offset="") -> OT::String
        __str__(CovarianceModelFactory self) -> OT::String
        """
        return _statistics.CovarianceModelFactory___str__(self, offset)

    def build(self, *args):
        """
        build(CovarianceModelFactory self, ProcessSample sample) -> CovarianceModel
        build(CovarianceModelFactory self, TimeSeries timeSerie) -> CovarianceModel
        """
        return _statistics.CovarianceModelFactory_build(self, *args)

    def __init__(self, *args): 
        """
        __init__(OT::CovarianceModelFactory self, OT::String const & name=DefaultName) -> CovarianceModelFactory
        __init__(OT::CovarianceModelFactory self) -> CovarianceModelFactory
        __init__(OT::CovarianceModelFactory self, CovarianceModelFactoryImplementation implementation, OT::String const & name=DefaultName) -> CovarianceModelFactory
        __init__(OT::CovarianceModelFactory self, CovarianceModelFactoryImplementation implementation) -> CovarianceModelFactory
        __init__(OT::CovarianceModelFactory self, OT::CovarianceModelFactory::Implementation const & p_implementation, OT::String const & name=DefaultName) -> CovarianceModelFactory
        __init__(OT::CovarianceModelFactory self, OT::CovarianceModelFactory::Implementation const & p_implementation) -> CovarianceModelFactory
        __init__(OT::CovarianceModelFactory self, CovarianceModelFactory other) -> CovarianceModelFactory
        """
        this = _statistics.new_CovarianceModelFactory(*args)
        try: self.this.append(this)
        except: self.this = this
    __swig_destroy__ = _statistics.delete_CovarianceModelFactory
    __del__ = lambda self : None;
CovarianceModelFactory_swigregister = _statistics.CovarianceModelFactory_swigregister
CovarianceModelFactory_swigregister(CovarianceModelFactory)

def CovarianceModelFactory_GetClassName():
  """CovarianceModelFactory_GetClassName() -> OT::String"""
  return _statistics.CovarianceModelFactory_GetClassName()

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

    if _newclass:GetClassName = staticmethod(GetClassName)
    __swig_getmethods__["GetClassName"] = lambda x: GetClassName
    def getClassName(self):
        """getClassName(UserDefinedCovarianceModel self) -> OT::String"""
        return _statistics.UserDefinedCovarianceModel_getClassName(self)

    def computeCovariance(self, *args):
        """computeCovariance(UserDefinedCovarianceModel self, OT::NumericalScalar const s, OT::NumericalScalar const t) -> CovarianceMatrix"""
        return _statistics.UserDefinedCovarianceModel_computeCovariance(self, *args)

    def getTimeGrid(self):
        """getTimeGrid(UserDefinedCovarianceModel self) -> RegularGrid"""
        return _statistics.UserDefinedCovarianceModel_getTimeGrid(self)

    def __repr__(self):
        """__repr__(UserDefinedCovarianceModel self) -> OT::String"""
        return _statistics.UserDefinedCovarianceModel___repr__(self)

    def __str__(self, offset=""):
        """
        __str__(UserDefinedCovarianceModel self, OT::String const & offset="") -> OT::String
        __str__(UserDefinedCovarianceModel self) -> OT::String
        """
        return _statistics.UserDefinedCovarianceModel___str__(self, offset)

    def __init__(self, *args): 
        """
        __init__(OT::UserDefinedCovarianceModel self, OT::String const & name=DefaultName) -> UserDefinedCovarianceModel
        __init__(OT::UserDefinedCovarianceModel self) -> UserDefinedCovarianceModel
        __init__(OT::UserDefinedCovarianceModel self, RegularGrid timeGrid, CovarianceMatrixCollection spectralFunction, OT::String const & name=DefaultName) -> UserDefinedCovarianceModel
        __init__(OT::UserDefinedCovarianceModel self, RegularGrid timeGrid, CovarianceMatrixCollection spectralFunction) -> UserDefinedCovarianceModel
        __init__(OT::UserDefinedCovarianceModel self, UserDefinedCovarianceModel other) -> UserDefinedCovarianceModel
        """
        this = _statistics.new_UserDefinedCovarianceModel(*args)
        try: self.this.append(this)
        except: self.this = this
    __swig_destroy__ = _statistics.delete_UserDefinedCovarianceModel
    __del__ = lambda self : None;
UserDefinedCovarianceModel_swigregister = _statistics.UserDefinedCovarianceModel_swigregister
UserDefinedCovarianceModel_swigregister(UserDefinedCovarianceModel)

def UserDefinedCovarianceModel_GetClassName():
  """UserDefinedCovarianceModel_GetClassName() -> OT::String"""
  return _statistics.UserDefinedCovarianceModel_GetClassName()

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

    if _newclass:GetClassName = staticmethod(GetClassName)
    __swig_getmethods__["GetClassName"] = lambda x: GetClassName
    def getClassName(self):
        """getClassName(NonStationaryCovarianceModelFactory self) -> OT::String"""
        return _statistics.NonStationaryCovarianceModelFactory_getClassName(self)

    def __repr__(self):
        """__repr__(NonStationaryCovarianceModelFactory self) -> OT::String"""
        return _statistics.NonStationaryCovarianceModelFactory___repr__(self)

    def __str__(self, offset=""):
        """
        __str__(NonStationaryCovarianceModelFactory self, OT::String const & offset="") -> OT::String
        __str__(NonStationaryCovarianceModelFactory self) -> OT::String
        """
        return _statistics.NonStationaryCovarianceModelFactory___str__(self, offset)

    def build(self, *args):
        """
        build(NonStationaryCovarianceModelFactory self, ProcessSample sample) -> UserDefinedCovarianceModel
        build(NonStationaryCovarianceModelFactory self, TimeSeries timeSerie) -> UserDefinedCovarianceModel
        """
        return _statistics.NonStationaryCovarianceModelFactory_build(self, *args)

    def __init__(self, *args): 
        """
        __init__(OT::NonStationaryCovarianceModelFactory self, OT::String const & name=DefaultName) -> NonStationaryCovarianceModelFactory
        __init__(OT::NonStationaryCovarianceModelFactory self) -> NonStationaryCovarianceModelFactory
        __init__(OT::NonStationaryCovarianceModelFactory self, NonStationaryCovarianceModelFactory other) -> NonStationaryCovarianceModelFactory
        """
        this = _statistics.new_NonStationaryCovarianceModelFactory(*args)
        try: self.this.append(this)
        except: self.this = this
    __swig_destroy__ = _statistics.delete_NonStationaryCovarianceModelFactory
    __del__ = lambda self : None;
NonStationaryCovarianceModelFactory_swigregister = _statistics.NonStationaryCovarianceModelFactory_swigregister
NonStationaryCovarianceModelFactory_swigregister(NonStationaryCovarianceModelFactory)

def NonStationaryCovarianceModelFactory_GetClassName():
  """NonStationaryCovarianceModelFactory_GetClassName() -> OT::String"""
  return _statistics.NonStationaryCovarianceModelFactory_GetClassName()

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

    if _newclass:GetClassName = staticmethod(GetClassName)
    __swig_getmethods__["GetClassName"] = lambda x: GetClassName
    def getClassName(self):
        """getClassName(UserDefinedStationaryCovarianceModel self) -> OT::String"""
        return _statistics.UserDefinedStationaryCovarianceModel_getClassName(self)

    def computeCovariance(self, *args):
        """
        computeCovariance(UserDefinedStationaryCovarianceModel self, OT::NumericalScalar const t, OT::NumericalScalar const s) -> CovarianceMatrix
        computeCovariance(UserDefinedStationaryCovarianceModel self, OT::NumericalScalar const t) -> CovarianceMatrix
        """
        return _statistics.UserDefinedStationaryCovarianceModel_computeCovariance(self, *args)

    def getTimeGrid(self):
        """getTimeGrid(UserDefinedStationaryCovarianceModel self) -> RegularGrid"""
        return _statistics.UserDefinedStationaryCovarianceModel_getTimeGrid(self)

    def __repr__(self):
        """__repr__(UserDefinedStationaryCovarianceModel self) -> OT::String"""
        return _statistics.UserDefinedStationaryCovarianceModel___repr__(self)

    def __str__(self, offset=""):
        """
        __str__(UserDefinedStationaryCovarianceModel self, OT::String const & offset="") -> OT::String
        __str__(UserDefinedStationaryCovarianceModel self) -> OT::String
        """
        return _statistics.UserDefinedStationaryCovarianceModel___str__(self, offset)

    def __init__(self, *args): 
        """
        __init__(OT::UserDefinedStationaryCovarianceModel self, OT::String const & name=DefaultName) -> UserDefinedStationaryCovarianceModel
        __init__(OT::UserDefinedStationaryCovarianceModel self) -> UserDefinedStationaryCovarianceModel
        __init__(OT::UserDefinedStationaryCovarianceModel self, RegularGrid timeGrid, CovarianceMatrixCollection spectralFunction, OT::String const & name=DefaultName) -> UserDefinedStationaryCovarianceModel
        __init__(OT::UserDefinedStationaryCovarianceModel self, RegularGrid timeGrid, CovarianceMatrixCollection spectralFunction) -> UserDefinedStationaryCovarianceModel
        __init__(OT::UserDefinedStationaryCovarianceModel self, UserDefinedStationaryCovarianceModel other) -> UserDefinedStationaryCovarianceModel
        """
        this = _statistics.new_UserDefinedStationaryCovarianceModel(*args)
        try: self.this.append(this)
        except: self.this = this
    __swig_destroy__ = _statistics.delete_UserDefinedStationaryCovarianceModel
    __del__ = lambda self : None;
UserDefinedStationaryCovarianceModel_swigregister = _statistics.UserDefinedStationaryCovarianceModel_swigregister
UserDefinedStationaryCovarianceModel_swigregister(UserDefinedStationaryCovarianceModel)

def UserDefinedStationaryCovarianceModel_GetClassName():
  """UserDefinedStationaryCovarianceModel_GetClassName() -> OT::String"""
  return _statistics.UserDefinedStationaryCovarianceModel_GetClassName()

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

    if _newclass:GetClassName = staticmethod(GetClassName)
    __swig_getmethods__["GetClassName"] = lambda x: GetClassName
    def getClassName(self):
        """getClassName(StationaryCovarianceModelFactory self) -> OT::String"""
        return _statistics.StationaryCovarianceModelFactory_getClassName(self)

    def getSpectralModelFactory(self):
        """getSpectralModelFactory(StationaryCovarianceModelFactory self) -> SpectralModelFactory"""
        return _statistics.StationaryCovarianceModelFactory_getSpectralModelFactory(self)

    def setSpectralModelFactory(self, *args):
        """setSpectralModelFactory(StationaryCovarianceModelFactory self, SpectralModelFactory factory)"""
        return _statistics.StationaryCovarianceModelFactory_setSpectralModelFactory(self, *args)

    def __repr__(self):
        """__repr__(StationaryCovarianceModelFactory self) -> OT::String"""
        return _statistics.StationaryCovarianceModelFactory___repr__(self)

    def __str__(self, offset=""):
        """
        __str__(StationaryCovarianceModelFactory self, OT::String const & offset="") -> OT::String
        __str__(StationaryCovarianceModelFactory self) -> OT::String
        """
        return _statistics.StationaryCovarianceModelFactory___str__(self, offset)

    def build(self, *args):
        """
        build(StationaryCovarianceModelFactory self, ProcessSample sample) -> UserDefinedStationaryCovarianceModel
        build(StationaryCovarianceModelFactory self, TimeSeries timeSerie) -> UserDefinedStationaryCovarianceModel
        """
        return _statistics.StationaryCovarianceModelFactory_build(self, *args)

    def __init__(self, *args): 
        """
        __init__(OT::StationaryCovarianceModelFactory self, SpectralModelFactory factory=OT::WelchFactory(), OT::String const & name=DefaultName) -> StationaryCovarianceModelFactory
        __init__(OT::StationaryCovarianceModelFactory self, SpectralModelFactory factory=OT::WelchFactory()) -> StationaryCovarianceModelFactory
        __init__(OT::StationaryCovarianceModelFactory self) -> StationaryCovarianceModelFactory
        __init__(OT::StationaryCovarianceModelFactory self, StationaryCovarianceModelFactory other) -> StationaryCovarianceModelFactory
        """
        this = _statistics.new_StationaryCovarianceModelFactory(*args)
        try: self.this.append(this)
        except: self.this = this
    __swig_destroy__ = _statistics.delete_StationaryCovarianceModelFactory
    __del__ = lambda self : None;
StationaryCovarianceModelFactory_swigregister = _statistics.StationaryCovarianceModelFactory_swigregister
StationaryCovarianceModelFactory_swigregister(StationaryCovarianceModelFactory)

def StationaryCovarianceModelFactory_GetClassName():
  """StationaryCovarianceModelFactory_GetClassName() -> OT::String"""
  return _statistics.StationaryCovarianceModelFactory_GetClassName()

class CovarianceModelImplementationPointer(_object):
    """Proxy of C++ OT::Pointer<(OT::CovarianceModelImplementation)> class"""
    __swig_setmethods__ = {}
    __setattr__ = lambda self, name, value: _swig_setattr(self, CovarianceModelImplementationPointer, name, value)
    __swig_getmethods__ = {}
    __getattr__ = lambda self, name: _swig_getattr(self, CovarianceModelImplementationPointer, name)
    __swig_setmethods__["ptr_"] = _statistics.CovarianceModelImplementationPointer_ptr__set
    __swig_getmethods__["ptr_"] = _statistics.CovarianceModelImplementationPointer_ptr__get
    if _newclass:ptr_ = _swig_property(_statistics.CovarianceModelImplementationPointer_ptr__get, _statistics.CovarianceModelImplementationPointer_ptr__set)
    def __init__(self, *args): 
        """
        __init__(OT::Pointer<(OT::CovarianceModelImplementation)> self) -> CovarianceModelImplementationPointer
        __init__(OT::Pointer<(OT::CovarianceModelImplementation)> self, CovarianceModelImplementation ptr) -> CovarianceModelImplementationPointer
        """
        this = _statistics.new_CovarianceModelImplementationPointer(*args)
        try: self.this.append(this)
        except: self.this = this
    __swig_destroy__ = _statistics.delete_CovarianceModelImplementationPointer
    __del__ = lambda self : None;
    def reset(self):
        """reset(CovarianceModelImplementationPointer self)"""
        return _statistics.CovarianceModelImplementationPointer_reset(self)

    def __ref__(self, *args):
        """
        __ref__(CovarianceModelImplementationPointer self) -> CovarianceModelImplementation
        __ref__(CovarianceModelImplementationPointer self) -> CovarianceModelImplementation
        """
        return _statistics.CovarianceModelImplementationPointer___ref__(self, *args)

    def __deref__(self):
        """__deref__(CovarianceModelImplementationPointer self) -> CovarianceModelImplementation"""
        return _statistics.CovarianceModelImplementationPointer___deref__(self)

    def isNull(self):
        """isNull(CovarianceModelImplementationPointer self) -> OT::Bool"""
        return _statistics.CovarianceModelImplementationPointer_isNull(self)

    def __nonzero__(self):
        return _statistics.CovarianceModelImplementationPointer___nonzero__(self)
    __bool__ = __nonzero__


    def get(self):
        """get(CovarianceModelImplementationPointer self) -> CovarianceModelImplementation"""
        return _statistics.CovarianceModelImplementationPointer_get(self)

    def getImplementation(self):
        """getImplementation(CovarianceModelImplementationPointer self) -> OT::Pointer< OT::CovarianceModelImplementation >::pointer_type const &"""
        return _statistics.CovarianceModelImplementationPointer_getImplementation(self)

    def unique(self):
        """unique(CovarianceModelImplementationPointer self) -> OT::Bool"""
        return _statistics.CovarianceModelImplementationPointer_unique(self)

    def use_count(self):
        """use_count(CovarianceModelImplementationPointer self) -> OT::UnsignedLong"""
        return _statistics.CovarianceModelImplementationPointer_use_count(self)

    def swap(self, *args):
        """swap(CovarianceModelImplementationPointer self, CovarianceModelImplementationPointer other)"""
        return _statistics.CovarianceModelImplementationPointer_swap(self, *args)

    def GetClassName(self):
        """GetClassName(CovarianceModelImplementationPointer self) -> OT::String"""
        return _statistics.CovarianceModelImplementationPointer_GetClassName(self)

    def getClassName(self):
        """getClassName(CovarianceModelImplementationPointer self) -> OT::String"""
        return _statistics.CovarianceModelImplementationPointer_getClassName(self)

    def getDimension(self):
        """getDimension(CovarianceModelImplementationPointer self) -> OT::UnsignedLong"""
        return _statistics.CovarianceModelImplementationPointer_getDimension(self)

    def computeCovariance(self, *args):
        """
        computeCovariance(CovarianceModelImplementationPointer self, OT::NumericalScalar const s, OT::NumericalScalar const t) -> CovarianceMatrix
        computeCovariance(CovarianceModelImplementationPointer self, OT::NumericalScalar const tau) -> CovarianceMatrix
        """
        return _statistics.CovarianceModelImplementationPointer_computeCovariance(self, *args)

    def discretizeCovariance(self, *args):
        """discretizeCovariance(CovarianceModelImplementationPointer self, RegularGrid timeGrid) -> CovarianceMatrix"""
        return _statistics.CovarianceModelImplementationPointer_discretizeCovariance(self, *args)

    def isStationary(self):
        """isStationary(CovarianceModelImplementationPointer self) -> OT::Bool"""
        return _statistics.CovarianceModelImplementationPointer_isStationary(self)

    def __repr__(self):
        """__repr__(CovarianceModelImplementationPointer self) -> OT::String"""
        return _statistics.CovarianceModelImplementationPointer___repr__(self)

    def __str__(self, offset=""):
        """
        __str__(CovarianceModelImplementationPointer self, OT::String const & offset="") -> OT::String
        __str__(CovarianceModelImplementationPointer self) -> OT::String
        """
        return _statistics.CovarianceModelImplementationPointer___str__(self, offset)

    def __eq__(self, *args):
        """__eq__(CovarianceModelImplementationPointer self, PersistentObject other) -> OT::Bool"""
        return _statistics.CovarianceModelImplementationPointer___eq__(self, *args)

    def Is(self, *args):
        """Is(CovarianceModelImplementationPointer self, PersistentObject other) -> OT::Bool"""
        return _statistics.CovarianceModelImplementationPointer_Is(self, *args)

    def getId(self):
        """getId(CovarianceModelImplementationPointer self) -> OT::Id"""
        return _statistics.CovarianceModelImplementationPointer_getId(self)

    def setShadowedId(self, *args):
        """setShadowedId(CovarianceModelImplementationPointer self, OT::Id id)"""
        return _statistics.CovarianceModelImplementationPointer_setShadowedId(self, *args)

    def getShadowedId(self):
        """getShadowedId(CovarianceModelImplementationPointer self) -> OT::Id"""
        return _statistics.CovarianceModelImplementationPointer_getShadowedId(self)

    def setVisibility(self, *args):
        """setVisibility(CovarianceModelImplementationPointer self, OT::Bool visible)"""
        return _statistics.CovarianceModelImplementationPointer_setVisibility(self, *args)

    def getVisibility(self):
        """getVisibility(CovarianceModelImplementationPointer self) -> OT::Bool"""
        return _statistics.CovarianceModelImplementationPointer_getVisibility(self)

    def hasName(self):
        """hasName(CovarianceModelImplementationPointer self) -> OT::Bool"""
        return _statistics.CovarianceModelImplementationPointer_hasName(self)

    def hasVisibleName(self):
        """hasVisibleName(CovarianceModelImplementationPointer self) -> OT::Bool"""
        return _statistics.CovarianceModelImplementationPointer_hasVisibleName(self)

    def getName(self):
        """getName(CovarianceModelImplementationPointer self) -> OT::String"""
        return _statistics.CovarianceModelImplementationPointer_getName(self)

    def setName(self, *args):
        """setName(CovarianceModelImplementationPointer self, OT::String const & name)"""
        return _statistics.CovarianceModelImplementationPointer_setName(self, *args)

CovarianceModelImplementationPointer_swigregister = _statistics.CovarianceModelImplementationPointer_swigregister
CovarianceModelImplementationPointer_swigregister(CovarianceModelImplementationPointer)

class SpectralModelImplementationPointer(_object):
    """Proxy of C++ OT::Pointer<(OT::SpectralModelImplementation)> class"""
    __swig_setmethods__ = {}
    __setattr__ = lambda self, name, value: _swig_setattr(self, SpectralModelImplementationPointer, name, value)
    __swig_getmethods__ = {}
    __getattr__ = lambda self, name: _swig_getattr(self, SpectralModelImplementationPointer, name)
    __swig_setmethods__["ptr_"] = _statistics.SpectralModelImplementationPointer_ptr__set
    __swig_getmethods__["ptr_"] = _statistics.SpectralModelImplementationPointer_ptr__get
    if _newclass:ptr_ = _swig_property(_statistics.SpectralModelImplementationPointer_ptr__get, _statistics.SpectralModelImplementationPointer_ptr__set)
    def __init__(self, *args): 
        """
        __init__(OT::Pointer<(OT::SpectralModelImplementation)> self) -> SpectralModelImplementationPointer
        __init__(OT::Pointer<(OT::SpectralModelImplementation)> self, SpectralModelImplementation ptr) -> SpectralModelImplementationPointer
        """
        this = _statistics.new_SpectralModelImplementationPointer(*args)
        try: self.this.append(this)
        except: self.this = this
    __swig_destroy__ = _statistics.delete_SpectralModelImplementationPointer
    __del__ = lambda self : None;
    def reset(self):
        """reset(SpectralModelImplementationPointer self)"""
        return _statistics.SpectralModelImplementationPointer_reset(self)

    def __ref__(self, *args):
        """
        __ref__(SpectralModelImplementationPointer self) -> SpectralModelImplementation
        __ref__(SpectralModelImplementationPointer self) -> SpectralModelImplementation
        """
        return _statistics.SpectralModelImplementationPointer___ref__(self, *args)

    def __deref__(self):
        """__deref__(SpectralModelImplementationPointer self) -> SpectralModelImplementation"""
        return _statistics.SpectralModelImplementationPointer___deref__(self)

    def isNull(self):
        """isNull(SpectralModelImplementationPointer self) -> OT::Bool"""
        return _statistics.SpectralModelImplementationPointer_isNull(self)

    def __nonzero__(self):
        return _statistics.SpectralModelImplementationPointer___nonzero__(self)
    __bool__ = __nonzero__


    def get(self):
        """get(SpectralModelImplementationPointer self) -> SpectralModelImplementation"""
        return _statistics.SpectralModelImplementationPointer_get(self)

    def getImplementation(self):
        """getImplementation(SpectralModelImplementationPointer self) -> OT::Pointer< OT::SpectralModelImplementation >::pointer_type const &"""
        return _statistics.SpectralModelImplementationPointer_getImplementation(self)

    def unique(self):
        """unique(SpectralModelImplementationPointer self) -> OT::Bool"""
        return _statistics.SpectralModelImplementationPointer_unique(self)

    def use_count(self):
        """use_count(SpectralModelImplementationPointer self) -> OT::UnsignedLong"""
        return _statistics.SpectralModelImplementationPointer_use_count(self)

    def swap(self, *args):
        """swap(SpectralModelImplementationPointer self, SpectralModelImplementationPointer other)"""
        return _statistics.SpectralModelImplementationPointer_swap(self, *args)

    def GetClassName(self):
        """GetClassName(SpectralModelImplementationPointer self) -> OT::String"""
        return _statistics.SpectralModelImplementationPointer_GetClassName(self)

    def getClassName(self):
        """getClassName(SpectralModelImplementationPointer self) -> OT::String"""
        return _statistics.SpectralModelImplementationPointer_getClassName(self)

    def getDimension(self):
        """getDimension(SpectralModelImplementationPointer self) -> OT::UnsignedLong"""
        return _statistics.SpectralModelImplementationPointer_getDimension(self)

    def setDimension(self, *args):
        """setDimension(SpectralModelImplementationPointer self, OT::UnsignedLong const dimension)"""
        return _statistics.SpectralModelImplementationPointer_setDimension(self, *args)

    def computeSpectralDensity(self, *args):
        """computeSpectralDensity(SpectralModelImplementationPointer self, OT::NumericalScalar const frequency) -> HermitianMatrix"""
        return _statistics.SpectralModelImplementationPointer_computeSpectralDensity(self, *args)

    def getFrequencyGrid(self):
        """getFrequencyGrid(SpectralModelImplementationPointer self) -> RegularGrid"""
        return _statistics.SpectralModelImplementationPointer_getFrequencyGrid(self)

    def setFrequencyGrid(self, *args):
        """setFrequencyGrid(SpectralModelImplementationPointer self, RegularGrid frequencyGrid)"""
        return _statistics.SpectralModelImplementationPointer_setFrequencyGrid(self, *args)

    def __repr__(self):
        """__repr__(SpectralModelImplementationPointer self) -> OT::String"""
        return _statistics.SpectralModelImplementationPointer___repr__(self)

    def __str__(self, offset=""):
        """
        __str__(SpectralModelImplementationPointer self, OT::String const & offset="") -> OT::String
        __str__(SpectralModelImplementationPointer self) -> OT::String
        """
        return _statistics.SpectralModelImplementationPointer___str__(self, offset)

    def __eq__(self, *args):
        """__eq__(SpectralModelImplementationPointer self, PersistentObject other) -> OT::Bool"""
        return _statistics.SpectralModelImplementationPointer___eq__(self, *args)

    def Is(self, *args):
        """Is(SpectralModelImplementationPointer self, PersistentObject other) -> OT::Bool"""
        return _statistics.SpectralModelImplementationPointer_Is(self, *args)

    def getId(self):
        """getId(SpectralModelImplementationPointer self) -> OT::Id"""
        return _statistics.SpectralModelImplementationPointer_getId(self)

    def setShadowedId(self, *args):
        """setShadowedId(SpectralModelImplementationPointer self, OT::Id id)"""
        return _statistics.SpectralModelImplementationPointer_setShadowedId(self, *args)

    def getShadowedId(self):
        """getShadowedId(SpectralModelImplementationPointer self) -> OT::Id"""
        return _statistics.SpectralModelImplementationPointer_getShadowedId(self)

    def setVisibility(self, *args):
        """setVisibility(SpectralModelImplementationPointer self, OT::Bool visible)"""
        return _statistics.SpectralModelImplementationPointer_setVisibility(self, *args)

    def getVisibility(self):
        """getVisibility(SpectralModelImplementationPointer self) -> OT::Bool"""
        return _statistics.SpectralModelImplementationPointer_getVisibility(self)

    def hasName(self):
        """hasName(SpectralModelImplementationPointer self) -> OT::Bool"""
        return _statistics.SpectralModelImplementationPointer_hasName(self)

    def hasVisibleName(self):
        """hasVisibleName(SpectralModelImplementationPointer self) -> OT::Bool"""
        return _statistics.SpectralModelImplementationPointer_hasVisibleName(self)

    def getName(self):
        """getName(SpectralModelImplementationPointer self) -> OT::String"""
        return _statistics.SpectralModelImplementationPointer_getName(self)

    def setName(self, *args):
        """setName(SpectralModelImplementationPointer self, OT::String const & name)"""
        return _statistics.SpectralModelImplementationPointer_setName(self, *args)

SpectralModelImplementationPointer_swigregister = _statistics.SpectralModelImplementationPointer_swigregister
SpectralModelImplementationPointer_swigregister(SpectralModelImplementationPointer)

class SecondOrderModelImplementationPointer(_object):
    """Proxy of C++ OT::Pointer<(OT::SecondOrderModelImplementation)> class"""
    __swig_setmethods__ = {}
    __setattr__ = lambda self, name, value: _swig_setattr(self, SecondOrderModelImplementationPointer, name, value)
    __swig_getmethods__ = {}
    __getattr__ = lambda self, name: _swig_getattr(self, SecondOrderModelImplementationPointer, name)
    __swig_setmethods__["ptr_"] = _statistics.SecondOrderModelImplementationPointer_ptr__set
    __swig_getmethods__["ptr_"] = _statistics.SecondOrderModelImplementationPointer_ptr__get
    if _newclass:ptr_ = _swig_property(_statistics.SecondOrderModelImplementationPointer_ptr__get, _statistics.SecondOrderModelImplementationPointer_ptr__set)
    def __init__(self, *args): 
        """
        __init__(OT::Pointer<(OT::SecondOrderModelImplementation)> self) -> SecondOrderModelImplementationPointer
        __init__(OT::Pointer<(OT::SecondOrderModelImplementation)> self, SecondOrderModelImplementation ptr) -> SecondOrderModelImplementationPointer
        """
        this = _statistics.new_SecondOrderModelImplementationPointer(*args)
        try: self.this.append(this)
        except: self.this = this
    __swig_destroy__ = _statistics.delete_SecondOrderModelImplementationPointer
    __del__ = lambda self : None;
    def reset(self):
        """reset(SecondOrderModelImplementationPointer self)"""
        return _statistics.SecondOrderModelImplementationPointer_reset(self)

    def __ref__(self, *args):
        """
        __ref__(SecondOrderModelImplementationPointer self) -> SecondOrderModelImplementation
        __ref__(SecondOrderModelImplementationPointer self) -> SecondOrderModelImplementation
        """
        return _statistics.SecondOrderModelImplementationPointer___ref__(self, *args)

    def __deref__(self):
        """__deref__(SecondOrderModelImplementationPointer self) -> SecondOrderModelImplementation"""
        return _statistics.SecondOrderModelImplementationPointer___deref__(self)

    def isNull(self):
        """isNull(SecondOrderModelImplementationPointer self) -> OT::Bool"""
        return _statistics.SecondOrderModelImplementationPointer_isNull(self)

    def __nonzero__(self):
        return _statistics.SecondOrderModelImplementationPointer___nonzero__(self)
    __bool__ = __nonzero__


    def get(self):
        """get(SecondOrderModelImplementationPointer self) -> SecondOrderModelImplementation"""
        return _statistics.SecondOrderModelImplementationPointer_get(self)

    def getImplementation(self):
        """getImplementation(SecondOrderModelImplementationPointer self) -> OT::Pointer< OT::SecondOrderModelImplementation >::pointer_type const &"""
        return _statistics.SecondOrderModelImplementationPointer_getImplementation(self)

    def unique(self):
        """unique(SecondOrderModelImplementationPointer self) -> OT::Bool"""
        return _statistics.SecondOrderModelImplementationPointer_unique(self)

    def use_count(self):
        """use_count(SecondOrderModelImplementationPointer self) -> OT::UnsignedLong"""
        return _statistics.SecondOrderModelImplementationPointer_use_count(self)

    def swap(self, *args):
        """swap(SecondOrderModelImplementationPointer self, SecondOrderModelImplementationPointer other)"""
        return _statistics.SecondOrderModelImplementationPointer_swap(self, *args)

    def GetClassName(self):
        """GetClassName(SecondOrderModelImplementationPointer self) -> OT::String"""
        return _statistics.SecondOrderModelImplementationPointer_GetClassName(self)

    def getClassName(self):
        """getClassName(SecondOrderModelImplementationPointer self) -> OT::String"""
        return _statistics.SecondOrderModelImplementationPointer_getClassName(self)

    def getDimension(self):
        """getDimension(SecondOrderModelImplementationPointer self) -> OT::UnsignedLong"""
        return _statistics.SecondOrderModelImplementationPointer_getDimension(self)

    def computeCovariance(self, *args):
        """
        computeCovariance(SecondOrderModelImplementationPointer self, OT::NumericalScalar const s, OT::NumericalScalar const t) -> CovarianceMatrix
        computeCovariance(SecondOrderModelImplementationPointer self, OT::NumericalScalar const tau) -> CovarianceMatrix
        """
        return _statistics.SecondOrderModelImplementationPointer_computeCovariance(self, *args)

    def getSpectralModel(self):
        """getSpectralModel(SecondOrderModelImplementationPointer self) -> SpectralModel"""
        return _statistics.SecondOrderModelImplementationPointer_getSpectralModel(self)

    def getCovarianceModel(self):
        """getCovarianceModel(SecondOrderModelImplementationPointer self) -> CovarianceModel"""
        return _statistics.SecondOrderModelImplementationPointer_getCovarianceModel(self)

    def setModels(self, *args):
        """setModels(SecondOrderModelImplementationPointer self, CovarianceModel covarianceModel, SpectralModel spectralModel)"""
        return _statistics.SecondOrderModelImplementationPointer_setModels(self, *args)

    def discretizeCovariance(self, *args):
        """discretizeCovariance(SecondOrderModelImplementationPointer self, RegularGrid timeGrid) -> CovarianceMatrix"""
        return _statistics.SecondOrderModelImplementationPointer_discretizeCovariance(self, *args)

    def computeSpectralDensity(self, *args):
        """computeSpectralDensity(SecondOrderModelImplementationPointer self, OT::NumericalScalar const frequency) -> HermitianMatrix"""
        return _statistics.SecondOrderModelImplementationPointer_computeSpectralDensity(self, *args)

    def __repr__(self):
        """__repr__(SecondOrderModelImplementationPointer self) -> OT::String"""
        return _statistics.SecondOrderModelImplementationPointer___repr__(self)

    def __str__(self, offset=""):
        """
        __str__(SecondOrderModelImplementationPointer self, OT::String const & offset="") -> OT::String
        __str__(SecondOrderModelImplementationPointer self) -> OT::String
        """
        return _statistics.SecondOrderModelImplementationPointer___str__(self, offset)

    def __eq__(self, *args):
        """__eq__(SecondOrderModelImplementationPointer self, PersistentObject other) -> OT::Bool"""
        return _statistics.SecondOrderModelImplementationPointer___eq__(self, *args)

    def Is(self, *args):
        """Is(SecondOrderModelImplementationPointer self, PersistentObject other) -> OT::Bool"""
        return _statistics.SecondOrderModelImplementationPointer_Is(self, *args)

    def getId(self):
        """getId(SecondOrderModelImplementationPointer self) -> OT::Id"""
        return _statistics.SecondOrderModelImplementationPointer_getId(self)

    def setShadowedId(self, *args):
        """setShadowedId(SecondOrderModelImplementationPointer self, OT::Id id)"""
        return _statistics.SecondOrderModelImplementationPointer_setShadowedId(self, *args)

    def getShadowedId(self):
        """getShadowedId(SecondOrderModelImplementationPointer self) -> OT::Id"""
        return _statistics.SecondOrderModelImplementationPointer_getShadowedId(self)

    def setVisibility(self, *args):
        """setVisibility(SecondOrderModelImplementationPointer self, OT::Bool visible)"""
        return _statistics.SecondOrderModelImplementationPointer_setVisibility(self, *args)

    def getVisibility(self):
        """getVisibility(SecondOrderModelImplementationPointer self) -> OT::Bool"""
        return _statistics.SecondOrderModelImplementationPointer_getVisibility(self)

    def hasName(self):
        """hasName(SecondOrderModelImplementationPointer self) -> OT::Bool"""
        return _statistics.SecondOrderModelImplementationPointer_hasName(self)

    def hasVisibleName(self):
        """hasVisibleName(SecondOrderModelImplementationPointer self) -> OT::Bool"""
        return _statistics.SecondOrderModelImplementationPointer_hasVisibleName(self)

    def getName(self):
        """getName(SecondOrderModelImplementationPointer self) -> OT::String"""
        return _statistics.SecondOrderModelImplementationPointer_getName(self)

    def setName(self, *args):
        """setName(SecondOrderModelImplementationPointer self, OT::String const & name)"""
        return _statistics.SecondOrderModelImplementationPointer_setName(self, *args)

SecondOrderModelImplementationPointer_swigregister = _statistics.SecondOrderModelImplementationPointer_swigregister
SecondOrderModelImplementationPointer_swigregister(SecondOrderModelImplementationPointer)

class StationaryCovarianceModelPointer(_object):
    """Proxy of C++ OT::Pointer<(OT::StationaryCovarianceModel)> class"""
    __swig_setmethods__ = {}
    __setattr__ = lambda self, name, value: _swig_setattr(self, StationaryCovarianceModelPointer, name, value)
    __swig_getmethods__ = {}
    __getattr__ = lambda self, name: _swig_getattr(self, StationaryCovarianceModelPointer, name)
    __swig_setmethods__["ptr_"] = _statistics.StationaryCovarianceModelPointer_ptr__set
    __swig_getmethods__["ptr_"] = _statistics.StationaryCovarianceModelPointer_ptr__get
    if _newclass:ptr_ = _swig_property(_statistics.StationaryCovarianceModelPointer_ptr__get, _statistics.StationaryCovarianceModelPointer_ptr__set)
    def __init__(self, *args): 
        """
        __init__(OT::Pointer<(OT::StationaryCovarianceModel)> self) -> StationaryCovarianceModelPointer
        __init__(OT::Pointer<(OT::StationaryCovarianceModel)> self, StationaryCovarianceModel ptr) -> StationaryCovarianceModelPointer
        """
        this = _statistics.new_StationaryCovarianceModelPointer(*args)
        try: self.this.append(this)
        except: self.this = this
    __swig_destroy__ = _statistics.delete_StationaryCovarianceModelPointer
    __del__ = lambda self : None;
    def reset(self):
        """reset(StationaryCovarianceModelPointer self)"""
        return _statistics.StationaryCovarianceModelPointer_reset(self)

    def __ref__(self, *args):
        """
        __ref__(StationaryCovarianceModelPointer self) -> StationaryCovarianceModel
        __ref__(StationaryCovarianceModelPointer self) -> StationaryCovarianceModel
        """
        return _statistics.StationaryCovarianceModelPointer___ref__(self, *args)

    def __deref__(self):
        """__deref__(StationaryCovarianceModelPointer self) -> StationaryCovarianceModel"""
        return _statistics.StationaryCovarianceModelPointer___deref__(self)

    def isNull(self):
        """isNull(StationaryCovarianceModelPointer self) -> OT::Bool"""
        return _statistics.StationaryCovarianceModelPointer_isNull(self)

    def __nonzero__(self):
        return _statistics.StationaryCovarianceModelPointer___nonzero__(self)
    __bool__ = __nonzero__


    def get(self):
        """get(StationaryCovarianceModelPointer self) -> StationaryCovarianceModel"""
        return _statistics.StationaryCovarianceModelPointer_get(self)

    def getImplementation(self):
        """getImplementation(StationaryCovarianceModelPointer self) -> OT::Pointer< OT::StationaryCovarianceModel >::pointer_type const &"""
        return _statistics.StationaryCovarianceModelPointer_getImplementation(self)

    def unique(self):
        """unique(StationaryCovarianceModelPointer self) -> OT::Bool"""
        return _statistics.StationaryCovarianceModelPointer_unique(self)

    def use_count(self):
        """use_count(StationaryCovarianceModelPointer self) -> OT::UnsignedLong"""
        return _statistics.StationaryCovarianceModelPointer_use_count(self)

    def swap(self, *args):
        """swap(StationaryCovarianceModelPointer self, StationaryCovarianceModelPointer other)"""
        return _statistics.StationaryCovarianceModelPointer_swap(self, *args)

    def GetClassName(self):
        """GetClassName(StationaryCovarianceModelPointer self) -> OT::String"""
        return _statistics.StationaryCovarianceModelPointer_GetClassName(self)

    def getClassName(self):
        """getClassName(StationaryCovarianceModelPointer self) -> OT::String"""
        return _statistics.StationaryCovarianceModelPointer_getClassName(self)

    def computeCovariance(self, *args):
        """
        computeCovariance(StationaryCovarianceModelPointer self, OT::NumericalScalar const s, OT::NumericalScalar const t) -> CovarianceMatrix
        computeCovariance(StationaryCovarianceModelPointer self, OT::NumericalScalar const tau) -> CovarianceMatrix
        """
        return _statistics.StationaryCovarianceModelPointer_computeCovariance(self, *args)

    def discretizeCovariance(self, *args):
        """discretizeCovariance(StationaryCovarianceModelPointer self, RegularGrid timeGrid) -> CovarianceMatrix"""
        return _statistics.StationaryCovarianceModelPointer_discretizeCovariance(self, *args)

    def isStationary(self):
        """isStationary(StationaryCovarianceModelPointer self) -> OT::Bool"""
        return _statistics.StationaryCovarianceModelPointer_isStationary(self)

    def __repr__(self):
        """__repr__(StationaryCovarianceModelPointer self) -> OT::String"""
        return _statistics.StationaryCovarianceModelPointer___repr__(self)

    def __str__(self, offset=""):
        """
        __str__(StationaryCovarianceModelPointer self, OT::String const & offset="") -> OT::String
        __str__(StationaryCovarianceModelPointer self) -> OT::String
        """
        return _statistics.StationaryCovarianceModelPointer___str__(self, offset)

    def getDimension(self):
        """getDimension(StationaryCovarianceModelPointer self) -> OT::UnsignedLong"""
        return _statistics.StationaryCovarianceModelPointer_getDimension(self)

    def __eq__(self, *args):
        """__eq__(StationaryCovarianceModelPointer self, PersistentObject other) -> OT::Bool"""
        return _statistics.StationaryCovarianceModelPointer___eq__(self, *args)

    def Is(self, *args):
        """Is(StationaryCovarianceModelPointer self, PersistentObject other) -> OT::Bool"""
        return _statistics.StationaryCovarianceModelPointer_Is(self, *args)

    def getId(self):
        """getId(StationaryCovarianceModelPointer self) -> OT::Id"""
        return _statistics.StationaryCovarianceModelPointer_getId(self)

    def setShadowedId(self, *args):
        """setShadowedId(StationaryCovarianceModelPointer self, OT::Id id)"""
        return _statistics.StationaryCovarianceModelPointer_setShadowedId(self, *args)

    def getShadowedId(self):
        """getShadowedId(StationaryCovarianceModelPointer self) -> OT::Id"""
        return _statistics.StationaryCovarianceModelPointer_getShadowedId(self)

    def setVisibility(self, *args):
        """setVisibility(StationaryCovarianceModelPointer self, OT::Bool visible)"""
        return _statistics.StationaryCovarianceModelPointer_setVisibility(self, *args)

    def getVisibility(self):
        """getVisibility(StationaryCovarianceModelPointer self) -> OT::Bool"""
        return _statistics.StationaryCovarianceModelPointer_getVisibility(self)

    def hasName(self):
        """hasName(StationaryCovarianceModelPointer self) -> OT::Bool"""
        return _statistics.StationaryCovarianceModelPointer_hasName(self)

    def hasVisibleName(self):
        """hasVisibleName(StationaryCovarianceModelPointer self) -> OT::Bool"""
        return _statistics.StationaryCovarianceModelPointer_hasVisibleName(self)

    def getName(self):
        """getName(StationaryCovarianceModelPointer self) -> OT::String"""
        return _statistics.StationaryCovarianceModelPointer_getName(self)

    def setName(self, *args):
        """setName(StationaryCovarianceModelPointer self, OT::String const & name)"""
        return _statistics.StationaryCovarianceModelPointer_setName(self, *args)

StationaryCovarianceModelPointer_swigregister = _statistics.StationaryCovarianceModelPointer_swigregister
StationaryCovarianceModelPointer_swigregister(StationaryCovarianceModelPointer)

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