利用scipy计算定积分

#使用scipy模块 求定积分
from numpy import e,pi,inf,sqrt, sin, cos, tan,arctan
from scipy.integrate import quad, dblquad, tplquad, nquad

# 一重积分
def f(x):
    return x*x
v, err = quad(f,-1,1) #第二个参数为积分下限，第三个参数为积分上限
# quad 返回一个元组，第一个元素为定积分的值，第二个为偏差
print(v,err)
#积分上/下限 为无穷大/小
#from numpy import inf
v, err = quad(lambda x: 1/(x**2),0.5,inf)
print(v,err)
v, err = quad(lambda x: 1/sqrt(2*pi)*e**(-x*x/2),-inf,inf) #标准正态分布，积分为1

print(v,err)
#带形参的积分
def g(x,a,b):
    return a*sin(x)+b*cos(x)
v, err = quad(g,0,2, args =(1,2)) # args 中输入形参 a和b的取值 a=1,b=2
print(v,err)
#如果积分函数有断点，可由points参数给出断点后继续求积分
v, err = quad(lambda x: 1/sqrt(abs(x)),-1,1, points=[0])
print(v)

# 二重积分
def f(x,y):
    return x**2 + y**2
def g(x):
    return -x
def h(x):
    return x+1
v, err = dblquad(f,0,3, g,h)
print(v)

# 三重积分
def f(x,y,z):
    return x*y*z
def g(x):
    return 1-x
def h(x):
    return x**2
def q(x,y):
    return x*y+1
def r(x,y):
    return 1-x-2*y
v, err = tplquad(f,0,2,g,h,q,r)
print(v)

# n重积分
f = lambda x0,x1,x2,x3 : x0**2 + x1*x2 - x3**3 + sin(x0) + (1 if (x0-.2*x3-.5-.25*x1>0) else 0)
points = [[lambda x1,x2,x3 : 0.2*x3 + 0.5 + 0.25*x1], [], [], []]
def opts0(*args, **kwargs):
    return {'points':[0.2*args[2] + 0.5 + 0.25*args[0]]}
v,err,out_dict = nquad(f, [[0,1], [-1,1], [0.13,0.8], [-0.15,1]],opts=[opts0,{},{},{}], full_output=True)
print(v)
'''
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)
    Compute a definite integral.
   
    Integrate func from `a` to `b` (possibly infinite interval) using a
    technique from the Fortran library QUADPACK.
   
    Parameters
    ----------
    func : {function, scipy.LowLevelCallable}
        A Python function or method to integrate.  If `func` takes many
        arguments, it is integrated along the axis corresponding to the
        first argument.
   
        If the user desires improved integration performance, then `f` may
        be a `scipy.LowLevelCallable` with one of the signatures::
   
            double func(double x)
            double func(double x, void *user_data)
            double func(int n, double *xx)
            double func(int n, double *xx, void *user_data)
   
        The ``user_data`` is the data contained in the `scipy.LowLevelCallable`.
        In the call forms with ``xx``,  ``n`` is the length of the ``xx``
        array which contains ``xx[0] == x`` and the rest of the items are
        numbers contained in the ``args`` argument of quad.
   
        In addition, certain ctypes call signatures are supported for
        backward compatibility, but those should not be used in new code.
    a : float
        Lower limit of integration (use -numpy.inf for -infinity).
    b : float
        Upper limit of integration (use numpy.inf for +infinity).
    args : tuple, optional
        Extra arguments to pass to `func`.
    full_output : int, optional
        Non-zero to return a dictionary of integration information.
        If non-zero, warning messages are also suppressed and the
        message is appended to the output tuple.
   
    Returns
    -------
    y : float
        The integral of func from `a` to `b`.
    abserr : float
        An estimate of the absolute error in the result.
    infodict : dict
        A dictionary containing additional information.
        Run scipy.integrate.quad_explain() for more information.
    message
        A convergence message.
    explain
        Appended only with 'cos' or 'sin' weighting and infinite
        integration limits, it contains an explanation of the codes in
        infodict['ierlst']
   
    Other Parameters
    ----------------
    epsabs : float or int, optional
        Absolute error tolerance.
    epsrel : float or int, optional
        Relative error tolerance.
    limit : float or int, optional
        An upper bound on the number of subintervals used in the adaptive
        algorithm.
    points : (sequence of floats,ints), optional
        A sequence of break points in the bounded integration interval
        where local difficulties of the integrand may occur (e.g.,
        singularities, discontinuities). The sequence does not have
        to be sorted. Note that this option cannot be used in conjunction
        with ``weight``.
    weight : float or int, optional
        String indicating weighting function. Full explanation for this
        and the remaining arguments can be found below.
    wvar : optional
        Variables for use with weighting functions.
    wopts : optional
        Optional input for reusing Chebyshev moments.
    maxp1 : float or int, optional
        An upper bound on the number of Chebyshev moments.
    limlst : int, optional
        Upper bound on the number of cycles (>=3) for use with a sinusoidal
        weighting and an infinite end-point.

nquad(func, ranges, args=None, opts=None, full_output=False)
    Integration over multiple variables.
   
    Wraps `quad` to enable integration over multiple variables.
    Various options allow improved integration of discontinuous functions, as
    well as the use of weighted integration, and generally finer control of the
    integration process.
   
    Parameters
    ----------
    func : {callable, scipy.LowLevelCallable}
        The function to be integrated. Has arguments of ``x0, ... xn``,
        ``t0, tm``, where integration is carried out over ``x0, ... xn``, which
        must be floats.  Function signature should be
        ``func(x0, x1, ..., xn, t0, t1, ..., tm)``.  Integration is carried out
        in order.  That is, integration over ``x0`` is the innermost integral,
        and ``xn`` is the outermost.
   
        If the user desires improved integration performance, then `f` may
        be a `scipy.LowLevelCallable` with one of the signatures::
   
            double func(int n, double *xx)
            double func(int n, double *xx, void *user_data)
   
        where ``n`` is the number of extra parameters and args is an array
        of doubles of the additional parameters, the ``xx`` array contains the
        coordinates. The ``user_data`` is the data contained in the
        `scipy.LowLevelCallable`.
    ranges : iterable object
        Each element of ranges may be either a sequence  of 2 numbers, or else
        a callable that returns such a sequence.  ``ranges[0]`` corresponds to
        integration over x0, and so on.  If an element of ranges is a callable,
        then it will be called with all of the integration arguments available,
        as well as any parametric arguments. e.g. if
        ``func = f(x0, x1, x2, t0, t1)``, then ``ranges[0]`` may be defined as
        either ``(a, b)`` or else as ``(a, b) = range0(x1, x2, t0, t1)``.
    args : iterable object, optional
        Additional arguments ``t0, ..., tn``, required by `func`, `ranges`, and
        ``opts``.
    opts : iterable object or dict, optional
        Options to be passed to `quad`.  May be empty, a dict, or
        a sequence of dicts or functions that return a dict.  If empty, the
        default options from scipy.integrate.quad are used.  If a dict, the same
        options are used for all levels of integraion.  If a sequence, then each
        element of the sequence corresponds to a particular integration. e.g.
        opts[0] corresponds to integration over x0, and so on. If a callable,
        the signature must be the same as for ``ranges``. The available
        options together with their default values are:
   
          - epsabs = 1.49e-08
          - epsrel = 1.49e-08
          - limit  = 50
          - points = None
          - weight = None
          - wvar   = None
          - wopts  = None
   
        For more information on these options, see `quad` and `quad_explain`.
   
    full_output : bool, optional
        Partial implementation of ``full_output`` from scipy.integrate.quad.
        The number of integrand function evaluations ``neval`` can be obtained
        by setting ``full_output=True`` when calling nquad.
   
    Returns
    -------
    result : float
        The result of the integration.
    abserr : float
        The maximum of the estimates of the absolute error in the various
        integration results.
    out_dict : dict, optional
        A dict containing additional information on the integration.
'''