libopenturns-dev 1.5-7build2 / usr / include / openturns / swig / NumericalMathFunction_doc.i

%feature("docstring") OT::NumericalMathFunction
"Function.

Available constructors:
    NumericalMathFunction(*filename*)

    NumericalMathFunction(*inputs, outputs, formulas*)

    NumericalMathFunction(*inputs, formulas*)

    NumericalMathFunction(*inputString, formulaString, outputString = 'outputVariable'*)

    NumericalMathFunction(*f, g*)

    NumericalMathFunction(*functionCollection*)

    NumericalMathFunction(*functionCollection, scalarCoefficientColl*)

    NumericalMathFunction(*scalarFunctionCollection, vectorCoefficientColl*)

    NumericalMathFunction(*function, comparisonOperator, threshold*)

    NumericalMathFunction(*function, indices, parametersSet=True*)

    NumericalMathFunction(*function, indices, referencePoint, parametersSet=True*)

    NumericalMathFunction(*inputSample, outputSample*)

Parameters
----------
fileName : String or :class:`~openturns.WrapperFile`
    A string to name the XML file (without the extension '.xml') which contains
    the implementation of the considered function.
inputs : list of strings
    Ordered list of input variables names of the *NumericalMathFunction*.
outputs : list of strings
    Ordered list of output variables names of the *NumericalMathFunction*.
    If it is not specified, default names are created for the output variables.
formulas : list of strings
    Ordered list of analytical formulas between the inputs and the outputs.
    The *NumericalMathFunction* is defined by *ouputs = formulas(inputs)*.
inputString : String
    Description of the *NumericalMathFunction*'s input.
outputString : String
    Description of the *NumericalMathFunction*'s output.
formulaString : String
    Analytical formula of the *NumericalMathFunction*.
    The *NumericalMathFunction* is defined by
    *ouputString = formulaString(inputString)*.
f,g : two :class:`~openturns.NumericalMathFunction`
    The *NumericalMathFunction* is the composition function :math:`f\\\\circ g`.
functionCollection : list of :class:`~openturns.NumericalMathFunction`
    Collection of several *NumericalMathFunction*.
scalarCoefficientColl : float sequence
    Collection of scalar weights.
scalarFunctionCollection : list of :class:`~openturns.NumericalMathFunction`
    Collection of several scalar *NumericalMathFunction*.
vectorCoefficientColl : 2D float sequence
    Collection of vectorial weights.
function : :class:`~openturns.NumericalMathFunction`
    Function from which another function is created.
comparisonOperator : :class:`~openturns.ComparisonOperator`
    Comparison operator.
threshold : float
    Threshold from which values are compared.
indices : list of ints
    Indices of the set variables.
    If *referencePoint* is not mentioned, the variables are set to a null
    value. Otherwise, the variables are set to the *referencePoint*'s values.
parametersSet : bool
    If *True*, the set variables are the ones referenced in *indices*.
    Otherwise, the variables are the ones referenced in the complementary
    vector of *indices*.
referencePoint : float sequence
    If not *referencePoint* take a null vector.
inputSample : 2D float sequence
    Values of the inputs.
outputSample : 2D float sequence
    Values of the outputs.

Examples
--------
Create a *NumericalMathFunction* from a list of analytical formulas and
descriptions of the inputs and the outputs :

>>> import openturns as ot
>>> f = ot.NumericalMathFunction(['x0', 'x1'], ['y0', 'y1'],
...                              ['x0 + x1', 'x0 - x1'])
>>> print(f([1, 2]))
[3,-1]


Create a *NumericalMathFunction* from strings:

>>> import openturns as ot
>>> f = ot.NumericalMathFunction('x', '2.0*sqrt(x)', 'y')
>>> print(f(([16],[4])))
    [ y ]
0 : [ 8 ]
1 : [ 4 ]


Create a *NumericalMathFunction* from a Python function:

>>> def a_function(X):
...     return [X[0] + X[1]]
>>> f = ot.PythonFunction(2, 1, a_function)
>>> print(f(((10, 5),(6, 7))))
    [ y0 ]
0 : [ 15 ]
1 : [ 13 ]


See :class:`~openturns.PythonFunction` for further details.

Create a *NumericalMathFunction* from another *NumericalMathFunction*:

>>> f = ot.NumericalMathFunction(ot.Description.BuildDefault(4, 'x'),
...                              ['x0', 'x0 + x1', 'x0 + x2 + x3'])

Then create another function by setting x1=0 and x3=0:

>>> g = ot.NumericalMathFunction(f, [3, 1], True)
>>> print(g.getInputDescription())
[x0,x2]
>>> print(g.getOutputDescription())
[y0,y1,y2]
>>> print(g((1, 2)))
[1,1,3]

Or by setting x1=4 and x3=10:

>>> g = ot.NumericalMathFunction(f, [3, 1], [6, 4, 5, 10], True)
>>> print(g((1, 2)))
[1,5,13]

Or by setting x0=6 and x2=5:

>>> g = ot.NumericalMathFunction(f, [3, 1], [6, 4, 5, 10], False)
>>> print(g.getInputDescription())
[x3,x1]
>>> print(g((1, 2)))
[6,8,12]


Create a *NumericalMathFunction* from another *NumericalMathFunction*
and by using a comparison operator:

>>> analytical = ot.NumericalMathFunction(['x0','x1'], ['y'], ['x0 + x1'])
>>> indicator = ot.NumericalMathFunction(analytical, ot.Less(), 0.0)
>>> print(indicator([2, 3]))
[0]
>>> print(indicator([2, -3]))
[1]

Create a *NumericalMathFunction* from a collection of functions:

>>> functions = list()
>>> functions.append(ot.NumericalMathFunction(['x1', 'x2', 'x3'], ['y1', 'y2'],
...                                      ['x1^2 + x2', 'x1 + x2 + x3']))
>>> functions.append(ot.NumericalMathFunction(['x1', 'x2', 'x3'], ['y1', 'y2'],
...                                      ['x1 + 2 * x2 + x3', 'x1 + x2 - x3']))
>>> myFunction = ot.NumericalMathFunction(functions)
>>> print(myFunction([1., 2., 3.]))
[3,6,8,0]

Create a *NumericalMathFunction* which is the linear combination *linComb*
of the functions defined in  *functionCollection* with scalar weights
defined in *scalarCoefficientColl*:

:math:`functionCollection  = (f_1, \\\\hdots, f_N)`
where :math:`\\\\forall 1 \\\\leq i \\\\leq N, \\\\,     f_i: \\\\Rset^n \\\\rightarrow \\\\Rset^{p}`
and :math:`scalarCoefficientColl = (c_1, \\\\hdots, c_N) \\\\in \\\\Rset^N`
then the linear combination is:

.. math::

    linComb: \\\\left|\\\\begin{array}{rcl}
                  \\\\Rset^n & \\\\rightarrow & \\\\Rset^{p} \\\\\\\\
                  \\\\vect{X} & \\\\mapsto & \\\\displaystyle \\\\sum_i c_if_i (\\\\vect{X})
              \\\\end{array}\\\\right.

>>> myFunction2 = ot.NumericalMathFunction(functions, [2., 4.])
>>> print(myFunction2([1., 2., 3.]))
[38,12]


Create a *NumericalMathFunction* which is the linear combination
*vectLinComb* of the scalar functions defined in
*scalarFunctionCollection* with vectorial weights defined in
*vectorCoefficientColl*:

If :math:`scalarFunctionCollection = (f_1, \\\\hdots, f_N)`
where :math:`\\\\forall 1 \\\\leq i \\\\leq N, \\\\,    f_i: \\\\Rset^n \\\\rightarrow \\\\Rset`
and :math:`vectorCoefficientColl = (\\\\vect{c}_1, \\\\hdots, \\\\vect{c}_N)`
where :math:`\\\\forall 1 \\\\leq i \\\\leq N, \\\\,   \\\\vect{c}_i \\\\in \\\\Rset^p`

.. math::

    vectLinComb: \\\\left|\\\\begin{array}{rcl}
                     \\\\Rset^n & \\\\rightarrow & \\\\Rset^{p} \\\\\\\\
                     \\\\vect{X} & \\\\mapsto & \\\\displaystyle \\\\sum_i \\\\vect{c}_if_i (\\\\vect{X})
                 \\\\end{array}\\\\right.

>>> functions=list()
>>> functions.append(ot.NumericalMathFunction(['x1', 'x2', 'x3'], ['y1'],
...                                           ['x1 + 2 * x2 + x3']))
>>> functions.append(ot.NumericalMathFunction(['x1', 'x2', 'x3'], ['y1'],
...                                           ['x1^2 + x2']))
>>> myFunction2 = ot.NumericalMathFunction(functions, [[2., 4.], [3., 1.]])
>>> print(myFunction2([1, 2, 3]))
[25,35]


Create a *NumericalMathFunction* from values of the inputs and the outputs:

>>> inputSample = [[1.0, 1.0], [2.0, 2.0]]
>>> outputSample = [[4.0], [5.0]]
>>> database = ot.NumericalMathFunction(inputSample, outputSample)
>>> x = [1.8]*database.getInputDimension()
>>> print(database(x))
[5]


Create a *NumericalMathFunction* which is the composition function
:math:`f\\\\circ g`:

>>> g = ot.NumericalMathFunction(['x1', 'x2'], ['y1', 'y2'],
...                              ['x1 + x2','3 * x1 * x2'])
>>> f = ot.NumericalMathFunction(['x1', 'x2'], ['y'], ['2 * x1 - x2'])
>>> composed = ot.NumericalMathFunction(f, g)
>>> print(composed([3, 4]))
[-22]"

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

%feature("docstring") OT::NumericalMathFunction::GetValidFunctions
"Return the list of valid functions.

Returns
-------
list_functions : list of strings
    List of the functions we can use within OpenTURNS.

Examples
--------
>>> import openturns as ot
>>> print(ot.NumericalMathFunction().GetValidFunctions()[0:2])
[sin(arg) -> sine function,cos(arg) -> cosine function]"

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

%feature("docstring") OT::NumericalMathFunction::GetValidConstants
"Return the list of valid constants.

Returns
-------
list_constants : list of strings
    List of the constants we can use within OpenTURNS.

Examples
--------
>>> import openturns as ot
>>> print(ot.NumericalMathFunction().GetValidConstants()[0:2])
[_e -> Euler's constant (2.71828...),_pi -> Pi constant (3.14159...)]"

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

%feature("docstring") OT::NumericalMathFunction::GetValidOperators
"Return the list of valid operators.

Returns
-------
list_operators : list of strings
    List of the operators we can use within OpenTURNS.

Examples
--------
>>> import openturns as ot
>>> print(ot.NumericalMathFunction().GetValidOperators()[0:2])
[= -> assignement, can only be applied to variable names (priority -1),and -> logical and (priority 1)]"

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

%feature("docstring") OT::NumericalMathFunction::enableCache
"Enable the cache mechanism."

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

%feature("docstring") OT::NumericalMathFunction::disableCache
"Disable the cache mechanism."

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

%feature("docstring") OT::NumericalMathFunction::clearCache
"Empty the content of the cache."

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

%feature("docstring") OT::NumericalMathFunction::isCacheEnabled
"Test whether the cache mechanism is enabled or not.

Returns
-------
isCacheEnabled : bool
    Flag telling whether the cache mechanism is enabled.
    It is disabled by default."

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

%feature("docstring") OT::NumericalMathFunction::getCacheHits
"Accessor to the number of computations saved thanks to the cache mecanism.

Returns
-------
cacheHits : int
    Integer that counts the number of computations saved thanks to the cache
    mecanism."

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

%feature("docstring") OT::NumericalMathFunction::getCacheInput
"Accessor to all the input numerical points stored in the cache mecanism.

Returns
-------
cacheInput : 2D float sequence
    All the input numerical points stored in the cache mecanism."

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

%feature("docstring") OT::NumericalMathFunction::getCacheOutput
"Accessor to all the output numerical points stored in the cache mecanism.

Returns
-------
cacheInput : 2D float sequence
    All the output numerical points stored in the cache mecanism."

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

%feature("docstring") OT::NumericalMathFunction::addCacheContent
"Add input numerical points and associated output to the cache.

Parameters
----------
input_sample : 2D float sequence
    Input numerical points to be added to the cache.
output_sample : 2D float sequence
    Output numerical points associated with the input_sample to be added to the
    cache."

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

%feature("docstring") OT::NumericalMathFunction::enableHistory
"Enable the history mechanism."

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

%feature("docstring") OT::NumericalMathFunction::disableHistory
"Disable the history mechanism."

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

%feature("docstring") OT::NumericalMathFunction::clearHistory
"Empty the content of the history."

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

%feature("docstring") OT::NumericalMathFunction::isHistoryEnabled
"Test whether the history mechanism is enabled or not.

Returns
-------
isHistoryEnabled : bool
    Flag telling whether the history mechanism is enabled.
    It is disabled by default."

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

%feature("docstring") OT::NumericalMathFunction::getHistoryInput
"Accessor to the history of the input values.

Returns
-------
input_history : 2D float sequence
    All the input numerical points stored in the history mecanism."

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

%feature("docstring") OT::NumericalMathFunction::getHistoryOutput
"Accessor to the history of the output values.

Returns
-------
output_history : 2D float sequence
    All the output numerical points stored in the history mecanism."

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

%feature("docstring") OT::NumericalMathFunction::getCallsNumber
"Accessor to the number of times the function has been called.

Returns
-------
calls_number : int
    Integer that counts the number of times the function has been called
    since its creation."

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

%feature("docstring") OT::NumericalMathFunction::getEvaluationCallsNumber
"Accessor to the number of times the function has been called.

Returns
-------
evaluation_calls_number : int
    Integer that counts the number of times the function has been called
    since its creation."

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

%feature("docstring") OT::NumericalMathFunction::getGradientCallsNumber
"Accessor to the number of times the gradient of the function has been called.

Returns
-------
gradient_calls_number : int
    Integer that counts the number of times the gradient of the
    NumericalMathFunction has been called since its creation.
    Note that if the gradient is implemented by a finite difference method,
    the gradient calls number is equal to 0 and the different calls are
    counted in the evaluation calls number."

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

%feature("docstring") OT::NumericalMathFunction::getHessianCallsNumber
"Accessor to the number of times the hessian of the function has been called.

Returns
-------
hessian_calls_number : int
    Integer that counts the number of times the hessian of the
    NumericalMathFunction has been called since its creation.
    Note that if the hessian is implemented by a finite difference method,
    the hessian calls number is equal to 0 and the different calls are counted
    in the evaluation calls number."

// ---------------------------------------------------------------------
%feature("docstring") OT::NumericalMathFunction::getMarginal
"Accessor to marginal.

Parameters
----------
indices : int or list of ints
    Set of indices for which the marginal is extracted.

Returns
-------
marginal : :class:`~openturns.NumericalMathFunction`
    Function corresponding to either :math:`f_i` or
    :math:`(f_i)_{i \\\\in indices}`, with :math:`f:\\\\Rset^n \\\\rightarrow \\\\Rset^p`
    and :math:`f=(f_0 , \\\\dots, f_{p-1})`."
// ---------------------------------------------------------------------

%feature("docstring") OT::NumericalMathFunction::getImplementation
"Accessor to the evaluation, gradient and hessian functions.

Returns
-------
function : :class:`~openturns.NumericalMathFunctionImplementation`
    The evaluation, gradient and hessian function.

Examples
--------
>>> import openturns as ot
>>> f = ot.NumericalMathFunction(['x1', 'x2'], ['y'],
...                          ['2 * x1^2 + x1 + 8 * x2 + 4 * cos(x1) * x2 + 6'])
>>> print(f.getImplementation())
input  : [x1,x2]
output : [y]
evaluation : 2 * x1^2 + x1 + 8 * x2 + 4 * cos(x1) * x2 + 6
gradient   :
| d(y) / d(x1) = (1)+(4*x1)+((-4*((x2)*(sin(x1)))))
| d(y) / d(x2) = (8)+((4*(cos(x1)))) 

hessian    :
|    d^2(y) / d(x1)^2 = (4)+((-4*((x2)*(cos(x1)))))
| d^2(y) / d(x2)d(x1) = (-4*(sin(x1))) 
|    d^2(y) / d(x2)^2 = 0"

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

%feature("docstring") OT::NumericalMathFunction::getEvaluation
"Accessor to the evaluation function.

Returns
-------
function : :class:`~openturns.NumericalMathEvaluationImplementation`
    The evaluation function.

Examples
--------
>>> import openturns as ot
>>> f = ot.NumericalMathFunction(['x1', 'x2'], ['y'],
...                          ['2 * x1^2 + x1 + 8 * x2 + 4 * cos(x1) * x2 + 6'])
>>> print(f.getEvaluation())
[x1,x2]->[2 * x1^2 + x1 + 8 * x2 + 4 * cos(x1) * x2 + 6]"

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

%feature("docstring") OT::NumericalMathFunction::getGradient
"Accessor to the gradient function.

Returns
-------
gradient : :class:`~openturns.NumericalMathGradientImplementation`
    The gradient function."

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

%feature("docstring") OT::NumericalMathFunction::getHessianImplementation
"Accessor to the hessian function.

Returns
-------
hessian : :class:`~openturns.NumericalMathHessianImplementation`
    The hessian function."

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

%feature("docstring") OT::NumericalMathFunction::getInitialEvaluationImplementation
"Accessor to the initial evaluation function.

Returns
-------
function : :class:`~openturns.NumericalMathEvaluationImplementation`
    The initial evaluation function."

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

%feature("docstring") OT::NumericalMathFunction::getInitialGradientImplementation
"Accessor to the initial gradient function.

Returns
-------
gradient : :class:`~openturns.NumericalMathGradientImplementation`
    The initial gradient function."

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

%feature("docstring") OT::NumericalMathFunction::getInitialHessianImplementation
"Accessor to the initial hessian function.

Returns
-------
hessian : :class:`~openturns.NumericalMathHessianImplementation`
    The initial hessian function."

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

%feature("docstring") OT::NumericalMathFunction::setEvaluationImplementation
"Accessor to the evaluation function.

Parameters
----------
function : :class:`~openturns.NumericalMathEvaluationImplementation`
    The evaluation function."

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

%feature("docstring") OT::NumericalMathFunction::setGradient
"Accessor to the gradient function.

Parameters
----------
gradient_function : :class:`~openturns.NumericalMathGradientImplementation`
    The gradient function.

Examples
--------
>>> import openturns as ot
>>> f = ot.NumericalMathFunction(['x1', 'x2'], ['y'],
...                          ['2 * x1^2 + x1 + 8 * x2 + 4 * cos(x1) * x2 + 6'])
>>> f.setGradient(ot.CenteredFiniteDifferenceGradient(
...  ot.ResourceMap.GetAsNumericalScalar('CenteredFiniteDifferenceGradient-DefaultEpsilon'),
...  f.getEvaluation()))"

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

%feature("docstring") OT::NumericalMathFunction::setHessianImplementation
"Accessor to the hessian function.

Parameters
----------
hessian_function : :class:`~openturns.NumericalMathHessianImplementation`
    The hessian function.

Examples
--------
>>> import openturns as ot
>>> f = ot.NumericalMathFunction(['x1', 'x2'], ['y'],
...                          ['2 * x1^2 + x1 + 8 * x2 + 4 * cos(x1) * x2 + 6'])
>>> f.setHessian(ot.CenteredFiniteDifferenceHessian(
...  ot.ResourceMap.GetAsNumericalScalar('CenteredFiniteDifferenceHessian-DefaultEpsilon'),
...  f.getEvaluation()))"

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

%feature("docstring") OT::NumericalMathFunction::gradient
"Return the Jacobian transposed matrix of the function at point.

Parameters
----------
point : float sequence
    Point where the Jacobian transposed matrix is calculated.

Returns
-------
gradient : :class:`~openturns.Matrix`
    The Jacobian transposed matrix of the function at point.

Examples
--------
>>> import openturns as ot
>>> f = ot.NumericalMathFunction(['x1', 'x2'], ['y','z'],
...                ['2 * x1^2 + x1 + 8 * x2 + 4 * cos(x1) * x2 + 6','x1 + x2'])
>>> print(f.gradient([3.14, 4]))
[[ 13.5345   1       ]
 [  4.00001  1       ]]"

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

%feature("docstring") OT::NumericalMathFunction::hessian
"Return the symmetric tensor of the function at point.

Parameters
----------
point : float sequence
    Point where the symmetric tensor of the function is calculated.

Returns
-------
hessian : :class:`~openturns.SymmetricTensor`
    Symmetric tensor of the function at point.

Examples
--------
>>> import openturns as ot
>>> f = ot.NumericalMathFunction(['x1', 'x2'], ['y','z'],
...                ['2 * x1^2 + x1 + 8 * x2 + 4 * cos(x1) * x2 + 6','x1 + x2'])
>>> print(f.hessian([3.14, 4]))
sheet #0
[[ 20          -0.00637061 ]
 [ -0.00637061  0          ]]
sheet #1
[[  0           0          ]
 [  0           0          ]]"

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

%feature("docstring") OT::NumericalMathFunction::getDescription
"Accessor to the description of the inputs and outputs.

Returns
-------
description : list of strings
    Description of the inputs and the outputs.

Examples
--------
>>> import openturns as ot
>>> f = ot.NumericalMathFunction(['x1', 'x2'], ['y'],
...                          ['2 * x1^2 + x1 + 8 * x2 + 4 * cos(x1) * x2 + 6'])
>>> print(f.getDescription())
[x1,x2,y]"

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

%feature("docstring") OT::NumericalMathFunction::setDescription
"Accessor to the description of the inputs and outputs.

Parameters
----------
description : list of strings
    Description of the inputs and the outputs.

Examples
--------
>>> import openturns as ot
>>> f = ot.NumericalMathFunction(['x1', 'x2'], ['y'],
...                          ['2 * x1^2 + x1 + 8 * x2 + 4 * cos(x1) * x2 + 6'])
>>> print(f.getDescription())
[x1,x2,y]
>>> f.setDescription(['a','b','y'])
>>> print(f.getDescription())
[a,b,y]"

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

%feature("docstring") OT::NumericalMathFunction::getInputDescription
"Accessor to the description of the inputs.

Returns
-------
description : list of strings
    Description of the inputs.

Examples
--------
>>> import openturns as ot
>>> f = ot.NumericalMathFunction(['x1', 'x2'], ['y'],
...                          ['2 * x1^2 + x1 + 8 * x2 + 4 * cos(x1) * x2 + 6'])
>>> print(f.getInputDescription())
[x1,x2]"

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

%feature("docstring") OT::NumericalMathFunction::getOutputDescription
"Accessor to the description of the outputs.

Returns
-------
description : list of strings
    Description of the outputs.

Examples
--------
>>> import openturns as ot
>>> f = ot.NumericalMathFunction(['x1', 'x2'], ['y'],
...                          ['2 * x1^2 + x1 + 8 * x2 + 4 * cos(x1) * x2 + 6'])
>>> print(f.getOutputDescription())
[y]"
// ---------------------------------------------------------------------

%feature("docstring") OT::NumericalMathFunction::getInputDimension
"Accessor to the number of the inputs.

Returns
-------
number_inputs : int
    Number of inputs.

Examples
--------
>>> import openturns as ot
>>> f = ot.NumericalMathFunction(['x1', 'x2'], ['y'],
...                          ['2 * x1^2 + x1 + 8 * x2 + 4 * cos(x1) * x2 + 6'])
>>> print(f.getInputDimension())
2"

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

%feature("docstring") OT::NumericalMathFunction::getOutputDimension
"Accessor to the number of the outputs.

Returns
-------
number_outputs : int
    Number of outputs.

Examples
--------
>>> import openturns as ot
>>> f = ot.NumericalMathFunction(['x1', 'x2'], ['y'],
...                          ['2 * x1^2 + x1 + 8 * x2 + 4 * cos(x1) * x2 + 6'])
>>> print(f.getOutputDimension())
1"

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

%feature("docstring") OT::NumericalMathFunction::draw
"Draw the output of function as a :class:`~openturns.Graph`.

Available usages:
    draw(*inputMarg, outputMarg, CP, xiMin, xiMax, ptNb*)

    draw(*firstInputMarg, secondInputMarg, outputMarg, CP, xiMin_xjMin, xiMax_xjMax, ptNbs*)

    draw(*xiMin, xiMax, ptNb*)

    draw(*xiMin_xjMin, xiMax_xjMax, ptNbs*)

Parameters
----------
outputMarg, inputMarg : int, :math:`outputMarg, inputMarg \\\\geq 0`
    *outputMarg* is the index of the marginal to draw as a function of the marginal
    with index *inputMarg*.
firstInputMarg, secondInputMarg : int, :math:`firstInputMarg, secondInputMarg \\\\geq 0`
    In the 2D case, the marginal *outputMarg* is drawn as a function of the
    two marginals with indexes *firstInputMarg* and *secondInputMarg*.
CP : float sequence
    Central point.
xiMin, xiMax : float
    Define the interval where the curve is plotted.
xiMin_xjMin, xiMax_xjMax : float sequences of dimension 2.
    In the 2D case, define the intervals where the curves are plotted.
ptNb : int :math:`ptNb > 0` or list of ints of dimension 2 :math:`ptNb_k > 0, k=1,2`
    The number of points to draw the curves.

Notes
-----
We note :math:`f: \\\\Rset^n \\\\rightarrow \\\\Rset^p`
where :math:`\\\\vect{x} = (x_1, \\\\dots, x_n)` and
:math:`f(\\\\vect{x}) = (f_1(\\\\vect{x}), \\\\dots,f_p(\\\\vect{x}))`,
with :math:`n\\\\geq 1` and :math:`p\\\\geq 1`.

- In the first usage:

Draws graph of the given 1D *outputMarg* marginal
:math:`f_k: \\\\Rset^n \\\\rightarrow \\\\Rset` as a function of the given 1D *inputMarg*
marginal with respect to the variation of :math:`x_i` in the interval
:math:`[x_i^{min}, x_i^{max}]`, when all the other components of
:math:`\\\\vect{x}` are fixed to the corresponding ones of the central point *CP*.
Then OpenTURNS draws the graph:
:math:`t\\\\in [x_i^{min}, x_i^{max}] \\\\mapsto f_k(CP_1, \\\\dots, CP_{i-1}, t,  CP_{i+1} \\\\dots, CP_n)`.

- In the second usage:

Draws the iso-curves of the given *outputMarg* marginal :math:`f_k` as a
function of the given 2D *firstInputMarg* and *secondInputMarg* marginals
with respect to the variation of :math:`(x_i, x_j)` in the interval
:math:`[x_i^{min}, x_i^{max}] \\\\times [x_j^{min}, x_j^{max}]`, when all the
other components of :math:`\\\\vect{x}` are fixed to the corresponding ones of the
central point *CP*. Then OpenTURNS draws the graph:
:math:`(t,u) \\\\in [x_i^{min}, x_i^{max}] \\\\times [x_j^{min}, x_j^{max}] \\\\mapsto f_k(CP_1, \\\\dots, CP_{i-1}, t, CP_{i+1}, \\\\dots, CP_{j-1}, u,  CP_{j+1} \\\\dots, CP_n)`.

- In the third usage:

The same as the first usage but only for function :math:`f: \\\\Rset \\\\rightarrow \\\\Rset`.

- In the fourth usage:

The same as the second usage but only for function :math:`f: \\\\Rset^2 \\\\rightarrow \\\\Rset`.


Examples
--------
>>> import openturns as ot
>>> from openturns.viewer import View
>>> f = ot.NumericalMathFunction('x', 'sin(2*_pi*x)*exp(-x^2/2)', 'y')
>>> graph = f.draw(-1.2, 1.2, 100)
>>> View(graph).show()"

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

%feature("docstring") OT::NumericalMathFunction::getParameters
"**(ditch me?)**"

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

%feature("docstring") OT::NumericalMathFunction::setParameters
"**(ditch me?)**"

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

%feature("docstring") OT::NumericalMathFunction::parametersGradient
"**(ditch me?)**"

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

%feature("docstring") OT::NumericalMathFunction::getUseDefaultGradientImplementation
"**(ditch me?)**"

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

%feature("docstring") OT::NumericalMathFunction::getUseDefaultHessianImplementation
"**(ditch me?)**"

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

%feature("docstring") OT::NumericalMathFunction::setUseDefaultGradientImplementation
"**(ditch me?)**"

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

%feature("docstring") OT::NumericalMathFunction::setUseDefaultHessianImplementation
"**(ditch me?)**"