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


"""
Stochastic process.
"""


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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

GCC_VERSION = _model_process.GCC_VERSION
class TestFailed:
  """
  TestFailed is used to raise an uniform exception in tests
  """
  __type = "TestFailed"
  def __init__(self,reason=""):
    self.reason = reason
  def type(self):
    return TestFailed.__type
  def what(self):
    return self.reason
  def __str__(self):
    return TestFailed.__type + ": " + self.reason
  def __lshift__(self,ch):
    self.reason += ch
    return self

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

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

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

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

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

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

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

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

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

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

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

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

    if _newclass:GetClassName = staticmethod(GetClassName)
    __swig_getmethods__["GetClassName"] = lambda x: GetClassName
    def getClassName(self):
        """getClassName(WhiteNoise self) -> OT::String"""
        return _model_process.WhiteNoise_getClassName(self)

    def __repr__(self):
        """__repr__(WhiteNoise self) -> OT::String"""
        return _model_process.WhiteNoise___repr__(self)

    def __str__(self, offset=""):
        """
        __str__(WhiteNoise self, OT::String const & offset="") -> OT::String
        __str__(WhiteNoise self) -> OT::String
        """
        return _model_process.WhiteNoise___str__(self, offset)

    def isStationary(self):
        """isStationary(WhiteNoise self) -> OT::Bool"""
        return _model_process.WhiteNoise_isStationary(self)

    def isNormal(self):
        """isNormal(WhiteNoise self) -> OT::Bool"""
        return _model_process.WhiteNoise_isNormal(self)

    def getRealization(self):
        """getRealization(WhiteNoise self) -> TimeSeries"""
        return _model_process.WhiteNoise_getRealization(self)

    def getFuture(self, *args):
        """
        getFuture(WhiteNoise self, OT::UnsignedLong const stepNumber) -> TimeSeries
        getFuture(WhiteNoise self, OT::UnsignedLong const stepNumber, OT::UnsignedLong const size) -> ProcessSample
        getFuture(WhiteNoise self, OT::UnsignedLong const stepNumber) -> TimeSeries
        """
        return _model_process.WhiteNoise_getFuture(self, *args)

    def getMarginalProcess(self, *args):
        """
        getMarginalProcess(WhiteNoise self, OT::UnsignedLong const i) -> ProcessImplementationPointer
        getMarginalProcess(WhiteNoise self, Indices indices) -> ProcessImplementationPointer
        """
        return _model_process.WhiteNoise_getMarginalProcess(self, *args)

    def getDistribution(self):
        """getDistribution(WhiteNoise self) -> Distribution"""
        return _model_process.WhiteNoise_getDistribution(self)

    def setDistribution(self, *args):
        """setDistribution(WhiteNoise self, Distribution distribution)"""
        return _model_process.WhiteNoise_setDistribution(self, *args)

    def __init__(self, *args): 
        """
        __init__(OT::WhiteNoise self, OT::String const & name=DefaultName) -> WhiteNoise
        __init__(OT::WhiteNoise self) -> WhiteNoise
        __init__(OT::WhiteNoise self, Distribution distribution, OT::String const & name=DefaultName) -> WhiteNoise
        __init__(OT::WhiteNoise self, Distribution distribution) -> WhiteNoise
        __init__(OT::WhiteNoise self, Distribution distribution, RegularGrid timeGrid, OT::String const & name=DefaultName) -> WhiteNoise
        __init__(OT::WhiteNoise self, Distribution distribution, RegularGrid timeGrid) -> WhiteNoise
        __init__(OT::WhiteNoise self, WhiteNoise other) -> WhiteNoise
        """
        this = _model_process.new_WhiteNoise(*args)
        try: self.this.append(this)
        except: self.this = this
    __swig_destroy__ = _model_process.delete_WhiteNoise
    __del__ = lambda self : None;
WhiteNoise_swigregister = _model_process.WhiteNoise_swigregister
WhiteNoise_swigregister(WhiteNoise)

def WhiteNoise_GetClassName():
  """WhiteNoise_GetClassName() -> OT::String"""
  return _model_process.WhiteNoise_GetClassName()

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

    if _newclass:GetClassName = staticmethod(GetClassName)
    __swig_getmethods__["GetClassName"] = lambda x: GetClassName
    def getClassName(self):
        """getClassName(RandomWalk self) -> OT::String"""
        return _model_process.RandomWalk_getClassName(self)

    def __repr__(self):
        """__repr__(RandomWalk self) -> OT::String"""
        return _model_process.RandomWalk___repr__(self)

    def isStationary(self):
        """isStationary(RandomWalk self) -> OT::Bool"""
        return _model_process.RandomWalk_isStationary(self)

    def isNormal(self):
        """isNormal(RandomWalk self) -> OT::Bool"""
        return _model_process.RandomWalk_isNormal(self)

    def getRealization(self):
        """getRealization(RandomWalk self) -> TimeSeries"""
        return _model_process.RandomWalk_getRealization(self)

    def getFuture(self, *args):
        """
        getFuture(RandomWalk self, OT::UnsignedLong const stepNumber) -> TimeSeries
        getFuture(RandomWalk self, OT::UnsignedLong const stepNumber, OT::UnsignedLong const size) -> ProcessSample
        getFuture(RandomWalk self, OT::UnsignedLong const stepNumber) -> TimeSeries
        """
        return _model_process.RandomWalk_getFuture(self, *args)

    def getMarginalProcess(self, *args):
        """
        getMarginalProcess(RandomWalk self, OT::UnsignedLong const i) -> ProcessImplementationPointer
        getMarginalProcess(RandomWalk self, Indices indices) -> ProcessImplementationPointer
        """
        return _model_process.RandomWalk_getMarginalProcess(self, *args)

    def getDistribution(self):
        """getDistribution(RandomWalk self) -> Distribution"""
        return _model_process.RandomWalk_getDistribution(self)

    def setDistribution(self, *args):
        """setDistribution(RandomWalk self, Distribution distribution)"""
        return _model_process.RandomWalk_setDistribution(self, *args)

    def getOrigin(self):
        """getOrigin(RandomWalk self) -> NumericalPoint"""
        return _model_process.RandomWalk_getOrigin(self)

    def setOrigin(self, *args):
        """setOrigin(RandomWalk self, NumericalPoint origin)"""
        return _model_process.RandomWalk_setOrigin(self, *args)

    def __init__(self, *args): 
        """
        __init__(OT::RandomWalk self, OT::String const & name=DefaultName) -> RandomWalk
        __init__(OT::RandomWalk self) -> RandomWalk
        __init__(OT::RandomWalk self, NumericalPoint origin, Distribution distribution, OT::String const & name=DefaultName) -> RandomWalk
        __init__(OT::RandomWalk self, NumericalPoint origin, Distribution distribution) -> RandomWalk
        __init__(OT::RandomWalk self, NumericalPoint origin, Distribution distribution, RegularGrid timeGrid, OT::String const & name=DefaultName) -> RandomWalk
        __init__(OT::RandomWalk self, NumericalPoint origin, Distribution distribution, RegularGrid timeGrid) -> RandomWalk
        __init__(OT::RandomWalk self, RandomWalk other) -> RandomWalk
        """
        this = _model_process.new_RandomWalk(*args)
        try: self.this.append(this)
        except: self.this = this
    __swig_destroy__ = _model_process.delete_RandomWalk
    __del__ = lambda self : None;
RandomWalk_swigregister = _model_process.RandomWalk_swigregister
RandomWalk_swigregister(RandomWalk)

def RandomWalk_GetClassName():
  """RandomWalk_GetClassName() -> OT::String"""
  return _model_process.RandomWalk_GetClassName()

class SquareMatrixCollection(_object):
    """Proxy of C++ OT::Collection<(OT::SquareMatrix)> class"""
    __swig_setmethods__ = {}
    __setattr__ = lambda self, name, value: _swig_setattr(self, SquareMatrixCollection, name, value)
    __swig_getmethods__ = {}
    __getattr__ = lambda self, name: _swig_getattr(self, SquareMatrixCollection, name)
    __swig_destroy__ = _model_process.delete_SquareMatrixCollection
    __del__ = lambda self : None;
    def clear(self):
        """clear(SquareMatrixCollection self)"""
        return _model_process.SquareMatrixCollection_clear(self)

    def __len__(self):
        """__len__(SquareMatrixCollection self) -> OT::UnsignedLong"""
        return _model_process.SquareMatrixCollection___len__(self)

    def __eq__(self, *args):
        """__eq__(SquareMatrixCollection self, SquareMatrixCollection rhs) -> OT::Bool"""
        return _model_process.SquareMatrixCollection___eq__(self, *args)

    def __contains__(self, *args):
        """__contains__(SquareMatrixCollection self, SquareMatrix val) -> OT::Bool"""
        return _model_process.SquareMatrixCollection___contains__(self, *args)

    def __getitem__(self, *args):
        """__getitem__(SquareMatrixCollection self, OT::UnsignedLong const i) -> SquareMatrix"""
        return _model_process.SquareMatrixCollection___getitem__(self, *args)

    def __setitem__(self, *args):
        """__setitem__(SquareMatrixCollection self, OT::UnsignedLong const i, SquareMatrix val)"""
        return _model_process.SquareMatrixCollection___setitem__(self, *args)

    def __delitem__(self, *args):
        """__delitem__(SquareMatrixCollection self, OT::UnsignedLong const i)"""
        return _model_process.SquareMatrixCollection___delitem__(self, *args)

    def at(self, *args):
        """
        at(SquareMatrixCollection self, OT::UnsignedLong const i) -> SquareMatrix
        at(SquareMatrixCollection self, OT::UnsignedLong const i) -> SquareMatrix
        """
        return _model_process.SquareMatrixCollection_at(self, *args)

    def add(self, *args):
        """
        add(SquareMatrixCollection self, SquareMatrix elt)
        add(SquareMatrixCollection self, SquareMatrixCollection coll)
        """
        return _model_process.SquareMatrixCollection_add(self, *args)

    def getSize(self):
        """getSize(SquareMatrixCollection self) -> OT::UnsignedLong"""
        return _model_process.SquareMatrixCollection_getSize(self)

    def resize(self, *args):
        """resize(SquareMatrixCollection self, OT::UnsignedLong const newSize)"""
        return _model_process.SquareMatrixCollection_resize(self, *args)

    def isEmpty(self):
        """isEmpty(SquareMatrixCollection self) -> OT::Bool"""
        return _model_process.SquareMatrixCollection_isEmpty(self)

    def __repr__(self):
        """__repr__(SquareMatrixCollection self) -> OT::String"""
        return _model_process.SquareMatrixCollection___repr__(self)

    def __str__(self, offset=""):
        """
        __str__(SquareMatrixCollection self, OT::String const & offset="") -> OT::String
        __str__(SquareMatrixCollection self) -> OT::String
        """
        return _model_process.SquareMatrixCollection___str__(self, offset)

    def __init__(self, *args): 
        """
        __init__(OT::Collection<(OT::SquareMatrix)> self) -> SquareMatrixCollection
        __init__(OT::Collection<(OT::SquareMatrix)> self, OT::UnsignedLong const size) -> SquareMatrixCollection
        __init__(OT::Collection<(OT::SquareMatrix)> self, OT::UnsignedLong const size, SquareMatrix value) -> SquareMatrixCollection
        __init__(OT::Collection<(OT::SquareMatrix)> self, PyObject * pyObj) -> SquareMatrixCollection
        __init__(OT::Collection<(OT::SquareMatrix)> self, SquareMatrixCollection other) -> SquareMatrixCollection
        """
        this = _model_process.new_SquareMatrixCollection(*args)
        try: self.this.append(this)
        except: self.this = this
SquareMatrixCollection_swigregister = _model_process.SquareMatrixCollection_swigregister
SquareMatrixCollection_swigregister(SquareMatrixCollection)

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

    if _newclass:GetClassName = staticmethod(GetClassName)
    __swig_getmethods__["GetClassName"] = lambda x: GetClassName
    def getClassName(self):
        """getClassName(SquareMatrixPersistentCollection self) -> OT::String"""
        return _model_process.SquareMatrixPersistentCollection_getClassName(self)

    def __init__(self, *args): 
        """
        __init__(OT::PersistentCollection<(OT::SquareMatrix)> self) -> SquareMatrixPersistentCollection
        __init__(OT::PersistentCollection<(OT::SquareMatrix)> self, SquareMatrixCollection collection) -> SquareMatrixPersistentCollection
        __init__(OT::PersistentCollection<(OT::SquareMatrix)> self, OT::UnsignedLong const size) -> SquareMatrixPersistentCollection
        __init__(OT::PersistentCollection<(OT::SquareMatrix)> self, OT::UnsignedLong const size, SquareMatrix value) -> SquareMatrixPersistentCollection
        """
        this = _model_process.new_SquareMatrixPersistentCollection(*args)
        try: self.this.append(this)
        except: self.this = this
    def __repr__(self):
        """__repr__(SquareMatrixPersistentCollection self) -> OT::String"""
        return _model_process.SquareMatrixPersistentCollection___repr__(self)

    def __str__(self, offset=""):
        """
        __str__(SquareMatrixPersistentCollection self, OT::String const & offset="") -> OT::String
        __str__(SquareMatrixPersistentCollection self) -> OT::String
        """
        return _model_process.SquareMatrixPersistentCollection___str__(self, offset)

    __swig_destroy__ = _model_process.delete_SquareMatrixPersistentCollection
    __del__ = lambda self : None;
SquareMatrixPersistentCollection_swigregister = _model_process.SquareMatrixPersistentCollection_swigregister
SquareMatrixPersistentCollection_swigregister(SquareMatrixPersistentCollection)

def SquareMatrixPersistentCollection_GetClassName():
  """SquareMatrixPersistentCollection_GetClassName() -> OT::String"""
  return _model_process.SquareMatrixPersistentCollection_GetClassName()

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

    if _newclass:GetClassName = staticmethod(GetClassName)
    __swig_getmethods__["GetClassName"] = lambda x: GetClassName
    def getClassName(self):
        """getClassName(ARMACoefficients self) -> OT::String"""
        return _model_process.ARMACoefficients_getClassName(self)

    def __repr__(self):
        """__repr__(ARMACoefficients self) -> OT::String"""
        return _model_process.ARMACoefficients___repr__(self)

    def __str__(self, offset=""):
        """
        __str__(ARMACoefficients self, OT::String const & offset="") -> OT::String
        __str__(ARMACoefficients self) -> OT::String
        """
        return _model_process.ARMACoefficients___str__(self, offset)

    def getDimension(self):
        """getDimension(ARMACoefficients self) -> OT::UnsignedLong"""
        return _model_process.ARMACoefficients_getDimension(self)

    def add(self, *args):
        """add(ARMACoefficients self, SquareMatrix matrix)"""
        return _model_process.ARMACoefficients_add(self, *args)

    def __init__(self, *args): 
        """
        __init__(OT::ARMACoefficients self, OT::UnsignedLong const & size=0, OT::UnsignedLong const & dimension=1) -> ARMACoefficients
        __init__(OT::ARMACoefficients self, OT::UnsignedLong const & size=0) -> ARMACoefficients
        __init__(OT::ARMACoefficients self) -> ARMACoefficients
        __init__(OT::ARMACoefficients self, SquareMatrixCollection collection) -> ARMACoefficients
        __init__(OT::ARMACoefficients self, NumericalPoint ScalarCoefficients) -> ARMACoefficients
        __init__(OT::ARMACoefficients self, UniVariatePolynomial polynomial) -> ARMACoefficients
        __init__(OT::ARMACoefficients self, PyObject * pyObj) -> ARMACoefficients
        __init__(OT::ARMACoefficients self, ARMACoefficients other) -> ARMACoefficients
        """
        this = _model_process.new_ARMACoefficients(*args)
        try: self.this.append(this)
        except: self.this = this
    __swig_destroy__ = _model_process.delete_ARMACoefficients
    __del__ = lambda self : None;
ARMACoefficients_swigregister = _model_process.ARMACoefficients_swigregister
ARMACoefficients_swigregister(ARMACoefficients)

def ARMACoefficients_GetClassName():
  """ARMACoefficients_GetClassName() -> OT::String"""
  return _model_process.ARMACoefficients_GetClassName()

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

    if _newclass:GetClassName = staticmethod(GetClassName)
    __swig_getmethods__["GetClassName"] = lambda x: GetClassName
    def getClassName(self):
        """getClassName(ARMAState self) -> OT::String"""
        return _model_process.ARMAState_getClassName(self)

    def __repr__(self):
        """__repr__(ARMAState self) -> OT::String"""
        return _model_process.ARMAState___repr__(self)

    def __str__(self, offset=""):
        """
        __str__(ARMAState self, OT::String const & offset="") -> OT::String
        __str__(ARMAState self) -> OT::String
        """
        return _model_process.ARMAState___str__(self, offset)

    def getX(self):
        """getX(ARMAState self) -> NumericalSample"""
        return _model_process.ARMAState_getX(self)

    def setXEpsilon(self, *args):
        """setXEpsilon(ARMAState self, NumericalSample x, NumericalSample epsilon)"""
        return _model_process.ARMAState_setXEpsilon(self, *args)

    def getEpsilon(self):
        """getEpsilon(ARMAState self) -> NumericalSample"""
        return _model_process.ARMAState_getEpsilon(self)

    def getDimension(self):
        """getDimension(ARMAState self) -> OT::UnsignedLong"""
        return _model_process.ARMAState_getDimension(self)

    def __init__(self, *args): 
        """
        __init__(OT::ARMAState self) -> ARMAState
        __init__(OT::ARMAState self, NumericalSample x, NumericalSample epsilon) -> ARMAState
        __init__(OT::ARMAState self, ARMAState other) -> ARMAState
        """
        this = _model_process.new_ARMAState(*args)
        try: self.this.append(this)
        except: self.this = this
    __swig_destroy__ = _model_process.delete_ARMAState
    __del__ = lambda self : None;
ARMAState_swigregister = _model_process.ARMAState_swigregister
ARMAState_swigregister(ARMAState)

def ARMAState_GetClassName():
  """ARMAState_GetClassName() -> OT::String"""
  return _model_process.ARMAState_GetClassName()

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

    if _newclass:GetClassName = staticmethod(GetClassName)
    __swig_getmethods__["GetClassName"] = lambda x: GetClassName
    def getClassName(self):
        """getClassName(ARMA self) -> OT::String"""
        return _model_process.ARMA_getClassName(self)

    def __repr__(self):
        """__repr__(ARMA self) -> OT::String"""
        return _model_process.ARMA___repr__(self)

    def __str__(self, offset=""):
        """
        __str__(ARMA self, OT::String const & offset="") -> OT::String
        __str__(ARMA self) -> OT::String
        """
        return _model_process.ARMA___str__(self, offset)

    def isStationary(self):
        """isStationary(ARMA self) -> OT::Bool"""
        return _model_process.ARMA_isStationary(self)

    def isNormal(self):
        """isNormal(ARMA self) -> OT::Bool"""
        return _model_process.ARMA_isNormal(self)

    def getRealization(self):
        """getRealization(ARMA self) -> TimeSeries"""
        return _model_process.ARMA_getRealization(self)

    def getFuture(self, *args):
        """
        getFuture(ARMA self, OT::UnsignedLong const stepNumber) -> TimeSeries
        getFuture(ARMA self, OT::UnsignedLong const stepNumber, OT::UnsignedLong const size) -> ProcessSample
        getFuture(ARMA self, OT::UnsignedLong const stepNumber) -> TimeSeries
        """
        return _model_process.ARMA_getFuture(self, *args)

    def getARCoefficients(self):
        """getARCoefficients(ARMA self) -> ARMACoefficients"""
        return _model_process.ARMA_getARCoefficients(self)

    def getMACoefficients(self):
        """getMACoefficients(ARMA self) -> ARMACoefficients"""
        return _model_process.ARMA_getMACoefficients(self)

    def getState(self):
        """getState(ARMA self) -> ARMAState"""
        return _model_process.ARMA_getState(self)

    def setState(self, *args):
        """setState(ARMA self, ARMAState state)"""
        return _model_process.ARMA_setState(self, *args)

    def getWhiteNoise(self):
        """getWhiteNoise(ARMA self) -> WhiteNoise"""
        return _model_process.ARMA_getWhiteNoise(self)

    def setWhiteNoise(self, *args):
        """setWhiteNoise(ARMA self, WhiteNoise whiteNoise)"""
        return _model_process.ARMA_setWhiteNoise(self, *args)

    def computeNThermalization(self, *args):
        """computeNThermalization(ARMA self, OT::NumericalScalar const epsilon) -> OT::UnsignedLong"""
        return _model_process.ARMA_computeNThermalization(self, *args)

    def getNThermalization(self):
        """getNThermalization(ARMA self) -> OT::UnsignedLong"""
        return _model_process.ARMA_getNThermalization(self)

    def setNThermalization(self, *args):
        """setNThermalization(ARMA self, OT::UnsignedLong const n)"""
        return _model_process.ARMA_setNThermalization(self, *args)

    def getMarginalProcess(self, *args):
        """
        getMarginalProcess(ARMA self, OT::UnsignedLong const i) -> ProcessImplementationPointer
        getMarginalProcess(ARMA self, Indices indices) -> ProcessImplementationPointer
        """
        return _model_process.ARMA_getMarginalProcess(self, *args)

    def __init__(self, *args): 
        """
        __init__(OT::ARMA self, OT::String const & name=DefaultName) -> ARMA
        __init__(OT::ARMA self) -> ARMA
        __init__(OT::ARMA self, ARMACoefficients ARCoefficients, ARMACoefficients MACoefficients, WhiteNoise whiteNoise, 
            OT::String const & name=DefaultName) -> ARMA
        __init__(OT::ARMA self, ARMACoefficients ARCoefficients, ARMACoefficients MACoefficients, WhiteNoise whiteNoise) -> ARMA
        __init__(OT::ARMA self, ARMACoefficients ARCoefficients, ARMACoefficients MACoefficients, WhiteNoise whiteNoise, 
            ARMAState state, OT::String const & name=DefaultName) -> ARMA
        __init__(OT::ARMA self, ARMACoefficients ARCoefficients, ARMACoefficients MACoefficients, WhiteNoise whiteNoise, 
            ARMAState state) -> ARMA
        __init__(OT::ARMA self, ARMA other) -> ARMA
        """
        this = _model_process.new_ARMA(*args)
        try: self.this.append(this)
        except: self.this = this
    __swig_destroy__ = _model_process.delete_ARMA
    __del__ = lambda self : None;
ARMA_swigregister = _model_process.ARMA_swigregister
ARMA_swigregister(ARMA)

def ARMA_GetClassName():
  """ARMA_GetClassName() -> OT::String"""
  return _model_process.ARMA_GetClassName()

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

    if _newclass:GetClassName = staticmethod(GetClassName)
    __swig_getmethods__["GetClassName"] = lambda x: GetClassName
    def getClassName(self):
        """getClassName(SpectralNormalProcess self) -> OT::String"""
        return _model_process.SpectralNormalProcess_getClassName(self)

    def __repr__(self):
        """__repr__(SpectralNormalProcess self) -> OT::String"""
        return _model_process.SpectralNormalProcess___repr__(self)

    def __str__(self, offset=""):
        """
        __str__(SpectralNormalProcess self, OT::String const & offset="") -> OT::String
        __str__(SpectralNormalProcess self) -> OT::String
        """
        return _model_process.SpectralNormalProcess___str__(self, offset)

    def getRealization(self):
        """getRealization(SpectralNormalProcess self) -> TimeSeries"""
        return _model_process.SpectralNormalProcess_getRealization(self)

    def getFrequencyGrid(self):
        """getFrequencyGrid(SpectralNormalProcess self) -> RegularGrid"""
        return _model_process.SpectralNormalProcess_getFrequencyGrid(self)

    def getMaximalFrequency(self):
        """getMaximalFrequency(SpectralNormalProcess self) -> OT::NumericalScalar"""
        return _model_process.SpectralNormalProcess_getMaximalFrequency(self)

    def getNFrequency(self):
        """getNFrequency(SpectralNormalProcess self) -> OT::UnsignedLong"""
        return _model_process.SpectralNormalProcess_getNFrequency(self)

    def getFrequencyStep(self):
        """getFrequencyStep(SpectralNormalProcess self) -> OT::NumericalScalar"""
        return _model_process.SpectralNormalProcess_getFrequencyStep(self)

    def getSpectralModel(self):
        """getSpectralModel(SpectralNormalProcess self) -> SpectralModel"""
        return _model_process.SpectralNormalProcess_getSpectralModel(self)

    def setTimeGrid(self, *args):
        """setTimeGrid(SpectralNormalProcess self, RegularGrid timeGrid)"""
        return _model_process.SpectralNormalProcess_setTimeGrid(self, *args)

    def getFFTAlgorithm(self):
        """getFFTAlgorithm(SpectralNormalProcess self) -> FFT"""
        return _model_process.SpectralNormalProcess_getFFTAlgorithm(self)

    def setFFTAlgorithm(self, *args):
        """setFFTAlgorithm(SpectralNormalProcess self, FFT fft)"""
        return _model_process.SpectralNormalProcess_setFFTAlgorithm(self, *args)

    def isStationary(self):
        """isStationary(SpectralNormalProcess self) -> OT::Bool"""
        return _model_process.SpectralNormalProcess_isStationary(self)

    def isNormal(self):
        """isNormal(SpectralNormalProcess self) -> OT::Bool"""
        return _model_process.SpectralNormalProcess_isNormal(self)

    def AdaptGrid(*args):
        """AdaptGrid(RegularGrid grid) -> RegularGrid"""
        return _model_process.SpectralNormalProcess_AdaptGrid(*args)

    if _newclass:AdaptGrid = staticmethod(AdaptGrid)
    __swig_getmethods__["AdaptGrid"] = lambda x: AdaptGrid
    def __init__(self, *args): 
        """
        __init__(OT::SpectralNormalProcess self, OT::String const & name=DefaultName) -> SpectralNormalProcess
        __init__(OT::SpectralNormalProcess self) -> SpectralNormalProcess
        __init__(OT::SpectralNormalProcess self, SecondOrderModel model, RegularGrid grid, OT::String const & name=DefaultName) -> SpectralNormalProcess
        __init__(OT::SpectralNormalProcess self, SecondOrderModel model, RegularGrid grid) -> SpectralNormalProcess
        __init__(OT::SpectralNormalProcess self, SpectralModel spectralModel, RegularGrid grid, OT::String const & name=DefaultName) -> SpectralNormalProcess
        __init__(OT::SpectralNormalProcess self, SpectralModel spectralModel, RegularGrid grid) -> SpectralNormalProcess
        __init__(OT::SpectralNormalProcess self, SecondOrderModel model, OT::NumericalScalar const maximalFrequency, OT::UnsignedLong const nFrequency, 
            OT::String const & name=DefaultName) -> SpectralNormalProcess
        __init__(OT::SpectralNormalProcess self, SecondOrderModel model, OT::NumericalScalar const maximalFrequency, OT::UnsignedLong const nFrequency) -> SpectralNormalProcess
        __init__(OT::SpectralNormalProcess self, SpectralModel spectralModel, OT::NumericalScalar const maximalFrequency, OT::UnsignedLong const nFrequency, 
            OT::String const & name=DefaultName) -> SpectralNormalProcess
        __init__(OT::SpectralNormalProcess self, SpectralModel spectralModel, OT::NumericalScalar const maximalFrequency, OT::UnsignedLong const nFrequency) -> SpectralNormalProcess
        __init__(OT::SpectralNormalProcess self, SpectralNormalProcess other) -> SpectralNormalProcess
        """
        this = _model_process.new_SpectralNormalProcess(*args)
        try: self.this.append(this)
        except: self.this = this
    __swig_destroy__ = _model_process.delete_SpectralNormalProcess
    __del__ = lambda self : None;
SpectralNormalProcess_swigregister = _model_process.SpectralNormalProcess_swigregister
SpectralNormalProcess_swigregister(SpectralNormalProcess)

def SpectralNormalProcess_GetClassName():
  """SpectralNormalProcess_GetClassName() -> OT::String"""
  return _model_process.SpectralNormalProcess_GetClassName()

def SpectralNormalProcess_AdaptGrid(*args):
  """SpectralNormalProcess_AdaptGrid(RegularGrid grid) -> RegularGrid"""
  return _model_process.SpectralNormalProcess_AdaptGrid(*args)

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

    if _newclass:GetClassName = staticmethod(GetClassName)
    __swig_getmethods__["GetClassName"] = lambda x: GetClassName
    def getClassName(self):
        """getClassName(TemporalNormalProcess self) -> OT::String"""
        return _model_process.TemporalNormalProcess_getClassName(self)

    def __repr__(self):
        """__repr__(TemporalNormalProcess self) -> OT::String"""
        return _model_process.TemporalNormalProcess___repr__(self)

    def __str__(self, offset=""):
        """
        __str__(TemporalNormalProcess self, OT::String const & offset="") -> OT::String
        __str__(TemporalNormalProcess self) -> OT::String
        """
        return _model_process.TemporalNormalProcess___str__(self, offset)

    def setTimeGrid(self, *args):
        """setTimeGrid(TemporalNormalProcess self, RegularGrid timeGrid)"""
        return _model_process.TemporalNormalProcess_setTimeGrid(self, *args)

    def getRealization(self):
        """getRealization(TemporalNormalProcess self) -> TimeSeries"""
        return _model_process.TemporalNormalProcess_getRealization(self)

    def getCovarianceModel(self):
        """getCovarianceModel(TemporalNormalProcess self) -> CovarianceModel"""
        return _model_process.TemporalNormalProcess_getCovarianceModel(self)

    def getTrend(self):
        """getTrend(TemporalNormalProcess self) -> TrendTransform"""
        return _model_process.TemporalNormalProcess_getTrend(self)

    def isStationary(self):
        """isStationary(TemporalNormalProcess self) -> OT::Bool"""
        return _model_process.TemporalNormalProcess_isStationary(self)

    def isTrendStationary(self):
        """isTrendStationary(TemporalNormalProcess self) -> OT::Bool"""
        return _model_process.TemporalNormalProcess_isTrendStationary(self)

    def isNormal(self):
        """isNormal(TemporalNormalProcess self) -> OT::Bool"""
        return _model_process.TemporalNormalProcess_isNormal(self)

    def __init__(self, *args): 
        """
        __init__(OT::TemporalNormalProcess self, OT::String const & name=DefaultName) -> TemporalNormalProcess
        __init__(OT::TemporalNormalProcess self) -> TemporalNormalProcess
        __init__(OT::TemporalNormalProcess self, TrendTransform trend, SecondOrderModel model, RegularGrid timeGrid, OT::String const & name=DefaultName) -> TemporalNormalProcess
        __init__(OT::TemporalNormalProcess self, TrendTransform trend, SecondOrderModel model, RegularGrid timeGrid) -> TemporalNormalProcess
        __init__(OT::TemporalNormalProcess self, TrendTransform trend, CovarianceModel covarianceModel, RegularGrid timeGrid, OT::String const & name=DefaultName) -> TemporalNormalProcess
        __init__(OT::TemporalNormalProcess self, TrendTransform trend, CovarianceModel covarianceModel, RegularGrid timeGrid) -> TemporalNormalProcess
        __init__(OT::TemporalNormalProcess self, SecondOrderModel model, RegularGrid timeGrid, OT::String const & name=DefaultName) -> TemporalNormalProcess
        __init__(OT::TemporalNormalProcess self, SecondOrderModel model, RegularGrid timeGrid) -> TemporalNormalProcess
        __init__(OT::TemporalNormalProcess self, CovarianceModel covarianceModel, RegularGrid timeGrid, OT::String const & name=DefaultName) -> TemporalNormalProcess
        __init__(OT::TemporalNormalProcess self, CovarianceModel covarianceModel, RegularGrid timeGrid) -> TemporalNormalProcess
        __init__(OT::TemporalNormalProcess self, TemporalNormalProcess other) -> TemporalNormalProcess
        """
        this = _model_process.new_TemporalNormalProcess(*args)
        try: self.this.append(this)
        except: self.this = this
    __swig_destroy__ = _model_process.delete_TemporalNormalProcess
    __del__ = lambda self : None;
TemporalNormalProcess_swigregister = _model_process.TemporalNormalProcess_swigregister
TemporalNormalProcess_swigregister(TemporalNormalProcess)

def TemporalNormalProcess_GetClassName():
  """TemporalNormalProcess_GetClassName() -> OT::String"""
  return _model_process.TemporalNormalProcess_GetClassName()

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

    if _newclass:GetClassName = staticmethod(GetClassName)
    __swig_getmethods__["GetClassName"] = lambda x: GetClassName
    def getClassName(self):
        """getClassName(CompositeProcess self) -> OT::String"""
        return _model_process.CompositeProcess_getClassName(self)

    def __repr__(self):
        """__repr__(CompositeProcess self) -> OT::String"""
        return _model_process.CompositeProcess___repr__(self)

    def __str__(self, offset=""):
        """
        __str__(CompositeProcess self, OT::String const & offset="") -> OT::String
        __str__(CompositeProcess self) -> OT::String
        """
        return _model_process.CompositeProcess___str__(self, offset)

    def isComposite(self):
        """isComposite(CompositeProcess self) -> OT::Bool"""
        return _model_process.CompositeProcess_isComposite(self)

    def getRealization(self):
        """getRealization(CompositeProcess self) -> TimeSeries"""
        return _model_process.CompositeProcess_getRealization(self)

    def getAntecedent(self):
        """getAntecedent(CompositeProcess self) -> ProcessImplementationPointer"""
        return _model_process.CompositeProcess_getAntecedent(self)

    def getFunction(self):
        """getFunction(CompositeProcess self) -> DynamicalFunction"""
        return _model_process.CompositeProcess_getFunction(self)

    def getMarginalProcess(self, *args):
        """
        getMarginalProcess(CompositeProcess self, OT::UnsignedLong const i) -> ProcessImplementationPointer
        getMarginalProcess(CompositeProcess self, Indices indices) -> ProcessImplementationPointer
        """
        return _model_process.CompositeProcess_getMarginalProcess(self, *args)

    def __init__(self, *args): 
        """
        __init__(OT::CompositeProcess self, OT::String const & name=DefaultName) -> CompositeProcess
        __init__(OT::CompositeProcess self) -> CompositeProcess
        __init__(OT::CompositeProcess self, DynamicalFunction function, ProcessImplementationPointer p_antecedent, OT::String const & name=DefaultName) -> CompositeProcess
        __init__(OT::CompositeProcess self, DynamicalFunction function, ProcessImplementationPointer p_antecedent) -> CompositeProcess
        __init__(OT::CompositeProcess self, DynamicalFunction function, Process antecedent, OT::String const & name=DefaultName) -> CompositeProcess
        __init__(OT::CompositeProcess self, DynamicalFunction function, Process antecedent) -> CompositeProcess
        __init__(OT::CompositeProcess self, CompositeProcess other) -> CompositeProcess
        """
        this = _model_process.new_CompositeProcess(*args)
        try: self.this.append(this)
        except: self.this = this
    __swig_destroy__ = _model_process.delete_CompositeProcess
    __del__ = lambda self : None;
CompositeProcess_swigregister = _model_process.CompositeProcess_swigregister
CompositeProcess_swigregister(CompositeProcess)

def CompositeProcess_GetClassName():
  """CompositeProcess_GetClassName() -> OT::String"""
  return _model_process.CompositeProcess_GetClassName()

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

    if _newclass:GetClassName = staticmethod(GetClassName)
    __swig_getmethods__["GetClassName"] = lambda x: GetClassName
    def getClassName(self):
        """getClassName(FunctionalBasisProcess self) -> OT::String"""
        return _model_process.FunctionalBasisProcess_getClassName(self)

    def __repr__(self):
        """__repr__(FunctionalBasisProcess self) -> OT::String"""
        return _model_process.FunctionalBasisProcess___repr__(self)

    def isStationary(self):
        """isStationary(FunctionalBasisProcess self) -> OT::Bool"""
        return _model_process.FunctionalBasisProcess_isStationary(self)

    def isNormal(self):
        """isNormal(FunctionalBasisProcess self) -> OT::Bool"""
        return _model_process.FunctionalBasisProcess_isNormal(self)

    def getRealization(self):
        """getRealization(FunctionalBasisProcess self) -> TimeSeries"""
        return _model_process.FunctionalBasisProcess_getRealization(self)

    def getContinuousRealization(self):
        """getContinuousRealization(FunctionalBasisProcess self) -> NumericalMathFunction"""
        return _model_process.FunctionalBasisProcess_getContinuousRealization(self)

    def getFuture(self, *args):
        """
        getFuture(FunctionalBasisProcess self, OT::UnsignedLong const stepNumber) -> TimeSeries
        getFuture(FunctionalBasisProcess self, OT::UnsignedLong const stepNumber, OT::UnsignedLong const size) -> ProcessSample
        getFuture(FunctionalBasisProcess self, OT::UnsignedLong const stepNumber) -> TimeSeries
        """
        return _model_process.FunctionalBasisProcess_getFuture(self, *args)

    def getMarginalProcess(self, *args):
        """
        getMarginalProcess(FunctionalBasisProcess self, OT::UnsignedLong const i) -> ProcessImplementationPointer
        getMarginalProcess(FunctionalBasisProcess self, Indices indices) -> ProcessImplementationPointer
        """
        return _model_process.FunctionalBasisProcess_getMarginalProcess(self, *args)

    def getDistribution(self):
        """getDistribution(FunctionalBasisProcess self) -> Distribution"""
        return _model_process.FunctionalBasisProcess_getDistribution(self)

    def setDistribution(self, *args):
        """setDistribution(FunctionalBasisProcess self, Distribution distribution)"""
        return _model_process.FunctionalBasisProcess_setDistribution(self, *args)

    def getBasis(self):
        """getBasis(FunctionalBasisProcess self) -> Basis"""
        return _model_process.FunctionalBasisProcess_getBasis(self)

    def setBasis(self, *args):
        """setBasis(FunctionalBasisProcess self, Basis basis)"""
        return _model_process.FunctionalBasisProcess_setBasis(self, *args)

    def __init__(self, *args): 
        """
        __init__(OT::FunctionalBasisProcess self, OT::String const & name=DefaultName) -> FunctionalBasisProcess
        __init__(OT::FunctionalBasisProcess self) -> FunctionalBasisProcess
        __init__(OT::FunctionalBasisProcess self, Distribution distribution, Basis basis, OT::String const & name=DefaultName) -> FunctionalBasisProcess
        __init__(OT::FunctionalBasisProcess self, Distribution distribution, Basis basis) -> FunctionalBasisProcess
        __init__(OT::FunctionalBasisProcess self, Distribution distribution, Basis basis, RegularGrid timeGrid, OT::String const & name=DefaultName) -> FunctionalBasisProcess
        __init__(OT::FunctionalBasisProcess self, Distribution distribution, Basis basis, RegularGrid timeGrid) -> FunctionalBasisProcess
        __init__(OT::FunctionalBasisProcess self, FunctionalBasisProcess other) -> FunctionalBasisProcess
        """
        this = _model_process.new_FunctionalBasisProcess(*args)
        try: self.this.append(this)
        except: self.this = this
    __swig_destroy__ = _model_process.delete_FunctionalBasisProcess
    __del__ = lambda self : None;
FunctionalBasisProcess_swigregister = _model_process.FunctionalBasisProcess_swigregister
FunctionalBasisProcess_swigregister(FunctionalBasisProcess)

def FunctionalBasisProcess_GetClassName():
  """FunctionalBasisProcess_GetClassName() -> OT::String"""
  return _model_process.FunctionalBasisProcess_GetClassName()

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

    if _newclass:GetClassName = staticmethod(GetClassName)
    __swig_getmethods__["GetClassName"] = lambda x: GetClassName
    def getClassName(self):
        """getClassName(ARMAFactoryImplementation self) -> OT::String"""
        return _model_process.ARMAFactoryImplementation_getClassName(self)

    def __repr__(self):
        """__repr__(ARMAFactoryImplementation self) -> OT::String"""
        return _model_process.ARMAFactoryImplementation___repr__(self)

    def __str__(self, offset=""):
        """
        __str__(ARMAFactoryImplementation self, OT::String const & offset="") -> OT::String
        __str__(ARMAFactoryImplementation self) -> OT::String
        """
        return _model_process.ARMAFactoryImplementation___str__(self, offset)

    def getP(self):
        """getP(ARMAFactoryImplementation self) -> Indices"""
        return _model_process.ARMAFactoryImplementation_getP(self)

    def getCurrentP(self):
        """getCurrentP(ARMAFactoryImplementation self) -> OT::UnsignedLong"""
        return _model_process.ARMAFactoryImplementation_getCurrentP(self)

    def getQ(self):
        """getQ(ARMAFactoryImplementation self) -> Indices"""
        return _model_process.ARMAFactoryImplementation_getQ(self)

    def getCurrentQ(self):
        """getCurrentQ(ARMAFactoryImplementation self) -> OT::UnsignedLong"""
        return _model_process.ARMAFactoryImplementation_getCurrentQ(self)

    def getInvertible(self):
        """getInvertible(ARMAFactoryImplementation self) -> OT::Bool"""
        return _model_process.ARMAFactoryImplementation_getInvertible(self)

    def setInvertible(self, *args):
        """setInvertible(ARMAFactoryImplementation self, OT::Bool const invertible)"""
        return _model_process.ARMAFactoryImplementation_setInvertible(self, *args)

    def build(self, *args):
        """
        build(ARMAFactoryImplementation self, TimeSeries timeSeries) -> ARMA
        build(ARMAFactoryImplementation self, TimeSeries timeSeries, NumericalPoint informationCriteria) -> ARMA
        build(ARMAFactoryImplementation self, ProcessSample sample) -> ARMA
        build(ARMAFactoryImplementation self, ProcessSample sample, NumericalPoint informationCriteria) -> ARMA
        """
        return _model_process.ARMAFactoryImplementation_build(self, *args)

    def __init__(self, *args): 
        """
        __init__(OT::ARMAFactoryImplementation self, OT::String const & name=DefaultName) -> ARMAFactoryImplementation
        __init__(OT::ARMAFactoryImplementation self) -> ARMAFactoryImplementation
        __init__(OT::ARMAFactoryImplementation self, OT::UnsignedLong const p, OT::UnsignedLong const q, OT::Bool const invertible=True, 
            OT::String const & name=DefaultName) -> ARMAFactoryImplementation
        __init__(OT::ARMAFactoryImplementation self, OT::UnsignedLong const p, OT::UnsignedLong const q, OT::Bool const invertible=True) -> ARMAFactoryImplementation
        __init__(OT::ARMAFactoryImplementation self, OT::UnsignedLong const p, OT::UnsignedLong const q) -> ARMAFactoryImplementation
        __init__(OT::ARMAFactoryImplementation self, Indices p, Indices q, OT::Bool const invertible=True, OT::String const & name=DefaultName) -> ARMAFactoryImplementation
        __init__(OT::ARMAFactoryImplementation self, Indices p, Indices q, OT::Bool const invertible=True) -> ARMAFactoryImplementation
        __init__(OT::ARMAFactoryImplementation self, Indices p, Indices q) -> ARMAFactoryImplementation
        __init__(OT::ARMAFactoryImplementation self, ARMAFactoryImplementation other) -> ARMAFactoryImplementation
        """
        this = _model_process.new_ARMAFactoryImplementation(*args)
        try: self.this.append(this)
        except: self.this = this
    __swig_destroy__ = _model_process.delete_ARMAFactoryImplementation
    __del__ = lambda self : None;
ARMAFactoryImplementation_swigregister = _model_process.ARMAFactoryImplementation_swigregister
ARMAFactoryImplementation_swigregister(ARMAFactoryImplementation)

def ARMAFactoryImplementation_GetClassName():
  """ARMAFactoryImplementation_GetClassName() -> OT::String"""
  return _model_process.ARMAFactoryImplementation_GetClassName()

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

    if _newclass:GetClassName = staticmethod(GetClassName)
    __swig_getmethods__["GetClassName"] = lambda x: GetClassName
    def getClassName(self):
        """getClassName(WhittleFactoryState self) -> OT::String"""
        return _model_process.WhittleFactoryState_getClassName(self)

    def __repr__(self):
        """__repr__(WhittleFactoryState self) -> OT::String"""
        return _model_process.WhittleFactoryState___repr__(self)

    def __str__(self, offset=""):
        """
        __str__(WhittleFactoryState self, OT::String const & offset="") -> OT::String
        __str__(WhittleFactoryState self) -> OT::String
        """
        return _model_process.WhittleFactoryState___str__(self, offset)

    def getP(self):
        """getP(WhittleFactoryState self) -> OT::UnsignedLong"""
        return _model_process.WhittleFactoryState_getP(self)

    def getQ(self):
        """getQ(WhittleFactoryState self) -> OT::UnsignedLong"""
        return _model_process.WhittleFactoryState_getQ(self)

    def getTheta(self):
        """getTheta(WhittleFactoryState self) -> NumericalPoint"""
        return _model_process.WhittleFactoryState_getTheta(self)

    def getSigma2(self):
        """getSigma2(WhittleFactoryState self) -> OT::NumericalScalar"""
        return _model_process.WhittleFactoryState_getSigma2(self)

    def getARCoefficients(self):
        """getARCoefficients(WhittleFactoryState self) -> ARMACoefficients"""
        return _model_process.WhittleFactoryState_getARCoefficients(self)

    def getMACoefficients(self):
        """getMACoefficients(WhittleFactoryState self) -> ARMACoefficients"""
        return _model_process.WhittleFactoryState_getMACoefficients(self)

    def getWhiteNoise(self):
        """getWhiteNoise(WhittleFactoryState self) -> WhiteNoise"""
        return _model_process.WhittleFactoryState_getWhiteNoise(self)

    def getARMA(self):
        """getARMA(WhittleFactoryState self) -> ARMA"""
        return _model_process.WhittleFactoryState_getARMA(self)

    def getInformationCriteria(self):
        """getInformationCriteria(WhittleFactoryState self) -> NumericalPoint"""
        return _model_process.WhittleFactoryState_getInformationCriteria(self)

    def getTimeGrid(self):
        """getTimeGrid(WhittleFactoryState self) -> RegularGrid"""
        return _model_process.WhittleFactoryState_getTimeGrid(self)

    def __init__(self, *args): 
        """
        __init__(OT::WhittleFactoryState self, OT::String const & name=DefaultName) -> WhittleFactoryState
        __init__(OT::WhittleFactoryState self) -> WhittleFactoryState
        __init__(OT::WhittleFactoryState self, OT::UnsignedLong const p, NumericalPoint theta, OT::NumericalScalar const sigma2, 
            NumericalPoint informationCriteria, RegularGrid timeGrid, OT::String const & name=DefaultName) -> WhittleFactoryState
        __init__(OT::WhittleFactoryState self, OT::UnsignedLong const p, NumericalPoint theta, OT::NumericalScalar const sigma2, 
            NumericalPoint informationCriteria, RegularGrid timeGrid) -> WhittleFactoryState
        __init__(OT::WhittleFactoryState self, WhittleFactoryState other) -> WhittleFactoryState
        """
        this = _model_process.new_WhittleFactoryState(*args)
        try: self.this.append(this)
        except: self.this = this
    __swig_destroy__ = _model_process.delete_WhittleFactoryState
    __del__ = lambda self : None;
WhittleFactoryState_swigregister = _model_process.WhittleFactoryState_swigregister
WhittleFactoryState_swigregister(WhittleFactoryState)

def WhittleFactoryState_GetClassName():
  """WhittleFactoryState_GetClassName() -> OT::String"""
  return _model_process.WhittleFactoryState_GetClassName()

class WhittleFactoryStateCollection(_object):
    """Proxy of C++ OT::Collection<(OT::WhittleFactoryState)> class"""
    __swig_setmethods__ = {}
    __setattr__ = lambda self, name, value: _swig_setattr(self, WhittleFactoryStateCollection, name, value)
    __swig_getmethods__ = {}
    __getattr__ = lambda self, name: _swig_getattr(self, WhittleFactoryStateCollection, name)
    __swig_destroy__ = _model_process.delete_WhittleFactoryStateCollection
    __del__ = lambda self : None;
    def clear(self):
        """clear(WhittleFactoryStateCollection self)"""
        return _model_process.WhittleFactoryStateCollection_clear(self)

    def __len__(self):
        """__len__(WhittleFactoryStateCollection self) -> OT::UnsignedLong"""
        return _model_process.WhittleFactoryStateCollection___len__(self)

    def __eq__(self, *args):
        """__eq__(WhittleFactoryStateCollection self, WhittleFactoryStateCollection rhs) -> OT::Bool"""
        return _model_process.WhittleFactoryStateCollection___eq__(self, *args)

    def __contains__(self, *args):
        """__contains__(WhittleFactoryStateCollection self, WhittleFactoryState val) -> OT::Bool"""
        return _model_process.WhittleFactoryStateCollection___contains__(self, *args)

    def __getitem__(self, *args):
        """__getitem__(WhittleFactoryStateCollection self, OT::UnsignedLong const i) -> WhittleFactoryState"""
        return _model_process.WhittleFactoryStateCollection___getitem__(self, *args)

    def __setitem__(self, *args):
        """__setitem__(WhittleFactoryStateCollection self, OT::UnsignedLong const i, WhittleFactoryState val)"""
        return _model_process.WhittleFactoryStateCollection___setitem__(self, *args)

    def __delitem__(self, *args):
        """__delitem__(WhittleFactoryStateCollection self, OT::UnsignedLong const i)"""
        return _model_process.WhittleFactoryStateCollection___delitem__(self, *args)

    def at(self, *args):
        """
        at(WhittleFactoryStateCollection self, OT::UnsignedLong const i) -> WhittleFactoryState
        at(WhittleFactoryStateCollection self, OT::UnsignedLong const i) -> WhittleFactoryState
        """
        return _model_process.WhittleFactoryStateCollection_at(self, *args)

    def add(self, *args):
        """
        add(WhittleFactoryStateCollection self, WhittleFactoryState elt)
        add(WhittleFactoryStateCollection self, WhittleFactoryStateCollection coll)
        """
        return _model_process.WhittleFactoryStateCollection_add(self, *args)

    def getSize(self):
        """getSize(WhittleFactoryStateCollection self) -> OT::UnsignedLong"""
        return _model_process.WhittleFactoryStateCollection_getSize(self)

    def resize(self, *args):
        """resize(WhittleFactoryStateCollection self, OT::UnsignedLong const newSize)"""
        return _model_process.WhittleFactoryStateCollection_resize(self, *args)

    def isEmpty(self):
        """isEmpty(WhittleFactoryStateCollection self) -> OT::Bool"""
        return _model_process.WhittleFactoryStateCollection_isEmpty(self)

    def __repr__(self):
        """__repr__(WhittleFactoryStateCollection self) -> OT::String"""
        return _model_process.WhittleFactoryStateCollection___repr__(self)

    def __str__(self, offset=""):
        """
        __str__(WhittleFactoryStateCollection self, OT::String const & offset="") -> OT::String
        __str__(WhittleFactoryStateCollection self) -> OT::String
        """
        return _model_process.WhittleFactoryStateCollection___str__(self, offset)

    def __init__(self, *args): 
        """
        __init__(OT::Collection<(OT::WhittleFactoryState)> self) -> WhittleFactoryStateCollection
        __init__(OT::Collection<(OT::WhittleFactoryState)> self, OT::UnsignedLong const size) -> WhittleFactoryStateCollection
        __init__(OT::Collection<(OT::WhittleFactoryState)> self, OT::UnsignedLong const size, WhittleFactoryState value) -> WhittleFactoryStateCollection
        __init__(OT::Collection<(OT::WhittleFactoryState)> self, PyObject * pyObj) -> WhittleFactoryStateCollection
        __init__(OT::Collection<(OT::WhittleFactoryState)> self, WhittleFactoryStateCollection other) -> WhittleFactoryStateCollection
        """
        this = _model_process.new_WhittleFactoryStateCollection(*args)
        try: self.this.append(this)
        except: self.this = this
WhittleFactoryStateCollection_swigregister = _model_process.WhittleFactoryStateCollection_swigregister
WhittleFactoryStateCollection_swigregister(WhittleFactoryStateCollection)

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

    if _newclass:GetClassName = staticmethod(GetClassName)
    __swig_getmethods__["GetClassName"] = lambda x: GetClassName
    def getClassName(self):
        """getClassName(WhittleFactoryStatePersistentCollection self) -> OT::String"""
        return _model_process.WhittleFactoryStatePersistentCollection_getClassName(self)

    def __init__(self, *args): 
        """
        __init__(OT::PersistentCollection<(OT::WhittleFactoryState)> self) -> WhittleFactoryStatePersistentCollection
        __init__(OT::PersistentCollection<(OT::WhittleFactoryState)> self, WhittleFactoryStateCollection collection) -> WhittleFactoryStatePersistentCollection
        __init__(OT::PersistentCollection<(OT::WhittleFactoryState)> self, OT::UnsignedLong const size) -> WhittleFactoryStatePersistentCollection
        __init__(OT::PersistentCollection<(OT::WhittleFactoryState)> self, OT::UnsignedLong const size, WhittleFactoryState value) -> WhittleFactoryStatePersistentCollection
        """
        this = _model_process.new_WhittleFactoryStatePersistentCollection(*args)
        try: self.this.append(this)
        except: self.this = this
    def __repr__(self):
        """__repr__(WhittleFactoryStatePersistentCollection self) -> OT::String"""
        return _model_process.WhittleFactoryStatePersistentCollection___repr__(self)

    def __str__(self, offset=""):
        """
        __str__(WhittleFactoryStatePersistentCollection self, OT::String const & offset="") -> OT::String
        __str__(WhittleFactoryStatePersistentCollection self) -> OT::String
        """
        return _model_process.WhittleFactoryStatePersistentCollection___str__(self, offset)

    __swig_destroy__ = _model_process.delete_WhittleFactoryStatePersistentCollection
    __del__ = lambda self : None;
WhittleFactoryStatePersistentCollection_swigregister = _model_process.WhittleFactoryStatePersistentCollection_swigregister
WhittleFactoryStatePersistentCollection_swigregister(WhittleFactoryStatePersistentCollection)

def WhittleFactoryStatePersistentCollection_GetClassName():
  """WhittleFactoryStatePersistentCollection_GetClassName() -> OT::String"""
  return _model_process.WhittleFactoryStatePersistentCollection_GetClassName()

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

    if _newclass:GetClassName = staticmethod(GetClassName)
    __swig_getmethods__["GetClassName"] = lambda x: GetClassName
    def getClassName(self):
        """getClassName(WhittleFactory self) -> OT::String"""
        return _model_process.WhittleFactory_getClassName(self)

    def __repr__(self):
        """__repr__(WhittleFactory self) -> OT::String"""
        return _model_process.WhittleFactory___repr__(self)

    def __str__(self, offset=""):
        """
        __str__(WhittleFactory self, OT::String const & offset="") -> OT::String
        __str__(WhittleFactory self) -> OT::String
        """
        return _model_process.WhittleFactory___str__(self, offset)

    def getSpectralModelFactory(self):
        """getSpectralModelFactory(WhittleFactory self) -> SpectralModelFactory"""
        return _model_process.WhittleFactory_getSpectralModelFactory(self)

    def setSpectralModelFactory(self, *args):
        """setSpectralModelFactory(WhittleFactory self, SpectralModelFactory factory)"""
        return _model_process.WhittleFactory_setSpectralModelFactory(self, *args)

    def build(self, *args):
        """
        build(WhittleFactory self, TimeSeries timeSeries, NumericalPoint informationCriteria) -> ARMA
        build(WhittleFactory self, TimeSeries timeSeries) -> ARMA
        build(WhittleFactory self, ProcessSample sample, NumericalPoint informationCriteria) -> ARMA
        build(WhittleFactory self, ProcessSample sample) -> ARMA
        """
        return _model_process.WhittleFactory_build(self, *args)

    def getVerbose(self):
        """getVerbose(WhittleFactory self) -> OT::Bool"""
        return _model_process.WhittleFactory_getVerbose(self)

    def setVerbose(self, *args):
        """setVerbose(WhittleFactory self, OT::Bool const verbose)"""
        return _model_process.WhittleFactory_setVerbose(self, *args)

    def enableHistory(self):
        """enableHistory(WhittleFactory self)"""
        return _model_process.WhittleFactory_enableHistory(self)

    def disableHistory(self):
        """disableHistory(WhittleFactory self)"""
        return _model_process.WhittleFactory_disableHistory(self)

    def isHistoryEnabled(self):
        """isHistoryEnabled(WhittleFactory self) -> OT::Bool"""
        return _model_process.WhittleFactory_isHistoryEnabled(self)

    def clearHistory(self):
        """clearHistory(WhittleFactory self)"""
        return _model_process.WhittleFactory_clearHistory(self)

    def getHistory(self):
        """getHistory(WhittleFactory self) -> WhittleFactoryStateCollection"""
        return _model_process.WhittleFactory_getHistory(self)

    def setStartingPoints(self, *args):
        """setStartingPoints(WhittleFactory self, NumericalPointCollection startingPoints)"""
        return _model_process.WhittleFactory_setStartingPoints(self, *args)

    def getStartingPoints(self):
        """getStartingPoints(WhittleFactory self) -> NumericalPointCollection"""
        return _model_process.WhittleFactory_getStartingPoints(self)

    def __init__(self, *args): 
        """
        __init__(OT::WhittleFactory self, OT::String const & name=DefaultName) -> WhittleFactory
        __init__(OT::WhittleFactory self) -> WhittleFactory
        __init__(OT::WhittleFactory self, OT::UnsignedLong const p, OT::UnsignedLong const q, OT::Bool const invertible=True, 
            OT::String const & name=DefaultName) -> WhittleFactory
        __init__(OT::WhittleFactory self, OT::UnsignedLong const p, OT::UnsignedLong const q, OT::Bool const invertible=True) -> WhittleFactory
        __init__(OT::WhittleFactory self, OT::UnsignedLong const p, OT::UnsignedLong const q) -> WhittleFactory
        __init__(OT::WhittleFactory self, Indices p, Indices q, OT::Bool const invertible=True, OT::String const & name=DefaultName) -> WhittleFactory
        __init__(OT::WhittleFactory self, Indices p, Indices q, OT::Bool const invertible=True) -> WhittleFactory
        __init__(OT::WhittleFactory self, Indices p, Indices q) -> WhittleFactory
        __init__(OT::WhittleFactory self, WhittleFactory other) -> WhittleFactory
        """
        this = _model_process.new_WhittleFactory(*args)
        try: self.this.append(this)
        except: self.this = this
    __swig_destroy__ = _model_process.delete_WhittleFactory
    __del__ = lambda self : None;
WhittleFactory_swigregister = _model_process.WhittleFactory_swigregister
WhittleFactory_swigregister(WhittleFactory)

def WhittleFactory_GetClassName():
  """WhittleFactory_GetClassName() -> OT::String"""
  return _model_process.WhittleFactory_GetClassName()

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

    if _newclass:GetClassName = staticmethod(GetClassName)
    __swig_getmethods__["GetClassName"] = lambda x: GetClassName
    def getClassName(self):
        """getClassName(ARMALikelihoodFactory self) -> OT::String"""
        return _model_process.ARMALikelihoodFactory_getClassName(self)

    def __repr__(self):
        """__repr__(ARMALikelihoodFactory self) -> OT::String"""
        return _model_process.ARMALikelihoodFactory___repr__(self)

    def __str__(self, offset=""):
        """
        __str__(ARMALikelihoodFactory self, OT::String const & offset="") -> OT::String
        __str__(ARMALikelihoodFactory self) -> OT::String
        """
        return _model_process.ARMALikelihoodFactory___str__(self, offset)

    def setInitialARCoefficients(self, *args):
        """setInitialARCoefficients(ARMALikelihoodFactory self, ARMACoefficients phi)"""
        return _model_process.ARMALikelihoodFactory_setInitialARCoefficients(self, *args)

    def setInitialMACoefficients(self, *args):
        """setInitialMACoefficients(ARMALikelihoodFactory self, ARMACoefficients theta)"""
        return _model_process.ARMALikelihoodFactory_setInitialMACoefficients(self, *args)

    def setInitialCovarianceMatrix(self, *args):
        """setInitialCovarianceMatrix(ARMALikelihoodFactory self, CovarianceMatrix covarianceMatrix)"""
        return _model_process.ARMALikelihoodFactory_setInitialCovarianceMatrix(self, *args)

    def setInitialConditions(self, *args):
        """setInitialConditions(ARMALikelihoodFactory self, ARMACoefficients arCoefficients, ARMACoefficients maCoefficients, CovarianceMatrix covarianceMatrix)"""
        return _model_process.ARMALikelihoodFactory_setInitialConditions(self, *args)

    def getInitialARCoefficients(self):
        """getInitialARCoefficients(ARMALikelihoodFactory self) -> ARMACoefficients"""
        return _model_process.ARMALikelihoodFactory_getInitialARCoefficients(self)

    def getInitialMACoefficients(self):
        """getInitialMACoefficients(ARMALikelihoodFactory self) -> ARMACoefficients"""
        return _model_process.ARMALikelihoodFactory_getInitialMACoefficients(self)

    def getInitialCovarianceMatrix(self):
        """getInitialCovarianceMatrix(ARMALikelihoodFactory self) -> CovarianceMatrix"""
        return _model_process.ARMALikelihoodFactory_getInitialCovarianceMatrix(self)

    def build(self, *args):
        """
        build(ARMALikelihoodFactory self, TimeSeries timeSeries) -> ARMA
        build(ARMALikelihoodFactory self, ProcessSample sample) -> ARMA
        """
        return _model_process.ARMALikelihoodFactory_build(self, *args)

    def getVerbose(self):
        """getVerbose(ARMALikelihoodFactory self) -> OT::Bool"""
        return _model_process.ARMALikelihoodFactory_getVerbose(self)

    def setVerbose(self, *args):
        """setVerbose(ARMALikelihoodFactory self, OT::Bool const verbose)"""
        return _model_process.ARMALikelihoodFactory_setVerbose(self, *args)

    def __init__(self, *args): 
        """
        __init__(OT::ARMALikelihoodFactory self, OT::String const & name=DefaultName) -> ARMALikelihoodFactory
        __init__(OT::ARMALikelihoodFactory self) -> ARMALikelihoodFactory
        __init__(OT::ARMALikelihoodFactory self, OT::UnsignedLong const p, OT::UnsignedLong const q, OT::UnsignedLong const dimension, 
            OT::Bool const invertible=True, OT::String const & name=DefaultName) -> ARMALikelihoodFactory
        __init__(OT::ARMALikelihoodFactory self, OT::UnsignedLong const p, OT::UnsignedLong const q, OT::UnsignedLong const dimension, 
            OT::Bool const invertible=True) -> ARMALikelihoodFactory
        __init__(OT::ARMALikelihoodFactory self, OT::UnsignedLong const p, OT::UnsignedLong const q, OT::UnsignedLong const dimension) -> ARMALikelihoodFactory
        __init__(OT::ARMALikelihoodFactory self, Indices p, Indices q, OT::UnsignedLong const dimension, OT::Bool const invertible=True, 
            OT::String const & name=DefaultName) -> ARMALikelihoodFactory
        __init__(OT::ARMALikelihoodFactory self, Indices p, Indices q, OT::UnsignedLong const dimension, OT::Bool const invertible=True) -> ARMALikelihoodFactory
        __init__(OT::ARMALikelihoodFactory self, Indices p, Indices q, OT::UnsignedLong const dimension) -> ARMALikelihoodFactory
        __init__(OT::ARMALikelihoodFactory self, ARMALikelihoodFactory other) -> ARMALikelihoodFactory
        """
        this = _model_process.new_ARMALikelihoodFactory(*args)
        try: self.this.append(this)
        except: self.this = this
    __swig_destroy__ = _model_process.delete_ARMALikelihoodFactory
    __del__ = lambda self : None;
ARMALikelihoodFactory_swigregister = _model_process.ARMALikelihoodFactory_swigregister
ARMALikelihoodFactory_swigregister(ARMALikelihoodFactory)

def ARMALikelihoodFactory_GetClassName():
  """ARMALikelihoodFactory_GetClassName() -> OT::String"""
  return _model_process.ARMALikelihoodFactory_GetClassName()

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

    def getImplementationAsPersistentObject(self):
        """getImplementationAsPersistentObject(ARMAFactoryImplementationTypedInterfaceObject self) -> PersistentObjectPointer"""
        return _model_process.ARMAFactoryImplementationTypedInterfaceObject_getImplementationAsPersistentObject(self)

    def setImplementationAsPersistentObject(self, *args):
        """setImplementationAsPersistentObject(ARMAFactoryImplementationTypedInterfaceObject self, PersistentObjectPointer obj)"""
        return _model_process.ARMAFactoryImplementationTypedInterfaceObject_setImplementationAsPersistentObject(self, *args)

    def swap(self, *args):
        """swap(ARMAFactoryImplementationTypedInterfaceObject self, ARMAFactoryImplementationTypedInterfaceObject other)"""
        return _model_process.ARMAFactoryImplementationTypedInterfaceObject_swap(self, *args)

    def setName(self, *args):
        """setName(ARMAFactoryImplementationTypedInterfaceObject self, OT::String const & name)"""
        return _model_process.ARMAFactoryImplementationTypedInterfaceObject_setName(self, *args)

    def getName(self):
        """getName(ARMAFactoryImplementationTypedInterfaceObject self) -> OT::String"""
        return _model_process.ARMAFactoryImplementationTypedInterfaceObject_getName(self)

    def __eq__(self, *args):
        """__eq__(ARMAFactoryImplementationTypedInterfaceObject self, ARMAFactoryImplementationTypedInterfaceObject other) -> OT::Bool"""
        return _model_process.ARMAFactoryImplementationTypedInterfaceObject___eq__(self, *args)

    __swig_destroy__ = _model_process.delete_ARMAFactoryImplementationTypedInterfaceObject
    __del__ = lambda self : None;
ARMAFactoryImplementationTypedInterfaceObject_swigregister = _model_process.ARMAFactoryImplementationTypedInterfaceObject_swigregister
ARMAFactoryImplementationTypedInterfaceObject_swigregister(ARMAFactoryImplementationTypedInterfaceObject)

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

    if _newclass:GetClassName = staticmethod(GetClassName)
    __swig_getmethods__["GetClassName"] = lambda x: GetClassName
    def getClassName(self):
        """getClassName(ARMAFactory self) -> OT::String"""
        return _model_process.ARMAFactory_getClassName(self)

    def __repr__(self):
        """__repr__(ARMAFactory self) -> OT::String"""
        return _model_process.ARMAFactory___repr__(self)

    def __str__(self, offset=""):
        """
        __str__(ARMAFactory self, OT::String const & offset="") -> OT::String
        __str__(ARMAFactory self) -> OT::String
        """
        return _model_process.ARMAFactory___str__(self, offset)

    def build(self, *args):
        """
        build(ARMAFactory self, TimeSeries timeSeries) -> ARMA
        build(ARMAFactory self, ProcessSample sample) -> ARMA
        """
        return _model_process.ARMAFactory_build(self, *args)

    def __init__(self, *args): 
        """
        __init__(OT::ARMAFactory self) -> ARMAFactory
        __init__(OT::ARMAFactory self, ARMAFactoryImplementation implementation, OT::String const & name=DefaultName) -> ARMAFactory
        __init__(OT::ARMAFactory self, ARMAFactoryImplementation implementation) -> ARMAFactory
        __init__(OT::ARMAFactory self, OT::ARMAFactory::Implementation const & p_implementation, OT::String const & name=DefaultName) -> ARMAFactory
        __init__(OT::ARMAFactory self, OT::ARMAFactory::Implementation const & p_implementation) -> ARMAFactory
        __init__(OT::ARMAFactory self, ARMAFactory other) -> ARMAFactory
        """
        this = _model_process.new_ARMAFactory(*args)
        try: self.this.append(this)
        except: self.this = this
    __swig_destroy__ = _model_process.delete_ARMAFactory
    __del__ = lambda self : None;
ARMAFactory_swigregister = _model_process.ARMAFactory_swigregister
ARMAFactory_swigregister(ARMAFactory)

def ARMAFactory_GetClassName():
  """ARMAFactory_GetClassName() -> OT::String"""
  return _model_process.ARMAFactory_GetClassName()

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