turning expressions into functions symbolic substitution, series, and lambdify

Transcription

1 Defining Functions 1 Lambda Functions turning expressions into functions symbolic substitution, series, and lambdify 2 Functions and Modules writing a function definition defining and using modules where does Python find its modules? 3 Documenting Software with Sphinx Sphinx generates documentation generating documentation for ourfirstmodule 4 Computing Series Developments exploring an example with a script series for expressions in two variables MCS 507 Lecture 7 Mathematical, Statistical and Scientific Software Jan Verschelde, 11 September 2013 Scientific Software (MCS 507 L-7) Defining Functions 11 September / 42

2 Defining Functions 1 Lambda Functions turning expressions into functions symbolic substitution, series, and lambdify 2 Functions and Modules writing a function definition defining and using modules where does Python find its modules? 3 Documenting Software with Sphinx Sphinx generates documentation generating documentation for ourfirstmodule 4 Computing Series Developments exploring an example with a script series for expressions in two variables Scientific Software (MCS 507 L-7) Defining Functions 11 September / 42

3 evaluating expressions Suppose we want to evaluate x 2 cos(y) + 4e z sin(x). >>> from math import cos, sin, exp >>> f = lambda x,y,z: x**2*cos(y) \ *exp(z)*sin(x) >>> f(1,2,3) >>> f(z=3,y=2,x=1) In f(z=3,y=2,x=1), we call f by its keyword arguments, linking the formal parameters x, y, z to the values 1, 2, 3. Scientific Software (MCS 507 L-7) Defining Functions 11 September / 42

4 evaluating strings Restarting the interactive Python session, making a function for x 2 cos(y) + 4e z sin(x), stored in a string: >>> e = x**2*cos(y) + 4*exp(z)*sin(x) >>> from math import cos, sin, exp >>> f = lambda x,y,z: eval(e) >>> f(1,2,3) >>> f(z=3,x=1,y=2) Scientific Software (MCS 507 L-7) Defining Functions 11 September / 42

5 Defining Functions 1 Lambda Functions turning expressions into functions symbolic substitution, series, and lambdify 2 Functions and Modules writing a function definition defining and using modules where does Python find its modules? 3 Documenting Software with Sphinx Sphinx generates documentation generating documentation for ourfirstmodule 4 Computing Series Developments exploring an example with a script series for expressions in two variables Scientific Software (MCS 507 L-7) Defining Functions 11 September / 42

6 symbolic substitution With the substitution of sympy, we can evaluate an expression in symbolically, e.g., to permute the variables (x, y, z) (z, y, x): >>> from sympy import * >>> x,y,z = var( x,y,z ) >>> e = x**2*cos(y) + 4*exp(z)*sin(x) >>> Subs(e,(x,y,z),(z,y,x)) Subs(_x**2*cos(_y) + 4*exp(_z)*sin(_x), \ (_x, _y, _z), (z, y, x)) >>> _.doit() z**2*cos(y) + 4*exp(x)*sin(z) Scientific Software (MCS 507 L-7) Defining Functions 11 September / 42

7 approximating functions With series we do symbolic-numeric computation: >>> from sympy import * >>> x = var( x ) >>> sin(x).series(x,x0=0,n=7) x - x**3/6 + x**5/120 + O(x**7) Using an iterator: >>> s = sin(x).series(x,n=none) >>> L = [s.next() for i in range(3)]; L [x, -x**3/6, x**5/120] We experience the O(x**7) when evaluating: >>> S = sum(l) >>> Subs(S,(x),(0.01)).doit() >>> Subs(sin(x),(x),(0.01)).doit() Scientific Software (MCS 507 L-7) Defining Functions 11 September / 42

8 lambdify >>> from sympy.utilities import lambdify >>> help(lambdify) >>> from sympy.abc import x >>> f = lambdify(x,x**2) >>> f(2) 4 >>> g = lambdify(x,"x**2") >>> g <function <lambda> at 0x23b3b90> >>> g(3) 9 Scientific Software (MCS 507 L-7) Defining Functions 11 September / 42

9 Defining Functions 1 Lambda Functions turning expressions into functions symbolic substitution, series, and lambdify 2 Functions and Modules writing a function definition defining and using modules where does Python find its modules? 3 Documenting Software with Sphinx Sphinx generates documentation generating documentation for ourfirstmodule 4 Computing Series Developments exploring an example with a script series for expressions in two variables Scientific Software (MCS 507 L-7) Defining Functions 11 September / 42

10 a function definition def fun(xarg, yarg, zarg): """ Returns the value of the expression xarg**2*cos(yarg) + 4*exp(zarg)*sin(xarg) for numerical values of the formal arguments xarg, yarg, and zarg. """ from math import exp, cos, sin result = xarg**2*cos(yarg) + 4*exp(zarg)*sin(xarg) return result Scientific Software (MCS 507 L-7) Defining Functions 11 September / 42

11 function definitions A function header (e.g., def fun(xarg, yarg, zarg):) consists of 1 The name of the function (e.g., fun) follows def. 2 Formal arguments of the function are (e.g., xarg, yarg, zarg): between round brackets ( and ); separated by commas. Round brackets are needed even if no arguments. 3 The colon : follows ). The documentation string (between triple quotes) is optional, but is strongly recommended. The function body may have local variables, e.g., result. Values (e.g., result) are returned with return result. Scientific Software (MCS 507 L-7) Defining Functions 11 September / 42

12 testing a function If we store the function definition for fun in the file ourfirstmodule.py, we can do >>> from ourfirstmodule import fun >>> fun(1,2,3) We import the function fun into an interactive Python session. Scientific Software (MCS 507 L-7) Defining Functions 11 September / 42

13 Defining Functions 1 Lambda Functions turning expressions into functions symbolic substitution, series, and lambdify 2 Functions and Modules writing a function definition defining and using modules where does Python find its modules? 3 Documenting Software with Sphinx Sphinx generates documentation generating documentation for ourfirstmodule 4 Computing Series Developments exploring an example with a script series for expressions in two variables Scientific Software (MCS 507 L-7) Defining Functions 11 September / 42

14 help(ourfirstmodule) Help on module ourfirstmodule: NAME ourfirstmodule FILE /home/jan/courses/mcs507/fall13/lec07/ourfirstmodule.py DESCRIPTION A module is a collection of functions. This module exports two functions: fun and main. By the last line of this file, we can run this script at the command prompt $ as $ python ourfirstmodule.py. Alternatively, we can import fun and/or main in an interactive Python session. What follows under DESCRIPTION is the documentation string of the module, stored in the variable doc. Scientific Software (MCS 507 L-7) Defining Functions 11 September / 42

15 help continued FUNCTIONS fun(xarg, yarg, zarg) Returns the value of the expression xarg**2*cos(yarg) + 4*exp(zarg)*sin(xarg) for numerical values of the formal arguments xarg, yarg, and zarg. main() Prompts the user for three values for the variables x, y, z and prints x**2*cos(y) + 4*exp(z)*sin(x). Scientific Software (MCS 507 L-7) Defining Functions 11 September / 42

16 the main function def main(): """ Prompts the user for three values for the variables x, y, z and prints x**2*cos(y) + 4*exp(z)*sin(x). """ print v = x**2*cos(y) + 4*exp(z)*sin(x) xval = input( give x : ) yval = input( give y : ) zval = input( give z : ) fval = fun(xval, yval, zval) print v =, fval At the time of the function call fun(xval, yval, zval), the values of xval, yval, zval are assigned to the formal arguments xarg, yarg, and zarg of the function definition. The variables xval, yval, zval are the actual arguments of the function. Scientific Software (MCS 507 L-7) Defining Functions 11 September / 42

17 running main() We can also import the function main(). In order to run main() as a program at the command prompt $ $ python ourfirstmodule.py the last line in ourfirstmodule.py is if name == " main ": main() Scientific Software (MCS 507 L-7) Defining Functions 11 September / 42

18 Defining Functions 1 Lambda Functions turning expressions into functions symbolic substitution, series, and lambdify 2 Functions and Modules writing a function definition defining and using modules where does Python find its modules? 3 Documenting Software with Sphinx Sphinx generates documentation generating documentation for ourfirstmodule 4 Computing Series Developments exploring an example with a script series for expressions in two variables Scientific Software (MCS 507 L-7) Defining Functions 11 September / 42

19 the module search path The module sys exports the module search path as the dynamic object path. >>> import sys >>> sys.path [,...,...] sys.path[0] is the script directory, or. The order of the directories in the list returned by sys.path determines the order in which Python searches for modules to import. Scientific Software (MCS 507 L-7) Defining Functions 11 September / 42

20 my math module def test(): print "This is my math module!" if name == " main ": test() If we save the code above as math.py in the current directory where we call the python interpreter, then: >>> import math >>> math.test() This is my math module! >> from math import cos Traceback (most recent call last): File "<stdin>", line 1, in <module> ImportError: cannot import name cos Scientific Software (MCS 507 L-7) Defining Functions 11 September / 42

21 doing an un-import What if we want to import the right math module? >>> import math >>> math.test() This is my math module! >>> import sys >>> sys.modules[ math ] <module math from math.py > >>> del sys.modules[ math ] modules is a dictionary of loaded modules, removing path[0]: >>> sys.path = sys.path[1:] >>> from math import cos >>> cos(3) Scientific Software (MCS 507 L-7) Defining Functions 11 September / 42

22 Defining Functions 1 Lambda Functions turning expressions into functions symbolic substitution, series, and lambdify 2 Functions and Modules writing a function definition defining and using modules where does Python find its modules? 3 Documenting Software with Sphinx Sphinx generates documentation generating documentation for ourfirstmodule 4 Computing Series Developments exploring an example with a script series for expressions in two variables Scientific Software (MCS 507 L-7) Defining Functions 11 September / 42

23 Sphinx generates documentation What is Sphinx? From Sphinx is a tool that makes it easy to create intelligent and beautiful documentation, written by Georg Brandl and licensed under the BSD license. It was originally created for the new Python documentation, and it has excellent facilities for the documentation of Python projects, but C/C++ is already supported as well, and it is planned to add special support for other languages as well. Sphinx uses restructuredtext as its markup language, and many of its strengths come from the power and straightforwardness of restructuredtext and its parsing and translating suite, the Docutils. The same documentation is generated in several formats, including latex, pdf, html. Why Sphinx? Used for the python language, numpy, sympy, matplotlib. Scientific Software (MCS 507 L-7) Defining Functions 11 September / 42

24 step-by-step documentation generation Given Python code with documentation strings, generate documentation with Sphinx. There are a few steps to take: 1 Make a new directory doc and do "cd doc". 2 Run sphinx-quickstart in the doc directory. Following default options, doc contains a "Makefile" and two directories: "build" and "source". 3 Edit conf.py in source as follows: sys.path.insert(0, os.path.abspath( <path> )) where <path> is the directory where our Python code is. 4 Edit index.rst with ".. automodule::" lines. 5 Type "make latexpdf" or "make html" to generate. Scientific Software (MCS 507 L-7) Defining Functions 11 September / 42

25 Defining Functions 1 Lambda Functions turning expressions into functions symbolic substitution, series, and lambdify 2 Functions and Modules writing a function definition defining and using modules where does Python find its modules? 3 Documenting Software with Sphinx Sphinx generates documentation generating documentation for ourfirstmodule 4 Computing Series Developments exploring an example with a script series for expressions in two variables Scientific Software (MCS 507 L-7) Defining Functions 11 September / 42

26 running sphinx-quickstart The doc directory is a subdirectory of the current directory that contains the module ourfirstmodule. Running sphinx-quickstart, some items: The root path is the current directory [.] if we run sphinx-quickstart in the doc directory. We want separate source and build directories. We can enter project name, author, version, and release numbers. Source files have suffix.rst. The master document is "index". We answer y to "autodoc" because we want automatically insert docstrings from modules. We answer y to "viewcode" to include links to the source code of documented Python objects. We also answer y to "Create Makefile?" Scientific Software (MCS 507 L-7) Defining Functions 11 September / 42

27 editing conf.py The source directory contains a file "conf.py" which we have to edit. sys.path.insert(0, os.path.abspath(../../ )) Because conf.py belongs to the directory source of the directory doc which is a subdirectory of the directory that contains ourfirstmodule.py. Scientific Software (MCS 507 L-7) Defining Functions 11 September / 42

28 editing index.rst Welcome to ourfirstmodule s documentation! ========================================== The module ourfirstmodule is an example of a module. Example of use in the Python shell: :: >>> from ourfirstmodule import fun >>> fun(1,2,3) What follows after the :: will appear in a special format on html pages. Scientific Software (MCS 507 L-7) Defining Functions 11 September / 42

29 use of automodule in index.rst the functions of ourfirstmodule The module ourfirstmodule exports one function fun and has a main program... automodule:: ourfirstmodule :members: The automodule will use the documentation string for each function of the module on the documentation pages. Scientific Software (MCS 507 L-7) Defining Functions 11 September / 42

30 a screen shot Scientific Software (MCS 507 L-7) Defining Functions 11 September / 42

31 Defining Functions 1 Lambda Functions turning expressions into functions symbolic substitution, series, and lambdify 2 Functions and Modules writing a function definition defining and using modules where does Python find its modules? 3 Documenting Software with Sphinx Sphinx generates documentation generating documentation for ourfirstmodule 4 Computing Series Developments exploring an example with a script series for expressions in two variables Scientific Software (MCS 507 L-7) Defining Functions 11 September / 42

32 example_series.py from sympy import sin, cos, exp from sympy.abc import x, y, z e = x**2*cos(y) + 4*exp(z)*sin(x) # developing e about x = 0, 4th order print e.series(x, x0=0, n=4) # using an iterator of the series tx = e.series(x, x0=0, n=none) Lx = [tx.next() for i in range(3)] print Lx =, Lx e3x = sum(lx) # observe there is no O() in e3x print sum(lx) =, e3x produces 4*x*exp(z) + x**2*cos(y) - 2*x**3*exp(z)/3 + O(x**4) Lx = [4*x*exp(z), x**2*cos(y), -2*x**3*exp(z)/3] sum(lx) = -2*x**3*exp(z)/3 + x**2*cos(y) + 4*x*exp(z) Scientific Software (MCS 507 L-7) Defining Functions 11 September / 42

33 the script continued Only the middle term of Lx contains a function in y: prints # developing e3x about y = 1 ty = Lx[1].series(y, n=none) Ly = [ty.next() for i in range(2)] print Ly =, Ly e2y = sum(ly) print e2y =, e2y Ly = [x**2, -x**2*y**2/2] e2y = -x**2*y**2/2 + x**2 Scientific Software (MCS 507 L-7) Defining Functions 11 September / 42

34 developing in z gives print e2y =, e2y # developing z about z = 0, 3rd order tz0 = Lx[0].series(z, n=none) tz2 = Lx[2].series(z, n=none) Lz0 = [tz0.next() for i in range(2)] print Lz0 =, Lz0 Lz2 = [tz2.next() for i in range(2)] print Lz2 =, Lz2 s = sum(lz0) + sum(ly) + sum(lz2) print s =, s Lz0 = [4*x, 4*x*z] Lz2 = [-2*x**3/3, -2*x**3*z/3] s = -2*x**3*z/3-2*x**3/3 - x**2*y**2/2 \ + x**2 + 4*x*z + 4*x Scientific Software (MCS 507 L-7) Defining Functions 11 September / 42

35 checking the series from sympy import Subs v = (0.01, 1.01, 0.01) ev = Subs(e, (x, y, z), v).doit() sv = Subs(s, (x, y, z), v).doit() print expression value =, ev print series value =, sv print difference =, abs(ev - sv) shows expression value = series value = difference = e-6 Scientific Software (MCS 507 L-7) Defining Functions 11 September / 42

36 Defining Functions 1 Lambda Functions turning expressions into functions symbolic substitution, series, and lambdify 2 Functions and Modules writing a function definition defining and using modules where does Python find its modules? 3 Documenting Software with Sphinx Sphinx generates documentation generating documentation for ourfirstmodule 4 Computing Series Developments exploring an example with a script series for expressions in two variables Scientific Software (MCS 507 L-7) Defining Functions 11 September / 42

37 running define_series.py The series() of sympy does not seem to apply for functions of several variables... $ python define_series.py give an expression : sin(x)*cos(y) give pair of variables : x,y give pair of orders : 2,2 x**3*y**2/12 - x**3/6 - x*y**2/2 + x Scientific Software (MCS 507 L-7) Defining Functions 11 September / 42

38 the function main() import sympy as sp def main(): """ Prompts user for an expression, a pair of variables and orders. """ from sympy import sin, cos expression = raw_input( give an expression : ) varpair = raw_input( give pair of variables (e.g.: x, y) : ) orders = input( give pair of orders (e.g.: 3, 4) : ) symvars = sp.var(varpair) print bivariate_series(eval(expression), symvars, orders) if name == " main ": main() Scientific Software (MCS 507 L-7) Defining Functions 11 September / 42

39 list comprehensions def bivariate_series(epr, varpair, orders): """ Returns a series of the expression epr in the pair of variables in varpair of respective orders in the pair orders. """ terms = epr.series(varpair[0], n=none) eterms = safe_expand(terms, orders[0]) terms2 = [a.series(varpair[1], n=none) for a in eterms] eterms2 = [safe_expand(t, orders[1]) for t in terms2] return sum([sum(term) for term in eterms2]) Scientific Software (MCS 507 L-7) Defining Functions 11 September / 42

40 exception handling def safe_expand(terms, order): """ Given an iterator, returns the list of terms up to the order order. Uses an exception handler to catch cases when there is no next term. """ result = [] for i in xrange(order): try: result.append(terms.next()) except StopIteration: return result return result Scientific Software (MCS 507 L-7) Defining Functions 11 September / 42

41 Summary + Exercises We started chapter 3 of the text book. Exercises: 1 The function numpy.linspace(a,b,n) returns a list of n equally spaced points in [a,b]. Write your own function definition for linspace. You may assume that n is at least 2 and a < b. 2 Compute the length of a path in the plane given by a list of coordinates (as tuples), see Exercise Extend the script define_series.py so it works for expressions in three variables. Test your solution on the expression x 2 cos(y) + 4e x sin(x). Scientific Software (MCS 507 L-7) Defining Functions 11 September / 42

42 more exercises 4 The formula T(t) = T + (T(0) T )e kt models the temperature T in function of time t. For k > 0, T(t) declines and models how an object cools off. Define a Python function that takes as arguments T(0), T, k, t and that returns T(t). 5 Use Sage or sympy to make a series approximation for T(t) from the previous exercise. Make a Python function from the series. Take various orders and compare the values at t = 0.1. The second homework is due on Friday 20 September, at 9AM: solve exercises 1 and 3 of Lecture 4; exercises 4 and 5 of Lecture 5; exercises 1, 2 and 5 of Lecture 6; exercises 1, 2, and 4 of Lecture 7. Scientific Software (MCS 507 L-7) Defining Functions 11 September / 42