A Computational System for Polynomials with Two Variables

Transcription

1 CS 610 Data Structures & Algorithms Programming Project A Computational System for Polynomials with Two Variables A polynomial with two variables x and y consists of a summation of terms of the form where c is a constant real number (positive or negative) and are integers. We call it an xy-polynomial. For example, the xy-polynomial P: The purpose of this project is to design a computational system for xy-polynomials, i.e. for evaluation, addition, subtraction, multiplication, and division of two xy-polynomials and raising such a polynomial to a power k where k is an integer. Let Q be another xy-polynomial: then Before deciding on the proper data structure to represent an xy-polynomial, we need to determine the order of the terms in the polynomial. In a polynomial with one variable x, we traditionally order the terms in decreasing order of the exponent, yielding a linear order. But with two variables in xypolynomials, it is more complex. P and Q were presented by decreasing order of the exponent of x. In case of several terms with the same exponents of x, we arrange them in decreasing order of y s exponent as in P, e.g.. However, by this order, the terms have the y exponents in an arbitrary order. For example, the term with the highest power of y in R is in the middle of the list of terms. To obtain a symmetric representation regarding the exponents of x and y we will use a matrix where the rows will correspond to the powers of x and the columns to the powers of y. For example, to represent P there will be five rows indexed 0 to 4 and four columns indexed 0 to 3. The entry of the matrix will be the corresponding coefficient for the term. Hence, the matrix P to represent the xy-polynomial P will be: [ ] We observe many zero values in the matrix P. Such a matrix is called a sparse matrix. The zero values waste space and time. Thus, we prefer a linked representation for sparse matrices, where only the entries with non-zero values are represented. To represent the row and column of an entry use fields with these names in a node representing a term. To enable scanning a row or column, we create 1

2 linked lists which link the non-zero terms of each row and each column. The term is linked in these linked lists where the pointer fields rowlink and collink for the row linked list and the column linked list, respectively. For example, the record for a term will have the fields: The record for will be: rowlink collink coefficient row column The next issue is the direction of the links. The order of performing addition, subtraction, and multiplication can be either starting with the lower power terms or with the highest power terms, but division must start with the highest power terms. Hence, both the row lists and the column lists will be linked from high power terms to lower power terms to support the division operation. No record exists in the linked lists for zero value terms. If a row or column has only zero coefficient values, like row 2 in P, the linked list for such as row is an empty linked list. Finally, to accommodate the necessary process for the operations on polynomials, we make the row linked lists and column linked lists circular singly linked lists, with header nodes for each linked list that look like regular nodes. The row header node will have a -1 in the column field and the column header node will have a -1 in the row field. The access to the header records will be through a row array and a column array. For example, the linked representation of the P xy-polynomial is given:

3 In this project we are providing an implementation for the Abstract Data Type (ADT) xy-polynomial. The following operations need to be implemented. All arguments are considered immutable (i.e. arguments are unchanged by an operation). This project lends itself to an object-oriented implementation and these operations may be implemented as class methods using such an implementation (argument P would also be part of the class). INITIALIZE(P, m, n): Initializes xy-polynomial P. Creates an m x n sparse matrix to represent the xy-polynomial. INPUT(P): Initializes an xy-polynomial P from standard input. Input will be in the format of triples (c, i, j) which represents term. The triple (4, 1, 2) would represent the term in P. Input will continue to be read until the user indicates they are finished inputting triples. The dimension of the sparse matrix representing the xy-polynomial P must be determined before initialization. The value of m must be equal to the highest power of x and the value of n must be equal to the highest power of y. OUTPUT(P): Prints the xy-polynomial P to standard output. Polynomial should be printed starting from the highest x exponent where each term is in the format cxiyj, e.g. for the output is 4x2y3. For each x exponent print the terms starting from the highest y exponent (e.g. P, Q, and R on page 1). If the exponent is zero x or y should not be printed. EVALUATE(P, x, y): Evaluates an xy-polynomial P for the given real numbers x and y. ADD(P, Q): Calculates and returns the xy-polynomial which represents the summation of the xypolynomials P and Q (i.e. P + Q). The dimension of the result will be equal to the largest power of x from P or Q by the largest power of y from P or Q (dimensions for other operations will similarly have to be determined). SUBTRACT(P, Q): Calculates and returns the xy-polynomial which represents the subtraction of the xy-polynomial Q from the xy-polynomial P (i.e. P Q). MULTIPLY(P, Q): Calculates and returns the xy-polynomial which represents the multiplication of the xy-polynomials P and Q (i.e. P * Q). POWER(P, k): Calculate and returns xy-polynomial which represents xy-polynomial P raised to the power k, an integer. No more than 2*lg(k) multiplications are permitted. DIVIDE(P,Q): Calculates and returns the xy-polynomial which represents the result of dividing xy-polynomial P by xy-polynomial Q. Also returns the remainder xy-polynomial resulting from dividing xy-polynomial P and xy-polynomial Q. In class we will specify and discuss how the various operations must be implemented. Only the implementations described in class will receive any credit. The project will be delivered in three steps. Step 1 (40 pts total, DUE Thursday 10/24/2013) Data structure implementation (20 pts), Input (5 pts), Output (5 pts), and Evaluate (10 pts). Step 2 (30 pts total, DUE Thursday 11/7/2013) Addition (10 pts), Subtraction (5 pts), and Multiplication (15 pts) Step 3 (30 pts total, DUE Wednesday 11/27/2013) Power (5 pts), Division (15 pts), Implement and run all test cases (5 pts), Error free execution (5 pts) 3

4 Submission Details Your submission for each step must be received on each step s specified due date before 11:59:59PM. Any submission after 11:59:59PM will be considered one week late. Ten percent will be deducted for each week a step is late, e.g. if Step 1 is considered one week late you lose four points. your submission to cro3@njit.edu with the subject CS 610 Project followed by the name of the step you are submitting, e.g. CS 610 Project Step 1. Submit only what is required for the current step, e.g. do not submit addition and subtraction in your Step 1 submission. Submit ONLY the source code for your submission. Only submit.cpp/.cc/.h/.hh/.c files. If you have more than one source file you can combine all of the source files into a single Zip file. Your code MUST compile and execute on NJIT s AFS computers (afsconnect1.njit.edu and afsconnect2.njit.edu) using GCC or G++. If your submission does not compile and run on AFS it will be treated as late and you must submit a version which compiles and executes on AFS. Your project MUST automatically run all of the test cases for the current step and all previous steps before prompting the user for input. Copying code from the internet or from another student, even if it is just a single line of code, is strictly prohibited. Any cases of such copying will be immediately reported to the Dean of Students and you will receive a zero for the entire project. You can modify a previous step s code for a future step if necessary, but document the changes. Comment and properly indent your code. Do not use any non-standard libraries (e.g. conio.h). Test Cases Step 1 Create polynomials P, Q, R, and S and print them to standard output using the OUTPUT procedure. Evaluate P, Q, R, and S using the following (x,y) inputs: (3, 8), (3, 0), (0, 2), (2, 2), (10, 6) Step 2 Perform the following operations, in order, using P, Q, R, and S. Print the result. A = P + Q B = P Q C = R + S D = P S E = S P F = Q + R G = P * Q H = R * S I = A * B J = E * F K = D * E L = I * K Step 3 Perform the following operations, in order, using P, Q, R, and S. Print the result. A = P^5 B = Q^3 C = R^7 D = S^2 E = P^2 F = Q^5 G = P/S H = Q/R I = R/S J = F/E K = B/A L = A/P 4

5 5