{ "cells": [ { "cell_type": "code", "execution_count": 1, "metadata": {}, "outputs": [], "source": [ "%matplotlib inline" ] }, { "cell_type": "code", "execution_count": 2, "metadata": {}, "outputs": [], "source": [ "import numpy as np\n", "import matplotlib.pyplot as plt" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "# Fonctions vectorisées" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "## 1. Tracés de courbes" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "Toutes les fonctions de numpy sont VECTORISÉES" ] }, { "cell_type": "code", "execution_count": 6, "metadata": {}, "outputs": [ { "data": { "text/plain": [ "array([0.70028175, 0.82560597, 0.72611354, 0.72611354, 0.82560597,\n", " 0.70028175])" ] }, "execution_count": 6, "metadata": {}, "output_type": "execute_result" } ], "source": [ "def f(t) :\n", " return np.sinc(t)-0.3*np.sinc(3*t)\n", "f(np.arange(-0.5,0.5001,0.2))" ] }, { "cell_type": "code", "execution_count": 11, "metadata": {}, "outputs": [ { "data": { "image/png": "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\n", "text/plain": [ "
" ] }, "metadata": {}, "output_type": "display_data" } ], "source": [ "X = np.linspace(-3,3,500)\n", "plt.plot(X,f(X),\"-m\",linewidth=2)\n", "plt.plot(X,1-0.2*X**2,\"--b\",linewidth=1)\n", "plt.grid()" ] }, { "cell_type": "code", "execution_count": null, "metadata": {}, "outputs": [], "source": [] }, { "cell_type": "markdown", "metadata": {}, "source": [ "Une intégrale $\\displaystyle\\int_{-1}^{1}f(t)\\;dt$" ] }, { "cell_type": "code", "execution_count": 14, "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ " quad(func, a, b, args=(), full_output=0, epsabs=1.49e-08, epsrel=1.49e-08,\n", " limit=50, points=None, weight=None, wvar=None, wopts=None, maxp1=50,\n", " limlst=50)\n", "\n", "Compute a definite integral.\n", "\n", "Integrate func from `a` to `b` (possibly infinite interval) using a\n", "technique from the Fortran library QUADPACK.\n", "\n", "Parameters\n", "----------\n", "func : {function, scipy.LowLevelCallable}\n", " A Python function or method to integrate. If `func` takes many\n", " arguments, it is integrated along the axis corresponding to the\n", " first argument.\n", "\n", " If the user desires improved integration performance, then `f` may\n", " be a `scipy.LowLevelCallable` with one of the signatures::\n", "\n", " double func(double x)\n", " double func(double x, void *user_data)\n", " double func(int n, double *xx)\n", " double func(int n, double *xx, void *user_data)\n", "\n", " The ``user_data`` is the data contained in the `scipy.LowLevelCallable`.\n", " In the call forms with ``xx``, ``n`` is the length of the ``xx``\n", " array which contains ``xx[0] == x`` and the rest of the items are\n", " numbers contained in the ``args`` argument of quad.\n", "\n", " In addition, certain ctypes call signatures are supported for\n", " backward compatibility, but those should not be used in new code.\n", "a : float\n", " Lower limit of integration (use -numpy.inf for -infinity).\n", "b : float\n", " Upper limit of integration (use numpy.inf for +infinity).\n", "args : tuple, optional\n", " Extra arguments to pass to `func`.\n", "full_output : int, optional\n", " Non-zero to return a dictionary of integration information.\n", " If non-zero, warning messages are also suppressed and the\n", " message is appended to the output tuple.\n", "\n", "Returns\n", "-------\n", "y : float\n", " The integral of func from `a` to `b`.\n", "abserr : float\n", " An estimate of the absolute error in the result.\n", "infodict : dict\n", " A dictionary containing additional information.\n", " Run scipy.integrate.quad_explain() for more information.\n", "message\n", " A convergence message.\n", "explain\n", " Appended only with 'cos' or 'sin' weighting and infinite\n", " integration limits, it contains an explanation of the codes in\n", " infodict['ierlst']\n", "\n", "Other Parameters\n", "----------------\n", "epsabs : float or int, optional\n", " Absolute error tolerance.\n", "epsrel : float or int, optional\n", " Relative error tolerance.\n", "limit : float or int, optional\n", " An upper bound on the number of subintervals used in the adaptive\n", " algorithm.\n", "points : (sequence of floats,ints), optional\n", " A sequence of break points in the bounded integration interval\n", " where local difficulties of the integrand may occur (e.g.,\n", " singularities, discontinuities). The sequence does not have\n", " to be sorted.\n", "weight : float or int, optional\n", " String indicating weighting function. Full explanation for this\n", " and the remaining arguments can be found below.\n", "wvar : optional\n", " Variables for use with weighting functions.\n", "wopts : optional\n", " Optional input for reusing Chebyshev moments.\n", "maxp1 : float or int, optional\n", " An upper bound on the number of Chebyshev moments.\n", "limlst : int, optional\n", " Upper bound on the number of cycles (>=3) for use with a sinusoidal\n", " weighting and an infinite end-point.\n", "\n", "See Also\n", "--------\n", "dblquad : double integral\n", "tplquad : triple integral\n", "nquad : n-dimensional integrals (uses `quad` recursively)\n", "fixed_quad : fixed-order Gaussian quadrature\n", "quadrature : adaptive Gaussian quadrature\n", "odeint : ODE integrator\n", "ode : ODE integrator\n", "simps : integrator for sampled data\n", "romb : integrator for sampled data\n", "scipy.special : for coefficients and roots of orthogonal polynomials\n", "\n", "Notes\n", "-----\n", "\n", "**Extra information for quad() inputs and outputs**\n", "\n", "If full_output is non-zero, then the third output argument\n", "(infodict) is a dictionary with entries as tabulated below. For\n", "infinite limits, the range is transformed to (0,1) and the\n", "optional outputs are given with respect to this transformed range.\n", "Let M be the input argument limit and let K be infodict['last'].\n", "The entries are:\n", "\n", "'neval'\n", " The number of function evaluations.\n", "'last'\n", " The number, K, of subintervals produced in the subdivision process.\n", "'alist'\n", " A rank-1 array of length M, the first K elements of which are the\n", " left end points of the subintervals in the partition of the\n", " integration range.\n", "'blist'\n", " A rank-1 array of length M, the first K elements of which are the\n", " right end points of the subintervals.\n", "'rlist'\n", " A rank-1 array of length M, the first K elements of which are the\n", " integral approximations on the subintervals.\n", "'elist'\n", " A rank-1 array of length M, the first K elements of which are the\n", " moduli of the absolute error estimates on the subintervals.\n", "'iord'\n", " A rank-1 integer array of length M, the first L elements of\n", " which are pointers to the error estimates over the subintervals\n", " with ``L=K`` if ``K<=M/2+2`` or ``L=M+1-K`` otherwise. Let I be the\n", " sequence ``infodict['iord']`` and let E be the sequence\n", " ``infodict['elist']``. Then ``E[I[1]], ..., E[I[L]]`` forms a\n", " decreasing sequence.\n", "\n", "If the input argument points is provided (i.e. it is not None),\n", "the following additional outputs are placed in the output\n", "dictionary. Assume the points sequence is of length P.\n", "\n", "'pts'\n", " A rank-1 array of length P+2 containing the integration limits\n", " and the break points of the intervals in ascending order.\n", " This is an array giving the subintervals over which integration\n", " will occur.\n", "'level'\n", " A rank-1 integer array of length M (=limit), containing the\n", " subdivision levels of the subintervals, i.e., if (aa,bb) is a\n", " subinterval of ``(pts[1], pts[2])`` where ``pts[0]`` and ``pts[2]``\n", " are adjacent elements of ``infodict['pts']``, then (aa,bb) has level l\n", " if ``|bb-aa| = |pts[2]-pts[1]| * 2**(-l)``.\n", "'ndin'\n", " A rank-1 integer array of length P+2. After the first integration\n", " over the intervals (pts[1], pts[2]), the error estimates over some\n", " of the intervals may have been increased artificially in order to\n", " put their subdivision forward. This array has ones in slots\n", " corresponding to the subintervals for which this happens.\n", "\n", "**Weighting the integrand**\n", "\n", "The input variables, *weight* and *wvar*, are used to weight the\n", "integrand by a select list of functions. Different integration\n", "methods are used to compute the integral with these weighting\n", "functions. The possible values of weight and the corresponding\n", "weighting functions are.\n", "\n", "========== =================================== =====================\n", "``weight`` Weight function used ``wvar``\n", "========== =================================== =====================\n", "'cos' cos(w*x) wvar = w\n", "'sin' sin(w*x) wvar = w\n", "'alg' g(x) = ((x-a)**alpha)*((b-x)**beta) wvar = (alpha, beta)\n", "'alg-loga' g(x)*log(x-a) wvar = (alpha, beta)\n", "'alg-logb' g(x)*log(b-x) wvar = (alpha, beta)\n", "'alg-log' g(x)*log(x-a)*log(b-x) wvar = (alpha, beta)\n", "'cauchy' 1/(x-c) wvar = c\n", "========== =================================== =====================\n", "\n", "wvar holds the parameter w, (alpha, beta), or c depending on the weight\n", "selected. In these expressions, a and b are the integration limits.\n", "\n", "For the 'cos' and 'sin' weighting, additional inputs and outputs are\n", "available.\n", "\n", "For finite integration limits, the integration is performed using a\n", "Clenshaw-Curtis method which uses Chebyshev moments. For repeated\n", "calculations, these moments are saved in the output dictionary:\n", "\n", "'momcom'\n", " The maximum level of Chebyshev moments that have been computed,\n", " i.e., if ``M_c`` is ``infodict['momcom']`` then the moments have been\n", " computed for intervals of length ``|b-a| * 2**(-l)``,\n", " ``l=0,1,...,M_c``.\n", "'nnlog'\n", " A rank-1 integer array of length M(=limit), containing the\n", " subdivision levels of the subintervals, i.e., an element of this\n", " array is equal to l if the corresponding subinterval is\n", " ``|b-a|* 2**(-l)``.\n", "'chebmo'\n", " A rank-2 array of shape (25, maxp1) containing the computed\n", " Chebyshev moments. These can be passed on to an integration\n", " over the same interval by passing this array as the second\n", " element of the sequence wopts and passing infodict['momcom'] as\n", " the first element.\n", "\n", "If one of the integration limits is infinite, then a Fourier integral is\n", "computed (assuming w neq 0). If full_output is 1 and a numerical error\n", "is encountered, besides the error message attached to the output tuple,\n", "a dictionary is also appended to the output tuple which translates the\n", "error codes in the array ``info['ierlst']`` to English messages. The\n", "output information dictionary contains the following entries instead of\n", "'last', 'alist', 'blist', 'rlist', and 'elist':\n", "\n", "'lst'\n", " The number of subintervals needed for the integration (call it ``K_f``).\n", "'rslst'\n", " A rank-1 array of length M_f=limlst, whose first ``K_f`` elements\n", " contain the integral contribution over the interval\n", " ``(a+(k-1)c, a+kc)`` where ``c = (2*floor(|w|) + 1) * pi / |w|``\n", " and ``k=1,2,...,K_f``.\n", "'erlst'\n", " A rank-1 array of length ``M_f`` containing the error estimate\n", " corresponding to the interval in the same position in\n", " ``infodict['rslist']``.\n", "'ierlst'\n", " A rank-1 integer array of length ``M_f`` containing an error flag\n", " corresponding to the interval in the same position in\n", " ``infodict['rslist']``. See the explanation dictionary (last entry\n", " in the output tuple) for the meaning of the codes.\n", "\n", "Examples\n", "--------\n", "Calculate :math:`\\int^4_0 x^2 dx` and compare with an analytic result\n", "\n", ">>> from scipy import integrate\n", ">>> x2 = lambda x: x**2\n", ">>> integrate.quad(x2, 0, 4)\n", "(21.333333333333332, 2.3684757858670003e-13)\n", ">>> print(4**3 / 3.) # analytical result\n", "21.3333333333\n", "\n", "Calculate :math:`\\int^\\infty_0 e^{-x} dx`\n", "\n", ">>> invexp = lambda x: np.exp(-x)\n", ">>> integrate.quad(invexp, 0, np.inf)\n", "(1.0, 5.842605999138044e-11)\n", "\n", ">>> f = lambda x,a : a*x\n", ">>> y, err = integrate.quad(f, 0, 1, args=(1,))\n", ">>> y\n", "0.5\n", ">>> y, err = integrate.quad(f, 0, 1, args=(3,))\n", ">>> y\n", "1.5\n", "\n", "Calculate :math:`\\int^1_0 x^2 + y^2 dx` with ctypes, holding\n", "y parameter as 1::\n", "\n", " testlib.c =>\n", " double func(int n, double args[n]){\n", " return args[0]*args[0] + args[1]*args[1];}\n", " compile to library testlib.*\n", "\n", "::\n", "\n", " from scipy import integrate\n", " import ctypes\n", " lib = ctypes.CDLL('/home/.../testlib.*') #use absolute path\n", " lib.func.restype = ctypes.c_double\n", " lib.func.argtypes = (ctypes.c_int,ctypes.c_double)\n", " integrate.quad(lib.func,0,1,(1))\n", " #(1.3333333333333333, 1.4802973661668752e-14)\n", " print((1.0**3/3.0 + 1.0) - (0.0**3/3.0 + 0.0)) #Analytic result\n", " # 1.3333333333333333\n", "\n", "Be aware that pulse shapes and other sharp features as compared to the\n", "size of the integration interval may not be integrated correctly using\n", "this method. A simplified example of this limitation is integrating a\n", "y-axis reflected step function with many zero values within the integrals\n", "bounds.\n", "\n", ">>> y = lambda x: 1 if x<=0 else 0\n", ">>> integrate.quad(y, -1, 1)\n", "(1.0, 1.1102230246251565e-14)\n", ">>> integrate.quad(y, -1, 100)\n", "(1.0000000002199108, 1.0189464580163188e-08)\n", ">>> integrate.quad(y, -1, 10000)\n", "(0.0, 0.0)\n" ] } ], "source": [ "from scipy.integrate import quad\n", "np.info(quad)" ] }, { "cell_type": "code", "execution_count": 15, "metadata": {}, "outputs": [ { "data": { "text/plain": [ "1.072361096948513" ] }, "execution_count": 15, "metadata": {}, "output_type": "execute_result" } ], "source": [ "integ,err = quad(f,-1,1)\n", "integ" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "## Fonction non vectorisée (à cause du if)" ] }, { "cell_type": "code", "execution_count": 35, "metadata": {}, "outputs": [], "source": [ "def b(t) :\n", " if t**2 < 5.0 : return 1-0.2*t**2\n", " else : return 0" ] }, { "cell_type": "code", "execution_count": 36, "metadata": {}, "outputs": [ { "ename": "ValueError", "evalue": "The truth value of an array with more than one element is ambiguous. Use a.any() or a.all()", "output_type": "error", "traceback": [ "\u001b[1;31m---------------------------------------------------------------------------\u001b[0m", "\u001b[1;31mValueError\u001b[0m Traceback (most recent call last)", "\u001b[1;32m\u001b[0m in \u001b[0;36m\u001b[1;34m()\u001b[0m\n\u001b[1;32m----> 1\u001b[1;33m \u001b[0mb\u001b[0m\u001b[1;33m(\u001b[0m\u001b[0mnp\u001b[0m\u001b[1;33m.\u001b[0m\u001b[0marange\u001b[0m\u001b[1;33m(\u001b[0m\u001b[1;33m-\u001b[0m\u001b[1;36m0.5\u001b[0m\u001b[1;33m,\u001b[0m\u001b[1;36m0.500\u001b[0m\u001b[1;33m,\u001b[0m\u001b[1;36m0.2\u001b[0m\u001b[1;33m)\u001b[0m\u001b[1;33m)\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[0m", "\u001b[1;32m\u001b[0m in \u001b[0;36mb\u001b[1;34m(t)\u001b[0m\n\u001b[0;32m 1\u001b[0m \u001b[1;32mdef\u001b[0m \u001b[0mb\u001b[0m\u001b[1;33m(\u001b[0m\u001b[0mt\u001b[0m\u001b[1;33m)\u001b[0m \u001b[1;33m:\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[1;32m----> 2\u001b[1;33m \u001b[1;32mif\u001b[0m \u001b[0mt\u001b[0m\u001b[1;33m**\u001b[0m\u001b[1;36m2\u001b[0m \u001b[1;33m<\u001b[0m \u001b[1;36m5.0\u001b[0m \u001b[1;33m:\u001b[0m \u001b[1;32mreturn\u001b[0m \u001b[1;36m1\u001b[0m\u001b[1;33m-\u001b[0m\u001b[1;36m0.2\u001b[0m\u001b[1;33m*\u001b[0m\u001b[0mt\u001b[0m\u001b[1;33m**\u001b[0m\u001b[1;36m2\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[0m\u001b[0;32m 3\u001b[0m \u001b[1;32melse\u001b[0m \u001b[1;33m:\u001b[0m \u001b[1;32mreturn\u001b[0m \u001b[1;36m0\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n", "\u001b[1;31mValueError\u001b[0m: The truth value of an array with more than one element is ambiguous. Use a.any() or a.all()" ] } ], "source": [ "b(np.arange(-0.5,0.500,0.2))" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "## Fonction vectorisée (sans if)" ] }, { "cell_type": "code", "execution_count": 37, "metadata": {}, "outputs": [ { "data": { "text/plain": [ "array([-6. , -3.5, -1. , 1.5, 4. ])" ] }, "execution_count": 37, "metadata": {}, "output_type": "execute_result" } ], "source": [ "T = np.arange(-6,6.01,2.5) ; T" ] }, { "cell_type": "code", "execution_count": 38, "metadata": {}, "outputs": [ { "data": { "text/plain": [ "array([False, False, True, True, False])" ] }, "execution_count": 38, "metadata": {}, "output_type": "execute_result" } ], "source": [ "T**2 < 5.0" ] }, { "cell_type": "code", "execution_count": 29, "metadata": {}, "outputs": [ { "data": { "text/plain": [ "array([0. , 0.982, 0.998, 0.998, 0.982, 0. ])" ] }, "execution_count": 29, "metadata": {}, "output_type": "execute_result" } ], "source": [ "(T**2 < 5.0)*(1-0.2*T**2)" ] }, { "cell_type": "code", "execution_count": 33, "metadata": {}, "outputs": [], "source": [ "def g_vec(t) : return (t**2 < 5.0)*(1-0.2*t**2)" ] }, { "cell_type": "code", "execution_count": 34, "metadata": {}, "outputs": [ { "data": { "image/png": "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\n", "text/plain": [ "
" ] }, "metadata": {}, "output_type": "display_data" } ], "source": [ "X = np.linspace(-3,3,500)\n", "plt.plot(X,g_vec(X),\"-g\",linewidth=2)\n", "plt.grid()" ] }, { "cell_type": "code", "execution_count": null, "metadata": {}, "outputs": [], "source": [] } ], "metadata": { "kernelspec": { "display_name": "Python 3", "language": "python", "name": "python3" }, "language_info": { "codemirror_mode": { "name": "ipython", "version": 3 }, "file_extension": ".py", "mimetype": "text/x-python", "name": "python", "nbconvert_exporter": "python", "pygments_lexer": "ipython3", "version": "3.6.5" } }, "nbformat": 4, "nbformat_minor": 2 }