python-openturns 1.3-3 / usr / lib / python2.7 / dist-packages / openturns / stattests.py

# This file was automatically generated by SWIG (http://www.swig.org).
# Version 2.0.12
#
# Do not make changes to this file unless you know what you are doing--modify
# the SWIG interface file instead.




"""
Statistical tests.
"""


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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

def TestResult_GetClassName():
  """TestResult_GetClassName() -> OT::String"""
  return _stattests.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 VisualTest(_object):
    """Proxy of C++ OT::VisualTest class"""
    __swig_setmethods__ = {}
    __setattr__ = lambda self, name, value: _swig_setattr(self, VisualTest, name, value)
    __swig_getmethods__ = {}
    __getattr__ = lambda self, name: _swig_getattr(self, VisualTest, name)
    def __init__(self, *args, **kwargs): raise AttributeError("No constructor defined")
    __repr__ = _swig_repr
    def DrawEmpiricalCDF(*args):
        """DrawEmpiricalCDF(NumericalSample sample, OT::NumericalScalar const xMin, OT::NumericalScalar const xMax) -> Graph"""
        return _stattests.VisualTest_DrawEmpiricalCDF(*args)

    if _newclass:DrawEmpiricalCDF = staticmethod(DrawEmpiricalCDF)
    __swig_getmethods__["DrawEmpiricalCDF"] = lambda x: DrawEmpiricalCDF
    def DrawHistogram(*args):
        """
        DrawHistogram(NumericalSample sample, OT::UnsignedLong const BarNumber) -> Graph
        DrawHistogram(NumericalSample sample) -> Graph
        """
        return _stattests.VisualTest_DrawHistogram(*args)

    if _newclass:DrawHistogram = staticmethod(DrawHistogram)
    __swig_getmethods__["DrawHistogram"] = lambda x: DrawHistogram
    def DrawQQplot(*args):
        """
        DrawQQplot(NumericalSample sample1, NumericalSample sample2, OT::UnsignedLong const pointNumber=OT::ResourceMap::GetAsUnsignedLong("DistributionImplementation-DefaultPointNumber")) -> Graph
        DrawQQplot(NumericalSample sample1, NumericalSample sample2) -> Graph
        DrawQQplot(NumericalSample sample, Distribution dist) -> Graph
        """
        return _stattests.VisualTest_DrawQQplot(*args)

    if _newclass:DrawQQplot = staticmethod(DrawQQplot)
    __swig_getmethods__["DrawQQplot"] = lambda x: DrawQQplot
    def DrawHenryLine(*args):
        """DrawHenryLine(NumericalSample sample) -> Graph"""
        return _stattests.VisualTest_DrawHenryLine(*args)

    if _newclass:DrawHenryLine = staticmethod(DrawHenryLine)
    __swig_getmethods__["DrawHenryLine"] = lambda x: DrawHenryLine
    def DrawClouds(*args):
        """
        DrawClouds(NumericalSample sample1, Distribution dist) -> Graph
        DrawClouds(NumericalSample sample1, NumericalSample sample2) -> Graph
        """
        return _stattests.VisualTest_DrawClouds(*args)

    if _newclass:DrawClouds = staticmethod(DrawClouds)
    __swig_getmethods__["DrawClouds"] = lambda x: DrawClouds
    def DrawLinearModel(*args):
        """DrawLinearModel(NumericalSample sample1, NumericalSample sample2, LinearModel linearModel) -> Graph"""
        return _stattests.VisualTest_DrawLinearModel(*args)

    if _newclass:DrawLinearModel = staticmethod(DrawLinearModel)
    __swig_getmethods__["DrawLinearModel"] = lambda x: DrawLinearModel
    def DrawLinearModelResidual(*args):
        """DrawLinearModelResidual(NumericalSample sample1, NumericalSample sample2, LinearModel linearModel) -> Graph"""
        return _stattests.VisualTest_DrawLinearModelResidual(*args)

    if _newclass:DrawLinearModelResidual = staticmethod(DrawLinearModelResidual)
    __swig_getmethods__["DrawLinearModelResidual"] = lambda x: DrawLinearModelResidual
    def DrawCobWeb(*args):
        """
        DrawCobWeb(NumericalSample inputSample, NumericalSample outputSample, OT::NumericalScalar const minValue, 
            OT::NumericalScalar const maxValue, OT::String const & color, 
            OT::Bool const quantileScale=True) -> Graph
        DrawCobWeb(NumericalSample inputSample, NumericalSample outputSample, OT::NumericalScalar const minValue, 
            OT::NumericalScalar const maxValue, OT::String const & color) -> Graph
        """
        return _stattests.VisualTest_DrawCobWeb(*args)

    if _newclass:DrawCobWeb = staticmethod(DrawCobWeb)
    __swig_getmethods__["DrawCobWeb"] = lambda x: DrawCobWeb
    def DrawKendallPlot(*args):
        """
        DrawKendallPlot(NumericalSample data, Copula copula) -> Graph
        DrawKendallPlot(NumericalSample firstSample, NumericalSample secondSample) -> Graph
        """
        return _stattests.VisualTest_DrawKendallPlot(*args)

    if _newclass:DrawKendallPlot = staticmethod(DrawKendallPlot)
    __swig_getmethods__["DrawKendallPlot"] = lambda x: DrawKendallPlot
    __swig_destroy__ = _stattests.delete_VisualTest
    __del__ = lambda self : None;
VisualTest_swigregister = _stattests.VisualTest_swigregister
VisualTest_swigregister(VisualTest)

def VisualTest_DrawEmpiricalCDF(*args):
  """VisualTest_DrawEmpiricalCDF(NumericalSample sample, OT::NumericalScalar const xMin, OT::NumericalScalar const xMax) -> Graph"""
  return _stattests.VisualTest_DrawEmpiricalCDF(*args)

def VisualTest_DrawHistogram(*args):
  """
    DrawHistogram(NumericalSample sample, OT::UnsignedLong const BarNumber) -> Graph
    VisualTest_DrawHistogram(NumericalSample sample) -> Graph
    """
  return _stattests.VisualTest_DrawHistogram(*args)

def VisualTest_DrawQQplot(*args):
  """
    DrawQQplot(NumericalSample sample1, NumericalSample sample2, OT::UnsignedLong const pointNumber=OT::ResourceMap::GetAsUnsignedLong("DistributionImplementation-DefaultPointNumber")) -> Graph
    DrawQQplot(NumericalSample sample1, NumericalSample sample2) -> Graph
    VisualTest_DrawQQplot(NumericalSample sample, Distribution dist) -> Graph
    """
  return _stattests.VisualTest_DrawQQplot(*args)

def VisualTest_DrawHenryLine(*args):
  """VisualTest_DrawHenryLine(NumericalSample sample) -> Graph"""
  return _stattests.VisualTest_DrawHenryLine(*args)

def VisualTest_DrawClouds(*args):
  """
    DrawClouds(NumericalSample sample1, Distribution dist) -> Graph
    VisualTest_DrawClouds(NumericalSample sample1, NumericalSample sample2) -> Graph
    """
  return _stattests.VisualTest_DrawClouds(*args)

def VisualTest_DrawLinearModel(*args):
  """VisualTest_DrawLinearModel(NumericalSample sample1, NumericalSample sample2, LinearModel linearModel) -> Graph"""
  return _stattests.VisualTest_DrawLinearModel(*args)

def VisualTest_DrawLinearModelResidual(*args):
  """VisualTest_DrawLinearModelResidual(NumericalSample sample1, NumericalSample sample2, LinearModel linearModel) -> Graph"""
  return _stattests.VisualTest_DrawLinearModelResidual(*args)

def VisualTest_DrawCobWeb(*args):
  """
    DrawCobWeb(NumericalSample inputSample, NumericalSample outputSample, OT::NumericalScalar const minValue, 
        OT::NumericalScalar const maxValue, OT::String const & color, 
        OT::Bool const quantileScale=True) -> Graph
    VisualTest_DrawCobWeb(NumericalSample inputSample, NumericalSample outputSample, OT::NumericalScalar const minValue, 
        OT::NumericalScalar const maxValue, OT::String const & color) -> Graph
    """
  return _stattests.VisualTest_DrawCobWeb(*args)

def VisualTest_DrawKendallPlot(*args):
  """
    DrawKendallPlot(NumericalSample data, Copula copula) -> Graph
    VisualTest_DrawKendallPlot(NumericalSample firstSample, NumericalSample secondSample) -> Graph
    """
  return _stattests.VisualTest_DrawKendallPlot(*args)

class FittingTest(_object):
    """Proxy of C++ OT::FittingTest class"""
    __swig_setmethods__ = {}
    __setattr__ = lambda self, name, value: _swig_setattr(self, FittingTest, name, value)
    __swig_getmethods__ = {}
    __getattr__ = lambda self, name: _swig_getattr(self, FittingTest, name)
    def __init__(self, *args, **kwargs): raise AttributeError("No constructor defined")
    __repr__ = _swig_repr
    def BestModelBIC(*args):
        """
        BestModelBIC(NumericalSample sample, DistributionFactoryCollection factoryCollection) -> Distribution
        BestModelBIC(NumericalSample sample, DistributionCollection distributionCollection) -> Distribution
        """
        return _stattests.FittingTest_BestModelBIC(*args)

    if _newclass:BestModelBIC = staticmethod(BestModelBIC)
    __swig_getmethods__["BestModelBIC"] = lambda x: BestModelBIC
    def BestModelKolmogorov(*args):
        """
        BestModelKolmogorov(NumericalSample sample, DistributionFactoryCollection factoryCollection) -> Distribution
        BestModelKolmogorov(NumericalSample sample, DistributionCollection distributionCollection) -> Distribution
        """
        return _stattests.FittingTest_BestModelKolmogorov(*args)

    if _newclass:BestModelKolmogorov = staticmethod(BestModelKolmogorov)
    __swig_getmethods__["BestModelKolmogorov"] = lambda x: BestModelKolmogorov
    def BestModelChiSquared(*args):
        """
        BestModelChiSquared(NumericalSample sample, DistributionFactoryCollection factoryCollection) -> Distribution
        BestModelChiSquared(NumericalSample sample, DistributionCollection distributionCollection) -> Distribution
        """
        return _stattests.FittingTest_BestModelChiSquared(*args)

    if _newclass:BestModelChiSquared = staticmethod(BestModelChiSquared)
    __swig_getmethods__["BestModelChiSquared"] = lambda x: BestModelChiSquared
    def BIC(*args):
        """
        BIC(NumericalSample sample, Distribution distribution, OT::UnsignedLong const estimatedParameters=0) -> OT::NumericalScalar
        BIC(NumericalSample sample, Distribution distribution) -> OT::NumericalScalar
        BIC(NumericalSample sample, DistributionFactory factory) -> OT::NumericalScalar
        """
        return _stattests.FittingTest_BIC(*args)

    if _newclass:BIC = staticmethod(BIC)
    __swig_getmethods__["BIC"] = lambda x: BIC
    def Kolmogorov(*args):
        """
        Kolmogorov(NumericalSample sample, Distribution distribution, OT::NumericalScalar const level=0.95, 
            OT::UnsignedLong const estimatedParameters=0) -> TestResult
        Kolmogorov(NumericalSample sample, Distribution distribution, OT::NumericalScalar const level=0.95) -> TestResult
        Kolmogorov(NumericalSample sample, Distribution distribution) -> TestResult
        Kolmogorov(NumericalSample sample, DistributionFactory factory, OT::NumericalScalar const level=0.95) -> TestResult
        Kolmogorov(NumericalSample sample, DistributionFactory factory) -> TestResult
        """
        return _stattests.FittingTest_Kolmogorov(*args)

    if _newclass:Kolmogorov = staticmethod(Kolmogorov)
    __swig_getmethods__["Kolmogorov"] = lambda x: Kolmogorov
    def ChiSquared(*args):
        """
        ChiSquared(NumericalSample sample, Distribution distribution, OT::NumericalScalar const level=0.95, 
            OT::UnsignedLong const estimatedParameters=0) -> TestResult
        ChiSquared(NumericalSample sample, Distribution distribution, OT::NumericalScalar const level=0.95) -> TestResult
        ChiSquared(NumericalSample sample, Distribution distribution) -> TestResult
        ChiSquared(NumericalSample sample, DistributionFactory factory, OT::NumericalScalar const level=0.95) -> TestResult
        ChiSquared(NumericalSample sample, DistributionFactory factory) -> TestResult
        """
        return _stattests.FittingTest_ChiSquared(*args)

    if _newclass:ChiSquared = staticmethod(ChiSquared)
    __swig_getmethods__["ChiSquared"] = lambda x: ChiSquared
    def GetLastResult():
        """GetLastResult() -> TestResult"""
        return _stattests.FittingTest_GetLastResult()

    if _newclass:GetLastResult = staticmethod(GetLastResult)
    __swig_getmethods__["GetLastResult"] = lambda x: GetLastResult
    __swig_destroy__ = _stattests.delete_FittingTest
    __del__ = lambda self : None;
FittingTest_swigregister = _stattests.FittingTest_swigregister
FittingTest_swigregister(FittingTest)

def FittingTest_BestModelBIC(*args):
  """
    BestModelBIC(NumericalSample sample, DistributionFactoryCollection factoryCollection) -> Distribution
    FittingTest_BestModelBIC(NumericalSample sample, DistributionCollection distributionCollection) -> Distribution
    """
  return _stattests.FittingTest_BestModelBIC(*args)

def FittingTest_BestModelKolmogorov(*args):
  """
    BestModelKolmogorov(NumericalSample sample, DistributionFactoryCollection factoryCollection) -> Distribution
    FittingTest_BestModelKolmogorov(NumericalSample sample, DistributionCollection distributionCollection) -> Distribution
    """
  return _stattests.FittingTest_BestModelKolmogorov(*args)

def FittingTest_BestModelChiSquared(*args):
  """
    BestModelChiSquared(NumericalSample sample, DistributionFactoryCollection factoryCollection) -> Distribution
    FittingTest_BestModelChiSquared(NumericalSample sample, DistributionCollection distributionCollection) -> Distribution
    """
  return _stattests.FittingTest_BestModelChiSquared(*args)

def FittingTest_BIC(*args):
  """
    BIC(NumericalSample sample, Distribution distribution, OT::UnsignedLong const estimatedParameters=0) -> OT::NumericalScalar
    BIC(NumericalSample sample, Distribution distribution) -> OT::NumericalScalar
    FittingTest_BIC(NumericalSample sample, DistributionFactory factory) -> OT::NumericalScalar
    """
  return _stattests.FittingTest_BIC(*args)

def FittingTest_Kolmogorov(*args):
  """
    Kolmogorov(NumericalSample sample, Distribution distribution, OT::NumericalScalar const level=0.95, 
        OT::UnsignedLong const estimatedParameters=0) -> TestResult
    Kolmogorov(NumericalSample sample, Distribution distribution, OT::NumericalScalar const level=0.95) -> TestResult
    Kolmogorov(NumericalSample sample, Distribution distribution) -> TestResult
    Kolmogorov(NumericalSample sample, DistributionFactory factory, OT::NumericalScalar const level=0.95) -> TestResult
    FittingTest_Kolmogorov(NumericalSample sample, DistributionFactory factory) -> TestResult
    """
  return _stattests.FittingTest_Kolmogorov(*args)

def FittingTest_ChiSquared(*args):
  """
    ChiSquared(NumericalSample sample, Distribution distribution, OT::NumericalScalar const level=0.95, 
        OT::UnsignedLong const estimatedParameters=0) -> TestResult
    ChiSquared(NumericalSample sample, Distribution distribution, OT::NumericalScalar const level=0.95) -> TestResult
    ChiSquared(NumericalSample sample, Distribution distribution) -> TestResult
    ChiSquared(NumericalSample sample, DistributionFactory factory, OT::NumericalScalar const level=0.95) -> TestResult
    FittingTest_ChiSquared(NumericalSample sample, DistributionFactory factory) -> TestResult
    """
  return _stattests.FittingTest_ChiSquared(*args)

def FittingTest_GetLastResult():
  """FittingTest_GetLastResult() -> TestResult"""
  return _stattests.FittingTest_GetLastResult()

class TestResultCollection(_object):
    """Proxy of C++ OT::Collection<(OT::TestResult)> class"""
    __swig_setmethods__ = {}
    __setattr__ = lambda self, name, value: _swig_setattr(self, TestResultCollection, name, value)
    __swig_getmethods__ = {}
    __getattr__ = lambda self, name: _swig_getattr(self, TestResultCollection, name)
    __swig_destroy__ = _stattests.delete_TestResultCollection
    __del__ = lambda self : None;
    def clear(self):
        """clear(TestResultCollection self)"""
        return _stattests.TestResultCollection_clear(self)

    def __len__(self):
        """__len__(TestResultCollection self) -> OT::UnsignedLong"""
        return _stattests.TestResultCollection___len__(self)

    def __eq__(self, *args):
        """__eq__(TestResultCollection self, TestResultCollection rhs) -> OT::Bool"""
        return _stattests.TestResultCollection___eq__(self, *args)

    def __contains__(self, *args):
        """__contains__(TestResultCollection self, TestResult val) -> OT::Bool"""
        return _stattests.TestResultCollection___contains__(self, *args)

    def __getitem__(self, *args):
        """__getitem__(TestResultCollection self, OT::UnsignedLong const i) -> TestResult"""
        return _stattests.TestResultCollection___getitem__(self, *args)

    def __setitem__(self, *args):
        """__setitem__(TestResultCollection self, OT::UnsignedLong const i, TestResult val)"""
        return _stattests.TestResultCollection___setitem__(self, *args)

    def __delitem__(self, *args):
        """__delitem__(TestResultCollection self, OT::UnsignedLong const i)"""
        return _stattests.TestResultCollection___delitem__(self, *args)

    def at(self, *args):
        """
        at(TestResultCollection self, OT::UnsignedLong const i) -> TestResult
        at(TestResultCollection self, OT::UnsignedLong const i) -> TestResult
        """
        return _stattests.TestResultCollection_at(self, *args)

    def add(self, *args):
        """
        add(TestResultCollection self, TestResult elt)
        add(TestResultCollection self, TestResultCollection coll)
        """
        return _stattests.TestResultCollection_add(self, *args)

    def getSize(self):
        """getSize(TestResultCollection self) -> OT::UnsignedLong"""
        return _stattests.TestResultCollection_getSize(self)

    def resize(self, *args):
        """resize(TestResultCollection self, OT::UnsignedLong const newSize)"""
        return _stattests.TestResultCollection_resize(self, *args)

    def isEmpty(self):
        """isEmpty(TestResultCollection self) -> OT::Bool"""
        return _stattests.TestResultCollection_isEmpty(self)

    def __repr__(self):
        """__repr__(TestResultCollection self) -> OT::String"""
        return _stattests.TestResultCollection___repr__(self)

    def __str__(self, offset=""):
        """
        __str__(TestResultCollection self, OT::String const & offset="") -> OT::String
        __str__(TestResultCollection self) -> OT::String
        """
        return _stattests.TestResultCollection___str__(self, offset)

    def __init__(self, *args): 
        """
        __init__(OT::Collection<(OT::TestResult)> self) -> TestResultCollection
        __init__(OT::Collection<(OT::TestResult)> self, OT::UnsignedLong const size) -> TestResultCollection
        __init__(OT::Collection<(OT::TestResult)> self, OT::UnsignedLong const size, TestResult value) -> TestResultCollection
        __init__(OT::Collection<(OT::TestResult)> self, PyObject * pyObj) -> TestResultCollection
        __init__(OT::Collection<(OT::TestResult)> self, TestResultCollection other) -> TestResultCollection
        """
        this = _stattests.new_TestResultCollection(*args)
        try: self.this.append(this)
        except: self.this = this
TestResultCollection_swigregister = _stattests.TestResultCollection_swigregister
TestResultCollection_swigregister(TestResultCollection)

class HypothesisTest(_object):
    """Proxy of C++ OT::HypothesisTest class"""
    __swig_setmethods__ = {}
    __setattr__ = lambda self, name, value: _swig_setattr(self, HypothesisTest, name, value)
    __swig_getmethods__ = {}
    __getattr__ = lambda self, name: _swig_getattr(self, HypothesisTest, name)
    def __init__(self, *args, **kwargs): raise AttributeError("No constructor defined")
    __repr__ = _swig_repr
    def ChiSquared(*args):
        """
        ChiSquared(NumericalSample firstSample, NumericalSample secondSample, OT::NumericalScalar const level=0.95) -> TestResult
        ChiSquared(NumericalSample firstSample, NumericalSample secondSample) -> TestResult
        """
        return _stattests.HypothesisTest_ChiSquared(*args)

    if _newclass:ChiSquared = staticmethod(ChiSquared)
    __swig_getmethods__["ChiSquared"] = lambda x: ChiSquared
    def Pearson(*args):
        """
        Pearson(NumericalSample firstSample, NumericalSample secondSample, OT::NumericalScalar const level=0.95) -> TestResult
        Pearson(NumericalSample firstSample, NumericalSample secondSample) -> TestResult
        """
        return _stattests.HypothesisTest_Pearson(*args)

    if _newclass:Pearson = staticmethod(Pearson)
    __swig_getmethods__["Pearson"] = lambda x: Pearson
    def Smirnov(*args):
        """
        Smirnov(NumericalSample firstSample, NumericalSample secondSample, OT::NumericalScalar const level=0.95) -> TestResult
        Smirnov(NumericalSample firstSample, NumericalSample secondSample) -> TestResult
        """
        return _stattests.HypothesisTest_Smirnov(*args)

    if _newclass:Smirnov = staticmethod(Smirnov)
    __swig_getmethods__["Smirnov"] = lambda x: Smirnov
    def Spearman(*args):
        """
        Spearman(NumericalSample firstSample, NumericalSample secondSample, OT::NumericalScalar const level=0.95) -> TestResult
        Spearman(NumericalSample firstSample, NumericalSample secondSample) -> TestResult
        """
        return _stattests.HypothesisTest_Spearman(*args)

    if _newclass:Spearman = staticmethod(Spearman)
    __swig_getmethods__["Spearman"] = lambda x: Spearman
    def PartialPearson(*args):
        """
        PartialPearson(NumericalSample firstSample, NumericalSample secondSample, Indices selection, OT::NumericalScalar const level=0.95) -> TestResultCollection
        PartialPearson(NumericalSample firstSample, NumericalSample secondSample, Indices selection) -> TestResultCollection
        """
        return _stattests.HypothesisTest_PartialPearson(*args)

    if _newclass:PartialPearson = staticmethod(PartialPearson)
    __swig_getmethods__["PartialPearson"] = lambda x: PartialPearson
    def PartialRegression(*args):
        """
        PartialRegression(NumericalSample firstSample, NumericalSample secondSample, Indices selection, OT::NumericalScalar const level=0.95) -> TestResultCollection
        PartialRegression(NumericalSample firstSample, NumericalSample secondSample, Indices selection) -> TestResultCollection
        """
        return _stattests.HypothesisTest_PartialRegression(*args)

    if _newclass:PartialRegression = staticmethod(PartialRegression)
    __swig_getmethods__["PartialRegression"] = lambda x: PartialRegression
    def PartialSpearman(*args):
        """
        PartialSpearman(NumericalSample firstSample, NumericalSample secondSample, Indices selection, OT::NumericalScalar const level=0.95) -> TestResultCollection
        PartialSpearman(NumericalSample firstSample, NumericalSample secondSample, Indices selection) -> TestResultCollection
        """
        return _stattests.HypothesisTest_PartialSpearman(*args)

    if _newclass:PartialSpearman = staticmethod(PartialSpearman)
    __swig_getmethods__["PartialSpearman"] = lambda x: PartialSpearman
    def FullPearson(*args):
        """
        FullPearson(NumericalSample firstSample, NumericalSample secondSample, OT::NumericalScalar const level=0.95) -> TestResultCollection
        FullPearson(NumericalSample firstSample, NumericalSample secondSample) -> TestResultCollection
        """
        return _stattests.HypothesisTest_FullPearson(*args)

    if _newclass:FullPearson = staticmethod(FullPearson)
    __swig_getmethods__["FullPearson"] = lambda x: FullPearson
    def FullRegression(*args):
        """
        FullRegression(NumericalSample firstSample, NumericalSample secondSample, OT::NumericalScalar const level=0.95) -> TestResultCollection
        FullRegression(NumericalSample firstSample, NumericalSample secondSample) -> TestResultCollection
        """
        return _stattests.HypothesisTest_FullRegression(*args)

    if _newclass:FullRegression = staticmethod(FullRegression)
    __swig_getmethods__["FullRegression"] = lambda x: FullRegression
    def FullSpearman(*args):
        """
        FullSpearman(NumericalSample firstSample, NumericalSample secondSample, OT::NumericalScalar const level=0.95) -> TestResultCollection
        FullSpearman(NumericalSample firstSample, NumericalSample secondSample) -> TestResultCollection
        """
        return _stattests.HypothesisTest_FullSpearman(*args)

    if _newclass:FullSpearman = staticmethod(FullSpearman)
    __swig_getmethods__["FullSpearman"] = lambda x: FullSpearman
    __swig_destroy__ = _stattests.delete_HypothesisTest
    __del__ = lambda self : None;
HypothesisTest_swigregister = _stattests.HypothesisTest_swigregister
HypothesisTest_swigregister(HypothesisTest)

def HypothesisTest_ChiSquared(*args):
  """
    ChiSquared(NumericalSample firstSample, NumericalSample secondSample, OT::NumericalScalar const level=0.95) -> TestResult
    HypothesisTest_ChiSquared(NumericalSample firstSample, NumericalSample secondSample) -> TestResult
    """
  return _stattests.HypothesisTest_ChiSquared(*args)

def HypothesisTest_Pearson(*args):
  """
    Pearson(NumericalSample firstSample, NumericalSample secondSample, OT::NumericalScalar const level=0.95) -> TestResult
    HypothesisTest_Pearson(NumericalSample firstSample, NumericalSample secondSample) -> TestResult
    """
  return _stattests.HypothesisTest_Pearson(*args)

def HypothesisTest_Smirnov(*args):
  """
    Smirnov(NumericalSample firstSample, NumericalSample secondSample, OT::NumericalScalar const level=0.95) -> TestResult
    HypothesisTest_Smirnov(NumericalSample firstSample, NumericalSample secondSample) -> TestResult
    """
  return _stattests.HypothesisTest_Smirnov(*args)

def HypothesisTest_Spearman(*args):
  """
    Spearman(NumericalSample firstSample, NumericalSample secondSample, OT::NumericalScalar const level=0.95) -> TestResult
    HypothesisTest_Spearman(NumericalSample firstSample, NumericalSample secondSample) -> TestResult
    """
  return _stattests.HypothesisTest_Spearman(*args)

def HypothesisTest_PartialPearson(*args):
  """
    PartialPearson(NumericalSample firstSample, NumericalSample secondSample, Indices selection, OT::NumericalScalar const level=0.95) -> TestResultCollection
    HypothesisTest_PartialPearson(NumericalSample firstSample, NumericalSample secondSample, Indices selection) -> TestResultCollection
    """
  return _stattests.HypothesisTest_PartialPearson(*args)

def HypothesisTest_PartialRegression(*args):
  """
    PartialRegression(NumericalSample firstSample, NumericalSample secondSample, Indices selection, OT::NumericalScalar const level=0.95) -> TestResultCollection
    HypothesisTest_PartialRegression(NumericalSample firstSample, NumericalSample secondSample, Indices selection) -> TestResultCollection
    """
  return _stattests.HypothesisTest_PartialRegression(*args)

def HypothesisTest_PartialSpearman(*args):
  """
    PartialSpearman(NumericalSample firstSample, NumericalSample secondSample, Indices selection, OT::NumericalScalar const level=0.95) -> TestResultCollection
    HypothesisTest_PartialSpearman(NumericalSample firstSample, NumericalSample secondSample, Indices selection) -> TestResultCollection
    """
  return _stattests.HypothesisTest_PartialSpearman(*args)

def HypothesisTest_FullPearson(*args):
  """
    FullPearson(NumericalSample firstSample, NumericalSample secondSample, OT::NumericalScalar const level=0.95) -> TestResultCollection
    HypothesisTest_FullPearson(NumericalSample firstSample, NumericalSample secondSample) -> TestResultCollection
    """
  return _stattests.HypothesisTest_FullPearson(*args)

def HypothesisTest_FullRegression(*args):
  """
    FullRegression(NumericalSample firstSample, NumericalSample secondSample, OT::NumericalScalar const level=0.95) -> TestResultCollection
    HypothesisTest_FullRegression(NumericalSample firstSample, NumericalSample secondSample) -> TestResultCollection
    """
  return _stattests.HypothesisTest_FullRegression(*args)

def HypothesisTest_FullSpearman(*args):
  """
    FullSpearman(NumericalSample firstSample, NumericalSample secondSample, OT::NumericalScalar const level=0.95) -> TestResultCollection
    HypothesisTest_FullSpearman(NumericalSample firstSample, NumericalSample secondSample) -> TestResultCollection
    """
  return _stattests.HypothesisTest_FullSpearman(*args)

class LinearModelTest(_object):
    """Proxy of C++ OT::LinearModelTest class"""
    __swig_setmethods__ = {}
    __setattr__ = lambda self, name, value: _swig_setattr(self, LinearModelTest, name, value)
    __swig_getmethods__ = {}
    __getattr__ = lambda self, name: _swig_getattr(self, LinearModelTest, name)
    def __init__(self, *args, **kwargs): raise AttributeError("No constructor defined")
    __repr__ = _swig_repr
    def LinearModelAdjustedRSquared(*args):
        """
        LinearModelAdjustedRSquared(NumericalSample firstSample, NumericalSample secondSample, LinearModel linearModel, 
            OT::NumericalScalar const level=0.95) -> TestResult
        LinearModelAdjustedRSquared(NumericalSample firstSample, NumericalSample secondSample, LinearModel linearModel) -> TestResult
        LinearModelAdjustedRSquared(NumericalSample firstSample, NumericalSample secondSample, OT::NumericalScalar const level=0.95) -> TestResult
        LinearModelAdjustedRSquared(NumericalSample firstSample, NumericalSample secondSample) -> TestResult
        """
        return _stattests.LinearModelTest_LinearModelAdjustedRSquared(*args)

    if _newclass:LinearModelAdjustedRSquared = staticmethod(LinearModelAdjustedRSquared)
    __swig_getmethods__["LinearModelAdjustedRSquared"] = lambda x: LinearModelAdjustedRSquared
    def LinearModelFisher(*args):
        """
        LinearModelFisher(NumericalSample firstSample, NumericalSample secondSample, LinearModel linearModel, 
            OT::NumericalScalar const level=0.95) -> TestResult
        LinearModelFisher(NumericalSample firstSample, NumericalSample secondSample, LinearModel linearModel) -> TestResult
        LinearModelFisher(NumericalSample firstSample, NumericalSample secondSample, OT::NumericalScalar const level=0.95) -> TestResult
        LinearModelFisher(NumericalSample firstSample, NumericalSample secondSample) -> TestResult
        """
        return _stattests.LinearModelTest_LinearModelFisher(*args)

    if _newclass:LinearModelFisher = staticmethod(LinearModelFisher)
    __swig_getmethods__["LinearModelFisher"] = lambda x: LinearModelFisher
    def LinearModelResidualMean(*args):
        """
        LinearModelResidualMean(NumericalSample firstSample, NumericalSample secondSample, LinearModel linearModel, 
            OT::NumericalScalar const level=0.95) -> TestResult
        LinearModelResidualMean(NumericalSample firstSample, NumericalSample secondSample, LinearModel linearModel) -> TestResult
        LinearModelResidualMean(NumericalSample firstSample, NumericalSample secondSample, OT::NumericalScalar const level=0.95) -> TestResult
        LinearModelResidualMean(NumericalSample firstSample, NumericalSample secondSample) -> TestResult
        """
        return _stattests.LinearModelTest_LinearModelResidualMean(*args)

    if _newclass:LinearModelResidualMean = staticmethod(LinearModelResidualMean)
    __swig_getmethods__["LinearModelResidualMean"] = lambda x: LinearModelResidualMean
    def LinearModelRSquared(*args):
        """
        LinearModelRSquared(NumericalSample firstSample, NumericalSample secondSample, LinearModel linearModel, 
            OT::NumericalScalar const level=0.95) -> TestResult
        LinearModelRSquared(NumericalSample firstSample, NumericalSample secondSample, LinearModel linearModel) -> TestResult
        LinearModelRSquared(NumericalSample firstSample, NumericalSample secondSample, OT::NumericalScalar const level=0.95) -> TestResult
        LinearModelRSquared(NumericalSample firstSample, NumericalSample secondSample) -> TestResult
        """
        return _stattests.LinearModelTest_LinearModelRSquared(*args)

    if _newclass:LinearModelRSquared = staticmethod(LinearModelRSquared)
    __swig_getmethods__["LinearModelRSquared"] = lambda x: LinearModelRSquared
    __swig_destroy__ = _stattests.delete_LinearModelTest
    __del__ = lambda self : None;
LinearModelTest_swigregister = _stattests.LinearModelTest_swigregister
LinearModelTest_swigregister(LinearModelTest)

def LinearModelTest_LinearModelAdjustedRSquared(*args):
  """
    LinearModelAdjustedRSquared(NumericalSample firstSample, NumericalSample secondSample, LinearModel linearModel, 
        OT::NumericalScalar const level=0.95) -> TestResult
    LinearModelAdjustedRSquared(NumericalSample firstSample, NumericalSample secondSample, LinearModel linearModel) -> TestResult
    LinearModelAdjustedRSquared(NumericalSample firstSample, NumericalSample secondSample, OT::NumericalScalar const level=0.95) -> TestResult
    LinearModelTest_LinearModelAdjustedRSquared(NumericalSample firstSample, NumericalSample secondSample) -> TestResult
    """
  return _stattests.LinearModelTest_LinearModelAdjustedRSquared(*args)

def LinearModelTest_LinearModelFisher(*args):
  """
    LinearModelFisher(NumericalSample firstSample, NumericalSample secondSample, LinearModel linearModel, 
        OT::NumericalScalar const level=0.95) -> TestResult
    LinearModelFisher(NumericalSample firstSample, NumericalSample secondSample, LinearModel linearModel) -> TestResult
    LinearModelFisher(NumericalSample firstSample, NumericalSample secondSample, OT::NumericalScalar const level=0.95) -> TestResult
    LinearModelTest_LinearModelFisher(NumericalSample firstSample, NumericalSample secondSample) -> TestResult
    """
  return _stattests.LinearModelTest_LinearModelFisher(*args)

def LinearModelTest_LinearModelResidualMean(*args):
  """
    LinearModelResidualMean(NumericalSample firstSample, NumericalSample secondSample, LinearModel linearModel, 
        OT::NumericalScalar const level=0.95) -> TestResult
    LinearModelResidualMean(NumericalSample firstSample, NumericalSample secondSample, LinearModel linearModel) -> TestResult
    LinearModelResidualMean(NumericalSample firstSample, NumericalSample secondSample, OT::NumericalScalar const level=0.95) -> TestResult
    LinearModelTest_LinearModelResidualMean(NumericalSample firstSample, NumericalSample secondSample) -> TestResult
    """
  return _stattests.LinearModelTest_LinearModelResidualMean(*args)

def LinearModelTest_LinearModelRSquared(*args):
  """
    LinearModelRSquared(NumericalSample firstSample, NumericalSample secondSample, LinearModel linearModel, 
        OT::NumericalScalar const level=0.95) -> TestResult
    LinearModelRSquared(NumericalSample firstSample, NumericalSample secondSample, LinearModel linearModel) -> TestResult
    LinearModelRSquared(NumericalSample firstSample, NumericalSample secondSample, OT::NumericalScalar const level=0.95) -> TestResult
    LinearModelTest_LinearModelRSquared(NumericalSample firstSample, NumericalSample secondSample) -> TestResult
    """
  return _stattests.LinearModelTest_LinearModelRSquared(*args)

class NormalityTest(_object):
    """Proxy of C++ OT::NormalityTest class"""
    __swig_setmethods__ = {}
    __setattr__ = lambda self, name, value: _swig_setattr(self, NormalityTest, name, value)
    __swig_getmethods__ = {}
    __getattr__ = lambda self, name: _swig_getattr(self, NormalityTest, name)
    def __init__(self, *args, **kwargs): raise AttributeError("No constructor defined")
    __repr__ = _swig_repr
    def AndersonDarlingNormal(*args):
        """
        AndersonDarlingNormal(NumericalSample sample, OT::NumericalScalar const level=0.95) -> TestResult
        AndersonDarlingNormal(NumericalSample sample) -> TestResult
        """
        return _stattests.NormalityTest_AndersonDarlingNormal(*args)

    if _newclass:AndersonDarlingNormal = staticmethod(AndersonDarlingNormal)
    __swig_getmethods__["AndersonDarlingNormal"] = lambda x: AndersonDarlingNormal
    def CramerVonMisesNormal(*args):
        """
        CramerVonMisesNormal(NumericalSample sample, OT::NumericalScalar const level=0.95) -> TestResult
        CramerVonMisesNormal(NumericalSample sample) -> TestResult
        """
        return _stattests.NormalityTest_CramerVonMisesNormal(*args)

    if _newclass:CramerVonMisesNormal = staticmethod(CramerVonMisesNormal)
    __swig_getmethods__["CramerVonMisesNormal"] = lambda x: CramerVonMisesNormal
    __swig_destroy__ = _stattests.delete_NormalityTest
    __del__ = lambda self : None;
NormalityTest_swigregister = _stattests.NormalityTest_swigregister
NormalityTest_swigregister(NormalityTest)

def NormalityTest_AndersonDarlingNormal(*args):
  """
    AndersonDarlingNormal(NumericalSample sample, OT::NumericalScalar const level=0.95) -> TestResult
    NormalityTest_AndersonDarlingNormal(NumericalSample sample) -> TestResult
    """
  return _stattests.NormalityTest_AndersonDarlingNormal(*args)

def NormalityTest_CramerVonMisesNormal(*args):
  """
    CramerVonMisesNormal(NumericalSample sample, OT::NumericalScalar const level=0.95) -> TestResult
    NormalityTest_CramerVonMisesNormal(NumericalSample sample) -> TestResult
    """
  return _stattests.NormalityTest_CramerVonMisesNormal(*args)

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

    if _newclass:GetClassName = staticmethod(GetClassName)
    __swig_getmethods__["GetClassName"] = lambda x: GetClassName
    def getClassName(self):
        """getClassName(DickeyFullerTest self) -> OT::String"""
        return _stattests.DickeyFullerTest_getClassName(self)

    def testUnitRootInDriftAndLinearTrendModel(self, level=0.95):
        """
        testUnitRootInDriftAndLinearTrendModel(DickeyFullerTest self, OT::NumericalScalar const level=0.95) -> TestResult
        testUnitRootInDriftAndLinearTrendModel(DickeyFullerTest self) -> TestResult
        """
        return _stattests.DickeyFullerTest_testUnitRootInDriftAndLinearTrendModel(self, level)

    def testUnitRootInDriftModel(self, level=0.95):
        """
        testUnitRootInDriftModel(DickeyFullerTest self, OT::NumericalScalar const level=0.95) -> TestResult
        testUnitRootInDriftModel(DickeyFullerTest self) -> TestResult
        """
        return _stattests.DickeyFullerTest_testUnitRootInDriftModel(self, level)

    def testUnitRootInAR1Model(self, level=0.95):
        """
        testUnitRootInAR1Model(DickeyFullerTest self, OT::NumericalScalar const level=0.95) -> TestResult
        testUnitRootInAR1Model(DickeyFullerTest self) -> TestResult
        """
        return _stattests.DickeyFullerTest_testUnitRootInAR1Model(self, level)

    def runStrategy(self, level=0.95):
        """
        runStrategy(DickeyFullerTest self, OT::NumericalScalar const level=0.95) -> TestResult
        runStrategy(DickeyFullerTest self) -> TestResult
        """
        return _stattests.DickeyFullerTest_runStrategy(self, level)

    def testUnitRootAndNoLinearTrendInDriftAndLinearTrendModel(self, level=0.95):
        """
        testUnitRootAndNoLinearTrendInDriftAndLinearTrendModel(DickeyFullerTest self, OT::NumericalScalar const level=0.95) -> TestResult
        testUnitRootAndNoLinearTrendInDriftAndLinearTrendModel(DickeyFullerTest self) -> TestResult
        """
        return _stattests.DickeyFullerTest_testUnitRootAndNoLinearTrendInDriftAndLinearTrendModel(self, level)

    def testNoUnitRootAndNoLinearTrendInDriftAndLinearTrendModel(self, level=0.95):
        """
        testNoUnitRootAndNoLinearTrendInDriftAndLinearTrendModel(DickeyFullerTest self, OT::NumericalScalar const level=0.95) -> TestResult
        testNoUnitRootAndNoLinearTrendInDriftAndLinearTrendModel(DickeyFullerTest self) -> TestResult
        """
        return _stattests.DickeyFullerTest_testNoUnitRootAndNoLinearTrendInDriftAndLinearTrendModel(self, level)

    def testUnitRootAndNoDriftInDriftModel(self, level=0.95):
        """
        testUnitRootAndNoDriftInDriftModel(DickeyFullerTest self, OT::NumericalScalar const level=0.95) -> TestResult
        testUnitRootAndNoDriftInDriftModel(DickeyFullerTest self) -> TestResult
        """
        return _stattests.DickeyFullerTest_testUnitRootAndNoDriftInDriftModel(self, level)

    def testNoUnitRootAndNoDriftInDriftModel(self, level=0.95):
        """
        testNoUnitRootAndNoDriftInDriftModel(DickeyFullerTest self, OT::NumericalScalar const level=0.95) -> TestResult
        testNoUnitRootAndNoDriftInDriftModel(DickeyFullerTest self) -> TestResult
        """
        return _stattests.DickeyFullerTest_testNoUnitRootAndNoDriftInDriftModel(self, level)

    def setVerbose(self, *args):
        """setVerbose(DickeyFullerTest self, OT::Bool const verbose)"""
        return _stattests.DickeyFullerTest_setVerbose(self, *args)

    def getVerbose(self):
        """getVerbose(DickeyFullerTest self) -> OT::Bool"""
        return _stattests.DickeyFullerTest_getVerbose(self)

    def __init__(self, *args): 
        """
        __init__(OT::DickeyFullerTest self, OT::String const & name=DefaultName) -> DickeyFullerTest
        __init__(OT::DickeyFullerTest self) -> DickeyFullerTest
        __init__(OT::DickeyFullerTest self, TimeSeries series, OT::Bool const verbose=True, OT::String const & name=DefaultName) -> DickeyFullerTest
        __init__(OT::DickeyFullerTest self, TimeSeries series, OT::Bool const verbose=True) -> DickeyFullerTest
        __init__(OT::DickeyFullerTest self, TimeSeries series) -> DickeyFullerTest
        __init__(OT::DickeyFullerTest self, DickeyFullerTest other) -> DickeyFullerTest
        """
        this = _stattests.new_DickeyFullerTest(*args)
        try: self.this.append(this)
        except: self.this = this
    __swig_destroy__ = _stattests.delete_DickeyFullerTest
    __del__ = lambda self : None;
DickeyFullerTest_swigregister = _stattests.DickeyFullerTest_swigregister
DickeyFullerTest_swigregister(DickeyFullerTest)

def DickeyFullerTest_GetClassName():
  """DickeyFullerTest_GetClassName() -> OT::String"""
  return _stattests.DickeyFullerTest_GetClassName()

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