Vous êtes un professionnel et vous avez besoin d'une formation ? Mise en oeuvre d'IHM
avec Qt et PySide6 Voir le programme détaillé

Module « scipy.integrate »

Fonction quad_vec - module scipy.integrate

Signature de la fonction quad_vec

def quad_vec(f, a, b, epsabs=1e-200, epsrel=1e-08, norm='2', cache_size=100000000.0, limit=10000, workers=1, points=None, quadrature=None, full_output=False, *, args=()) 

Description

help(scipy.integrate.quad_vec)

Adaptive integration of a vector-valued function.

Parameters
----------
f : callable
    Vector-valued function f(x) to integrate.
a : float
    Initial point.
b : float
    Final point.
epsabs : float, optional
    Absolute tolerance.
epsrel : float, optional
    Relative tolerance.
norm : {'max', '2'}, optional
    Vector norm to use for error estimation.
cache_size : int, optional
    Number of bytes to use for memoization.
limit : float or int, optional
    An upper bound on the number of subintervals used in the adaptive
    algorithm.
workers : int or map-like callable, optional
    If `workers` is an integer, part of the computation is done in
    parallel subdivided to this many tasks (using
    :class:`python:multiprocessing.pool.Pool`).
    Supply `-1` to use all cores available to the Process.
    Alternatively, supply a map-like callable, such as
    :meth:`python:multiprocessing.pool.Pool.map` for evaluating the
    population in parallel.
    This evaluation is carried out as ``workers(func, iterable)``.
points : list, optional
    List of additional breakpoints.
quadrature : {'gk21', 'gk15', 'trapezoid'}, optional
    Quadrature rule to use on subintervals.
    Options: 'gk21' (Gauss-Kronrod 21-point rule),
    'gk15' (Gauss-Kronrod 15-point rule),
    'trapezoid' (composite trapezoid rule).
    Default: 'gk21' for finite intervals and 'gk15' for (semi-)infinite
full_output : bool, optional
    Return an additional ``info`` dictionary.
args : tuple, optional
    Extra arguments to pass to function, if any.

    .. versionadded:: 1.8.0

Returns
-------
res : {float, array-like}
    Estimate for the result
err : float
    Error estimate for the result in the given norm
info : dict
    Returned only when ``full_output=True``.
    Info dictionary. Is an object with the attributes:

        success : bool
            Whether integration reached target precision.
        status : int
            Indicator for convergence, success (0),
            failure (1), and failure due to rounding error (2).
        neval : int
            Number of function evaluations.
        intervals : ndarray, shape (num_intervals, 2)
            Start and end points of subdivision intervals.
        integrals : ndarray, shape (num_intervals, ...)
            Integral for each interval.
            Note that at most ``cache_size`` values are recorded,
            and the array may contains *nan* for missing items.
        errors : ndarray, shape (num_intervals,)
            Estimated integration error for each interval.

Notes
-----
The algorithm mainly follows the implementation of QUADPACK's
DQAG* algorithms, implementing global error control and adaptive
subdivision.

The algorithm here has some differences to the QUADPACK approach:

Instead of subdividing one interval at a time, the algorithm
subdivides N intervals with largest errors at once. This enables
(partial) parallelization of the integration.

The logic of subdividing "next largest" intervals first is then
not implemented, and we rely on the above extension to avoid
concentrating on "small" intervals only.

The Wynn epsilon table extrapolation is not used (QUADPACK uses it
for infinite intervals). This is because the algorithm here is
supposed to work on vector-valued functions, in an user-specified
norm, and the extension of the epsilon algorithm to this case does
not appear to be widely agreed. For max-norm, using elementwise
Wynn epsilon could be possible, but we do not do this here with
the hope that the epsilon extrapolation is mainly useful in
special cases.

References
----------
[1] R. Piessens, E. de Doncker, QUADPACK (1983).

Examples
--------
We can compute integrations of a vector-valued function:

>>> from scipy.integrate import quad_vec
>>> import numpy as np
>>> import matplotlib.pyplot as plt
>>> alpha = np.linspace(0.0, 2.0, num=30)
>>> f = lambda x: x**alpha
>>> x0, x1 = 0, 2
>>> y, err = quad_vec(f, x0, x1)
>>> plt.plot(alpha, y)
>>> plt.xlabel(r"$\alpha$")
>>> plt.ylabel(r"$\int_{0}^{2} x^\alpha dx$")
>>> plt.show()

When using the argument `workers`, one should ensure
that the main module is import-safe, for instance
by rewriting the example above as:

.. code-block:: python

    from scipy.integrate import quad_vec
    import numpy as np
    import matplotlib.pyplot as plt

    alpha = np.linspace(0.0, 2.0, num=30)
    x0, x1 = 0, 2
    def f(x):
        return x**alpha

    if __name__ == "__main__":
        y, err = quad_vec(f, x0, x1, workers=2)

Vous êtes un professionnel et vous avez besoin d'une formation ? Machine Learning
avec Scikit-Learn Voir le programme détaillé