Skip to main content
`Ctrl`+`K`

# Integration and ODEs (`scipy.integrate`)

## Integrating functions, given function object

`quad`(func, a, b[, args, full_output, ...]) | Compute a definite integral.
`quad_vec`(f, a, b[, epsabs, epsrel, norm, ...]) | Adaptive integration of a vector-valued function.
`cubature`(f, a, b, *[, rule, rtol, atol, ...]) | Adaptive cubature of multidimensional array-valued function.
`dblquad`(func, a, b, gfun, hfun[, args, ...]) | Compute a double integral.
`tplquad`(func, a, b, gfun, hfun, qfun, rfun) | Compute a triple (definite) integral.
`nquad`(func, ranges[, args, opts, full_output]) | Integration over multiple variables.
`tanhsinh`(f, a, b, *[, args, kwargs, log, ...]) | Evaluate a convergent integral numerically using tanh-sinh quadrature.
`fixed_quad`(func, a, b[, args, n]) | Compute a definite integral using fixed-order Gaussian quadrature.
`newton_cotes`(rn[, equal]) | Return weights and error coefficient for Newton-Cotes integration.
`lebedev_rule`(n) | Lebedev quadrature.
`qmc_quad`(func, a, b, *[, n_estimates, ...]) | Compute an integral in N-dimensions using Quasi-Monte Carlo quadrature.
`IntegrationWarning` | Warning on issues during integration.

## Integrating functions, given fixed samples

`trapezoid`(y[, x, dx, axis]) | Integrate along the given axis using the composite trapezoidal rule.
`cumulative_trapezoid`(y[, x, dx, axis, initial]) | Cumulatively integrate y(x) using the composite trapezoidal rule.
`simpson`(y[, x, dx, axis]) | Integrate y(x) using samples along the given axis and the composite Simpson's rule.
`cumulative_simpson`(y, *[, x, dx, axis, initial]) | Cumulatively integrate y(x) using the composite Simpson's 1/3 rule.
`romb`(y[, dx, axis, show]) | Romberg integration using samples of a function.

See also

`scipy.special` for orthogonal polynomials (special) for Gaussian quadrature roots and weights for other weighting factors and regions.

## Summation

`nsum`(f, a, b, *[, step, args, kwargs, log, ...]) | Evaluate a convergent finite or infinite series.

## Solving initial value problems for ODE systems

The solvers are implemented as individual classes, which can be used directly (low-level usage) or through a convenience function.

`solve_ivp`(fun, t_span, y0[, method, t_eval, ...]) | Solve an initial value problem for a system of ODEs.
`RK23`(fun, t0, y0, t_bound[, max_step, rtol, ...]) | Explicit Runge-Kutta method of order 3(2).
`RK45`(fun, t0, y0, t_bound[, max_step, rtol, ...]) | Explicit Runge-Kutta method of order 5(4).
`DOP853`(fun, t0, y0, t_bound[, max_step, ...]) | Explicit Runge-Kutta method of order 8.
`Radau`(fun, t0, y0, t_bound[, max_step, ...]) | Implicit Runge-Kutta method of Radau IIA family of order 5.
`BDF`(fun, t0, y0, t_bound[, max_step, rtol, ...]) | Implicit method based on backward-differentiation formulas.
`LSODA`(fun, t0, y0, t_bound[, first_step, ...]) | Adams/BDF method with automatic stiffness detection and switching.
`OdeSolver`(fun, t0, y0, t_bound, vectorized) | Base class for ODE solvers.
`DenseOutput`(t_old, t) | Base class for local interpolant over step made by an ODE solver.
`OdeSolution`(ts, interpolants[, alt_segment]) | Continuous ODE solution.

### Old API

These are the routines developed earlier for SciPy. They wrap older solvers implemented in Fortran (mostly ODEPACK). While the interface to them is not particularly convenient and certain features are missing compared to the new API, the solvers themselves are of good quality and work fast as compiled Fortran code. In some cases, it might be worth using this old API.

`odeint`(func, y0, t[, args, Dfun, col_deriv, ...]) | Integrate a system of ordinary differential equations.
`ode`(f[, jac]) | A generic interface class to numeric integrators.
`complex_ode`(f[, jac]) | A wrapper of ode for complex systems.
`ODEintWarning` | Warning raised during the execution of `odeint`.

## Solving boundary value problems for ODE systems

`solve_bvp`(fun, bc, x, y[, p, S, fun_jac, ...]) | Solve a boundary value problem for a system of ODEs.