Arbitrary Precision and Symbolic Calculations

Transcription

1 Arbitrary Precision and Symbolic Calculations K. 1 1 Department of Mathematics 2018

2 Sympy There are several packages for Python that do symbolic mathematics. The most prominent of these seems to be Sympy. Sympy stands for Symbolic Python. Sympy is a separate project from Numpy, Scipy, Pylab, and Matplotlib. We can typically pick what we want from those and load them using from *py import * Don t do that with Sympy.

3 Loading Sympy from numpy import * import sympy as sp I recommend doing it this way because Sympy has many functions with the same names as common math or Numpy functions. For example, sp.zeros(5) returns a Sympy 5 5 matrix of sympy.core.numbers.zero values, while zeros(5) returns a 5 1 array of zeros with type numpy.float64. Failing to keep these packages straight can lead to a great deal of confusion and frustration.

4 Numbers Sympy understands many more basic data types than simple int and float. z = sp.zeros(3) z[0,1]=3 type(z[0,1]) gives a result of class sympy.core.numbers.integer. z[0,2] = 3. give a result of class sympy.core.numbers.float

5 Numbers z[1,0] = sp.pi yields a result of type sympy.core.numbers.pi while z[1,1] = pi gives a type sympy.core.numbers.float z[1,2] = sp.exp(1) has type sympy.core.numbers.exp1

6 Rationals We can do rational numbers in Sympy: z[2,1] = sp.rational(2,5) print(z[2,1]) yields 2/5. This has type sympy.core.numbers.rational, by the way. Observe the capital R and the comma in the arguments. z[2,2] = sp.rational(1/2) type(z[2,2]) gives sympy.core.numbers.zero. But z[2,2] = sp.rational(1,2) type(z[2,2]) is sympy.core.numbers.half

7 Floating Point We can evaluate any number to arbitrary precision using the evalf() method. q = sp.rational(3,7) print(q.evalf()) gives Not good enough? q.evalf(51) gives Likewise, sp.pi.evalf(51) is

8 Exactness The good and bad news in this is that Sympy knows the difference between an exact number and an approximation. a = sin(pi/4) print(a) b = sp.sin(pi/4) print(b) c = sp.sin(sp.pi/4) print(c) gives , , and sqrt(2)/2, respectively.

9 Precision Sympy floating point numbers are different from the hardware floating point numbers used in Python and Numpy. However, Sympy by default uses the same precision in the mantissa as IEEE 754. a = sin(1) b = sp.sin(1) c = (a-b).evalf() yields e-18. But... a = sin(1) b = sp.sin(1).evalf() c = a-b yields 0.

10 Variables In Numpy/Python, every variable has a value. By contrast, we can make symbolic variables in Sympy, variables in a mathematical sense. There are a couple of ways to do this. sp.var( x,y ) makes x and y into variables. Often people use the syntax x,y = symbols( x,y ) to do the same thing.

11 Ranges of Variables We can make ranges of variables. sp.var( u:3 ) gives (u0, u1, u2). sp.var( a:d ) gives (a, b, c, d) a,b,c,d = sp.symbols( a:d ) does the same thing as the last.

12 Principles Symbolic calculation is very resource- and time-intensive. It is recursive. It is slow. Use symbolic calculation when you have a special need for it. Always convert to floating point or integer data types as soon as you can afford to.

13 Why would we use this? Suppose we want to demonstrate experimentally the relation ( e = lim ) n. n n def num_exp(n): return (1.+1./n)**n

14 Time required: 1.7e-4 seconds

15 Symbolic version The high-precision version is a bit different: here digit is 50. def sym_exp(n,digit): res = (1 + sp.rational(1,n).evalf(digit))**n.evalf(digit) return res

16 Time required: 2.0e-2 seconds

17 Caution! We could write the symbolic version badly (I did). def slo_exp(n,digit): res = (1 + sp.rational(1,n))**n return res.evalf(digit) This did not finish in the five minutes I gave it. Switch to floating point as early as possible. Even 50-digit floating point is spectacularly faster than rational calculations.

18 Functions vs. Expressions It is important in symbolic calculations to distinguish between functions and expressions. An expression is any combination of arithmetic operators with symbolic and numerical objects: e.g sp.var( x,alpha ) expr1 = x*x*x*x-alpha expr2 = sp.sin(x) A function is... a function. It maps arguments to some result. When we evaluate a function at a symbolic argument, the result is an expression.

19 Functions vs. Expressions f = lambda x: x*x*x*x-alpha v = f(2) results in v = -alpha u = f(x+2) gives u = -alpha + (x + 2)**4. The f is a function, while u and v are expressions.

20 Algebraic operations We can do algebraic operations on expressions. Most of these operations can be expressed as methods of the expressions, or as stand-alone functions. u.expand() or sp.expand(u) results in -alpha + x**4 + 8*x**3 + 24*x**2 + 32*x The expand() method just distributes multiplication over addition.

21 Factor The factor method tries to factor polynomials. (x*x+2*x+1).factor() sp.factor(x*x+2*x+1) give the same result: (x + 1)**2 sp.factor(x**3-3*x**2+x-3) yields (x - 3)*(x**2 + 1). sp.factor(x**3-3*x**2+x-3,extension=[sp.i]) gives (x - 3)*(x - I)*(x + I). Note that the imaginary unit in Sympy is I.

22 Fractions There are a couple of methods to handle fractional expressions. p = x**3-3*x**2+x-3 q = (x-2)*(x-1)*(x+3) r = sp.apart(p/q) results in 1-3/(x + 3) + 1/(x - 1) - 1/(x - 2) sp.together(r) gives ((x - 2)*(x - 1)*(x + 3) - 3*(x - 2)*(x - 1) + (x - 2)*(x + 3) - (x - 1)*(x + 3))/((x - 2)*(x - 1)*(x + 3)) Incidentally sp.numer(p/q) gives the numerator of the fraction; sp.denom(p/q)...

23 Simplify The simplify method tries to distribute, factor, cancel, and use some trig identities to make an expression smaller. r.together().simplify() gives (x**3-3*x**2 + x - 3)/(x**3-7*x + 6) ((x*x+2*x+1)/(x+1)).simplify() produces x + 1. Note that simplification is considered to be a purely formal process. No attention was paid to what happens if x = -1. sp.simplify(sp.tan(x)**2+1) results in cos(x)**(-2).

24 Substitution We can substitute into expressions. Recall that u = -alpha + (x + 2)**4. u.subs(x,0) gives -alpha+16. u.subs(x,x-2) gives -alpha + x**4. u.subs(x,0).subs(alpha,23) yields -7.