0.1 0.995

0.2 0.98007

0.3 0.95534

0.4 0.92106

0.5 0.87758

0.6 0.82534

0.7 0.76484

0.8 0.69671

0.9 0.62161

1.0 0.5403

1.1 0.4536

1.2 0.36236

1.3 0.2675

1.4 0.16997

1.5 0.07074

1.6 -0.0292

1.7 -0.12884

1.8 -0.2272

1.9 -0.32329

2.0 -0.41615

2.1 -0.50485

2.2 -0.5885

2.3 -0.66628

2.4 -0.73739

2.5 -0.80114

2.6 -0.85689

2.7 -0.90407

2.8 -0.94222

2.9 -0.97096

3.0 -0.98999

In [7]: import pylab as p

In [8]: p.plot(x, y, '*b', ms=20)

Out[8]: [<matplotlib.lines.Line2D at 0x1e15eacf390>]

In [9]: x1, y2 = myfun1(0, 3, 0.1)

In [10]: x1, y1 = myfun1(0, 3, 0.1)

In [11]: p.plot(x, y, '*b', x1, y1, 'ro', ms=20)

Out[11]:

[<matplotlib.lines.Line2D at 0x1e15f32aa58>,

<matplotlib.lines.Line2D at 0x1e15f32ac18>]

In [12]: x2, y2 = myfun1(0, 3, 0.1)

In [13]: p.plot(x, y, '*b', x1, y1, 'ro', x2, y2, 'g+', ms=20)

Out[13]:

[<matplotlib.lines.Line2D at 0x1e15f394748>,

<matplotlib.lines.Line2D at 0x1e15f394908>,

<matplotlib.lines.Line2D at 0x1e15f394a90>]

In [14]: x2, y2 = myfun3(0, 3, 0.1)

In [15]: p.plot(x, y, '*b', x1, y1, 'ro', x2, y2, 'g+', ms=20)

Out[15]:

[<matplotlib.lines.Line2D at 0x1e15f3f9390>,

<matplotlib.lines.Line2D at 0x1e15f3f9550>,

<matplotlib.lines.Line2D at 0x1e15f3f9f60>]

In [16]: x1, y1 = myfun(m.cos, 0, 3, 0.1)

In [17]: p.plot(x, y, '*b', x1, y1, 'ro', x2, y2, 'g+', ms=20)

Out[17]:

[<matplotlib.lines.Line2D at 0x1e15f459d68>,

<matplotlib.lines.Line2D at 0x1e15f459ef0>,

<matplotlib.lines.Line2D at 0x1e15f45f978>]

In [18]: x1, y1 = myfun(m.sin, 0, 3, 0.1)

In [19]: p.plot(x1, y1, 'sg', ms=20)

Out[19]: [<matplotlib.lines.Line2D at 0x1e15f4c1710>]

In [20]: x1, y1 = myfun(m.cos, 0, 3, 0.1)

In [21]: p.plot(x1, y1, 'sg', ms=20)

Out[21]: [<matplotlib.lines.Line2D at 0x1e15f527390>]

In [22]: x1, y1 = myfun(x2, 0, 3, 0.1)

Traceback (most recent call last):

File "<ipython-input-22-4602c0572731>", line 1, in <module>

x1, y1 = myfun(x2, 0, 3, 0.1)

File "//filestore.soton.ac.uk/users/oh1m12/mydocuments/20172018/Lecture6/lecture6_high.py", line 95, in myfun

y.append(f(x_elem))

TypeError: 'list' object is not callable

In [23]: runfile('//filestore.soton.ac.uk/users/oh1m12/mydocuments/20172018/Lecture6/lecture6_high.py', wdir='//filestore.soton.ac.uk/users/oh1m12/mydocuments/20172018/Lecture6')

In [24]: x1, y1 = myfun(x2, 0, 3, 0.1)

In [24]:

In [25]: p.plot(x1, y1, 'o')

Out[25]: [<matplotlib.lines.Line2D at 0x1e15f598860>]

In [26]: runfile('//filestore.soton.ac.uk/users/oh1m12/mydocuments/20172018/Lecture6/lecture6_high.py', wdir='//filestore.soton.ac.uk/users/oh1m12/mydocuments/20172018/Lecture6')

In [27]: x, y = myfun(x2)

In [28]: p.plot(x, y)

Out[28]: [<matplotlib.lines.Line2D at 0x1e15f601dd8>]

In [29]: x, y = myfun(x2, -1, 1, 0.01)

In [30]: p.plot(x, y)

Out[30]: [<matplotlib.lines.Line2D at 0x1e15f662b70>]

In [31]: x, y = myfun(m.cos)

In [32]: p.plot(x, y)

Out[32]: [<matplotlib.lines.Line2D at 0x1e15f6bcc18>]

In [33]: from scipy.integrate import quad

Out[34]: (0.33333333333333337, 3.700743415417189e-15)

Out[35]: (0.8414709848078965, 9.34220461887732e-15)

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

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

instead be a ctypes function of the form:

f(int n, double args[n]),

where args is an array of function arguments and n is the

length of args. f.argtypes should be set to

(c_int, c_double), and f.restype should be (c_double,).

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

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.

--------

nquad : n-dimensional integrals (uses quad recursively)

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

(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)

(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)

#(1.3333333333333333, 1.4802973661668752e-14)

print((1.0**3/3.0 + 1.0) - (0.0**3/3.0 + 0.0)) #Analytic result

# 1.3333333333333333

In [37]: quad(m.cos, 0, 1, full_output=1)

Out[37]:

(0.8414709848078965,

9.34220461887732e-15,

{'alist': array([ 0.00000000e+000, 7.74860419e-304, 7.74860419e-304,

7.74860419e-304, 7.74860419e-304, 7.74860419e-304,

7.74860419e-304, 7.74860419e-304, 7.74860419e-304,

7.74860419e-304, 7.74860419e-304, 7.74860419e-304,

7.74860419e-304, 7.74860419e-304, 7.74860419e-304,

7.74860419e-304, 7.74860419e-304, 7.74860419e-304,

7.74860419e-304, 7.74860419e-304, 7.74860419e-304,

7.74860419e-304, 7.74860419e-304, 7.74860419e-304,

7.74860419e-304, 7.74860419e-304, 7.74860419e-304,

7.74860419e-304, 7.74860419e-304, 7.74860419e-304,

7.74860419e-304, 7.74860419e-304, 7.74860419e-304,

7.74860419e-304, 7.74860419e-304, 7.74860419e-304,

7.74860419e-304, 7.74860419e-304, 7.74860419e-304,

7.74860419e-304, 7.74860419e-304, 7.74860419e-304,

7.74860419e-304, 7.74860419e-304, 7.74860419e-304,

7.74860419e-304, 7.74860419e-304, 7.74860419e-304,

7.74860419e-304, 7.74860419e-304]),

'blist': array([ 1.00000000e+000, 1.02147086e-311, 1.02139878e-311,

1.02145608e-311, 1.02145623e-311, 1.02139878e-311,

1.02147036e-311, 1.02147056e-311, 1.02145618e-311,

1.02145607e-311, 1.02145608e-311, 1.02145618e-311,

1.02145609e-311, 1.02145623e-311, 1.02139878e-311,

1.02147086e-311, 1.02139878e-311, 1.02145609e-311,

1.02145607e-311, 1.02145609e-311, 1.02147084e-311,

1.02145608e-311, 1.02147084e-311, 1.02147044e-311,

1.02146891e-311, 1.02145622e-311, 1.02146955e-311,

1.02147044e-311, 1.02147044e-311, 1.02145623e-311,

1.02139878e-311, 1.02147084e-311, 1.02147084e-311,

1.02147084e-311, 1.02145622e-311, 1.02145618e-311,

1.02145607e-311, 1.02145618e-311, 1.02145623e-311,

1.02147044e-311, 1.02147084e-311, 1.02147044e-311,

1.02147084e-311, 1.02147044e-311, 1.02147044e-311,

1.02146917e-311, 1.02139878e-311, 1.02145618e-311,

1.02145618e-311, 1.02147091e-311]),

'elist': array([ 9.34220462e-015, 1.02145607e-311, 1.02146918e-311,

1.02145607e-311, 1.02147013e-311, 1.02139878e-311,

1.02145608e-311, 1.02145607e-311, 1.02145607e-311,

1.02146918e-311, 1.02139878e-311, 1.02145608e-311,

1.02145610e-311, 1.02139878e-311, 1.02145607e-311,

1.02145607e-311, 1.02145622e-311, 1.02145608e-311,

1.02147011e-311, 1.02139878e-311, 1.02145607e-311,

1.02145608e-311, 1.02139878e-311, 1.02147008e-311,

1.02139878e-311, 1.02146918e-311, 1.02139878e-311,

1.02145607e-311, 1.02145607e-311, 1.02146998e-311,

1.02139878e-311, 1.02145607e-311, 1.02146998e-311,

1.02139878e-311, 1.02146918e-311, 1.02146998e-311,

1.02146918e-311, 1.02147008e-311, 1.02147008e-311,

1.02147008e-311, 1.02147008e-311, 1.02147006e-311,

1.02147006e-311, 1.02147006e-311, 1.02145622e-311,

1.02147006e-311, 1.02145622e-311, 1.02145622e-311,

1.02146998e-311, 1.02146998e-311]),

'iord': array([ 1, 481, 1599759920, 481, 1460202552,

481, 1599040960, 481, 1460622704, 481,

1571049808, 481, 1460202552, 481, 1599041352,

481, 1460622704, 481, 1571052112, 481,

1460202552, 481, 1560294936, 481, 1460622704,

481, 1600767408, 481, 1460202552, 481,

1560334096, 481, 1460334752, 481, 312,

0, 226, 0, 139, 0,

48, 131, 48, 256, 48,

381, 139, 512, 1460334752, 481], dtype=int32),

'last': 1,

'neval': 21,

'rlist': array([ 8.41470985e-001, 1.02147094e-311, 1.02139878e-311,

1.02145607e-311, 1.02145623e-311, 1.02139878e-311,

1.02147086e-311, 1.02147056e-311, 1.02145618e-311,

1.02145608e-311, 1.02145608e-311, 1.02145618e-311,

1.02145609e-311, 1.02145623e-311, 1.02139878e-311,

1.02147094e-311, 1.02139878e-311, 1.02145609e-311,

1.02145607e-311, 1.02145609e-311, 1.02147042e-311,

1.02145608e-311, 1.02147036e-311, 1.02147044e-311,

1.02147084e-311, 1.02145622e-311, 1.02147084e-311,

1.02147044e-311, 1.02147044e-311, 1.02145623e-311,

1.02139878e-311, 1.02147036e-311, 1.02147085e-311,

1.02147085e-311, 1.02145622e-311, 1.02145618e-311,

1.02145607e-311, 1.02145618e-311, 1.02145623e-311,

1.02147044e-311, 1.02147085e-311, 1.02147084e-311,

1.02147085e-311, 1.02147044e-311, 1.02147044e-311,

1.02147084e-311, 1.02139878e-311, 1.02145618e-311,

1.02145618e-311, 1.02147094e-311])})

Out[38]: (0.8414709848078965, 9.34220461887732e-15)

In [39]: x, y = myfun(x2, 0, 1)

In [40]: x, y = myfun(x2, dx=0.2)

In [41]: x, y = myfun(x2, xi=0, xf=1)

In [42]: x, y = myfun(x2, xf=1, xi=0)

In [43]: