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


"""
Random vectors
"""


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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

    if _newclass:GetClassName = staticmethod(GetClassName)
    __swig_getmethods__["GetClassName"] = lambda x: GetClassName
    def getClassName(self):
        """getClassName(ProcessImplementation self) -> OT::String"""
        return _randomvector.ProcessImplementation_getClassName(self)

    def __repr__(self):
        """__repr__(ProcessImplementation self) -> OT::String"""
        return _randomvector.ProcessImplementation___repr__(self)

    def __str__(self, offset=""):
        """
        __str__(ProcessImplementation self, OT::String const & offset="") -> OT::String
        __str__(ProcessImplementation self) -> OT::String
        """
        return _randomvector.ProcessImplementation___str__(self, offset)

    def isNormal(self):
        """isNormal(ProcessImplementation self) -> OT::Bool"""
        return _randomvector.ProcessImplementation_isNormal(self)

    def isStationary(self):
        """isStationary(ProcessImplementation self) -> OT::Bool"""
        return _randomvector.ProcessImplementation_isStationary(self)

    def isComposite(self):
        """isComposite(ProcessImplementation self) -> OT::Bool"""
        return _randomvector.ProcessImplementation_isComposite(self)

    def getDimension(self):
        """getDimension(ProcessImplementation self) -> OT::UnsignedLong"""
        return _randomvector.ProcessImplementation_getDimension(self)

    def getTimeGrid(self):
        """getTimeGrid(ProcessImplementation self) -> RegularGrid"""
        return _randomvector.ProcessImplementation_getTimeGrid(self)

    def setTimeGrid(self, *args):
        """setTimeGrid(ProcessImplementation self, RegularGrid timeGrid)"""
        return _randomvector.ProcessImplementation_setTimeGrid(self, *args)

    def getRealization(self):
        """getRealization(ProcessImplementation self) -> TimeSeries"""
        return _randomvector.ProcessImplementation_getRealization(self)

    def getContinuousRealization(self):
        """getContinuousRealization(ProcessImplementation self) -> NumericalMathFunction"""
        return _randomvector.ProcessImplementation_getContinuousRealization(self)

    def getSample(self, *args):
        """getSample(ProcessImplementation self, OT::UnsignedLong const size) -> ProcessSample"""
        return _randomvector.ProcessImplementation_getSample(self, *args)

    def getFuture(self, *args):
        """
        getFuture(ProcessImplementation self, OT::UnsignedLong const stepNumber) -> TimeSeries
        getFuture(ProcessImplementation self, OT::UnsignedLong const stepNumber, OT::UnsignedLong const size) -> ProcessSample
        """
        return _randomvector.ProcessImplementation_getFuture(self, *args)

    def getMarginalProcess(self, *args):
        """
        getMarginalProcess(ProcessImplementation self, OT::UnsignedLong const i) -> ProcessImplementationPointer
        getMarginalProcess(ProcessImplementation self, Indices indices) -> ProcessImplementationPointer
        """
        return _randomvector.ProcessImplementation_getMarginalProcess(self, *args)

    def setDescription(self, *args):
        """setDescription(ProcessImplementation self, Description description)"""
        return _randomvector.ProcessImplementation_setDescription(self, *args)

    def getDescription(self):
        """getDescription(ProcessImplementation self) -> Description"""
        return _randomvector.ProcessImplementation_getDescription(self)

    def __init__(self, *args): 
        """
        __init__(OT::ProcessImplementation self, OT::String const & name=DefaultName) -> ProcessImplementation
        __init__(OT::ProcessImplementation self) -> ProcessImplementation
        __init__(OT::ProcessImplementation self, ProcessImplementation other) -> ProcessImplementation
        """
        this = _randomvector.new_ProcessImplementation(*args)
        try: self.this.append(this)
        except: self.this = this
    __swig_destroy__ = _randomvector.delete_ProcessImplementation
    __del__ = lambda self : None;
ProcessImplementation_swigregister = _randomvector.ProcessImplementation_swigregister
ProcessImplementation_swigregister(ProcessImplementation)

def ProcessImplementation_GetClassName():
  """ProcessImplementation_GetClassName() -> OT::String"""
  return _randomvector.ProcessImplementation_GetClassName()

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

    def getImplementationAsPersistentObject(self):
        """getImplementationAsPersistentObject(ProcessImplementationTypedInterfaceObject self) -> PersistentObjectPointer"""
        return _randomvector.ProcessImplementationTypedInterfaceObject_getImplementationAsPersistentObject(self)

    def setImplementationAsPersistentObject(self, *args):
        """setImplementationAsPersistentObject(ProcessImplementationTypedInterfaceObject self, PersistentObjectPointer obj)"""
        return _randomvector.ProcessImplementationTypedInterfaceObject_setImplementationAsPersistentObject(self, *args)

    def swap(self, *args):
        """swap(ProcessImplementationTypedInterfaceObject self, ProcessImplementationTypedInterfaceObject other)"""
        return _randomvector.ProcessImplementationTypedInterfaceObject_swap(self, *args)

    def setName(self, *args):
        """setName(ProcessImplementationTypedInterfaceObject self, OT::String const & name)"""
        return _randomvector.ProcessImplementationTypedInterfaceObject_setName(self, *args)

    def getName(self):
        """getName(ProcessImplementationTypedInterfaceObject self) -> OT::String"""
        return _randomvector.ProcessImplementationTypedInterfaceObject_getName(self)

    def __eq__(self, *args):
        """__eq__(ProcessImplementationTypedInterfaceObject self, ProcessImplementationTypedInterfaceObject other) -> OT::Bool"""
        return _randomvector.ProcessImplementationTypedInterfaceObject___eq__(self, *args)

    __swig_destroy__ = _randomvector.delete_ProcessImplementationTypedInterfaceObject
    __del__ = lambda self : None;
ProcessImplementationTypedInterfaceObject_swigregister = _randomvector.ProcessImplementationTypedInterfaceObject_swigregister
ProcessImplementationTypedInterfaceObject_swigregister(ProcessImplementationTypedInterfaceObject)

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

    if _newclass:GetClassName = staticmethod(GetClassName)
    __swig_getmethods__["GetClassName"] = lambda x: GetClassName
    def getClassName(self):
        """getClassName(Process self) -> OT::String"""
        return _randomvector.Process_getClassName(self)

    def __repr__(self):
        """__repr__(Process self) -> OT::String"""
        return _randomvector.Process___repr__(self)

    def __str__(self, offset=""):
        """
        __str__(Process self, OT::String const & offset="") -> OT::String
        __str__(Process self) -> OT::String
        """
        return _randomvector.Process___str__(self, offset)

    def setDescription(self, *args):
        """setDescription(Process self, Description description)"""
        return _randomvector.Process_setDescription(self, *args)

    def getDescription(self):
        """getDescription(Process self) -> Description"""
        return _randomvector.Process_getDescription(self)

    def isNormal(self):
        """isNormal(Process self) -> OT::Bool"""
        return _randomvector.Process_isNormal(self)

    def isStationary(self):
        """isStationary(Process self) -> OT::Bool"""
        return _randomvector.Process_isStationary(self)

    def isComposite(self):
        """isComposite(Process self) -> OT::Bool"""
        return _randomvector.Process_isComposite(self)

    def getDimension(self):
        """getDimension(Process self) -> OT::UnsignedLong"""
        return _randomvector.Process_getDimension(self)

    def getRealization(self):
        """getRealization(Process self) -> TimeSeries"""
        return _randomvector.Process_getRealization(self)

    def getContinuousRealization(self):
        """getContinuousRealization(Process self) -> NumericalMathFunction"""
        return _randomvector.Process_getContinuousRealization(self)

    def getTimeGrid(self):
        """getTimeGrid(Process self) -> RegularGrid"""
        return _randomvector.Process_getTimeGrid(self)

    def setTimeGrid(self, *args):
        """setTimeGrid(Process self, RegularGrid timeGrid)"""
        return _randomvector.Process_setTimeGrid(self, *args)

    def getSample(self, *args):
        """getSample(Process self, OT::UnsignedLong const size) -> ProcessSample"""
        return _randomvector.Process_getSample(self, *args)

    def getFuture(self, *args):
        """
        getFuture(Process self, OT::UnsignedLong const stepNumber) -> TimeSeries
        getFuture(Process self, OT::UnsignedLong const stepNumber, OT::UnsignedLong const size) -> ProcessSample
        """
        return _randomvector.Process_getFuture(self, *args)

    def getMarginalProcess(self, *args):
        """
        getMarginalProcess(Process self, OT::UnsignedLong const i) -> Process
        getMarginalProcess(Process self, Indices indices) -> Process
        """
        return _randomvector.Process_getMarginalProcess(self, *args)

    def __init__(self, *args): 
        """
        __init__(OT::Process self) -> Process
        __init__(OT::Process self, ProcessImplementation implementation, OT::String const & name=DefaultName) -> Process
        __init__(OT::Process self, ProcessImplementation implementation) -> Process
        __init__(OT::Process self, ProcessImplementationPointer p_implementation, OT::String const & name=DefaultName) -> Process
        __init__(OT::Process self, ProcessImplementationPointer p_implementation) -> Process
        __init__(OT::Process self, Process other) -> Process
        """
        this = _randomvector.new_Process(*args)
        try: self.this.append(this)
        except: self.this = this
    __swig_destroy__ = _randomvector.delete_Process
    __del__ = lambda self : None;
Process_swigregister = _randomvector.Process_swigregister
Process_swigregister(Process)

def Process_GetClassName():
  """Process_GetClassName() -> OT::String"""
  return _randomvector.Process_GetClassName()

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

    if _newclass:GetClassName = staticmethod(GetClassName)
    __swig_getmethods__["GetClassName"] = lambda x: GetClassName
    def getClassName(self):
        """getClassName(RandomVectorImplementation self) -> OT::String"""
        return _randomvector.RandomVectorImplementation_getClassName(self)

    def __repr__(self):
        """__repr__(RandomVectorImplementation self) -> OT::String"""
        return _randomvector.RandomVectorImplementation___repr__(self)

    def isComposite(self):
        """isComposite(RandomVectorImplementation self) -> OT::Bool"""
        return _randomvector.RandomVectorImplementation_isComposite(self)

    def getDimension(self):
        """getDimension(RandomVectorImplementation self) -> OT::UnsignedLong"""
        return _randomvector.RandomVectorImplementation_getDimension(self)

    def getRealization(self):
        """getRealization(RandomVectorImplementation self) -> NumericalPoint"""
        return _randomvector.RandomVectorImplementation_getRealization(self)

    def getSample(self, *args):
        """getSample(RandomVectorImplementation self, OT::UnsignedLong const size) -> NumericalSample"""
        return _randomvector.RandomVectorImplementation_getSample(self, *args)

    def getMean(self):
        """getMean(RandomVectorImplementation self) -> NumericalPoint"""
        return _randomvector.RandomVectorImplementation_getMean(self)

    def getCovariance(self):
        """getCovariance(RandomVectorImplementation self) -> CovarianceMatrix"""
        return _randomvector.RandomVectorImplementation_getCovariance(self)

    def getMarginal(self, *args):
        """
        getMarginal(RandomVectorImplementation self, OT::UnsignedLong const i) -> RandomVectorImplementationPointer
        getMarginal(RandomVectorImplementation self, Indices indices) -> RandomVectorImplementationPointer
        """
        return _randomvector.RandomVectorImplementation_getMarginal(self, *args)

    def getAntecedent(self):
        """getAntecedent(RandomVectorImplementation self) -> RandomVectorImplementationPointer"""
        return _randomvector.RandomVectorImplementation_getAntecedent(self)

    def getFunction(self):
        """getFunction(RandomVectorImplementation self) -> NumericalMathFunction"""
        return _randomvector.RandomVectorImplementation_getFunction(self)

    def getDistribution(self):
        """getDistribution(RandomVectorImplementation self) -> Distribution"""
        return _randomvector.RandomVectorImplementation_getDistribution(self)

    def getOperator(self):
        """getOperator(RandomVectorImplementation self) -> ComparisonOperator"""
        return _randomvector.RandomVectorImplementation_getOperator(self)

    def getDomain(self):
        """getDomain(RandomVectorImplementation self) -> Domain"""
        return _randomvector.RandomVectorImplementation_getDomain(self)

    def getProcess(self):
        """getProcess(RandomVectorImplementation self) -> Process"""
        return _randomvector.RandomVectorImplementation_getProcess(self)

    def getThreshold(self):
        """getThreshold(RandomVectorImplementation self) -> OT::NumericalScalar"""
        return _randomvector.RandomVectorImplementation_getThreshold(self)

    def setDescription(self, *args):
        """setDescription(RandomVectorImplementation self, Description description)"""
        return _randomvector.RandomVectorImplementation_setDescription(self, *args)

    def getDescription(self):
        """getDescription(RandomVectorImplementation self) -> Description"""
        return _randomvector.RandomVectorImplementation_getDescription(self)

    def __init__(self, *args): 
        """
        __init__(OT::RandomVectorImplementation self, OT::String const & name=DefaultName) -> RandomVectorImplementation
        __init__(OT::RandomVectorImplementation self) -> RandomVectorImplementation
        __init__(OT::RandomVectorImplementation self, RandomVectorImplementation other) -> RandomVectorImplementation
        """
        this = _randomvector.new_RandomVectorImplementation(*args)
        try: self.this.append(this)
        except: self.this = this
    __swig_destroy__ = _randomvector.delete_RandomVectorImplementation
    __del__ = lambda self : None;
RandomVectorImplementation_swigregister = _randomvector.RandomVectorImplementation_swigregister
RandomVectorImplementation_swigregister(RandomVectorImplementation)

def RandomVectorImplementation_GetClassName():
  """RandomVectorImplementation_GetClassName() -> OT::String"""
  return _randomvector.RandomVectorImplementation_GetClassName()

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

    if _newclass:GetClassName = staticmethod(GetClassName)
    __swig_getmethods__["GetClassName"] = lambda x: GetClassName
    def getClassName(self):
        """getClassName(ConstantRandomVector self) -> OT::String"""
        return _randomvector.ConstantRandomVector_getClassName(self)

    def __repr__(self):
        """__repr__(ConstantRandomVector self) -> OT::String"""
        return _randomvector.ConstantRandomVector___repr__(self)

    def getDimension(self):
        """getDimension(ConstantRandomVector self) -> OT::UnsignedLong"""
        return _randomvector.ConstantRandomVector_getDimension(self)

    def getRealization(self):
        """getRealization(ConstantRandomVector self) -> NumericalPoint"""
        return _randomvector.ConstantRandomVector_getRealization(self)

    def getSample(self, *args):
        """getSample(ConstantRandomVector self, OT::UnsignedLong const size) -> NumericalSample"""
        return _randomvector.ConstantRandomVector_getSample(self, *args)

    def getMean(self):
        """getMean(ConstantRandomVector self) -> NumericalPoint"""
        return _randomvector.ConstantRandomVector_getMean(self)

    def getCovariance(self):
        """getCovariance(ConstantRandomVector self) -> CovarianceMatrix"""
        return _randomvector.ConstantRandomVector_getCovariance(self)

    def getMarginal(self, *args):
        """
        getMarginal(ConstantRandomVector self, OT::UnsignedLong const i) -> RandomVectorImplementationPointer
        getMarginal(ConstantRandomVector self, Indices indices) -> RandomVectorImplementationPointer
        """
        return _randomvector.ConstantRandomVector_getMarginal(self, *args)

    def getDistribution(self):
        """getDistribution(ConstantRandomVector self) -> Distribution"""
        return _randomvector.ConstantRandomVector_getDistribution(self)

    def __init__(self, *args): 
        """
        __init__(OT::ConstantRandomVector self, NumericalPointWithDescription point, OT::String const & name=DefaultName) -> ConstantRandomVector
        __init__(OT::ConstantRandomVector self, NumericalPointWithDescription point) -> ConstantRandomVector
        __init__(OT::ConstantRandomVector self, NumericalPoint point, OT::String const & name=DefaultName) -> ConstantRandomVector
        __init__(OT::ConstantRandomVector self, NumericalPoint point) -> ConstantRandomVector
        __init__(OT::ConstantRandomVector self, ConstantRandomVector other) -> ConstantRandomVector
        """
        this = _randomvector.new_ConstantRandomVector(*args)
        try: self.this.append(this)
        except: self.this = this
    __swig_destroy__ = _randomvector.delete_ConstantRandomVector
    __del__ = lambda self : None;
ConstantRandomVector_swigregister = _randomvector.ConstantRandomVector_swigregister
ConstantRandomVector_swigregister(ConstantRandomVector)

def ConstantRandomVector_GetClassName():
  """ConstantRandomVector_GetClassName() -> OT::String"""
  return _randomvector.ConstantRandomVector_GetClassName()

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

    if _newclass:GetClassName = staticmethod(GetClassName)
    __swig_getmethods__["GetClassName"] = lambda x: GetClassName
    def getClassName(self):
        """getClassName(UsualRandomVector self) -> OT::String"""
        return _randomvector.UsualRandomVector_getClassName(self)

    def __repr__(self):
        """__repr__(UsualRandomVector self) -> OT::String"""
        return _randomvector.UsualRandomVector___repr__(self)

    def getDimension(self):
        """getDimension(UsualRandomVector self) -> OT::UnsignedLong"""
        return _randomvector.UsualRandomVector_getDimension(self)

    def getRealization(self):
        """getRealization(UsualRandomVector self) -> NumericalPoint"""
        return _randomvector.UsualRandomVector_getRealization(self)

    def getSample(self, *args):
        """getSample(UsualRandomVector self, OT::UnsignedLong size) -> NumericalSample"""
        return _randomvector.UsualRandomVector_getSample(self, *args)

    def getMean(self):
        """getMean(UsualRandomVector self) -> NumericalPoint"""
        return _randomvector.UsualRandomVector_getMean(self)

    def getCovariance(self):
        """getCovariance(UsualRandomVector self) -> CovarianceMatrix"""
        return _randomvector.UsualRandomVector_getCovariance(self)

    def getMarginal(self, *args):
        """
        getMarginal(UsualRandomVector self, OT::UnsignedLong const i) -> RandomVectorImplementationPointer
        getMarginal(UsualRandomVector self, Indices indices) -> RandomVectorImplementationPointer
        """
        return _randomvector.UsualRandomVector_getMarginal(self, *args)

    def getDistribution(self):
        """getDistribution(UsualRandomVector self) -> Distribution"""
        return _randomvector.UsualRandomVector_getDistribution(self)

    def __init__(self, *args): 
        """
        __init__(OT::UsualRandomVector self, Distribution distribution, OT::String const & name=DefaultName) -> UsualRandomVector
        __init__(OT::UsualRandomVector self, Distribution distribution) -> UsualRandomVector
        __init__(OT::UsualRandomVector self, UsualRandomVector other) -> UsualRandomVector
        """
        this = _randomvector.new_UsualRandomVector(*args)
        try: self.this.append(this)
        except: self.this = this
    __swig_destroy__ = _randomvector.delete_UsualRandomVector
    __del__ = lambda self : None;
UsualRandomVector_swigregister = _randomvector.UsualRandomVector_swigregister
UsualRandomVector_swigregister(UsualRandomVector)

def UsualRandomVector_GetClassName():
  """UsualRandomVector_GetClassName() -> OT::String"""
  return _randomvector.UsualRandomVector_GetClassName()

class ProcessImplementationPointer(_object):
    """Proxy of C++ OT::Pointer<(OT::ProcessImplementation)> class"""
    __swig_setmethods__ = {}
    __setattr__ = lambda self, name, value: _swig_setattr(self, ProcessImplementationPointer, name, value)
    __swig_getmethods__ = {}
    __getattr__ = lambda self, name: _swig_getattr(self, ProcessImplementationPointer, name)
    __swig_setmethods__["ptr_"] = _randomvector.ProcessImplementationPointer_ptr__set
    __swig_getmethods__["ptr_"] = _randomvector.ProcessImplementationPointer_ptr__get
    if _newclass:ptr_ = _swig_property(_randomvector.ProcessImplementationPointer_ptr__get, _randomvector.ProcessImplementationPointer_ptr__set)
    def __init__(self, *args): 
        """
        __init__(OT::Pointer<(OT::ProcessImplementation)> self) -> ProcessImplementationPointer
        __init__(OT::Pointer<(OT::ProcessImplementation)> self, ProcessImplementation ptr) -> ProcessImplementationPointer
        """
        this = _randomvector.new_ProcessImplementationPointer(*args)
        try: self.this.append(this)
        except: self.this = this
    __swig_destroy__ = _randomvector.delete_ProcessImplementationPointer
    __del__ = lambda self : None;
    def reset(self):
        """reset(ProcessImplementationPointer self)"""
        return _randomvector.ProcessImplementationPointer_reset(self)

    def __ref__(self, *args):
        """
        __ref__(ProcessImplementationPointer self) -> ProcessImplementation
        __ref__(ProcessImplementationPointer self) -> ProcessImplementation
        """
        return _randomvector.ProcessImplementationPointer___ref__(self, *args)

    def __deref__(self):
        """__deref__(ProcessImplementationPointer self) -> ProcessImplementation"""
        return _randomvector.ProcessImplementationPointer___deref__(self)

    def isNull(self):
        """isNull(ProcessImplementationPointer self) -> OT::Bool"""
        return _randomvector.ProcessImplementationPointer_isNull(self)

    def __nonzero__(self):
        return _randomvector.ProcessImplementationPointer___nonzero__(self)
    __bool__ = __nonzero__


    def get(self):
        """get(ProcessImplementationPointer self) -> ProcessImplementation"""
        return _randomvector.ProcessImplementationPointer_get(self)

    def getImplementation(self):
        """getImplementation(ProcessImplementationPointer self) -> OT::Pointer< OT::ProcessImplementation >::pointer_type const &"""
        return _randomvector.ProcessImplementationPointer_getImplementation(self)

    def unique(self):
        """unique(ProcessImplementationPointer self) -> OT::Bool"""
        return _randomvector.ProcessImplementationPointer_unique(self)

    def use_count(self):
        """use_count(ProcessImplementationPointer self) -> OT::UnsignedLong"""
        return _randomvector.ProcessImplementationPointer_use_count(self)

    def swap(self, *args):
        """swap(ProcessImplementationPointer self, ProcessImplementationPointer other)"""
        return _randomvector.ProcessImplementationPointer_swap(self, *args)

    def GetClassName(self):
        """GetClassName(ProcessImplementationPointer self) -> OT::String"""
        return _randomvector.ProcessImplementationPointer_GetClassName(self)

    def getClassName(self):
        """getClassName(ProcessImplementationPointer self) -> OT::String"""
        return _randomvector.ProcessImplementationPointer_getClassName(self)

    def __repr__(self):
        """__repr__(ProcessImplementationPointer self) -> OT::String"""
        return _randomvector.ProcessImplementationPointer___repr__(self)

    def __str__(self, offset=""):
        """
        __str__(ProcessImplementationPointer self, OT::String const & offset="") -> OT::String
        __str__(ProcessImplementationPointer self) -> OT::String
        """
        return _randomvector.ProcessImplementationPointer___str__(self, offset)

    def isNormal(self):
        """isNormal(ProcessImplementationPointer self) -> OT::Bool"""
        return _randomvector.ProcessImplementationPointer_isNormal(self)

    def isStationary(self):
        """isStationary(ProcessImplementationPointer self) -> OT::Bool"""
        return _randomvector.ProcessImplementationPointer_isStationary(self)

    def isComposite(self):
        """isComposite(ProcessImplementationPointer self) -> OT::Bool"""
        return _randomvector.ProcessImplementationPointer_isComposite(self)

    def getDimension(self):
        """getDimension(ProcessImplementationPointer self) -> OT::UnsignedLong"""
        return _randomvector.ProcessImplementationPointer_getDimension(self)

    def getTimeGrid(self):
        """getTimeGrid(ProcessImplementationPointer self) -> RegularGrid"""
        return _randomvector.ProcessImplementationPointer_getTimeGrid(self)

    def setTimeGrid(self, *args):
        """setTimeGrid(ProcessImplementationPointer self, RegularGrid timeGrid)"""
        return _randomvector.ProcessImplementationPointer_setTimeGrid(self, *args)

    def getRealization(self):
        """getRealization(ProcessImplementationPointer self) -> TimeSeries"""
        return _randomvector.ProcessImplementationPointer_getRealization(self)

    def getContinuousRealization(self):
        """getContinuousRealization(ProcessImplementationPointer self) -> NumericalMathFunction"""
        return _randomvector.ProcessImplementationPointer_getContinuousRealization(self)

    def getSample(self, *args):
        """getSample(ProcessImplementationPointer self, OT::UnsignedLong const size) -> ProcessSample"""
        return _randomvector.ProcessImplementationPointer_getSample(self, *args)

    def getFuture(self, *args):
        """
        getFuture(ProcessImplementationPointer self, OT::UnsignedLong const stepNumber) -> TimeSeries
        getFuture(ProcessImplementationPointer self, OT::UnsignedLong const stepNumber, OT::UnsignedLong const size) -> ProcessSample
        """
        return _randomvector.ProcessImplementationPointer_getFuture(self, *args)

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

    def setDescription(self, *args):
        """setDescription(ProcessImplementationPointer self, Description description)"""
        return _randomvector.ProcessImplementationPointer_setDescription(self, *args)

    def getDescription(self):
        """getDescription(ProcessImplementationPointer self) -> Description"""
        return _randomvector.ProcessImplementationPointer_getDescription(self)

    def __eq__(self, *args):
        """__eq__(ProcessImplementationPointer self, PersistentObject other) -> OT::Bool"""
        return _randomvector.ProcessImplementationPointer___eq__(self, *args)

    def Is(self, *args):
        """Is(ProcessImplementationPointer self, PersistentObject other) -> OT::Bool"""
        return _randomvector.ProcessImplementationPointer_Is(self, *args)

    def getId(self):
        """getId(ProcessImplementationPointer self) -> OT::Id"""
        return _randomvector.ProcessImplementationPointer_getId(self)

    def setShadowedId(self, *args):
        """setShadowedId(ProcessImplementationPointer self, OT::Id id)"""
        return _randomvector.ProcessImplementationPointer_setShadowedId(self, *args)

    def getShadowedId(self):
        """getShadowedId(ProcessImplementationPointer self) -> OT::Id"""
        return _randomvector.ProcessImplementationPointer_getShadowedId(self)

    def setVisibility(self, *args):
        """setVisibility(ProcessImplementationPointer self, OT::Bool visible)"""
        return _randomvector.ProcessImplementationPointer_setVisibility(self, *args)

    def getVisibility(self):
        """getVisibility(ProcessImplementationPointer self) -> OT::Bool"""
        return _randomvector.ProcessImplementationPointer_getVisibility(self)

    def hasName(self):
        """hasName(ProcessImplementationPointer self) -> OT::Bool"""
        return _randomvector.ProcessImplementationPointer_hasName(self)

    def hasVisibleName(self):
        """hasVisibleName(ProcessImplementationPointer self) -> OT::Bool"""
        return _randomvector.ProcessImplementationPointer_hasVisibleName(self)

    def getName(self):
        """getName(ProcessImplementationPointer self) -> OT::String"""
        return _randomvector.ProcessImplementationPointer_getName(self)

    def setName(self, *args):
        """setName(ProcessImplementationPointer self, OT::String const & name)"""
        return _randomvector.ProcessImplementationPointer_setName(self, *args)

ProcessImplementationPointer_swigregister = _randomvector.ProcessImplementationPointer_swigregister
ProcessImplementationPointer_swigregister(ProcessImplementationPointer)

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