1. The Polynomial ADT By Karim Kaddoura For CS146-6

2. Polynomial ADT What is it? ( Recall it from mathematics ) An example of a single variable polynomial: 4x 6 + 10x 4 - 5x + 3 Remark: the order of this polynomial is 6 (look for highest exponent)

3. Polynomial ADT (continued) Why call it an Abstract Data Type (ADT)? A single variable polynomial can be generalized as:

4. Polynomial ADT (continued) …This sum can be expanded to: a n x n + a (n-1) x (n-1) + … + a 1 x 1 + a 0 Notice the two visible data sets namely: (C and E), where C is the coefficient object [Real #]. and E is the exponent object [Integer #].

5. Polynomial ADT (continued) Now what? By definition of a data types: A set of values and a set of allowable operations on those values. We can now operate on this polynomial the way we like…

6. What kinds of operations? Here are the most common operations on a polynomial: Add & Subtract Multiply Differentiate Integrate etc… Polynomial ADT (continued)

7. Why implement this? Calculating polynomial operations by hand can be very cumbersome. Take differentiation as an example: d(23x 9 + 18x 7 + 41x 6 + 163x 4 + 5x + 3)/dx = (23*9)x (9-1) + (18*7)x (7-1) + (41*6)x (6-1) + …

8. Polynomial ADT (continued) How to implement this? There are different ways of implementing the polynomial ADT: Array (not recommended) Double Array (inefficient) Linked List (preferred and recommended)

9. Polynomial ADT (continued) Array Implementation: p1(x) = 8x 3 + 3x 2 + 2x + 6 p2(x) = 23x 4 + 18x - 3 6238 0 2 Index represents exponents -3180023 0 42 p1(x)p2(x)

10. This is why arrays arent good to represent polynomials: p3(x) = 16x 21 - 3x 5 + 2x + 6 Polynomial ADT (continued) 6200-30 016 ………… WASTE OF SPACE!

11. Polynomial ADT (continued) Advantages of using an Array: only good for non-sparse polynomials. ease of storage and retrieval. Disadvantages of using an Array: have to allocate array size ahead of time. huge array size required for sparse polynomials. Waste of space and runtime.

12. Polynomial ADT (continued) Double Array Implementation: Say you want to represent the following two polynomials: p1(x) = 23x 9 + 18x 7 - 41x 6 + 163x 4 - 5x + 3 p2(x) = 4x 6 + 10x 4 + 12x + 8

13. p1(x) = 23x 9 + 18x 7 - 41x 6 + 163x 4 - 5x + 3 p2(x) = 4x 6 + 10x 4 + 12x + 8 Polynomial ADT (continued) 2318-41163-53410128 9764106410 Coefficient Exponent Start p1(x)Start p2(x) End p1(x)End p2(x) 0 28

14. Polynomial ADT (continued) Advantages of using a double Array: save space (compact) Disadvantages of using a double Array: difficult to maintain have to allocate array size ahead of time more code required for misc. operations.

15. Polynomial ADT (continued) Linked list Implementation: p1(x) = 23x 9 + 18x 7 + 41x 6 + 163x 4 + 3 p2(x) = 4x 6 + 10x 4 + 12x + 8 23 918741618730 4 610412180 P1 P2 NODE (contains coefficient & exponent) TAIL (contains pointer)

16. Polynomial ADT (continued) Advantages of using a Linked list: save space (dont have to worry about sparse polynomials) and easy to maintain dont need to allocate list size and can declare nodes (terms) only as needed Disadvantages of using a Linked list : cant go backwards through the list cant jump to the beginning of the list from the end.

17. Polynomial ADT (continued) Adding polynomials using a Linked list representation: (storing the result in p3) To do this, we have to break the process down to cases: Case 1: exponent of p1 > exponent of p2 Copy node of p1 to end of p3. [go to next node] Case 2: exponent of p1 < exponent of p2 Copy node of p2 to end of p3. [go to next node]

18. Polynomial ADT (continued) Case 3: exponent of p1 = exponent of p2 Create a new node in p3 with the same exponent and with the sum of the coefficients of p1 and p2.

19. Polynomial ADT (continued) Introducing Horners rule: -Suppose for simplicity we use an array to represent the following non-sparse polynomial: 4x 3 + 10x 2 + 5x + 3 - Place it in an array, call it a[i], and compute it…

20. Polynomial ADT (continued) 4x 3 + 10x 2 + 5x + 3 A general (and inefficient) algorithm: int Poly = 0; int Multiply; for (int i=0; i < a.Size; i++) { Multiply =1; for (int j=0; j<i; j++) { Multiply *= x; } Poly += m*a[i]; } ijPoly 003 105x + 3 2010x + 5x +3 110x 2 + 5x + 3 304x + 10x 2 + 5x + 3 14x 2 + 10x 2 + 5x + 3 24x 3 + 10x 2 + 5x + 3 Time Complexity O(n 2 )

21. Polynomial ADT (continued) 4x 3 + 10x 2 + 5x + 3 Now using Horners rule algorithm: int Poly = 0; for (int i = (a.Size-1); i >= 0 ; i++) { Poly = x * Poly + a[i]; } iPoly 34 24x + 10 14x2 + 10x + 5 04x3 +10x2 + 5x +3 Time Complexity O(n) MUCH BETTER!

22. Polynomial ADT (continued) So what is Horners rule doing to our polynomial? instead of: ax 2 + bx + c Horners simplification: x(x(a)+b)+c

23. Polynomial ADT (continued) So in general a n x n + a (n-1) x (n-1) + … + a 1 x 1 + a 0 EQUALS: ( ( (a n + a (n-1) )x + a (n-2) ) x + … + a 1 ) x + a 0