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


"""
Transformations.
"""


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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

    if _newclass:GetClassName = staticmethod(GetClassName)
    __swig_getmethods__["GetClassName"] = lambda x: GetClassName
    def getClassName(self):
        """getClassName(MarginalTransformationEvaluation self) -> OT::String"""
        return _transformation.MarginalTransformationEvaluation_getClassName(self)

    FROM = _transformation.MarginalTransformationEvaluation_FROM
    TO = _transformation.MarginalTransformationEvaluation_TO
    FROMTO = _transformation.MarginalTransformationEvaluation_FROMTO
    def __call__(self, *args):
        """__call__(MarginalTransformationEvaluation self, NumericalPoint inP) -> NumericalPoint"""
        return _transformation.MarginalTransformationEvaluation___call__(self, *args)

    def parametersGradient(self, *args):
        """parametersGradient(MarginalTransformationEvaluation self, NumericalPoint inP) -> Matrix"""
        return _transformation.MarginalTransformationEvaluation_parametersGradient(self, *args)

    def getInputDimension(self):
        """getInputDimension(MarginalTransformationEvaluation self) -> OT::UnsignedLong"""
        return _transformation.MarginalTransformationEvaluation_getInputDimension(self)

    def getOutputDimension(self):
        """getOutputDimension(MarginalTransformationEvaluation self) -> OT::UnsignedLong"""
        return _transformation.MarginalTransformationEvaluation_getOutputDimension(self)

    def setDirection(self, *args):
        """setDirection(MarginalTransformationEvaluation self, OT::MarginalTransformationEvaluation::TranformationDirection const direction)"""
        return _transformation.MarginalTransformationEvaluation_setDirection(self, *args)

    def getDirection(self):
        """getDirection(MarginalTransformationEvaluation self) -> OT::UnsignedLong"""
        return _transformation.MarginalTransformationEvaluation_getDirection(self)

    def setInputDistributionCollection(self, *args):
        """setInputDistributionCollection(MarginalTransformationEvaluation self, DistributionCollection inputDistributionCollection)"""
        return _transformation.MarginalTransformationEvaluation_setInputDistributionCollection(self, *args)

    def getInputDistributionCollection(self):
        """getInputDistributionCollection(MarginalTransformationEvaluation self) -> DistributionCollection"""
        return _transformation.MarginalTransformationEvaluation_getInputDistributionCollection(self)

    def setOutputDistributionCollection(self, *args):
        """setOutputDistributionCollection(MarginalTransformationEvaluation self, DistributionCollection outputDistributionCollection)"""
        return _transformation.MarginalTransformationEvaluation_setOutputDistributionCollection(self, *args)

    def getOutputDistributionCollection(self):
        """getOutputDistributionCollection(MarginalTransformationEvaluation self) -> DistributionCollection"""
        return _transformation.MarginalTransformationEvaluation_getOutputDistributionCollection(self)

    def getSimplifications(self):
        """getSimplifications(MarginalTransformationEvaluation self) -> UnsignedLongCollection"""
        return _transformation.MarginalTransformationEvaluation_getSimplifications(self)

    def getExpressions(self):
        """getExpressions(MarginalTransformationEvaluation self) -> NumericalMathFunctionCollection"""
        return _transformation.MarginalTransformationEvaluation_getExpressions(self)

    def __repr__(self):
        """__repr__(MarginalTransformationEvaluation self) -> OT::String"""
        return _transformation.MarginalTransformationEvaluation___repr__(self)

    def __str__(self, offset=""):
        """
        __str__(MarginalTransformationEvaluation self, OT::String const & offset="") -> OT::String
        __str__(MarginalTransformationEvaluation self) -> OT::String
        """
        return _transformation.MarginalTransformationEvaluation___str__(self, offset)

    def __init__(self, *args): 
        """
        __init__(OT::MarginalTransformationEvaluation self) -> MarginalTransformationEvaluation
        __init__(OT::MarginalTransformationEvaluation self, DistributionCollection distributionCollection, OT::UnsignedLong const direction=FROM) -> MarginalTransformationEvaluation
        __init__(OT::MarginalTransformationEvaluation self, DistributionCollection distributionCollection) -> MarginalTransformationEvaluation
        __init__(OT::MarginalTransformationEvaluation self, DistributionCollection inputDistributionCollection, DistributionCollection outputDistributionCollection, 
            OT::Bool const simplify=True) -> MarginalTransformationEvaluation
        __init__(OT::MarginalTransformationEvaluation self, DistributionCollection inputDistributionCollection, DistributionCollection outputDistributionCollection) -> MarginalTransformationEvaluation
        __init__(OT::MarginalTransformationEvaluation self, MarginalTransformationEvaluation other) -> MarginalTransformationEvaluation
        """
        this = _transformation.new_MarginalTransformationEvaluation(*args)
        try: self.this.append(this)
        except: self.this = this
    __swig_destroy__ = _transformation.delete_MarginalTransformationEvaluation
    __del__ = lambda self : None;
MarginalTransformationEvaluation_swigregister = _transformation.MarginalTransformationEvaluation_swigregister
MarginalTransformationEvaluation_swigregister(MarginalTransformationEvaluation)

def MarginalTransformationEvaluation_GetClassName():
  """MarginalTransformationEvaluation_GetClassName() -> OT::String"""
  return _transformation.MarginalTransformationEvaluation_GetClassName()

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

    if _newclass:GetClassName = staticmethod(GetClassName)
    __swig_getmethods__["GetClassName"] = lambda x: GetClassName
    def getClassName(self):
        """getClassName(MarginalTransformationGradient self) -> OT::String"""
        return _transformation.MarginalTransformationGradient_getClassName(self)

    def gradient(self, *args):
        """gradient(MarginalTransformationGradient self, NumericalPoint inP) -> Matrix"""
        return _transformation.MarginalTransformationGradient_gradient(self, *args)

    def getInputDimension(self):
        """getInputDimension(MarginalTransformationGradient self) -> OT::UnsignedLong"""
        return _transformation.MarginalTransformationGradient_getInputDimension(self)

    def getOutputDimension(self):
        """getOutputDimension(MarginalTransformationGradient self) -> OT::UnsignedLong"""
        return _transformation.MarginalTransformationGradient_getOutputDimension(self)

    def __repr__(self):
        """__repr__(MarginalTransformationGradient self) -> OT::String"""
        return _transformation.MarginalTransformationGradient___repr__(self)

    def __str__(self, offset=""):
        """
        __str__(MarginalTransformationGradient self, OT::String const & offset="") -> OT::String
        __str__(MarginalTransformationGradient self) -> OT::String
        """
        return _transformation.MarginalTransformationGradient___str__(self, offset)

    def __init__(self, *args): 
        """
        __init__(OT::MarginalTransformationGradient self) -> MarginalTransformationGradient
        __init__(OT::MarginalTransformationGradient self, MarginalTransformationEvaluation evaluation) -> MarginalTransformationGradient
        __init__(OT::MarginalTransformationGradient self, MarginalTransformationGradient other) -> MarginalTransformationGradient
        """
        this = _transformation.new_MarginalTransformationGradient(*args)
        try: self.this.append(this)
        except: self.this = this
    __swig_destroy__ = _transformation.delete_MarginalTransformationGradient
    __del__ = lambda self : None;
MarginalTransformationGradient_swigregister = _transformation.MarginalTransformationGradient_swigregister
MarginalTransformationGradient_swigregister(MarginalTransformationGradient)

def MarginalTransformationGradient_GetClassName():
  """MarginalTransformationGradient_GetClassName() -> OT::String"""
  return _transformation.MarginalTransformationGradient_GetClassName()

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

    if _newclass:GetClassName = staticmethod(GetClassName)
    __swig_getmethods__["GetClassName"] = lambda x: GetClassName
    def getClassName(self):
        """getClassName(MarginalTransformationHessian self) -> OT::String"""
        return _transformation.MarginalTransformationHessian_getClassName(self)

    def hessian(self, *args):
        """hessian(MarginalTransformationHessian self, NumericalPoint inP) -> SymmetricTensor"""
        return _transformation.MarginalTransformationHessian_hessian(self, *args)

    def getInputDimension(self):
        """getInputDimension(MarginalTransformationHessian self) -> OT::UnsignedLong"""
        return _transformation.MarginalTransformationHessian_getInputDimension(self)

    def getOutputDimension(self):
        """getOutputDimension(MarginalTransformationHessian self) -> OT::UnsignedLong"""
        return _transformation.MarginalTransformationHessian_getOutputDimension(self)

    def __repr__(self):
        """__repr__(MarginalTransformationHessian self) -> OT::String"""
        return _transformation.MarginalTransformationHessian___repr__(self)

    def __str__(self, offset=""):
        """
        __str__(MarginalTransformationHessian self, OT::String const & offset="") -> OT::String
        __str__(MarginalTransformationHessian self) -> OT::String
        """
        return _transformation.MarginalTransformationHessian___str__(self, offset)

    def __init__(self, *args): 
        """
        __init__(OT::MarginalTransformationHessian self) -> MarginalTransformationHessian
        __init__(OT::MarginalTransformationHessian self, MarginalTransformationEvaluation evaluation) -> MarginalTransformationHessian
        __init__(OT::MarginalTransformationHessian self, MarginalTransformationHessian other) -> MarginalTransformationHessian
        """
        this = _transformation.new_MarginalTransformationHessian(*args)
        try: self.this.append(this)
        except: self.this = this
    __swig_destroy__ = _transformation.delete_MarginalTransformationHessian
    __del__ = lambda self : None;
MarginalTransformationHessian_swigregister = _transformation.MarginalTransformationHessian_swigregister
MarginalTransformationHessian_swigregister(MarginalTransformationHessian)

def MarginalTransformationHessian_GetClassName():
  """MarginalTransformationHessian_GetClassName() -> OT::String"""
  return _transformation.MarginalTransformationHessian_GetClassName()

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

    if _newclass:GetClassName = staticmethod(GetClassName)
    __swig_getmethods__["GetClassName"] = lambda x: GetClassName
    def getClassName(self):
        """getClassName(NatafEllipticalCopulaEvaluation self) -> OT::String"""
        return _transformation.NatafEllipticalCopulaEvaluation_getClassName(self)

    def __call__(self, *args):
        """__call__(NatafEllipticalCopulaEvaluation self, NumericalPoint inP) -> NumericalPoint"""
        return _transformation.NatafEllipticalCopulaEvaluation___call__(self, *args)

    def parametersGradient(self, *args):
        """parametersGradient(NatafEllipticalCopulaEvaluation self, NumericalPoint inP) -> Matrix"""
        return _transformation.NatafEllipticalCopulaEvaluation_parametersGradient(self, *args)

    def getInputDimension(self):
        """getInputDimension(NatafEllipticalCopulaEvaluation self) -> OT::UnsignedLong"""
        return _transformation.NatafEllipticalCopulaEvaluation_getInputDimension(self)

    def getOutputDimension(self):
        """getOutputDimension(NatafEllipticalCopulaEvaluation self) -> OT::UnsignedLong"""
        return _transformation.NatafEllipticalCopulaEvaluation_getOutputDimension(self)

    def __repr__(self):
        """__repr__(NatafEllipticalCopulaEvaluation self) -> OT::String"""
        return _transformation.NatafEllipticalCopulaEvaluation___repr__(self)

    def __init__(self, *args): 
        """
        __init__(OT::NatafEllipticalCopulaEvaluation self) -> NatafEllipticalCopulaEvaluation
        __init__(OT::NatafEllipticalCopulaEvaluation self, Distribution standardDistribution, SquareMatrix inverseCholesky) -> NatafEllipticalCopulaEvaluation
        __init__(OT::NatafEllipticalCopulaEvaluation self, NatafEllipticalCopulaEvaluation other) -> NatafEllipticalCopulaEvaluation
        """
        this = _transformation.new_NatafEllipticalCopulaEvaluation(*args)
        try: self.this.append(this)
        except: self.this = this
    __swig_destroy__ = _transformation.delete_NatafEllipticalCopulaEvaluation
    __del__ = lambda self : None;
NatafEllipticalCopulaEvaluation_swigregister = _transformation.NatafEllipticalCopulaEvaluation_swigregister
NatafEllipticalCopulaEvaluation_swigregister(NatafEllipticalCopulaEvaluation)

def NatafEllipticalCopulaEvaluation_GetClassName():
  """NatafEllipticalCopulaEvaluation_GetClassName() -> OT::String"""
  return _transformation.NatafEllipticalCopulaEvaluation_GetClassName()

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

    if _newclass:GetClassName = staticmethod(GetClassName)
    __swig_getmethods__["GetClassName"] = lambda x: GetClassName
    def getClassName(self):
        """getClassName(NatafEllipticalCopulaGradient self) -> OT::String"""
        return _transformation.NatafEllipticalCopulaGradient_getClassName(self)

    def gradient(self, *args):
        """gradient(NatafEllipticalCopulaGradient self, NumericalPoint inP) -> Matrix"""
        return _transformation.NatafEllipticalCopulaGradient_gradient(self, *args)

    def getInputDimension(self):
        """getInputDimension(NatafEllipticalCopulaGradient self) -> OT::UnsignedLong"""
        return _transformation.NatafEllipticalCopulaGradient_getInputDimension(self)

    def getOutputDimension(self):
        """getOutputDimension(NatafEllipticalCopulaGradient self) -> OT::UnsignedLong"""
        return _transformation.NatafEllipticalCopulaGradient_getOutputDimension(self)

    def __repr__(self):
        """__repr__(NatafEllipticalCopulaGradient self) -> OT::String"""
        return _transformation.NatafEllipticalCopulaGradient___repr__(self)

    def __init__(self, *args): 
        """
        __init__(OT::NatafEllipticalCopulaGradient self) -> NatafEllipticalCopulaGradient
        __init__(OT::NatafEllipticalCopulaGradient self, Distribution standardDistribution, SquareMatrix inverseCholesky) -> NatafEllipticalCopulaGradient
        __init__(OT::NatafEllipticalCopulaGradient self, NatafEllipticalCopulaGradient other) -> NatafEllipticalCopulaGradient
        """
        this = _transformation.new_NatafEllipticalCopulaGradient(*args)
        try: self.this.append(this)
        except: self.this = this
    __swig_destroy__ = _transformation.delete_NatafEllipticalCopulaGradient
    __del__ = lambda self : None;
NatafEllipticalCopulaGradient_swigregister = _transformation.NatafEllipticalCopulaGradient_swigregister
NatafEllipticalCopulaGradient_swigregister(NatafEllipticalCopulaGradient)

def NatafEllipticalCopulaGradient_GetClassName():
  """NatafEllipticalCopulaGradient_GetClassName() -> OT::String"""
  return _transformation.NatafEllipticalCopulaGradient_GetClassName()

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

    if _newclass:GetClassName = staticmethod(GetClassName)
    __swig_getmethods__["GetClassName"] = lambda x: GetClassName
    def getClassName(self):
        """getClassName(NatafEllipticalCopulaHessian self) -> OT::String"""
        return _transformation.NatafEllipticalCopulaHessian_getClassName(self)

    def hessian(self, *args):
        """hessian(NatafEllipticalCopulaHessian self, NumericalPoint inP) -> SymmetricTensor"""
        return _transformation.NatafEllipticalCopulaHessian_hessian(self, *args)

    def getInputDimension(self):
        """getInputDimension(NatafEllipticalCopulaHessian self) -> OT::UnsignedLong"""
        return _transformation.NatafEllipticalCopulaHessian_getInputDimension(self)

    def getOutputDimension(self):
        """getOutputDimension(NatafEllipticalCopulaHessian self) -> OT::UnsignedLong"""
        return _transformation.NatafEllipticalCopulaHessian_getOutputDimension(self)

    def __repr__(self):
        """__repr__(NatafEllipticalCopulaHessian self) -> OT::String"""
        return _transformation.NatafEllipticalCopulaHessian___repr__(self)

    def __init__(self, *args): 
        """
        __init__(OT::NatafEllipticalCopulaHessian self) -> NatafEllipticalCopulaHessian
        __init__(OT::NatafEllipticalCopulaHessian self, Distribution standardDistribution, SquareMatrix inverseCholesky) -> NatafEllipticalCopulaHessian
        __init__(OT::NatafEllipticalCopulaHessian self, NatafEllipticalCopulaHessian other) -> NatafEllipticalCopulaHessian
        """
        this = _transformation.new_NatafEllipticalCopulaHessian(*args)
        try: self.this.append(this)
        except: self.this = this
    __swig_destroy__ = _transformation.delete_NatafEllipticalCopulaHessian
    __del__ = lambda self : None;
NatafEllipticalCopulaHessian_swigregister = _transformation.NatafEllipticalCopulaHessian_swigregister
NatafEllipticalCopulaHessian_swigregister(NatafEllipticalCopulaHessian)

def NatafEllipticalCopulaHessian_GetClassName():
  """NatafEllipticalCopulaHessian_GetClassName() -> OT::String"""
  return _transformation.NatafEllipticalCopulaHessian_GetClassName()

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

    if _newclass:GetClassName = staticmethod(GetClassName)
    __swig_getmethods__["GetClassName"] = lambda x: GetClassName
    def getClassName(self):
        """getClassName(InverseNatafEllipticalCopulaEvaluation self) -> OT::String"""
        return _transformation.InverseNatafEllipticalCopulaEvaluation_getClassName(self)

    def __call__(self, *args):
        """__call__(InverseNatafEllipticalCopulaEvaluation self, NumericalPoint inP) -> NumericalPoint"""
        return _transformation.InverseNatafEllipticalCopulaEvaluation___call__(self, *args)

    def parametersGradient(self, *args):
        """parametersGradient(InverseNatafEllipticalCopulaEvaluation self, NumericalPoint inP) -> Matrix"""
        return _transformation.InverseNatafEllipticalCopulaEvaluation_parametersGradient(self, *args)

    def getInputDimension(self):
        """getInputDimension(InverseNatafEllipticalCopulaEvaluation self) -> OT::UnsignedLong"""
        return _transformation.InverseNatafEllipticalCopulaEvaluation_getInputDimension(self)

    def getOutputDimension(self):
        """getOutputDimension(InverseNatafEllipticalCopulaEvaluation self) -> OT::UnsignedLong"""
        return _transformation.InverseNatafEllipticalCopulaEvaluation_getOutputDimension(self)

    def __repr__(self):
        """__repr__(InverseNatafEllipticalCopulaEvaluation self) -> OT::String"""
        return _transformation.InverseNatafEllipticalCopulaEvaluation___repr__(self)

    def __init__(self, *args): 
        """
        __init__(OT::InverseNatafEllipticalCopulaEvaluation self) -> InverseNatafEllipticalCopulaEvaluation
        __init__(OT::InverseNatafEllipticalCopulaEvaluation self, Distribution standardDistribution, SquareMatrix cholesky) -> InverseNatafEllipticalCopulaEvaluation
        __init__(OT::InverseNatafEllipticalCopulaEvaluation self, InverseNatafEllipticalCopulaEvaluation other) -> InverseNatafEllipticalCopulaEvaluation
        """
        this = _transformation.new_InverseNatafEllipticalCopulaEvaluation(*args)
        try: self.this.append(this)
        except: self.this = this
    __swig_destroy__ = _transformation.delete_InverseNatafEllipticalCopulaEvaluation
    __del__ = lambda self : None;
InverseNatafEllipticalCopulaEvaluation_swigregister = _transformation.InverseNatafEllipticalCopulaEvaluation_swigregister
InverseNatafEllipticalCopulaEvaluation_swigregister(InverseNatafEllipticalCopulaEvaluation)

def InverseNatafEllipticalCopulaEvaluation_GetClassName():
  """InverseNatafEllipticalCopulaEvaluation_GetClassName() -> OT::String"""
  return _transformation.InverseNatafEllipticalCopulaEvaluation_GetClassName()

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

    if _newclass:GetClassName = staticmethod(GetClassName)
    __swig_getmethods__["GetClassName"] = lambda x: GetClassName
    def getClassName(self):
        """getClassName(InverseNatafEllipticalCopulaGradient self) -> OT::String"""
        return _transformation.InverseNatafEllipticalCopulaGradient_getClassName(self)

    def gradient(self, *args):
        """gradient(InverseNatafEllipticalCopulaGradient self, NumericalPoint inP) -> Matrix"""
        return _transformation.InverseNatafEllipticalCopulaGradient_gradient(self, *args)

    def getInputDimension(self):
        """getInputDimension(InverseNatafEllipticalCopulaGradient self) -> OT::UnsignedLong"""
        return _transformation.InverseNatafEllipticalCopulaGradient_getInputDimension(self)

    def getOutputDimension(self):
        """getOutputDimension(InverseNatafEllipticalCopulaGradient self) -> OT::UnsignedLong"""
        return _transformation.InverseNatafEllipticalCopulaGradient_getOutputDimension(self)

    def __repr__(self):
        """__repr__(InverseNatafEllipticalCopulaGradient self) -> OT::String"""
        return _transformation.InverseNatafEllipticalCopulaGradient___repr__(self)

    def __init__(self, *args): 
        """
        __init__(OT::InverseNatafEllipticalCopulaGradient self) -> InverseNatafEllipticalCopulaGradient
        __init__(OT::InverseNatafEllipticalCopulaGradient self, Distribution standardDistribution, SquareMatrix cholesky) -> InverseNatafEllipticalCopulaGradient
        __init__(OT::InverseNatafEllipticalCopulaGradient self, InverseNatafEllipticalCopulaGradient other) -> InverseNatafEllipticalCopulaGradient
        """
        this = _transformation.new_InverseNatafEllipticalCopulaGradient(*args)
        try: self.this.append(this)
        except: self.this = this
    __swig_destroy__ = _transformation.delete_InverseNatafEllipticalCopulaGradient
    __del__ = lambda self : None;
InverseNatafEllipticalCopulaGradient_swigregister = _transformation.InverseNatafEllipticalCopulaGradient_swigregister
InverseNatafEllipticalCopulaGradient_swigregister(InverseNatafEllipticalCopulaGradient)

def InverseNatafEllipticalCopulaGradient_GetClassName():
  """InverseNatafEllipticalCopulaGradient_GetClassName() -> OT::String"""
  return _transformation.InverseNatafEllipticalCopulaGradient_GetClassName()

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

    if _newclass:GetClassName = staticmethod(GetClassName)
    __swig_getmethods__["GetClassName"] = lambda x: GetClassName
    def getClassName(self):
        """getClassName(InverseNatafEllipticalCopulaHessian self) -> OT::String"""
        return _transformation.InverseNatafEllipticalCopulaHessian_getClassName(self)

    def hessian(self, *args):
        """hessian(InverseNatafEllipticalCopulaHessian self, NumericalPoint inP) -> SymmetricTensor"""
        return _transformation.InverseNatafEllipticalCopulaHessian_hessian(self, *args)

    def getInputDimension(self):
        """getInputDimension(InverseNatafEllipticalCopulaHessian self) -> OT::UnsignedLong"""
        return _transformation.InverseNatafEllipticalCopulaHessian_getInputDimension(self)

    def getOutputDimension(self):
        """getOutputDimension(InverseNatafEllipticalCopulaHessian self) -> OT::UnsignedLong"""
        return _transformation.InverseNatafEllipticalCopulaHessian_getOutputDimension(self)

    def __repr__(self):
        """__repr__(InverseNatafEllipticalCopulaHessian self) -> OT::String"""
        return _transformation.InverseNatafEllipticalCopulaHessian___repr__(self)

    def __init__(self, *args): 
        """
        __init__(OT::InverseNatafEllipticalCopulaHessian self) -> InverseNatafEllipticalCopulaHessian
        __init__(OT::InverseNatafEllipticalCopulaHessian self, Distribution standardDistribution, SquareMatrix cholesky) -> InverseNatafEllipticalCopulaHessian
        __init__(OT::InverseNatafEllipticalCopulaHessian self, InverseNatafEllipticalCopulaHessian other) -> InverseNatafEllipticalCopulaHessian
        """
        this = _transformation.new_InverseNatafEllipticalCopulaHessian(*args)
        try: self.this.append(this)
        except: self.this = this
    __swig_destroy__ = _transformation.delete_InverseNatafEllipticalCopulaHessian
    __del__ = lambda self : None;
InverseNatafEllipticalCopulaHessian_swigregister = _transformation.InverseNatafEllipticalCopulaHessian_swigregister
InverseNatafEllipticalCopulaHessian_swigregister(InverseNatafEllipticalCopulaHessian)

def InverseNatafEllipticalCopulaHessian_GetClassName():
  """InverseNatafEllipticalCopulaHessian_GetClassName() -> OT::String"""
  return _transformation.InverseNatafEllipticalCopulaHessian_GetClassName()

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

    if _newclass:GetClassName = staticmethod(GetClassName)
    __swig_getmethods__["GetClassName"] = lambda x: GetClassName
    def getClassName(self):
        """getClassName(NatafIndependentCopulaEvaluation self) -> OT::String"""
        return _transformation.NatafIndependentCopulaEvaluation_getClassName(self)

    def __call__(self, *args):
        """__call__(NatafIndependentCopulaEvaluation self, NumericalPoint inP) -> NumericalPoint"""
        return _transformation.NatafIndependentCopulaEvaluation___call__(self, *args)

    def parametersGradient(self, *args):
        """parametersGradient(NatafIndependentCopulaEvaluation self, NumericalPoint inP) -> Matrix"""
        return _transformation.NatafIndependentCopulaEvaluation_parametersGradient(self, *args)

    def getInputDimension(self):
        """getInputDimension(NatafIndependentCopulaEvaluation self) -> OT::UnsignedLong"""
        return _transformation.NatafIndependentCopulaEvaluation_getInputDimension(self)

    def getOutputDimension(self):
        """getOutputDimension(NatafIndependentCopulaEvaluation self) -> OT::UnsignedLong"""
        return _transformation.NatafIndependentCopulaEvaluation_getOutputDimension(self)

    def __repr__(self):
        """__repr__(NatafIndependentCopulaEvaluation self) -> OT::String"""
        return _transformation.NatafIndependentCopulaEvaluation___repr__(self)

    def __init__(self, *args): 
        """
        __init__(OT::NatafIndependentCopulaEvaluation self) -> NatafIndependentCopulaEvaluation
        __init__(OT::NatafIndependentCopulaEvaluation self, OT::UnsignedLong const dimension) -> NatafIndependentCopulaEvaluation
        __init__(OT::NatafIndependentCopulaEvaluation self, NatafIndependentCopulaEvaluation other) -> NatafIndependentCopulaEvaluation
        """
        this = _transformation.new_NatafIndependentCopulaEvaluation(*args)
        try: self.this.append(this)
        except: self.this = this
    __swig_destroy__ = _transformation.delete_NatafIndependentCopulaEvaluation
    __del__ = lambda self : None;
NatafIndependentCopulaEvaluation_swigregister = _transformation.NatafIndependentCopulaEvaluation_swigregister
NatafIndependentCopulaEvaluation_swigregister(NatafIndependentCopulaEvaluation)

def NatafIndependentCopulaEvaluation_GetClassName():
  """NatafIndependentCopulaEvaluation_GetClassName() -> OT::String"""
  return _transformation.NatafIndependentCopulaEvaluation_GetClassName()

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

    if _newclass:GetClassName = staticmethod(GetClassName)
    __swig_getmethods__["GetClassName"] = lambda x: GetClassName
    def getClassName(self):
        """getClassName(NatafIndependentCopulaGradient self) -> OT::String"""
        return _transformation.NatafIndependentCopulaGradient_getClassName(self)

    def gradient(self, *args):
        """gradient(NatafIndependentCopulaGradient self, NumericalPoint inP) -> Matrix"""
        return _transformation.NatafIndependentCopulaGradient_gradient(self, *args)

    def getInputDimension(self):
        """getInputDimension(NatafIndependentCopulaGradient self) -> OT::UnsignedLong"""
        return _transformation.NatafIndependentCopulaGradient_getInputDimension(self)

    def getOutputDimension(self):
        """getOutputDimension(NatafIndependentCopulaGradient self) -> OT::UnsignedLong"""
        return _transformation.NatafIndependentCopulaGradient_getOutputDimension(self)

    def __repr__(self):
        """__repr__(NatafIndependentCopulaGradient self) -> OT::String"""
        return _transformation.NatafIndependentCopulaGradient___repr__(self)

    def __init__(self, *args): 
        """
        __init__(OT::NatafIndependentCopulaGradient self) -> NatafIndependentCopulaGradient
        __init__(OT::NatafIndependentCopulaGradient self, OT::UnsignedLong const dimension) -> NatafIndependentCopulaGradient
        __init__(OT::NatafIndependentCopulaGradient self, NatafIndependentCopulaGradient other) -> NatafIndependentCopulaGradient
        """
        this = _transformation.new_NatafIndependentCopulaGradient(*args)
        try: self.this.append(this)
        except: self.this = this
    __swig_destroy__ = _transformation.delete_NatafIndependentCopulaGradient
    __del__ = lambda self : None;
NatafIndependentCopulaGradient_swigregister = _transformation.NatafIndependentCopulaGradient_swigregister
NatafIndependentCopulaGradient_swigregister(NatafIndependentCopulaGradient)

def NatafIndependentCopulaGradient_GetClassName():
  """NatafIndependentCopulaGradient_GetClassName() -> OT::String"""
  return _transformation.NatafIndependentCopulaGradient_GetClassName()

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

    if _newclass:GetClassName = staticmethod(GetClassName)
    __swig_getmethods__["GetClassName"] = lambda x: GetClassName
    def getClassName(self):
        """getClassName(NatafIndependentCopulaHessian self) -> OT::String"""
        return _transformation.NatafIndependentCopulaHessian_getClassName(self)

    def hessian(self, *args):
        """hessian(NatafIndependentCopulaHessian self, NumericalPoint inP) -> SymmetricTensor"""
        return _transformation.NatafIndependentCopulaHessian_hessian(self, *args)

    def getInputDimension(self):
        """getInputDimension(NatafIndependentCopulaHessian self) -> OT::UnsignedLong"""
        return _transformation.NatafIndependentCopulaHessian_getInputDimension(self)

    def getOutputDimension(self):
        """getOutputDimension(NatafIndependentCopulaHessian self) -> OT::UnsignedLong"""
        return _transformation.NatafIndependentCopulaHessian_getOutputDimension(self)

    def __repr__(self):
        """__repr__(NatafIndependentCopulaHessian self) -> OT::String"""
        return _transformation.NatafIndependentCopulaHessian___repr__(self)

    def __init__(self, *args): 
        """
        __init__(OT::NatafIndependentCopulaHessian self) -> NatafIndependentCopulaHessian
        __init__(OT::NatafIndependentCopulaHessian self, OT::UnsignedLong const dimension) -> NatafIndependentCopulaHessian
        __init__(OT::NatafIndependentCopulaHessian self, NatafIndependentCopulaHessian other) -> NatafIndependentCopulaHessian
        """
        this = _transformation.new_NatafIndependentCopulaHessian(*args)
        try: self.this.append(this)
        except: self.this = this
    __swig_destroy__ = _transformation.delete_NatafIndependentCopulaHessian
    __del__ = lambda self : None;
NatafIndependentCopulaHessian_swigregister = _transformation.NatafIndependentCopulaHessian_swigregister
NatafIndependentCopulaHessian_swigregister(NatafIndependentCopulaHessian)

def NatafIndependentCopulaHessian_GetClassName():
  """NatafIndependentCopulaHessian_GetClassName() -> OT::String"""
  return _transformation.NatafIndependentCopulaHessian_GetClassName()

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

    if _newclass:GetClassName = staticmethod(GetClassName)
    __swig_getmethods__["GetClassName"] = lambda x: GetClassName
    def getClassName(self):
        """getClassName(InverseNatafIndependentCopulaEvaluation self) -> OT::String"""
        return _transformation.InverseNatafIndependentCopulaEvaluation_getClassName(self)

    def __call__(self, *args):
        """__call__(InverseNatafIndependentCopulaEvaluation self, NumericalPoint inP) -> NumericalPoint"""
        return _transformation.InverseNatafIndependentCopulaEvaluation___call__(self, *args)

    def parametersGradient(self, *args):
        """parametersGradient(InverseNatafIndependentCopulaEvaluation self, NumericalPoint inP) -> Matrix"""
        return _transformation.InverseNatafIndependentCopulaEvaluation_parametersGradient(self, *args)

    def getInputDimension(self):
        """getInputDimension(InverseNatafIndependentCopulaEvaluation self) -> OT::UnsignedLong"""
        return _transformation.InverseNatafIndependentCopulaEvaluation_getInputDimension(self)

    def getOutputDimension(self):
        """getOutputDimension(InverseNatafIndependentCopulaEvaluation self) -> OT::UnsignedLong"""
        return _transformation.InverseNatafIndependentCopulaEvaluation_getOutputDimension(self)

    def __repr__(self):
        """__repr__(InverseNatafIndependentCopulaEvaluation self) -> OT::String"""
        return _transformation.InverseNatafIndependentCopulaEvaluation___repr__(self)

    def __init__(self, *args): 
        """
        __init__(OT::InverseNatafIndependentCopulaEvaluation self, OT::UnsignedLong const dimension) -> InverseNatafIndependentCopulaEvaluation
        __init__(OT::InverseNatafIndependentCopulaEvaluation self, InverseNatafIndependentCopulaEvaluation other) -> InverseNatafIndependentCopulaEvaluation
        """
        this = _transformation.new_InverseNatafIndependentCopulaEvaluation(*args)
        try: self.this.append(this)
        except: self.this = this
    __swig_destroy__ = _transformation.delete_InverseNatafIndependentCopulaEvaluation
    __del__ = lambda self : None;
InverseNatafIndependentCopulaEvaluation_swigregister = _transformation.InverseNatafIndependentCopulaEvaluation_swigregister
InverseNatafIndependentCopulaEvaluation_swigregister(InverseNatafIndependentCopulaEvaluation)

def InverseNatafIndependentCopulaEvaluation_GetClassName():
  """InverseNatafIndependentCopulaEvaluation_GetClassName() -> OT::String"""
  return _transformation.InverseNatafIndependentCopulaEvaluation_GetClassName()

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

    if _newclass:GetClassName = staticmethod(GetClassName)
    __swig_getmethods__["GetClassName"] = lambda x: GetClassName
    def getClassName(self):
        """getClassName(InverseNatafIndependentCopulaGradient self) -> OT::String"""
        return _transformation.InverseNatafIndependentCopulaGradient_getClassName(self)

    def gradient(self, *args):
        """gradient(InverseNatafIndependentCopulaGradient self, NumericalPoint inP) -> Matrix"""
        return _transformation.InverseNatafIndependentCopulaGradient_gradient(self, *args)

    def getInputDimension(self):
        """getInputDimension(InverseNatafIndependentCopulaGradient self) -> OT::UnsignedLong"""
        return _transformation.InverseNatafIndependentCopulaGradient_getInputDimension(self)

    def getOutputDimension(self):
        """getOutputDimension(InverseNatafIndependentCopulaGradient self) -> OT::UnsignedLong"""
        return _transformation.InverseNatafIndependentCopulaGradient_getOutputDimension(self)

    def __repr__(self):
        """__repr__(InverseNatafIndependentCopulaGradient self) -> OT::String"""
        return _transformation.InverseNatafIndependentCopulaGradient___repr__(self)

    def __init__(self, *args): 
        """
        __init__(OT::InverseNatafIndependentCopulaGradient self) -> InverseNatafIndependentCopulaGradient
        __init__(OT::InverseNatafIndependentCopulaGradient self, OT::UnsignedLong const dimension) -> InverseNatafIndependentCopulaGradient
        __init__(OT::InverseNatafIndependentCopulaGradient self, InverseNatafIndependentCopulaGradient other) -> InverseNatafIndependentCopulaGradient
        """
        this = _transformation.new_InverseNatafIndependentCopulaGradient(*args)
        try: self.this.append(this)
        except: self.this = this
    __swig_destroy__ = _transformation.delete_InverseNatafIndependentCopulaGradient
    __del__ = lambda self : None;
InverseNatafIndependentCopulaGradient_swigregister = _transformation.InverseNatafIndependentCopulaGradient_swigregister
InverseNatafIndependentCopulaGradient_swigregister(InverseNatafIndependentCopulaGradient)

def InverseNatafIndependentCopulaGradient_GetClassName():
  """InverseNatafIndependentCopulaGradient_GetClassName() -> OT::String"""
  return _transformation.InverseNatafIndependentCopulaGradient_GetClassName()

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

    if _newclass:GetClassName = staticmethod(GetClassName)
    __swig_getmethods__["GetClassName"] = lambda x: GetClassName
    def getClassName(self):
        """getClassName(InverseNatafIndependentCopulaHessian self) -> OT::String"""
        return _transformation.InverseNatafIndependentCopulaHessian_getClassName(self)

    def hessian(self, *args):
        """hessian(InverseNatafIndependentCopulaHessian self, NumericalPoint inP) -> SymmetricTensor"""
        return _transformation.InverseNatafIndependentCopulaHessian_hessian(self, *args)

    def getInputDimension(self):
        """getInputDimension(InverseNatafIndependentCopulaHessian self) -> OT::UnsignedLong"""
        return _transformation.InverseNatafIndependentCopulaHessian_getInputDimension(self)

    def getOutputDimension(self):
        """getOutputDimension(InverseNatafIndependentCopulaHessian self) -> OT::UnsignedLong"""
        return _transformation.InverseNatafIndependentCopulaHessian_getOutputDimension(self)

    def __repr__(self):
        """__repr__(InverseNatafIndependentCopulaHessian self) -> OT::String"""
        return _transformation.InverseNatafIndependentCopulaHessian___repr__(self)

    def __init__(self, *args): 
        """
        __init__(OT::InverseNatafIndependentCopulaHessian self) -> InverseNatafIndependentCopulaHessian
        __init__(OT::InverseNatafIndependentCopulaHessian self, OT::UnsignedLong const dimension) -> InverseNatafIndependentCopulaHessian
        __init__(OT::InverseNatafIndependentCopulaHessian self, InverseNatafIndependentCopulaHessian other) -> InverseNatafIndependentCopulaHessian
        """
        this = _transformation.new_InverseNatafIndependentCopulaHessian(*args)
        try: self.this.append(this)
        except: self.this = this
    __swig_destroy__ = _transformation.delete_InverseNatafIndependentCopulaHessian
    __del__ = lambda self : None;
InverseNatafIndependentCopulaHessian_swigregister = _transformation.InverseNatafIndependentCopulaHessian_swigregister
InverseNatafIndependentCopulaHessian_swigregister(InverseNatafIndependentCopulaHessian)

def InverseNatafIndependentCopulaHessian_GetClassName():
  """InverseNatafIndependentCopulaHessian_GetClassName() -> OT::String"""
  return _transformation.InverseNatafIndependentCopulaHessian_GetClassName()

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

    if _newclass:GetClassName = staticmethod(GetClassName)
    __swig_getmethods__["GetClassName"] = lambda x: GetClassName
    def getClassName(self):
        """getClassName(NatafEllipticalDistributionEvaluation self) -> OT::String"""
        return _transformation.NatafEllipticalDistributionEvaluation_getClassName(self)

    def parametersGradient(self, *args):
        """parametersGradient(NatafEllipticalDistributionEvaluation self, NumericalPoint inP) -> Matrix"""
        return _transformation.NatafEllipticalDistributionEvaluation_parametersGradient(self, *args)

    def __repr__(self):
        """__repr__(NatafEllipticalDistributionEvaluation self) -> OT::String"""
        return _transformation.NatafEllipticalDistributionEvaluation___repr__(self)

    def __init__(self, *args): 
        """
        __init__(OT::NatafEllipticalDistributionEvaluation self) -> NatafEllipticalDistributionEvaluation
        __init__(OT::NatafEllipticalDistributionEvaluation self, NumericalPoint mean, SquareMatrix inverseCholesky) -> NatafEllipticalDistributionEvaluation
        __init__(OT::NatafEllipticalDistributionEvaluation self, NatafEllipticalDistributionEvaluation other) -> NatafEllipticalDistributionEvaluation
        """
        this = _transformation.new_NatafEllipticalDistributionEvaluation(*args)
        try: self.this.append(this)
        except: self.this = this
    __swig_destroy__ = _transformation.delete_NatafEllipticalDistributionEvaluation
    __del__ = lambda self : None;
NatafEllipticalDistributionEvaluation_swigregister = _transformation.NatafEllipticalDistributionEvaluation_swigregister
NatafEllipticalDistributionEvaluation_swigregister(NatafEllipticalDistributionEvaluation)

def NatafEllipticalDistributionEvaluation_GetClassName():
  """NatafEllipticalDistributionEvaluation_GetClassName() -> OT::String"""
  return _transformation.NatafEllipticalDistributionEvaluation_GetClassName()

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

    if _newclass:GetClassName = staticmethod(GetClassName)
    __swig_getmethods__["GetClassName"] = lambda x: GetClassName
    def getClassName(self):
        """getClassName(NatafEllipticalDistributionGradient self) -> OT::String"""
        return _transformation.NatafEllipticalDistributionGradient_getClassName(self)

    def __repr__(self):
        """__repr__(NatafEllipticalDistributionGradient self) -> OT::String"""
        return _transformation.NatafEllipticalDistributionGradient___repr__(self)

    def __init__(self, *args): 
        """
        __init__(OT::NatafEllipticalDistributionGradient self) -> NatafEllipticalDistributionGradient
        __init__(OT::NatafEllipticalDistributionGradient self, SquareMatrix inverseCholesky) -> NatafEllipticalDistributionGradient
        __init__(OT::NatafEllipticalDistributionGradient self, NatafEllipticalDistributionGradient other) -> NatafEllipticalDistributionGradient
        """
        this = _transformation.new_NatafEllipticalDistributionGradient(*args)
        try: self.this.append(this)
        except: self.this = this
    __swig_destroy__ = _transformation.delete_NatafEllipticalDistributionGradient
    __del__ = lambda self : None;
NatafEllipticalDistributionGradient_swigregister = _transformation.NatafEllipticalDistributionGradient_swigregister
NatafEllipticalDistributionGradient_swigregister(NatafEllipticalDistributionGradient)

def NatafEllipticalDistributionGradient_GetClassName():
  """NatafEllipticalDistributionGradient_GetClassName() -> OT::String"""
  return _transformation.NatafEllipticalDistributionGradient_GetClassName()

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

    if _newclass:GetClassName = staticmethod(GetClassName)
    __swig_getmethods__["GetClassName"] = lambda x: GetClassName
    def getClassName(self):
        """getClassName(NatafEllipticalDistributionHessian self) -> OT::String"""
        return _transformation.NatafEllipticalDistributionHessian_getClassName(self)

    def __repr__(self):
        """__repr__(NatafEllipticalDistributionHessian self) -> OT::String"""
        return _transformation.NatafEllipticalDistributionHessian___repr__(self)

    def __init__(self, *args): 
        """
        __init__(OT::NatafEllipticalDistributionHessian self) -> NatafEllipticalDistributionHessian
        __init__(OT::NatafEllipticalDistributionHessian self, OT::UnsignedLong const dimension) -> NatafEllipticalDistributionHessian
        __init__(OT::NatafEllipticalDistributionHessian self, NatafEllipticalDistributionHessian other) -> NatafEllipticalDistributionHessian
        """
        this = _transformation.new_NatafEllipticalDistributionHessian(*args)
        try: self.this.append(this)
        except: self.this = this
    __swig_destroy__ = _transformation.delete_NatafEllipticalDistributionHessian
    __del__ = lambda self : None;
NatafEllipticalDistributionHessian_swigregister = _transformation.NatafEllipticalDistributionHessian_swigregister
NatafEllipticalDistributionHessian_swigregister(NatafEllipticalDistributionHessian)

def NatafEllipticalDistributionHessian_GetClassName():
  """NatafEllipticalDistributionHessian_GetClassName() -> OT::String"""
  return _transformation.NatafEllipticalDistributionHessian_GetClassName()

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

    if _newclass:GetClassName = staticmethod(GetClassName)
    __swig_getmethods__["GetClassName"] = lambda x: GetClassName
    def getClassName(self):
        """getClassName(InverseNatafEllipticalDistributionEvaluation self) -> OT::String"""
        return _transformation.InverseNatafEllipticalDistributionEvaluation_getClassName(self)

    def parametersGradient(self, *args):
        """parametersGradient(InverseNatafEllipticalDistributionEvaluation self, NumericalPoint inP) -> Matrix"""
        return _transformation.InverseNatafEllipticalDistributionEvaluation_parametersGradient(self, *args)

    def __repr__(self):
        """__repr__(InverseNatafEllipticalDistributionEvaluation self) -> OT::String"""
        return _transformation.InverseNatafEllipticalDistributionEvaluation___repr__(self)

    def __init__(self, *args): 
        """
        __init__(OT::InverseNatafEllipticalDistributionEvaluation self) -> InverseNatafEllipticalDistributionEvaluation
        __init__(OT::InverseNatafEllipticalDistributionEvaluation self, NumericalPoint mean, SquareMatrix cholesky) -> InverseNatafEllipticalDistributionEvaluation
        __init__(OT::InverseNatafEllipticalDistributionEvaluation self, InverseNatafEllipticalDistributionEvaluation other) -> InverseNatafEllipticalDistributionEvaluation
        """
        this = _transformation.new_InverseNatafEllipticalDistributionEvaluation(*args)
        try: self.this.append(this)
        except: self.this = this
    __swig_destroy__ = _transformation.delete_InverseNatafEllipticalDistributionEvaluation
    __del__ = lambda self : None;
InverseNatafEllipticalDistributionEvaluation_swigregister = _transformation.InverseNatafEllipticalDistributionEvaluation_swigregister
InverseNatafEllipticalDistributionEvaluation_swigregister(InverseNatafEllipticalDistributionEvaluation)

def InverseNatafEllipticalDistributionEvaluation_GetClassName():
  """InverseNatafEllipticalDistributionEvaluation_GetClassName() -> OT::String"""
  return _transformation.InverseNatafEllipticalDistributionEvaluation_GetClassName()

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

    if _newclass:GetClassName = staticmethod(GetClassName)
    __swig_getmethods__["GetClassName"] = lambda x: GetClassName
    def getClassName(self):
        """getClassName(InverseNatafEllipticalDistributionGradient self) -> OT::String"""
        return _transformation.InverseNatafEllipticalDistributionGradient_getClassName(self)

    def __repr__(self):
        """__repr__(InverseNatafEllipticalDistributionGradient self) -> OT::String"""
        return _transformation.InverseNatafEllipticalDistributionGradient___repr__(self)

    def __init__(self, *args): 
        """
        __init__(OT::InverseNatafEllipticalDistributionGradient self) -> InverseNatafEllipticalDistributionGradient
        __init__(OT::InverseNatafEllipticalDistributionGradient self, SquareMatrix inverseCholesky) -> InverseNatafEllipticalDistributionGradient
        __init__(OT::InverseNatafEllipticalDistributionGradient self, InverseNatafEllipticalDistributionGradient other) -> InverseNatafEllipticalDistributionGradient
        """
        this = _transformation.new_InverseNatafEllipticalDistributionGradient(*args)
        try: self.this.append(this)
        except: self.this = this
    __swig_destroy__ = _transformation.delete_InverseNatafEllipticalDistributionGradient
    __del__ = lambda self : None;
InverseNatafEllipticalDistributionGradient_swigregister = _transformation.InverseNatafEllipticalDistributionGradient_swigregister
InverseNatafEllipticalDistributionGradient_swigregister(InverseNatafEllipticalDistributionGradient)

def InverseNatafEllipticalDistributionGradient_GetClassName():
  """InverseNatafEllipticalDistributionGradient_GetClassName() -> OT::String"""
  return _transformation.InverseNatafEllipticalDistributionGradient_GetClassName()

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

    if _newclass:GetClassName = staticmethod(GetClassName)
    __swig_getmethods__["GetClassName"] = lambda x: GetClassName
    def getClassName(self):
        """getClassName(InverseNatafEllipticalDistributionHessian self) -> OT::String"""
        return _transformation.InverseNatafEllipticalDistributionHessian_getClassName(self)

    def __repr__(self):
        """__repr__(InverseNatafEllipticalDistributionHessian self) -> OT::String"""
        return _transformation.InverseNatafEllipticalDistributionHessian___repr__(self)

    def __init__(self, *args): 
        """
        __init__(OT::InverseNatafEllipticalDistributionHessian self) -> InverseNatafEllipticalDistributionHessian
        __init__(OT::InverseNatafEllipticalDistributionHessian self, OT::UnsignedLong const dimension) -> InverseNatafEllipticalDistributionHessian
        __init__(OT::InverseNatafEllipticalDistributionHessian self, InverseNatafEllipticalDistributionHessian other) -> InverseNatafEllipticalDistributionHessian
        """
        this = _transformation.new_InverseNatafEllipticalDistributionHessian(*args)
        try: self.this.append(this)
        except: self.this = this
    __swig_destroy__ = _transformation.delete_InverseNatafEllipticalDistributionHessian
    __del__ = lambda self : None;
InverseNatafEllipticalDistributionHessian_swigregister = _transformation.InverseNatafEllipticalDistributionHessian_swigregister
InverseNatafEllipticalDistributionHessian_swigregister(InverseNatafEllipticalDistributionHessian)

def InverseNatafEllipticalDistributionHessian_GetClassName():
  """InverseNatafEllipticalDistributionHessian_GetClassName() -> OT::String"""
  return _transformation.InverseNatafEllipticalDistributionHessian_GetClassName()

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

    if _newclass:GetClassName = staticmethod(GetClassName)
    __swig_getmethods__["GetClassName"] = lambda x: GetClassName
    def getClassName(self):
        """getClassName(RosenblattEvaluation self) -> OT::String"""
        return _transformation.RosenblattEvaluation_getClassName(self)

    def __call__(self, *args):
        """__call__(RosenblattEvaluation self, NumericalPoint inP) -> NumericalPoint"""
        return _transformation.RosenblattEvaluation___call__(self, *args)

    def parametersGradient(self, *args):
        """parametersGradient(RosenblattEvaluation self, NumericalPoint inP) -> Matrix"""
        return _transformation.RosenblattEvaluation_parametersGradient(self, *args)

    def getInputDimension(self):
        """getInputDimension(RosenblattEvaluation self) -> OT::UnsignedLong"""
        return _transformation.RosenblattEvaluation_getInputDimension(self)

    def getOutputDimension(self):
        """getOutputDimension(RosenblattEvaluation self) -> OT::UnsignedLong"""
        return _transformation.RosenblattEvaluation_getOutputDimension(self)

    def __repr__(self):
        """__repr__(RosenblattEvaluation self) -> OT::String"""
        return _transformation.RosenblattEvaluation___repr__(self)

    def __init__(self, *args): 
        """
        __init__(OT::RosenblattEvaluation self) -> RosenblattEvaluation
        __init__(OT::RosenblattEvaluation self, Distribution distribution) -> RosenblattEvaluation
        __init__(OT::RosenblattEvaluation self, RosenblattEvaluation other) -> RosenblattEvaluation
        """
        this = _transformation.new_RosenblattEvaluation(*args)
        try: self.this.append(this)
        except: self.this = this
    __swig_destroy__ = _transformation.delete_RosenblattEvaluation
    __del__ = lambda self : None;
RosenblattEvaluation_swigregister = _transformation.RosenblattEvaluation_swigregister
RosenblattEvaluation_swigregister(RosenblattEvaluation)

def RosenblattEvaluation_GetClassName():
  """RosenblattEvaluation_GetClassName() -> OT::String"""
  return _transformation.RosenblattEvaluation_GetClassName()

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

    if _newclass:GetClassName = staticmethod(GetClassName)
    __swig_getmethods__["GetClassName"] = lambda x: GetClassName
    def getClassName(self):
        """getClassName(InverseRosenblattEvaluation self) -> OT::String"""
        return _transformation.InverseRosenblattEvaluation_getClassName(self)

    def __call__(self, *args):
        """__call__(InverseRosenblattEvaluation self, NumericalPoint inP) -> NumericalPoint"""
        return _transformation.InverseRosenblattEvaluation___call__(self, *args)

    def parametersGradient(self, *args):
        """parametersGradient(InverseRosenblattEvaluation self, NumericalPoint inP) -> Matrix"""
        return _transformation.InverseRosenblattEvaluation_parametersGradient(self, *args)

    def getInputDimension(self):
        """getInputDimension(InverseRosenblattEvaluation self) -> OT::UnsignedLong"""
        return _transformation.InverseRosenblattEvaluation_getInputDimension(self)

    def getOutputDimension(self):
        """getOutputDimension(InverseRosenblattEvaluation self) -> OT::UnsignedLong"""
        return _transformation.InverseRosenblattEvaluation_getOutputDimension(self)

    def __repr__(self):
        """__repr__(InverseRosenblattEvaluation self) -> OT::String"""
        return _transformation.InverseRosenblattEvaluation___repr__(self)

    def __init__(self, *args): 
        """
        __init__(OT::InverseRosenblattEvaluation self) -> InverseRosenblattEvaluation
        __init__(OT::InverseRosenblattEvaluation self, Distribution distribution) -> InverseRosenblattEvaluation
        __init__(OT::InverseRosenblattEvaluation self, InverseRosenblattEvaluation other) -> InverseRosenblattEvaluation
        """
        this = _transformation.new_InverseRosenblattEvaluation(*args)
        try: self.this.append(this)
        except: self.this = this
    __swig_destroy__ = _transformation.delete_InverseRosenblattEvaluation
    __del__ = lambda self : None;
InverseRosenblattEvaluation_swigregister = _transformation.InverseRosenblattEvaluation_swigregister
InverseRosenblattEvaluation_swigregister(InverseRosenblattEvaluation)

def InverseRosenblattEvaluation_GetClassName():
  """InverseRosenblattEvaluation_GetClassName() -> OT::String"""
  return _transformation.InverseRosenblattEvaluation_GetClassName()

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

    if _newclass:GetClassName = staticmethod(GetClassName)
    __swig_getmethods__["GetClassName"] = lambda x: GetClassName
    def getClassName(self):
        """getClassName(BoxCoxFactory self) -> OT::String"""
        return _transformation.BoxCoxFactory_getClassName(self)

    def __repr__(self):
        """__repr__(BoxCoxFactory self) -> OT::String"""
        return _transformation.BoxCoxFactory___repr__(self)

    def __str__(self, offset=""):
        """
        __str__(BoxCoxFactory self, OT::String const & offset="") -> OT::String
        __str__(BoxCoxFactory self) -> OT::String
        """
        return _transformation.BoxCoxFactory___str__(self, offset)

    def build(self, *args):
        """
        build(BoxCoxFactory self, TimeSeries timeSeries) -> BoxCoxTransform
        build(BoxCoxFactory self, TimeSeries timeSeries, NumericalPoint shift) -> BoxCoxTransform
        build(BoxCoxFactory self, TimeSeries timeSeries, NumericalPoint shift, Graph graph) -> BoxCoxTransform
        build(BoxCoxFactory self, NumericalSample sample) -> BoxCoxTransform
        build(BoxCoxFactory self, NumericalSample sample, NumericalPoint shift) -> BoxCoxTransform
        build(BoxCoxFactory self, NumericalSample sample, NumericalPoint shift, Graph graph) -> BoxCoxTransform
        """
        return _transformation.BoxCoxFactory_build(self, *args)

    def __init__(self, *args): 
        """
        __init__(OT::BoxCoxFactory self) -> BoxCoxFactory
        __init__(OT::BoxCoxFactory self, BoxCoxFactory other) -> BoxCoxFactory
        """
        this = _transformation.new_BoxCoxFactory(*args)
        try: self.this.append(this)
        except: self.this = this
    __swig_destroy__ = _transformation.delete_BoxCoxFactory
    __del__ = lambda self : None;
BoxCoxFactory_swigregister = _transformation.BoxCoxFactory_swigregister
BoxCoxFactory_swigregister(BoxCoxFactory)

def BoxCoxFactory_GetClassName():
  """BoxCoxFactory_GetClassName() -> OT::String"""
  return _transformation.BoxCoxFactory_GetClassName()

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

    if _newclass:GetClassName = staticmethod(GetClassName)
    __swig_getmethods__["GetClassName"] = lambda x: GetClassName
    def getClassName(self):
        """getClassName(TrendFactory self) -> OT::String"""
        return _transformation.TrendFactory_getClassName(self)

    def getBasisSequenceFactory(self):
        """getBasisSequenceFactory(TrendFactory self) -> BasisSequenceFactory"""
        return _transformation.TrendFactory_getBasisSequenceFactory(self)

    def setBasisSequenceFactory(self, *args):
        """setBasisSequenceFactory(TrendFactory self, BasisSequenceFactory basisSequenceFactory)"""
        return _transformation.TrendFactory_setBasisSequenceFactory(self, *args)

    def getFittingAlgorithm(self):
        """getFittingAlgorithm(TrendFactory self) -> FittingAlgorithm"""
        return _transformation.TrendFactory_getFittingAlgorithm(self)

    def setFittingAlgorithm(self, *args):
        """setFittingAlgorithm(TrendFactory self, FittingAlgorithm fittingAlgorithm)"""
        return _transformation.TrendFactory_setFittingAlgorithm(self, *args)

    def __repr__(self):
        """__repr__(TrendFactory self) -> OT::String"""
        return _transformation.TrendFactory___repr__(self)

    def __str__(self, offset=""):
        """
        __str__(TrendFactory self, OT::String const & offset="") -> OT::String
        __str__(TrendFactory self) -> OT::String
        """
        return _transformation.TrendFactory___str__(self, offset)

    def build(self, *args):
        """build(TrendFactory self, TimeSeries timeSeries, Basis basis) -> TrendTransform"""
        return _transformation.TrendFactory_build(self, *args)

    def __init__(self, *args): 
        """
        __init__(OT::TrendFactory self, BasisSequenceFactory basisSequenceFactory=OT::LAR(), FittingAlgorithm fittingAlgorithm=OT::CorrectedLeaveOneOut(), 
            OT::String const & name=DefaultName) -> TrendFactory
        __init__(OT::TrendFactory self, BasisSequenceFactory basisSequenceFactory=OT::LAR(), FittingAlgorithm fittingAlgorithm=OT::CorrectedLeaveOneOut()) -> TrendFactory
        __init__(OT::TrendFactory self, BasisSequenceFactory basisSequenceFactory=OT::LAR()) -> TrendFactory
        __init__(OT::TrendFactory self) -> TrendFactory
        __init__(OT::TrendFactory self, TrendFactory other) -> TrendFactory
        """
        this = _transformation.new_TrendFactory(*args)
        try: self.this.append(this)
        except: self.this = this
    __swig_destroy__ = _transformation.delete_TrendFactory
    __del__ = lambda self : None;
TrendFactory_swigregister = _transformation.TrendFactory_swigregister
TrendFactory_swigregister(TrendFactory)

def TrendFactory_GetClassName():
  """TrendFactory_GetClassName() -> OT::String"""
  return _transformation.TrendFactory_GetClassName()

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