strings, dictionaries, and files

Size: px

Start display at page:

Download "strings, dictionaries, and files"

Annis May
6 years ago
Views:

1 strings, dictionaries, and 1 2 MCS 507 Lecture 18 Mathematical, Statistical and Scientific Software Jan Verschelde, 3 October 2011

2 strings, dictionaries, and 1 2

3 data structures Python glues with strings,, and dictionaries: String representations of objects serve well to pass data between different programs. On we store objects permanently. A dictionary associates keys to values and scales well to organize large data sets. page 3

4 multivariate polynomials Our mathematical object of today is a polynomial in several variables with complex coefficients. The basic data structure is a tuple of two lists: a list of coefficients of type complex, a list of tuples, exponents are natural numbers. The monomial ( j)*x1**2*x2**4 is the kth element in the exponent list: (2, 4) and kth coefficient: ( j). page 4

5 random polynomials We generate random polynomials as follows: 1 Generate a list C of random coefficients: c = cos(θ) + I sin(θ) for angles θ uniformly distributed in [0, 2π]. 2 Generate a list E of random exponents, the exponents of a monomial are stored in a tuple t: 1 for a number of variables n choose an index k {0, 1,...,n 1}, 2 do a coin flip e [0, 1]: t k = t k + e, and repeat d times for a monomial of degree d. So a polynomial p is then the tuple (C, E). page 5

6 string representations Defining a string representation for (C, E): instead of tuple of lists, we see p as a polynomial, we verify (C, E) as a sympy expression with eval. For n variables, we have n symbols in the list S. p = "" for all c C and e E do t = str(c) for all k {0, 1,...,n} do if e k > 0 then t = t + * + S k if e k > 1 then t = t + ** + str(e k ) p = p + t page 6

7 strings, dictionaries, and 1 2

8 duplicate monomials If we generate many monomials of low degree, then duplicate exponents are very likely. Goal: add coefficients of monomials with same exponents. Store (C, E) into a dictionary D: D[e] = c for all pairs (c, e) with c C, e E. Every key in the dictionary is unique: if D.has_key(e), then D[e] = D[e] + c. Then p is described as D = {e : c, e E, c C}. page 8

9 Five monomials in three unknowns: a polynomial on file Every line has one monomial: real and complex part of the coefficient, followed by n natural numbers. page 9

10 Opening and closing : file = open(name, w ) for writing, file = open(name, r ) for reading. file.close() sends buffer to file when w. Writing and reading lines to file: s = str(data); file.write(s + \n ) line = file.readline() L = line.split( ) The result of line.split( ) is a list L of items which are separated by spaces in the string line. page 10

11 To convert lines separated by spaces to a comma separated value (csv) file, we convert lines with split and join: split and join >>> line = " " >>> L = line.split( ) >>> L [ , ,, 3, 0, 1 ] >>> s =,.join(l) >>> s ,0.0841,,3,0,1 >>> line.split() [ , , 3, 0, 1 ] page 11

12 We develop the code in two : two Python modules 1 A module to generate random polynomials: generate coefficients C and exponents E, turn (C, E) into string representation and then into sympy expression. 2 A module to make a dictionary representation and write/read a random polynomial to/from file. page 12

13 strings, dictionaries, and 1 2

14 random coefficients def random_coefficient(): Returns a random complex coefficient, uniformly distributed on the unit circle. from math import cos, sin, pi from random import uniform u = uniform(0,2*pi) return complex(cos(u),sin(u)) page 14

15 random exponents def random_exponent(n,d): Returns an n-tuple obtained after d coin flips. from random import randint L = [0 for i in xrange(n)] for i in xrange(d): L[randint(0,n-1)] += randint(0,1) return tuple(l) page 15

16 a random polynomial def (n,d,m): A random polynomial in n variables of degree at most d and m terms is returns as a tuple of two lists: coefficients and exponents. C = [random_coefficient() for i in xrange(m)] E = [random_exponent(n,d) for i in xrange(m)] return (C,E) page 16

17 the main function def main(): Prompts the user for number of variables, largest degree, number of monomials, and then generates a random polynomial. n = input( give number of variables : ) d = input( give the largest degree : ) m = input( give number of monomials : ) (C,E) = (n,d,m) print coefficients & exponents :, (C,E) S = [ x + str(i) for i in xrange(1,n+1)] strp = strpoly(s,c,e) print string representation :, strp page 17

18 monomials as strings def strmon(s,c,e): Returns a string representation of a monomial using the list of symbols in S, the coefficient c, and the exponents e. r = ( + + str(c)) for i in xrange(len(e)): if e[i] > 0: r += ( * + S[i]) if e[i] > 1: r += ( ** + str(e[i])) return r page 18

19 polynomials as strings def strpoly(s,c,e): Returns a string representation of a polynomial in the variables in S with coefficients in C and exponents in E. p = "" for i in xrange(len(c)): p += strmon(s,c[i],e[i]) return p page 19

20 sympy expressions import sympy as sp def sympypoly(s,c,e): Turns the polynomial with coefficients in C, exponents in E and symbols in S into a sympy expression. strp = strpoly(s,c,e) sp.var(s) return eval(strp) page 20

21 strings, dictionaries, and 1 2

22 sympy >>> import sympy as sp >>> x,y = sp.var( x,y ) >>> s = 2*x + y - 8 >>> p = eval(s) >>> p 2*x + y - 8 >>> type(p) <class sympy.core.add.add > >>> q = sp.poly(p) >>> type(q) <class sympy.polys.polytools.poly > >>> q Poly(2*x + y - 8, x, y, domain= ZZ ) >>> q.terms() [((1, 0), 2), ((0, 1), 1), ((0, 0), -8)] page 22

23 import as rp import sympy as sp the main function def main(): Tests manipulation of a random polynomial as a sympy polynomial. (C,E) = rp.(3,7,5) S = [ x, y, z ] p = rp.sympypoly(s,c,e) q = sp.poly(p) print a random polynomial :, q page 23

24 the I in sympy $ python.py a random polynomial : Poly( *x**2*z** *x**2*z** *x*y**2* *x*y**2*z *x*y*z*I *x*y*z *y*z**3*I *y*z** *y*z**2*I *y*z**2, x, y, z, I, domain= RR ) Problem: I is another variable in sympy, exponent tuples are 4-tuples in the example above. page 24

25 sympy Poly dict def dictpoly(p): Returns a dictionary representation of the polynomial p. The imaginary unit I is the last power of every exponent. R = {} T = p.terms() for t in T: (e,c) = t a = e[0:-1] Ideg = e[len(e)-1] cf = (c if Ideg == 0 else complex(0,c)) if not R.has_key(a): R[a] = cf else: R[a] += cf return R page 25

26 tableau format def strexp(e): Returns a string representation of the exponent in the tuple e. s = "" for d in e: s += ( + str(d)) return s def dictprint(n,d): Prints the tableau format of the dictionary D, n = #variables. print len(d), n for k in D.keys(): c = D[k] print sp.re(c), sp.im(c), strexp(k) page 26

27 writing to file def dictwrite(name,n,d): Writes the dictionary D in tableau format to file with the given name. file = open(name, w ) s = str(len(d)) + + str(n) + \n file.write(s) for k in D.keys(): c = D[k] s = str(sp.re(c)) s += + str(sp.im(c)) s += + strexp(k) + \n file.write(s) file.close() page 27

28 extracting monomials def cffexp(s): Returns the tuple of coefficient and exponent stored in s. L = s.split( ) c = complex(eval(l[0]),eval(l[1])) e = [] for k in xrange(2,len(l)): if L[k]!= : e.append(eval(l[k])) return (c, tuple(e)) page 28

29 reading from file def dictread(name): Opens the file with name, reads it and returns the dictionary representation of the polynomial stored in the file. file = open(name, r ) line = file.readline() L = line.split( ); n = eval(l[1]) s = reading + L[0] + monomials s += in + str(n) + variables... print s; D = {} while True: s = file.readline() if s == : break (c,e) = cffexp(s); D[e] = c file.close() return D page 29

30 Summary + Exercises Strings, dictionaries, and help glue programs. Exercises: 1 Suppose our multivariate polynomials would be products of linear equations. Describe how you would change the data structures. Explain why expanding the polynomials with sympy is a very bad idea. 2 Change so that dense polynomials are generated. A polynomial of degree d is dense if all monomials of degree d appear with nonzero coefficient. page 30

31 homework & midterm The third homework is due on Wednesday 5 October, 10AM: exercises 2 and 3 of Lecture 8; 3 and 5 of Lecture 9; 3 and 4 of Lecture 10; 2 and 3 of Lecture 11; 1 and 5 of Lecture 12. Friday 7 October is our midterm exam, which could be either or An in-class conventional exam, open book and notes, but without computer; A take-home exam due on Monday 10 October at 10AM which must be solved individually, but will need the use of software. page 31

strings, dictionaries, and files

strings, dictionaries, and files 1 Polynomials in Several Variables representing and storing polynomials polynomials in dictionaries and in files 2 Two Modules in Python the module randpoly the module