libopenturns-dev 1.7-3 / usr / include / openturns / swig / EnumerateFunctionImplementation_doc.i

%define OT_EnumerateFunction_doc
"Enumerate function.

Available constructors:
    EnumerateFunction(*dim=1*)

    EnumerateFunction(*dim, q*)

    EnumerateFunction(*weight, q*)

Parameters
----------
dim : positive int
    If *dim* is the only argument mentioned, it is used to create
    a :class:`~openturns.LinearEnumerateFunction` object of dimension *dim*.
    If *q* is also mentioned, it is used to create
    a :class:`~openturns.HyperbolicAnisotropicEnumerateFunction` object of
    dimension *dim* and parameter *q*.
q : float
    The q-quasi-norm parameter used to create a
    :class:`~openturns.HyperbolicAnisotropicEnumerateFunction` object.
weight : sequence of float
    The weights of the indices in each dimension used to create a
    :class:`~openturns.HyperbolicAnisotropicEnumerateFunction` object.

Notes
-----
*EnumerateFunction* represents a bijection from :math:`\\\\Nset` to
:math:`\\\\Nset^{dim}`. This bijection is based on a particular procedure of
enumerating the set of multi-indices. It begins from the multi-index
:math:`\\\\{0,0,\\\\dots,0\\\\}`.

We associate a multi-index :math:`\\\\{j_{p1}, j_{p2},\\\\dots, j_{pdim}\\\\}` for every
integer :math:`i_p` in :math:`\\\\Nset`:

For more details, let us consider any :math:`i_p, i_q \\\\in \\\\Nset`:

if :math:`|i_p-i_q|\\\\leq 1` then
:math:`|\\\\sum_{k=1}^{dim} (j_{pk}- j_{qk})| \\\\leq 1`. This proposition provides a
necessary but unsufficient condition for the construction of the bijection.
Another assumption was done indicating the way of iteration.
Below an example showing this assumption.

Example for :math:`dim=2`:

.. math::

    phi(0) &= [0 ~ 0] \\\\\\\\
    phi(1) &= [1 ~ 0] \\\\\\\\
    phi(2) &= [0 ~ 1] \\\\\\\\
    phi(3) &= [2 ~ 0] \\\\\\\\
    phi(4) &= [1 ~ 1] \\\\\\\\
    phi(5) &= [0 ~ 2] \\\\\\\\
    phi(6) &= [3 ~ 0]

For the functional expansion (respectively polynomial chaos expansion), the
multi-index :math:`\\\\vect{i_p}` represents the collection of degrees of the
selected orthogonal functions (respectively orthogonal polynomials). In fact,
after the selection of the type of orthogonal functions (respectively
orthogonal polynomials) for the construction of the orthogonal basis, the
*EnumerateFunction* characterizes the term of the basis by providing the
degrees of the univariate functions (respectively univariate polynomials).

In order to know the degree of the :math:`k^{th}` polynomial of the
multivariate basis, it is enough to sum all the integers given in the list.

Examples
--------
>>> import openturns as ot
>>> enumerateFunction = ot.EnumerateFunction(ot.LinearEnumerateFunction(2))
>>> for i in range(6):
...     print(enumerateFunction(i))
[0,0]
[1,0]
[0,1]
[2,0]
[1,1]
[0,2]"
%enddef
%feature("docstring") OT::EnumerateFunctionImplementation
OT_EnumerateFunction_doc

// ---------------------------------------------------------------------

%define OT_EnumerateFunction_getDimension_doc
"Return the dimension of the *EnumerateFunction*.

Returns
-------
dim : int, :math:`dim \\\\geq 0`
    Dimension of the *EnumerateFunction*."
%enddef
%feature("docstring") OT::EnumerateFunctionImplementation::getDimension
OT_EnumerateFunction_getDimension_doc

// ---------------------------------------------------------------------

%define OT_EnumerateFunction_getMaximumDegreeCardinal_doc
"Get the cardinal of indices of degree inferior or equal to a given value.

Parameters
----------
maximumDegree : int
    Number of polynoms of the basis.

Returns
-------
cardinal : int
    Cardinal of indices of degree :math:`max \\\\leq maximumDegree`.

Examples
--------
>>> import openturns as ot
>>> enumerateFunction = ot.EnumerateFunction(ot.LinearEnumerateFunction(2))
>>> for i in range(6):
...     indices = enumerateFunction(i)
...     degree = sum(indices)
...     print(str(int(degree))+' '+str(indices))
0 [0,0]
1 [1,0]
1 [0,1]
2 [2,0]
2 [1,1]
2 [0,2]
>>> print(enumerateFunction.getMaximumDegreeCardinal(2))
6"
%enddef
%feature("docstring") OT::EnumerateFunctionImplementation::getMaximumDegreeCardinal
OT_EnumerateFunction_getMaximumDegreeCardinal_doc

// ---------------------------------------------------------------------

%define OT_EnumerateFunction_getMaximumDegreeStrataIndex_doc
"Get the index of the strata of degree inferior to a given value.

Parameters
----------
maximumDegree : int
    Degree.

Returns
-------
index : int
    Index of the strata of degree :math:`max < maximumDegree`.

Examples
--------
>>> import openturns as ot
>>> enumerateFunction = ot.EnumerateFunction(ot.LinearEnumerateFunction(2))
>>> for i in [1, 2]:
...     indices = enumerateFunction(i)
...     strataIndex = sum(indices) + 1
...     print(str(int(strataIndex))+' '+str(indices))
2 [1,0]
2 [0,1]
>>> print(enumerateFunction.getMaximumDegreeStrataIndex(2))
2"
%enddef
%feature("docstring") OT::EnumerateFunctionImplementation::getMaximumDegreeStrataIndex
OT_EnumerateFunction_getMaximumDegreeStrataIndex_doc

// ---------------------------------------------------------------------

%define OT_EnumerateFunction_getStrataCardinal_doc
"Get the number of members of the basis associated to a given strata.

Parameters
----------
strataIndex : int
    Index of the strata in the hierarchical basis. In the context of product of
    polynomial basis, this is the total polynom degree.

Returns
-------
cardinal : int
    Number of members of the basis associated to the strata *strataIndex*. In
    the context of product of polynomial basis, this is the number of polynoms
    of the basis which total degree is *strataIndex*.

Examples
--------
>>> import openturns as ot
>>> enumerateFunction = ot.EnumerateFunction(ot.LinearEnumerateFunction(2))
>>> for i in [3, 4, 5]:
...     indices = enumerateFunction(i)
...     degree = sum(indices)
...     print(str(int(degree))+' '+str(indices))
2 [2,0]
2 [1,1]
2 [0,2]
>>> print(enumerateFunction.getStrataCardinal(2))
3"
%enddef
%feature("docstring") OT::EnumerateFunctionImplementation::getStrataCardinal
OT_EnumerateFunction_getStrataCardinal_doc

// ---------------------------------------------------------------------

%define OT_EnumerateFunction_getStrataCumulatedCardinal_doc
"Get the cardinal of the cumulated strata above or equal to the given strata.

Parameters
----------
strataIndex : int
    Index of the strata in the hierarchical basis. In the context of product of
    polynomial basis, this is the total polynomial degree.

Returns
-------
cardinal : int
    Number of members of the basis associated to the strates inferior or equal
    to *strataIndex*. In the context of product of polynomial basis, this is
    the number of polynomials of the basis which total degree is inferior or
    equal to *strataIndex*.

Examples
--------
>>> import openturns as ot
>>> enumerateFunction = ot.EnumerateFunction(ot.LinearEnumerateFunction(2))
>>> for i in range(6):
...     indices = enumerateFunction(i)
...     degree = sum(indices)
...     print(str(int(degree))+' '+str(indices))
0 [0,0]
1 [1,0]
1 [0,1]
2 [2,0]
2 [1,1]
2 [0,2]
>>> print(enumerateFunction.getStrataCumulatedCardinal(2))
6"
%enddef
%feature("docstring") OT::EnumerateFunctionImplementation::getStrataCumulatedCardinal
OT_EnumerateFunction_getStrataCumulatedCardinal_doc

// ---------------------------------------------------------------------

%define OT_EnumerateFunction_inverse_doc
"Get the antecedent of a indices list in the *EnumerateFunction*.

Parameters
----------
multiIndex : sequence of int
    List of indices.

Returns
-------
antecedent : int
    Represents the antecedent of the *multiIndex* in the *EnumerateFunction*.

Examples
--------
>>> import openturns as ot
>>> enumerateFunction = ot.EnumerateFunction(ot.LinearEnumerateFunction(2))
>>> for i in range(6):
...     print(str(i)+' '+str(enumerateFunction(i)))
0 [0,0]
1 [1,0]
2 [0,1]
3 [2,0]
4 [1,1]
5 [0,2]
>>> print(enumerateFunction.inverse([1,1]))
4"
%enddef
%feature("docstring") OT::EnumerateFunctionImplementation::inverse
OT_EnumerateFunction_inverse_doc

// ---------------------------------------------------------------------

%define OT_EnumerateFunction_setDimension_doc
"Set the dimension of the *EnumerateFunction*.

Parameters
----------
dim : int, :math:`dim \\\\geq 0`
    Dimension of the *EnumerateFunction*."
%enddef
%feature("docstring") OT::EnumerateFunctionImplementation::setDimension
OT_EnumerateFunction_setDimension_doc

// ---------------------------------------------------------------------