(self, f, points, prec, epsilon, max_degree, verbose=False)
return I, err
Main integration function. Computes the 1D integral over
        the interval specified by *points*. For each subinterval,
        performs quadrature of degree from 1 up to *max_degree*
        until :func:`~mpmath.estimate_error` signals convergence.

        :func:`~mpmath.summation` transforms each subintegration to
        the standard interval and then calls :func:`~mpmath.sum_next`.
Main integration function. Computes the 1D integral over
        the interval specified by *points*. For each subinterval,
        performs quadrature of degree from 1 up to *max_degree*
        until :func:`~mpmath.estimate_error` signals convergence.
Main integration function . Computes the 1D integral over the interval specified by * points * . For each subinterval performs quadrature of degree from 1 up to * max_degree * until : func : ~mpmath . estimate_error signals convergence .
def summation(self, f, points, prec, epsilon, max_degree, verbose=False):
        """
        Main integration function. Computes the 1D integral over
        the interval specified by *points*. For each subinterval,
        performs quadrature of degree from 1 up to *max_degree*
        until :func:`~mpmath.estimate_error` signals convergence.

        :func:`~mpmath.summation` transforms each subintegration to
        the standard interval and then calls :func:`~mpmath.sum_next`.
        """
        ctx = self.ctx
        I = err = ctx.zero
        for i in xrange(len(points)-1):
            a, b = points[i], points[i+1]
            if a == b:
                continue
            # XXX: we could use a single variable transformation,
            # but this is not good in practice. We get better accuracy
            # by having 0 as an endpoint.
            if (a, b) == (ctx.ninf, ctx.inf):
                _f = f
                f = lambda x: _f(-x) + _f(x)
                a, b = (ctx.zero, ctx.inf)
            results = []
            for degree in xrange(1, max_degree+1):
                nodes = self.get_nodes(a, b, degree, prec, verbose)
                if verbose:
                    print("Integrating from %s to %s (degree %s of %s)" % \
                        (ctx.nstr(a), ctx.nstr(b), degree, max_degree))
                results.append(self.sum_next(f, nodes, degree, prec, results, verbose))
                if degree > 1:
                    err = self.estimate_error(results, prec, epsilon)
                    if err <= epsilon:
                        break
                    if verbose:
                        print("Estimated error:", ctx.nstr(err))
            I += results[-1]
        if err > epsilon:
            if verbose:
                print("Failed to reach full accuracy. Estimated error:", ctx.nstr(err))
        return I, err
def summation ( self , f , points , prec , epsilon , max_degree , verbose = False ) : ctx = self . ctx I = err = ctx . zero for i in xrange ( len ( points ) - 1 ) : a , b = points [ i ] , points [ i + 1 ] if a == b : continue # XXX: we could use a single variable transformation, # but this is not good in practice. We get better accuracy # by having 0 as an endpoint. if ( a , b ) == ( ctx . ninf , ctx . inf ) : _f = f f = lambda x : _f ( - x ) + _f ( x ) a , b = ( ctx . zero , ctx . inf ) results = [ ] for degree in xrange ( 1 , max_degree + 1 ) : nodes = self . get_nodes ( a , b , degree , prec , verbose ) if verbose : print ( "Integrating from %s to %s (degree %s of %s)" % ( ctx . nstr ( a ) , ctx . nstr ( b ) , degree , max_degree ) ) results . append ( self . sum_next ( f , nodes , degree , prec , results , verbose ) ) if degree > 1 : err = self . estimate_error ( results , prec , epsilon ) if err <= epsilon : break if verbose : print ( "Estimated error:" , ctx . nstr ( err ) ) I += results [ - 1 ] if err > epsilon : if verbose : print ( "Failed to reach full accuracy. Estimated error:" , ctx . nstr ( err ) ) return I , err