SciPy.ipynb

{
  "nbformat": 4,
  "nbformat_minor": 0,
  "metadata": {
    "colab": {
      "name": "SciPy.ipynb",
      "provenance": [],
      "include_colab_link": true
    },
    "kernelspec": {
      "name": "python3",
      "display_name": "Python 3"
    }
  },
  "cells": [
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "view-in-github",
        "colab_type": "text"
      },
      "source": [
        "<a href=\"https://colab.research.google.com/github/Chandradithya8/Machine-Learning/blob/master/SciPy.ipynb\" target=\"_parent\"><img src=\"https://colab.research.google.com/assets/colab-badge.svg\" alt=\"Open In Colab\"/></a>"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "4ZLhAmzJ9c6H",
        "outputId": "9bedcc1c-9988-44a1-ea16-a4990c71d527",
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 731
        }
      },
      "source": [
        "#help function\n",
        "from scipy import cluster\n",
        "help(cluster)"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "Help on package scipy.cluster in scipy:\n",
            "\n",
            "NAME\n",
            "    scipy.cluster\n",
            "\n",
            "DESCRIPTION\n",
            "    =========================================\n",
            "    Clustering package (:mod:`scipy.cluster`)\n",
            "    =========================================\n",
            "    \n",
            "    .. currentmodule:: scipy.cluster\n",
            "    \n",
            "    :mod:`scipy.cluster.vq`\n",
            "    \n",
            "    Clustering algorithms are useful in information theory, target detection,\n",
            "    communications, compression, and other areas.  The `vq` module only\n",
            "    supports vector quantization and the k-means algorithms.\n",
            "    \n",
            "    :mod:`scipy.cluster.hierarchy`\n",
            "    \n",
            "    The `hierarchy` module provides functions for hierarchical and\n",
            "    agglomerative clustering.  Its features include generating hierarchical\n",
            "    clusters from distance matrices,\n",
            "    calculating statistics on clusters, cutting linkages\n",
            "    to generate flat clusters, and visualizing clusters with dendrograms.\n",
            "\n",
            "PACKAGE CONTENTS\n",
            "    _hierarchy\n",
            "    _optimal_leaf_ordering\n",
            "    _vq\n",
            "    hierarchy\n",
            "    setup\n",
            "    tests (package)\n",
            "    vq\n",
            "\n",
            "DATA\n",
            "    __all__ = ['vq', 'hierarchy']\n",
            "\n",
            "FILE\n",
            "    /usr/local/lib/python3.6/dist-packages/scipy/cluster/__init__.py\n",
            "\n",
            "\n"
          ],
          "name": "stdout"
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "8bxsm0Zt-ywL",
        "outputId": "1b4c7f47-364a-4af4-d104-d91728360d32",
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 1000
        }
      },
      "source": [
        "help()"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "\n",
            "Welcome to Python 3.6's help utility!\n",
            "\n",
            "If this is your first time using Python, you should definitely check out\n",
            "the tutorial on the Internet at https://docs.python.org/3.6/tutorial/.\n",
            "\n",
            "Enter the name of any module, keyword, or topic to get help on writing\n",
            "Python programs and using Python modules.  To quit this help utility and\n",
            "return to the interpreter, just type \"quit\".\n",
            "\n",
            "To get a list of available modules, keywords, symbols, or topics, type\n",
            "\"modules\", \"keywords\", \"symbols\", or \"topics\".  Each module also comes\n",
            "with a one-line summary of what it does; to list the modules whose name\n",
            "or summary contain a given string such as \"spam\", type \"modules spam\".\n",
            "\n",
            "help> scipy.cluster\n",
            "Help on package scipy.cluster in scipy:\n",
            "\n",
            "NAME\n",
            "    scipy.cluster\n",
            "\n",
            "DESCRIPTION\n",
            "    =========================================\n",
            "    Clustering package (:mod:`scipy.cluster`)\n",
            "    =========================================\n",
            "    \n",
            "    .. currentmodule:: scipy.cluster\n",
            "    \n",
            "    :mod:`scipy.cluster.vq`\n",
            "    \n",
            "    Clustering algorithms are useful in information theory, target detection,\n",
            "    communications, compression, and other areas.  The `vq` module only\n",
            "    supports vector quantization and the k-means algorithms.\n",
            "    \n",
            "    :mod:`scipy.cluster.hierarchy`\n",
            "    \n",
            "    The `hierarchy` module provides functions for hierarchical and\n",
            "    agglomerative clustering.  Its features include generating hierarchical\n",
            "    clusters from distance matrices,\n",
            "    calculating statistics on clusters, cutting linkages\n",
            "    to generate flat clusters, and visualizing clusters with dendrograms.\n",
            "\n",
            "PACKAGE CONTENTS\n",
            "    _hierarchy\n",
            "    _optimal_leaf_ordering\n",
            "    _vq\n",
            "    hierarchy\n",
            "    setup\n",
            "    tests (package)\n",
            "    vq\n",
            "\n",
            "DATA\n",
            "    __all__ = ['vq', 'hierarchy']\n",
            "\n",
            "FILE\n",
            "    /usr/local/lib/python3.6/dist-packages/scipy/cluster/__init__.py\n",
            "\n",
            "\n",
            "help> quit\n",
            "\n",
            "You are now leaving help and returning to the Python interpreter.\n",
            "If you want to ask for help on a particular object directly from the\n",
            "interpreter, you can type \"help(object)\".  Executing \"help('string')\"\n",
            "has the same effect as typing a particular string at the help> prompt.\n"
          ],
          "name": "stdout"
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "7_P2Uv6O_CfO",
        "outputId": "1af9aff2-c3cf-4428-d3b8-21ff61d37c66",
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 51
        }
      },
      "source": [
        "#info\n",
        "import scipy\n",
        "scipy.info(cluster)"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "/usr/local/lib/python3.6/dist-packages/ipykernel_launcher.py:3: DeprecationWarning: scipy.info is deprecated and will be removed in SciPy 2.0.0, use numpy.info instead\n",
            "  This is separate from the ipykernel package so we can avoid doing imports until\n"
          ],
          "name": "stderr"
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "MVa3Mk2v_wbl",
        "outputId": "15360154-edaa-46bd-d5c8-5ea6358b7a49",
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 51
        }
      },
      "source": [
        "#source\n",
        "scipy.source(cluster)"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "/usr/local/lib/python3.6/dist-packages/ipykernel_launcher.py:2: DeprecationWarning: scipy.source is deprecated and will be removed in SciPy 2.0.0, use numpy.source instead\n",
            "  \n"
          ],
          "name": "stderr"
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "2eZsiEmZAOmw",
        "outputId": "1cda94d5-3c2e-47e8-8e79-c834faf9c5d8",
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 34
        }
      },
      "source": [
        "#special functions\n",
        "from scipy  import special\n",
        "a=special.exp10(2)\n",
        "print(a)"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "100.0\n"
          ],
          "name": "stdout"
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "GgVzaa3AA3Pq",
        "outputId": "396db172-4980-4ff2-a3a4-3e74665fc7ba",
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 34
        }
      },
      "source": [
        "b=special.exp2(3)\n",
        "print(b)"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "8.0\n"
          ],
          "name": "stdout"
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "SG2XRmKNBB1y",
        "outputId": "2b9321f1-0103-456c-c024-803768441fb1",
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 34
        }
      },
      "source": [
        "c=special.sindg(90)\n",
        "print(c)"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "1.0\n"
          ],
          "name": "stdout"
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "JmBes5o_BdeK",
        "outputId": "36b0e30b-f480-4113-c171-513a8dc8f052",
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 34
        }
      },
      "source": [
        "d=special.cosdg(90)\n",
        "print(d)"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "-0.0\n"
          ],
          "name": "stdout"
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "peqPiTJ3BkCi",
        "outputId": "1e870ccc-ad7b-46bd-e12a-77ff0ce57f30",
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 1000
        }
      },
      "source": [
        "#integration function\n",
        "from scipy import integrate\n",
        "help(integrate)\n",
        "\n",
        "\n"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "Help on package scipy.integrate in scipy:\n",
            "\n",
            "NAME\n",
            "    scipy.integrate\n",
            "\n",
            "DESCRIPTION\n",
            "    =============================================\n",
            "    Integration and ODEs (:mod:`scipy.integrate`)\n",
            "    =============================================\n",
            "    \n",
            "    .. currentmodule:: scipy.integrate\n",
            "    \n",
            "    Integrating functions, given function object\n",
            "    ============================================\n",
            "    \n",
            "    .. autosummary::\n",
            "       :toctree: generated/\n",
            "    \n",
            "       quad          -- General purpose integration\n",
            "       quad_vec      -- General purpose integration of vector-valued functions\n",
            "       dblquad       -- General purpose double integration\n",
            "       tplquad       -- General purpose triple integration\n",
            "       nquad         -- General purpose n-dimensional integration\n",
            "       fixed_quad    -- Integrate func(x) using Gaussian quadrature of order n\n",
            "       quadrature    -- Integrate with given tolerance using Gaussian quadrature\n",
            "       romberg       -- Integrate func using Romberg integration\n",
            "       quad_explain  -- Print information for use of quad\n",
            "       newton_cotes  -- Weights and error coefficient for Newton-Cotes integration\n",
            "       IntegrationWarning -- Warning on issues during integration\n",
            "    \n",
            "    Integrating functions, given fixed samples\n",
            "    ==========================================\n",
            "    \n",
            "    .. autosummary::\n",
            "       :toctree: generated/\n",
            "    \n",
            "       trapz         -- Use trapezoidal rule to compute integral.\n",
            "       cumtrapz      -- Use trapezoidal rule to cumulatively compute integral.\n",
            "       simps         -- Use Simpson's rule to compute integral from samples.\n",
            "       romb          -- Use Romberg Integration to compute integral from\n",
            "                     -- (2**k + 1) evenly-spaced samples.\n",
            "    \n",
            "    .. seealso::\n",
            "    \n",
            "       :mod:`scipy.special` for orthogonal polynomials (special) for Gaussian\n",
            "       quadrature roots and weights for other weighting factors and regions.\n",
            "    \n",
            "    Solving initial value problems for ODE systems\n",
            "    ==============================================\n",
            "    \n",
            "    The solvers are implemented as individual classes which can be used directly\n",
            "    (low-level usage) or through a convenience function.\n",
            "    \n",
            "    .. autosummary::\n",
            "       :toctree: generated/\n",
            "    \n",
            "       solve_ivp     -- Convenient function for ODE integration.\n",
            "       RK23          -- Explicit Runge-Kutta solver of order 3(2).\n",
            "       RK45          -- Explicit Runge-Kutta solver of order 5(4).\n",
            "       DOP853        -- Explicit Runge-Kutta solver of order 8.\n",
            "       Radau         -- Implicit Runge-Kutta solver of order 5.\n",
            "       BDF           -- Implicit multi-step variable order (1 to 5) solver.\n",
            "       LSODA         -- LSODA solver from ODEPACK Fortran package.\n",
            "       OdeSolver     -- Base class for ODE solvers.\n",
            "       DenseOutput   -- Local interpolant for computing a dense output.\n",
            "       OdeSolution   -- Class which represents a continuous ODE solution.\n",
            "    \n",
            "    \n",
            "    Old API\n",
            "    -------\n",
            "    \n",
            "    These are the routines developed earlier for scipy. They wrap older solvers\n",
            "    implemented in Fortran (mostly ODEPACK). While the interface to them is not\n",
            "    particularly convenient and certain features are missing compared to the new\n",
            "    API, the solvers themselves are of good quality and work fast as compiled\n",
            "    Fortran code. In some cases it might be worth using this old API.\n",
            "    \n",
            "    .. autosummary::\n",
            "       :toctree: generated/\n",
            "    \n",
            "       odeint        -- General integration of ordinary differential equations.\n",
            "       ode           -- Integrate ODE using VODE and ZVODE routines.\n",
            "       complex_ode   -- Convert a complex-valued ODE to real-valued and integrate.\n",
            "    \n",
            "    \n",
            "    Solving boundary value problems for ODE systems\n",
            "    ===============================================\n",
            "    \n",
            "    .. autosummary::\n",
            "       :toctree: generated/\n",
            "    \n",
            "       solve_bvp     -- Solve a boundary value problem for a system of ODEs.\n",
            "\n",
            "PACKAGE CONTENTS\n",
            "    _bvp\n",
            "    _dop\n",
            "    _ivp (package)\n",
            "    _ode\n",
            "    _odepack\n",
            "    _quad_vec\n",
            "    _quadpack\n",
            "    _test_multivariate\n",
            "    _test_odeint_banded\n",
            "    lsoda\n",
            "    odepack\n",
            "    quadpack\n",
            "    quadrature\n",
            "    setup\n",
            "    tests (package)\n",
            "    vode\n",
            "\n",
            "CLASSES\n",
            "    builtins.UserWarning(builtins.Warning)\n",
            "        scipy.integrate.quadpack.IntegrationWarning\n",
            "    builtins.object\n",
            "        scipy.integrate._ivp.base.DenseOutput\n",
            "        scipy.integrate._ivp.base.OdeSolver\n",
            "            scipy.integrate._ivp.bdf.BDF\n",
            "            scipy.integrate._ivp.lsoda.LSODA\n",
            "            scipy.integrate._ivp.radau.Radau\n",
            "        scipy.integrate._ivp.common.OdeSolution\n",
            "        scipy.integrate._ode.ode\n",
            "            scipy.integrate._ode.complex_ode\n",
            "    scipy.integrate._ivp.rk.RungeKutta(scipy.integrate._ivp.base.OdeSolver)\n",
            "        scipy.integrate._ivp.rk.DOP853\n",
            "        scipy.integrate._ivp.rk.RK23\n",
            "        scipy.integrate._ivp.rk.RK45\n",
            "    \n",
            "    class BDF(scipy.integrate._ivp.base.OdeSolver)\n",
            "     |  Implicit method based on backward-differentiation formulas.\n",
            "     |  \n",
            "     |  This is a variable order method with the order varying automatically from\n",
            "     |  1 to 5. The general framework of the BDF algorithm is described in [1]_.\n",
            "     |  This class implements a quasi-constant step size as explained in [2]_.\n",
            "     |  The error estimation strategy for the constant-step BDF is derived in [3]_.\n",
            "     |  An accuracy enhancement using modified formulas (NDF) [2]_ is also implemented.\n",
            "     |  \n",
            "     |  Can be applied in the complex domain.\n",
            "     |  \n",
            "     |  Parameters\n",
            "     |  ----------\n",
            "     |  fun : callable\n",
            "     |      Right-hand side of the system. The calling signature is ``fun(t, y)``.\n",
            "     |      Here ``t`` is a scalar, and there are two options for the ndarray ``y``:\n",
            "     |      It can either have shape (n,); then ``fun`` must return array_like with\n",
            "     |      shape (n,). Alternatively it can have shape (n, k); then ``fun``\n",
            "     |      must return an array_like with shape (n, k), i.e. each column\n",
            "     |      corresponds to a single column in ``y``. The choice between the two\n",
            "     |      options is determined by `vectorized` argument (see below). The\n",
            "     |      vectorized implementation allows a faster approximation of the Jacobian\n",
            "     |      by finite differences (required for this solver).\n",
            "     |  t0 : float\n",
            "     |      Initial time.\n",
            "     |  y0 : array_like, shape (n,)\n",
            "     |      Initial state.\n",
            "     |  t_bound : float\n",
            "     |      Boundary time - the integration won't continue beyond it. It also\n",
            "     |      determines the direction of the integration.\n",
            "     |  first_step : float or None, optional\n",
            "     |      Initial step size. Default is ``None`` which means that the algorithm\n",
            "     |      should choose.\n",
            "     |  max_step : float, optional\n",
            "     |      Maximum allowed step size. Default is np.inf, i.e. the step size is not\n",
            "     |      bounded and determined solely by the solver.\n",
            "     |  rtol, atol : float and array_like, optional\n",
            "     |      Relative and absolute tolerances. The solver keeps the local error\n",
            "     |      estimates less than ``atol + rtol * abs(y)``. Here `rtol` controls a\n",
            "     |      relative accuracy (number of correct digits). But if a component of `y`\n",
            "     |      is approximately below `atol`, the error only needs to fall within\n",
            "     |      the same `atol` threshold, and the number of correct digits is not\n",
            "     |      guaranteed. If components of y have different scales, it might be\n",
            "     |      beneficial to set different `atol` values for different components by\n",
            "     |      passing array_like with shape (n,) for `atol`. Default values are\n",
            "     |      1e-3 for `rtol` and 1e-6 for `atol`.\n",
            "     |  jac : {None, array_like, sparse_matrix, callable}, optional\n",
            "     |      Jacobian matrix of the right-hand side of the system with respect to y,\n",
            "     |      required by this method. The Jacobian matrix has shape (n, n) and its\n",
            "     |      element (i, j) is equal to ``d f_i / d y_j``.\n",
            "     |      There are three ways to define the Jacobian:\n",
            "     |  \n",
            "     |          * If array_like or sparse_matrix, the Jacobian is assumed to\n",
            "     |            be constant.\n",
            "     |          * If callable, the Jacobian is assumed to depend on both\n",
            "     |            t and y; it will be called as ``jac(t, y)`` as necessary.\n",
            "     |            For the 'Radau' and 'BDF' methods, the return value might be a\n",
            "     |            sparse matrix.\n",
            "     |          * If None (default), the Jacobian will be approximated by\n",
            "     |            finite differences.\n",
            "     |  \n",
            "     |      It is generally recommended to provide the Jacobian rather than\n",
            "     |      relying on a finite-difference approximation.\n",
            "     |  jac_sparsity : {None, array_like, sparse matrix}, optional\n",
            "     |      Defines a sparsity structure of the Jacobian matrix for a\n",
            "     |      finite-difference approximation. Its shape must be (n, n). This argument\n",
            "     |      is ignored if `jac` is not `None`. If the Jacobian has only few non-zero\n",
            "     |      elements in *each* row, providing the sparsity structure will greatly\n",
            "     |      speed up the computations [4]_. A zero entry means that a corresponding\n",
            "     |      element in the Jacobian is always zero. If None (default), the Jacobian\n",
            "     |      is assumed to be dense.\n",
            "     |  vectorized : bool, optional\n",
            "     |      Whether `fun` is implemented in a vectorized fashion. Default is False.\n",
            "     |  \n",
            "     |  Attributes\n",
            "     |  ----------\n",
            "     |  n : int\n",
            "     |      Number of equations.\n",
            "     |  status : string\n",
            "     |      Current status of the solver: 'running', 'finished' or 'failed'.\n",
            "     |  t_bound : float\n",
            "     |      Boundary time.\n",
            "     |  direction : float\n",
            "     |      Integration direction: +1 or -1.\n",
            "     |  t : float\n",
            "     |      Current time.\n",
            "     |  y : ndarray\n",
            "     |      Current state.\n",
            "     |  t_old : float\n",
            "     |      Previous time. None if no steps were made yet.\n",
            "     |  step_size : float\n",
            "     |      Size of the last successful step. None if no steps were made yet.\n",
            "     |  nfev : int\n",
            "     |      Number of evaluations of the right-hand side.\n",
            "     |  njev : int\n",
            "     |      Number of evaluations of the Jacobian.\n",
            "     |  nlu : int\n",
            "     |      Number of LU decompositions.\n",
            "     |  \n",
            "     |  References\n",
            "     |  ----------\n",
            "     |  .. [1] G. D. Byrne, A. C. Hindmarsh, \"A Polyalgorithm for the Numerical\n",
            "     |         Solution of Ordinary Differential Equations\", ACM Transactions on\n",
            "     |         Mathematical Software, Vol. 1, No. 1, pp. 71-96, March 1975.\n",
            "     |  .. [2] L. F. Shampine, M. W. Reichelt, \"THE MATLAB ODE SUITE\", SIAM J. SCI.\n",
            "     |         COMPUTE., Vol. 18, No. 1, pp. 1-22, January 1997.\n",
            "     |  .. [3] E. Hairer, G. Wanner, \"Solving Ordinary Differential Equations I:\n",
            "     |         Nonstiff Problems\", Sec. III.2.\n",
            "     |  .. [4] A. Curtis, M. J. D. Powell, and J. Reid, \"On the estimation of\n",
            "     |         sparse Jacobian matrices\", Journal of the Institute of Mathematics\n",
            "     |         and its Applications, 13, pp. 117-120, 1974.\n",
            "     |  \n",
            "     |  Method resolution order:\n",
            "     |      BDF\n",
            "     |      scipy.integrate._ivp.base.OdeSolver\n",
            "     |      builtins.object\n",
            "     |  \n",
            "     |  Methods defined here:\n",
            "     |  \n",
            "     |  __init__(self, fun, t0, y0, t_bound, max_step=inf, rtol=0.001, atol=1e-06, jac=None, jac_sparsity=None, vectorized=False, first_step=None, **extraneous)\n",
            "     |      Initialize self.  See help(type(self)) for accurate signature.\n",
            "     |  \n",
            "     |  ----------------------------------------------------------------------\n",
            "     |  Methods inherited from scipy.integrate._ivp.base.OdeSolver:\n",
            "     |  \n",
            "     |  dense_output(self)\n",
            "     |      Compute a local interpolant over the last successful step.\n",
            "     |      \n",
            "     |      Returns\n",
            "     |      -------\n",
            "     |      sol : `DenseOutput`\n",
            "     |          Local interpolant over the last successful step.\n",
            "     |  \n",
            "     |  step(self)\n",
            "     |      Perform one integration step.\n",
            "     |      \n",
            "     |      Returns\n",
            "     |      -------\n",
            "     |      message : string or None\n",
            "     |          Report from the solver. Typically a reason for a failure if\n",
            "     |          `self.status` is 'failed' after the step was taken or None\n",
            "     |          otherwise.\n",
            "     |  \n",
            "     |  ----------------------------------------------------------------------\n",
            "     |  Data descriptors inherited from scipy.integrate._ivp.base.OdeSolver:\n",
            "     |  \n",
            "     |  __dict__\n",
            "     |      dictionary for instance variables (if defined)\n",
            "     |  \n",
            "     |  __weakref__\n",
            "     |      list of weak references to the object (if defined)\n",
            "     |  \n",
            "     |  step_size\n",
            "     |  \n",
            "     |  ----------------------------------------------------------------------\n",
            "     |  Data and other attributes inherited from scipy.integrate._ivp.base.OdeSolver:\n",
            "     |  \n",
            "     |  TOO_SMALL_STEP = 'Required step size is less than spacing between numb...\n",
            "    \n",
            "    class DOP853(RungeKutta)\n",
            "     |  Explicit Runge-Kutta method of order 8.\n",
            "     |  \n",
            "     |  This is a Python implementation of \"DOP853\" algorithm originally written\n",
            "     |  in Fortran [1]_, [2]_. Note that this is not a literate translation, but\n",
            "     |  the algorithmic core and coefficients are the same.\n",
            "     |  \n",
            "     |  Can be applied in the complex domain.\n",
            "     |  \n",
            "     |  Parameters\n",
            "     |  ----------\n",
            "     |  fun : callable\n",
            "     |      Right-hand side of the system. The calling signature is ``fun(t, y)``.\n",
            "     |      Here ``t`` is a scalar, and there are two options for the ndarray ``y``:\n",
            "     |      It can either have shape (n,); then ``fun`` must return array_like with\n",
            "     |      shape (n,). Alternatively it can have shape (n, k); then ``fun``\n",
            "     |      must return an array_like with shape (n, k), i.e. each column\n",
            "     |      corresponds to a single column in ``y``. The choice between the two\n",
            "     |      options is determined by `vectorized` argument (see below).\n",
            "     |  t0 : float\n",
            "     |      Initial time.\n",
            "     |  y0 : array_like, shape (n,)\n",
            "     |      Initial state.\n",
            "     |  t_bound : float\n",
            "     |      Boundary time - the integration won't continue beyond it. It also\n",
            "     |      determines the direction of the integration.\n",
            "     |  first_step : float or None, optional\n",
            "     |      Initial step size. Default is ``None`` which means that the algorithm\n",
            "     |      should choose.\n",
            "     |  max_step : float, optional\n",
            "     |      Maximum allowed step size. Default is np.inf, i.e. the step size is not\n",
            "     |      bounded and determined solely by the solver.\n",
            "     |  rtol, atol : float and array_like, optional\n",
            "     |      Relative and absolute tolerances. The solver keeps the local error\n",
            "     |      estimates less than ``atol + rtol * abs(y)``. Here `rtol` controls a\n",
            "     |      relative accuracy (number of correct digits). But if a component of `y`\n",
            "     |      is approximately below `atol`, the error only needs to fall within\n",
            "     |      the same `atol` threshold, and the number of correct digits is not\n",
            "     |      guaranteed. If components of y have different scales, it might be\n",
            "     |      beneficial to set different `atol` values for different components by\n",
            "     |      passing array_like with shape (n,) for `atol`. Default values are\n",
            "     |      1e-3 for `rtol` and 1e-6 for `atol`.\n",
            "     |  vectorized : bool, optional\n",
            "     |      Whether `fun` is implemented in a vectorized fashion. Default is False.\n",
            "     |  \n",
            "     |  Attributes\n",
            "     |  ----------\n",
            "     |  n : int\n",
            "     |      Number of equations.\n",
            "     |  status : string\n",
            "     |      Current status of the solver: 'running', 'finished' or 'failed'.\n",
            "     |  t_bound : float\n",
            "     |      Boundary time.\n",
            "     |  direction : float\n",
            "     |      Integration direction: +1 or -1.\n",
            "     |  t : float\n",
            "     |      Current time.\n",
            "     |  y : ndarray\n",
            "     |      Current state.\n",
            "     |  t_old : float\n",
            "     |      Previous time. None if no steps were made yet.\n",
            "     |  step_size : float\n",
            "     |      Size of the last successful step. None if no steps were made yet.\n",
            "     |  nfev : int\n",
            "     |      Number evaluations of the system's right-hand side.\n",
            "     |  njev : int\n",
            "     |      Number of evaluations of the Jacobian. Is always 0 for this solver\n",
            "     |      as it does not use the Jacobian.\n",
            "     |  nlu : int\n",
            "     |      Number of LU decompositions. Is always 0 for this solver.\n",
            "     |  \n",
            "     |  References\n",
            "     |  ----------\n",
            "     |  .. [1] E. Hairer, S. P. Norsett G. Wanner, \"Solving Ordinary Differential\n",
            "     |         Equations I: Nonstiff Problems\", Sec. II.\n",
            "     |  .. [2] `Page with original Fortran code of DOP853\n",
            "     |          <http://www.unige.ch/~hairer/software.html>`_.\n",
            "     |  \n",
            "     |  Method resolution order:\n",
            "     |      DOP853\n",
            "     |      RungeKutta\n",
            "     |      scipy.integrate._ivp.base.OdeSolver\n",
            "     |      builtins.object\n",
            "     |  \n",
            "     |  Methods defined here:\n",
            "     |  \n",
            "     |  __init__(self, fun, t0, y0, t_bound, max_step=inf, rtol=0.001, atol=1e-06, vectorized=False, first_step=None, **extraneous)\n",
            "     |      Initialize self.  See help(type(self)) for accurate signature.\n",
            "     |  \n",
            "     |  ----------------------------------------------------------------------\n",
            "     |  Data and other attributes defined here:\n",
            "     |  \n",
            "     |  A = array([[ 0.00000000e+00,  0.00000000e+00,  0.000...23605672e+01,  ...\n",
            "     |  \n",
            "     |  A_EXTRA = array([[ 5.61675023e-02,  0.00000000e+00,  0.000...e+00, -9....\n",
            "     |  \n",
            "     |  B = array([ 0.05429373,  0.        ,  0.        ,  0...7, -0.15216095,...\n",
            "     |  \n",
            "     |  C = array([0.        , 0.05260015, 0.07890023, 0.118...8205, 0.6      ...\n",
            "     |  \n",
            "     |  C_EXTRA = array([0.1       , 0.2       , 0.77777778])\n",
            "     |  \n",
            "     |  D = array([[-8.42893828e+00,  0.00000000e+00,  0.000...e+01, -3.917726...\n",
            "     |  \n",
            "     |  E3 = array([-0.18980075,  0.        ,  0.        ,  0...5,\n",
            "     |          0.2...\n",
            "     |  \n",
            "     |  E5 = array([ 0.01312004,  0.        ,  0.        ,  0...2,\n",
            "     |          0.0...\n",
            "     |  \n",
            "     |  error_estimator_order = 7\n",
            "     |  \n",
            "     |  n_stages = 12\n",
            "     |  \n",
            "     |  order = 8\n",
            "     |  \n",
            "     |  ----------------------------------------------------------------------\n",
            "     |  Data and other attributes inherited from RungeKutta:\n",
            "     |  \n",
            "     |  E = NotImplemented\n",
            "     |  \n",
            "     |  P = NotImplemented\n",
            "     |  \n",
            "     |  ----------------------------------------------------------------------\n",
            "     |  Methods inherited from scipy.integrate._ivp.base.OdeSolver:\n",
            "     |  \n",
            "     |  dense_output(self)\n",
            "     |      Compute a local interpolant over the last successful step.\n",
            "     |      \n",
            "     |      Returns\n",
            "     |      -------\n",
            "     |      sol : `DenseOutput`\n",
            "     |          Local interpolant over the last successful step.\n",
            "     |  \n",
            "     |  step(self)\n",
            "     |      Perform one integration step.\n",
            "     |      \n",
            "     |      Returns\n",
            "     |      -------\n",
            "     |      message : string or None\n",
            "     |          Report from the solver. Typically a reason for a failure if\n",
            "     |          `self.status` is 'failed' after the step was taken or None\n",
            "     |          otherwise.\n",
            "     |  \n",
            "     |  ----------------------------------------------------------------------\n",
            "     |  Data descriptors inherited from scipy.integrate._ivp.base.OdeSolver:\n",
            "     |  \n",
            "     |  __dict__\n",
            "     |      dictionary for instance variables (if defined)\n",
            "     |  \n",
            "     |  __weakref__\n",
            "     |      list of weak references to the object (if defined)\n",
            "     |  \n",
            "     |  step_size\n",
            "     |  \n",
            "     |  ----------------------------------------------------------------------\n",
            "     |  Data and other attributes inherited from scipy.integrate._ivp.base.OdeSolver:\n",
            "     |  \n",
            "     |  TOO_SMALL_STEP = 'Required step size is less than spacing between numb...\n",
            "    \n",
            "    class DenseOutput(builtins.object)\n",
            "     |  Base class for local interpolant over step made by an ODE solver.\n",
            "     |  \n",
            "     |  It interpolates between `t_min` and `t_max` (see Attributes below).\n",
            "     |  Evaluation outside this interval is not forbidden, but the accuracy is not\n",
            "     |  guaranteed.\n",
            "     |  \n",
            "     |  Attributes\n",
            "     |  ----------\n",
            "     |  t_min, t_max : float\n",
            "     |      Time range of the interpolation.\n",
            "     |  \n",
            "     |  Methods defined here:\n",
            "     |  \n",
            "     |  __call__(self, t)\n",
            "     |      Evaluate the interpolant.\n",
            "     |      \n",
            "     |      Parameters\n",
            "     |      ----------\n",
            "     |      t : float or array_like with shape (n_points,)\n",
            "     |          Points to evaluate the solution at.\n",
            "     |      \n",
            "     |      Returns\n",
            "     |      -------\n",
            "     |      y : ndarray, shape (n,) or (n, n_points)\n",
            "     |          Computed values. Shape depends on whether `t` was a scalar or a\n",
            "     |          1-d array.\n",
            "     |  \n",
            "     |  __init__(self, t_old, t)\n",
            "     |      Initialize self.  See help(type(self)) for accurate signature.\n",
            "     |  \n",
            "     |  ----------------------------------------------------------------------\n",
            "     |  Data descriptors defined here:\n",
            "     |  \n",
            "     |  __dict__\n",
            "     |      dictionary for instance variables (if defined)\n",
            "     |  \n",
            "     |  __weakref__\n",
            "     |      list of weak references to the object (if defined)\n",
            "    \n",
            "    class IntegrationWarning(builtins.UserWarning)\n",
            "     |  Warning on issues during integration.\n",
            "     |  \n",
            "     |  Method resolution order:\n",
            "     |      IntegrationWarning\n",
            "     |      builtins.UserWarning\n",
            "     |      builtins.Warning\n",
            "     |      builtins.Exception\n",
            "     |      builtins.BaseException\n",
            "     |      builtins.object\n",
            "     |  \n",
            "     |  Data descriptors defined here:\n",
            "     |  \n",
            "     |  __weakref__\n",
            "     |      list of weak references to the object (if defined)\n",
            "     |  \n",
            "     |  ----------------------------------------------------------------------\n",
            "     |  Methods inherited from builtins.UserWarning:\n",
            "     |  \n",
            "     |  __init__(self, /, *args, **kwargs)\n",
            "     |      Initialize self.  See help(type(self)) for accurate signature.\n",
            "     |  \n",
            "     |  __new__(*args, **kwargs) from builtins.type\n",
            "     |      Create and return a new object.  See help(type) for accurate signature.\n",
            "     |  \n",
            "     |  ----------------------------------------------------------------------\n",
            "     |  Methods inherited from builtins.BaseException:\n",
            "     |  \n",
            "     |  __delattr__(self, name, /)\n",
            "     |      Implement delattr(self, name).\n",
            "     |  \n",
            "     |  __getattribute__(self, name, /)\n",
            "     |      Return getattr(self, name).\n",
            "     |  \n",
            "     |  __reduce__(...)\n",
            "     |      helper for pickle\n",
            "     |  \n",
            "     |  __repr__(self, /)\n",
            "     |      Return repr(self).\n",
            "     |  \n",
            "     |  __setattr__(self, name, value, /)\n",
            "     |      Implement setattr(self, name, value).\n",
            "     |  \n",
            "     |  __setstate__(...)\n",
            "     |  \n",
            "     |  __str__(self, /)\n",
            "     |      Return str(self).\n",
            "     |  \n",
            "     |  with_traceback(...)\n",
            "     |      Exception.with_traceback(tb) --\n",
            "     |      set self.__traceback__ to tb and return self.\n",
            "     |  \n",
            "     |  ----------------------------------------------------------------------\n",
            "     |  Data descriptors inherited from builtins.BaseException:\n",
            "     |  \n",
            "     |  __cause__\n",
            "     |      exception cause\n",
            "     |  \n",
            "     |  __context__\n",
            "     |      exception context\n",
            "     |  \n",
            "     |  __dict__\n",
            "     |  \n",
            "     |  __suppress_context__\n",
            "     |  \n",
            "     |  __traceback__\n",
            "     |  \n",
            "     |  args\n",
            "    \n",
            "    class LSODA(scipy.integrate._ivp.base.OdeSolver)\n",
            "     |  Adams/BDF method with automatic stiffness detection and switching.\n",
            "     |  \n",
            "     |  This is a wrapper to the Fortran solver from ODEPACK [1]_. It switches\n",
            "     |  automatically between the nonstiff Adams method and the stiff BDF method.\n",
            "     |  The method was originally detailed in [2]_.\n",
            "     |  \n",
            "     |  Parameters\n",
            "     |  ----------\n",
            "     |  fun : callable\n",
            "     |      Right-hand side of the system. The calling signature is ``fun(t, y)``.\n",
            "     |      Here ``t`` is a scalar, and there are two options for the ndarray ``y``:\n",
            "     |      It can either have shape (n,); then ``fun`` must return array_like with\n",
            "     |      shape (n,). Alternatively it can have shape (n, k); then ``fun``\n",
            "     |      must return an array_like with shape (n, k), i.e. each column\n",
            "     |      corresponds to a single column in ``y``. The choice between the two\n",
            "     |      options is determined by `vectorized` argument (see below). The\n",
            "     |      vectorized implementation allows a faster approximation of the Jacobian\n",
            "     |      by finite differences (required for this solver).\n",
            "     |  t0 : float\n",
            "     |      Initial time.\n",
            "     |  y0 : array_like, shape (n,)\n",
            "     |      Initial state.\n",
            "     |  t_bound : float\n",
            "     |      Boundary time - the integration won't continue beyond it. It also\n",
            "     |      determines the direction of the integration.\n",
            "     |  first_step : float or None, optional\n",
            "     |      Initial step size. Default is ``None`` which means that the algorithm\n",
            "     |      should choose.\n",
            "     |  min_step : float, optional\n",
            "     |      Minimum allowed step size. Default is 0.0, i.e. the step size is not\n",
            "     |      bounded and determined solely by the solver.\n",
            "     |  max_step : float, optional\n",
            "     |      Maximum allowed step size. Default is np.inf, i.e. the step size is not\n",
            "     |      bounded and determined solely by the solver.\n",
            "     |  rtol, atol : float and array_like, optional\n",
            "     |      Relative and absolute tolerances. The solver keeps the local error\n",
            "     |      estimates less than ``atol + rtol * abs(y)``. Here `rtol` controls a\n",
            "     |      relative accuracy (number of correct digits). But if a component of `y`\n",
            "     |      is approximately below `atol`, the error only needs to fall within\n",
            "     |      the same `atol` threshold, and the number of correct digits is not\n",
            "     |      guaranteed. If components of y have different scales, it might be\n",
            "     |      beneficial to set different `atol` values for different components by\n",
            "     |      passing array_like with shape (n,) for `atol`. Default values are\n",
            "     |      1e-3 for `rtol` and 1e-6 for `atol`.\n",
            "     |  jac : None or callable, optional\n",
            "     |      Jacobian matrix of the right-hand side of the system with respect to\n",
            "     |      ``y``. The Jacobian matrix has shape (n, n) and its element (i, j) is\n",
            "     |      equal to ``d f_i / d y_j``. The function will be called as\n",
            "     |      ``jac(t, y)``. If None (default), the Jacobian will be\n",
            "     |      approximated by finite differences. It is generally recommended to\n",
            "     |      provide the Jacobian rather than relying on a finite-difference\n",
            "     |      approximation.\n",
            "     |  lband, uband : int or None\n",
            "     |      Parameters defining the bandwidth of the Jacobian,\n",
            "     |      i.e., ``jac[i, j] != 0 only for i - lband <= j <= i + uband``. Setting\n",
            "     |      these requires your jac routine to return the Jacobian in the packed format:\n",
            "     |      the returned array must have ``n`` columns and ``uband + lband + 1``\n",
            "     |      rows in which Jacobian diagonals are written. Specifically\n",
            "     |      ``jac_packed[uband + i - j , j] = jac[i, j]``. The same format is used\n",
            "     |      in `scipy.linalg.solve_banded` (check for an illustration).\n",
            "     |      These parameters can be also used with ``jac=None`` to reduce the\n",
            "     |      number of Jacobian elements estimated by finite differences.\n",
            "     |  vectorized : bool, optional\n",
            "     |      Whether `fun` is implemented in a vectorized fashion. A vectorized\n",
            "     |      implementation offers no advantages for this solver. Default is False.\n",
            "     |  \n",
            "     |  Attributes\n",
            "     |  ----------\n",
            "     |  n : int\n",
            "     |      Number of equations.\n",
            "     |  status : string\n",
            "     |      Current status of the solver: 'running', 'finished' or 'failed'.\n",
            "     |  t_bound : float\n",
            "     |      Boundary time.\n",
            "     |  direction : float\n",
            "     |      Integration direction: +1 or -1.\n",
            "     |  t : float\n",
            "     |      Current time.\n",
            "     |  y : ndarray\n",
            "     |      Current state.\n",
            "     |  t_old : float\n",
            "     |      Previous time. None if no steps were made yet.\n",
            "     |  nfev : int\n",
            "     |      Number of evaluations of the right-hand side.\n",
            "     |  njev : int\n",
            "     |      Number of evaluations of the Jacobian.\n",
            "     |  \n",
            "     |  References\n",
            "     |  ----------\n",
            "     |  .. [1] A. C. Hindmarsh, \"ODEPACK, A Systematized Collection of ODE\n",
            "     |         Solvers,\" IMACS Transactions on Scientific Computation, Vol 1.,\n",
            "     |         pp. 55-64, 1983.\n",
            "     |  .. [2] L. Petzold, \"Automatic selection of methods for solving stiff and\n",
            "     |         nonstiff systems of ordinary differential equations\", SIAM Journal\n",
            "     |         on Scientific and Statistical Computing, Vol. 4, No. 1, pp. 136-148,\n",
            "     |         1983.\n",
            "     |  \n",
            "     |  Method resolution order:\n",
            "     |      LSODA\n",
            "     |      scipy.integrate._ivp.base.OdeSolver\n",
            "     |      builtins.object\n",
            "     |  \n",
            "     |  Methods defined here:\n",
            "     |  \n",
            "     |  __init__(self, fun, t0, y0, t_bound, first_step=None, min_step=0.0, max_step=inf, rtol=0.001, atol=1e-06, jac=None, lband=None, uband=None, vectorized=False, **extraneous)\n",
            "     |      Initialize self.  See help(type(self)) for accurate signature.\n",
            "     |  \n",
            "     |  ----------------------------------------------------------------------\n",
            "     |  Methods inherited from scipy.integrate._ivp.base.OdeSolver:\n",
            "     |  \n",
            "     |  dense_output(self)\n",
            "     |      Compute a local interpolant over the last successful step.\n",
            "     |      \n",
            "     |      Returns\n",
            "     |      -------\n",
            "     |      sol : `DenseOutput`\n",
            "     |          Local interpolant over the last successful step.\n",
            "     |  \n",
            "     |  step(self)\n",
            "     |      Perform one integration step.\n",
            "     |      \n",
            "     |      Returns\n",
            "     |      -------\n",
            "     |      message : string or None\n",
            "     |          Report from the solver. Typically a reason for a failure if\n",
            "     |          `self.status` is 'failed' after the step was taken or None\n",
            "     |          otherwise.\n",
            "     |  \n",
            "     |  ----------------------------------------------------------------------\n",
            "     |  Data descriptors inherited from scipy.integrate._ivp.base.OdeSolver:\n",
            "     |  \n",
            "     |  __dict__\n",
            "     |      dictionary for instance variables (if defined)\n",
            "     |  \n",
            "     |  __weakref__\n",
            "     |      list of weak references to the object (if defined)\n",
            "     |  \n",
            "     |  step_size\n",
            "     |  \n",
            "     |  ----------------------------------------------------------------------\n",
            "     |  Data and other attributes inherited from scipy.integrate._ivp.base.OdeSolver:\n",
            "     |  \n",
            "     |  TOO_SMALL_STEP = 'Required step size is less than spacing between numb...\n",
            "    \n",
            "    class OdeSolution(builtins.object)\n",
            "     |  Continuous ODE solution.\n",
            "     |  \n",
            "     |  It is organized as a collection of `DenseOutput` objects which represent\n",
            "     |  local interpolants. It provides an algorithm to select a right interpolant\n",
            "     |  for each given point.\n",
            "     |  \n",
            "     |  The interpolants cover the range between `t_min` and `t_max` (see\n",
            "     |  Attributes below). Evaluation outside this interval is not forbidden, but\n",
            "     |  the accuracy is not guaranteed.\n",
            "     |  \n",
            "     |  When evaluating at a breakpoint (one of the values in `ts`) a segment with\n",
            "     |  the lower index is selected.\n",
            "     |  \n",
            "     |  Parameters\n",
            "     |  ----------\n",
            "     |  ts : array_like, shape (n_segments + 1,)\n",
            "     |      Time instants between which local interpolants are defined. Must\n",
            "     |      be strictly increasing or decreasing (zero segment with two points is\n",
            "     |      also allowed).\n",
            "     |  interpolants : list of DenseOutput with n_segments elements\n",
            "     |      Local interpolants. An i-th interpolant is assumed to be defined\n",
            "     |      between ``ts[i]`` and ``ts[i + 1]``.\n",
            "     |  \n",
            "     |  Attributes\n",
            "     |  ----------\n",
            "     |  t_min, t_max : float\n",
            "     |      Time range of the interpolation.\n",
            "     |  \n",
            "     |  Methods defined here:\n",
            "     |  \n",
            "     |  __call__(self, t)\n",
            "     |      Evaluate the solution.\n",
            "     |      \n",
            "     |      Parameters\n",
            "     |      ----------\n",
            "     |      t : float or array_like with shape (n_points,)\n",
            "     |          Points to evaluate at.\n",
            "     |      \n",
            "     |      Returns\n",
            "     |      -------\n",
            "     |      y : ndarray, shape (n_states,) or (n_states, n_points)\n",
            "     |          Computed values. Shape depends on whether `t` is a scalar or a\n",
            "     |          1-d array.\n",
            "     |  \n",
            "     |  __init__(self, ts, interpolants)\n",
            "     |      Initialize self.  See help(type(self)) for accurate signature.\n",
            "     |  \n",
            "     |  ----------------------------------------------------------------------\n",
            "     |  Data descriptors defined here:\n",
            "     |  \n",
            "     |  __dict__\n",
            "     |      dictionary for instance variables (if defined)\n",
            "     |  \n",
            "     |  __weakref__\n",
            "     |      list of weak references to the object (if defined)\n",
            "    \n",
            "    class OdeSolver(builtins.object)\n",
            "     |  Base class for ODE solvers.\n",
            "     |  \n",
            "     |  In order to implement a new solver you need to follow the guidelines:\n",
            "     |  \n",
            "     |      1. A constructor must accept parameters presented in the base class\n",
            "     |         (listed below) along with any other parameters specific to a solver.\n",
            "     |      2. A constructor must accept arbitrary extraneous arguments\n",
            "     |         ``**extraneous``, but warn that these arguments are irrelevant\n",
            "     |         using `common.warn_extraneous` function. Do not pass these\n",
            "     |         arguments to the base class.\n",
            "     |      3. A solver must implement a private method `_step_impl(self)` which\n",
            "     |         propagates a solver one step further. It must return tuple\n",
            "     |         ``(success, message)``, where ``success`` is a boolean indicating\n",
            "     |         whether a step was successful, and ``message`` is a string\n",
            "     |         containing description of a failure if a step failed or None\n",
            "     |         otherwise.\n",
            "     |      4. A solver must implement a private method `_dense_output_impl(self)`\n",
            "     |         which returns a `DenseOutput` object covering the last successful\n",
            "     |         step.\n",
            "     |      5. A solver must have attributes listed below in Attributes section.\n",
            "     |         Note that ``t_old`` and ``step_size`` are updated automatically.\n",
            "     |      6. Use `fun(self, t, y)` method for the system rhs evaluation, this\n",
            "     |         way the number of function evaluations (`nfev`) will be tracked\n",
            "     |         automatically.\n",
            "     |      7. For convenience a base class provides `fun_single(self, t, y)` and\n",
            "     |         `fun_vectorized(self, t, y)` for evaluating the rhs in\n",
            "     |         non-vectorized and vectorized fashions respectively (regardless of\n",
            "     |         how `fun` from the constructor is implemented). These calls don't\n",
            "     |         increment `nfev`.\n",
            "     |      8. If a solver uses a Jacobian matrix and LU decompositions, it should\n",
            "     |         track the number of Jacobian evaluations (`njev`) and the number of\n",
            "     |         LU decompositions (`nlu`).\n",
            "     |      9. By convention the function evaluations used to compute a finite\n",
            "     |         difference approximation of the Jacobian should not be counted in\n",
            "     |         `nfev`, thus use `fun_single(self, t, y)` or\n",
            "     |         `fun_vectorized(self, t, y)` when computing a finite difference\n",
            "     |         approximation of the Jacobian.\n",
            "     |  \n",
            "     |  Parameters\n",
            "     |  ----------\n",
            "     |  fun : callable\n",
            "     |      Right-hand side of the system. The calling signature is ``fun(t, y)``.\n",
            "     |      Here ``t`` is a scalar and there are two options for ndarray ``y``.\n",
            "     |      It can either have shape (n,), then ``fun`` must return array_like with\n",
            "     |      shape (n,). Or alternatively it can have shape (n, n_points), then\n",
            "     |      ``fun`` must return array_like with shape (n, n_points) (each column\n",
            "     |      corresponds to a single column in ``y``). The choice between the two\n",
            "     |      options is determined by `vectorized` argument (see below).\n",
            "     |  t0 : float\n",
            "     |      Initial time.\n",
            "     |  y0 : array_like, shape (n,)\n",
            "     |      Initial state.\n",
            "     |  t_bound : float\n",
            "     |      Boundary time --- the integration won't continue beyond it. It also\n",
            "     |      determines the direction of the integration.\n",
            "     |  vectorized : bool\n",
            "     |      Whether `fun` is implemented in a vectorized fashion.\n",
            "     |  support_complex : bool, optional\n",
            "     |      Whether integration in a complex domain should be supported.\n",
            "     |      Generally determined by a derived solver class capabilities.\n",
            "     |      Default is False.\n",
            "     |  \n",
            "     |  Attributes\n",
            "     |  ----------\n",
            "     |  n : int\n",
            "     |      Number of equations.\n",
            "     |  status : string\n",
            "     |      Current status of the solver: 'running', 'finished' or 'failed'.\n",
            "     |  t_bound : float\n",
            "     |      Boundary time.\n",
            "     |  direction : float\n",
            "     |      Integration direction: +1 or -1.\n",
            "     |  t : float\n",
            "     |      Current time.\n",
            "     |  y : ndarray\n",
            "     |      Current state.\n",
            "     |  t_old : float\n",
            "     |      Previous time. None if no steps were made yet.\n",
            "     |  step_size : float\n",
            "     |      Size of the last successful step. None if no steps were made yet.\n",
            "     |  nfev : int\n",
            "     |      Number of the system's rhs evaluations.\n",
            "     |  njev : int\n",
            "     |      Number of the Jacobian evaluations.\n",
            "     |  nlu : int\n",
            "     |      Number of LU decompositions.\n",
            "     |  \n",
            "     |  Methods defined here:\n",
            "     |  \n",
            "     |  __init__(self, fun, t0, y0, t_bound, vectorized, support_complex=False)\n",
            "     |      Initialize self.  See help(type(self)) for accurate signature.\n",
            "     |  \n",
            "     |  dense_output(self)\n",
            "     |      Compute a local interpolant over the last successful step.\n",
            "     |      \n",
            "     |      Returns\n",
            "     |      -------\n",
            "     |      sol : `DenseOutput`\n",
            "     |          Local interpolant over the last successful step.\n",
            "     |  \n",
            "     |  step(self)\n",
            "     |      Perform one integration step.\n",
            "     |      \n",
            "     |      Returns\n",
            "     |      -------\n",
            "     |      message : string or None\n",
            "     |          Report from the solver. Typically a reason for a failure if\n",
            "     |          `self.status` is 'failed' after the step was taken or None\n",
            "     |          otherwise.\n",
            "     |  \n",
            "     |  ----------------------------------------------------------------------\n",
            "     |  Data descriptors defined here:\n",
            "     |  \n",
            "     |  __dict__\n",
            "     |      dictionary for instance variables (if defined)\n",
            "     |  \n",
            "     |  __weakref__\n",
            "     |      list of weak references to the object (if defined)\n",
            "     |  \n",
            "     |  step_size\n",
            "     |  \n",
            "     |  ----------------------------------------------------------------------\n",
            "     |  Data and other attributes defined here:\n",
            "     |  \n",
            "     |  TOO_SMALL_STEP = 'Required step size is less than spacing between numb...\n",
            "    \n",
            "    class RK23(RungeKutta)\n",
            "     |  Explicit Runge-Kutta method of order 3(2).\n",
            "     |  \n",
            "     |  This uses the Bogacki-Shampine pair of formulas [1]_. The error is controlled\n",
            "     |  assuming accuracy of the second-order method, but steps are taken using the\n",
            "     |  third-order accurate formula (local extrapolation is done). A cubic Hermite\n",
            "     |  polynomial is used for the dense output.\n",
            "     |  \n",
            "     |  Can be applied in the complex domain.\n",
            "     |  \n",
            "     |  Parameters\n",
            "     |  ----------\n",
            "     |  fun : callable\n",
            "     |      Right-hand side of the system. The calling signature is ``fun(t, y)``.\n",
            "     |      Here ``t`` is a scalar and there are two options for ndarray ``y``.\n",
            "     |      It can either have shape (n,), then ``fun`` must return array_like with\n",
            "     |      shape (n,). Or alternatively it can have shape (n, k), then ``fun``\n",
            "     |      must return array_like with shape (n, k), i.e. each column\n",
            "     |      corresponds to a single column in ``y``. The choice between the two\n",
            "     |      options is determined by `vectorized` argument (see below).\n",
            "     |  t0 : float\n",
            "     |      Initial time.\n",
            "     |  y0 : array_like, shape (n,)\n",
            "     |      Initial state.\n",
            "     |  t_bound : float\n",
            "     |      Boundary time - the integration won't continue beyond it. It also\n",
            "     |      determines the direction of the integration.\n",
            "     |  first_step : float or None, optional\n",
            "     |      Initial step size. Default is ``None`` which means that the algorithm\n",
            "     |      should choose.\n",
            "     |  max_step : float, optional\n",
            "     |      Maximum allowed step size. Default is np.inf, i.e. the step size is not\n",
            "     |      bounded and determined solely by the solver.\n",
            "     |  rtol, atol : float and array_like, optional\n",
            "     |      Relative and absolute tolerances. The solver keeps the local error\n",
            "     |      estimates less than ``atol + rtol * abs(y)``. Here `rtol` controls a\n",
            "     |      relative accuracy (number of correct digits). But if a component of `y`\n",
            "     |      is approximately below `atol`, the error only needs to fall within\n",
            "     |      the same `atol` threshold, and the number of correct digits is not\n",
            "     |      guaranteed. If components of y have different scales, it might be\n",
            "     |      beneficial to set different `atol` values for different components by\n",
            "     |      passing array_like with shape (n,) for `atol`. Default values are\n",
            "     |      1e-3 for `rtol` and 1e-6 for `atol`.\n",
            "     |  vectorized : bool, optional\n",
            "     |      Whether `fun` is implemented in a vectorized fashion. Default is False.\n",
            "     |  \n",
            "     |  Attributes\n",
            "     |  ----------\n",
            "     |  n : int\n",
            "     |      Number of equations.\n",
            "     |  status : string\n",
            "     |      Current status of the solver: 'running', 'finished' or 'failed'.\n",
            "     |  t_bound : float\n",
            "     |      Boundary time.\n",
            "     |  direction : float\n",
            "     |      Integration direction: +1 or -1.\n",
            "     |  t : float\n",
            "     |      Current time.\n",
            "     |  y : ndarray\n",
            "     |      Current state.\n",
            "     |  t_old : float\n",
            "     |      Previous time. None if no steps were made yet.\n",
            "     |  step_size : float\n",
            "     |      Size of the last successful step. None if no steps were made yet.\n",
            "     |  nfev : int\n",
            "     |      Number evaluations of the system's right-hand side.\n",
            "     |  njev : int\n",
            "     |      Number of evaluations of the Jacobian. Is always 0 for this solver as it does not use the Jacobian.\n",
            "     |  nlu : int\n",
            "     |      Number of LU decompositions. Is always 0 for this solver.\n",
            "     |  \n",
            "     |  References\n",
            "     |  ----------\n",
            "     |  .. [1] P. Bogacki, L.F. Shampine, \"A 3(2) Pair of Runge-Kutta Formulas\",\n",
            "     |         Appl. Math. Lett. Vol. 2, No. 4. pp. 321-325, 1989.\n",
            "     |  \n",
            "     |  Method resolution order:\n",
            "     |      RK23\n",
            "     |      RungeKutta\n",
            "     |      scipy.integrate._ivp.base.OdeSolver\n",
            "     |      builtins.object\n",
            "     |  \n",
            "     |  Data and other attributes defined here:\n",
            "     |  \n",
            "     |  A = array([[0.  , 0.  , 0.  ],\n",
            "     |         [0.5 , 0.  , 0.  ],\n",
            "     |         [0.  ...\n",
            "     |  \n",
            "     |  B = array([0.22222222, 0.33333333, 0.44444444])\n",
            "     |  \n",
            "     |  C = array([0.  , 0.5 , 0.75])\n",
            "     |  \n",
            "     |  E = array([ 0.06944444, -0.08333333, -0.11111111,  0.125     ])\n",
            "     |  \n",
            "     |  P = array([[ 1.        , -1.33333333,  0.55555556],\n",
            "     |  ...\n",
            "     |         [ 0.   ...\n",
            "     |  \n",
            "     |  error_estimator_order = 2\n",
            "     |  \n",
            "     |  n_stages = 3\n",
            "     |  \n",
            "     |  order = 3\n",
            "     |  \n",
            "     |  ----------------------------------------------------------------------\n",
            "     |  Methods inherited from RungeKutta:\n",
            "     |  \n",
            "     |  __init__(self, fun, t0, y0, t_bound, max_step=inf, rtol=0.001, atol=1e-06, vectorized=False, first_step=None, **extraneous)\n",
            "     |      Initialize self.  See help(type(self)) for accurate signature.\n",
            "     |  \n",
            "     |  ----------------------------------------------------------------------\n",
            "     |  Methods inherited from scipy.integrate._ivp.base.OdeSolver:\n",
            "     |  \n",
            "     |  dense_output(self)\n",
            "     |      Compute a local interpolant over the last successful step.\n",
            "     |      \n",
            "     |      Returns\n",
            "     |      -------\n",
            "     |      sol : `DenseOutput`\n",
            "     |          Local interpolant over the last successful step.\n",
            "     |  \n",
            "     |  step(self)\n",
            "     |      Perform one integration step.\n",
            "     |      \n",
            "     |      Returns\n",
            "     |      -------\n",
            "     |      message : string or None\n",
            "     |          Report from the solver. Typically a reason for a failure if\n",
            "     |          `self.status` is 'failed' after the step was taken or None\n",
            "     |          otherwise.\n",
            "     |  \n",
            "     |  ----------------------------------------------------------------------\n",
            "     |  Data descriptors inherited from scipy.integrate._ivp.base.OdeSolver:\n",
            "     |  \n",
            "     |  __dict__\n",
            "     |      dictionary for instance variables (if defined)\n",
            "     |  \n",
            "     |  __weakref__\n",
            "     |      list of weak references to the object (if defined)\n",
            "     |  \n",
            "     |  step_size\n",
            "     |  \n",
            "     |  ----------------------------------------------------------------------\n",
            "     |  Data and other attributes inherited from scipy.integrate._ivp.base.OdeSolver:\n",
            "     |  \n",
            "     |  TOO_SMALL_STEP = 'Required step size is less than spacing between numb...\n",
            "    \n",
            "    class RK45(RungeKutta)\n",
            "     |  Explicit Runge-Kutta method of order 5(4).\n",
            "     |  \n",
            "     |  This uses the Dormand-Prince pair of formulas [1]_. The error is controlled\n",
            "     |  assuming accuracy of the fourth-order method accuracy, but steps are taken\n",
            "     |  using the fifth-order accurate formula (local extrapolation is done).\n",
            "     |  A quartic interpolation polynomial is used for the dense output [2]_.\n",
            "     |  \n",
            "     |  Can be applied in the complex domain.\n",
            "     |  \n",
            "     |  Parameters\n",
            "     |  ----------\n",
            "     |  fun : callable\n",
            "     |      Right-hand side of the system. The calling signature is ``fun(t, y)``.\n",
            "     |      Here ``t`` is a scalar, and there are two options for the ndarray ``y``:\n",
            "     |      It can either have shape (n,); then ``fun`` must return array_like with\n",
            "     |      shape (n,). Alternatively it can have shape (n, k); then ``fun``\n",
            "     |      must return an array_like with shape (n, k), i.e. each column\n",
            "     |      corresponds to a single column in ``y``. The choice between the two\n",
            "     |      options is determined by `vectorized` argument (see below).\n",
            "     |  t0 : float\n",
            "     |      Initial time.\n",
            "     |  y0 : array_like, shape (n,)\n",
            "     |      Initial state.\n",
            "     |  t_bound : float\n",
            "     |      Boundary time - the integration won't continue beyond it. It also\n",
            "     |      determines the direction of the integration.\n",
            "     |  first_step : float or None, optional\n",
            "     |      Initial step size. Default is ``None`` which means that the algorithm\n",
            "     |      should choose.\n",
            "     |  max_step : float, optional\n",
            "     |      Maximum allowed step size. Default is np.inf, i.e. the step size is not\n",
            "     |      bounded and determined solely by the solver.\n",
            "     |  rtol, atol : float and array_like, optional\n",
            "     |      Relative and absolute tolerances. The solver keeps the local error\n",
            "     |      estimates less than ``atol + rtol * abs(y)``. Here `rtol` controls a\n",
            "     |      relative accuracy (number of correct digits). But if a component of `y`\n",
            "     |      is approximately below `atol`, the error only needs to fall within\n",
            "     |      the same `atol` threshold, and the number of correct digits is not\n",
            "     |      guaranteed. If components of y have different scales, it might be\n",
            "     |      beneficial to set different `atol` values for different components by\n",
            "     |      passing array_like with shape (n,) for `atol`. Default values are\n",
            "     |      1e-3 for `rtol` and 1e-6 for `atol`.\n",
            "     |  vectorized : bool, optional\n",
            "     |      Whether `fun` is implemented in a vectorized fashion. Default is False.\n",
            "     |  \n",
            "     |  Attributes\n",
            "     |  ----------\n",
            "     |  n : int\n",
            "     |      Number of equations.\n",
            "     |  status : string\n",
            "     |      Current status of the solver: 'running', 'finished' or 'failed'.\n",
            "     |  t_bound : float\n",
            "     |      Boundary time.\n",
            "     |  direction : float\n",
            "     |      Integration direction: +1 or -1.\n",
            "     |  t : float\n",
            "     |      Current time.\n",
            "     |  y : ndarray\n",
            "     |      Current state.\n",
            "     |  t_old : float\n",
            "     |      Previous time. None if no steps were made yet.\n",
            "     |  step_size : float\n",
            "     |      Size of the last successful step. None if no steps were made yet.\n",
            "     |  nfev : int\n",
            "     |      Number evaluations of the system's right-hand side.\n",
            "     |  njev : int\n",
            "     |      Number of evaluations of the Jacobian. Is always 0 for this solver as it does not use the Jacobian.\n",
            "     |  nlu : int\n",
            "     |      Number of LU decompositions. Is always 0 for this solver.\n",
            "     |  \n",
            "     |  References\n",
            "     |  ----------\n",
            "     |  .. [1] J. R. Dormand, P. J. Prince, \"A family of embedded Runge-Kutta\n",
            "     |         formulae\", Journal of Computational and Applied Mathematics, Vol. 6,\n",
            "     |         No. 1, pp. 19-26, 1980.\n",
            "     |  .. [2] L. W. Shampine, \"Some Practical Runge-Kutta Formulas\", Mathematics\n",
            "     |         of Computation,, Vol. 46, No. 173, pp. 135-150, 1986.\n",
            "     |  \n",
            "     |  Method resolution order:\n",
            "     |      RK45\n",
            "     |      RungeKutta\n",
            "     |      scipy.integrate._ivp.base.OdeSolver\n",
            "     |      builtins.object\n",
            "     |  \n",
            "     |  Data and other attributes defined here:\n",
            "     |  \n",
            "     |  A = array([[  0.        ,   0.        ,   0.        ...8.90642272,   0...\n",
            "     |  \n",
            "     |  B = array([ 0.09114583,  0.        ,  0.4492363 ,  0.65104167, -0.3223...\n",
            "     |  \n",
            "     |  C = array([0.        , 0.2       , 0.3       , 0.8       , 0.88888889,...\n",
            "     |  \n",
            "     |  E = array([-0.00123264,  0.        ,  0.00425277, -0...7,  0.0508638 ,...\n",
            "     |  \n",
            "     |  P = array([[ 1.        , -2.85358007,  3.07174346, -...       ,  1.382...\n",
            "     |  \n",
            "     |  error_estimator_order = 4\n",
            "     |  \n",
            "     |  n_stages = 6\n",
            "     |  \n",
            "     |  order = 5\n",
            "     |  \n",
            "     |  ----------------------------------------------------------------------\n",
            "     |  Methods inherited from RungeKutta:\n",
            "     |  \n",
            "     |  __init__(self, fun, t0, y0, t_bound, max_step=inf, rtol=0.001, atol=1e-06, vectorized=False, first_step=None, **extraneous)\n",
            "     |      Initialize self.  See help(type(self)) for accurate signature.\n",
            "     |  \n",
            "     |  ----------------------------------------------------------------------\n",
            "     |  Methods inherited from scipy.integrate._ivp.base.OdeSolver:\n",
            "     |  \n",
            "     |  dense_output(self)\n",
            "     |      Compute a local interpolant over the last successful step.\n",
            "     |      \n",
            "     |      Returns\n",
            "     |      -------\n",
            "     |      sol : `DenseOutput`\n",
            "     |          Local interpolant over the last successful step.\n",
            "     |  \n",
            "     |  step(self)\n",
            "     |      Perform one integration step.\n",
            "     |      \n",
            "     |      Returns\n",
            "     |      -------\n",
            "     |      message : string or None\n",
            "     |          Report from the solver. Typically a reason for a failure if\n",
            "     |          `self.status` is 'failed' after the step was taken or None\n",
            "     |          otherwise.\n",
            "     |  \n",
            "     |  ----------------------------------------------------------------------\n",
            "     |  Data descriptors inherited from scipy.integrate._ivp.base.OdeSolver:\n",
            "     |  \n",
            "     |  __dict__\n",
            "     |      dictionary for instance variables (if defined)\n",
            "     |  \n",
            "     |  __weakref__\n",
            "     |      list of weak references to the object (if defined)\n",
            "     |  \n",
            "     |  step_size\n",
            "     |  \n",
            "     |  ----------------------------------------------------------------------\n",
            "     |  Data and other attributes inherited from scipy.integrate._ivp.base.OdeSolver:\n",
            "     |  \n",
            "     |  TOO_SMALL_STEP = 'Required step size is less than spacing between numb...\n",
            "    \n",
            "    class Radau(scipy.integrate._ivp.base.OdeSolver)\n",
            "     |  Implicit Runge-Kutta method of Radau IIA family of order 5.\n",
            "     |  \n",
            "     |  The implementation follows [1]_. The error is controlled with a\n",
            "     |  third-order accurate embedded formula. A cubic polynomial which satisfies\n",
            "     |  the collocation conditions is used for the dense output.\n",
            "     |  \n",
            "     |  Parameters\n",
            "     |  ----------\n",
            "     |  fun : callable\n",
            "     |      Right-hand side of the system. The calling signature is ``fun(t, y)``.\n",
            "     |      Here ``t`` is a scalar, and there are two options for the ndarray ``y``:\n",
            "     |      It can either have shape (n,); then ``fun`` must return array_like with\n",
            "     |      shape (n,). Alternatively it can have shape (n, k); then ``fun``\n",
            "     |      must return an array_like with shape (n, k), i.e. each column\n",
            "     |      corresponds to a single column in ``y``. The choice between the two\n",
            "     |      options is determined by `vectorized` argument (see below). The\n",
            "     |      vectorized implementation allows a faster approximation of the Jacobian\n",
            "     |      by finite differences (required for this solver).\n",
            "     |  t0 : float\n",
            "     |      Initial time.\n",
            "     |  y0 : array_like, shape (n,)\n",
            "     |      Initial state.\n",
            "     |  t_bound : float\n",
            "     |      Boundary time - the integration won't continue beyond it. It also\n",
            "     |      determines the direction of the integration.\n",
            "     |  first_step : float or None, optional\n",
            "     |      Initial step size. Default is ``None`` which means that the algorithm\n",
            "     |      should choose.\n",
            "     |  max_step : float, optional\n",
            "     |      Maximum allowed step size. Default is np.inf, i.e. the step size is not\n",
            "     |      bounded and determined solely by the solver.\n",
            "     |  rtol, atol : float and array_like, optional\n",
            "     |      Relative and absolute tolerances. The solver keeps the local error\n",
            "     |      estimates less than ``atol + rtol * abs(y)``. Here `rtol` controls a\n",
            "     |      relative accuracy (number of correct digits). But if a component of `y`\n",
            "     |      is approximately below `atol`, the error only needs to fall within\n",
            "     |      the same `atol` threshold, and the number of correct digits is not\n",
            "     |      guaranteed. If components of y have different scales, it might be\n",
            "     |      beneficial to set different `atol` values for different components by\n",
            "     |      passing array_like with shape (n,) for `atol`. Default values are\n",
            "     |      1e-3 for `rtol` and 1e-6 for `atol`.\n",
            "     |  jac : {None, array_like, sparse_matrix, callable}, optional\n",
            "     |      Jacobian matrix of the right-hand side of the system with respect to\n",
            "     |      y, required by this method. The Jacobian matrix has shape (n, n) and\n",
            "     |      its element (i, j) is equal to ``d f_i / d y_j``.\n",
            "     |      There are three ways to define the Jacobian:\n",
            "     |  \n",
            "     |          * If array_like or sparse_matrix, the Jacobian is assumed to\n",
            "     |            be constant.\n",
            "     |          * If callable, the Jacobian is assumed to depend on both\n",
            "     |            t and y; it will be called as ``jac(t, y)`` as necessary.\n",
            "     |            For the 'Radau' and 'BDF' methods, the return value might be a\n",
            "     |            sparse matrix.\n",
            "     |          * If None (default), the Jacobian will be approximated by\n",
            "     |            finite differences.\n",
            "     |  \n",
            "     |      It is generally recommended to provide the Jacobian rather than\n",
            "     |      relying on a finite-difference approximation.\n",
            "     |  jac_sparsity : {None, array_like, sparse matrix}, optional\n",
            "     |      Defines a sparsity structure of the Jacobian matrix for a\n",
            "     |      finite-difference approximation. Its shape must be (n, n). This argument\n",
            "     |      is ignored if `jac` is not `None`. If the Jacobian has only few non-zero\n",
            "     |      elements in *each* row, providing the sparsity structure will greatly\n",
            "     |      speed up the computations [2]_. A zero entry means that a corresponding\n",
            "     |      element in the Jacobian is always zero. If None (default), the Jacobian\n",
            "     |      is assumed to be dense.\n",
            "     |  vectorized : bool, optional\n",
            "     |      Whether `fun` is implemented in a vectorized fashion. Default is False.\n",
            "     |  \n",
            "     |  Attributes\n",
            "     |  ----------\n",
            "     |  n : int\n",
            "     |      Number of equations.\n",
            "     |  status : string\n",
            "     |      Current status of the solver: 'running', 'finished' or 'failed'.\n",
            "     |  t_bound : float\n",
            "     |      Boundary time.\n",
            "     |  direction : float\n",
            "     |      Integration direction: +1 or -1.\n",
            "     |  t : float\n",
            "     |      Current time.\n",
            "     |  y : ndarray\n",
            "     |      Current state.\n",
            "     |  t_old : float\n",
            "     |      Previous time. None if no steps were made yet.\n",
            "     |  step_size : float\n",
            "     |      Size of the last successful step. None if no steps were made yet.\n",
            "     |  nfev : int\n",
            "     |      Number of evaluations of the right-hand side.\n",
            "     |  njev : int\n",
            "     |      Number of evaluations of the Jacobian.\n",
            "     |  nlu : int\n",
            "     |      Number of LU decompositions.\n",
            "     |  \n",
            "     |  References\n",
            "     |  ----------\n",
            "     |  .. [1] E. Hairer, G. Wanner, \"Solving Ordinary Differential Equations II:\n",
            "     |         Stiff and Differential-Algebraic Problems\", Sec. IV.8.\n",
            "     |  .. [2] A. Curtis, M. J. D. Powell, and J. Reid, \"On the estimation of\n",
            "     |         sparse Jacobian matrices\", Journal of the Institute of Mathematics\n",
            "     |         and its Applications, 13, pp. 117-120, 1974.\n",
            "     |  \n",
            "     |  Method resolution order:\n",
            "     |      Radau\n",
            "     |      scipy.integrate._ivp.base.OdeSolver\n",
            "     |      builtins.object\n",
            "     |  \n",
            "     |  Methods defined here:\n",
            "     |  \n",
            "     |  __init__(self, fun, t0, y0, t_bound, max_step=inf, rtol=0.001, atol=1e-06, jac=None, jac_sparsity=None, vectorized=False, first_step=None, **extraneous)\n",
            "     |      Initialize self.  See help(type(self)) for accurate signature.\n",
            "     |  \n",
            "     |  ----------------------------------------------------------------------\n",
            "     |  Methods inherited from scipy.integrate._ivp.base.OdeSolver:\n",
            "     |  \n",
            "     |  dense_output(self)\n",
            "     |      Compute a local interpolant over the last successful step.\n",
            "     |      \n",
            "     |      Returns\n",
            "     |      -------\n",
            "     |      sol : `DenseOutput`\n",
            "     |          Local interpolant over the last successful step.\n",
            "     |  \n",
            "     |  step(self)\n",
            "     |      Perform one integration step.\n",
            "     |      \n",
            "     |      Returns\n",
            "     |      -------\n",
            "     |      message : string or None\n",
            "     |          Report from the solver. Typically a reason for a failure if\n",
            "     |          `self.status` is 'failed' after the step was taken or None\n",
            "     |          otherwise.\n",
            "     |  \n",
            "     |  ----------------------------------------------------------------------\n",
            "     |  Data descriptors inherited from scipy.integrate._ivp.base.OdeSolver:\n",
            "     |  \n",
            "     |  __dict__\n",
            "     |      dictionary for instance variables (if defined)\n",
            "     |  \n",
            "     |  __weakref__\n",
            "     |      list of weak references to the object (if defined)\n",
            "     |  \n",
            "     |  step_size\n",
            "     |  \n",
            "     |  ----------------------------------------------------------------------\n",
            "     |  Data and other attributes inherited from scipy.integrate._ivp.base.OdeSolver:\n",
            "     |  \n",
            "     |  TOO_SMALL_STEP = 'Required step size is less than spacing between numb...\n",
            "    \n",
            "    class complex_ode(ode)\n",
            "     |  A wrapper of ode for complex systems.\n",
            "     |  \n",
            "     |  This functions similarly as `ode`, but re-maps a complex-valued\n",
            "     |  equation system to a real-valued one before using the integrators.\n",
            "     |  \n",
            "     |  Parameters\n",
            "     |  ----------\n",
            "     |  f : callable ``f(t, y, *f_args)``\n",
            "     |      Rhs of the equation. t is a scalar, ``y.shape == (n,)``.\n",
            "     |      ``f_args`` is set by calling ``set_f_params(*args)``.\n",
            "     |  jac : callable ``jac(t, y, *jac_args)``\n",
            "     |      Jacobian of the rhs, ``jac[i,j] = d f[i] / d y[j]``.\n",
            "     |      ``jac_args`` is set by calling ``set_f_params(*args)``.\n",
            "     |  \n",
            "     |  Attributes\n",
            "     |  ----------\n",
            "     |  t : float\n",
            "     |      Current time.\n",
            "     |  y : ndarray\n",
            "     |      Current variable values.\n",
            "     |  \n",
            "     |  Examples\n",
            "     |  --------\n",
            "     |  For usage examples, see `ode`.\n",
            "     |  \n",
            "     |  Method resolution order:\n",
            "     |      complex_ode\n",
            "     |      ode\n",
            "     |      builtins.object\n",
            "     |  \n",
            "     |  Methods defined here:\n",
            "     |  \n",
            "     |  __init__(self, f, jac=None)\n",
            "     |      Initialize self.  See help(type(self)) for accurate signature.\n",
            "     |  \n",
            "     |  integrate(self, t, step=False, relax=False)\n",
            "     |      Find y=y(t), set y as an initial condition, and return y.\n",
            "     |      \n",
            "     |      Parameters\n",
            "     |      ----------\n",
            "     |      t : float\n",
            "     |          The endpoint of the integration step.\n",
            "     |      step : bool\n",
            "     |          If True, and if the integrator supports the step method,\n",
            "     |          then perform a single integration step and return.\n",
            "     |          This parameter is provided in order to expose internals of\n",
            "     |          the implementation, and should not be changed from its default\n",
            "     |          value in most cases.\n",
            "     |      relax : bool\n",
            "     |          If True and if the integrator supports the run_relax method,\n",
            "     |          then integrate until t_1 >= t and return. ``relax`` is not\n",
            "     |          referenced if ``step=True``.\n",
            "     |          This parameter is provided in order to expose internals of\n",
            "     |          the implementation, and should not be changed from its default\n",
            "     |          value in most cases.\n",
            "     |      \n",
            "     |      Returns\n",
            "     |      -------\n",
            "     |      y : float\n",
            "     |          The integrated value at t\n",
            "     |  \n",
            "     |  set_initial_value(self, y, t=0.0)\n",
            "     |      Set initial conditions y(t) = y.\n",
            "     |  \n",
            "     |  set_integrator(self, name, **integrator_params)\n",
            "     |      Set integrator by name.\n",
            "     |      \n",
            "     |      Parameters\n",
            "     |      ----------\n",
            "     |      name : str\n",
            "     |          Name of the integrator\n",
            "     |      integrator_params\n",
            "     |          Additional parameters for the integrator.\n",
            "     |  \n",
            "     |  set_solout(self, solout)\n",
            "     |      Set callable to be called at every successful integration step.\n",
            "     |      \n",
            "     |      Parameters\n",
            "     |      ----------\n",
            "     |      solout : callable\n",
            "     |          ``solout(t, y)`` is called at each internal integrator step,\n",
            "     |          t is a scalar providing the current independent position\n",
            "     |          y is the current soloution ``y.shape == (n,)``\n",
            "     |          solout should return -1 to stop integration\n",
            "     |          otherwise it should return None or 0\n",
            "     |  \n",
            "     |  ----------------------------------------------------------------------\n",
            "     |  Data descriptors defined here:\n",
            "     |  \n",
            "     |  y\n",
            "     |  \n",
            "     |  ----------------------------------------------------------------------\n",
            "     |  Methods inherited from ode:\n",
            "     |  \n",
            "     |  get_return_code(self)\n",
            "     |      Extracts the return code for the integration to enable better control\n",
            "     |      if the integration fails.\n",
            "     |      \n",
            "     |      In general, a return code > 0 implies success while a return code < 0\n",
            "     |      implies failure.\n",
            "     |      \n",
            "     |      Notes\n",
            "     |      -----\n",
            "     |      This section describes possible return codes and their meaning, for available\n",
            "     |      integrators that can be selected by `set_integrator` method.\n",
            "     |      \n",
            "     |      \"vode\"\n",
            "     |      \n",
            "     |      ===========  =======\n",
            "     |      Return Code  Message\n",
            "     |      ===========  =======\n",
            "     |      2            Integration successful.\n",
            "     |      -1           Excess work done on this call. (Perhaps wrong MF.)\n",
            "     |      -2           Excess accuracy requested. (Tolerances too small.)\n",
            "     |      -3           Illegal input detected. (See printed message.)\n",
            "     |      -4           Repeated error test failures. (Check all input.)\n",
            "     |      -5           Repeated convergence failures. (Perhaps bad Jacobian\n",
            "     |                   supplied or wrong choice of MF or tolerances.)\n",
            "     |      -6           Error weight became zero during problem. (Solution\n",
            "     |                   component i vanished, and ATOL or ATOL(i) = 0.)\n",
            "     |      ===========  =======\n",
            "     |      \n",
            "     |      \"zvode\"\n",
            "     |      \n",
            "     |      ===========  =======\n",
            "     |      Return Code  Message\n",
            "     |      ===========  =======\n",
            "     |      2            Integration successful.\n",
            "     |      -1           Excess work done on this call. (Perhaps wrong MF.)\n",
            "     |      -2           Excess accuracy requested. (Tolerances too small.)\n",
            "     |      -3           Illegal input detected. (See printed message.)\n",
            "     |      -4           Repeated error test failures. (Check all input.)\n",
            "     |      -5           Repeated convergence failures. (Perhaps bad Jacobian\n",
            "     |                   supplied or wrong choice of MF or tolerances.)\n",
            "     |      -6           Error weight became zero during problem. (Solution\n",
            "     |                   component i vanished, and ATOL or ATOL(i) = 0.)\n",
            "     |      ===========  =======\n",
            "     |      \n",
            "     |      \"dopri5\"\n",
            "     |      \n",
            "     |      ===========  =======\n",
            "     |      Return Code  Message\n",
            "     |      ===========  =======\n",
            "     |      1            Integration successful.\n",
            "     |      2            Integration successful (interrupted by solout).\n",
            "     |      -1           Input is not consistent.\n",
            "     |      -2           Larger nsteps is needed.\n",
            "     |      -3           Step size becomes too small.\n",
            "     |      -4           Problem is probably stiff (interrupted).\n",
            "     |      ===========  =======\n",
            "     |      \n",
            "     |      \"dop853\"\n",
            "     |      \n",
            "     |      ===========  =======\n",
            "     |      Return Code  Message\n",
            "     |      ===========  =======\n",
            "     |      1            Integration successful.\n",
            "     |      2            Integration successful (interrupted by solout).\n",
            "     |      -1           Input is not consistent.\n",
            "     |      -2           Larger nsteps is needed.\n",
            "     |      -3           Step size becomes too small.\n",
            "     |      -4           Problem is probably stiff (interrupted).\n",
            "     |      ===========  =======\n",
            "     |      \n",
            "     |      \"lsoda\"\n",
            "     |      \n",
            "     |      ===========  =======\n",
            "     |      Return Code  Message\n",
            "     |      ===========  =======\n",
            "     |      2            Integration successful.\n",
            "     |      -1           Excess work done on this call (perhaps wrong Dfun type).\n",
            "     |      -2           Excess accuracy requested (tolerances too small).\n",
            "     |      -3           Illegal input detected (internal error).\n",
            "     |      -4           Repeated error test failures (internal error).\n",
            "     |      -5           Repeated convergence failures (perhaps bad Jacobian or tolerances).\n",
            "     |      -6           Error weight became zero during problem.\n",
            "     |      -7           Internal workspace insufficient to finish (internal error).\n",
            "     |      ===========  =======\n",
            "     |  \n",
            "     |  set_f_params(self, *args)\n",
            "     |      Set extra parameters for user-supplied function f.\n",
            "     |  \n",
            "     |  set_jac_params(self, *args)\n",
            "     |      Set extra parameters for user-supplied function jac.\n",
            "     |  \n",
            "     |  successful(self)\n",
            "     |      Check if integration was successful.\n",
            "     |  \n",
            "     |  ----------------------------------------------------------------------\n",
            "     |  Data descriptors inherited from ode:\n",
            "     |  \n",
            "     |  __dict__\n",
            "     |      dictionary for instance variables (if defined)\n",
            "     |  \n",
            "     |  __weakref__\n",
            "     |      list of weak references to the object (if defined)\n",
            "    \n",
            "    class ode(builtins.object)\n",
            "     |  A generic interface class to numeric integrators.\n",
            "     |  \n",
            "     |  Solve an equation system :math:`y'(t) = f(t,y)` with (optional) ``jac = df/dy``.\n",
            "     |  \n",
            "     |  *Note*: The first two arguments of ``f(t, y, ...)`` are in the\n",
            "     |  opposite order of the arguments in the system definition function used\n",
            "     |  by `scipy.integrate.odeint`.\n",
            "     |  \n",
            "     |  Parameters\n",
            "     |  ----------\n",
            "     |  f : callable ``f(t, y, *f_args)``\n",
            "     |      Right-hand side of the differential equation. t is a scalar,\n",
            "     |      ``y.shape == (n,)``.\n",
            "     |      ``f_args`` is set by calling ``set_f_params(*args)``.\n",
            "     |      `f` should return a scalar, array or list (not a tuple).\n",
            "     |  jac : callable ``jac(t, y, *jac_args)``, optional\n",
            "     |      Jacobian of the right-hand side, ``jac[i,j] = d f[i] / d y[j]``.\n",
            "     |      ``jac_args`` is set by calling ``set_jac_params(*args)``.\n",
            "     |  \n",
            "     |  Attributes\n",
            "     |  ----------\n",
            "     |  t : float\n",
            "     |      Current time.\n",
            "     |  y : ndarray\n",
            "     |      Current variable values.\n",
            "     |  \n",
            "     |  See also\n",
            "     |  --------\n",
            "     |  odeint : an integrator with a simpler interface based on lsoda from ODEPACK\n",
            "     |  quad : for finding the area under a curve\n",
            "     |  \n",
            "     |  Notes\n",
            "     |  -----\n",
            "     |  Available integrators are listed below. They can be selected using\n",
            "     |  the `set_integrator` method.\n",
            "     |  \n",
            "     |  \"vode\"\n",
            "     |  \n",
            "     |      Real-valued Variable-coefficient Ordinary Differential Equation\n",
            "     |      solver, with fixed-leading-coefficient implementation. It provides\n",
            "     |      implicit Adams method (for non-stiff problems) and a method based on\n",
            "     |      backward differentiation formulas (BDF) (for stiff problems).\n",
            "     |  \n",
            "     |      Source: http://www.netlib.org/ode/vode.f\n",
            "     |  \n",
            "     |      .. warning::\n",
            "     |  \n",
            "     |         This integrator is not re-entrant. You cannot have two `ode`\n",
            "     |         instances using the \"vode\" integrator at the same time.\n",
            "     |  \n",
            "     |      This integrator accepts the following parameters in `set_integrator`\n",
            "     |      method of the `ode` class:\n",
            "     |  \n",
            "     |      - atol : float or sequence\n",
            "     |        absolute tolerance for solution\n",
            "     |      - rtol : float or sequence\n",
            "     |        relative tolerance for solution\n",
            "     |      - lband : None or int\n",
            "     |      - uband : None or int\n",
            "     |        Jacobian band width, jac[i,j] != 0 for i-lband <= j <= i+uband.\n",
            "     |        Setting these requires your jac routine to return the jacobian\n",
            "     |        in packed format, jac_packed[i-j+uband, j] = jac[i,j]. The\n",
            "     |        dimension of the matrix must be (lband+uband+1, len(y)).\n",
            "     |      - method: 'adams' or 'bdf'\n",
            "     |        Which solver to use, Adams (non-stiff) or BDF (stiff)\n",
            "     |      - with_jacobian : bool\n",
            "     |        This option is only considered when the user has not supplied a\n",
            "     |        Jacobian function and has not indicated (by setting either band)\n",
            "     |        that the Jacobian is banded.  In this case, `with_jacobian` specifies\n",
            "     |        whether the iteration method of the ODE solver's correction step is\n",
            "     |        chord iteration with an internally generated full Jacobian or\n",
            "     |        functional iteration with no Jacobian.\n",
            "     |      - nsteps : int\n",
            "     |        Maximum number of (internally defined) steps allowed during one\n",
            "     |        call to the solver.\n",
            "     |      - first_step : float\n",
            "     |      - min_step : float\n",
            "     |      - max_step : float\n",
            "     |        Limits for the step sizes used by the integrator.\n",
            "     |      - order : int\n",
            "     |        Maximum order used by the integrator,\n",
            "     |        order <= 12 for Adams, <= 5 for BDF.\n",
            "     |  \n",
            "     |  \"zvode\"\n",
            "     |  \n",
            "     |      Complex-valued Variable-coefficient Ordinary Differential Equation\n",
            "     |      solver, with fixed-leading-coefficient implementation.  It provides\n",
            "     |      implicit Adams method (for non-stiff problems) and a method based on\n",
            "     |      backward differentiation formulas (BDF) (for stiff problems).\n",
            "     |  \n",
            "     |      Source: http://www.netlib.org/ode/zvode.f\n",
            "     |  \n",
            "     |      .. warning::\n",
            "     |  \n",
            "     |         This integrator is not re-entrant. You cannot have two `ode`\n",
            "     |         instances using the \"zvode\" integrator at the same time.\n",
            "     |  \n",
            "     |      This integrator accepts the same parameters in `set_integrator`\n",
            "     |      as the \"vode\" solver.\n",
            "     |  \n",
            "     |      .. note::\n",
            "     |  \n",
            "     |          When using ZVODE for a stiff system, it should only be used for\n",
            "     |          the case in which the function f is analytic, that is, when each f(i)\n",
            "     |          is an analytic function of each y(j).  Analyticity means that the\n",
            "     |          partial derivative df(i)/dy(j) is a unique complex number, and this\n",
            "     |          fact is critical in the way ZVODE solves the dense or banded linear\n",
            "     |          systems that arise in the stiff case.  For a complex stiff ODE system\n",
            "     |          in which f is not analytic, ZVODE is likely to have convergence\n",
            "     |          failures, and for this problem one should instead use DVODE on the\n",
            "     |          equivalent real system (in the real and imaginary parts of y).\n",
            "     |  \n",
            "     |  \"lsoda\"\n",
            "     |  \n",
            "     |      Real-valued Variable-coefficient Ordinary Differential Equation\n",
            "     |      solver, with fixed-leading-coefficient implementation. It provides\n",
            "     |      automatic method switching between implicit Adams method (for non-stiff\n",
            "     |      problems) and a method based on backward differentiation formulas (BDF)\n",
            "     |      (for stiff problems).\n",
            "     |  \n",
            "     |      Source: http://www.netlib.org/odepack\n",
            "     |  \n",
            "     |      .. warning::\n",
            "     |  \n",
            "     |         This integrator is not re-entrant. You cannot have two `ode`\n",
            "     |         instances using the \"lsoda\" integrator at the same time.\n",
            "     |  \n",
            "     |      This integrator accepts the following parameters in `set_integrator`\n",
            "     |      method of the `ode` class:\n",
            "     |  \n",
            "     |      - atol : float or sequence\n",
            "     |        absolute tolerance for solution\n",
            "     |      - rtol : float or sequence\n",
            "     |        relative tolerance for solution\n",
            "     |      - lband : None or int\n",
            "     |      - uband : None or int\n",
            "     |        Jacobian band width, jac[i,j] != 0 for i-lband <= j <= i+uband.\n",
            "     |        Setting these requires your jac routine to return the jacobian\n",
            "     |        in packed format, jac_packed[i-j+uband, j] = jac[i,j].\n",
            "     |      - with_jacobian : bool\n",
            "     |        *Not used.*\n",
            "     |      - nsteps : int\n",
            "     |        Maximum number of (internally defined) steps allowed during one\n",
            "     |        call to the solver.\n",
            "     |      - first_step : float\n",
            "     |      - min_step : float\n",
            "     |      - max_step : float\n",
            "     |        Limits for the step sizes used by the integrator.\n",
            "     |      - max_order_ns : int\n",
            "     |        Maximum order used in the nonstiff case (default 12).\n",
            "     |      - max_order_s : int\n",
            "     |        Maximum order used in the stiff case (default 5).\n",
            "     |      - max_hnil : int\n",
            "     |        Maximum number of messages reporting too small step size (t + h = t)\n",
            "     |        (default 0)\n",
            "     |      - ixpr : int\n",
            "     |        Whether to generate extra printing at method switches (default False).\n",
            "     |  \n",
            "     |  \"dopri5\"\n",
            "     |  \n",
            "     |      This is an explicit runge-kutta method of order (4)5 due to Dormand &\n",
            "     |      Prince (with stepsize control and dense output).\n",
            "     |  \n",
            "     |      Authors:\n",
            "     |  \n",
            "     |          E. Hairer and G. Wanner\n",
            "     |          Universite de Geneve, Dept. de Mathematiques\n",
            "     |          CH-1211 Geneve 24, Switzerland\n",
            "     |          e-mail:  ernst.hairer@math.unige.ch, gerhard.wanner@math.unige.ch\n",
            "     |  \n",
            "     |      This code is described in [HNW93]_.\n",
            "     |  \n",
            "     |      This integrator accepts the following parameters in set_integrator()\n",
            "     |      method of the ode class:\n",
            "     |  \n",
            "     |      - atol : float or sequence\n",
            "     |        absolute tolerance for solution\n",
            "     |      - rtol : float or sequence\n",
            "     |        relative tolerance for solution\n",
            "     |      - nsteps : int\n",
            "     |        Maximum number of (internally defined) steps allowed during one\n",
            "     |        call to the solver.\n",
            "     |      - first_step : float\n",
            "     |      - max_step : float\n",
            "     |      - safety : float\n",
            "     |        Safety factor on new step selection (default 0.9)\n",
            "     |      - ifactor : float\n",
            "     |      - dfactor : float\n",
            "     |        Maximum factor to increase/decrease step size by in one step\n",
            "     |      - beta : float\n",
            "     |        Beta parameter for stabilised step size control.\n",
            "     |      - verbosity : int\n",
            "     |        Switch for printing messages (< 0 for no messages).\n",
            "     |  \n",
            "     |  \"dop853\"\n",
            "     |  \n",
            "     |      This is an explicit runge-kutta method of order 8(5,3) due to Dormand\n",
            "     |      & Prince (with stepsize control and dense output).\n",
            "     |  \n",
            "     |      Options and references the same as \"dopri5\".\n",
            "     |  \n",
            "     |  Examples\n",
            "     |  --------\n",
            "     |  \n",
            "     |  A problem to integrate and the corresponding jacobian:\n",
            "     |  \n",
            "     |  >>> from scipy.integrate import ode\n",
            "     |  >>>\n",
            "     |  >>> y0, t0 = [1.0j, 2.0], 0\n",
            "     |  >>>\n",
            "     |  >>> def f(t, y, arg1):\n",
            "     |  ...     return [1j*arg1*y[0] + y[1], -arg1*y[1]**2]\n",
            "     |  >>> def jac(t, y, arg1):\n",
            "     |  ...     return [[1j*arg1, 1], [0, -arg1*2*y[1]]]\n",
            "     |  \n",
            "     |  The integration:\n",
            "     |  \n",
            "     |  >>> r = ode(f, jac).set_integrator('zvode', method='bdf')\n",
            "     |  >>> r.set_initial_value(y0, t0).set_f_params(2.0).set_jac_params(2.0)\n",
            "     |  >>> t1 = 10\n",
            "     |  >>> dt = 1\n",
            "     |  >>> while r.successful() and r.t < t1:\n",
            "     |  ...     print(r.t+dt, r.integrate(r.t+dt))\n",
            "     |  1 [-0.71038232+0.23749653j  0.40000271+0.j        ]\n",
            "     |  2.0 [0.19098503-0.52359246j 0.22222356+0.j        ]\n",
            "     |  3.0 [0.47153208+0.52701229j 0.15384681+0.j        ]\n",
            "     |  4.0 [-0.61905937+0.30726255j  0.11764744+0.j        ]\n",
            "     |  5.0 [0.02340997-0.61418799j 0.09523835+0.j        ]\n",
            "     |  6.0 [0.58643071+0.339819j 0.08000018+0.j      ]\n",
            "     |  7.0 [-0.52070105+0.44525141j  0.06896565+0.j        ]\n",
            "     |  8.0 [-0.15986733-0.61234476j  0.06060616+0.j        ]\n",
            "     |  9.0 [0.64850462+0.15048982j 0.05405414+0.j        ]\n",
            "     |  10.0 [-0.38404699+0.56382299j  0.04878055+0.j        ]\n",
            "     |  \n",
            "     |  References\n",
            "     |  ----------\n",
            "     |  .. [HNW93] E. Hairer, S.P. Norsett and G. Wanner, Solving Ordinary\n",
            "     |      Differential Equations i. Nonstiff Problems. 2nd edition.\n",
            "     |      Springer Series in Computational Mathematics,\n",
            "     |      Springer-Verlag (1993)\n",
            "     |  \n",
            "     |  Methods defined here:\n",
            "     |  \n",
            "     |  __init__(self, f, jac=None)\n",
            "     |      Initialize self.  See help(type(self)) for accurate signature.\n",
            "     |  \n",
            "     |  get_return_code(self)\n",
            "     |      Extracts the return code for the integration to enable better control\n",
            "     |      if the integration fails.\n",
            "     |      \n",
            "     |      In general, a return code > 0 implies success while a return code < 0\n",
            "     |      implies failure.\n",
            "     |      \n",
            "     |      Notes\n",
            "     |      -----\n",
            "     |      This section describes possible return codes and their meaning, for available\n",
            "     |      integrators that can be selected by `set_integrator` method.\n",
            "     |      \n",
            "     |      \"vode\"\n",
            "     |      \n",
            "     |      ===========  =======\n",
            "     |      Return Code  Message\n",
            "     |      ===========  =======\n",
            "     |      2            Integration successful.\n",
            "     |      -1           Excess work done on this call. (Perhaps wrong MF.)\n",
            "     |      -2           Excess accuracy requested. (Tolerances too small.)\n",
            "     |      -3           Illegal input detected. (See printed message.)\n",
            "     |      -4           Repeated error test failures. (Check all input.)\n",
            "     |      -5           Repeated convergence failures. (Perhaps bad Jacobian\n",
            "     |                   supplied or wrong choice of MF or tolerances.)\n",
            "     |      -6           Error weight became zero during problem. (Solution\n",
            "     |                   component i vanished, and ATOL or ATOL(i) = 0.)\n",
            "     |      ===========  =======\n",
            "     |      \n",
            "     |      \"zvode\"\n",
            "     |      \n",
            "     |      ===========  =======\n",
            "     |      Return Code  Message\n",
            "     |      ===========  =======\n",
            "     |      2            Integration successful.\n",
            "     |      -1           Excess work done on this call. (Perhaps wrong MF.)\n",
            "     |      -2           Excess accuracy requested. (Tolerances too small.)\n",
            "     |      -3           Illegal input detected. (See printed message.)\n",
            "     |      -4           Repeated error test failures. (Check all input.)\n",
            "     |      -5           Repeated convergence failures. (Perhaps bad Jacobian\n",
            "     |                   supplied or wrong choice of MF or tolerances.)\n",
            "     |      -6           Error weight became zero during problem. (Solution\n",
            "     |                   component i vanished, and ATOL or ATOL(i) = 0.)\n",
            "     |      ===========  =======\n",
            "     |      \n",
            "     |      \"dopri5\"\n",
            "     |      \n",
            "     |      ===========  =======\n",
            "     |      Return Code  Message\n",
            "     |      ===========  =======\n",
            "     |      1            Integration successful.\n",
            "     |      2            Integration successful (interrupted by solout).\n",
            "     |      -1           Input is not consistent.\n",
            "     |      -2           Larger nsteps is needed.\n",
            "     |      -3           Step size becomes too small.\n",
            "     |      -4           Problem is probably stiff (interrupted).\n",
            "     |      ===========  =======\n",
            "     |      \n",
            "     |      \"dop853\"\n",
            "     |      \n",
            "     |      ===========  =======\n",
            "     |      Return Code  Message\n",
            "     |      ===========  =======\n",
            "     |      1            Integration successful.\n",
            "     |      2            Integration successful (interrupted by solout).\n",
            "     |      -1           Input is not consistent.\n",
            "     |      -2           Larger nsteps is needed.\n",
            "     |      -3           Step size becomes too small.\n",
            "     |      -4           Problem is probably stiff (interrupted).\n",
            "     |      ===========  =======\n",
            "     |      \n",
            "     |      \"lsoda\"\n",
            "     |      \n",
            "     |      ===========  =======\n",
            "     |      Return Code  Message\n",
            "     |      ===========  =======\n",
            "     |      2            Integration successful.\n",
            "     |      -1           Excess work done on this call (perhaps wrong Dfun type).\n",
            "     |      -2           Excess accuracy requested (tolerances too small).\n",
            "     |      -3           Illegal input detected (internal error).\n",
            "     |      -4           Repeated error test failures (internal error).\n",
            "     |      -5           Repeated convergence failures (perhaps bad Jacobian or tolerances).\n",
            "     |      -6           Error weight became zero during problem.\n",
            "     |      -7           Internal workspace insufficient to finish (internal error).\n",
            "     |      ===========  =======\n",
            "     |  \n",
            "     |  integrate(self, t, step=False, relax=False)\n",
            "     |      Find y=y(t), set y as an initial condition, and return y.\n",
            "     |      \n",
            "     |      Parameters\n",
            "     |      ----------\n",
            "     |      t : float\n",
            "     |          The endpoint of the integration step.\n",
            "     |      step : bool\n",
            "     |          If True, and if the integrator supports the step method,\n",
            "     |          then perform a single integration step and return.\n",
            "     |          This parameter is provided in order to expose internals of\n",
            "     |          the implementation, and should not be changed from its default\n",
            "     |          value in most cases.\n",
            "     |      relax : bool\n",
            "     |          If True and if the integrator supports the run_relax method,\n",
            "     |          then integrate until t_1 >= t and return. ``relax`` is not\n",
            "     |          referenced if ``step=True``.\n",
            "     |          This parameter is provided in order to expose internals of\n",
            "     |          the implementation, and should not be changed from its default\n",
            "     |          value in most cases.\n",
            "     |      \n",
            "     |      Returns\n",
            "     |      -------\n",
            "     |      y : float\n",
            "     |          The integrated value at t\n",
            "     |  \n",
            "     |  set_f_params(self, *args)\n",
            "     |      Set extra parameters for user-supplied function f.\n",
            "     |  \n",
            "     |  set_initial_value(self, y, t=0.0)\n",
            "     |      Set initial conditions y(t) = y.\n",
            "     |  \n",
            "     |  set_integrator(self, name, **integrator_params)\n",
            "     |      Set integrator by name.\n",
            "     |      \n",
            "     |      Parameters\n",
            "     |      ----------\n",
            "     |      name : str\n",
            "     |          Name of the integrator.\n",
            "     |      integrator_params\n",
            "     |          Additional parameters for the integrator.\n",
            "     |  \n",
            "     |  set_jac_params(self, *args)\n",
            "     |      Set extra parameters for user-supplied function jac.\n",
            "     |  \n",
            "     |  set_solout(self, solout)\n",
            "     |      Set callable to be called at every successful integration step.\n",
            "     |      \n",
            "     |      Parameters\n",
            "     |      ----------\n",
            "     |      solout : callable\n",
            "     |          ``solout(t, y)`` is called at each internal integrator step,\n",
            "     |          t is a scalar providing the current independent position\n",
            "     |          y is the current soloution ``y.shape == (n,)``\n",
            "     |          solout should return -1 to stop integration\n",
            "     |          otherwise it should return None or 0\n",
            "     |  \n",
            "     |  successful(self)\n",
            "     |      Check if integration was successful.\n",
            "     |  \n",
            "     |  ----------------------------------------------------------------------\n",
            "     |  Data descriptors defined here:\n",
            "     |  \n",
            "     |  __dict__\n",
            "     |      dictionary for instance variables (if defined)\n",
            "     |  \n",
            "     |  __weakref__\n",
            "     |      list of weak references to the object (if defined)\n",
            "     |  \n",
            "     |  y\n",
            "\n",
            "FUNCTIONS\n",
            "    cumtrapz(y, x=None, dx=1.0, axis=-1, initial=None)\n",
            "        Cumulatively integrate y(x) using the composite trapezoidal rule.\n",
            "        \n",
            "        Parameters\n",
            "        ----------\n",
            "        y : array_like\n",
            "            Values to integrate.\n",
            "        x : array_like, optional\n",
            "            The coordinate to integrate along.  If None (default), use spacing `dx`\n",
            "            between consecutive elements in `y`.\n",
            "        dx : float, optional\n",
            "            Spacing between elements of `y`.  Only used if `x` is None.\n",
            "        axis : int, optional\n",
            "            Specifies the axis to cumulate.  Default is -1 (last axis).\n",
            "        initial : scalar, optional\n",
            "            If given, insert this value at the beginning of the returned result.\n",
            "            Typically this value should be 0.  Default is None, which means no\n",
            "            value at ``x[0]`` is returned and `res` has one element less than `y`\n",
            "            along the axis of integration.\n",
            "        \n",
            "        Returns\n",
            "        -------\n",
            "        res : ndarray\n",
            "            The result of cumulative integration of `y` along `axis`.\n",
            "            If `initial` is None, the shape is such that the axis of integration\n",
            "            has one less value than `y`.  If `initial` is given, the shape is equal\n",
            "            to that of `y`.\n",
            "        \n",
            "        See Also\n",
            "        --------\n",
            "        numpy.cumsum, numpy.cumprod\n",
            "        quad: adaptive quadrature using QUADPACK\n",
            "        romberg: adaptive Romberg quadrature\n",
            "        quadrature: adaptive Gaussian quadrature\n",
            "        fixed_quad: fixed-order Gaussian quadrature\n",
            "        dblquad: double integrals\n",
            "        tplquad: triple integrals\n",
            "        romb: integrators for sampled data\n",
            "        ode: ODE integrators\n",
            "        odeint: ODE integrators\n",
            "        \n",
            "        Examples\n",
            "        --------\n",
            "        >>> from scipy import integrate\n",
            "        >>> import matplotlib.pyplot as plt\n",
            "        \n",
            "        >>> x = np.linspace(-2, 2, num=20)\n",
            "        >>> y = x\n",
            "        >>> y_int = integrate.cumtrapz(y, x, initial=0)\n",
            "        >>> plt.plot(x, y_int, 'ro', x, y[0] + 0.5 * x**2, 'b-')\n",
            "        >>> plt.show()\n",
            "    \n",
            "    dblquad(func, a, b, gfun, hfun, args=(), epsabs=1.49e-08, epsrel=1.49e-08)\n",
            "        Compute a double integral.\n",
            "        \n",
            "        Return the double (definite) integral of ``func(y, x)`` from ``x = a..b``\n",
            "        and ``y = gfun(x)..hfun(x)``.\n",
            "        \n",
            "        Parameters\n",
            "        ----------\n",
            "        func : callable\n",
            "            A Python function or method of at least two variables: y must be the\n",
            "            first argument and x the second argument.\n",
            "        a, b : float\n",
            "            The limits of integration in x: `a` < `b`\n",
            "        gfun : callable or float\n",
            "            The lower boundary curve in y which is a function taking a single\n",
            "            floating point argument (x) and returning a floating point result\n",
            "            or a float indicating a constant boundary curve.\n",
            "        hfun : callable or float\n",
            "            The upper boundary curve in y (same requirements as `gfun`).\n",
            "        args : sequence, optional\n",
            "            Extra arguments to pass to `func`.\n",
            "        epsabs : float, optional\n",
            "            Absolute tolerance passed directly to the inner 1-D quadrature\n",
            "            integration. Default is 1.49e-8.\n",
            "        epsrel : float, optional\n",
            "            Relative tolerance of the inner 1-D integrals. Default is 1.49e-8.\n",
            "        \n",
            "        Returns\n",
            "        -------\n",
            "        y : float\n",
            "            The resultant integral.\n",
            "        abserr : float\n",
            "            An estimate of the error.\n",
            "        \n",
            "        See also\n",
            "        --------\n",
            "        quad : single integral\n",
            "        tplquad : triple integral\n",
            "        nquad : N-dimensional integrals\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",
            "        Examples\n",
            "        --------\n",
            "        \n",
            "        Compute the double integral of ``x * y**2`` over the box\n",
            "        ``x`` ranging from 0 to 2 and ``y`` ranging from 0 to 1.\n",
            "        \n",
            "        >>> from scipy import integrate\n",
            "        >>> f = lambda y, x: x*y**2\n",
            "        >>> integrate.dblquad(f, 0, 2, lambda x: 0, lambda x: 1)\n",
            "            (0.6666666666666667, 7.401486830834377e-15)\n",
            "    \n",
            "    fixed_quad(func, a, b, args=(), n=5)\n",
            "        Compute a definite integral using fixed-order Gaussian quadrature.\n",
            "        \n",
            "        Integrate `func` from `a` to `b` using Gaussian quadrature of\n",
            "        order `n`.\n",
            "        \n",
            "        Parameters\n",
            "        ----------\n",
            "        func : callable\n",
            "            A Python function or method to integrate (must accept vector inputs).\n",
            "            If integrating a vector-valued function, the returned array must have\n",
            "            shape ``(..., len(x))``.\n",
            "        a : float\n",
            "            Lower limit of integration.\n",
            "        b : float\n",
            "            Upper limit of integration.\n",
            "        args : tuple, optional\n",
            "            Extra arguments to pass to function, if any.\n",
            "        n : int, optional\n",
            "            Order of quadrature integration. Default is 5.\n",
            "        \n",
            "        Returns\n",
            "        -------\n",
            "        val : float\n",
            "            Gaussian quadrature approximation to the integral\n",
            "        none : None\n",
            "            Statically returned value of None\n",
            "        \n",
            "        \n",
            "        See Also\n",
            "        --------\n",
            "        quad : adaptive quadrature using QUADPACK\n",
            "        dblquad : double integrals\n",
            "        tplquad : triple integrals\n",
            "        romberg : adaptive Romberg quadrature\n",
            "        quadrature : adaptive Gaussian quadrature\n",
            "        romb : integrators for sampled data\n",
            "        simps : integrators for sampled data\n",
            "        cumtrapz : cumulative integration for sampled data\n",
            "        ode : ODE integrator\n",
            "        odeint : ODE integrator\n",
            "        \n",
            "        Examples\n",
            "        --------\n",
            "        >>> from scipy import integrate\n",
            "        >>> f = lambda x: x**8\n",
            "        >>> integrate.fixed_quad(f, 0.0, 1.0, n=4)\n",
            "        (0.1110884353741496, None)\n",
            "        >>> integrate.fixed_quad(f, 0.0, 1.0, n=5)\n",
            "        (0.11111111111111102, None)\n",
            "        >>> print(1/9.0)  # analytical result\n",
            "        0.1111111111111111\n",
            "        \n",
            "        >>> integrate.fixed_quad(np.cos, 0.0, np.pi/2, n=4)\n",
            "        (0.9999999771971152, None)\n",
            "        >>> integrate.fixed_quad(np.cos, 0.0, np.pi/2, n=5)\n",
            "        (1.000000000039565, None)\n",
            "        >>> np.sin(np.pi/2)-np.sin(0)  # analytical result\n",
            "        1.0\n",
            "    \n",
            "    newton_cotes(rn, equal=0)\n",
            "        Return weights and error coefficient for Newton-Cotes integration.\n",
            "        \n",
            "        Suppose we have (N+1) samples of f at the positions\n",
            "        x_0, x_1, ..., x_N.  Then an N-point Newton-Cotes formula for the\n",
            "        integral between x_0 and x_N is:\n",
            "        \n",
            "        :math:`\\int_{x_0}^{x_N} f(x)dx = \\Delta x \\sum_{i=0}^{N} a_i f(x_i)\n",
            "        + B_N (\\Delta x)^{N+2} f^{N+1} (\\xi)`\n",
            "        \n",
            "        where :math:`\\xi \\in [x_0,x_N]`\n",
            "        and :math:`\\Delta x = \\frac{x_N-x_0}{N}` is the average samples spacing.\n",
            "        \n",
            "        If the samples are equally-spaced and N is even, then the error\n",
            "        term is :math:`B_N (\\Delta x)^{N+3} f^{N+2}(\\xi)`.\n",
            "        \n",
            "        Parameters\n",
            "        ----------\n",
            "        rn : int\n",
            "            The integer order for equally-spaced data or the relative positions of\n",
            "            the samples with the first sample at 0 and the last at N, where N+1 is\n",
            "            the length of `rn`.  N is the order of the Newton-Cotes integration.\n",
            "        equal : int, optional\n",
            "            Set to 1 to enforce equally spaced data.\n",
            "        \n",
            "        Returns\n",
            "        -------\n",
            "        an : ndarray\n",
            "            1-D array of weights to apply to the function at the provided sample\n",
            "            positions.\n",
            "        B : float\n",
            "            Error coefficient.\n",
            "        \n",
            "        Examples\n",
            "        --------\n",
            "        Compute the integral of sin(x) in [0, :math:`\\pi`]:\n",
            "        \n",
            "        >>> from scipy.integrate import newton_cotes\n",
            "        >>> def f(x):\n",
            "        ...     return np.sin(x)\n",
            "        >>> a = 0\n",
            "        >>> b = np.pi\n",
            "        >>> exact = 2\n",
            "        >>> for N in [2, 4, 6, 8, 10]:\n",
            "        ...     x = np.linspace(a, b, N + 1)\n",
            "        ...     an, B = newton_cotes(N, 1)\n",
            "        ...     dx = (b - a) / N\n",
            "        ...     quad = dx * np.sum(an * f(x))\n",
            "        ...     error = abs(quad - exact)\n",
            "        ...     print('{:2d}  {:10.9f}  {:.5e}'.format(N, quad, error))\n",
            "        ...\n",
            "         2   2.094395102   9.43951e-02\n",
            "         4   1.998570732   1.42927e-03\n",
            "         6   2.000017814   1.78136e-05\n",
            "         8   1.999999835   1.64725e-07\n",
            "        10   2.000000001   1.14677e-09\n",
            "        \n",
            "        Notes\n",
            "        -----\n",
            "        Normally, the Newton-Cotes rules are used on smaller integration\n",
            "        regions and a composite rule is used to return the total integral.\n",
            "    \n",
            "    nquad(func, ranges, args=None, opts=None, full_output=False)\n",
            "        Integration over multiple variables.\n",
            "        \n",
            "        Wraps `quad` to enable integration over multiple variables.\n",
            "        Various options allow improved integration of discontinuous functions, as\n",
            "        well as the use of weighted integration, and generally finer control of the\n",
            "        integration process.\n",
            "        \n",
            "        Parameters\n",
            "        ----------\n",
            "        func : {callable, scipy.LowLevelCallable}\n",
            "            The function to be integrated. Has arguments of ``x0, ... xn``,\n",
            "            ``t0, tm``, where integration is carried out over ``x0, ... xn``, which\n",
            "            must be floats.  Function signature should be\n",
            "            ``func(x0, x1, ..., xn, t0, t1, ..., tm)``.  Integration is carried out\n",
            "            in order.  That is, integration over ``x0`` is the innermost integral,\n",
            "            and ``xn`` is the outermost.\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(int n, double *xx)\n",
            "                double func(int n, double *xx, void *user_data)\n",
            "        \n",
            "            where ``n`` is the number of extra parameters and args is an array\n",
            "            of doubles of the additional parameters, the ``xx`` array contains the\n",
            "            coordinates. The ``user_data`` is the data contained in the\n",
            "            `scipy.LowLevelCallable`.\n",
            "        ranges : iterable object\n",
            "            Each element of ranges may be either a sequence  of 2 numbers, or else\n",
            "            a callable that returns such a sequence.  ``ranges[0]`` corresponds to\n",
            "            integration over x0, and so on.  If an element of ranges is a callable,\n",
            "            then it will be called with all of the integration arguments available,\n",
            "            as well as any parametric arguments. e.g. if\n",
            "            ``func = f(x0, x1, x2, t0, t1)``, then ``ranges[0]`` may be defined as\n",
            "            either ``(a, b)`` or else as ``(a, b) = range0(x1, x2, t0, t1)``.\n",
            "        args : iterable object, optional\n",
            "            Additional arguments ``t0, ..., tn``, required by `func`, `ranges`, and\n",
            "            ``opts``.\n",
            "        opts : iterable object or dict, optional\n",
            "            Options to be passed to `quad`.  May be empty, a dict, or\n",
            "            a sequence of dicts or functions that return a dict.  If empty, the\n",
            "            default options from scipy.integrate.quad are used.  If a dict, the same\n",
            "            options are used for all levels of integraion.  If a sequence, then each\n",
            "            element of the sequence corresponds to a particular integration. e.g.\n",
            "            opts[0] corresponds to integration over x0, and so on. If a callable,\n",
            "            the signature must be the same as for ``ranges``. The available\n",
            "            options together with their default values are:\n",
            "        \n",
            "              - epsabs = 1.49e-08\n",
            "              - epsrel = 1.49e-08\n",
            "              - limit  = 50\n",
            "              - points = None\n",
            "              - weight = None\n",
            "              - wvar   = None\n",
            "              - wopts  = None\n",
            "        \n",
            "            For more information on these options, see `quad` and `quad_explain`.\n",
            "        \n",
            "        full_output : bool, optional\n",
            "            Partial implementation of ``full_output`` from scipy.integrate.quad.\n",
            "            The number of integrand function evaluations ``neval`` can be obtained\n",
            "            by setting ``full_output=True`` when calling nquad.\n",
            "        \n",
            "        Returns\n",
            "        -------\n",
            "        result : float\n",
            "            The result of the integration.\n",
            "        abserr : float\n",
            "            The maximum of the estimates of the absolute error in the various\n",
            "            integration results.\n",
            "        out_dict : dict, optional\n",
            "            A dict containing additional information on the integration.\n",
            "        \n",
            "        See Also\n",
            "        --------\n",
            "        quad : 1-dimensional numerical integration\n",
            "        dblquad, tplquad : double and triple integrals\n",
            "        fixed_quad : fixed-order Gaussian quadrature\n",
            "        quadrature : adaptive Gaussian quadrature\n",
            "        \n",
            "        Examples\n",
            "        --------\n",
            "        >>> from scipy import integrate\n",
            "        >>> func = lambda x0,x1,x2,x3 : x0**2 + x1*x2 - x3**3 + np.sin(x0) + (\n",
            "        ...                                 1 if (x0-.2*x3-.5-.25*x1>0) else 0)\n",
            "        >>> points = [[lambda x1,x2,x3 : 0.2*x3 + 0.5 + 0.25*x1], [], [], []]\n",
            "        >>> def opts0(*args, **kwargs):\n",
            "        ...     return {'points':[0.2*args[2] + 0.5 + 0.25*args[0]]}\n",
            "        >>> integrate.nquad(func, [[0,1], [-1,1], [.13,.8], [-.15,1]],\n",
            "        ...                 opts=[opts0,{},{},{}], full_output=True)\n",
            "        (1.5267454070738633, 2.9437360001402324e-14, {'neval': 388962})\n",
            "        \n",
            "        >>> scale = .1\n",
            "        >>> def func2(x0, x1, x2, x3, t0, t1):\n",
            "        ...     return x0*x1*x3**2 + np.sin(x2) + 1 + (1 if x0+t1*x1-t0>0 else 0)\n",
            "        >>> def lim0(x1, x2, x3, t0, t1):\n",
            "        ...     return [scale * (x1**2 + x2 + np.cos(x3)*t0*t1 + 1) - 1,\n",
            "        ...             scale * (x1**2 + x2 + np.cos(x3)*t0*t1 + 1) + 1]\n",
            "        >>> def lim1(x2, x3, t0, t1):\n",
            "        ...     return [scale * (t0*x2 + t1*x3) - 1,\n",
            "        ...             scale * (t0*x2 + t1*x3) + 1]\n",
            "        >>> def lim2(x3, t0, t1):\n",
            "        ...     return [scale * (x3 + t0**2*t1**3) - 1,\n",
            "        ...             scale * (x3 + t0**2*t1**3) + 1]\n",
            "        >>> def lim3(t0, t1):\n",
            "        ...     return [scale * (t0+t1) - 1, scale * (t0+t1) + 1]\n",
            "        >>> def opts0(x1, x2, x3, t0, t1):\n",
            "        ...     return {'points' : [t0 - t1*x1]}\n",
            "        >>> def opts1(x2, x3, t0, t1):\n",
            "        ...     return {}\n",
            "        >>> def opts2(x3, t0, t1):\n",
            "        ...     return {}\n",
            "        >>> def opts3(t0, t1):\n",
            "        ...     return {}\n",
            "        >>> integrate.nquad(func2, [lim0, lim1, lim2, lim3], args=(0,0),\n",
            "        ...                 opts=[opts0, opts1, opts2, opts3])\n",
            "        (25.066666666666666, 2.7829590483937256e-13)\n",
            "    \n",
            "    odeint(func, y0, t, args=(), Dfun=None, col_deriv=0, full_output=0, ml=None, mu=None, rtol=None, atol=None, tcrit=None, h0=0.0, hmax=0.0, hmin=0.0, ixpr=0, mxstep=0, mxhnil=0, mxordn=12, mxords=5, printmessg=0, tfirst=False)\n",
            "        Integrate a system of ordinary differential equations.\n",
            "        \n",
            "        .. note:: For new code, use `scipy.integrate.solve_ivp` to solve a\n",
            "                  differential equation.\n",
            "        \n",
            "        Solve a system of ordinary differential equations using lsoda from the\n",
            "        FORTRAN library odepack.\n",
            "        \n",
            "        Solves the initial value problem for stiff or non-stiff systems\n",
            "        of first order ode-s::\n",
            "        \n",
            "            dy/dt = func(y, t, ...)  [or func(t, y, ...)]\n",
            "        \n",
            "        where y can be a vector.\n",
            "        \n",
            "        .. note:: By default, the required order of the first two arguments of\n",
            "                  `func` are in the opposite order of the arguments in the system\n",
            "                  definition function used by the `scipy.integrate.ode` class and\n",
            "                  the function `scipy.integrate.solve_ivp`.  To use a function with\n",
            "                  the signature ``func(t, y, ...)``, the argument `tfirst` must be\n",
            "                  set to ``True``.\n",
            "        \n",
            "        Parameters\n",
            "        ----------\n",
            "        func : callable(y, t, ...) or callable(t, y, ...)\n",
            "            Computes the derivative of y at t.\n",
            "            If the signature is ``callable(t, y, ...)``, then the argument\n",
            "            `tfirst` must be set ``True``.\n",
            "        y0 : array\n",
            "            Initial condition on y (can be a vector).\n",
            "        t : array\n",
            "            A sequence of time points for which to solve for y.  The initial\n",
            "            value point should be the first element of this sequence.\n",
            "            This sequence must be monotonically increasing or monotonically\n",
            "            decreasing; repeated values are allowed.\n",
            "        args : tuple, optional\n",
            "            Extra arguments to pass to function.\n",
            "        Dfun : callable(y, t, ...) or callable(t, y, ...)\n",
            "            Gradient (Jacobian) of `func`.\n",
            "            If the signature is ``callable(t, y, ...)``, then the argument\n",
            "            `tfirst` must be set ``True``.\n",
            "        col_deriv : bool, optional\n",
            "            True if `Dfun` defines derivatives down columns (faster),\n",
            "            otherwise `Dfun` should define derivatives across rows.\n",
            "        full_output : bool, optional\n",
            "            True if to return a dictionary of optional outputs as the second output\n",
            "        printmessg : bool, optional\n",
            "            Whether to print the convergence message\n",
            "        tfirst: bool, optional\n",
            "            If True, the first two arguments of `func` (and `Dfun`, if given)\n",
            "            must ``t, y`` instead of the default ``y, t``.\n",
            "        \n",
            "            .. versionadded:: 1.1.0\n",
            "        \n",
            "        Returns\n",
            "        -------\n",
            "        y : array, shape (len(t), len(y0))\n",
            "            Array containing the value of y for each desired time in t,\n",
            "            with the initial value `y0` in the first row.\n",
            "        infodict : dict, only returned if full_output == True\n",
            "            Dictionary containing additional output information\n",
            "        \n",
            "            =======  ============================================================\n",
            "            key      meaning\n",
            "            =======  ============================================================\n",
            "            'hu'     vector of step sizes successfully used for each time step.\n",
            "            'tcur'   vector with the value of t reached for each time step.\n",
            "                     (will always be at least as large as the input times).\n",
            "            'tolsf'  vector of tolerance scale factors, greater than 1.0,\n",
            "                     computed when a request for too much accuracy was detected.\n",
            "            'tsw'    value of t at the time of the last method switch\n",
            "                     (given for each time step)\n",
            "            'nst'    cumulative number of time steps\n",
            "            'nfe'    cumulative number of function evaluations for each time step\n",
            "            'nje'    cumulative number of jacobian evaluations for each time step\n",
            "            'nqu'    a vector of method orders for each successful step.\n",
            "            'imxer'  index of the component of largest magnitude in the\n",
            "                     weighted local error vector (e / ewt) on an error return, -1\n",
            "                     otherwise.\n",
            "            'lenrw'  the length of the double work array required.\n",
            "            'leniw'  the length of integer work array required.\n",
            "            'mused'  a vector of method indicators for each successful time step:\n",
            "                     1: adams (nonstiff), 2: bdf (stiff)\n",
            "            =======  ============================================================\n",
            "        \n",
            "        Other Parameters\n",
            "        ----------------\n",
            "        ml, mu : int, optional\n",
            "            If either of these are not None or non-negative, then the\n",
            "            Jacobian is assumed to be banded.  These give the number of\n",
            "            lower and upper non-zero diagonals in this banded matrix.\n",
            "            For the banded case, `Dfun` should return a matrix whose\n",
            "            rows contain the non-zero bands (starting with the lowest diagonal).\n",
            "            Thus, the return matrix `jac` from `Dfun` should have shape\n",
            "            ``(ml + mu + 1, len(y0))`` when ``ml >=0`` or ``mu >=0``.\n",
            "            The data in `jac` must be stored such that ``jac[i - j + mu, j]``\n",
            "            holds the derivative of the `i`th equation with respect to the `j`th\n",
            "            state variable.  If `col_deriv` is True, the transpose of this\n",
            "            `jac` must be returned.\n",
            "        rtol, atol : float, optional\n",
            "            The input parameters `rtol` and `atol` determine the error\n",
            "            control performed by the solver.  The solver will control the\n",
            "            vector, e, of estimated local errors in y, according to an\n",
            "            inequality of the form ``max-norm of (e / ewt) <= 1``,\n",
            "            where ewt is a vector of positive error weights computed as\n",
            "            ``ewt = rtol * abs(y) + atol``.\n",
            "            rtol and atol can be either vectors the same length as y or scalars.\n",
            "            Defaults to 1.49012e-8.\n",
            "        tcrit : ndarray, optional\n",
            "            Vector of critical points (e.g. singularities) where integration\n",
            "            care should be taken.\n",
            "        h0 : float, (0: solver-determined), optional\n",
            "            The step size to be attempted on the first step.\n",
            "        hmax : float, (0: solver-determined), optional\n",
            "            The maximum absolute step size allowed.\n",
            "        hmin : float, (0: solver-determined), optional\n",
            "            The minimum absolute step size allowed.\n",
            "        ixpr : bool, optional\n",
            "            Whether to generate extra printing at method switches.\n",
            "        mxstep : int, (0: solver-determined), optional\n",
            "            Maximum number of (internally defined) steps allowed for each\n",
            "            integration point in t.\n",
            "        mxhnil : int, (0: solver-determined), optional\n",
            "            Maximum number of messages printed.\n",
            "        mxordn : int, (0: solver-determined), optional\n",
            "            Maximum order to be allowed for the non-stiff (Adams) method.\n",
            "        mxords : int, (0: solver-determined), optional\n",
            "            Maximum order to be allowed for the stiff (BDF) method.\n",
            "        \n",
            "        See Also\n",
            "        --------\n",
            "        solve_ivp : Solve an initial value problem for a system of ODEs.\n",
            "        ode : a more object-oriented integrator based on VODE.\n",
            "        quad : for finding the area under a curve.\n",
            "        \n",
            "        Examples\n",
            "        --------\n",
            "        The second order differential equation for the angle `theta` of a\n",
            "        pendulum acted on by gravity with friction can be written::\n",
            "        \n",
            "            theta''(t) + b*theta'(t) + c*sin(theta(t)) = 0\n",
            "        \n",
            "        where `b` and `c` are positive constants, and a prime (') denotes a\n",
            "        derivative.  To solve this equation with `odeint`, we must first convert\n",
            "        it to a system of first order equations.  By defining the angular\n",
            "        velocity ``omega(t) = theta'(t)``, we obtain the system::\n",
            "        \n",
            "            theta'(t) = omega(t)\n",
            "            omega'(t) = -b*omega(t) - c*sin(theta(t))\n",
            "        \n",
            "        Let `y` be the vector [`theta`, `omega`].  We implement this system\n",
            "        in python as:\n",
            "        \n",
            "        >>> def pend(y, t, b, c):\n",
            "        ...     theta, omega = y\n",
            "        ...     dydt = [omega, -b*omega - c*np.sin(theta)]\n",
            "        ...     return dydt\n",
            "        ...\n",
            "        \n",
            "        We assume the constants are `b` = 0.25 and `c` = 5.0:\n",
            "        \n",
            "        >>> b = 0.25\n",
            "        >>> c = 5.0\n",
            "        \n",
            "        For initial conditions, we assume the pendulum is nearly vertical\n",
            "        with `theta(0)` = `pi` - 0.1, and is initially at rest, so\n",
            "        `omega(0)` = 0.  Then the vector of initial conditions is\n",
            "        \n",
            "        >>> y0 = [np.pi - 0.1, 0.0]\n",
            "        \n",
            "        We will generate a solution at 101 evenly spaced samples in the interval\n",
            "        0 <= `t` <= 10.  So our array of times is:\n",
            "        \n",
            "        >>> t = np.linspace(0, 10, 101)\n",
            "        \n",
            "        Call `odeint` to generate the solution.  To pass the parameters\n",
            "        `b` and `c` to `pend`, we give them to `odeint` using the `args`\n",
            "        argument.\n",
            "        \n",
            "        >>> from scipy.integrate import odeint\n",
            "        >>> sol = odeint(pend, y0, t, args=(b, c))\n",
            "        \n",
            "        The solution is an array with shape (101, 2).  The first column\n",
            "        is `theta(t)`, and the second is `omega(t)`.  The following code\n",
            "        plots both components.\n",
            "        \n",
            "        >>> import matplotlib.pyplot as plt\n",
            "        >>> plt.plot(t, sol[:, 0], 'b', label='theta(t)')\n",
            "        >>> plt.plot(t, sol[:, 1], 'g', label='omega(t)')\n",
            "        >>> plt.legend(loc='best')\n",
            "        >>> plt.xlabel('t')\n",
            "        >>> plt.grid()\n",
            "        >>> plt.show()\n",
            "    \n",
            "    quad(func, a, b, args=(), full_output=0, epsabs=1.49e-08, epsrel=1.49e-08, limit=50, points=None, weight=None, wvar=None, wopts=None, maxp1=50, limlst=50)\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. Note that this option cannot be used in conjunction\n",
            "            with ``weight``.\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, and these do not support specifying break points. The\n",
            "        possible values of weight and the corresponding 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",
            "    \n",
            "    quad_explain(output=<ipykernel.iostream.OutStream object at 0x7fc46dcf79e8>)\n",
            "        Print extra information about integrate.quad() parameters and returns.\n",
            "        \n",
            "        Parameters\n",
            "        ----------\n",
            "        output : instance with \"write\" method, optional\n",
            "            Information about `quad` is passed to ``output.write()``.\n",
            "            Default is ``sys.stdout``.\n",
            "        \n",
            "        Returns\n",
            "        -------\n",
            "        None\n",
            "    \n",
            "    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)\n",
            "        Adaptive integration of a vector-valued function.\n",
            "        \n",
            "        Parameters\n",
            "        ----------\n",
            "        f : callable\n",
            "            Vector-valued function f(x) to integrate.\n",
            "        a : float\n",
            "            Initial point.\n",
            "        b : float\n",
            "            Final point.\n",
            "        epsabs : float, optional\n",
            "            Absolute tolerance.\n",
            "        epsrel : float, optional\n",
            "            Relative tolerance.\n",
            "        norm : {'max', '2'}, optional\n",
            "            Vector norm to use for error estimation.\n",
            "        cache_size : int, optional\n",
            "            Number of bytes to use for memoization.\n",
            "        workers : int or map-like callable, optional\n",
            "            If `workers` is an integer, part of the computation is done in\n",
            "            parallel subdivided to this many tasks (using\n",
            "            :class:`python:multiprocessing.pool.Pool`).\n",
            "            Supply `-1` to use all cores available to the Process.\n",
            "            Alternatively, supply a map-like callable, such as\n",
            "            :meth:`python:multiprocessing.pool.Pool.map` for evaluating the\n",
            "            population in parallel.\n",
            "            This evaluation is carried out as ``workers(func, iterable)``.\n",
            "        points : list, optional\n",
            "            List of additional breakpoints.\n",
            "        quadrature : {'gk21', 'gk15', 'trapz'}, optional\n",
            "            Quadrature rule to use on subintervals.\n",
            "            Options: 'gk21' (Gauss-Kronrod 21-point rule),\n",
            "            'gk15' (Gauss-Kronrod 15-point rule),\n",
            "            'trapz' (composite trapezoid rule).\n",
            "            Default: 'gk21' for finite intervals and 'gk15' for (semi-)infinite\n",
            "        full_output : bool, optional\n",
            "            Return an additional ``info`` dictionary.\n",
            "        \n",
            "        Returns\n",
            "        -------\n",
            "        res : {float, array-like}\n",
            "            Estimate for the result\n",
            "        err : float\n",
            "            Error estimate for the result in the given norm\n",
            "        info : dict\n",
            "            Returned only when ``full_output=True``.\n",
            "            Info dictionary. Is an object with the attributes:\n",
            "        \n",
            "                success : bool\n",
            "                    Whether integration reached target precision.\n",
            "                status : int\n",
            "                    Indicator for convergence, success (0),\n",
            "                    failure (1), and failure due to rounding error (2).\n",
            "                neval : int\n",
            "                    Number of function evaluations.\n",
            "                intervals : ndarray, shape (num_intervals, 2)\n",
            "                    Start and end points of subdivision intervals.\n",
            "                integrals : ndarray, shape (num_intervals, ...)\n",
            "                    Integral for each interval.\n",
            "                    Note that at most ``cache_size`` values are recorded,\n",
            "                    and the array may contains *nan* for missing items.\n",
            "                errors : ndarray, shape (num_intervals,)\n",
            "                    Estimated integration error for each interval.\n",
            "        \n",
            "        Notes\n",
            "        -----\n",
            "        The algorithm mainly follows the implementation of QUADPACK's\n",
            "        DQAG* algorithms, implementing global error control and adaptive\n",
            "        subdivision.\n",
            "        \n",
            "        The algorithm here has some differences to the QUADPACK approach:\n",
            "        \n",
            "        Instead of subdividing one interval at a time, the algorithm\n",
            "        subdivides N intervals with largest errors at once. This enables\n",
            "        (partial) parallelization of the integration.\n",
            "        \n",
            "        The logic of subdividing \"next largest\" intervals first is then\n",
            "        not implemented, and we rely on the above extension to avoid\n",
            "        concentrating on \"small\" intervals only.\n",
            "        \n",
            "        The Wynn epsilon table extrapolation is not used (QUADPACK uses it\n",
            "        for infinite intervals). This is because the algorithm here is\n",
            "        supposed to work on vector-valued functions, in an user-specified\n",
            "        norm, and the extension of the epsilon algorithm to this case does\n",
            "        not appear to be widely agreed.  For max-norm, using elementwise\n",
            "        Wynn epsilon could be possible, but we do not do this here with\n",
            "        the hope that the epsilon extrapolation is mainly useful in\n",
            "        special cases.\n",
            "        \n",
            "        References\n",
            "        ----------\n",
            "        [1] R. Piessens, E. de Doncker, QUADPACK (1983).\n",
            "    \n",
            "    quadrature(func, a, b, args=(), tol=1.49e-08, rtol=1.49e-08, maxiter=50, vec_func=True, miniter=1)\n",
            "        Compute a definite integral using fixed-tolerance Gaussian quadrature.\n",
            "        \n",
            "        Integrate `func` from `a` to `b` using Gaussian quadrature\n",
            "        with absolute tolerance `tol`.\n",
            "        \n",
            "        Parameters\n",
            "        ----------\n",
            "        func : function\n",
            "            A Python function or method to integrate.\n",
            "        a : float\n",
            "            Lower limit of integration.\n",
            "        b : float\n",
            "            Upper limit of integration.\n",
            "        args : tuple, optional\n",
            "            Extra arguments to pass to function.\n",
            "        tol, rtol : float, optional\n",
            "            Iteration stops when error between last two iterates is less than\n",
            "            `tol` OR the relative change is less than `rtol`.\n",
            "        maxiter : int, optional\n",
            "            Maximum order of Gaussian quadrature.\n",
            "        vec_func : bool, optional\n",
            "            True or False if func handles arrays as arguments (is\n",
            "            a \"vector\" function). Default is True.\n",
            "        miniter : int, optional\n",
            "            Minimum order of Gaussian quadrature.\n",
            "        \n",
            "        Returns\n",
            "        -------\n",
            "        val : float\n",
            "            Gaussian quadrature approximation (within tolerance) to integral.\n",
            "        err : float\n",
            "            Difference between last two estimates of the integral.\n",
            "        \n",
            "        See also\n",
            "        --------\n",
            "        romberg: adaptive Romberg quadrature\n",
            "        fixed_quad: fixed-order Gaussian quadrature\n",
            "        quad: adaptive quadrature using QUADPACK\n",
            "        dblquad: double integrals\n",
            "        tplquad: triple integrals\n",
            "        romb: integrator for sampled data\n",
            "        simps: integrator for sampled data\n",
            "        cumtrapz: cumulative integration for sampled data\n",
            "        ode: ODE integrator\n",
            "        odeint: ODE integrator\n",
            "        \n",
            "        Examples\n",
            "        --------\n",
            "        >>> from scipy import integrate\n",
            "        >>> f = lambda x: x**8\n",
            "        >>> integrate.quadrature(f, 0.0, 1.0)\n",
            "        (0.11111111111111106, 4.163336342344337e-17)\n",
            "        >>> print(1/9.0)  # analytical result\n",
            "        0.1111111111111111\n",
            "        \n",
            "        >>> integrate.quadrature(np.cos, 0.0, np.pi/2)\n",
            "        (0.9999999999999536, 3.9611425250996035e-11)\n",
            "        >>> np.sin(np.pi/2)-np.sin(0)  # analytical result\n",
            "        1.0\n",
            "    \n",
            "    romb(y, dx=1.0, axis=-1, show=False)\n",
            "        Romberg integration using samples of a function.\n",
            "        \n",
            "        Parameters\n",
            "        ----------\n",
            "        y : array_like\n",
            "            A vector of ``2**k + 1`` equally-spaced samples of a function.\n",
            "        dx : float, optional\n",
            "            The sample spacing. Default is 1.\n",
            "        axis : int, optional\n",
            "            The axis along which to integrate. Default is -1 (last axis).\n",
            "        show : bool, optional\n",
            "            When `y` is a single 1-D array, then if this argument is True\n",
            "            print the table showing Richardson extrapolation from the\n",
            "            samples. Default is False.\n",
            "        \n",
            "        Returns\n",
            "        -------\n",
            "        romb : ndarray\n",
            "            The integrated result for `axis`.\n",
            "        \n",
            "        See also\n",
            "        --------\n",
            "        quad : adaptive quadrature using QUADPACK\n",
            "        romberg : adaptive Romberg quadrature\n",
            "        quadrature : adaptive Gaussian quadrature\n",
            "        fixed_quad : fixed-order Gaussian quadrature\n",
            "        dblquad : double integrals\n",
            "        tplquad : triple integrals\n",
            "        simps : integrators for sampled data\n",
            "        cumtrapz : cumulative integration for sampled data\n",
            "        ode : ODE integrators\n",
            "        odeint : ODE integrators\n",
            "        \n",
            "        Examples\n",
            "        --------\n",
            "        >>> from scipy import integrate\n",
            "        >>> x = np.arange(10, 14.25, 0.25)\n",
            "        >>> y = np.arange(3, 12)\n",
            "        \n",
            "        >>> integrate.romb(y)\n",
            "        56.0\n",
            "        \n",
            "        >>> y = np.sin(np.power(x, 2.5))\n",
            "        >>> integrate.romb(y)\n",
            "        -0.742561336672229\n",
            "        \n",
            "        >>> integrate.romb(y, show=True)\n",
            "        Richardson Extrapolation Table for Romberg Integration\n",
            "        ====================================================================\n",
            "        -0.81576\n",
            "        4.63862  6.45674\n",
            "        -1.10581 -3.02062 -3.65245\n",
            "        -2.57379 -3.06311 -3.06595 -3.05664\n",
            "        -1.34093 -0.92997 -0.78776 -0.75160 -0.74256\n",
            "        ====================================================================\n",
            "        -0.742561336672229\n",
            "    \n",
            "    romberg(function, a, b, args=(), tol=1.48e-08, rtol=1.48e-08, show=False, divmax=10, vec_func=False)\n",
            "        Romberg integration of a callable function or method.\n",
            "        \n",
            "        Returns the integral of `function` (a function of one variable)\n",
            "        over the interval (`a`, `b`).\n",
            "        \n",
            "        If `show` is 1, the triangular array of the intermediate results\n",
            "        will be printed.  If `vec_func` is True (default is False), then\n",
            "        `function` is assumed to support vector arguments.\n",
            "        \n",
            "        Parameters\n",
            "        ----------\n",
            "        function : callable\n",
            "            Function to be integrated.\n",
            "        a : float\n",
            "            Lower limit of integration.\n",
            "        b : float\n",
            "            Upper limit of integration.\n",
            "        \n",
            "        Returns\n",
            "        -------\n",
            "        results  : float\n",
            "            Result of the integration.\n",
            "        \n",
            "        Other Parameters\n",
            "        ----------------\n",
            "        args : tuple, optional\n",
            "            Extra arguments to pass to function. Each element of `args` will\n",
            "            be passed as a single argument to `func`. Default is to pass no\n",
            "            extra arguments.\n",
            "        tol, rtol : float, optional\n",
            "            The desired absolute and relative tolerances. Defaults are 1.48e-8.\n",
            "        show : bool, optional\n",
            "            Whether to print the results. Default is False.\n",
            "        divmax : int, optional\n",
            "            Maximum order of extrapolation. Default is 10.\n",
            "        vec_func : bool, optional\n",
            "            Whether `func` handles arrays as arguments (i.e whether it is a\n",
            "            \"vector\" function). Default is False.\n",
            "        \n",
            "        See Also\n",
            "        --------\n",
            "        fixed_quad : Fixed-order Gaussian quadrature.\n",
            "        quad : Adaptive quadrature using QUADPACK.\n",
            "        dblquad : Double integrals.\n",
            "        tplquad : Triple integrals.\n",
            "        romb : Integrators for sampled data.\n",
            "        simps : Integrators for sampled data.\n",
            "        cumtrapz : Cumulative integration for sampled data.\n",
            "        ode : ODE integrator.\n",
            "        odeint : ODE integrator.\n",
            "        \n",
            "        References\n",
            "        ----------\n",
            "        .. [1] 'Romberg's method' https://en.wikipedia.org/wiki/Romberg%27s_method\n",
            "        \n",
            "        Examples\n",
            "        --------\n",
            "        Integrate a gaussian from 0 to 1 and compare to the error function.\n",
            "        \n",
            "        >>> from scipy import integrate\n",
            "        >>> from scipy.special import erf\n",
            "        >>> gaussian = lambda x: 1/np.sqrt(np.pi) * np.exp(-x**2)\n",
            "        >>> result = integrate.romberg(gaussian, 0, 1, show=True)\n",
            "        Romberg integration of <function vfunc at ...> from [0, 1]\n",
            "        \n",
            "        ::\n",
            "        \n",
            "           Steps  StepSize  Results\n",
            "               1  1.000000  0.385872\n",
            "               2  0.500000  0.412631  0.421551\n",
            "               4  0.250000  0.419184  0.421368  0.421356\n",
            "               8  0.125000  0.420810  0.421352  0.421350  0.421350\n",
            "              16  0.062500  0.421215  0.421350  0.421350  0.421350  0.421350\n",
            "              32  0.031250  0.421317  0.421350  0.421350  0.421350  0.421350  0.421350\n",
            "        \n",
            "        The final result is 0.421350396475 after 33 function evaluations.\n",
            "        \n",
            "        >>> print(\"%g %g\" % (2*result, erf(1)))\n",
            "        0.842701 0.842701\n",
            "    \n",
            "    simps(y, x=None, dx=1, axis=-1, even='avg')\n",
            "        Integrate y(x) using samples along the given axis and the composite\n",
            "        Simpson's rule.  If x is None, spacing of dx is assumed.\n",
            "        \n",
            "        If there are an even number of samples, N, then there are an odd\n",
            "        number of intervals (N-1), but Simpson's rule requires an even number\n",
            "        of intervals.  The parameter 'even' controls how this is handled.\n",
            "        \n",
            "        Parameters\n",
            "        ----------\n",
            "        y : array_like\n",
            "            Array to be integrated.\n",
            "        x : array_like, optional\n",
            "            If given, the points at which `y` is sampled.\n",
            "        dx : int, optional\n",
            "            Spacing of integration points along axis of `y`. Only used when\n",
            "            `x` is None. Default is 1.\n",
            "        axis : int, optional\n",
            "            Axis along which to integrate. Default is the last axis.\n",
            "        even : str {'avg', 'first', 'last'}, optional\n",
            "            'avg' : Average two results:1) use the first N-2 intervals with\n",
            "                      a trapezoidal rule on the last interval and 2) use the last\n",
            "                      N-2 intervals with a trapezoidal rule on the first interval.\n",
            "        \n",
            "            'first' : Use Simpson's rule for the first N-2 intervals with\n",
            "                    a trapezoidal rule on the last interval.\n",
            "        \n",
            "            'last' : Use Simpson's rule for the last N-2 intervals with a\n",
            "                   trapezoidal rule on the first interval.\n",
            "        \n",
            "        See Also\n",
            "        --------\n",
            "        quad: adaptive quadrature using QUADPACK\n",
            "        romberg: adaptive Romberg quadrature\n",
            "        quadrature: adaptive Gaussian quadrature\n",
            "        fixed_quad: fixed-order Gaussian quadrature\n",
            "        dblquad: double integrals\n",
            "        tplquad: triple integrals\n",
            "        romb: integrators for sampled data\n",
            "        cumtrapz: cumulative integration for sampled data\n",
            "        ode: ODE integrators\n",
            "        odeint: ODE integrators\n",
            "        \n",
            "        Notes\n",
            "        -----\n",
            "        For an odd number of samples that are equally spaced the result is\n",
            "        exact if the function is a polynomial of order 3 or less.  If\n",
            "        the samples are not equally spaced, then the result is exact only\n",
            "        if the function is a polynomial of order 2 or less.\n",
            "        \n",
            "        Examples\n",
            "        --------\n",
            "        >>> from scipy import integrate\n",
            "        >>> x = np.arange(0, 10)\n",
            "        >>> y = np.arange(0, 10)\n",
            "        \n",
            "        >>> integrate.simps(y, x)\n",
            "        40.5\n",
            "        \n",
            "        >>> y = np.power(x, 3)\n",
            "        >>> integrate.simps(y, x)\n",
            "        1642.5\n",
            "        >>> integrate.quad(lambda x: x**3, 0, 9)[0]\n",
            "        1640.25\n",
            "        \n",
            "        >>> integrate.simps(y, x, even='first')\n",
            "        1644.5\n",
            "    \n",
            "    solve_bvp(fun, bc, x, y, p=None, S=None, fun_jac=None, bc_jac=None, tol=0.001, max_nodes=1000, verbose=0, bc_tol=None)\n",
            "        Solve a boundary-value problem for a system of ODEs.\n",
            "        \n",
            "        This function numerically solves a first order system of ODEs subject to\n",
            "        two-point boundary conditions::\n",
            "        \n",
            "            dy / dx = f(x, y, p) + S * y / (x - a), a <= x <= b\n",
            "            bc(y(a), y(b), p) = 0\n",
            "        \n",
            "        Here x is a 1-dimensional independent variable, y(x) is a n-dimensional\n",
            "        vector-valued function and p is a k-dimensional vector of unknown\n",
            "        parameters which is to be found along with y(x). For the problem to be\n",
            "        determined there must be n + k boundary conditions, i.e. bc must be\n",
            "        (n + k)-dimensional function.\n",
            "        \n",
            "        The last singular term in the right-hand side of the system is optional.\n",
            "        It is defined by an n-by-n matrix S, such that the solution must satisfy\n",
            "        S y(a) = 0. This condition will be forced during iterations, so it must not\n",
            "        contradict boundary conditions. See [2]_ for the explanation how this term\n",
            "        is handled when solving BVPs numerically.\n",
            "        \n",
            "        Problems in a complex domain can be solved as well. In this case y and p\n",
            "        are considered to be complex, and f and bc are assumed to be complex-valued\n",
            "        functions, but x stays real. Note that f and bc must be complex\n",
            "        differentiable (satisfy Cauchy-Riemann equations [4]_), otherwise you\n",
            "        should rewrite your problem for real and imaginary parts separately. To\n",
            "        solve a problem in a complex domain, pass an initial guess for y with a\n",
            "        complex data type (see below).\n",
            "        \n",
            "        Parameters\n",
            "        ----------\n",
            "        fun : callable\n",
            "            Right-hand side of the system. The calling signature is ``fun(x, y)``,\n",
            "            or ``fun(x, y, p)`` if parameters are present. All arguments are\n",
            "            ndarray: ``x`` with shape (m,), ``y`` with shape (n, m), meaning that\n",
            "            ``y[:, i]`` corresponds to ``x[i]``, and ``p`` with shape (k,). The\n",
            "            return value must be an array with shape (n, m) and with the same\n",
            "            layout as ``y``.\n",
            "        bc : callable\n",
            "            Function evaluating residuals of the boundary conditions. The calling\n",
            "            signature is ``bc(ya, yb)``, or ``bc(ya, yb, p)`` if parameters are\n",
            "            present. All arguments are ndarray: ``ya`` and ``yb`` with shape (n,),\n",
            "            and ``p`` with shape (k,). The return value must be an array with\n",
            "            shape (n + k,).\n",
            "        x : array_like, shape (m,)\n",
            "            Initial mesh. Must be a strictly increasing sequence of real numbers\n",
            "            with ``x[0]=a`` and ``x[-1]=b``.\n",
            "        y : array_like, shape (n, m)\n",
            "            Initial guess for the function values at the mesh nodes, i-th column\n",
            "            corresponds to ``x[i]``. For problems in a complex domain pass `y`\n",
            "            with a complex data type (even if the initial guess is purely real).\n",
            "        p : array_like with shape (k,) or None, optional\n",
            "            Initial guess for the unknown parameters. If None (default), it is\n",
            "            assumed that the problem doesn't depend on any parameters.\n",
            "        S : array_like with shape (n, n) or None\n",
            "            Matrix defining the singular term. If None (default), the problem is\n",
            "            solved without the singular term.\n",
            "        fun_jac : callable or None, optional\n",
            "            Function computing derivatives of f with respect to y and p. The\n",
            "            calling signature is ``fun_jac(x, y)``, or ``fun_jac(x, y, p)`` if\n",
            "            parameters are present. The return must contain 1 or 2 elements in the\n",
            "            following order:\n",
            "        \n",
            "                * df_dy : array_like with shape (n, n, m) where an element\n",
            "                  (i, j, q) equals to d f_i(x_q, y_q, p) / d (y_q)_j.\n",
            "                * df_dp : array_like with shape (n, k, m) where an element\n",
            "                  (i, j, q) equals to d f_i(x_q, y_q, p) / d p_j.\n",
            "        \n",
            "            Here q numbers nodes at which x and y are defined, whereas i and j\n",
            "            number vector components. If the problem is solved without unknown\n",
            "            parameters df_dp should not be returned.\n",
            "        \n",
            "            If `fun_jac` is None (default), the derivatives will be estimated\n",
            "            by the forward finite differences.\n",
            "        bc_jac : callable or None, optional\n",
            "            Function computing derivatives of bc with respect to ya, yb and p.\n",
            "            The calling signature is ``bc_jac(ya, yb)``, or ``bc_jac(ya, yb, p)``\n",
            "            if parameters are present. The return must contain 2 or 3 elements in\n",
            "            the following order:\n",
            "        \n",
            "                * dbc_dya : array_like with shape (n, n) where an element (i, j)\n",
            "                  equals to d bc_i(ya, yb, p) / d ya_j.\n",
            "                * dbc_dyb : array_like with shape (n, n) where an element (i, j)\n",
            "                  equals to d bc_i(ya, yb, p) / d yb_j.\n",
            "                * dbc_dp : array_like with shape (n, k) where an element (i, j)\n",
            "                  equals to d bc_i(ya, yb, p) / d p_j.\n",
            "        \n",
            "            If the problem is solved without unknown parameters dbc_dp should not\n",
            "            be returned.\n",
            "        \n",
            "            If `bc_jac` is None (default), the derivatives will be estimated by\n",
            "            the forward finite differences.\n",
            "        tol : float, optional\n",
            "            Desired tolerance of the solution. If we define ``r = y' - f(x, y)``\n",
            "            where y is the found solution, then the solver tries to achieve on each\n",
            "            mesh interval ``norm(r / (1 + abs(f)) < tol``, where ``norm`` is\n",
            "            estimated in a root mean squared sense (using a numerical quadrature\n",
            "            formula). Default is 1e-3.\n",
            "        max_nodes : int, optional\n",
            "            Maximum allowed number of the mesh nodes. If exceeded, the algorithm\n",
            "            terminates. Default is 1000.\n",
            "        verbose : {0, 1, 2}, optional\n",
            "            Level of algorithm's verbosity:\n",
            "        \n",
            "                * 0 (default) : work silently.\n",
            "                * 1 : display a termination report.\n",
            "                * 2 : display progress during iterations.\n",
            "        bc_tol : float, optional\n",
            "            Desired absolute tolerance for the boundary condition residuals: `bc` \n",
            "            value should satisfy ``abs(bc) < bc_tol`` component-wise. \n",
            "            Equals to `tol` by default. Up to 10 iterations are allowed to achieve this\n",
            "            tolerance.\n",
            "        \n",
            "        Returns\n",
            "        -------\n",
            "        Bunch object with the following fields defined:\n",
            "        sol : PPoly\n",
            "            Found solution for y as `scipy.interpolate.PPoly` instance, a C1\n",
            "            continuous cubic spline.\n",
            "        p : ndarray or None, shape (k,)\n",
            "            Found parameters. None, if the parameters were not present in the\n",
            "            problem.\n",
            "        x : ndarray, shape (m,)\n",
            "            Nodes of the final mesh.\n",
            "        y : ndarray, shape (n, m)\n",
            "            Solution values at the mesh nodes.\n",
            "        yp : ndarray, shape (n, m)\n",
            "            Solution derivatives at the mesh nodes.\n",
            "        rms_residuals : ndarray, shape (m - 1,)\n",
            "            RMS values of the relative residuals over each mesh interval (see the\n",
            "            description of `tol` parameter).\n",
            "        niter : int\n",
            "            Number of completed iterations.\n",
            "        status : int\n",
            "            Reason for algorithm termination:\n",
            "        \n",
            "                * 0: The algorithm converged to the desired accuracy.\n",
            "                * 1: The maximum number of mesh nodes is exceeded.\n",
            "                * 2: A singular Jacobian encountered when solving the collocation\n",
            "                  system.\n",
            "        \n",
            "        message : string\n",
            "            Verbal description of the termination reason.\n",
            "        success : bool\n",
            "            True if the algorithm converged to the desired accuracy (``status=0``).\n",
            "        \n",
            "        Notes\n",
            "        -----\n",
            "        This function implements a 4-th order collocation algorithm with the\n",
            "        control of residuals similar to [1]_. A collocation system is solved\n",
            "        by a damped Newton method with an affine-invariant criterion function as\n",
            "        described in [3]_.\n",
            "        \n",
            "        Note that in [1]_  integral residuals are defined without normalization\n",
            "        by interval lengths. So their definition is different by a multiplier of\n",
            "        h**0.5 (h is an interval length) from the definition used here.\n",
            "        \n",
            "        .. versionadded:: 0.18.0\n",
            "        \n",
            "        References\n",
            "        ----------\n",
            "        .. [1] J. Kierzenka, L. F. Shampine, \"A BVP Solver Based on Residual\n",
            "               Control and the Maltab PSE\", ACM Trans. Math. Softw., Vol. 27,\n",
            "               Number 3, pp. 299-316, 2001.\n",
            "        .. [2] L.F. Shampine, P. H. Muir and H. Xu, \"A User-Friendly Fortran BVP\n",
            "               Solver\".\n",
            "        .. [3] U. Ascher, R. Mattheij and R. Russell \"Numerical Solution of\n",
            "               Boundary Value Problems for Ordinary Differential Equations\".\n",
            "        .. [4] `Cauchy-Riemann equations\n",
            "                <https://en.wikipedia.org/wiki/Cauchy-Riemann_equations>`_ on\n",
            "                Wikipedia.\n",
            "        \n",
            "        Examples\n",
            "        --------\n",
            "        In the first example we solve Bratu's problem::\n",
            "        \n",
            "            y'' + k * exp(y) = 0\n",
            "            y(0) = y(1) = 0\n",
            "        \n",
            "        for k = 1.\n",
            "        \n",
            "        We rewrite the equation as a first order system and implement its\n",
            "        right-hand side evaluation::\n",
            "        \n",
            "            y1' = y2\n",
            "            y2' = -exp(y1)\n",
            "        \n",
            "        >>> def fun(x, y):\n",
            "        ...     return np.vstack((y[1], -np.exp(y[0])))\n",
            "        \n",
            "        Implement evaluation of the boundary condition residuals:\n",
            "        \n",
            "        >>> def bc(ya, yb):\n",
            "        ...     return np.array([ya[0], yb[0]])\n",
            "        \n",
            "        Define the initial mesh with 5 nodes:\n",
            "        \n",
            "        >>> x = np.linspace(0, 1, 5)\n",
            "        \n",
            "        This problem is known to have two solutions. To obtain both of them we\n",
            "        use two different initial guesses for y. We denote them by subscripts\n",
            "        a and b.\n",
            "        \n",
            "        >>> y_a = np.zeros((2, x.size))\n",
            "        >>> y_b = np.zeros((2, x.size))\n",
            "        >>> y_b[0] = 3\n",
            "        \n",
            "        Now we are ready to run the solver.\n",
            "        \n",
            "        >>> from scipy.integrate import solve_bvp\n",
            "        >>> res_a = solve_bvp(fun, bc, x, y_a)\n",
            "        >>> res_b = solve_bvp(fun, bc, x, y_b)\n",
            "        \n",
            "        Let's plot the two found solutions. We take an advantage of having the\n",
            "        solution in a spline form to produce a smooth plot.\n",
            "        \n",
            "        >>> x_plot = np.linspace(0, 1, 100)\n",
            "        >>> y_plot_a = res_a.sol(x_plot)[0]\n",
            "        >>> y_plot_b = res_b.sol(x_plot)[0]\n",
            "        >>> import matplotlib.pyplot as plt\n",
            "        >>> plt.plot(x_plot, y_plot_a, label='y_a')\n",
            "        >>> plt.plot(x_plot, y_plot_b, label='y_b')\n",
            "        >>> plt.legend()\n",
            "        >>> plt.xlabel(\"x\")\n",
            "        >>> plt.ylabel(\"y\")\n",
            "        >>> plt.show()\n",
            "        \n",
            "        We see that the two solutions have similar shape, but differ in scale\n",
            "        significantly.\n",
            "        \n",
            "        In the second example we solve a simple Sturm-Liouville problem::\n",
            "        \n",
            "            y'' + k**2 * y = 0\n",
            "            y(0) = y(1) = 0\n",
            "        \n",
            "        It is known that a non-trivial solution y = A * sin(k * x) is possible for\n",
            "        k = pi * n, where n is an integer. To establish the normalization constant\n",
            "        A = 1 we add a boundary condition::\n",
            "        \n",
            "            y'(0) = k\n",
            "        \n",
            "        Again we rewrite our equation as a first order system and implement its\n",
            "        right-hand side evaluation::\n",
            "        \n",
            "            y1' = y2\n",
            "            y2' = -k**2 * y1\n",
            "        \n",
            "        >>> def fun(x, y, p):\n",
            "        ...     k = p[0]\n",
            "        ...     return np.vstack((y[1], -k**2 * y[0]))\n",
            "        \n",
            "        Note that parameters p are passed as a vector (with one element in our\n",
            "        case).\n",
            "        \n",
            "        Implement the boundary conditions:\n",
            "        \n",
            "        >>> def bc(ya, yb, p):\n",
            "        ...     k = p[0]\n",
            "        ...     return np.array([ya[0], yb[0], ya[1] - k])\n",
            "        \n",
            "        Setup the initial mesh and guess for y. We aim to find the solution for\n",
            "        k = 2 * pi, to achieve that we set values of y to approximately follow\n",
            "        sin(2 * pi * x):\n",
            "        \n",
            "        >>> x = np.linspace(0, 1, 5)\n",
            "        >>> y = np.zeros((2, x.size))\n",
            "        >>> y[0, 1] = 1\n",
            "        >>> y[0, 3] = -1\n",
            "        \n",
            "        Run the solver with 6 as an initial guess for k.\n",
            "        \n",
            "        >>> sol = solve_bvp(fun, bc, x, y, p=[6])\n",
            "        \n",
            "        We see that the found k is approximately correct:\n",
            "        \n",
            "        >>> sol.p[0]\n",
            "        6.28329460046\n",
            "        \n",
            "        And finally plot the solution to see the anticipated sinusoid:\n",
            "        \n",
            "        >>> x_plot = np.linspace(0, 1, 100)\n",
            "        >>> y_plot = sol.sol(x_plot)[0]\n",
            "        >>> plt.plot(x_plot, y_plot)\n",
            "        >>> plt.xlabel(\"x\")\n",
            "        >>> plt.ylabel(\"y\")\n",
            "        >>> plt.show()\n",
            "    \n",
            "    solve_ivp(fun, t_span, y0, method='RK45', t_eval=None, dense_output=False, events=None, vectorized=False, args=None, **options)\n",
            "        Solve an initial value problem for a system of ODEs.\n",
            "        \n",
            "        This function numerically integrates a system of ordinary differential\n",
            "        equations given an initial value::\n",
            "        \n",
            "            dy / dt = f(t, y)\n",
            "            y(t0) = y0\n",
            "        \n",
            "        Here t is a one-dimensional independent variable (time), y(t) is an\n",
            "        n-dimensional vector-valued function (state), and an n-dimensional\n",
            "        vector-valued function f(t, y) determines the differential equations.\n",
            "        The goal is to find y(t) approximately satisfying the differential\n",
            "        equations, given an initial value y(t0)=y0.\n",
            "        \n",
            "        Some of the solvers support integration in the complex domain, but note\n",
            "        that for stiff ODE solvers, the right-hand side must be\n",
            "        complex-differentiable (satisfy Cauchy-Riemann equations [11]_).\n",
            "        To solve a problem in the complex domain, pass y0 with a complex data type.\n",
            "        Another option always available is to rewrite your problem for real and\n",
            "        imaginary parts separately.\n",
            "        \n",
            "        Parameters\n",
            "        ----------\n",
            "        fun : callable\n",
            "            Right-hand side of the system. The calling signature is ``fun(t, y)``.\n",
            "            Here `t` is a scalar, and there are two options for the ndarray `y`:\n",
            "            It can either have shape (n,); then `fun` must return array_like with\n",
            "            shape (n,). Alternatively it can have shape (n, k); then `fun`\n",
            "            must return an array_like with shape (n, k), i.e. each column\n",
            "            corresponds to a single column in `y`. The choice between the two\n",
            "            options is determined by `vectorized` argument (see below). The\n",
            "            vectorized implementation allows a faster approximation of the Jacobian\n",
            "            by finite differences (required for stiff solvers).\n",
            "        t_span : 2-tuple of floats\n",
            "            Interval of integration (t0, tf). The solver starts with t=t0 and\n",
            "            integrates until it reaches t=tf.\n",
            "        y0 : array_like, shape (n,)\n",
            "            Initial state. For problems in the complex domain, pass `y0` with a\n",
            "            complex data type (even if the initial value is purely real).\n",
            "        method : string or `OdeSolver`, optional\n",
            "            Integration method to use:\n",
            "        \n",
            "                * 'RK45' (default): Explicit Runge-Kutta method of order 5(4) [1]_.\n",
            "                  The error is controlled assuming accuracy of the fourth-order\n",
            "                  method, but steps are taken using the fifth-order accurate\n",
            "                  formula (local extrapolation is done). A quartic interpolation\n",
            "                  polynomial is used for the dense output [2]_. Can be applied in\n",
            "                  the complex domain.\n",
            "                * 'RK23': Explicit Runge-Kutta method of order 3(2) [3]_. The error\n",
            "                  is controlled assuming accuracy of the second-order method, but\n",
            "                  steps are taken using the third-order accurate formula (local\n",
            "                  extrapolation is done). A cubic Hermite polynomial is used for the\n",
            "                  dense output. Can be applied in the complex domain.\n",
            "                * 'DOP853': Explicit Runge-Kutta method of order 8 [13]_.\n",
            "                  Python implementation of the \"DOP853\" algorithm originally\n",
            "                  written in Fortran [14]_. A 7-th order interpolation polynomial\n",
            "                  accurate to 7-th order is used for the dense output.\n",
            "                  Can be applied in the complex domain.\n",
            "                * 'Radau': Implicit Runge-Kutta method of the Radau IIA family of\n",
            "                  order 5 [4]_. The error is controlled with a third-order accurate\n",
            "                  embedded formula. A cubic polynomial which satisfies the\n",
            "                  collocation conditions is used for the dense output.\n",
            "                * 'BDF': Implicit multi-step variable-order (1 to 5) method based\n",
            "                  on a backward differentiation formula for the derivative\n",
            "                  approximation [5]_. The implementation follows the one described\n",
            "                  in [6]_. A quasi-constant step scheme is used and accuracy is\n",
            "                  enhanced using the NDF modification. Can be applied in the\n",
            "                  complex domain.\n",
            "                * 'LSODA': Adams/BDF method with automatic stiffness detection and\n",
            "                  switching [7]_, [8]_. This is a wrapper of the Fortran solver\n",
            "                  from ODEPACK.\n",
            "        \n",
            "            Explicit Runge-Kutta methods ('RK23', 'RK45', 'DOP853') should be used\n",
            "            for non-stiff problems and implicit methods ('Radau', 'BDF') for\n",
            "            stiff problems [9]_. Among Runge-Kutta methods, 'DOP853' is recommended\n",
            "            for solving with high precision (low values of `rtol` and `atol`).\n",
            "        \n",
            "            If not sure, first try to run 'RK45'. If it makes unusually many\n",
            "            iterations, diverges, or fails, your problem is likely to be stiff and\n",
            "            you should use 'Radau' or 'BDF'. 'LSODA' can also be a good universal\n",
            "            choice, but it might be somewhat less convenient to work with as it\n",
            "            wraps old Fortran code.\n",
            "        \n",
            "            You can also pass an arbitrary class derived from `OdeSolver` which\n",
            "            implements the solver.\n",
            "        t_eval : array_like or None, optional\n",
            "            Times at which to store the computed solution, must be sorted and lie\n",
            "            within `t_span`. If None (default), use points selected by the solver.\n",
            "        dense_output : bool, optional\n",
            "            Whether to compute a continuous solution. Default is False.\n",
            "        events : callable, or list of callables, optional\n",
            "            Events to track. If None (default), no events will be tracked.\n",
            "            Each event occurs at the zeros of a continuous function of time and\n",
            "            state. Each function must have the signature ``event(t, y)`` and return\n",
            "            a float. The solver will find an accurate value of `t` at which\n",
            "            ``event(t, y(t)) = 0`` using a root-finding algorithm. By default, all\n",
            "            zeros will be found. The solver looks for a sign change over each step,\n",
            "            so if multiple zero crossings occur within one step, events may be\n",
            "            missed. Additionally each `event` function might have the following\n",
            "            attributes:\n",
            "        \n",
            "                terminal: bool, optional\n",
            "                    Whether to terminate integration if this event occurs.\n",
            "                    Implicitly False if not assigned.\n",
            "                direction: float, optional\n",
            "                    Direction of a zero crossing. If `direction` is positive,\n",
            "                    `event` will only trigger when going from negative to positive,\n",
            "                    and vice versa if `direction` is negative. If 0, then either\n",
            "                    direction will trigger event. Implicitly 0 if not assigned.\n",
            "        \n",
            "            You can assign attributes like ``event.terminal = True`` to any\n",
            "            function in Python. \n",
            "        vectorized : bool, optional\n",
            "            Whether `fun` is implemented in a vectorized fashion. Default is False.\n",
            "        args : tuple, optional\n",
            "            Additional arguments to pass to the user-defined functions.  If given,\n",
            "            the additional arguments are passed to all user-defined functions.\n",
            "            So if, for example, `fun` has the signature ``fun(t, y, a, b, c)``,\n",
            "            then `jac` (if given) and any event functions must have the same\n",
            "            signature, and `args` must be a tuple of length 3.\n",
            "        options\n",
            "            Options passed to a chosen solver. All options available for already\n",
            "            implemented solvers are listed below.\n",
            "        first_step : float or None, optional\n",
            "            Initial step size. Default is `None` which means that the algorithm\n",
            "            should choose.\n",
            "        max_step : float, optional\n",
            "            Maximum allowed step size. Default is np.inf, i.e. the step size is not\n",
            "            bounded and determined solely by the solver.\n",
            "        rtol, atol : float or array_like, optional\n",
            "            Relative and absolute tolerances. The solver keeps the local error\n",
            "            estimates less than ``atol + rtol * abs(y)``. Here `rtol` controls a\n",
            "            relative accuracy (number of correct digits). But if a component of `y`\n",
            "            is approximately below `atol`, the error only needs to fall within\n",
            "            the same `atol` threshold, and the number of correct digits is not\n",
            "            guaranteed. If components of y have different scales, it might be\n",
            "            beneficial to set different `atol` values for different components by\n",
            "            passing array_like with shape (n,) for `atol`. Default values are\n",
            "            1e-3 for `rtol` and 1e-6 for `atol`.\n",
            "        jac : array_like, sparse_matrix, callable or None, optional\n",
            "            Jacobian matrix of the right-hand side of the system with respect\n",
            "            to y, required by the 'Radau', 'BDF' and 'LSODA' method. The\n",
            "            Jacobian matrix has shape (n, n) and its element (i, j) is equal to\n",
            "            ``d f_i / d y_j``.  There are three ways to define the Jacobian:\n",
            "        \n",
            "                * If array_like or sparse_matrix, the Jacobian is assumed to\n",
            "                  be constant. Not supported by 'LSODA'.\n",
            "                * If callable, the Jacobian is assumed to depend on both\n",
            "                  t and y; it will be called as ``jac(t, y)`` as necessary.\n",
            "                  For 'Radau' and 'BDF' methods, the return value might be a\n",
            "                  sparse matrix.\n",
            "                * If None (default), the Jacobian will be approximated by\n",
            "                  finite differences.\n",
            "        \n",
            "            It is generally recommended to provide the Jacobian rather than\n",
            "            relying on a finite-difference approximation.\n",
            "        jac_sparsity : array_like, sparse matrix or None, optional\n",
            "            Defines a sparsity structure of the Jacobian matrix for a finite-\n",
            "            difference approximation. Its shape must be (n, n). This argument\n",
            "            is ignored if `jac` is not `None`. If the Jacobian has only few\n",
            "            non-zero elements in *each* row, providing the sparsity structure\n",
            "            will greatly speed up the computations [10]_. A zero entry means that\n",
            "            a corresponding element in the Jacobian is always zero. If None\n",
            "            (default), the Jacobian is assumed to be dense.\n",
            "            Not supported by 'LSODA', see `lband` and `uband` instead.\n",
            "        lband, uband : int or None, optional\n",
            "            Parameters defining the bandwidth of the Jacobian for the 'LSODA'\n",
            "            method, i.e., ``jac[i, j] != 0 only for i - lband <= j <= i + uband``.\n",
            "            Default is None. Setting these requires your jac routine to return the\n",
            "            Jacobian in the packed format: the returned array must have ``n``\n",
            "            columns and ``uband + lband + 1`` rows in which Jacobian diagonals are\n",
            "            written. Specifically ``jac_packed[uband + i - j , j] = jac[i, j]``.\n",
            "            The same format is used in `scipy.linalg.solve_banded` (check for an\n",
            "            illustration).  These parameters can be also used with ``jac=None`` to\n",
            "            reduce the number of Jacobian elements estimated by finite differences.\n",
            "        min_step : float, optional\n",
            "            The minimum allowed step size for 'LSODA' method. \n",
            "            By default `min_step` is zero.\n",
            "        \n",
            "        Returns\n",
            "        -------\n",
            "        Bunch object with the following fields defined:\n",
            "        t : ndarray, shape (n_points,)\n",
            "            Time points.\n",
            "        y : ndarray, shape (n, n_points)\n",
            "            Values of the solution at `t`.\n",
            "        sol : `OdeSolution` or None\n",
            "            Found solution as `OdeSolution` instance; None if `dense_output` was\n",
            "            set to False.\n",
            "        t_events : list of ndarray or None\n",
            "            Contains for each event type a list of arrays at which an event of\n",
            "            that type event was detected. None if `events` was None.\n",
            "        y_events : list of ndarray or None\n",
            "            For each value of `t_events`, the corresponding value of the solution.\n",
            "            None if `events` was None.\n",
            "        nfev : int\n",
            "            Number of evaluations of the right-hand side.\n",
            "        njev : int\n",
            "            Number of evaluations of the Jacobian.\n",
            "        nlu : int\n",
            "            Number of LU decompositions.\n",
            "        status : int\n",
            "            Reason for algorithm termination:\n",
            "        \n",
            "                * -1: Integration step failed.\n",
            "                *  0: The solver successfully reached the end of `tspan`.\n",
            "                *  1: A termination event occurred.\n",
            "        \n",
            "        message : string\n",
            "            Human-readable description of the termination reason.\n",
            "        success : bool\n",
            "            True if the solver reached the interval end or a termination event\n",
            "            occurred (``status >= 0``).\n",
            "        \n",
            "        References\n",
            "        ----------\n",
            "        .. [1] J. R. Dormand, P. J. Prince, \"A family of embedded Runge-Kutta\n",
            "               formulae\", Journal of Computational and Applied Mathematics, Vol. 6,\n",
            "               No. 1, pp. 19-26, 1980.\n",
            "        .. [2] L. W. Shampine, \"Some Practical Runge-Kutta Formulas\", Mathematics\n",
            "               of Computation,, Vol. 46, No. 173, pp. 135-150, 1986.\n",
            "        .. [3] P. Bogacki, L.F. Shampine, \"A 3(2) Pair of Runge-Kutta Formulas\",\n",
            "               Appl. Math. Lett. Vol. 2, No. 4. pp. 321-325, 1989.\n",
            "        .. [4] E. Hairer, G. Wanner, \"Solving Ordinary Differential Equations II:\n",
            "               Stiff and Differential-Algebraic Problems\", Sec. IV.8.\n",
            "        .. [5] `Backward Differentiation Formula\n",
            "                <https://en.wikipedia.org/wiki/Backward_differentiation_formula>`_\n",
            "                on Wikipedia.\n",
            "        .. [6] L. F. Shampine, M. W. Reichelt, \"THE MATLAB ODE SUITE\", SIAM J. SCI.\n",
            "               COMPUTE., Vol. 18, No. 1, pp. 1-22, January 1997.\n",
            "        .. [7] A. C. Hindmarsh, \"ODEPACK, A Systematized Collection of ODE\n",
            "               Solvers,\" IMACS Transactions on Scientific Computation, Vol 1.,\n",
            "               pp. 55-64, 1983.\n",
            "        .. [8] L. Petzold, \"Automatic selection of methods for solving stiff and\n",
            "               nonstiff systems of ordinary differential equations\", SIAM Journal\n",
            "               on Scientific and Statistical Computing, Vol. 4, No. 1, pp. 136-148,\n",
            "               1983.\n",
            "        .. [9] `Stiff equation <https://en.wikipedia.org/wiki/Stiff_equation>`_ on\n",
            "               Wikipedia.\n",
            "        .. [10] A. Curtis, M. J. D. Powell, and J. Reid, \"On the estimation of\n",
            "                sparse Jacobian matrices\", Journal of the Institute of Mathematics\n",
            "                and its Applications, 13, pp. 117-120, 1974.\n",
            "        .. [11] `Cauchy-Riemann equations\n",
            "                 <https://en.wikipedia.org/wiki/Cauchy-Riemann_equations>`_ on\n",
            "                 Wikipedia.\n",
            "        .. [12] `Lotka-Volterra equations\n",
            "                <https://en.wikipedia.org/wiki/Lotka%E2%80%93Volterra_equations>`_\n",
            "                on Wikipedia.\n",
            "        .. [13] E. Hairer, S. P. Norsett G. Wanner, \"Solving Ordinary Differential\n",
            "                Equations I: Nonstiff Problems\", Sec. II.\n",
            "        .. [14] `Page with original Fortran code of DOP853\n",
            "                <http://www.unige.ch/~hairer/software.html>`_.\n",
            "        \n",
            "        Examples\n",
            "        --------\n",
            "        Basic exponential decay showing automatically chosen time points.\n",
            "        \n",
            "        >>> from scipy.integrate import solve_ivp\n",
            "        >>> def exponential_decay(t, y): return -0.5 * y\n",
            "        >>> sol = solve_ivp(exponential_decay, [0, 10], [2, 4, 8])\n",
            "        >>> print(sol.t)\n",
            "        [ 0.          0.11487653  1.26364188  3.06061781  4.81611105  6.57445806\n",
            "          8.33328988 10.        ]\n",
            "        >>> print(sol.y)\n",
            "        [[2.         1.88836035 1.06327177 0.43319312 0.18017253 0.07483045\n",
            "          0.03107158 0.01350781]\n",
            "         [4.         3.7767207  2.12654355 0.86638624 0.36034507 0.14966091\n",
            "          0.06214316 0.02701561]\n",
            "         [8.         7.5534414  4.25308709 1.73277247 0.72069014 0.29932181\n",
            "          0.12428631 0.05403123]]\n",
            "        \n",
            "        Specifying points where the solution is desired.\n",
            "        \n",
            "        >>> sol = solve_ivp(exponential_decay, [0, 10], [2, 4, 8],\n",
            "        ...                 t_eval=[0, 1, 2, 4, 10])\n",
            "        >>> print(sol.t)\n",
            "        [ 0  1  2  4 10]\n",
            "        >>> print(sol.y)\n",
            "        [[2.         1.21305369 0.73534021 0.27066736 0.01350938]\n",
            "         [4.         2.42610739 1.47068043 0.54133472 0.02701876]\n",
            "         [8.         4.85221478 2.94136085 1.08266944 0.05403753]]\n",
            "        \n",
            "        Cannon fired upward with terminal event upon impact. The ``terminal`` and\n",
            "        ``direction`` fields of an event are applied by monkey patching a function.\n",
            "        Here ``y[0]`` is position and ``y[1]`` is velocity. The projectile starts\n",
            "        at position 0 with velocity +10. Note that the integration never reaches\n",
            "        t=100 because the event is terminal.\n",
            "        \n",
            "        >>> def upward_cannon(t, y): return [y[1], -0.5]\n",
            "        >>> def hit_ground(t, y): return y[0]\n",
            "        >>> hit_ground.terminal = True\n",
            "        >>> hit_ground.direction = -1\n",
            "        >>> sol = solve_ivp(upward_cannon, [0, 100], [0, 10], events=hit_ground)\n",
            "        >>> print(sol.t_events)\n",
            "        [array([40.])]\n",
            "        >>> print(sol.t)\n",
            "        [0.00000000e+00 9.99900010e-05 1.09989001e-03 1.10988901e-02\n",
            "         1.11088891e-01 1.11098890e+00 1.11099890e+01 4.00000000e+01]\n",
            "        \n",
            "        Use `dense_output` and `events` to find position, which is 100, at the apex\n",
            "        of the cannonball's trajectory. Apex is not defined as terminal, so both\n",
            "        apex and hit_ground are found. There is no information at t=20, so the sol\n",
            "        attribute is used to evaluate the solution. The sol attribute is returned\n",
            "        by setting ``dense_output=True``. Alternatively, the `y_events` attribute\n",
            "        can be used to access the solution at the time of the event.\n",
            "        \n",
            "        >>> def apex(t, y): return y[1]\n",
            "        >>> sol = solve_ivp(upward_cannon, [0, 100], [0, 10], \n",
            "        ...                 events=(hit_ground, apex), dense_output=True)\n",
            "        >>> print(sol.t_events)\n",
            "        [array([40.]), array([20.])]\n",
            "        >>> print(sol.t)\n",
            "        [0.00000000e+00 9.99900010e-05 1.09989001e-03 1.10988901e-02\n",
            "         1.11088891e-01 1.11098890e+00 1.11099890e+01 4.00000000e+01]\n",
            "        >>> print(sol.sol(sol.t_events[1][0]))\n",
            "        [100.   0.]\n",
            "        >>> print(sol.y_events)\n",
            "        [array([[-5.68434189e-14, -1.00000000e+01]]), array([[1.00000000e+02, 1.77635684e-15]])]\n",
            "        \n",
            "        As an example of a system with additional parameters, we'll implement\n",
            "        the Lotka-Volterra equations [12]_.\n",
            "        \n",
            "        >>> def lotkavolterra(t, z, a, b, c, d):\n",
            "        ...     x, y = z\n",
            "        ...     return [a*x - b*x*y, -c*y + d*x*y]\n",
            "        ...\n",
            "        \n",
            "        We pass in the parameter values a=1.5, b=1, c=3 and d=1 with the `args`\n",
            "        argument.\n",
            "        \n",
            "        >>> sol = solve_ivp(lotkavolterra, [0, 15], [10, 5], args=(1.5, 1, 3, 1),\n",
            "        ...                 dense_output=True)\n",
            "        \n",
            "        Compute a dense solution and plot it.\n",
            "        \n",
            "        >>> t = np.linspace(0, 15, 300)\n",
            "        >>> z = sol.sol(t)\n",
            "        >>> import matplotlib.pyplot as plt\n",
            "        >>> plt.plot(t, z.T)\n",
            "        >>> plt.xlabel('t')\n",
            "        >>> plt.legend(['x', 'y'], shadow=True)\n",
            "        >>> plt.title('Lotka-Volterra System')\n",
            "        >>> plt.show()\n",
            "    \n",
            "    tplquad(func, a, b, gfun, hfun, qfun, rfun, args=(), epsabs=1.49e-08, epsrel=1.49e-08)\n",
            "        Compute a triple (definite) integral.\n",
            "        \n",
            "        Return the triple integral of ``func(z, y, x)`` from ``x = a..b``,\n",
            "        ``y = gfun(x)..hfun(x)``, and ``z = qfun(x,y)..rfun(x,y)``.\n",
            "        \n",
            "        Parameters\n",
            "        ----------\n",
            "        func : function\n",
            "            A Python function or method of at least three variables in the\n",
            "            order (z, y, x).\n",
            "        a, b : float\n",
            "            The limits of integration in x: `a` < `b`\n",
            "        gfun : function or float\n",
            "            The lower boundary curve in y which is a function taking a single\n",
            "            floating point argument (x) and returning a floating point result\n",
            "            or a float indicating a constant boundary curve.\n",
            "        hfun : function or float\n",
            "            The upper boundary curve in y (same requirements as `gfun`).\n",
            "        qfun : function or float\n",
            "            The lower boundary surface in z.  It must be a function that takes\n",
            "            two floats in the order (x, y) and returns a float or a float\n",
            "            indicating a constant boundary surface.\n",
            "        rfun : function or float\n",
            "            The upper boundary surface in z. (Same requirements as `qfun`.)\n",
            "        args : tuple, optional\n",
            "            Extra arguments to pass to `func`.\n",
            "        epsabs : float, optional\n",
            "            Absolute tolerance passed directly to the innermost 1-D quadrature\n",
            "            integration. Default is 1.49e-8.\n",
            "        epsrel : float, optional\n",
            "            Relative tolerance of the innermost 1-D integrals. Default is 1.49e-8.\n",
            "        \n",
            "        Returns\n",
            "        -------\n",
            "        y : float\n",
            "            The resultant integral.\n",
            "        abserr : float\n",
            "            An estimate of the error.\n",
            "        \n",
            "        See Also\n",
            "        --------\n",
            "        quad: Adaptive quadrature using QUADPACK\n",
            "        quadrature: Adaptive Gaussian quadrature\n",
            "        fixed_quad: Fixed-order Gaussian quadrature\n",
            "        dblquad: Double integrals\n",
            "        nquad : N-dimensional integrals\n",
            "        romb: Integrators for sampled data\n",
            "        simps: Integrators for sampled data\n",
            "        ode: ODE integrators\n",
            "        odeint: ODE integrators\n",
            "        scipy.special: For coefficients and roots of orthogonal polynomials\n",
            "        \n",
            "        Examples\n",
            "        --------\n",
            "        \n",
            "        Compute the triple integral of ``x * y * z``, over ``x`` ranging\n",
            "        from 1 to 2, ``y`` ranging from 2 to 3, ``z`` ranging from 0 to 1.\n",
            "        \n",
            "        >>> from scipy import integrate\n",
            "        >>> f = lambda z, y, x: x*y*z\n",
            "        >>> integrate.tplquad(f, 1, 2, lambda x: 2, lambda x: 3,\n",
            "        ...                   lambda x, y: 0, lambda x, y: 1)\n",
            "        (1.8750000000000002, 3.324644794257407e-14)\n",
            "    \n",
            "    trapz(y, x=None, dx=1.0, axis=-1)\n",
            "        Integrate along the given axis using the composite trapezoidal rule.\n",
            "        \n",
            "        Integrate `y` (`x`) along given axis.\n",
            "        \n",
            "        Parameters\n",
            "        ----------\n",
            "        y : array_like\n",
            "            Input array to integrate.\n",
            "        x : array_like, optional\n",
            "            The sample points corresponding to the `y` values. If `x` is None,\n",
            "            the sample points are assumed to be evenly spaced `dx` apart. The\n",
            "            default is None.\n",
            "        dx : scalar, optional\n",
            "            The spacing between sample points when `x` is None. The default is 1.\n",
            "        axis : int, optional\n",
            "            The axis along which to integrate.\n",
            "        \n",
            "        Returns\n",
            "        -------\n",
            "        trapz : float\n",
            "            Definite integral as approximated by trapezoidal rule.\n",
            "        \n",
            "        See Also\n",
            "        --------\n",
            "        numpy.cumsum\n",
            "        \n",
            "        Notes\n",
            "        -----\n",
            "        Image [2]_ illustrates trapezoidal rule -- y-axis locations of points\n",
            "        will be taken from `y` array, by default x-axis distances between\n",
            "        points will be 1.0, alternatively they can be provided with `x` array\n",
            "        or with `dx` scalar.  Return value will be equal to combined area under\n",
            "        the red lines.\n",
            "        \n",
            "        \n",
            "        References\n",
            "        ----------\n",
            "        .. [1] Wikipedia page: https://en.wikipedia.org/wiki/Trapezoidal_rule\n",
            "        \n",
            "        .. [2] Illustration image:\n",
            "               https://en.wikipedia.org/wiki/File:Composite_trapezoidal_rule_illustration.png\n",
            "        \n",
            "        Examples\n",
            "        --------\n",
            "        >>> np.trapz([1,2,3])\n",
            "        4.0\n",
            "        >>> np.trapz([1,2,3], x=[4,6,8])\n",
            "        8.0\n",
            "        >>> np.trapz([1,2,3], dx=2)\n",
            "        8.0\n",
            "        >>> a = np.arange(6).reshape(2, 3)\n",
            "        >>> a\n",
            "        array([[0, 1, 2],\n",
            "               [3, 4, 5]])\n",
            "        >>> np.trapz(a, axis=0)\n",
            "        array([1.5, 2.5, 3.5])\n",
            "        >>> np.trapz(a, axis=1)\n",
            "        array([2.,  8.])\n",
            "\n",
            "DATA\n",
            "    __all__ = ['BDF', 'DOP853', 'DenseOutput', 'IntegrationWarning', 'LSOD...\n",
            "    absolute_import = _Feature((2, 5, 0, 'alpha', 1), (3, 0, 0, 'alpha', 0...\n",
            "    division = _Feature((2, 2, 0, 'alpha', 2), (3, 0, 0, 'alpha', 0), 8192...\n",
            "    print_function = _Feature((2, 6, 0, 'alpha', 2), (3, 0, 0, 'alpha', 0)...\n",
            "\n",
            "FILE\n",
            "    /usr/local/lib/python3.6/dist-packages/scipy/integrate/__init__.py\n",
            "\n",
            "\n"
          ],
          "name": "stdout"
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "M5c_MX9sE5F7",
        "outputId": "a072b988-faaf-434e-df23-c7d17c553e23",
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 34
        }
      },
      "source": [
        "i=integrate.quad(lambda x:special.exp10(x),0,1)\n",
        "print(i)"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "(3.9086503371292665, 4.3394735994897923e-14)\n"
          ],
          "name": "stdout"
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "F6pPJi_bGrf6",
        "outputId": "4bab065f-8c0c-424f-bf0e-58df2a32a908",
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 34
        }
      },
      "source": [
        "e=lambda x,y:x*y**2\n",
        "f=lambda x:1\n",
        "g=lambda x:-1\n",
        "integrate.dblquad(e,0,1,f,g)"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "(-0.0, 1.101285676892444e-14)"
            ]
          },
          "metadata": {
            "tags": []
          },
          "execution_count": 20
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "t4W8eWCRIHUw",
        "outputId": "66318a0d-5b32-4b5c-965d-91ae23cfb4f6",
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 68
        }
      },
      "source": [
        "#Fourier transforms\n",
        "from scipy import fft,ifft\n",
        "import numpy as np\n",
        "x=np.array([1,2,3,4])\n",
        "y=fft(x)\n",
        "print(y)\n"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "[10.+0.j -2.+2.j -2.+0.j -2.-2.j]\n"
          ],
          "name": "stdout"
        },
        {
          "output_type": "stream",
          "text": [
            "/usr/local/lib/python3.6/dist-packages/ipykernel_launcher.py:5: DeprecationWarning: Using scipy.fft as a function is deprecated and will be removed in SciPy 1.5.0, use scipy.fft.fft instead.\n",
            "  \"\"\"\n"
          ],
          "name": "stderr"
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "LqSg2da7JbkH"
      },
      "source": [
        ""
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "DcqECPipJdDl",
        "outputId": "6a43b064-a894-4e51-e9f2-e11b40da5148",
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 68
        }
      },
      "source": [
        "#Fourier transforms\n",
        "from scipy import fft,ifft\n",
        "import numpy as np\n",
        "x=np.array([1,2,3,4])\n",
        "y=ifft(x)\n",
        "print(y)\n"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "[ 2.5+0.j  -0.5-0.5j -0.5+0.j  -0.5+0.5j]\n"
          ],
          "name": "stdout"
        },
        {
          "output_type": "stream",
          "text": [
            "/usr/local/lib/python3.6/dist-packages/ipykernel_launcher.py:5: DeprecationWarning: scipy.ifft is deprecated and will be removed in SciPy 2.0.0, use scipy.fft.ifft instead\n",
            "  \"\"\"\n"
          ],
          "name": "stderr"
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "z-4kzXrGLVLg",
        "outputId": "6e959c8f-0665-4c67-b97c-5c552a7953c3",
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 51
        }
      },
      "source": [
        "#Linear algebra\n",
        "from scipy import linalg\n",
        "a=np.array([[1,2],[3,4]])\n",
        "b=linalg.inv(a)\n",
        "print(b)"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "[[-2.   1. ]\n",
            " [ 1.5 -0.5]]\n"
          ],
          "name": "stdout"
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "UljUzykSMmH6",
        "outputId": "eda11772-8ca5-4b75-e38d-6921638d1752",
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 299
        }
      },
      "source": [
        "#interpolation functions\n",
        "import matplotlib.pyplot as plt\n",
        "from scipy import interpolate\n",
        "x=np.arange(5,20)\n",
        "y=np.exp(x/3.0)\n",
        "f=interpolate.interp1d(x,y)\n",
        "x1=np.arange(6,12)\n",
        "y1=f(x1)\n",
        "plt.plot(x,y,'o',x1,y1,'--')\n"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "[<matplotlib.lines.Line2D at 0x7fc4566f6940>,\n",
              " <matplotlib.lines.Line2D at 0x7fc4566f6a90>]"
            ]
          },
          "metadata": {
            "tags": []
          },
          "execution_count": 29
        },
        {
          "output_type": "display_data",
          "data": {
            "image/png": "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\n",
            "text/plain": [
              "<Figure size 432x288 with 1 Axes>"
            ]
          },
          "metadata": {
            "tags": [],
            "needs_background": "light"
          }
        }
      ]
    }
  ]
}