python-openturns 1.3-3 / usr / lib / python2.7 / dist-packages / openturns / algo.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.




"""
Approximation algorithms.
"""


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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

    if _newclass:GetClassName = staticmethod(GetClassName)
    __swig_getmethods__["GetClassName"] = lambda x: GetClassName
    def getClassName(self):
        """getClassName(ApproximationAlgorithmImplementation self) -> OT::String"""
        return _algo.ApproximationAlgorithmImplementation_getClassName(self)

    def getX(self):
        """getX(ApproximationAlgorithmImplementation self) -> NumericalSample"""
        return _algo.ApproximationAlgorithmImplementation_getX(self)

    def getY(self):
        """getY(ApproximationAlgorithmImplementation self) -> NumericalSample"""
        return _algo.ApproximationAlgorithmImplementation_getY(self)

    def getWeight(self):
        """getWeight(ApproximationAlgorithmImplementation self) -> NumericalPoint"""
        return _algo.ApproximationAlgorithmImplementation_getWeight(self)

    def getPsi(self):
        """getPsi(ApproximationAlgorithmImplementation self) -> Basis"""
        return _algo.ApproximationAlgorithmImplementation_getPsi(self)

    def __repr__(self):
        """__repr__(ApproximationAlgorithmImplementation self) -> OT::String"""
        return _algo.ApproximationAlgorithmImplementation___repr__(self)

    def __str__(self, offset=""):
        """
        __str__(ApproximationAlgorithmImplementation self, OT::String const & offset="") -> OT::String
        __str__(ApproximationAlgorithmImplementation self) -> OT::String
        """
        return _algo.ApproximationAlgorithmImplementation___str__(self, offset)

    def run(self):
        """run(ApproximationAlgorithmImplementation self)"""
        return _algo.ApproximationAlgorithmImplementation_run(self)

    def getCoefficients(self):
        """getCoefficients(ApproximationAlgorithmImplementation self) -> NumericalPoint"""
        return _algo.ApproximationAlgorithmImplementation_getCoefficients(self)

    def getResidual(self):
        """getResidual(ApproximationAlgorithmImplementation self) -> OT::NumericalScalar"""
        return _algo.ApproximationAlgorithmImplementation_getResidual(self)

    def getRelativeError(self):
        """getRelativeError(ApproximationAlgorithmImplementation self) -> OT::NumericalScalar"""
        return _algo.ApproximationAlgorithmImplementation_getRelativeError(self)

    def setVerbose(self, *args):
        """setVerbose(ApproximationAlgorithmImplementation self, OT::Bool const verbose)"""
        return _algo.ApproximationAlgorithmImplementation_setVerbose(self, *args)

    def getVerbose(self):
        """getVerbose(ApproximationAlgorithmImplementation self) -> OT::Bool"""
        return _algo.ApproximationAlgorithmImplementation_getVerbose(self)

    def __init__(self, *args): 
        """
        __init__(OT::ApproximationAlgorithmImplementation self) -> ApproximationAlgorithmImplementation
        __init__(OT::ApproximationAlgorithmImplementation self, NumericalSample x, NumericalSample y, Basis psi) -> ApproximationAlgorithmImplementation
        __init__(OT::ApproximationAlgorithmImplementation self, NumericalSample x, NumericalSample y, NumericalPoint weight, Basis psi) -> ApproximationAlgorithmImplementation
        __init__(OT::ApproximationAlgorithmImplementation self, ApproximationAlgorithmImplementation other) -> ApproximationAlgorithmImplementation
        """
        this = _algo.new_ApproximationAlgorithmImplementation(*args)
        try: self.this.append(this)
        except: self.this = this
    __swig_destroy__ = _algo.delete_ApproximationAlgorithmImplementation
    __del__ = lambda self : None;
ApproximationAlgorithmImplementation_swigregister = _algo.ApproximationAlgorithmImplementation_swigregister
ApproximationAlgorithmImplementation_swigregister(ApproximationAlgorithmImplementation)

def ApproximationAlgorithmImplementation_GetClassName():
  """ApproximationAlgorithmImplementation_GetClassName() -> OT::String"""
  return _algo.ApproximationAlgorithmImplementation_GetClassName()

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

    def getImplementationAsPersistentObject(self):
        """getImplementationAsPersistentObject(ApproximationAlgorithmImplementationTypedInterfaceObject self) -> PersistentObjectPointer"""
        return _algo.ApproximationAlgorithmImplementationTypedInterfaceObject_getImplementationAsPersistentObject(self)

    def setImplementationAsPersistentObject(self, *args):
        """setImplementationAsPersistentObject(ApproximationAlgorithmImplementationTypedInterfaceObject self, PersistentObjectPointer obj)"""
        return _algo.ApproximationAlgorithmImplementationTypedInterfaceObject_setImplementationAsPersistentObject(self, *args)

    def swap(self, *args):
        """swap(ApproximationAlgorithmImplementationTypedInterfaceObject self, ApproximationAlgorithmImplementationTypedInterfaceObject other)"""
        return _algo.ApproximationAlgorithmImplementationTypedInterfaceObject_swap(self, *args)

    def setName(self, *args):
        """setName(ApproximationAlgorithmImplementationTypedInterfaceObject self, OT::String const & name)"""
        return _algo.ApproximationAlgorithmImplementationTypedInterfaceObject_setName(self, *args)

    def getName(self):
        """getName(ApproximationAlgorithmImplementationTypedInterfaceObject self) -> OT::String"""
        return _algo.ApproximationAlgorithmImplementationTypedInterfaceObject_getName(self)

    def __eq__(self, *args):
        """__eq__(ApproximationAlgorithmImplementationTypedInterfaceObject self, ApproximationAlgorithmImplementationTypedInterfaceObject other) -> OT::Bool"""
        return _algo.ApproximationAlgorithmImplementationTypedInterfaceObject___eq__(self, *args)

    __swig_destroy__ = _algo.delete_ApproximationAlgorithmImplementationTypedInterfaceObject
    __del__ = lambda self : None;
ApproximationAlgorithmImplementationTypedInterfaceObject_swigregister = _algo.ApproximationAlgorithmImplementationTypedInterfaceObject_swigregister
ApproximationAlgorithmImplementationTypedInterfaceObject_swigregister(ApproximationAlgorithmImplementationTypedInterfaceObject)

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

    if _newclass:GetClassName = staticmethod(GetClassName)
    __swig_getmethods__["GetClassName"] = lambda x: GetClassName
    def getClassName(self):
        """getClassName(ApproximationAlgorithm self) -> OT::String"""
        return _algo.ApproximationAlgorithm_getClassName(self)

    def getX(self):
        """getX(ApproximationAlgorithm self) -> NumericalSample"""
        return _algo.ApproximationAlgorithm_getX(self)

    def getY(self):
        """getY(ApproximationAlgorithm self) -> NumericalSample"""
        return _algo.ApproximationAlgorithm_getY(self)

    def getWeight(self):
        """getWeight(ApproximationAlgorithm self) -> NumericalPoint"""
        return _algo.ApproximationAlgorithm_getWeight(self)

    def getPsi(self):
        """getPsi(ApproximationAlgorithm self) -> Basis"""
        return _algo.ApproximationAlgorithm_getPsi(self)

    def setVerbose(self, *args):
        """setVerbose(ApproximationAlgorithm self, OT::Bool const verbose)"""
        return _algo.ApproximationAlgorithm_setVerbose(self, *args)

    def getVerbose(self):
        """getVerbose(ApproximationAlgorithm self) -> OT::Bool"""
        return _algo.ApproximationAlgorithm_getVerbose(self)

    def __repr__(self):
        """__repr__(ApproximationAlgorithm self) -> OT::String"""
        return _algo.ApproximationAlgorithm___repr__(self)

    def __str__(self, offset=""):
        """
        __str__(ApproximationAlgorithm self, OT::String const & offset="") -> OT::String
        __str__(ApproximationAlgorithm self) -> OT::String
        """
        return _algo.ApproximationAlgorithm___str__(self, offset)

    def run(self):
        """run(ApproximationAlgorithm self)"""
        return _algo.ApproximationAlgorithm_run(self)

    def getCoefficients(self):
        """getCoefficients(ApproximationAlgorithm self) -> NumericalPoint"""
        return _algo.ApproximationAlgorithm_getCoefficients(self)

    def getResidual(self):
        """getResidual(ApproximationAlgorithm self) -> OT::NumericalScalar"""
        return _algo.ApproximationAlgorithm_getResidual(self)

    def getRelativeError(self):
        """getRelativeError(ApproximationAlgorithm self) -> OT::NumericalScalar"""
        return _algo.ApproximationAlgorithm_getRelativeError(self)

    def __init__(self, *args): 
        """
        __init__(OT::ApproximationAlgorithm self, ApproximationAlgorithmImplementation implementation) -> ApproximationAlgorithm
        __init__(OT::ApproximationAlgorithm self, ApproximationAlgorithmImplementationPointer p_implementation) -> ApproximationAlgorithm
        __init__(OT::ApproximationAlgorithm self, ApproximationAlgorithm other) -> ApproximationAlgorithm
        """
        this = _algo.new_ApproximationAlgorithm(*args)
        try: self.this.append(this)
        except: self.this = this
    __swig_destroy__ = _algo.delete_ApproximationAlgorithm
    __del__ = lambda self : None;
ApproximationAlgorithm_swigregister = _algo.ApproximationAlgorithm_swigregister
ApproximationAlgorithm_swigregister(ApproximationAlgorithm)

def ApproximationAlgorithm_GetClassName():
  """ApproximationAlgorithm_GetClassName() -> OT::String"""
  return _algo.ApproximationAlgorithm_GetClassName()

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

    if _newclass:GetClassName = staticmethod(GetClassName)
    __swig_getmethods__["GetClassName"] = lambda x: GetClassName
    def getClassName(self):
        """getClassName(ApproximationAlgorithmImplementationFactory self) -> OT::String"""
        return _algo.ApproximationAlgorithmImplementationFactory_getClassName(self)

    def build(self, *args):
        """
        build(ApproximationAlgorithmImplementationFactory self, NumericalSample x, NumericalSample y, Basis psi) -> ApproximationAlgorithmImplementation
        build(ApproximationAlgorithmImplementationFactory self, NumericalSample x, NumericalSample y, NumericalPoint weight, Basis psi) -> ApproximationAlgorithmImplementation
        """
        return _algo.ApproximationAlgorithmImplementationFactory_build(self, *args)

    def __repr__(self):
        """__repr__(ApproximationAlgorithmImplementationFactory self) -> OT::String"""
        return _algo.ApproximationAlgorithmImplementationFactory___repr__(self)

    def __init__(self, *args): 
        """
        __init__(OT::ApproximationAlgorithmImplementationFactory self) -> ApproximationAlgorithmImplementationFactory
        __init__(OT::ApproximationAlgorithmImplementationFactory self, ApproximationAlgorithmImplementationFactory other) -> ApproximationAlgorithmImplementationFactory
        """
        this = _algo.new_ApproximationAlgorithmImplementationFactory(*args)
        try: self.this.append(this)
        except: self.this = this
    __swig_destroy__ = _algo.delete_ApproximationAlgorithmImplementationFactory
    __del__ = lambda self : None;
ApproximationAlgorithmImplementationFactory_swigregister = _algo.ApproximationAlgorithmImplementationFactory_swigregister
ApproximationAlgorithmImplementationFactory_swigregister(ApproximationAlgorithmImplementationFactory)

def ApproximationAlgorithmImplementationFactory_GetClassName():
  """ApproximationAlgorithmImplementationFactory_GetClassName() -> OT::String"""
  return _algo.ApproximationAlgorithmImplementationFactory_GetClassName()

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

    if _newclass:GetClassName = staticmethod(GetClassName)
    __swig_getmethods__["GetClassName"] = lambda x: GetClassName
    def getClassName(self):
        """getClassName(ClassifierImplementation self) -> OT::String"""
        return _algo.ClassifierImplementation_getClassName(self)

    def classify(self, *args):
        """
        classify(ClassifierImplementation self, NumericalPoint inP) -> OT::UnsignedLong
        classify(ClassifierImplementation self, NumericalSample inS) -> Indices
        """
        return _algo.ClassifierImplementation_classify(self, *args)

    def grade(self, *args):
        """
        grade(ClassifierImplementation self, NumericalPoint inP, OT::UnsignedLong outC) -> OT::NumericalScalar
        grade(ClassifierImplementation self, NumericalSample inS, Indices outC) -> NumericalPoint
        """
        return _algo.ClassifierImplementation_grade(self, *args)

    def __repr__(self):
        """__repr__(ClassifierImplementation self) -> OT::String"""
        return _algo.ClassifierImplementation___repr__(self)

    def __str__(self, offset=""):
        """
        __str__(ClassifierImplementation self, OT::String const & offset="") -> OT::String
        __str__(ClassifierImplementation self) -> OT::String
        """
        return _algo.ClassifierImplementation___str__(self, offset)

    def setVerbose(self, *args):
        """setVerbose(ClassifierImplementation self, OT::Bool const verbose)"""
        return _algo.ClassifierImplementation_setVerbose(self, *args)

    def getVerbose(self):
        """getVerbose(ClassifierImplementation self) -> OT::Bool"""
        return _algo.ClassifierImplementation_getVerbose(self)

    def getDimension(self):
        """getDimension(ClassifierImplementation self) -> OT::UnsignedLong"""
        return _algo.ClassifierImplementation_getDimension(self)

    def __init__(self, *args): 
        """
        __init__(OT::ClassifierImplementation self) -> ClassifierImplementation
        __init__(OT::ClassifierImplementation self, NumericalSample inputSample, Indices outClasses) -> ClassifierImplementation
        __init__(OT::ClassifierImplementation self, ClassifierImplementation other) -> ClassifierImplementation
        """
        this = _algo.new_ClassifierImplementation(*args)
        try: self.this.append(this)
        except: self.this = this
    __swig_destroy__ = _algo.delete_ClassifierImplementation
    __del__ = lambda self : None;
ClassifierImplementation_swigregister = _algo.ClassifierImplementation_swigregister
ClassifierImplementation_swigregister(ClassifierImplementation)

def ClassifierImplementation_GetClassName():
  """ClassifierImplementation_GetClassName() -> OT::String"""
  return _algo.ClassifierImplementation_GetClassName()

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

    def getImplementationAsPersistentObject(self):
        """getImplementationAsPersistentObject(ClassifierImplementationTypedInterfaceObject self) -> PersistentObjectPointer"""
        return _algo.ClassifierImplementationTypedInterfaceObject_getImplementationAsPersistentObject(self)

    def setImplementationAsPersistentObject(self, *args):
        """setImplementationAsPersistentObject(ClassifierImplementationTypedInterfaceObject self, PersistentObjectPointer obj)"""
        return _algo.ClassifierImplementationTypedInterfaceObject_setImplementationAsPersistentObject(self, *args)

    def swap(self, *args):
        """swap(ClassifierImplementationTypedInterfaceObject self, ClassifierImplementationTypedInterfaceObject other)"""
        return _algo.ClassifierImplementationTypedInterfaceObject_swap(self, *args)

    def setName(self, *args):
        """setName(ClassifierImplementationTypedInterfaceObject self, OT::String const & name)"""
        return _algo.ClassifierImplementationTypedInterfaceObject_setName(self, *args)

    def getName(self):
        """getName(ClassifierImplementationTypedInterfaceObject self) -> OT::String"""
        return _algo.ClassifierImplementationTypedInterfaceObject_getName(self)

    def __eq__(self, *args):
        """__eq__(ClassifierImplementationTypedInterfaceObject self, ClassifierImplementationTypedInterfaceObject other) -> OT::Bool"""
        return _algo.ClassifierImplementationTypedInterfaceObject___eq__(self, *args)

    __swig_destroy__ = _algo.delete_ClassifierImplementationTypedInterfaceObject
    __del__ = lambda self : None;
ClassifierImplementationTypedInterfaceObject_swigregister = _algo.ClassifierImplementationTypedInterfaceObject_swigregister
ClassifierImplementationTypedInterfaceObject_swigregister(ClassifierImplementationTypedInterfaceObject)

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

    if _newclass:GetClassName = staticmethod(GetClassName)
    __swig_getmethods__["GetClassName"] = lambda x: GetClassName
    def getClassName(self):
        """getClassName(Classifier self) -> OT::String"""
        return _algo.Classifier_getClassName(self)

    def classify(self, *args):
        """
        classify(Classifier self, NumericalPoint inP) -> OT::UnsignedLong
        classify(Classifier self, NumericalSample inS) -> Indices
        """
        return _algo.Classifier_classify(self, *args)

    def grade(self, *args):
        """
        grade(Classifier self, NumericalPoint inP, OT::UnsignedLong outC) -> OT::NumericalScalar
        grade(Classifier self, NumericalSample inS, Indices outC) -> NumericalPoint
        """
        return _algo.Classifier_grade(self, *args)

    def getDimension(self):
        """getDimension(Classifier self) -> OT::UnsignedLong"""
        return _algo.Classifier_getDimension(self)

    def setVerbose(self, *args):
        """setVerbose(Classifier self, OT::Bool const verbose)"""
        return _algo.Classifier_setVerbose(self, *args)

    def getVerbose(self):
        """getVerbose(Classifier self) -> OT::Bool"""
        return _algo.Classifier_getVerbose(self)

    def __repr__(self):
        """__repr__(Classifier self) -> OT::String"""
        return _algo.Classifier___repr__(self)

    def __str__(self, offset=""):
        """
        __str__(Classifier self, OT::String const & offset="") -> OT::String
        __str__(Classifier self) -> OT::String
        """
        return _algo.Classifier___str__(self, offset)

    def __init__(self, *args): 
        """
        __init__(OT::Classifier self) -> Classifier
        __init__(OT::Classifier self, ClassifierImplementation implementation) -> Classifier
        __init__(OT::Classifier self, OT::Classifier::Implementation const & p_implementation) -> Classifier
        __init__(OT::Classifier self, NumericalSample inS, Indices outC) -> Classifier
        __init__(OT::Classifier self, Classifier other) -> Classifier
        """
        this = _algo.new_Classifier(*args)
        try: self.this.append(this)
        except: self.this = this
    __swig_destroy__ = _algo.delete_Classifier
    __del__ = lambda self : None;
Classifier_swigregister = _algo.Classifier_swigregister
Classifier_swigregister(Classifier)

def Classifier_GetClassName():
  """Classifier_GetClassName() -> OT::String"""
  return _algo.Classifier_GetClassName()

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

    if _newclass:GetClassName = staticmethod(GetClassName)
    __swig_getmethods__["GetClassName"] = lambda x: GetClassName
    def getClassName(self):
        """getClassName(FittingAlgorithmImplementation self) -> OT::String"""
        return _algo.FittingAlgorithmImplementation_getClassName(self)

    def __repr__(self):
        """__repr__(FittingAlgorithmImplementation self) -> OT::String"""
        return _algo.FittingAlgorithmImplementation___repr__(self)

    def run(self, *args):
        """run(FittingAlgorithmImplementation self, NumericalSample x, NumericalSample y, Basis basis) -> OT::NumericalScalar"""
        return _algo.FittingAlgorithmImplementation_run(self, *args)

    def __init__(self, *args): 
        """
        __init__(OT::FittingAlgorithmImplementation self) -> FittingAlgorithmImplementation
        __init__(OT::FittingAlgorithmImplementation self, FittingAlgorithmImplementation other) -> FittingAlgorithmImplementation
        """
        this = _algo.new_FittingAlgorithmImplementation(*args)
        try: self.this.append(this)
        except: self.this = this
    __swig_destroy__ = _algo.delete_FittingAlgorithmImplementation
    __del__ = lambda self : None;
FittingAlgorithmImplementation_swigregister = _algo.FittingAlgorithmImplementation_swigregister
FittingAlgorithmImplementation_swigregister(FittingAlgorithmImplementation)

def FittingAlgorithmImplementation_GetClassName():
  """FittingAlgorithmImplementation_GetClassName() -> OT::String"""
  return _algo.FittingAlgorithmImplementation_GetClassName()

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

    def getImplementationAsPersistentObject(self):
        """getImplementationAsPersistentObject(FittingAlgorithmImplementationTypedInterfaceObject self) -> PersistentObjectPointer"""
        return _algo.FittingAlgorithmImplementationTypedInterfaceObject_getImplementationAsPersistentObject(self)

    def setImplementationAsPersistentObject(self, *args):
        """setImplementationAsPersistentObject(FittingAlgorithmImplementationTypedInterfaceObject self, PersistentObjectPointer obj)"""
        return _algo.FittingAlgorithmImplementationTypedInterfaceObject_setImplementationAsPersistentObject(self, *args)

    def swap(self, *args):
        """swap(FittingAlgorithmImplementationTypedInterfaceObject self, FittingAlgorithmImplementationTypedInterfaceObject other)"""
        return _algo.FittingAlgorithmImplementationTypedInterfaceObject_swap(self, *args)

    def setName(self, *args):
        """setName(FittingAlgorithmImplementationTypedInterfaceObject self, OT::String const & name)"""
        return _algo.FittingAlgorithmImplementationTypedInterfaceObject_setName(self, *args)

    def getName(self):
        """getName(FittingAlgorithmImplementationTypedInterfaceObject self) -> OT::String"""
        return _algo.FittingAlgorithmImplementationTypedInterfaceObject_getName(self)

    def __eq__(self, *args):
        """__eq__(FittingAlgorithmImplementationTypedInterfaceObject self, FittingAlgorithmImplementationTypedInterfaceObject other) -> OT::Bool"""
        return _algo.FittingAlgorithmImplementationTypedInterfaceObject___eq__(self, *args)

    __swig_destroy__ = _algo.delete_FittingAlgorithmImplementationTypedInterfaceObject
    __del__ = lambda self : None;
FittingAlgorithmImplementationTypedInterfaceObject_swigregister = _algo.FittingAlgorithmImplementationTypedInterfaceObject_swigregister
FittingAlgorithmImplementationTypedInterfaceObject_swigregister(FittingAlgorithmImplementationTypedInterfaceObject)

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

    if _newclass:GetClassName = staticmethod(GetClassName)
    __swig_getmethods__["GetClassName"] = lambda x: GetClassName
    def getClassName(self):
        """getClassName(FittingAlgorithm self) -> OT::String"""
        return _algo.FittingAlgorithm_getClassName(self)

    def __repr__(self):
        """__repr__(FittingAlgorithm self) -> OT::String"""
        return _algo.FittingAlgorithm___repr__(self)

    def __str__(self, offset=""):
        """
        __str__(FittingAlgorithm self, OT::String const & offset="") -> OT::String
        __str__(FittingAlgorithm self) -> OT::String
        """
        return _algo.FittingAlgorithm___str__(self, offset)

    def run(self, *args):
        """run(FittingAlgorithm self, NumericalSample x, NumericalSample y, Basis basis) -> OT::NumericalScalar"""
        return _algo.FittingAlgorithm_run(self, *args)

    def __init__(self, *args): 
        """
        __init__(OT::FittingAlgorithm self) -> FittingAlgorithm
        __init__(OT::FittingAlgorithm self, OT::FittingAlgorithm::Implementation const & p_implementation) -> FittingAlgorithm
        __init__(OT::FittingAlgorithm self, FittingAlgorithmImplementation implementation) -> FittingAlgorithm
        __init__(OT::FittingAlgorithm self, FittingAlgorithm other) -> FittingAlgorithm
        """
        this = _algo.new_FittingAlgorithm(*args)
        try: self.this.append(this)
        except: self.this = this
    __swig_destroy__ = _algo.delete_FittingAlgorithm
    __del__ = lambda self : None;
FittingAlgorithm_swigregister = _algo.FittingAlgorithm_swigregister
FittingAlgorithm_swigregister(FittingAlgorithm)

def FittingAlgorithm_GetClassName():
  """FittingAlgorithm_GetClassName() -> OT::String"""
  return _algo.FittingAlgorithm_GetClassName()

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

    if _newclass:GetClassName = staticmethod(GetClassName)
    __swig_getmethods__["GetClassName"] = lambda x: GetClassName
    def getClassName(self):
        """getClassName(KFold self) -> OT::String"""
        return _algo.KFold_getClassName(self)

    def __repr__(self):
        """__repr__(KFold self) -> OT::String"""
        return _algo.KFold___repr__(self)

    def run(self, *args):
        """run(KFold self, NumericalSample x, NumericalSample y, Basis basis) -> OT::NumericalScalar"""
        return _algo.KFold_run(self, *args)

    def setK(self, *args):
        """setK(KFold self, OT::UnsignedLong const p)"""
        return _algo.KFold_setK(self, *args)

    def getK(self):
        """getK(KFold self) -> OT::UnsignedLong"""
        return _algo.KFold_getK(self)

    def __init__(self, *args): 
        """
        __init__(OT::KFold self, OT::UnsignedLong const k=OT::ResourceMap::GetAsUnsignedLong( "KFold-DefaultK" )) -> KFold
        __init__(OT::KFold self) -> KFold
        __init__(OT::KFold self, KFold other) -> KFold
        """
        this = _algo.new_KFold(*args)
        try: self.this.append(this)
        except: self.this = this
    __swig_destroy__ = _algo.delete_KFold
    __del__ = lambda self : None;
KFold_swigregister = _algo.KFold_swigregister
KFold_swigregister(KFold)

def KFold_GetClassName():
  """KFold_GetClassName() -> OT::String"""
  return _algo.KFold_GetClassName()

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

    if _newclass:GetClassName = staticmethod(GetClassName)
    __swig_getmethods__["GetClassName"] = lambda x: GetClassName
    def getClassName(self):
        """getClassName(CorrectedLeaveOneOut self) -> OT::String"""
        return _algo.CorrectedLeaveOneOut_getClassName(self)

    def __repr__(self):
        """__repr__(CorrectedLeaveOneOut self) -> OT::String"""
        return _algo.CorrectedLeaveOneOut___repr__(self)

    def run(self, *args):
        """run(CorrectedLeaveOneOut self, NumericalSample x, NumericalSample y, Basis basis) -> OT::NumericalScalar"""
        return _algo.CorrectedLeaveOneOut_run(self, *args)

    def __init__(self, *args): 
        """
        __init__(OT::CorrectedLeaveOneOut self) -> CorrectedLeaveOneOut
        __init__(OT::CorrectedLeaveOneOut self, CorrectedLeaveOneOut other) -> CorrectedLeaveOneOut
        """
        this = _algo.new_CorrectedLeaveOneOut(*args)
        try: self.this.append(this)
        except: self.this = this
    __swig_destroy__ = _algo.delete_CorrectedLeaveOneOut
    __del__ = lambda self : None;
CorrectedLeaveOneOut_swigregister = _algo.CorrectedLeaveOneOut_swigregister
CorrectedLeaveOneOut_swigregister(CorrectedLeaveOneOut)

def CorrectedLeaveOneOut_GetClassName():
  """CorrectedLeaveOneOut_GetClassName() -> OT::String"""
  return _algo.CorrectedLeaveOneOut_GetClassName()

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

    if _newclass:GetClassName = staticmethod(GetClassName)
    __swig_getmethods__["GetClassName"] = lambda x: GetClassName
    def getClassName(self):
        """getClassName(LeastSquaresMetaModelSelection self) -> OT::String"""
        return _algo.LeastSquaresMetaModelSelection_getClassName(self)

    def __repr__(self):
        """__repr__(LeastSquaresMetaModelSelection self) -> OT::String"""
        return _algo.LeastSquaresMetaModelSelection___repr__(self)

    def setBasisSequenceFactory(self, *args):
        """setBasisSequenceFactory(LeastSquaresMetaModelSelection self, BasisSequenceFactory basisSequenceFactory)"""
        return _algo.LeastSquaresMetaModelSelection_setBasisSequenceFactory(self, *args)

    def getBasisSequenceFactory(self):
        """getBasisSequenceFactory(LeastSquaresMetaModelSelection self) -> BasisSequenceFactory"""
        return _algo.LeastSquaresMetaModelSelection_getBasisSequenceFactory(self)

    def setFittingAlgorithm(self, *args):
        """setFittingAlgorithm(LeastSquaresMetaModelSelection self, FittingAlgorithm fittingAlgorithm)"""
        return _algo.LeastSquaresMetaModelSelection_setFittingAlgorithm(self, *args)

    def getFittingAlgorithm(self):
        """getFittingAlgorithm(LeastSquaresMetaModelSelection self) -> FittingAlgorithm"""
        return _algo.LeastSquaresMetaModelSelection_getFittingAlgorithm(self)

    def run(self):
        """run(LeastSquaresMetaModelSelection self)"""
        return _algo.LeastSquaresMetaModelSelection_run(self)

    def __init__(self, *args): 
        """
        __init__(OT::LeastSquaresMetaModelSelection self, NumericalSample x, NumericalSample y, Basis psi, BasisSequenceFactory basisSequenceFactory=OT::LAR(), 
            FittingAlgorithm fittingAlgorithm=OT::CorrectedLeaveOneOut()) -> LeastSquaresMetaModelSelection
        __init__(OT::LeastSquaresMetaModelSelection self, NumericalSample x, NumericalSample y, Basis psi, BasisSequenceFactory basisSequenceFactory=OT::LAR()) -> LeastSquaresMetaModelSelection
        __init__(OT::LeastSquaresMetaModelSelection self, NumericalSample x, NumericalSample y, Basis psi) -> LeastSquaresMetaModelSelection
        __init__(OT::LeastSquaresMetaModelSelection self, NumericalSample x, NumericalSample y, NumericalPoint weight, Basis psi, BasisSequenceFactory basisSequenceFactory=OT::LAR(), 
            FittingAlgorithm fittingAlgorithm=OT::CorrectedLeaveOneOut()) -> LeastSquaresMetaModelSelection
        __init__(OT::LeastSquaresMetaModelSelection self, NumericalSample x, NumericalSample y, NumericalPoint weight, Basis psi, BasisSequenceFactory basisSequenceFactory=OT::LAR()) -> LeastSquaresMetaModelSelection
        __init__(OT::LeastSquaresMetaModelSelection self, NumericalSample x, NumericalSample y, NumericalPoint weight, Basis psi) -> LeastSquaresMetaModelSelection
        __init__(OT::LeastSquaresMetaModelSelection self, LeastSquaresMetaModelSelection other) -> LeastSquaresMetaModelSelection
        """
        this = _algo.new_LeastSquaresMetaModelSelection(*args)
        try: self.this.append(this)
        except: self.this = this
    __swig_destroy__ = _algo.delete_LeastSquaresMetaModelSelection
    __del__ = lambda self : None;
LeastSquaresMetaModelSelection_swigregister = _algo.LeastSquaresMetaModelSelection_swigregister
LeastSquaresMetaModelSelection_swigregister(LeastSquaresMetaModelSelection)

def LeastSquaresMetaModelSelection_GetClassName():
  """LeastSquaresMetaModelSelection_GetClassName() -> OT::String"""
  return _algo.LeastSquaresMetaModelSelection_GetClassName()

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

    if _newclass:GetClassName = staticmethod(GetClassName)
    __swig_getmethods__["GetClassName"] = lambda x: GetClassName
    def getClassName(self):
        """getClassName(LeastSquaresMetaModelSelectionFactory self) -> OT::String"""
        return _algo.LeastSquaresMetaModelSelectionFactory_getClassName(self)

    def getBasisSequenceFactory(self):
        """getBasisSequenceFactory(LeastSquaresMetaModelSelectionFactory self) -> BasisSequenceFactory"""
        return _algo.LeastSquaresMetaModelSelectionFactory_getBasisSequenceFactory(self)

    def getFittingAlgorithm(self):
        """getFittingAlgorithm(LeastSquaresMetaModelSelectionFactory self) -> FittingAlgorithm"""
        return _algo.LeastSquaresMetaModelSelectionFactory_getFittingAlgorithm(self)

    def build(self, *args):
        """build(LeastSquaresMetaModelSelectionFactory self, NumericalSample x, NumericalSample y, NumericalPoint weight, Basis psi) -> LeastSquaresMetaModelSelection"""
        return _algo.LeastSquaresMetaModelSelectionFactory_build(self, *args)

    def __repr__(self):
        """__repr__(LeastSquaresMetaModelSelectionFactory self) -> OT::String"""
        return _algo.LeastSquaresMetaModelSelectionFactory___repr__(self)

    def __init__(self, *args): 
        """
        __init__(OT::LeastSquaresMetaModelSelectionFactory self, BasisSequenceFactory fact=OT::LAR(), FittingAlgorithm algo=OT::CorrectedLeaveOneOut()) -> LeastSquaresMetaModelSelectionFactory
        __init__(OT::LeastSquaresMetaModelSelectionFactory self, BasisSequenceFactory fact=OT::LAR()) -> LeastSquaresMetaModelSelectionFactory
        __init__(OT::LeastSquaresMetaModelSelectionFactory self) -> LeastSquaresMetaModelSelectionFactory
        __init__(OT::LeastSquaresMetaModelSelectionFactory self, LeastSquaresMetaModelSelectionFactory other) -> LeastSquaresMetaModelSelectionFactory
        """
        this = _algo.new_LeastSquaresMetaModelSelectionFactory(*args)
        try: self.this.append(this)
        except: self.this = this
    __swig_destroy__ = _algo.delete_LeastSquaresMetaModelSelectionFactory
    __del__ = lambda self : None;
LeastSquaresMetaModelSelectionFactory_swigregister = _algo.LeastSquaresMetaModelSelectionFactory_swigregister
LeastSquaresMetaModelSelectionFactory_swigregister(LeastSquaresMetaModelSelectionFactory)

def LeastSquaresMetaModelSelectionFactory_GetClassName():
  """LeastSquaresMetaModelSelectionFactory_GetClassName() -> OT::String"""
  return _algo.LeastSquaresMetaModelSelectionFactory_GetClassName()

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

    if _newclass:GetClassName = staticmethod(GetClassName)
    __swig_getmethods__["GetClassName"] = lambda x: GetClassName
    def getClassName(self):
        """getClassName(PenalizedLeastSquaresAlgorithm self) -> OT::String"""
        return _algo.PenalizedLeastSquaresAlgorithm_getClassName(self)

    def __repr__(self):
        """__repr__(PenalizedLeastSquaresAlgorithm self) -> OT::String"""
        return _algo.PenalizedLeastSquaresAlgorithm___repr__(self)

    def run(self):
        """run(PenalizedLeastSquaresAlgorithm self)"""
        return _algo.PenalizedLeastSquaresAlgorithm_run(self)

    def __init__(self, *args): 
        """
        __init__(OT::PenalizedLeastSquaresAlgorithm self) -> PenalizedLeastSquaresAlgorithm
        __init__(OT::PenalizedLeastSquaresAlgorithm self, NumericalSample x, NumericalSample y, NumericalMathFunctionCollection psi, OT::NumericalScalar const penalizationFactor=0.0) -> PenalizedLeastSquaresAlgorithm
        __init__(OT::PenalizedLeastSquaresAlgorithm self, NumericalSample x, NumericalSample y, NumericalMathFunctionCollection psi) -> PenalizedLeastSquaresAlgorithm
        __init__(OT::PenalizedLeastSquaresAlgorithm self, NumericalSample x, NumericalSample y, NumericalPoint weight, NumericalMathFunctionCollection psi, 
            OT::NumericalScalar const penalizationFactor=0.0) -> PenalizedLeastSquaresAlgorithm
        __init__(OT::PenalizedLeastSquaresAlgorithm self, NumericalSample x, NumericalSample y, NumericalPoint weight, NumericalMathFunctionCollection psi) -> PenalizedLeastSquaresAlgorithm
        __init__(OT::PenalizedLeastSquaresAlgorithm self, NumericalSample x, NumericalSample y, NumericalPoint weight, NumericalMathFunctionCollection psi, 
            OT::NumericalScalar const penalizationFactor, CovarianceMatrix penalizationMatrix) -> PenalizedLeastSquaresAlgorithm
        __init__(OT::PenalizedLeastSquaresAlgorithm self, PenalizedLeastSquaresAlgorithm other) -> PenalizedLeastSquaresAlgorithm
        """
        this = _algo.new_PenalizedLeastSquaresAlgorithm(*args)
        try: self.this.append(this)
        except: self.this = this
    __swig_destroy__ = _algo.delete_PenalizedLeastSquaresAlgorithm
    __del__ = lambda self : None;
PenalizedLeastSquaresAlgorithm_swigregister = _algo.PenalizedLeastSquaresAlgorithm_swigregister
PenalizedLeastSquaresAlgorithm_swigregister(PenalizedLeastSquaresAlgorithm)

def PenalizedLeastSquaresAlgorithm_GetClassName():
  """PenalizedLeastSquaresAlgorithm_GetClassName() -> OT::String"""
  return _algo.PenalizedLeastSquaresAlgorithm_GetClassName()

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

    if _newclass:GetClassName = staticmethod(GetClassName)
    __swig_getmethods__["GetClassName"] = lambda x: GetClassName
    def getClassName(self):
        """getClassName(PenalizedLeastSquaresAlgorithmFactory self) -> OT::String"""
        return _algo.PenalizedLeastSquaresAlgorithmFactory_getClassName(self)

    def build(self, *args):
        """build(PenalizedLeastSquaresAlgorithmFactory self, NumericalSample x, NumericalSample y, NumericalPoint weight, Basis psi) -> PenalizedLeastSquaresAlgorithm"""
        return _algo.PenalizedLeastSquaresAlgorithmFactory_build(self, *args)

    def __repr__(self):
        """__repr__(PenalizedLeastSquaresAlgorithmFactory self) -> OT::String"""
        return _algo.PenalizedLeastSquaresAlgorithmFactory___repr__(self)

    def __init__(self, *args): 
        """
        __init__(OT::PenalizedLeastSquaresAlgorithmFactory self) -> PenalizedLeastSquaresAlgorithmFactory
        __init__(OT::PenalizedLeastSquaresAlgorithmFactory self, PenalizedLeastSquaresAlgorithmFactory other) -> PenalizedLeastSquaresAlgorithmFactory
        """
        this = _algo.new_PenalizedLeastSquaresAlgorithmFactory(*args)
        try: self.this.append(this)
        except: self.this = this
    __swig_destroy__ = _algo.delete_PenalizedLeastSquaresAlgorithmFactory
    __del__ = lambda self : None;
PenalizedLeastSquaresAlgorithmFactory_swigregister = _algo.PenalizedLeastSquaresAlgorithmFactory_swigregister
PenalizedLeastSquaresAlgorithmFactory_swigregister(PenalizedLeastSquaresAlgorithmFactory)

def PenalizedLeastSquaresAlgorithmFactory_GetClassName():
  """PenalizedLeastSquaresAlgorithmFactory_GetClassName() -> OT::String"""
  return _algo.PenalizedLeastSquaresAlgorithmFactory_GetClassName()

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

    if _newclass:GetClassName = staticmethod(GetClassName)
    __swig_getmethods__["GetClassName"] = lambda x: GetClassName
    def getClassName(self):
        """getClassName(KissFFT self) -> OT::String"""
        return _algo.KissFFT_getClassName(self)

    def transform(self, *args):
        """
        transform(KissFFT self, NumericalComplexCollection collection) -> NumericalComplexCollection
        transform(KissFFT self, NumericalComplexCollection collection, OT::UnsignedLong const first, OT::UnsignedLong const size) -> NumericalComplexCollection
        """
        return _algo.KissFFT_transform(self, *args)

    def inverseTransform(self, *args):
        """
        inverseTransform(KissFFT self, NumericalComplexCollection collection) -> NumericalComplexCollection
        inverseTransform(KissFFT self, NumericalComplexCollection collection, OT::UnsignedLong const first, OT::UnsignedLong const size) -> NumericalComplexCollection
        """
        return _algo.KissFFT_inverseTransform(self, *args)

    def __repr__(self):
        """__repr__(KissFFT self) -> OT::String"""
        return _algo.KissFFT___repr__(self)

    def __str__(self, offset=""):
        """
        __str__(KissFFT self, OT::String const & offset="") -> OT::String
        __str__(KissFFT self) -> OT::String
        """
        return _algo.KissFFT___str__(self, offset)

    def __init__(self, *args): 
        """
        __init__(OT::KissFFT self, OT::String const & name=DefaultName) -> KissFFT
        __init__(OT::KissFFT self) -> KissFFT
        __init__(OT::KissFFT self, KissFFT other) -> KissFFT
        """
        this = _algo.new_KissFFT(*args)
        try: self.this.append(this)
        except: self.this = this
    __swig_destroy__ = _algo.delete_KissFFT
    __del__ = lambda self : None;
KissFFT_swigregister = _algo.KissFFT_swigregister
KissFFT_swigregister(KissFFT)

def KissFFT_GetClassName():
  """KissFFT_GetClassName() -> OT::String"""
  return _algo.KissFFT_GetClassName()

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

    if _newclass:GetClassName = staticmethod(GetClassName)
    __swig_getmethods__["GetClassName"] = lambda x: GetClassName
    def getClassName(self):
        """getClassName(IntegrationAlgorithmImplementation self) -> OT::String"""
        return _algo.IntegrationAlgorithmImplementation_getClassName(self)

    def integrate(self, *args):
        """
        integrate(IntegrationAlgorithmImplementation self, NumericalMathFunction function, Interval interval) -> OT::NumericalScalar
        integrate(IntegrationAlgorithmImplementation self, NumericalMathFunction function, Interval interval, NumericalPoint error) -> OT::NumericalScalar
        """
        return _algo.IntegrationAlgorithmImplementation_integrate(self, *args)

    def __repr__(self):
        """__repr__(IntegrationAlgorithmImplementation self) -> OT::String"""
        return _algo.IntegrationAlgorithmImplementation___repr__(self)

    def __str__(self, offset=""):
        """
        __str__(IntegrationAlgorithmImplementation self, OT::String const & offset="") -> OT::String
        __str__(IntegrationAlgorithmImplementation self) -> OT::String
        """
        return _algo.IntegrationAlgorithmImplementation___str__(self, offset)

    def __init__(self, *args): 
        """
        __init__(OT::IntegrationAlgorithmImplementation self, OT::String const & name=DefaultName) -> IntegrationAlgorithmImplementation
        __init__(OT::IntegrationAlgorithmImplementation self) -> IntegrationAlgorithmImplementation
        __init__(OT::IntegrationAlgorithmImplementation self, IntegrationAlgorithmImplementation other) -> IntegrationAlgorithmImplementation
        """
        this = _algo.new_IntegrationAlgorithmImplementation(*args)
        try: self.this.append(this)
        except: self.this = this
    __swig_destroy__ = _algo.delete_IntegrationAlgorithmImplementation
    __del__ = lambda self : None;
IntegrationAlgorithmImplementation_swigregister = _algo.IntegrationAlgorithmImplementation_swigregister
IntegrationAlgorithmImplementation_swigregister(IntegrationAlgorithmImplementation)

def IntegrationAlgorithmImplementation_GetClassName():
  """IntegrationAlgorithmImplementation_GetClassName() -> OT::String"""
  return _algo.IntegrationAlgorithmImplementation_GetClassName()

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

    def getImplementationAsPersistentObject(self):
        """getImplementationAsPersistentObject(IntegrationAlgorithmImplementationTypedInterfaceObject self) -> PersistentObjectPointer"""
        return _algo.IntegrationAlgorithmImplementationTypedInterfaceObject_getImplementationAsPersistentObject(self)

    def setImplementationAsPersistentObject(self, *args):
        """setImplementationAsPersistentObject(IntegrationAlgorithmImplementationTypedInterfaceObject self, PersistentObjectPointer obj)"""
        return _algo.IntegrationAlgorithmImplementationTypedInterfaceObject_setImplementationAsPersistentObject(self, *args)

    def swap(self, *args):
        """swap(IntegrationAlgorithmImplementationTypedInterfaceObject self, IntegrationAlgorithmImplementationTypedInterfaceObject other)"""
        return _algo.IntegrationAlgorithmImplementationTypedInterfaceObject_swap(self, *args)

    def setName(self, *args):
        """setName(IntegrationAlgorithmImplementationTypedInterfaceObject self, OT::String const & name)"""
        return _algo.IntegrationAlgorithmImplementationTypedInterfaceObject_setName(self, *args)

    def getName(self):
        """getName(IntegrationAlgorithmImplementationTypedInterfaceObject self) -> OT::String"""
        return _algo.IntegrationAlgorithmImplementationTypedInterfaceObject_getName(self)

    def __eq__(self, *args):
        """__eq__(IntegrationAlgorithmImplementationTypedInterfaceObject self, IntegrationAlgorithmImplementationTypedInterfaceObject other) -> OT::Bool"""
        return _algo.IntegrationAlgorithmImplementationTypedInterfaceObject___eq__(self, *args)

    __swig_destroy__ = _algo.delete_IntegrationAlgorithmImplementationTypedInterfaceObject
    __del__ = lambda self : None;
IntegrationAlgorithmImplementationTypedInterfaceObject_swigregister = _algo.IntegrationAlgorithmImplementationTypedInterfaceObject_swigregister
IntegrationAlgorithmImplementationTypedInterfaceObject_swigregister(IntegrationAlgorithmImplementationTypedInterfaceObject)

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

    if _newclass:GetClassName = staticmethod(GetClassName)
    __swig_getmethods__["GetClassName"] = lambda x: GetClassName
    def getClassName(self):
        """getClassName(IntegrationAlgorithm self) -> OT::String"""
        return _algo.IntegrationAlgorithm_getClassName(self)

    def integrate(self, *args):
        """
        integrate(IntegrationAlgorithm self, NumericalMathFunction function, Interval interval) -> OT::NumericalScalar
        integrate(IntegrationAlgorithm self, NumericalMathFunction function, Interval interval, NumericalPoint error) -> OT::NumericalScalar
        """
        return _algo.IntegrationAlgorithm_integrate(self, *args)

    def __repr__(self):
        """__repr__(IntegrationAlgorithm self) -> OT::String"""
        return _algo.IntegrationAlgorithm___repr__(self)

    def __str__(self, offset=""):
        """
        __str__(IntegrationAlgorithm self, OT::String const & offset="") -> OT::String
        __str__(IntegrationAlgorithm self) -> OT::String
        """
        return _algo.IntegrationAlgorithm___str__(self, offset)

    def __init__(self, *args): 
        """
        __init__(OT::IntegrationAlgorithm self) -> IntegrationAlgorithm
        __init__(OT::IntegrationAlgorithm self, IntegrationAlgorithmImplementation implementation, OT::String const & name=DefaultName) -> IntegrationAlgorithm
        __init__(OT::IntegrationAlgorithm self, IntegrationAlgorithmImplementation implementation) -> IntegrationAlgorithm
        __init__(OT::IntegrationAlgorithm self, OT::IntegrationAlgorithm::Implementation const & p_implementation, OT::String const & name=DefaultName) -> IntegrationAlgorithm
        __init__(OT::IntegrationAlgorithm self, OT::IntegrationAlgorithm::Implementation const & p_implementation) -> IntegrationAlgorithm
        __init__(OT::IntegrationAlgorithm self, IntegrationAlgorithm other) -> IntegrationAlgorithm
        """
        this = _algo.new_IntegrationAlgorithm(*args)
        try: self.this.append(this)
        except: self.this = this
    __swig_destroy__ = _algo.delete_IntegrationAlgorithm
    __del__ = lambda self : None;
IntegrationAlgorithm_swigregister = _algo.IntegrationAlgorithm_swigregister
IntegrationAlgorithm_swigregister(IntegrationAlgorithm)

def IntegrationAlgorithm_GetClassName():
  """IntegrationAlgorithm_GetClassName() -> OT::String"""
  return _algo.IntegrationAlgorithm_GetClassName()

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

    if _newclass:GetClassName = staticmethod(GetClassName)
    __swig_getmethods__["GetClassName"] = lambda x: GetClassName
    def getClassName(self):
        """getClassName(GaussKronrodRule self) -> OT::String"""
        return _algo.GaussKronrodRule_getClassName(self)

    G3K7 = _algo.GaussKronrodRule_G3K7
    G7K15 = _algo.GaussKronrodRule_G7K15
    G11K23 = _algo.GaussKronrodRule_G11K23
    G15K31 = _algo.GaussKronrodRule_G15K31
    G25K51 = _algo.GaussKronrodRule_G25K51
    def __repr__(self):
        """__repr__(GaussKronrodRule self) -> OT::String"""
        return _algo.GaussKronrodRule___repr__(self)

    def __str__(self, offset=""):
        """
        __str__(GaussKronrodRule self, OT::String const & offset="") -> OT::String
        __str__(GaussKronrodRule self) -> OT::String
        """
        return _algo.GaussKronrodRule___str__(self, offset)

    def getPair(self):
        """getPair(GaussKronrodRule self) -> OT::GaussKronrodRule::GaussKronrodPair"""
        return _algo.GaussKronrodRule_getPair(self)

    def getOrder(self):
        """getOrder(GaussKronrodRule self) -> OT::UnsignedLong"""
        return _algo.GaussKronrodRule_getOrder(self)

    def getZeroGaussWeight(self):
        """getZeroGaussWeight(GaussKronrodRule self) -> OT::NumericalScalar"""
        return _algo.GaussKronrodRule_getZeroGaussWeight(self)

    def getOtherGaussWeights(self):
        """getOtherGaussWeights(GaussKronrodRule self) -> NumericalPoint"""
        return _algo.GaussKronrodRule_getOtherGaussWeights(self)

    def getOtherKronrodNodes(self):
        """getOtherKronrodNodes(GaussKronrodRule self) -> NumericalPoint"""
        return _algo.GaussKronrodRule_getOtherKronrodNodes(self)

    def getZeroKronrodWeight(self):
        """getZeroKronrodWeight(GaussKronrodRule self) -> OT::NumericalScalar"""
        return _algo.GaussKronrodRule_getZeroKronrodWeight(self)

    def getOtherKronrodWeights(self):
        """getOtherKronrodWeights(GaussKronrodRule self) -> NumericalPoint"""
        return _algo.GaussKronrodRule_getOtherKronrodWeights(self)

    def __init__(self, *args): 
        """
        __init__(OT::GaussKronrodRule self, OT::String const & name=DefaultName) -> GaussKronrodRule
        __init__(OT::GaussKronrodRule self) -> GaussKronrodRule
        __init__(OT::GaussKronrodRule self, OT::GaussKronrodRule::GaussKronrodPair const pair) -> GaussKronrodRule
        __init__(OT::GaussKronrodRule self, GaussKronrodRule other) -> GaussKronrodRule
        """
        this = _algo.new_GaussKronrodRule(*args)
        try: self.this.append(this)
        except: self.this = this
    __swig_destroy__ = _algo.delete_GaussKronrodRule
    __del__ = lambda self : None;
GaussKronrodRule_swigregister = _algo.GaussKronrodRule_swigregister
GaussKronrodRule_swigregister(GaussKronrodRule)

def GaussKronrodRule_GetClassName():
  """GaussKronrodRule_GetClassName() -> OT::String"""
  return _algo.GaussKronrodRule_GetClassName()

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

    if _newclass:GetClassName = staticmethod(GetClassName)
    __swig_getmethods__["GetClassName"] = lambda x: GetClassName
    def getClassName(self):
        """getClassName(GaussKronrod self) -> OT::String"""
        return _algo.GaussKronrod_getClassName(self)

    def integrate(self, *args):
        """
        integrate(GaussKronrod self, NumericalMathFunction function, Interval interval) -> OT::NumericalScalar
        integrate(GaussKronrod self, NumericalMathFunction function, Interval interval, NumericalPoint error) -> OT::NumericalScalar
        integrate(GaussKronrod self, NumericalMathFunction function, OT::NumericalScalar const a, OT::NumericalScalar const b, 
            NumericalPoint error, NumericalPoint ai, NumericalPoint bi, NumericalPoint fi, 
            NumericalPoint ei) -> OT::NumericalScalar
        """
        return _algo.GaussKronrod_integrate(self, *args)

    def getMaximumSubIntervals(self):
        """getMaximumSubIntervals(GaussKronrod self) -> OT::UnsignedLong"""
        return _algo.GaussKronrod_getMaximumSubIntervals(self)

    def setMaximumSubIntervals(self, *args):
        """setMaximumSubIntervals(GaussKronrod self, OT::UnsignedLong const maximumSubIntervals)"""
        return _algo.GaussKronrod_setMaximumSubIntervals(self, *args)

    def getMaximumError(self):
        """getMaximumError(GaussKronrod self) -> OT::NumericalScalar"""
        return _algo.GaussKronrod_getMaximumError(self)

    def setMaximumError(self, *args):
        """setMaximumError(GaussKronrod self, OT::NumericalScalar const maximumError)"""
        return _algo.GaussKronrod_setMaximumError(self, *args)

    def getRule(self):
        """getRule(GaussKronrod self) -> GaussKronrodRule"""
        return _algo.GaussKronrod_getRule(self)

    def setRule(self, *args):
        """setRule(GaussKronrod self, GaussKronrodRule rule)"""
        return _algo.GaussKronrod_setRule(self, *args)

    def __repr__(self):
        """__repr__(GaussKronrod self) -> OT::String"""
        return _algo.GaussKronrod___repr__(self)

    def __str__(self, offset=""):
        """
        __str__(GaussKronrod self, OT::String const & offset="") -> OT::String
        __str__(GaussKronrod self) -> OT::String
        """
        return _algo.GaussKronrod___str__(self, offset)

    def __init__(self, *args): 
        """
        __init__(OT::GaussKronrod self, OT::String const & name=DefaultName) -> GaussKronrod
        __init__(OT::GaussKronrod self) -> GaussKronrod
        __init__(OT::GaussKronrod self, OT::UnsignedLong const maximumSubIntervals, OT::NumericalScalar const maximumError, 
            GaussKronrodRule rule) -> GaussKronrod
        __init__(OT::GaussKronrod self, GaussKronrod other) -> GaussKronrod
        """
        this = _algo.new_GaussKronrod(*args)
        try: self.this.append(this)
        except: self.this = this
    __swig_destroy__ = _algo.delete_GaussKronrod
    __del__ = lambda self : None;
GaussKronrod_swigregister = _algo.GaussKronrod_swigregister
GaussKronrod_swigregister(GaussKronrod)

def GaussKronrod_GetClassName():
  """GaussKronrod_GetClassName() -> OT::String"""
  return _algo.GaussKronrod_GetClassName()

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

    if _newclass:GetClassName = staticmethod(GetClassName)
    __swig_getmethods__["GetClassName"] = lambda x: GetClassName
    def getClassName(self):
        """getClassName(ExpertMixture self) -> OT::String"""
        return _algo.ExpertMixture_getClassName(self)

    def __eq__(self, *args):
        """__eq__(ExpertMixture self, ExpertMixture other) -> OT::Bool"""
        return _algo.ExpertMixture___eq__(self, *args)

    def __repr__(self):
        """__repr__(ExpertMixture self) -> OT::String"""
        return _algo.ExpertMixture___repr__(self)

    def __str__(self, offset=""):
        """
        __str__(ExpertMixture self, OT::String const & offset="") -> OT::String
        __str__(ExpertMixture self) -> OT::String
        """
        return _algo.ExpertMixture___str__(self, offset)

    def __call__(self, *args):
        """
        __call__(ExpertMixture self, NumericalPoint inP) -> NumericalPoint
        __call__(ExpertMixture self, NumericalSample inSample) -> NumericalSample
        __call__(ExpertMixture self, Field inField) -> Field
        __call__(ExpertMixture self, NumericalPoint inP) -> NumericalPoint
        """
        return _algo.ExpertMixture___call__(self, *args)

    def getInputDimension(self):
        """getInputDimension(ExpertMixture self) -> OT::UnsignedLong"""
        return _algo.ExpertMixture_getInputDimension(self)

    def getOutputDimension(self):
        """getOutputDimension(ExpertMixture self) -> OT::UnsignedLong"""
        return _algo.ExpertMixture_getOutputDimension(self)

    def getExperts(self):
        """getExperts(ExpertMixture self) -> Basis"""
        return _algo.ExpertMixture_getExperts(self)

    def setExperts(self, *args):
        """setExperts(ExpertMixture self, Basis experts)"""
        return _algo.ExpertMixture_setExperts(self, *args)

    def getClassifier(self):
        """getClassifier(ExpertMixture self) -> Classifier"""
        return _algo.ExpertMixture_getClassifier(self)

    def setClassifier(self, *args):
        """setClassifier(ExpertMixture self, Classifier classifier)"""
        return _algo.ExpertMixture_setClassifier(self, *args)

    def __init__(self, *args): 
        """
        __init__(OT::ExpertMixture self) -> ExpertMixture
        __init__(OT::ExpertMixture self, Basis experts, Classifier classifier) -> ExpertMixture
        __init__(OT::ExpertMixture self, ExpertMixture other) -> ExpertMixture
        """
        this = _algo.new_ExpertMixture(*args)
        try: self.this.append(this)
        except: self.this = this
    __swig_destroy__ = _algo.delete_ExpertMixture
    __del__ = lambda self : None;
ExpertMixture_swigregister = _algo.ExpertMixture_swigregister
ExpertMixture_swigregister(ExpertMixture)

def ExpertMixture_GetClassName():
  """ExpertMixture_GetClassName() -> OT::String"""
  return _algo.ExpertMixture_GetClassName()

class ApproximationAlgorithmImplementationPointer(_object):
    """Proxy of C++ OT::Pointer<(OT::ApproximationAlgorithmImplementation)> class"""
    __swig_setmethods__ = {}
    __setattr__ = lambda self, name, value: _swig_setattr(self, ApproximationAlgorithmImplementationPointer, name, value)
    __swig_getmethods__ = {}
    __getattr__ = lambda self, name: _swig_getattr(self, ApproximationAlgorithmImplementationPointer, name)
    __swig_setmethods__["ptr_"] = _algo.ApproximationAlgorithmImplementationPointer_ptr__set
    __swig_getmethods__["ptr_"] = _algo.ApproximationAlgorithmImplementationPointer_ptr__get
    if _newclass:ptr_ = _swig_property(_algo.ApproximationAlgorithmImplementationPointer_ptr__get, _algo.ApproximationAlgorithmImplementationPointer_ptr__set)
    def __init__(self, *args): 
        """
        __init__(OT::Pointer<(OT::ApproximationAlgorithmImplementation)> self) -> ApproximationAlgorithmImplementationPointer
        __init__(OT::Pointer<(OT::ApproximationAlgorithmImplementation)> self, ApproximationAlgorithmImplementation ptr) -> ApproximationAlgorithmImplementationPointer
        """
        this = _algo.new_ApproximationAlgorithmImplementationPointer(*args)
        try: self.this.append(this)
        except: self.this = this
    __swig_destroy__ = _algo.delete_ApproximationAlgorithmImplementationPointer
    __del__ = lambda self : None;
    def reset(self):
        """reset(ApproximationAlgorithmImplementationPointer self)"""
        return _algo.ApproximationAlgorithmImplementationPointer_reset(self)

    def __ref__(self, *args):
        """
        __ref__(ApproximationAlgorithmImplementationPointer self) -> ApproximationAlgorithmImplementation
        __ref__(ApproximationAlgorithmImplementationPointer self) -> ApproximationAlgorithmImplementation
        """
        return _algo.ApproximationAlgorithmImplementationPointer___ref__(self, *args)

    def __deref__(self):
        """__deref__(ApproximationAlgorithmImplementationPointer self) -> ApproximationAlgorithmImplementation"""
        return _algo.ApproximationAlgorithmImplementationPointer___deref__(self)

    def isNull(self):
        """isNull(ApproximationAlgorithmImplementationPointer self) -> OT::Bool"""
        return _algo.ApproximationAlgorithmImplementationPointer_isNull(self)

    def __nonzero__(self):
        return _algo.ApproximationAlgorithmImplementationPointer___nonzero__(self)
    __bool__ = __nonzero__


    def get(self):
        """get(ApproximationAlgorithmImplementationPointer self) -> ApproximationAlgorithmImplementation"""
        return _algo.ApproximationAlgorithmImplementationPointer_get(self)

    def getImplementation(self):
        """getImplementation(ApproximationAlgorithmImplementationPointer self) -> OT::Pointer< OT::ApproximationAlgorithmImplementation >::pointer_type const &"""
        return _algo.ApproximationAlgorithmImplementationPointer_getImplementation(self)

    def unique(self):
        """unique(ApproximationAlgorithmImplementationPointer self) -> OT::Bool"""
        return _algo.ApproximationAlgorithmImplementationPointer_unique(self)

    def use_count(self):
        """use_count(ApproximationAlgorithmImplementationPointer self) -> OT::UnsignedLong"""
        return _algo.ApproximationAlgorithmImplementationPointer_use_count(self)

    def swap(self, *args):
        """swap(ApproximationAlgorithmImplementationPointer self, ApproximationAlgorithmImplementationPointer other)"""
        return _algo.ApproximationAlgorithmImplementationPointer_swap(self, *args)

    def GetClassName(self):
        """GetClassName(ApproximationAlgorithmImplementationPointer self) -> OT::String"""
        return _algo.ApproximationAlgorithmImplementationPointer_GetClassName(self)

    def getClassName(self):
        """getClassName(ApproximationAlgorithmImplementationPointer self) -> OT::String"""
        return _algo.ApproximationAlgorithmImplementationPointer_getClassName(self)

    def getX(self):
        """getX(ApproximationAlgorithmImplementationPointer self) -> NumericalSample"""
        return _algo.ApproximationAlgorithmImplementationPointer_getX(self)

    def getY(self):
        """getY(ApproximationAlgorithmImplementationPointer self) -> NumericalSample"""
        return _algo.ApproximationAlgorithmImplementationPointer_getY(self)

    def getWeight(self):
        """getWeight(ApproximationAlgorithmImplementationPointer self) -> NumericalPoint"""
        return _algo.ApproximationAlgorithmImplementationPointer_getWeight(self)

    def getPsi(self):
        """getPsi(ApproximationAlgorithmImplementationPointer self) -> Basis"""
        return _algo.ApproximationAlgorithmImplementationPointer_getPsi(self)

    def __repr__(self):
        """__repr__(ApproximationAlgorithmImplementationPointer self) -> OT::String"""
        return _algo.ApproximationAlgorithmImplementationPointer___repr__(self)

    def __str__(self, offset=""):
        """
        __str__(ApproximationAlgorithmImplementationPointer self, OT::String const & offset="") -> OT::String
        __str__(ApproximationAlgorithmImplementationPointer self) -> OT::String
        """
        return _algo.ApproximationAlgorithmImplementationPointer___str__(self, offset)

    def run(self):
        """run(ApproximationAlgorithmImplementationPointer self)"""
        return _algo.ApproximationAlgorithmImplementationPointer_run(self)

    def getCoefficients(self):
        """getCoefficients(ApproximationAlgorithmImplementationPointer self) -> NumericalPoint"""
        return _algo.ApproximationAlgorithmImplementationPointer_getCoefficients(self)

    def getResidual(self):
        """getResidual(ApproximationAlgorithmImplementationPointer self) -> OT::NumericalScalar"""
        return _algo.ApproximationAlgorithmImplementationPointer_getResidual(self)

    def getRelativeError(self):
        """getRelativeError(ApproximationAlgorithmImplementationPointer self) -> OT::NumericalScalar"""
        return _algo.ApproximationAlgorithmImplementationPointer_getRelativeError(self)

    def setVerbose(self, *args):
        """setVerbose(ApproximationAlgorithmImplementationPointer self, OT::Bool const verbose)"""
        return _algo.ApproximationAlgorithmImplementationPointer_setVerbose(self, *args)

    def getVerbose(self):
        """getVerbose(ApproximationAlgorithmImplementationPointer self) -> OT::Bool"""
        return _algo.ApproximationAlgorithmImplementationPointer_getVerbose(self)

    def __eq__(self, *args):
        """__eq__(ApproximationAlgorithmImplementationPointer self, PersistentObject other) -> OT::Bool"""
        return _algo.ApproximationAlgorithmImplementationPointer___eq__(self, *args)

    def Is(self, *args):
        """Is(ApproximationAlgorithmImplementationPointer self, PersistentObject other) -> OT::Bool"""
        return _algo.ApproximationAlgorithmImplementationPointer_Is(self, *args)

    def getId(self):
        """getId(ApproximationAlgorithmImplementationPointer self) -> OT::Id"""
        return _algo.ApproximationAlgorithmImplementationPointer_getId(self)

    def setShadowedId(self, *args):
        """setShadowedId(ApproximationAlgorithmImplementationPointer self, OT::Id id)"""
        return _algo.ApproximationAlgorithmImplementationPointer_setShadowedId(self, *args)

    def getShadowedId(self):
        """getShadowedId(ApproximationAlgorithmImplementationPointer self) -> OT::Id"""
        return _algo.ApproximationAlgorithmImplementationPointer_getShadowedId(self)

    def setVisibility(self, *args):
        """setVisibility(ApproximationAlgorithmImplementationPointer self, OT::Bool visible)"""
        return _algo.ApproximationAlgorithmImplementationPointer_setVisibility(self, *args)

    def getVisibility(self):
        """getVisibility(ApproximationAlgorithmImplementationPointer self) -> OT::Bool"""
        return _algo.ApproximationAlgorithmImplementationPointer_getVisibility(self)

    def hasName(self):
        """hasName(ApproximationAlgorithmImplementationPointer self) -> OT::Bool"""
        return _algo.ApproximationAlgorithmImplementationPointer_hasName(self)

    def hasVisibleName(self):
        """hasVisibleName(ApproximationAlgorithmImplementationPointer self) -> OT::Bool"""
        return _algo.ApproximationAlgorithmImplementationPointer_hasVisibleName(self)

    def getName(self):
        """getName(ApproximationAlgorithmImplementationPointer self) -> OT::String"""
        return _algo.ApproximationAlgorithmImplementationPointer_getName(self)

    def setName(self, *args):
        """setName(ApproximationAlgorithmImplementationPointer self, OT::String const & name)"""
        return _algo.ApproximationAlgorithmImplementationPointer_setName(self, *args)

ApproximationAlgorithmImplementationPointer_swigregister = _algo.ApproximationAlgorithmImplementationPointer_swigregister
ApproximationAlgorithmImplementationPointer_swigregister(ApproximationAlgorithmImplementationPointer)

class FFTImplementationPointer(_object):
    """Proxy of C++ OT::Pointer<(OT::FFTImplementation)> class"""
    __swig_setmethods__ = {}
    __setattr__ = lambda self, name, value: _swig_setattr(self, FFTImplementationPointer, name, value)
    __swig_getmethods__ = {}
    __getattr__ = lambda self, name: _swig_getattr(self, FFTImplementationPointer, name)
    __swig_setmethods__["ptr_"] = _algo.FFTImplementationPointer_ptr__set
    __swig_getmethods__["ptr_"] = _algo.FFTImplementationPointer_ptr__get
    if _newclass:ptr_ = _swig_property(_algo.FFTImplementationPointer_ptr__get, _algo.FFTImplementationPointer_ptr__set)
    def __init__(self, *args): 
        """
        __init__(OT::Pointer<(OT::FFTImplementation)> self) -> FFTImplementationPointer
        __init__(OT::Pointer<(OT::FFTImplementation)> self, FFTImplementation ptr) -> FFTImplementationPointer
        """
        this = _algo.new_FFTImplementationPointer(*args)
        try: self.this.append(this)
        except: self.this = this
    __swig_destroy__ = _algo.delete_FFTImplementationPointer
    __del__ = lambda self : None;
    def reset(self):
        """reset(FFTImplementationPointer self)"""
        return _algo.FFTImplementationPointer_reset(self)

    def __ref__(self, *args):
        """
        __ref__(FFTImplementationPointer self) -> FFTImplementation
        __ref__(FFTImplementationPointer self) -> FFTImplementation
        """
        return _algo.FFTImplementationPointer___ref__(self, *args)

    def __deref__(self):
        """__deref__(FFTImplementationPointer self) -> FFTImplementation"""
        return _algo.FFTImplementationPointer___deref__(self)

    def isNull(self):
        """isNull(FFTImplementationPointer self) -> OT::Bool"""
        return _algo.FFTImplementationPointer_isNull(self)

    def __nonzero__(self):
        return _algo.FFTImplementationPointer___nonzero__(self)
    __bool__ = __nonzero__


    def get(self):
        """get(FFTImplementationPointer self) -> FFTImplementation"""
        return _algo.FFTImplementationPointer_get(self)

    def getImplementation(self):
        """getImplementation(FFTImplementationPointer self) -> OT::Pointer< OT::FFTImplementation >::pointer_type const &"""
        return _algo.FFTImplementationPointer_getImplementation(self)

    def unique(self):
        """unique(FFTImplementationPointer self) -> OT::Bool"""
        return _algo.FFTImplementationPointer_unique(self)

    def use_count(self):
        """use_count(FFTImplementationPointer self) -> OT::UnsignedLong"""
        return _algo.FFTImplementationPointer_use_count(self)

    def swap(self, *args):
        """swap(FFTImplementationPointer self, FFTImplementationPointer other)"""
        return _algo.FFTImplementationPointer_swap(self, *args)

    def GetClassName(self):
        """GetClassName(FFTImplementationPointer self) -> OT::String"""
        return _algo.FFTImplementationPointer_GetClassName(self)

    def getClassName(self):
        """getClassName(FFTImplementationPointer self) -> OT::String"""
        return _algo.FFTImplementationPointer_getClassName(self)

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

    def inverseTransform(self, *args):
        """
        inverseTransform(FFTImplementationPointer self, NumericalComplexCollection collection) -> NumericalComplexCollection
        inverseTransform(FFTImplementationPointer self, NumericalComplexCollection collection, OT::UnsignedLong const first, OT::UnsignedLong const size) -> NumericalComplexCollection
        inverseTransform(FFTImplementationPointer self, NumericalComplexCollection collection, OT::UnsignedLong const first, OT::UnsignedLong const step, 
            OT::UnsignedLong const last) -> NumericalComplexCollection
        """
        return _algo.FFTImplementationPointer_inverseTransform(self, *args)

    def __repr__(self):
        """__repr__(FFTImplementationPointer self) -> OT::String"""
        return _algo.FFTImplementationPointer___repr__(self)

    def __str__(self, offset=""):
        """
        __str__(FFTImplementationPointer self, OT::String const & offset="") -> OT::String
        __str__(FFTImplementationPointer self) -> OT::String
        """
        return _algo.FFTImplementationPointer___str__(self, offset)

    def __eq__(self, *args):
        """__eq__(FFTImplementationPointer self, PersistentObject other) -> OT::Bool"""
        return _algo.FFTImplementationPointer___eq__(self, *args)

    def Is(self, *args):
        """Is(FFTImplementationPointer self, PersistentObject other) -> OT::Bool"""
        return _algo.FFTImplementationPointer_Is(self, *args)

    def getId(self):
        """getId(FFTImplementationPointer self) -> OT::Id"""
        return _algo.FFTImplementationPointer_getId(self)

    def setShadowedId(self, *args):
        """setShadowedId(FFTImplementationPointer self, OT::Id id)"""
        return _algo.FFTImplementationPointer_setShadowedId(self, *args)

    def getShadowedId(self):
        """getShadowedId(FFTImplementationPointer self) -> OT::Id"""
        return _algo.FFTImplementationPointer_getShadowedId(self)

    def setVisibility(self, *args):
        """setVisibility(FFTImplementationPointer self, OT::Bool visible)"""
        return _algo.FFTImplementationPointer_setVisibility(self, *args)

    def getVisibility(self):
        """getVisibility(FFTImplementationPointer self) -> OT::Bool"""
        return _algo.FFTImplementationPointer_getVisibility(self)

    def hasName(self):
        """hasName(FFTImplementationPointer self) -> OT::Bool"""
        return _algo.FFTImplementationPointer_hasName(self)

    def hasVisibleName(self):
        """hasVisibleName(FFTImplementationPointer self) -> OT::Bool"""
        return _algo.FFTImplementationPointer_hasVisibleName(self)

    def getName(self):
        """getName(FFTImplementationPointer self) -> OT::String"""
        return _algo.FFTImplementationPointer_getName(self)

    def setName(self, *args):
        """setName(FFTImplementationPointer self, OT::String const & name)"""
        return _algo.FFTImplementationPointer_setName(self, *args)

FFTImplementationPointer_swigregister = _algo.FFTImplementationPointer_swigregister
FFTImplementationPointer_swigregister(FFTImplementationPointer)

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