python-openturns 1.2-2 / usr / share / pyshared / openturns / orthogonalbasis.py

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


"""
Polynomial primitives.
"""


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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

    def __eq__(self, *args):
        """__eq__(TestResult self, TestResult other) -> OT::Bool"""
        return _orthogonalbasis.TestResult___eq__(self, *args)

    def __init__(self, *args): 
        """
        __init__(OT::TestResult self) -> TestResult
        __init__(OT::TestResult self, OT::String const & type, OT::Bool const binMeasure, OT::NumericalScalar const pVal, 
            OT::NumericalScalar const pThreshold) -> TestResult
        __init__(OT::TestResult self, TestResult other) -> TestResult
        __init__(OT::TestResult self, PyObject * pyObj) -> TestResult
        """
        this = _orthogonalbasis.new_TestResult(*args)
        try: self.this.append(this)
        except: self.this = this
    __swig_destroy__ = _orthogonalbasis.delete_TestResult
    __del__ = lambda self : None;
TestResult_swigregister = _orthogonalbasis.TestResult_swigregister
TestResult_swigregister(TestResult)

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

import openturns.base
import openturns.statistics
import openturns.graph
import openturns.func
import openturns.geom
import openturns.diff
import openturns.optim
import openturns.solver
import openturns.algo
import openturns.experiment
import openturns.model_copula
import openturns.weightedexperiment
class EnumerateFunctionImplementation(openturns.common.PersistentObject):
    """Proxy of C++ OT::EnumerateFunctionImplementation class"""
    __swig_setmethods__ = {}
    for _s in [openturns.common.PersistentObject]: __swig_setmethods__.update(getattr(_s,'__swig_setmethods__',{}))
    __setattr__ = lambda self, name, value: _swig_setattr(self, EnumerateFunctionImplementation, name, value)
    __swig_getmethods__ = {}
    for _s in [openturns.common.PersistentObject]: __swig_getmethods__.update(getattr(_s,'__swig_getmethods__',{}))
    __getattr__ = lambda self, name: _swig_getattr(self, EnumerateFunctionImplementation, name)
    def __init__(self, *args, **kwargs): raise AttributeError("No constructor defined - class is abstract")
    def GetClassName():
        """GetClassName() -> OT::String"""
        return _orthogonalbasis.EnumerateFunctionImplementation_GetClassName()

    if _newclass:GetClassName = staticmethod(GetClassName)
    __swig_getmethods__["GetClassName"] = lambda x: GetClassName
    def getClassName(self):
        """getClassName(EnumerateFunctionImplementation self) -> OT::String"""
        return _orthogonalbasis.EnumerateFunctionImplementation_getClassName(self)

    def __repr__(self):
        """__repr__(EnumerateFunctionImplementation self) -> OT::String"""
        return _orthogonalbasis.EnumerateFunctionImplementation___repr__(self)

    def __call__(self, *args):
        """__call__(EnumerateFunctionImplementation self, OT::UnsignedLong const index) -> Indices"""
        return _orthogonalbasis.EnumerateFunctionImplementation___call__(self, *args)

    def inverse(self, *args):
        """inverse(EnumerateFunctionImplementation self, Indices indices) -> OT::UnsignedLong"""
        return _orthogonalbasis.EnumerateFunctionImplementation_inverse(self, *args)

    def getStrataCardinal(self, *args):
        """getStrataCardinal(EnumerateFunctionImplementation self, OT::UnsignedLong const strateIndex) -> OT::UnsignedLong"""
        return _orthogonalbasis.EnumerateFunctionImplementation_getStrataCardinal(self, *args)

    def getStrataCumulatedCardinal(self, *args):
        """getStrataCumulatedCardinal(EnumerateFunctionImplementation self, OT::UnsignedLong const strateIndex) -> OT::UnsignedLong"""
        return _orthogonalbasis.EnumerateFunctionImplementation_getStrataCumulatedCardinal(self, *args)

    def getMaximumDegreeStrataIndex(self, *args):
        """getMaximumDegreeStrataIndex(EnumerateFunctionImplementation self, OT::UnsignedLong const maximumDegree) -> OT::UnsignedLong"""
        return _orthogonalbasis.EnumerateFunctionImplementation_getMaximumDegreeStrataIndex(self, *args)

    def getMaximumDegreeCardinal(self, *args):
        """getMaximumDegreeCardinal(EnumerateFunctionImplementation self, OT::UnsignedLong const maximumDegree) -> OT::UnsignedLong"""
        return _orthogonalbasis.EnumerateFunctionImplementation_getMaximumDegreeCardinal(self, *args)

    def setDimension(self, *args):
        """setDimension(EnumerateFunctionImplementation self, OT::UnsignedLong const dimension)"""
        return _orthogonalbasis.EnumerateFunctionImplementation_setDimension(self, *args)

    def getDimension(self):
        """getDimension(EnumerateFunctionImplementation self) -> OT::UnsignedLong"""
        return _orthogonalbasis.EnumerateFunctionImplementation_getDimension(self)

    __swig_destroy__ = _orthogonalbasis.delete_EnumerateFunctionImplementation
    __del__ = lambda self : None;
EnumerateFunctionImplementation_swigregister = _orthogonalbasis.EnumerateFunctionImplementation_swigregister
EnumerateFunctionImplementation_swigregister(EnumerateFunctionImplementation)

def EnumerateFunctionImplementation_GetClassName():
  """EnumerateFunctionImplementation_GetClassName() -> OT::String"""
  return _orthogonalbasis.EnumerateFunctionImplementation_GetClassName()

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

    def getImplementationAsPersistentObject(self):
        """getImplementationAsPersistentObject(EnumerateFunctionImplementationTypedInterfaceObject self) -> PersistentObjectPointer"""
        return _orthogonalbasis.EnumerateFunctionImplementationTypedInterfaceObject_getImplementationAsPersistentObject(self)

    def setImplementationAsPersistentObject(self, *args):
        """setImplementationAsPersistentObject(EnumerateFunctionImplementationTypedInterfaceObject self, PersistentObjectPointer obj)"""
        return _orthogonalbasis.EnumerateFunctionImplementationTypedInterfaceObject_setImplementationAsPersistentObject(self, *args)

    def swap(self, *args):
        """swap(EnumerateFunctionImplementationTypedInterfaceObject self, EnumerateFunctionImplementationTypedInterfaceObject other)"""
        return _orthogonalbasis.EnumerateFunctionImplementationTypedInterfaceObject_swap(self, *args)

    def setName(self, *args):
        """setName(EnumerateFunctionImplementationTypedInterfaceObject self, OT::String const & name)"""
        return _orthogonalbasis.EnumerateFunctionImplementationTypedInterfaceObject_setName(self, *args)

    def getName(self):
        """getName(EnumerateFunctionImplementationTypedInterfaceObject self) -> OT::String"""
        return _orthogonalbasis.EnumerateFunctionImplementationTypedInterfaceObject_getName(self)

    def __eq__(self, *args):
        """__eq__(EnumerateFunctionImplementationTypedInterfaceObject self, EnumerateFunctionImplementationTypedInterfaceObject other) -> OT::Bool"""
        return _orthogonalbasis.EnumerateFunctionImplementationTypedInterfaceObject___eq__(self, *args)

    __swig_destroy__ = _orthogonalbasis.delete_EnumerateFunctionImplementationTypedInterfaceObject
    __del__ = lambda self : None;
EnumerateFunctionImplementationTypedInterfaceObject_swigregister = _orthogonalbasis.EnumerateFunctionImplementationTypedInterfaceObject_swigregister
EnumerateFunctionImplementationTypedInterfaceObject_swigregister(EnumerateFunctionImplementationTypedInterfaceObject)

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

    if _newclass:GetClassName = staticmethod(GetClassName)
    __swig_getmethods__["GetClassName"] = lambda x: GetClassName
    def getClassName(self):
        """getClassName(EnumerateFunction self) -> OT::String"""
        return _orthogonalbasis.EnumerateFunction_getClassName(self)

    def __repr__(self):
        """__repr__(EnumerateFunction self) -> OT::String"""
        return _orthogonalbasis.EnumerateFunction___repr__(self)

    def __str__(self, offset=""):
        """
        __str__(EnumerateFunction self, OT::String const & offset="") -> OT::String
        __str__(EnumerateFunction self) -> OT::String
        """
        return _orthogonalbasis.EnumerateFunction___str__(self, offset)

    def __call__(self, *args):
        """__call__(EnumerateFunction self, OT::UnsignedLong const index) -> Indices"""
        return _orthogonalbasis.EnumerateFunction___call__(self, *args)

    def inverse(self, *args):
        """inverse(EnumerateFunction self, Indices indices) -> OT::UnsignedLong"""
        return _orthogonalbasis.EnumerateFunction_inverse(self, *args)

    def getStrataCardinal(self, *args):
        """getStrataCardinal(EnumerateFunction self, OT::UnsignedLong const strataIndex) -> OT::UnsignedLong"""
        return _orthogonalbasis.EnumerateFunction_getStrataCardinal(self, *args)

    def getStrataCumulatedCardinal(self, *args):
        """getStrataCumulatedCardinal(EnumerateFunction self, OT::UnsignedLong const strataIndex) -> OT::UnsignedLong"""
        return _orthogonalbasis.EnumerateFunction_getStrataCumulatedCardinal(self, *args)

    def getMaximumDegreeStrataIndex(self, *args):
        """getMaximumDegreeStrataIndex(EnumerateFunction self, OT::UnsignedLong const maximumDegree) -> OT::UnsignedLong"""
        return _orthogonalbasis.EnumerateFunction_getMaximumDegreeStrataIndex(self, *args)

    def getMaximumDegreeCardinal(self, *args):
        """getMaximumDegreeCardinal(EnumerateFunction self, OT::UnsignedLong const maximumDegree) -> OT::UnsignedLong"""
        return _orthogonalbasis.EnumerateFunction_getMaximumDegreeCardinal(self, *args)

    def setDimension(self, *args):
        """setDimension(EnumerateFunction self, OT::UnsignedLong const dimension)"""
        return _orthogonalbasis.EnumerateFunction_setDimension(self, *args)

    def getDimension(self):
        """getDimension(EnumerateFunction self) -> OT::UnsignedLong"""
        return _orthogonalbasis.EnumerateFunction_getDimension(self)

    def __init__(self, *args): 
        """
        __init__(OT::EnumerateFunction self, EnumerateFunctionImplementation implementation) -> EnumerateFunction
        __init__(OT::EnumerateFunction self, OT::EnumerateFunction::Implementation & p_implementation) -> EnumerateFunction
        __init__(OT::EnumerateFunction self, OT::UnsignedLong const dimension=1) -> EnumerateFunction
        __init__(OT::EnumerateFunction self) -> EnumerateFunction
        __init__(OT::EnumerateFunction self, OT::UnsignedLong const dimension, OT::NumericalScalar const q) -> EnumerateFunction
        __init__(OT::EnumerateFunction self, NumericalPoint weight, OT::NumericalScalar const q) -> EnumerateFunction
        __init__(OT::EnumerateFunction self, EnumerateFunction other) -> EnumerateFunction
        """
        this = _orthogonalbasis.new_EnumerateFunction(*args)
        try: self.this.append(this)
        except: self.this = this
    __swig_destroy__ = _orthogonalbasis.delete_EnumerateFunction
    __del__ = lambda self : None;
EnumerateFunction_swigregister = _orthogonalbasis.EnumerateFunction_swigregister
EnumerateFunction_swigregister(EnumerateFunction)

def EnumerateFunction_GetClassName():
  """EnumerateFunction_GetClassName() -> OT::String"""
  return _orthogonalbasis.EnumerateFunction_GetClassName()

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

    if _newclass:GetClassName = staticmethod(GetClassName)
    __swig_getmethods__["GetClassName"] = lambda x: GetClassName
    def getClassName(self):
        """getClassName(LinearEnumerateFunction self) -> OT::String"""
        return _orthogonalbasis.LinearEnumerateFunction_getClassName(self)

    def __repr__(self):
        """__repr__(LinearEnumerateFunction self) -> OT::String"""
        return _orthogonalbasis.LinearEnumerateFunction___repr__(self)

    def __call__(self, *args):
        """__call__(LinearEnumerateFunction self, OT::UnsignedLong const index) -> Indices"""
        return _orthogonalbasis.LinearEnumerateFunction___call__(self, *args)

    def inverse(self, *args):
        """inverse(LinearEnumerateFunction self, Indices indices) -> OT::UnsignedLong"""
        return _orthogonalbasis.LinearEnumerateFunction_inverse(self, *args)

    def getStrataCardinal(self, *args):
        """getStrataCardinal(LinearEnumerateFunction self, OT::UnsignedLong const strataIndex) -> OT::UnsignedLong"""
        return _orthogonalbasis.LinearEnumerateFunction_getStrataCardinal(self, *args)

    def getStrataCumulatedCardinal(self, *args):
        """getStrataCumulatedCardinal(LinearEnumerateFunction self, OT::UnsignedLong const strataIndex) -> OT::UnsignedLong"""
        return _orthogonalbasis.LinearEnumerateFunction_getStrataCumulatedCardinal(self, *args)

    def getMaximumDegreeStrataIndex(self, *args):
        """getMaximumDegreeStrataIndex(LinearEnumerateFunction self, OT::UnsignedLong const maximumDegree) -> OT::UnsignedLong"""
        return _orthogonalbasis.LinearEnumerateFunction_getMaximumDegreeStrataIndex(self, *args)

    def __init__(self, *args): 
        """
        __init__(OT::LinearEnumerateFunction self) -> LinearEnumerateFunction
        __init__(OT::LinearEnumerateFunction self, OT::UnsignedLong const dimension) -> LinearEnumerateFunction
        __init__(OT::LinearEnumerateFunction self, LinearEnumerateFunction other) -> LinearEnumerateFunction
        """
        this = _orthogonalbasis.new_LinearEnumerateFunction(*args)
        try: self.this.append(this)
        except: self.this = this
    __swig_destroy__ = _orthogonalbasis.delete_LinearEnumerateFunction
    __del__ = lambda self : None;
LinearEnumerateFunction_swigregister = _orthogonalbasis.LinearEnumerateFunction_swigregister
LinearEnumerateFunction_swigregister(LinearEnumerateFunction)

def LinearEnumerateFunction_GetClassName():
  """LinearEnumerateFunction_GetClassName() -> OT::String"""
  return _orthogonalbasis.LinearEnumerateFunction_GetClassName()

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

    if _newclass:GetClassName = staticmethod(GetClassName)
    __swig_getmethods__["GetClassName"] = lambda x: GetClassName
    def getClassName(self):
        """getClassName(HyperbolicAnisotropicEnumerateFunction self) -> OT::String"""
        return _orthogonalbasis.HyperbolicAnisotropicEnumerateFunction_getClassName(self)

    def __repr__(self):
        """__repr__(HyperbolicAnisotropicEnumerateFunction self) -> OT::String"""
        return _orthogonalbasis.HyperbolicAnisotropicEnumerateFunction___repr__(self)

    def __call__(self, *args):
        """__call__(HyperbolicAnisotropicEnumerateFunction self, OT::UnsignedLong const index) -> Indices"""
        return _orthogonalbasis.HyperbolicAnisotropicEnumerateFunction___call__(self, *args)

    def inverse(self, *args):
        """inverse(HyperbolicAnisotropicEnumerateFunction self, Indices indices) -> OT::UnsignedLong"""
        return _orthogonalbasis.HyperbolicAnisotropicEnumerateFunction_inverse(self, *args)

    def getStrataCardinal(self, *args):
        """getStrataCardinal(HyperbolicAnisotropicEnumerateFunction self, OT::UnsignedLong const strataIndex) -> OT::UnsignedLong"""
        return _orthogonalbasis.HyperbolicAnisotropicEnumerateFunction_getStrataCardinal(self, *args)

    def getStrataCumulatedCardinal(self, *args):
        """getStrataCumulatedCardinal(HyperbolicAnisotropicEnumerateFunction self, OT::UnsignedLong const strataIndex) -> OT::UnsignedLong"""
        return _orthogonalbasis.HyperbolicAnisotropicEnumerateFunction_getStrataCumulatedCardinal(self, *args)

    def getMaximumDegreeStrataIndex(self, *args):
        """getMaximumDegreeStrataIndex(HyperbolicAnisotropicEnumerateFunction self, OT::UnsignedLong const maximumDegree) -> OT::UnsignedLong"""
        return _orthogonalbasis.HyperbolicAnisotropicEnumerateFunction_getMaximumDegreeStrataIndex(self, *args)

    def setQ(self, *args):
        """setQ(HyperbolicAnisotropicEnumerateFunction self, OT::NumericalScalar const q)"""
        return _orthogonalbasis.HyperbolicAnisotropicEnumerateFunction_setQ(self, *args)

    def getQ(self):
        """getQ(HyperbolicAnisotropicEnumerateFunction self) -> OT::NumericalScalar"""
        return _orthogonalbasis.HyperbolicAnisotropicEnumerateFunction_getQ(self)

    def setWeight(self, *args):
        """setWeight(HyperbolicAnisotropicEnumerateFunction self, NumericalPoint weight)"""
        return _orthogonalbasis.HyperbolicAnisotropicEnumerateFunction_setWeight(self, *args)

    def getWeight(self):
        """getWeight(HyperbolicAnisotropicEnumerateFunction self) -> NumericalPoint"""
        return _orthogonalbasis.HyperbolicAnisotropicEnumerateFunction_getWeight(self)

    def __init__(self, *args): 
        """
        __init__(OT::HyperbolicAnisotropicEnumerateFunction self) -> HyperbolicAnisotropicEnumerateFunction
        __init__(OT::HyperbolicAnisotropicEnumerateFunction self, OT::UnsignedLong const dimension, OT::NumericalScalar const q=OT::ResourceMap::GetAsNumericalScalar("HyperbolicAnisotropicEnumerateFunction-DefaultQ")) -> HyperbolicAnisotropicEnumerateFunction
        __init__(OT::HyperbolicAnisotropicEnumerateFunction self, OT::UnsignedLong const dimension) -> HyperbolicAnisotropicEnumerateFunction
        __init__(OT::HyperbolicAnisotropicEnumerateFunction self, NumericalPoint weight, OT::NumericalScalar const q=OT::ResourceMap::GetAsNumericalScalar("HyperbolicAnisotropicEnumerateFunction-DefaultQ")) -> HyperbolicAnisotropicEnumerateFunction
        __init__(OT::HyperbolicAnisotropicEnumerateFunction self, NumericalPoint weight) -> HyperbolicAnisotropicEnumerateFunction
        __init__(OT::HyperbolicAnisotropicEnumerateFunction self, HyperbolicAnisotropicEnumerateFunction other) -> HyperbolicAnisotropicEnumerateFunction
        """
        this = _orthogonalbasis.new_HyperbolicAnisotropicEnumerateFunction(*args)
        try: self.this.append(this)
        except: self.this = this
    __swig_destroy__ = _orthogonalbasis.delete_HyperbolicAnisotropicEnumerateFunction
    __del__ = lambda self : None;
HyperbolicAnisotropicEnumerateFunction_swigregister = _orthogonalbasis.HyperbolicAnisotropicEnumerateFunction_swigregister
HyperbolicAnisotropicEnumerateFunction_swigregister(HyperbolicAnisotropicEnumerateFunction)

def HyperbolicAnisotropicEnumerateFunction_GetClassName():
  """HyperbolicAnisotropicEnumerateFunction_GetClassName() -> OT::String"""
  return _orthogonalbasis.HyperbolicAnisotropicEnumerateFunction_GetClassName()

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

    if _newclass:GetClassName = staticmethod(GetClassName)
    __swig_getmethods__["GetClassName"] = lambda x: GetClassName
    def getClassName(self):
        """getClassName(OrthogonalUniVariatePolynomial self) -> OT::String"""
        return _orthogonalbasis.OrthogonalUniVariatePolynomial_getClassName(self)

    def __call__(self, *args):
        """__call__(OrthogonalUniVariatePolynomial self, OT::NumericalScalar const x) -> OT::NumericalScalar"""
        return _orthogonalbasis.OrthogonalUniVariatePolynomial___call__(self, *args)

    def getRecurrenceCoefficients(self):
        """getRecurrenceCoefficients(OrthogonalUniVariatePolynomial self) -> NumericalPointCollection"""
        return _orthogonalbasis.OrthogonalUniVariatePolynomial_getRecurrenceCoefficients(self)

    def getRoots(self):
        """getRoots(OrthogonalUniVariatePolynomial self) -> NumericalComplexCollection"""
        return _orthogonalbasis.OrthogonalUniVariatePolynomial_getRoots(self)

    def __init__(self, *args): 
        """
        __init__(OT::OrthogonalUniVariatePolynomial self) -> OrthogonalUniVariatePolynomial
        __init__(OT::OrthogonalUniVariatePolynomial self, NumericalPointCollection recurrenceCoefficients) -> OrthogonalUniVariatePolynomial
        __init__(OT::OrthogonalUniVariatePolynomial self, OrthogonalUniVariatePolynomial other) -> OrthogonalUniVariatePolynomial
        """
        this = _orthogonalbasis.new_OrthogonalUniVariatePolynomial(*args)
        try: self.this.append(this)
        except: self.this = this
    __swig_destroy__ = _orthogonalbasis.delete_OrthogonalUniVariatePolynomial
    __del__ = lambda self : None;
OrthogonalUniVariatePolynomial_swigregister = _orthogonalbasis.OrthogonalUniVariatePolynomial_swigregister
OrthogonalUniVariatePolynomial_swigregister(OrthogonalUniVariatePolynomial)

def OrthogonalUniVariatePolynomial_GetClassName():
  """OrthogonalUniVariatePolynomial_GetClassName() -> OT::String"""
  return _orthogonalbasis.OrthogonalUniVariatePolynomial_GetClassName()

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

    if _newclass:GetClassName = staticmethod(GetClassName)
    __swig_getmethods__["GetClassName"] = lambda x: GetClassName
    def getClassName(self):
        """getClassName(OrthogonalUniVariatePolynomialFactory self) -> OT::String"""
        return _orthogonalbasis.OrthogonalUniVariatePolynomialFactory_getClassName(self)

    ANALYSIS = _orthogonalbasis.OrthogonalUniVariatePolynomialFactory_ANALYSIS
    PROBABILITY = _orthogonalbasis.OrthogonalUniVariatePolynomialFactory_PROBABILITY
    def __repr__(self):
        """__repr__(OrthogonalUniVariatePolynomialFactory self) -> OT::String"""
        return _orthogonalbasis.OrthogonalUniVariatePolynomialFactory___repr__(self)

    def build(self, *args):
        """build(OrthogonalUniVariatePolynomialFactory self, OT::UnsignedLong const degree) -> OrthogonalUniVariatePolynomial"""
        return _orthogonalbasis.OrthogonalUniVariatePolynomialFactory_build(self, *args)

    def buildRecurrenceCoefficientsCollection(self, *args):
        """buildRecurrenceCoefficientsCollection(OrthogonalUniVariatePolynomialFactory self, OT::UnsignedLong const degree) -> NumericalPointCollection"""
        return _orthogonalbasis.OrthogonalUniVariatePolynomialFactory_buildRecurrenceCoefficientsCollection(self, *args)

    def buildCoefficients(self, *args):
        """buildCoefficients(OrthogonalUniVariatePolynomialFactory self, OT::UnsignedLong const degree) -> NumericalPoint"""
        return _orthogonalbasis.OrthogonalUniVariatePolynomialFactory_buildCoefficients(self, *args)

    def getRoots(self, *args):
        """getRoots(OrthogonalUniVariatePolynomialFactory self, OT::UnsignedLong const n) -> NumericalPoint"""
        return _orthogonalbasis.OrthogonalUniVariatePolynomialFactory_getRoots(self, *args)

    def getNodesAndWeights(self, *args):
        """getNodesAndWeights(OrthogonalUniVariatePolynomialFactory self, OT::UnsignedLong const n, NumericalPoint weights) -> NumericalPoint"""
        return _orthogonalbasis.OrthogonalUniVariatePolynomialFactory_getNodesAndWeights(self, *args)

    def getMeasure(self):
        """getMeasure(OrthogonalUniVariatePolynomialFactory self) -> Distribution"""
        return _orthogonalbasis.OrthogonalUniVariatePolynomialFactory_getMeasure(self)

    def getRecurrenceCoefficients(self, *args):
        """getRecurrenceCoefficients(OrthogonalUniVariatePolynomialFactory self, OT::UnsignedLong const n) -> NumericalPoint"""
        return _orthogonalbasis.OrthogonalUniVariatePolynomialFactory_getRecurrenceCoefficients(self, *args)

    def __init__(self, *args): 
        """
        __init__(OT::OrthogonalUniVariatePolynomialFactory self, Distribution measure) -> OrthogonalUniVariatePolynomialFactory
        __init__(OT::OrthogonalUniVariatePolynomialFactory self, OrthogonalUniVariatePolynomialFactory other) -> OrthogonalUniVariatePolynomialFactory
        """
        this = _orthogonalbasis.new_OrthogonalUniVariatePolynomialFactory(*args)
        try: self.this.append(this)
        except: self.this = this
    __swig_destroy__ = _orthogonalbasis.delete_OrthogonalUniVariatePolynomialFactory
    __del__ = lambda self : None;
OrthogonalUniVariatePolynomialFactory_swigregister = _orthogonalbasis.OrthogonalUniVariatePolynomialFactory_swigregister
OrthogonalUniVariatePolynomialFactory_swigregister(OrthogonalUniVariatePolynomialFactory)

def OrthogonalUniVariatePolynomialFactory_GetClassName():
  """OrthogonalUniVariatePolynomialFactory_GetClassName() -> OT::String"""
  return _orthogonalbasis.OrthogonalUniVariatePolynomialFactory_GetClassName()

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

    if _newclass:GetClassName = staticmethod(GetClassName)
    __swig_getmethods__["GetClassName"] = lambda x: GetClassName
    def getClassName(self):
        """getClassName(CharlierFactory self) -> OT::String"""
        return _orthogonalbasis.CharlierFactory_getClassName(self)

    def getRecurrenceCoefficients(self, *args):
        """getRecurrenceCoefficients(CharlierFactory self, OT::UnsignedLong const n) -> NumericalPoint"""
        return _orthogonalbasis.CharlierFactory_getRecurrenceCoefficients(self, *args)

    def getLambda(self):
        """getLambda(CharlierFactory self) -> OT::NumericalScalar"""
        return _orthogonalbasis.CharlierFactory_getLambda(self)

    def __repr__(self):
        """__repr__(CharlierFactory self) -> OT::String"""
        return _orthogonalbasis.CharlierFactory___repr__(self)

    def __init__(self, *args): 
        """
        __init__(OT::CharlierFactory self) -> CharlierFactory
        __init__(OT::CharlierFactory self, OT::NumericalScalar const _lambda) -> CharlierFactory
        __init__(OT::CharlierFactory self, CharlierFactory other) -> CharlierFactory
        """
        this = _orthogonalbasis.new_CharlierFactory(*args)
        try: self.this.append(this)
        except: self.this = this
    __swig_destroy__ = _orthogonalbasis.delete_CharlierFactory
    __del__ = lambda self : None;
CharlierFactory_swigregister = _orthogonalbasis.CharlierFactory_swigregister
CharlierFactory_swigregister(CharlierFactory)

def CharlierFactory_GetClassName():
  """CharlierFactory_GetClassName() -> OT::String"""
  return _orthogonalbasis.CharlierFactory_GetClassName()

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

    if _newclass:GetClassName = staticmethod(GetClassName)
    __swig_getmethods__["GetClassName"] = lambda x: GetClassName
    def getClassName(self):
        """getClassName(HermiteFactory self) -> OT::String"""
        return _orthogonalbasis.HermiteFactory_getClassName(self)

    def getRecurrenceCoefficients(self, *args):
        """getRecurrenceCoefficients(HermiteFactory self, OT::UnsignedLong const n) -> NumericalPoint"""
        return _orthogonalbasis.HermiteFactory_getRecurrenceCoefficients(self, *args)

    def __repr__(self):
        """__repr__(HermiteFactory self) -> OT::String"""
        return _orthogonalbasis.HermiteFactory___repr__(self)

    def __init__(self, *args): 
        """
        __init__(OT::HermiteFactory self) -> HermiteFactory
        __init__(OT::HermiteFactory self, HermiteFactory other) -> HermiteFactory
        """
        this = _orthogonalbasis.new_HermiteFactory(*args)
        try: self.this.append(this)
        except: self.this = this
    __swig_destroy__ = _orthogonalbasis.delete_HermiteFactory
    __del__ = lambda self : None;
HermiteFactory_swigregister = _orthogonalbasis.HermiteFactory_swigregister
HermiteFactory_swigregister(HermiteFactory)

def HermiteFactory_GetClassName():
  """HermiteFactory_GetClassName() -> OT::String"""
  return _orthogonalbasis.HermiteFactory_GetClassName()

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

    if _newclass:GetClassName = staticmethod(GetClassName)
    __swig_getmethods__["GetClassName"] = lambda x: GetClassName
    def getClassName(self):
        """getClassName(JacobiFactory self) -> OT::String"""
        return _orthogonalbasis.JacobiFactory_getClassName(self)

    def getRecurrenceCoefficients(self, *args):
        """getRecurrenceCoefficients(JacobiFactory self, OT::UnsignedLong const n) -> NumericalPoint"""
        return _orthogonalbasis.JacobiFactory_getRecurrenceCoefficients(self, *args)

    def getAlpha(self):
        """getAlpha(JacobiFactory self) -> OT::NumericalScalar"""
        return _orthogonalbasis.JacobiFactory_getAlpha(self)

    def getBeta(self):
        """getBeta(JacobiFactory self) -> OT::NumericalScalar"""
        return _orthogonalbasis.JacobiFactory_getBeta(self)

    def __repr__(self):
        """__repr__(JacobiFactory self) -> OT::String"""
        return _orthogonalbasis.JacobiFactory___repr__(self)

    def __init__(self, *args): 
        """
        __init__(OT::JacobiFactory self) -> JacobiFactory
        __init__(OT::JacobiFactory self, OT::NumericalScalar const alpha, OT::NumericalScalar const beta, OT::OrthogonalUniVariatePolynomialFactory::ParameterSet const parameterization=ANALYSIS) -> JacobiFactory
        __init__(OT::JacobiFactory self, OT::NumericalScalar const alpha, OT::NumericalScalar const beta) -> JacobiFactory
        __init__(OT::JacobiFactory self, JacobiFactory other) -> JacobiFactory
        """
        this = _orthogonalbasis.new_JacobiFactory(*args)
        try: self.this.append(this)
        except: self.this = this
    __swig_destroy__ = _orthogonalbasis.delete_JacobiFactory
    __del__ = lambda self : None;
JacobiFactory_swigregister = _orthogonalbasis.JacobiFactory_swigregister
JacobiFactory_swigregister(JacobiFactory)

def JacobiFactory_GetClassName():
  """JacobiFactory_GetClassName() -> OT::String"""
  return _orthogonalbasis.JacobiFactory_GetClassName()

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

    if _newclass:GetClassName = staticmethod(GetClassName)
    __swig_getmethods__["GetClassName"] = lambda x: GetClassName
    def getClassName(self):
        """getClassName(KrawtchoukFactory self) -> OT::String"""
        return _orthogonalbasis.KrawtchoukFactory_getClassName(self)

    def getRecurrenceCoefficients(self, *args):
        """getRecurrenceCoefficients(KrawtchoukFactory self, OT::UnsignedLong const n) -> NumericalPoint"""
        return _orthogonalbasis.KrawtchoukFactory_getRecurrenceCoefficients(self, *args)

    def getN(self):
        """getN(KrawtchoukFactory self) -> OT::UnsignedLong"""
        return _orthogonalbasis.KrawtchoukFactory_getN(self)

    def getP(self):
        """getP(KrawtchoukFactory self) -> OT::NumericalScalar"""
        return _orthogonalbasis.KrawtchoukFactory_getP(self)

    def __repr__(self):
        """__repr__(KrawtchoukFactory self) -> OT::String"""
        return _orthogonalbasis.KrawtchoukFactory___repr__(self)

    def __init__(self, *args): 
        """
        __init__(OT::KrawtchoukFactory self) -> KrawtchoukFactory
        __init__(OT::KrawtchoukFactory self, OT::UnsignedLong const n, OT::NumericalScalar const p) -> KrawtchoukFactory
        __init__(OT::KrawtchoukFactory self, KrawtchoukFactory other) -> KrawtchoukFactory
        """
        this = _orthogonalbasis.new_KrawtchoukFactory(*args)
        try: self.this.append(this)
        except: self.this = this
    __swig_destroy__ = _orthogonalbasis.delete_KrawtchoukFactory
    __del__ = lambda self : None;
KrawtchoukFactory_swigregister = _orthogonalbasis.KrawtchoukFactory_swigregister
KrawtchoukFactory_swigregister(KrawtchoukFactory)

def KrawtchoukFactory_GetClassName():
  """KrawtchoukFactory_GetClassName() -> OT::String"""
  return _orthogonalbasis.KrawtchoukFactory_GetClassName()

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

    if _newclass:GetClassName = staticmethod(GetClassName)
    __swig_getmethods__["GetClassName"] = lambda x: GetClassName
    def getClassName(self):
        """getClassName(LaguerreFactory self) -> OT::String"""
        return _orthogonalbasis.LaguerreFactory_getClassName(self)

    def getRecurrenceCoefficients(self, *args):
        """getRecurrenceCoefficients(LaguerreFactory self, OT::UnsignedLong const n) -> NumericalPoint"""
        return _orthogonalbasis.LaguerreFactory_getRecurrenceCoefficients(self, *args)

    def getK(self):
        """getK(LaguerreFactory self) -> OT::NumericalScalar"""
        return _orthogonalbasis.LaguerreFactory_getK(self)

    def __repr__(self):
        """__repr__(LaguerreFactory self) -> OT::String"""
        return _orthogonalbasis.LaguerreFactory___repr__(self)

    def __init__(self, *args): 
        """
        __init__(OT::LaguerreFactory self) -> LaguerreFactory
        __init__(OT::LaguerreFactory self, OT::NumericalScalar const k, OT::OrthogonalUniVariatePolynomialFactory::ParameterSet const parameterization=ANALYSIS) -> LaguerreFactory
        __init__(OT::LaguerreFactory self, OT::NumericalScalar const k) -> LaguerreFactory
        __init__(OT::LaguerreFactory self, LaguerreFactory other) -> LaguerreFactory
        """
        this = _orthogonalbasis.new_LaguerreFactory(*args)
        try: self.this.append(this)
        except: self.this = this
    __swig_destroy__ = _orthogonalbasis.delete_LaguerreFactory
    __del__ = lambda self : None;
LaguerreFactory_swigregister = _orthogonalbasis.LaguerreFactory_swigregister
LaguerreFactory_swigregister(LaguerreFactory)

def LaguerreFactory_GetClassName():
  """LaguerreFactory_GetClassName() -> OT::String"""
  return _orthogonalbasis.LaguerreFactory_GetClassName()

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

    if _newclass:GetClassName = staticmethod(GetClassName)
    __swig_getmethods__["GetClassName"] = lambda x: GetClassName
    def getClassName(self):
        """getClassName(LegendreFactory self) -> OT::String"""
        return _orthogonalbasis.LegendreFactory_getClassName(self)

    def getRecurrenceCoefficients(self, *args):
        """getRecurrenceCoefficients(LegendreFactory self, OT::UnsignedLong const n) -> NumericalPoint"""
        return _orthogonalbasis.LegendreFactory_getRecurrenceCoefficients(self, *args)

    def __repr__(self):
        """__repr__(LegendreFactory self) -> OT::String"""
        return _orthogonalbasis.LegendreFactory___repr__(self)

    def __init__(self, *args): 
        """
        __init__(OT::LegendreFactory self) -> LegendreFactory
        __init__(OT::LegendreFactory self, LegendreFactory other) -> LegendreFactory
        """
        this = _orthogonalbasis.new_LegendreFactory(*args)
        try: self.this.append(this)
        except: self.this = this
    __swig_destroy__ = _orthogonalbasis.delete_LegendreFactory
    __del__ = lambda self : None;
LegendreFactory_swigregister = _orthogonalbasis.LegendreFactory_swigregister
LegendreFactory_swigregister(LegendreFactory)

def LegendreFactory_GetClassName():
  """LegendreFactory_GetClassName() -> OT::String"""
  return _orthogonalbasis.LegendreFactory_GetClassName()

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

    if _newclass:GetClassName = staticmethod(GetClassName)
    __swig_getmethods__["GetClassName"] = lambda x: GetClassName
    def getClassName(self):
        """getClassName(MeixnerFactory self) -> OT::String"""
        return _orthogonalbasis.MeixnerFactory_getClassName(self)

    def getRecurrenceCoefficients(self, *args):
        """getRecurrenceCoefficients(MeixnerFactory self, OT::UnsignedLong const n) -> NumericalPoint"""
        return _orthogonalbasis.MeixnerFactory_getRecurrenceCoefficients(self, *args)

    def getR(self):
        """getR(MeixnerFactory self) -> OT::NumericalScalar"""
        return _orthogonalbasis.MeixnerFactory_getR(self)

    def getP(self):
        """getP(MeixnerFactory self) -> OT::NumericalScalar"""
        return _orthogonalbasis.MeixnerFactory_getP(self)

    def __repr__(self):
        """__repr__(MeixnerFactory self) -> OT::String"""
        return _orthogonalbasis.MeixnerFactory___repr__(self)

    def __init__(self, *args): 
        """
        __init__(OT::MeixnerFactory self) -> MeixnerFactory
        __init__(OT::MeixnerFactory self, OT::NumericalScalar const r, OT::NumericalScalar const p) -> MeixnerFactory
        __init__(OT::MeixnerFactory self, MeixnerFactory other) -> MeixnerFactory
        """
        this = _orthogonalbasis.new_MeixnerFactory(*args)
        try: self.this.append(this)
        except: self.this = this
    __swig_destroy__ = _orthogonalbasis.delete_MeixnerFactory
    __del__ = lambda self : None;
MeixnerFactory_swigregister = _orthogonalbasis.MeixnerFactory_swigregister
MeixnerFactory_swigregister(MeixnerFactory)

def MeixnerFactory_GetClassName():
  """MeixnerFactory_GetClassName() -> OT::String"""
  return _orthogonalbasis.MeixnerFactory_GetClassName()

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

    def getImplementationAsPersistentObject(self):
        """getImplementationAsPersistentObject(OrthogonalUniVariatePolynomialFactoryTypedInterfaceObject self) -> PersistentObjectPointer"""
        return _orthogonalbasis.OrthogonalUniVariatePolynomialFactoryTypedInterfaceObject_getImplementationAsPersistentObject(self)

    def setImplementationAsPersistentObject(self, *args):
        """setImplementationAsPersistentObject(OrthogonalUniVariatePolynomialFactoryTypedInterfaceObject self, PersistentObjectPointer obj)"""
        return _orthogonalbasis.OrthogonalUniVariatePolynomialFactoryTypedInterfaceObject_setImplementationAsPersistentObject(self, *args)

    def swap(self, *args):
        """swap(OrthogonalUniVariatePolynomialFactoryTypedInterfaceObject self, OrthogonalUniVariatePolynomialFactoryTypedInterfaceObject other)"""
        return _orthogonalbasis.OrthogonalUniVariatePolynomialFactoryTypedInterfaceObject_swap(self, *args)

    def setName(self, *args):
        """setName(OrthogonalUniVariatePolynomialFactoryTypedInterfaceObject self, OT::String const & name)"""
        return _orthogonalbasis.OrthogonalUniVariatePolynomialFactoryTypedInterfaceObject_setName(self, *args)

    def getName(self):
        """getName(OrthogonalUniVariatePolynomialFactoryTypedInterfaceObject self) -> OT::String"""
        return _orthogonalbasis.OrthogonalUniVariatePolynomialFactoryTypedInterfaceObject_getName(self)

    def __eq__(self, *args):
        """__eq__(OrthogonalUniVariatePolynomialFactoryTypedInterfaceObject self, OrthogonalUniVariatePolynomialFactoryTypedInterfaceObject other) -> OT::Bool"""
        return _orthogonalbasis.OrthogonalUniVariatePolynomialFactoryTypedInterfaceObject___eq__(self, *args)

    __swig_destroy__ = _orthogonalbasis.delete_OrthogonalUniVariatePolynomialFactoryTypedInterfaceObject
    __del__ = lambda self : None;
OrthogonalUniVariatePolynomialFactoryTypedInterfaceObject_swigregister = _orthogonalbasis.OrthogonalUniVariatePolynomialFactoryTypedInterfaceObject_swigregister
OrthogonalUniVariatePolynomialFactoryTypedInterfaceObject_swigregister(OrthogonalUniVariatePolynomialFactoryTypedInterfaceObject)

class PolynomialFamilyCollection(_object):
    """Proxy of C++ OT::Collection<(OT::OrthogonalUniVariatePolynomialFamily)> class"""
    __swig_setmethods__ = {}
    __setattr__ = lambda self, name, value: _swig_setattr(self, PolynomialFamilyCollection, name, value)
    __swig_getmethods__ = {}
    __getattr__ = lambda self, name: _swig_getattr(self, PolynomialFamilyCollection, name)
    __swig_destroy__ = _orthogonalbasis.delete_PolynomialFamilyCollection
    __del__ = lambda self : None;
    def clear(self):
        """clear(PolynomialFamilyCollection self)"""
        return _orthogonalbasis.PolynomialFamilyCollection_clear(self)

    def __len__(self):
        """__len__(PolynomialFamilyCollection self) -> OT::UnsignedLong"""
        return _orthogonalbasis.PolynomialFamilyCollection___len__(self)

    def __eq__(self, *args):
        """__eq__(PolynomialFamilyCollection self, PolynomialFamilyCollection rhs) -> OT::Bool"""
        return _orthogonalbasis.PolynomialFamilyCollection___eq__(self, *args)

    def __contains__(self, *args):
        """__contains__(PolynomialFamilyCollection self, OrthogonalUniVariatePolynomialFamily val) -> OT::Bool"""
        return _orthogonalbasis.PolynomialFamilyCollection___contains__(self, *args)

    def __getitem__(self, *args):
        """__getitem__(PolynomialFamilyCollection self, OT::UnsignedLong const i) -> OrthogonalUniVariatePolynomialFamily"""
        return _orthogonalbasis.PolynomialFamilyCollection___getitem__(self, *args)

    def __setitem__(self, *args):
        """__setitem__(PolynomialFamilyCollection self, OT::UnsignedLong const i, OrthogonalUniVariatePolynomialFamily val)"""
        return _orthogonalbasis.PolynomialFamilyCollection___setitem__(self, *args)

    def __delitem__(self, *args):
        """__delitem__(PolynomialFamilyCollection self, OT::UnsignedLong const i)"""
        return _orthogonalbasis.PolynomialFamilyCollection___delitem__(self, *args)

    def at(self, *args):
        """
        at(PolynomialFamilyCollection self, OT::UnsignedLong const i) -> OrthogonalUniVariatePolynomialFamily
        at(PolynomialFamilyCollection self, OT::UnsignedLong const i) -> OrthogonalUniVariatePolynomialFamily
        """
        return _orthogonalbasis.PolynomialFamilyCollection_at(self, *args)

    def add(self, *args):
        """
        add(PolynomialFamilyCollection self, OrthogonalUniVariatePolynomialFamily elt)
        add(PolynomialFamilyCollection self, PolynomialFamilyCollection coll)
        """
        return _orthogonalbasis.PolynomialFamilyCollection_add(self, *args)

    def getSize(self):
        """getSize(PolynomialFamilyCollection self) -> OT::UnsignedLong"""
        return _orthogonalbasis.PolynomialFamilyCollection_getSize(self)

    def resize(self, *args):
        """resize(PolynomialFamilyCollection self, OT::UnsignedLong const newSize)"""
        return _orthogonalbasis.PolynomialFamilyCollection_resize(self, *args)

    def isEmpty(self):
        """isEmpty(PolynomialFamilyCollection self) -> OT::Bool"""
        return _orthogonalbasis.PolynomialFamilyCollection_isEmpty(self)

    def __repr__(self):
        """__repr__(PolynomialFamilyCollection self) -> OT::String"""
        return _orthogonalbasis.PolynomialFamilyCollection___repr__(self)

    def __str__(self, offset=""):
        """
        __str__(PolynomialFamilyCollection self, OT::String const & offset="") -> OT::String
        __str__(PolynomialFamilyCollection self) -> OT::String
        """
        return _orthogonalbasis.PolynomialFamilyCollection___str__(self, offset)

    def __init__(self, *args): 
        """
        __init__(OT::Collection<(OT::OrthogonalUniVariatePolynomialFamily)> self) -> PolynomialFamilyCollection
        __init__(OT::Collection<(OT::OrthogonalUniVariatePolynomialFamily)> self, OT::UnsignedLong const size) -> PolynomialFamilyCollection
        __init__(OT::Collection<(OT::OrthogonalUniVariatePolynomialFamily)> self, OT::UnsignedLong const size, OrthogonalUniVariatePolynomialFamily value) -> PolynomialFamilyCollection
        __init__(OT::Collection<(OT::OrthogonalUniVariatePolynomialFamily)> self, PyObject * pyObj) -> PolynomialFamilyCollection
        __init__(OT::Collection<(OT::OrthogonalUniVariatePolynomialFamily)> self, PolynomialFamilyCollection other) -> PolynomialFamilyCollection
        """
        this = _orthogonalbasis.new_PolynomialFamilyCollection(*args)
        try: self.this.append(this)
        except: self.this = this
PolynomialFamilyCollection_swigregister = _orthogonalbasis.PolynomialFamilyCollection_swigregister
PolynomialFamilyCollection_swigregister(PolynomialFamilyCollection)

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

    if _newclass:GetClassName = staticmethod(GetClassName)
    __swig_getmethods__["GetClassName"] = lambda x: GetClassName
    def getClassName(self):
        """getClassName(OrthogonalUniVariatePolynomialFamily self) -> OT::String"""
        return _orthogonalbasis.OrthogonalUniVariatePolynomialFamily_getClassName(self)

    def __repr__(self):
        """__repr__(OrthogonalUniVariatePolynomialFamily self) -> OT::String"""
        return _orthogonalbasis.OrthogonalUniVariatePolynomialFamily___repr__(self)

    def build(self, *args):
        """build(OrthogonalUniVariatePolynomialFamily self, OT::UnsignedLong const degree) -> OrthogonalUniVariatePolynomial"""
        return _orthogonalbasis.OrthogonalUniVariatePolynomialFamily_build(self, *args)

    def getRoots(self, *args):
        """getRoots(OrthogonalUniVariatePolynomialFamily self, OT::UnsignedLong const n) -> NumericalPoint"""
        return _orthogonalbasis.OrthogonalUniVariatePolynomialFamily_getRoots(self, *args)

    def getNodesAndWeights(self, *args):
        """getNodesAndWeights(OrthogonalUniVariatePolynomialFamily self, OT::UnsignedLong const n, NumericalPoint weights) -> NumericalPoint"""
        return _orthogonalbasis.OrthogonalUniVariatePolynomialFamily_getNodesAndWeights(self, *args)

    def getMeasure(self):
        """getMeasure(OrthogonalUniVariatePolynomialFamily self) -> Distribution"""
        return _orthogonalbasis.OrthogonalUniVariatePolynomialFamily_getMeasure(self)

    def getRecurrenceCoefficients(self, *args):
        """getRecurrenceCoefficients(OrthogonalUniVariatePolynomialFamily self, OT::UnsignedLong const n) -> NumericalPoint"""
        return _orthogonalbasis.OrthogonalUniVariatePolynomialFamily_getRecurrenceCoefficients(self, *args)

    def __init__(self, *args): 
        """
        __init__(OT::OrthogonalUniVariatePolynomialFamily self) -> OrthogonalUniVariatePolynomialFamily
        __init__(OT::OrthogonalUniVariatePolynomialFamily self, OrthogonalUniVariatePolynomialFactory implementation) -> OrthogonalUniVariatePolynomialFamily
        __init__(OT::OrthogonalUniVariatePolynomialFamily self, OrthogonalUniVariatePolynomialFamily other) -> OrthogonalUniVariatePolynomialFamily
        """
        this = _orthogonalbasis.new_OrthogonalUniVariatePolynomialFamily(*args)
        try: self.this.append(this)
        except: self.this = this
    __swig_destroy__ = _orthogonalbasis.delete_OrthogonalUniVariatePolynomialFamily
    __del__ = lambda self : None;
OrthogonalUniVariatePolynomialFamily_swigregister = _orthogonalbasis.OrthogonalUniVariatePolynomialFamily_swigregister
OrthogonalUniVariatePolynomialFamily_swigregister(OrthogonalUniVariatePolynomialFamily)

def OrthogonalUniVariatePolynomialFamily_GetClassName():
  """OrthogonalUniVariatePolynomialFamily_GetClassName() -> OT::String"""
  return _orthogonalbasis.OrthogonalUniVariatePolynomialFamily_GetClassName()

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

    if _newclass:GetClassName = staticmethod(GetClassName)
    __swig_getmethods__["GetClassName"] = lambda x: GetClassName
    def getClassName(self):
        """getClassName(OrthonormalizationAlgorithmImplementation self) -> OT::String"""
        return _orthogonalbasis.OrthonormalizationAlgorithmImplementation_getClassName(self)

    def getRecurrenceCoefficients(self, *args):
        """getRecurrenceCoefficients(OrthonormalizationAlgorithmImplementation self, OT::UnsignedLong const n) -> NumericalPoint"""
        return _orthogonalbasis.OrthonormalizationAlgorithmImplementation_getRecurrenceCoefficients(self, *args)

    def __repr__(self):
        """__repr__(OrthonormalizationAlgorithmImplementation self) -> OT::String"""
        return _orthogonalbasis.OrthonormalizationAlgorithmImplementation___repr__(self)

    def getMeasure(self):
        """getMeasure(OrthonormalizationAlgorithmImplementation self) -> Distribution"""
        return _orthogonalbasis.OrthonormalizationAlgorithmImplementation_getMeasure(self)

    def setMeasure(self, *args):
        """setMeasure(OrthonormalizationAlgorithmImplementation self, Distribution measure)"""
        return _orthogonalbasis.OrthonormalizationAlgorithmImplementation_setMeasure(self, *args)

    def __init__(self, *args): 
        """
        __init__(OT::OrthonormalizationAlgorithmImplementation self) -> OrthonormalizationAlgorithmImplementation
        __init__(OT::OrthonormalizationAlgorithmImplementation self, Distribution measure) -> OrthonormalizationAlgorithmImplementation
        __init__(OT::OrthonormalizationAlgorithmImplementation self, OrthonormalizationAlgorithmImplementation other) -> OrthonormalizationAlgorithmImplementation
        """
        this = _orthogonalbasis.new_OrthonormalizationAlgorithmImplementation(*args)
        try: self.this.append(this)
        except: self.this = this
    __swig_destroy__ = _orthogonalbasis.delete_OrthonormalizationAlgorithmImplementation
    __del__ = lambda self : None;
OrthonormalizationAlgorithmImplementation_swigregister = _orthogonalbasis.OrthonormalizationAlgorithmImplementation_swigregister
OrthonormalizationAlgorithmImplementation_swigregister(OrthonormalizationAlgorithmImplementation)

def OrthonormalizationAlgorithmImplementation_GetClassName():
  """OrthonormalizationAlgorithmImplementation_GetClassName() -> OT::String"""
  return _orthogonalbasis.OrthonormalizationAlgorithmImplementation_GetClassName()

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

    def getImplementationAsPersistentObject(self):
        """getImplementationAsPersistentObject(OrthonormalizationAlgorithmImplementationTypedInterfaceObject self) -> PersistentObjectPointer"""
        return _orthogonalbasis.OrthonormalizationAlgorithmImplementationTypedInterfaceObject_getImplementationAsPersistentObject(self)

    def setImplementationAsPersistentObject(self, *args):
        """setImplementationAsPersistentObject(OrthonormalizationAlgorithmImplementationTypedInterfaceObject self, PersistentObjectPointer obj)"""
        return _orthogonalbasis.OrthonormalizationAlgorithmImplementationTypedInterfaceObject_setImplementationAsPersistentObject(self, *args)

    def swap(self, *args):
        """swap(OrthonormalizationAlgorithmImplementationTypedInterfaceObject self, OrthonormalizationAlgorithmImplementationTypedInterfaceObject other)"""
        return _orthogonalbasis.OrthonormalizationAlgorithmImplementationTypedInterfaceObject_swap(self, *args)

    def setName(self, *args):
        """setName(OrthonormalizationAlgorithmImplementationTypedInterfaceObject self, OT::String const & name)"""
        return _orthogonalbasis.OrthonormalizationAlgorithmImplementationTypedInterfaceObject_setName(self, *args)

    def getName(self):
        """getName(OrthonormalizationAlgorithmImplementationTypedInterfaceObject self) -> OT::String"""
        return _orthogonalbasis.OrthonormalizationAlgorithmImplementationTypedInterfaceObject_getName(self)

    def __eq__(self, *args):
        """__eq__(OrthonormalizationAlgorithmImplementationTypedInterfaceObject self, OrthonormalizationAlgorithmImplementationTypedInterfaceObject other) -> OT::Bool"""
        return _orthogonalbasis.OrthonormalizationAlgorithmImplementationTypedInterfaceObject___eq__(self, *args)

    __swig_destroy__ = _orthogonalbasis.delete_OrthonormalizationAlgorithmImplementationTypedInterfaceObject
    __del__ = lambda self : None;
OrthonormalizationAlgorithmImplementationTypedInterfaceObject_swigregister = _orthogonalbasis.OrthonormalizationAlgorithmImplementationTypedInterfaceObject_swigregister
OrthonormalizationAlgorithmImplementationTypedInterfaceObject_swigregister(OrthonormalizationAlgorithmImplementationTypedInterfaceObject)

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

    if _newclass:GetClassName = staticmethod(GetClassName)
    __swig_getmethods__["GetClassName"] = lambda x: GetClassName
    def getClassName(self):
        """getClassName(OrthonormalizationAlgorithm self) -> OT::String"""
        return _orthogonalbasis.OrthonormalizationAlgorithm_getClassName(self)

    def getRecurrenceCoefficients(self, *args):
        """getRecurrenceCoefficients(OrthonormalizationAlgorithm self, OT::UnsignedLong const n) -> NumericalPoint"""
        return _orthogonalbasis.OrthonormalizationAlgorithm_getRecurrenceCoefficients(self, *args)

    def getMeasure(self):
        """getMeasure(OrthonormalizationAlgorithm self) -> Distribution"""
        return _orthogonalbasis.OrthonormalizationAlgorithm_getMeasure(self)

    def setMeasure(self, *args):
        """setMeasure(OrthonormalizationAlgorithm self, Distribution measure)"""
        return _orthogonalbasis.OrthonormalizationAlgorithm_setMeasure(self, *args)

    def __repr__(self):
        """__repr__(OrthonormalizationAlgorithm self) -> OT::String"""
        return _orthogonalbasis.OrthonormalizationAlgorithm___repr__(self)

    def __str__(self, offset=""):
        """
        __str__(OrthonormalizationAlgorithm self, OT::String const & offset="") -> OT::String
        __str__(OrthonormalizationAlgorithm self) -> OT::String
        """
        return _orthogonalbasis.OrthonormalizationAlgorithm___str__(self, offset)

    def __init__(self, *args): 
        """
        __init__(OT::OrthonormalizationAlgorithm self, OrthonormalizationAlgorithmImplementation implementation) -> OrthonormalizationAlgorithm
        __init__(OT::OrthonormalizationAlgorithm self, OT::OrthonormalizationAlgorithm::Implementation & p_implementation) -> OrthonormalizationAlgorithm
        __init__(OT::OrthonormalizationAlgorithm self, Distribution measure) -> OrthonormalizationAlgorithm
        __init__(OT::OrthonormalizationAlgorithm self) -> OrthonormalizationAlgorithm
        __init__(OT::OrthonormalizationAlgorithm self, OrthonormalizationAlgorithm other) -> OrthonormalizationAlgorithm
        """
        this = _orthogonalbasis.new_OrthonormalizationAlgorithm(*args)
        try: self.this.append(this)
        except: self.this = this
    __swig_destroy__ = _orthogonalbasis.delete_OrthonormalizationAlgorithm
    __del__ = lambda self : None;
OrthonormalizationAlgorithm_swigregister = _orthogonalbasis.OrthonormalizationAlgorithm_swigregister
OrthonormalizationAlgorithm_swigregister(OrthonormalizationAlgorithm)

def OrthonormalizationAlgorithm_GetClassName():
  """OrthonormalizationAlgorithm_GetClassName() -> OT::String"""
  return _orthogonalbasis.OrthonormalizationAlgorithm_GetClassName()

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

    if _newclass:GetClassName = staticmethod(GetClassName)
    __swig_getmethods__["GetClassName"] = lambda x: GetClassName
    def getClassName(self):
        """getClassName(ChebychevAlgorithm self) -> OT::String"""
        return _orthogonalbasis.ChebychevAlgorithm_getClassName(self)

    def getRecurrenceCoefficients(self, *args):
        """getRecurrenceCoefficients(ChebychevAlgorithm self, OT::UnsignedLong const n) -> NumericalPoint"""
        return _orthogonalbasis.ChebychevAlgorithm_getRecurrenceCoefficients(self, *args)

    def setReferenceFamily(self, *args):
        """setReferenceFamily(ChebychevAlgorithm self, OrthogonalUniVariatePolynomialFamily family)"""
        return _orthogonalbasis.ChebychevAlgorithm_setReferenceFamily(self, *args)

    def getReferenceFamily(self):
        """getReferenceFamily(ChebychevAlgorithm self) -> OrthogonalUniVariatePolynomialFamily"""
        return _orthogonalbasis.ChebychevAlgorithm_getReferenceFamily(self)

    def __repr__(self):
        """__repr__(ChebychevAlgorithm self) -> OT::String"""
        return _orthogonalbasis.ChebychevAlgorithm___repr__(self)

    def __init__(self, *args): 
        """
        __init__(OT::ChebychevAlgorithm self) -> ChebychevAlgorithm
        __init__(OT::ChebychevAlgorithm self, Distribution measure) -> ChebychevAlgorithm
        __init__(OT::ChebychevAlgorithm self, Distribution measure, OrthogonalUniVariatePolynomialFamily family) -> ChebychevAlgorithm
        __init__(OT::ChebychevAlgorithm self, ChebychevAlgorithm other) -> ChebychevAlgorithm
        """
        this = _orthogonalbasis.new_ChebychevAlgorithm(*args)
        try: self.this.append(this)
        except: self.this = this
    __swig_destroy__ = _orthogonalbasis.delete_ChebychevAlgorithm
    __del__ = lambda self : None;
ChebychevAlgorithm_swigregister = _orthogonalbasis.ChebychevAlgorithm_swigregister
ChebychevAlgorithm_swigregister(ChebychevAlgorithm)

def ChebychevAlgorithm_GetClassName():
  """ChebychevAlgorithm_GetClassName() -> OT::String"""
  return _orthogonalbasis.ChebychevAlgorithm_GetClassName()

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

    if _newclass:GetClassName = staticmethod(GetClassName)
    __swig_getmethods__["GetClassName"] = lambda x: GetClassName
    def getClassName(self):
        """getClassName(GramSchmidtAlgorithm self) -> OT::String"""
        return _orthogonalbasis.GramSchmidtAlgorithm_getClassName(self)

    def getRecurrenceCoefficients(self, *args):
        """getRecurrenceCoefficients(GramSchmidtAlgorithm self, OT::UnsignedLong const n) -> NumericalPoint"""
        return _orthogonalbasis.GramSchmidtAlgorithm_getRecurrenceCoefficients(self, *args)

    def setReferenceFamily(self, *args):
        """setReferenceFamily(GramSchmidtAlgorithm self, OrthogonalUniVariatePolynomialFamily family)"""
        return _orthogonalbasis.GramSchmidtAlgorithm_setReferenceFamily(self, *args)

    def getReferenceFamily(self):
        """getReferenceFamily(GramSchmidtAlgorithm self) -> OrthogonalUniVariatePolynomialFamily"""
        return _orthogonalbasis.GramSchmidtAlgorithm_getReferenceFamily(self)

    def __repr__(self):
        """__repr__(GramSchmidtAlgorithm self) -> OT::String"""
        return _orthogonalbasis.GramSchmidtAlgorithm___repr__(self)

    def __init__(self, *args): 
        """
        __init__(OT::GramSchmidtAlgorithm self) -> GramSchmidtAlgorithm
        __init__(OT::GramSchmidtAlgorithm self, Distribution measure) -> GramSchmidtAlgorithm
        __init__(OT::GramSchmidtAlgorithm self, Distribution measure, OrthogonalUniVariatePolynomialFamily referenceFamily) -> GramSchmidtAlgorithm
        __init__(OT::GramSchmidtAlgorithm self, GramSchmidtAlgorithm other) -> GramSchmidtAlgorithm
        """
        this = _orthogonalbasis.new_GramSchmidtAlgorithm(*args)
        try: self.this.append(this)
        except: self.this = this
    __swig_destroy__ = _orthogonalbasis.delete_GramSchmidtAlgorithm
    __del__ = lambda self : None;
GramSchmidtAlgorithm_swigregister = _orthogonalbasis.GramSchmidtAlgorithm_swigregister
GramSchmidtAlgorithm_swigregister(GramSchmidtAlgorithm)

def GramSchmidtAlgorithm_GetClassName():
  """GramSchmidtAlgorithm_GetClassName() -> OT::String"""
  return _orthogonalbasis.GramSchmidtAlgorithm_GetClassName()

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

    if _newclass:GetClassName = staticmethod(GetClassName)
    __swig_getmethods__["GetClassName"] = lambda x: GetClassName
    def getClassName(self):
        """getClassName(StandardDistributionPolynomialFactory self) -> OT::String"""
        return _orthogonalbasis.StandardDistributionPolynomialFactory_getClassName(self)

    def getRecurrenceCoefficients(self, *args):
        """getRecurrenceCoefficients(StandardDistributionPolynomialFactory self, OT::UnsignedLong const n) -> NumericalPoint"""
        return _orthogonalbasis.StandardDistributionPolynomialFactory_getRecurrenceCoefficients(self, *args)

    def __repr__(self):
        """__repr__(StandardDistributionPolynomialFactory self) -> OT::String"""
        return _orthogonalbasis.StandardDistributionPolynomialFactory___repr__(self)

    def __init__(self, *args): 
        """
        __init__(OT::StandardDistributionPolynomialFactory self) -> StandardDistributionPolynomialFactory
        __init__(OT::StandardDistributionPolynomialFactory self, Distribution distribution) -> StandardDistributionPolynomialFactory
        __init__(OT::StandardDistributionPolynomialFactory self, OrthonormalizationAlgorithm orthonormalizationAlgorithm) -> StandardDistributionPolynomialFactory
        __init__(OT::StandardDistributionPolynomialFactory self, StandardDistributionPolynomialFactory other) -> StandardDistributionPolynomialFactory
        """
        this = _orthogonalbasis.new_StandardDistributionPolynomialFactory(*args)
        try: self.this.append(this)
        except: self.this = this
    __swig_destroy__ = _orthogonalbasis.delete_StandardDistributionPolynomialFactory
    __del__ = lambda self : None;
StandardDistributionPolynomialFactory_swigregister = _orthogonalbasis.StandardDistributionPolynomialFactory_swigregister
StandardDistributionPolynomialFactory_swigregister(StandardDistributionPolynomialFactory)

def StandardDistributionPolynomialFactory_GetClassName():
  """StandardDistributionPolynomialFactory_GetClassName() -> OT::String"""
  return _orthogonalbasis.StandardDistributionPolynomialFactory_GetClassName()

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

    if _newclass:GetClassName = staticmethod(GetClassName)
    __swig_getmethods__["GetClassName"] = lambda x: GetClassName
    def getClassName(self):
        """getClassName(OrthogonalFunctionFactory self) -> OT::String"""
        return _orthogonalbasis.OrthogonalFunctionFactory_getClassName(self)

    def build(self, *args):
        """build(OrthogonalFunctionFactory self, OT::UnsignedLong const index) -> NumericalMathFunction"""
        return _orthogonalbasis.OrthogonalFunctionFactory_build(self, *args)

    def getMeasure(self):
        """getMeasure(OrthogonalFunctionFactory self) -> Distribution"""
        return _orthogonalbasis.OrthogonalFunctionFactory_getMeasure(self)

    def getEnumerateFunction(self):
        """getEnumerateFunction(OrthogonalFunctionFactory self) -> EnumerateFunction"""
        return _orthogonalbasis.OrthogonalFunctionFactory_getEnumerateFunction(self)

    def __repr__(self):
        """__repr__(OrthogonalFunctionFactory self) -> OT::String"""
        return _orthogonalbasis.OrthogonalFunctionFactory___repr__(self)

    def __init__(self, *args): 
        """
        __init__(OT::OrthogonalFunctionFactory self) -> OrthogonalFunctionFactory
        __init__(OT::OrthogonalFunctionFactory self, OrthogonalFunctionFactory other) -> OrthogonalFunctionFactory
        """
        this = _orthogonalbasis.new_OrthogonalFunctionFactory(*args)
        try: self.this.append(this)
        except: self.this = this
    __swig_destroy__ = _orthogonalbasis.delete_OrthogonalFunctionFactory
    __del__ = lambda self : None;
OrthogonalFunctionFactory_swigregister = _orthogonalbasis.OrthogonalFunctionFactory_swigregister
OrthogonalFunctionFactory_swigregister(OrthogonalFunctionFactory)

def OrthogonalFunctionFactory_GetClassName():
  """OrthogonalFunctionFactory_GetClassName() -> OT::String"""
  return _orthogonalbasis.OrthogonalFunctionFactory_GetClassName()

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

    if _newclass:GetClassName = staticmethod(GetClassName)
    __swig_getmethods__["GetClassName"] = lambda x: GetClassName
    def getClassName(self):
        """getClassName(OrthogonalProductPolynomialFactory self) -> OT::String"""
        return _orthogonalbasis.OrthogonalProductPolynomialFactory_getClassName(self)

    def build(self, *args):
        """build(OrthogonalProductPolynomialFactory self, OT::UnsignedLong const index) -> NumericalMathFunction"""
        return _orthogonalbasis.OrthogonalProductPolynomialFactory_build(self, *args)

    def getEnumerateFunction(self):
        """getEnumerateFunction(OrthogonalProductPolynomialFactory self) -> EnumerateFunction"""
        return _orthogonalbasis.OrthogonalProductPolynomialFactory_getEnumerateFunction(self)

    def getPolynomialFamilyCollection(self):
        """getPolynomialFamilyCollection(OrthogonalProductPolynomialFactory self) -> PolynomialFamilyCollection"""
        return _orthogonalbasis.OrthogonalProductPolynomialFactory_getPolynomialFamilyCollection(self)

    def getNodesAndWeights(self, *args):
        """getNodesAndWeights(OrthogonalProductPolynomialFactory self, Indices degrees, NumericalPoint weights) -> NumericalSample"""
        return _orthogonalbasis.OrthogonalProductPolynomialFactory_getNodesAndWeights(self, *args)

    def __repr__(self):
        """__repr__(OrthogonalProductPolynomialFactory self) -> OT::String"""
        return _orthogonalbasis.OrthogonalProductPolynomialFactory___repr__(self)

    def __init__(self, *args): 
        """
        __init__(OT::OrthogonalProductPolynomialFactory self) -> OrthogonalProductPolynomialFactory
        __init__(OT::OrthogonalProductPolynomialFactory self, PolynomialFamilyCollection coll) -> OrthogonalProductPolynomialFactory
        __init__(OT::OrthogonalProductPolynomialFactory self, PolynomialFamilyCollection coll, EnumerateFunction phi) -> OrthogonalProductPolynomialFactory
        __init__(OT::OrthogonalProductPolynomialFactory self, OrthogonalProductPolynomialFactory other) -> OrthogonalProductPolynomialFactory
        """
        this = _orthogonalbasis.new_OrthogonalProductPolynomialFactory(*args)
        try: self.this.append(this)
        except: self.this = this
    __swig_destroy__ = _orthogonalbasis.delete_OrthogonalProductPolynomialFactory
    __del__ = lambda self : None;
OrthogonalProductPolynomialFactory_swigregister = _orthogonalbasis.OrthogonalProductPolynomialFactory_swigregister
OrthogonalProductPolynomialFactory_swigregister(OrthogonalProductPolynomialFactory)

def OrthogonalProductPolynomialFactory_GetClassName():
  """OrthogonalProductPolynomialFactory_GetClassName() -> OT::String"""
  return _orthogonalbasis.OrthogonalProductPolynomialFactory_GetClassName()

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

    def getImplementationAsPersistentObject(self):
        """getImplementationAsPersistentObject(OrthogonalFunctionFactoryTypedInterfaceObject self) -> PersistentObjectPointer"""
        return _orthogonalbasis.OrthogonalFunctionFactoryTypedInterfaceObject_getImplementationAsPersistentObject(self)

    def setImplementationAsPersistentObject(self, *args):
        """setImplementationAsPersistentObject(OrthogonalFunctionFactoryTypedInterfaceObject self, PersistentObjectPointer obj)"""
        return _orthogonalbasis.OrthogonalFunctionFactoryTypedInterfaceObject_setImplementationAsPersistentObject(self, *args)

    def swap(self, *args):
        """swap(OrthogonalFunctionFactoryTypedInterfaceObject self, OrthogonalFunctionFactoryTypedInterfaceObject other)"""
        return _orthogonalbasis.OrthogonalFunctionFactoryTypedInterfaceObject_swap(self, *args)

    def setName(self, *args):
        """setName(OrthogonalFunctionFactoryTypedInterfaceObject self, OT::String const & name)"""
        return _orthogonalbasis.OrthogonalFunctionFactoryTypedInterfaceObject_setName(self, *args)

    def getName(self):
        """getName(OrthogonalFunctionFactoryTypedInterfaceObject self) -> OT::String"""
        return _orthogonalbasis.OrthogonalFunctionFactoryTypedInterfaceObject_getName(self)

    def __eq__(self, *args):
        """__eq__(OrthogonalFunctionFactoryTypedInterfaceObject self, OrthogonalFunctionFactoryTypedInterfaceObject other) -> OT::Bool"""
        return _orthogonalbasis.OrthogonalFunctionFactoryTypedInterfaceObject___eq__(self, *args)

    __swig_destroy__ = _orthogonalbasis.delete_OrthogonalFunctionFactoryTypedInterfaceObject
    __del__ = lambda self : None;
OrthogonalFunctionFactoryTypedInterfaceObject_swigregister = _orthogonalbasis.OrthogonalFunctionFactoryTypedInterfaceObject_swigregister
OrthogonalFunctionFactoryTypedInterfaceObject_swigregister(OrthogonalFunctionFactoryTypedInterfaceObject)

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

    if _newclass:GetClassName = staticmethod(GetClassName)
    __swig_getmethods__["GetClassName"] = lambda x: GetClassName
    def getClassName(self):
        """getClassName(OrthogonalBasis self) -> OT::String"""
        return _orthogonalbasis.OrthogonalBasis_getClassName(self)

    def build(self, *args):
        """build(OrthogonalBasis self, OT::UnsignedLong const index) -> NumericalMathFunction"""
        return _orthogonalbasis.OrthogonalBasis_build(self, *args)

    def getMeasure(self):
        """getMeasure(OrthogonalBasis self) -> Distribution"""
        return _orthogonalbasis.OrthogonalBasis_getMeasure(self)

    def getEnumerateFunction(self):
        """getEnumerateFunction(OrthogonalBasis self) -> EnumerateFunction"""
        return _orthogonalbasis.OrthogonalBasis_getEnumerateFunction(self)

    def __repr__(self):
        """__repr__(OrthogonalBasis self) -> OT::String"""
        return _orthogonalbasis.OrthogonalBasis___repr__(self)

    def __init__(self, *args): 
        """
        __init__(OT::OrthogonalBasis self) -> OrthogonalBasis
        __init__(OT::OrthogonalBasis self, OrthogonalFunctionFactory implementation) -> OrthogonalBasis
        __init__(OT::OrthogonalBasis self, OrthogonalBasis other) -> OrthogonalBasis
        """
        this = _orthogonalbasis.new_OrthogonalBasis(*args)
        try: self.this.append(this)
        except: self.this = this
    __swig_destroy__ = _orthogonalbasis.delete_OrthogonalBasis
    __del__ = lambda self : None;
OrthogonalBasis_swigregister = _orthogonalbasis.OrthogonalBasis_swigregister
OrthogonalBasis_swigregister(OrthogonalBasis)

def OrthogonalBasis_GetClassName():
  """OrthogonalBasis_GetClassName() -> OT::String"""
  return _orthogonalbasis.OrthogonalBasis_GetClassName()

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