POLY : A new polynomial data structure for Maple.

Transcription

1 : A new polynomial data structure for Maple. Center for Experimental and Constructive Mathematics Simon Fraser University British Columbia CANADA ASCM 2012, Beijing, October 26-28, 2012 This is joint work with Roman Pearce.

2 Talk Outline Polynomial data structures in Maple and Singular are slow. Our new data structure

3 Talk Outline Polynomial data structures in Maple and Singular are slow. Our new data structure Johnson s polynomial multiplication using a heap from Our parallelization of it.

4 Talk Outline Polynomial data structures in Maple and Singular are slow. Our new data structure Johnson s polynomial multiplication using a heap from Our parallelization of it. Maple 16 integration of. A multiplication and factorization benchmark.

5 Talk Outline Polynomial data structures in Maple and Singular are slow. Our new data structure Johnson s polynomial multiplication using a heap from Our parallelization of it. Maple 16 integration of. A multiplication and factorization benchmark. Maple 17 integration of. New timings for same benchmark.

6 Talk Outline Polynomial data structures in Maple and Singular are slow. Our new data structure Johnson s polynomial multiplication using a heap from Our parallelization of it. Maple 16 integration of. A multiplication and factorization benchmark. Maple 17 integration of. New timings for same benchmark. Notes on integration into Maple 17 kernel.

7 Talk Outline Polynomial data structures in Maple and Singular are slow. Our new data structure Johnson s polynomial multiplication using a heap from Our parallelization of it. Maple 16 integration of. A multiplication and factorization benchmark. Maple 17 integration of. New timings for same benchmark. Notes on integration into Maple 17 kernel. Status of Maple 17 integration.

8 Representations for 9 xy 3 z 4 y 3 z 2 6 xy 2 z 8 x 3 5. PROD 7 x 1 y 3 z 1 Maple 16 PROD 5 y 3 z PROD 7 x 2 1 y 2 z 1 PROD 3 x 3 SUM

9 Representations for 9 xy 3 z 4 y 3 z 2 6 xy 2 z 8 x 3 5. PROD 7 x 1 y 3 z 1 Maple 16 PROD 5 y 3 z PROD 7 x 2 1 y 2 z 1 PROD 3 x 3 SUM Singular x y z Memory access is not sequential. Monomial multiplication costs O(100) cycles.

10 Our representation 9 xy 3 z 4 y 3 z 2 6 xy 2 z 8 x 3 5. SEQ 4 x y z Monomial encoding for graded lex order with x>y >z Encodes x i y j z k in a single word d i j k where d = i+j+k. Advantages

11 Our representation 9 xy 3 z 4 y 3 z 2 6 xy 2 z 8 x 3 5. SEQ 4 x y z Monomial encoding for graded lex order with x>y >z Encodes x i y j z k in a single word d i j k where d = i+j+k. Advantages It s more compact (2 words per term instead of 9). Memory access is sequential. Fewer objects to clutter tables. Monomial > and cost one instruction.

12 Parallel polynomial multiplication and division using heaps. Let f = f 1 + f f n and g = g 1 + g g m. Compute f g = f 1 g + f 2 g + + f n g. Naive merge: O(mn 2 ) comparisons. Johnson (1974) simultaneous n-ary merge (heap): O(mn log n).

13 Parallel polynomial multiplication and division using heaps. Let f = f 1 + f f n and g = g 1 + g g m. Compute f g = f 1 g + f 2 g + + f n g. Naive merge: O(mn 2 ) comparisons. Johnson (1974) simultaneous n-ary merge (heap): O(mn log n). [MM, RP (2009)] parallel multiplication. [MM, RP (2010)] parallel division. Global Heap Local Heaps f g 4 Target architecture: Intel Core i7 (quad core)

14 Old multiplication and factorization benchmark. Intel Core i GHz (4 cores) Times in seconds Maple Maple 16 Magma Singular Mathem multiply 13 1 core 4 cores atica 7 p 1 := f 1(f 1 + 1) p 4 := f 4(f 4 + 1) factor Hensel lifting is mostly polynomial multiplication! p terms p terms f 1 = (1 + x + y + z) f 4 = (1 + x + y + z + t) terms terms Parallel speedup for f 4 (f 4 + 1) is 1.81 /.632 = Why?

15 Maple 16 Integration of To expand sums f g Maple calls expand/bigprod(f,g) if #f > 2 and #g > 2 and #f #g > expand/bigprod := proc(a,b) # multiply two large sums if type(a,polynom(integer)) and type(b,polynom(integer)) then x := indets(a) union indets(b); k := nops(x); A := sdmp:-import(a, plex(op(x)), pack=k); B := sdmp:-import(b, plex(op(x)), pack=k); C := sdmp:-multiply(a,b); return sdmp:-export(c); else... expand/bigdiv := proc(a,b,q) # divide two large sums... x := indets(a) union indets(b); k := nops(x)+1; A := sdmp:-import(a, grlex(op(x)), pack=k); B := sdmp:-import(b, grlex(op(x)), pack=k);...

16 Make the default representation in Maple. If we can pack all monomials into one word use SEQ 4 x y z O(1) O(n) O(n + t) degree(f); lcoeff(f); indets(f); has(f,z); type(f,polynom(integer)); degree(f,x); expand(x*t); diff(f,x); For f with t terms in n variables.

17 Almost everything is fast. command Maple 16 Maple 17 speedup notes coeff(f, x, 20) s s 420x terms easy to locate coeffs(f, x) s s 8x reorder exponents and radix frontend(g, [f ]) s s O(n) looks at variables only degree(f, x) s s 24x stop early using monomial de diff(f, x) s s 30x terms remain sorted eval(f, x = 6) s s 21x use Horner form recursively expand(2 x f ) s s 18x terms remain sorted indets(f ) s s O(1) first word in dag op(f ) s s 0.26x has to construct old structur for t in f do s s 0.26x has to construct old structur subs(x = y, f ) s s 15x combine exponents, sort, me taylor(f, x, 50) s s 12x get coefficients in one pass type(f, polynom) s s O(n) type check variables only For f with n = 3 variables and t = 10 6 terms created by f := expand(mul(randpoly(v,degree=100,dense),v=[x,y,z])):

18 New multiplication and factorization benchmark Intel Core i GHz (4 cores) Times in seconds Maple 16 Maple 17 Magma Singular multiply 1 core 4 cores 1 core 4 cores p 1 := f 1(f 1 + 1) p 4 := f 4(f 4 + 1) factor Singular s factorization improved! p terms p terms f 1 = (1 + x + y + z) f 4 = (1 + x + y + z + t) terms terms Parallel speedup for f 4 (f 4 + 1) is 1.730/0.508 = 3.41.

19 Profile for factor(p1); Profile for factor(p1); Real time from 2.63s to 1.11s real. Maple 16 New Maple function #calls time time% time time% coeftayl s s expand s s factor/diophant s s divide s s 4.56 factor s s 1.41 factor/hensel s s 6.22 factor/unifactor s s 3.57 total: s % 1.206s % The coeftayl(f,x=a,k); command is defined by coeff(taylor(f,x=a,k+1),x,k); and is computed via eval(diff(f,x$k),x=a) / k! which is 4x faster.

20 Notes on the new integration for Maple 17. Given a polynomial f (x 1, x 2,..., x n ), we store f using if (1) f is expanded and has integer coefficients, (2) d > 1 and t > 1 where d = deg f and t = #terms, (3) we can pack all monomials of f into one 64 bit word, i.e. if d < 2 b where b = 64 n+1 Otherwise we use the old sum-of-products representation.

21 Notes on the new integration for Maple 17. Given a polynomial f (x 1, x 2,..., x n ), we store f using if (1) f is expanded and has integer coefficients, (2) d > 1 and t > 1 where d = deg f and t = #terms, (3) we can pack all monomials of f into one 64 bit word, i.e. if d < 2 b where b = 64 n+1 Otherwise we use the old sum-of-products representation. The representation is invisible to the Maple user. Conversions are automatic.

22 Notes on the new integration for Maple 17. Given a polynomial f (x 1, x 2,..., x n ), we store f using if (1) f is expanded and has integer coefficients, (2) d > 1 and t > 1 where d = deg f and t = #terms, (3) we can pack all monomials of f into one 64 bit word, i.e. if d < 2 b where b = 64 n+1 Otherwise we use the old sum-of-products representation. The representation is invisible to the Maple user. Conversions are automatic. polynomials will be displayed in sorted order.

23 Notes on the new integration for Maple 17. Given a polynomial f (x 1, x 2,..., x n ), we store f using if (1) f is expanded and has integer coefficients, (2) d > 1 and t > 1 where d = deg f and t = #terms, (3) we can pack all monomials of f into one 64 bit word, i.e. if d < 2 b where b = 64 n+1 Otherwise we use the old sum-of-products representation. The representation is invisible to the Maple user. Conversions are automatic. polynomials will be displayed in sorted order. Packing is fixed by n = #variables.

24 Notes on the new integration for Maple 17. Given a polynomial f (x 1, x 2,..., x n ), we store f using if (1) f is expanded and has integer coefficients, (2) d > 1 and t > 1 where d = deg f and t = #terms, (3) we can pack all monomials of f into one 64 bit word, i.e. if d < 2 b where b = 64 n+1 Otherwise we use the old sum-of-products representation. The representation is invisible to the Maple user. Conversions are automatic. polynomials will be displayed in sorted order. Packing is fixed by n = #variables. If n = 8, (3) = we use b = 64/9 = 7 bits per exponent field hence restricts d < 128.

25 Current Work and Paper Content We are trying to get it ready for Maple 17.

26 Current Work and Paper Content We are trying to get it ready for Maple 17. Avoid operations like indets(f,type) which unpack.

27 Current Work and Paper Content We are trying to get it ready for Maple 17. Avoid operations like indets(f,type) which unpack. Some external C libraries need support

28 Current Work and Paper Content We are trying to get it ready for Maple 17. Avoid operations like indets(f,type) which unpack. Some external C libraries need support The different ordering has exposed hidden bugs. The paper gives details on

29 Current Work and Paper Content We are trying to get it ready for Maple 17. Avoid operations like indets(f,type) which unpack. Some external C libraries need support The different ordering has exposed hidden bugs. The paper gives details on Why we chose a graded ordering instead of lex order.

30 Current Work and Paper Content We are trying to get it ready for Maple 17. Avoid operations like indets(f,type) which unpack. Some external C libraries need support The different ordering has exposed hidden bugs. The paper gives details on Why we chose a graded ordering instead of lex order. How we repack polynomials efficiently e.g. for coeff(f, x, k).

31 Current Work and Paper Content We are trying to get it ready for Maple 17. Avoid operations like indets(f,type) which unpack. Some external C libraries need support The different ordering has exposed hidden bugs. The paper gives details on Why we chose a graded ordering instead of lex order. How we repack polynomials efficiently e.g. for coeff(f, x, k). A determinant benchmark showing a factor of 50 speedup.

32 Current Work and Paper Content We are trying to get it ready for Maple 17. Avoid operations like indets(f,type) which unpack. Some external C libraries need support The different ordering has exposed hidden bugs. The paper gives details on Why we chose a graded ordering instead of lex order. How we repack polynomials efficiently e.g. for coeff(f, x, k). A determinant benchmark showing a factor of 50 speedup. Thank you for attending my talk.