%feature("docstring") OT::EvaluationImplementation
"Numerical math evaluation implementation.

Available constructors:
    EvaluationImplementation()

See also
--------
Function, AggregatedEvaluation,
DatabaseEvaluation,
DualLinearCombinationEvaluation, LinearFunction
"

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

%feature("docstring") OT::EvaluationImplementation::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::EvaluationImplementation::getCacheInput
"Accessor to all the input numerical points stored in the cache mecanism.

Returns
-------
cacheInput : :class:`~openturns.Sample`
    All the input numerical points stored in the cache mecanism."

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

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

Returns
-------
cacheInput : :class:`~openturns.Sample`
    All the output numerical points stored in the cache mecanism."

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

%feature("docstring") OT::EvaluationImplementation::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::EvaluationImplementation::getDescription
"Accessor to the description of the inputs and outputs.

Returns
-------
description : :class:`~openturns.Description`
    Description of the inputs and the outputs.

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

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

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

Returns
-------
input_history : :class:`~openturns.Sample`
    All the input numerical points stored in the history mecanism."

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

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

Returns
-------
output_history : :class:`~openturns.Sample`
    All the output numerical points stored in the history mecanism."

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

%feature("docstring") OT::EvaluationImplementation::getInputPointHistory 
"Accessor to the history of the input points values.

Returns
-------
history : :class:`~openturns.Sample`
    All the input points stored in the history mecanism."

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

%feature("docstring") OT::EvaluationImplementation::getInputParameterHistory 
"Accessor to the history of the input parameter values.

Returns
-------
history : :class:`~openturns.Sample`
    All the input parameters stored in the history mecanism."

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

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

Returns
-------
description : :class:`~openturns.Description`
    Description of the inputs.

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

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

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

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

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

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

%feature("docstring") OT::EvaluationImplementation::getMarginal
"Accessor to marginal.

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

Returns
-------
marginal : :class:`~openturns.Function`
    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::EvaluationImplementation::getOutputDescription
"Accessor to the description of the outputs.

Returns
-------
description : :class:`~openturns.Description`
    Description of the outputs.

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

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

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

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

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

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

%feature("docstring") OT::EvaluationImplementation::getParameterDimension
"Accessor to the dimension of the parameter.

Returns
-------
parameter_dimension : int
    Dimension of the parameter."

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

%feature("docstring") OT::EvaluationImplementation::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::EvaluationImplementation::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::EvaluationImplementation::setDescription
"Accessor to the description of the inputs and outputs.

Parameters
----------
description : sequence of str
    Description of the inputs and the outputs.

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

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

%feature("docstring") OT::EvaluationImplementation::setInputDescription
"Accessor to the description of the inputs.

Returns
-------
description : :class:`~openturns.Description`
    Description of the inputs."

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

%feature("docstring") OT::EvaluationImplementation::setOutputDescription
"Accessor to the description of the outputs.

Returns
-------
description : :class:`~openturns.Description`
    Description of the outputs."

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

%feature("docstring") OT::EvaluationImplementation::parameterGradient
"Gradient against the parameters.

Parameters
----------
x : sequence of float
    Input point

Returns
-------
parameter_gradient : :class:`~openturns.Matrix`
    The parameters gradient computed at x."

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

%feature("docstring") OT::EvaluationImplementation::getParameter
"Accessor to the parameter values.

Returns
-------
parameter : :class:`~openturns.Point`
    The parameter values."

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

%feature("docstring") OT::EvaluationImplementation::setParameter
"Accessor to the parameter values.

Parameters
----------
parameter : sequence of float
    The parameter values."

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

%feature("docstring") OT::EvaluationImplementation::getParameterDescription
"Accessor to the parameter description.

Returns
-------
parameter : :class:`~openturns.Description`
    The parameter description."

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

%feature("docstring") OT::EvaluationImplementation::setParameterDescription
"Accessor to the parameter description.

Parameters
----------
parameter : :class:`~openturns.Description`
    The parameter description."

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

%feature("docstring") OT::EvaluationImplementation::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 : sequence of float
    Central point.
xiMin, xiMax : float
    Define the interval where the curve is plotted.
xiMin_xjMin, xiMax_xjMax : sequence of float 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.SymbolicFunction(['x'], ['sin(2*_pi*x)*exp(-x^2/2)'])
>>> graph = f.draw(-1.2, 1.2, 100)
>>> View(graph).show()"

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

%feature("docstring") OT::EvaluationImplementation::isActualImplementation
"Accessor to the validity flag.

Returns
-------
is_impl : bool
    Whether the implementation is valid."
