code: def quad(
      func,
      a,
      b,
      args=(),
      full_output=0,
      epsabs=1.49e-8,
      epsrel=1.49e-8,
      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.
      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.
  
      See Also
      --------
      dblquad : double integral
      tplquad : triple integral
      nquad : n-dimensional integrals (uses `quad` recursively)
      fixed_quad : fixed-order Gaussian quadrature
      quadrature : adaptive Gaussian quadrature
      odeint : ODE integrator
      ode : ODE integrator
      simps : integrator for sampled data
      romb : integrator for sampled data
      scipy.special : for coefficients and roots of orthogonal polynomials
  
      Notes
      -----
  
      **Extra information for quad() inputs and outputs**
  
      If full_output is non-zero, then the third output argument
      (infodict) is a dictionary with entries as tabulated below.  For
      infinite limits, the range is transformed to (0,1) and the
      optional outputs are given with respect to this transformed range.
      Let M be the input argument limit and let K be infodict['last'].
      The entries are:
  
      'neval'
          The number of function evaluations.
      'last'
          The number, K, of subintervals produced in the subdivision process.
      'alist'
          A rank-1 array of length M, the first K elements of which are the
          left end points of the subintervals in the partition of the
          integration range.
      'blist'
          A rank-1 array of length M, the first K elements of which are the
          right end points of the subintervals.
      'rlist'
          A rank-1 array of length M, the first K elements of which are the
          integral approximations on the subintervals.
      'elist'
          A rank-1 array of length M, the first K elements of which are the
          moduli of the absolute error estimates on the subintervals.
      'iord'
          A rank-1 integer array of length M, the first L elements of
          which are pointers to the error estimates over the subintervals
          with ``L=K`` if ``K<=M/2+2`` or ``L=M+1-K`` otherwise. Let I be the
          sequence ``infodict['iord']`` and let E be the sequence
          ``infodict['elist']``.  Then ``E[I[1]], ..., E[I[L]]`` forms a
          decreasing sequence.
  
      If the input argument points is provided (i.e. it is not None),
      the following additional outputs are placed in the output
      dictionary.  Assume the points sequence is of length P.
  
      'pts'
          A rank-1 array of length P+2 containing the integration limits
          and the break points of the intervals in ascending order.
          This is an array giving the subintervals over which integration
          will occur.
      'level'
          A rank-1 integer array of length M (=limit), containing the
          subdivision levels of the subintervals, i.e., if (aa,bb) is a
          subinterval of ``(pts[1], pts[2])`` where ``pts[0]`` and ``pts[2]``
          are adjacent elements of ``infodict['pts']``, then (aa,bb) has level l
          if ``|bb-aa| = |pts[2]-pts[1]| * 2**(-l)``.
      'ndin'
          A rank-1 integer array of length P+2.  After the first integration
          over the intervals (pts[1], pts[2]), the error estimates over some
          of the intervals may have been increased artificially in order to
          put their subdivision forward.  This array has ones in slots
          corresponding to the subintervals for which this happens.
  
      **Weighting the integrand**
  
      The input variables, *weight* and *wvar*, are used to weight the
      integrand by a select list of functions.  Different integration
      methods are used to compute the integral with these weighting
      functions.  The possible values of weight and the corresponding
      weighting functions are.
  
      ==========  ===================================   =====================
      ``weight``  Weight function used                  ``wvar``
      ==========  ===================================   =====================
      'cos'       cos(w*x)                              wvar = w
      'sin'       sin(w*x)                              wvar = w
      'alg'       g(x) = ((x-a)**alpha)*((b-x)**beta)   wvar = (alpha, beta)
      'alg-loga'  g(x)*log(x-a)                         wvar = (alpha, beta)
      'alg-logb'  g(x)*log(b-x)                         wvar = (alpha, beta)
      'alg-log'   g(x)*log(x-a)*log(b-x)                wvar = (alpha, beta)
      'cauchy'    1/(x-c)                               wvar = c
      ==========  ===================================   =====================
  
      wvar holds the parameter w, (alpha, beta), or c depending on the weight
      selected.  In these expressions, a and b are the integration limits.
  
      For the 'cos' and 'sin' weighting, additional inputs and outputs are
      available.
  
      For finite integration limits, the integration is performed using a
      Clenshaw-Curtis method which uses Chebyshev moments.  For repeated
      calculations, these moments are saved in the output dictionary:
  
      'momcom'
          The maximum level of Chebyshev moments that have been computed,
          i.e., if ``M_c`` is ``infodict['momcom']`` then the moments have been
          computed for intervals of length ``|b-a| * 2**(-l)``,
          ``l=0,1,...,M_c``.
      'nnlog'
          A rank-1 integer array of length M(=limit), containing the
          subdivision levels of the subintervals, i.e., an element of this
          array is equal to l if the corresponding subinterval is
          ``|b-a|* 2**(-l)``.
      'chebmo'
          A rank-2 array of shape (25, maxp1) containing the computed
          Chebyshev moments.  These can be passed on to an integration
          over the same interval by passing this array as the second
          element of the sequence wopts and passing infodict['momcom'] as
          the first element.
  
      If one of the integration limits is infinite, then a Fourier integral is
      computed (assuming w neq 0).  If full_output is 1 and a numerical error
      is encountered, besides the error message attached to the output tuple,
      a dictionary is also appended to the output tuple which translates the
      error codes in the array ``info['ierlst']`` to English messages.  The
      output information dictionary contains the following entries instead of
      'last', 'alist', 'blist', 'rlist', and 'elist':
  
      'lst'
          The number of subintervals needed for the integration (call it ``K_f``).
      'rslst'
          A rank-1 array of length M_f=limlst, whose first ``K_f`` elements
          contain the integral contribution over the interval
          ``(a+(k-1)c, a+kc)`` where ``c = (2*floor(|w|) + 1) * pi / |w|``
          and ``k=1,2,...,K_f``.
      'erlst'
          A rank-1 array of length ``M_f`` containing the error estimate
          corresponding to the interval in the same position in
          ``infodict['rslist']``.
      'ierlst'
          A rank-1 integer array of length ``M_f`` containing an error flag
          corresponding to the interval in the same position in
          ``infodict['rslist']``.  See the explanation dictionary (last entry
          in the output tuple) for the meaning of the codes.
  
      Examples
      --------
      Calculate :math:`\\int^4_0 x^2 dx` and compare with an analytic result
  
      >>> from scipy import integrate
      >>> x2 = lambda x: x**2
      >>> integrate.quad(x2, 0, 4)
      (21.333333333333332, 2.3684757858670003e-13)
      >>> print(4**3 / 3.)  # analytical result
      21.3333333333
  
      Calculate :math:`\\int^\\infty_0 e^{-x} dx`
  
      >>> invexp = lambda x: np.exp(-x)
      >>> integrate.quad(invexp, 0, np.inf)
      (1.0, 5.842605999138044e-11)
  
      >>> f = lambda x,a : a*x
      >>> y, err = integrate.quad(f, 0, 1, args=(1,))
      >>> y
      0.5
      >>> y, err = integrate.quad(f, 0, 1, args=(3,))
      >>> y
      1.5
  
      Calculate :math:`\\int^1_0 x^2 + y^2 dx` with ctypes, holding
      y parameter as 1::
  
          testlib.c =>
              double func(int n, double args[n]){
                  return args[0]*args[0] + args[1]*args[1];}
          compile to library testlib.*
  
      ::
  
         from scipy import integrate
         import ctypes
         lib = ctypes.CDLL('/home/.../testlib.*') #use absolute path
         lib.func.restype = ctypes.c_double
         lib.func.argtypes = (ctypes.c_int,ctypes.c_double)
         integrate.quad(lib.func,0,1,(1))
         #(1.3333333333333333, 1.4802973661668752e-14)
         print((1.0**3/3.0 + 1.0) - (0.0**3/3.0 + 0.0)) #Analytic result
         # 1.3333333333333333
  
      Be aware that pulse shapes and other sharp features as compared to the
      size of the integration interval may not be integrated correctly using
      this method. A simplified example of this limitation is integrating a
      y-axis reflected step function with many zero values within the integrals
      bounds.
  
      >>> y = lambda x: 1 if x<=0 else 0
      >>> integrate.quad(y, -1, 1)
      (1.0, 1.1102230246251565e-14)
      >>> integrate.quad(y, -1, 100)
      (1.0000000002199108, 1.0189464580163188e-08)
      >>> integrate.quad(y, -1, 10000)
      (0.0, 0.0)
  
      """
      if not isinstance(args, tuple):
          args = (args,)
  
      # check the limits of integration: \int_a^b, expect a < b
      flip, a, b = b < a, min(a, b), max(a, b)
  
      if weight is None:
          retval = _quad(
              func,
              a,
              b,
              args,
              full_output,
              epsabs,
              epsrel,
              limit,
              points,
          )
      else:
          retval = _quad_weight(
              func,
              a,
              b,
              args,
              full_output,
              epsabs,
              epsrel,
              limlst,
              limit,
              maxp1,
              weight,
              wvar,
              wopts,
          )
  
      if flip:
          retval = (-retval[0],) + retval[1:]
  
      ier = retval[-1]
      if ier == 0:
          return retval[:-1]
  
      msgs = {
          80: "A Python error occurred possibly while calling the function.",
          1: "The maximum number of subdivisions (%d) has been achieved.\n  If increasing the limit yields no improvement it is advised to analyze \n  the integrand in order to determine the difficulties.  If the position of a \n  local difficulty can be determined (singularity, discontinuity) one will \n  probably gain from splitting up the interval and calling the integrator \n  on the subranges.  Perhaps a special-purpose integrator should be used."
          % limit,
          2: "The occurrence of roundoff error is detected, which prevents \n  the requested tolerance from being achieved.  The error may be \n  underestimated.",
          3: "Extremely bad integrand behavior occurs at some points of the\n  integration interval.",
          4: "The algorithm does not converge.  Roundoff error is detected\n  in the extrapolation table.  It is assumed that the requested tolerance\n  cannot be achieved, and that the returned result (if full_output = 1) is \n  the best which can be obtained.",
          5: "The integral is probably divergent, or slowly convergent.",
          6: "The input is invalid.",
          7: "Abnormal termination of the routine.  The estimates for result\n  and error are less reliable.  It is assumed that the requested accuracy\n  has not been achieved.",
          "unknown": "Unknown error.",
      }
  
      if weight in ["cos", "sin"] and (b == Inf or a == -Inf):
          msgs[
              1
          ] = "The maximum number of cycles allowed has been achieved., e.e.\n  of subintervals (a+(k-1)c, a+kc) where c = (2*int(abs(omega)+1))\n  *pi/abs(omega), for k = 1, 2, ..., lst.  One can allow more cycles by increasing the value of limlst.  Look at info['ierlst'] with full_output=1."
          msgs[
              4
          ] = "The extrapolation table constructed for convergence acceleration\n  of the series formed by the integral contributions over the cycles, \n  does not converge to within the requested accuracy.  Look at \n  info['ierlst'] with full_output=1."
          msgs[
              7
          ] = "Bad integrand behavior occurs within one or more of the cycles.\n  Location and type of the difficulty involved can be determined from \n  the vector info['ierlist'] obtained with full_output=1."
          explain = {
              1: "The maximum number of subdivisions (= limit) has been \n  achieved on this cycle.",
              2: "The occurrence of roundoff error is detected and prevents\n  the tolerance imposed on this cycle from being achieved.",
              3: "Extremely bad integrand behavior occurs at some points of\n  this cycle.",
              4: "The integral over this cycle does not converge (to within the required accuracy) due to roundoff in the extrapolation procedure invoked on this cycle.  It is assumed that the result on this interval is the best which can be obtained.",
              5: "The integral over this cycle is probably divergent or slowly convergent.",
          }
  
      try:
          msg = msgs[ier]
      except KeyError:
          msg = msgs["unknown"]
  
      if ier in [1, 2, 3, 4, 5, 7]:
          if full_output:
              if weight in ["cos", "sin"] and (b == Inf or a == Inf):
                  return retval[:-1] + (msg, explain)
              else:
                  return retval[:-1] + (msg,)
          else:
              warnings.warn(msg, IntegrationWarning, stacklevel=2)
              return retval[:-1]
  
      elif (
          ier == 6
      ):  # Forensic decision tree when QUADPACK throws ier=6
          if (
              epsabs <= 0
          ):  # Small error tolerance - applies to all methods
              if epsrel < max(50 * sys.float_info.epsilon, 5e-29):
                  msg = (
                      "If 'errabs'<=0, 'epsrel' must be greater than both"
                      " 5e-29 and 50*(machine epsilon)."
                  )
              elif weight in ["sin", "cos"] and (
                  abs(a) + abs(b) == Inf
              ):
                  msg = (
                      "Sine or cosine weighted intergals with infinite domain"
                      " must have 'epsabs'>0."
                  )
  
          elif weight is None:
              if points is None:  # QAGSE/QAGIE
                  msg = (
                      "Invalid 'limit' argument. There must be"
                      " at least one subinterval"
                  )
              else:  # QAGPE
                  if not (
                      min(a, b)
                      <= min(points)
                      <= max(points)
                      <= max(a, b)
                  ):
                      msg = (
                          "All break points in 'points' must lie within the"
                          " integration limits."
                      )
                  elif len(points) >= limit:
                      msg = (
                          "Number of break points ({:d})"
                          " must be less than subinterval"
                          " limit ({:d})"
                      ).format(len(points), limit)
  
          else:
              if maxp1 < 1:
                  msg = "Chebyshev moment limit maxp1 must be >=1."
  
              elif (
                  weight in ("cos", "sin") and abs(a + b) == Inf
              ):  # QAWFE
                  msg = "Cycle limit limlst must be >=3."
  
              elif weight.startswith("alg"):  # QAWSE
                  if min(wvar) < -1:
                      msg = "wvar parameters (alpha, beta) must both be >= -1."
                  if b < a:
                      msg = "Integration limits a, b must satistfy a<b."
  
              elif weight == "cauchy" and wvar in (a, b):
                  msg = (
                      "Parameter 'wvar' must not equal"
                      " integration limits 'a' or 'b'."
                  )
  
      raise ValueError(msg)
  
imports: from __future__ import division, print_function, absolute_import
  import sys
  import warnings
  from functools import partial
  from .None import _quadpack
  import numpy
  from numpy import Inf
label_desc: Use image node_id 2 for calling a global function with example usage: quad(func, a, b, args, full_output, epsabs, epsrel, limit, points, weight, wvar, wopts, maxp1, limlst) and returns: retval, retval, unknown, unknown