Adding two polynomials - c

Question

I am trying to add two polynomial functions and store the answer into first one. So far I have this:
// co = coefficient, ex = exponent
void add_polynom(int co1[], int ex1[], int co2[], int ex2[])
{
int i, j;
for (i = 0; i < dataSize; i++)
{
for (j = 0; j < dataSize; j++)
{
if (ex1[i] == ex2[j])
{
co1[i] = co1[i] + co2[i];
co2[i] = 0;
}
}
}
}
Am I on the right track?

Answer 1

Your representation of polynomials is impractical:
you iterate in 2 nested loops (quadratic complexity) to try and match the corresponding terms of both polynomials, but if the second has a power that the first does not have, it will be missing in the sum.
you pass the degree as a global variable dataSize that may have an inappropriate value.
You should instead use an array of coefficients for all exponents from 0 to the degree of the polynomial and pass the destination polynomial and its degree this way:
/* add 2 polynomials into a destination array.
* count variables are the sizes of the arrays,
* ie 1 more than the degree of the polynomials.
* return the size of the resulting polynomial,
* potentially larger than the size of the destination array.
*/
int add_polynomials(int dest[], int dest_count,
const int co1[], int count1,
const int co2[], int count2) {
/* compute the result coefficients */
int i, count;
for (i = count = 0; i < dest_count; i++) {
int coef = 0;
if (i < count1)
coef += co1[i];
if (i < count2)
coef += co2[i];
dest[i] = coef;
if (coef != 0)
count = i + 1;
}
/* determine the result count */
for (; i < count1 && i < count2; i++) {
if (co1[i] + co2[i] != 0)
count = i + 1;
}
for (; i < count1; i++) {
if (co1[i] != 0)
count = i + 1;
}
for (; i < count2; i++) {
if (co2[i] != 0)
count = i + 1;
}
return count;
}
If you must use the given prototype and global definition for dataSize, you could use 2 nested loops indeed, but depending on how the exponents are used in both polynomials, it might be impossible to fit the result in the destination array:
the source polynomials can each have up to dataSize terms with any range of exponents. The resulting polynomial might have a total number of terms that exceeds dataSize and thus not representable in an array of size dataSize.
your code fails because you wrote co1[i] = co1[i] + co2[i]; instead of co1[i] = co1[i] + co2[j];, but you also modify co2[i], which is inappropriate and you miss the terms that are only present in co2/ex2.
If we can assume that the maximum exponent is less than dataSize, here is an efficient approach (linear time) that will generate a result in normalized form:
#define dataSize 50
// co = coefficients, ex = exponents
void add_polynom(int co1[], int ex1[], int co2[], int ex2[]) {
int res[dataSize] = { 0 };
int i, j;
for (i = 0; i < dataSize; i++) {
res[ex1[i]] += co1[i];
res[ex2[i]] += co2[i];
}
j = 0;
for (i = dataSize; i-- > 0;) {
if (res[i] != 0) {
co1[j] = res[i];
ex1[j] = i;
j++;
}
}
while (j < dataSize) {
co1[j] = ex1[j] = 0;
}
}

Answer 2

Take for example say 7x^3 + 2x + 1 as first and 5x^4 + 9x^2 as second polynomial. Now dataSize becomes 5(since higher degree of both is 4).
Now co1 would be {1, 2, 0, 7, 0} and co2 would be {0, 0, 9, 0, 5}.
for (i = 0; i < dataSize; i++)
{
co1[i] += co2[i];
}

Answer 3

Your interface is "suboptimal". It forces guarantees to to be made for it to work at all.
Use option 1 if you can guarantee that all values of exs1 and exs2 are in [0..(DATASIZE-1)].
Use option 2 if you can merely guarantee that there are fewer than DATASIZE different values in exs1 and exs2 combined.
Option 1
This solution's performance is bound by O(N).
#define DATASIZE 50
void panic(const char* msg) {
fprintf(stderr, msg);
exit(EXIT_FAILURE);
}
find_ex(ex,
// Assumes all values in exs1 are in [0..49].
// Assumes all values in exs2 are in [0..49].
void add_polynom(int cos1[], int exs1[], int cos2[], int exs2[]) {
int cos_sum[DATASIZE];
size_t i;
int exs1i, exs2i;
for (i=DATASIZE; i--; )
cos_sum[i] = 0;
for (i=DATASIZE; i--; ) {
if (exs1[i] < 0 || exs1[i] >= DATASIZE || exs2[i] < 0 || exs2[i] >= DATASIZE)
panic("add_polynom: Exponent out of range\n");
cos_sum[exs1[i]] += cos1[i];
cos_sum[exs2[i]] += cos2[i];
}
for (i=DATASIZE; i--; ) {
cos1[i] = cos_sum[i];
exs1[i] = i;
cos2[i] = 0;
/* exs2[i] = i; */
}
}
Option 2
This solution's performance is bound by O(N2). The bound can be reduced to O(N) by using an associative array instead of find_index_of_ex, but that's too much work for this answer.
#define DATASIZE 50
void panic(const char* msg) {
fprintf(stderr, msg);
exit(EXIT_FAILURE);
}
ssize_t find_index_of_ex(int ex, int cos[], int exs[], size_t size) {
ssize_t i;
for (i=0; i<size; ++i) {
if (exs[i] == ex) {
return i;
}
}
return -1;
}
// Assumes there are fewer than DATASIZE different values in exs1 and exs2 combined.
void add_polynom(int cos1[], int exs1[], int cos2[], int exs2[]) {
int cos_sum[];
int exs_sum[];
ssize_t lookup_is_by_ex[datasize];
size_t i, sum_count;
ssize_t i_sum;
for (i=DATASIZE; i--; ) {
cos_sum[i] = 0;
exs_sum[i] = 0;
}
sum_count = 0;
for (i=DATASIZE; i--; ) {
if (cos1[i] == 0)
continue;
i_sum = find_index_of_ex(exs1[i], exs_sum, sum_count);
if (i_sum >= 0)
cos_sum[i_sum] += cos1[i];
continue;
}
if (sum_count == DATASIZE)
panic("add_polynom: Too many different exponents\n");
cos_sum[sum_count] = cos1[i];
exs_sum[sum_count] = exs1[i];
++sum_count;
}
for (i=DATASIZE; i--; ) {
if (cos2[i] == 0)
continue;
i_sum = find_index_of_ex(exs2[i], exs_sum, sum_count);
if (i_sum >= 0)
cos_sum[i_sum] += cos2[i];
continue;
}
if (sum_count == DATASIZE)
panic("add_polynom: Too many different exponents\n");
cos_sum[sum_count] = cos2[i];
exs_sum[sum_count] = exs2[i];
++sum_count;
}
for (i=DATASIZE; i--; ) {
cos1[i] = cos_sum[i];
exs1[i] = exs_sum[i];
cos2[i] = 0;
/* exs2[i] = i; */
}
}