Jack F - 1 month ago 10

C++ Question

For some reason when i am trying to do my derivative it just does a derivative of the one item not the whole polynomial.

`struct term{`

double coef;

unsigned deg;

struct term * next;

};

I have a struct and then also a class Polynomial with deep copy constructor and = constructor.

In a private class i have a

`term* ptr`

here is my code for the derivative

`void Polynomial::derivative (Polynomial *p){`

term *x;

if ( ptr == NULL)

return ;

term *temp;

temp = ptr;

while (temp != NULL){

if ( ptr == NULL){

ptr = new term ;

x = ptr ;

}

else{

x -> next = new term ;

x = x -> next ;

}

x-> coef = temp -> coef * temp -> deg;

x-> deg = temp -> deg - 1;

temp = temp -> next;

}

ptr=x;

}

so when i try to derivative of

`3x^4 + 3x^4 + 6x^7 + 3x^4 + 3x^4 + 6x^7 + 2x^9`

`18x^8`

I was looking over the code and have no idea why does it do that for just the last term, since it is a while loop and should go from beginning till NULL and do the derivative.

Answer

You're getting the last term because of these two lines:

in your else condition:

```
x = x -> next
```

and your final assignment:

```
ptr = x;
```

Consequently, this also leaks memory, since all those pretty terms you allocated prior are now in the ether. You were leaking the old ones anyway, so this really needs a rethink regardless.

I strongly recommend that since your Polynomial class supports full copy construction and assignment operation, you create a *new* derivative polynomial *from* this one, and return *that*. if the caller wants this one transformed they can `poly = poly.derivative();`

themselves.

Example of derivative generator (as opposed to transformer). And as a bonus, eliminates all constant terms when generating the derivative.

```
Polynomial Polynomial::derivative() const
{
Polynomial poly;
const term *p = ptr;
while (p)
{
if (p->deg != 0) // skip constant terms
{
// add term to poly here (whatever your method is called)
poly.addTerm(p->coef * p->deg, p->deg-1);
}
p = p->next;
}
return poly;
}
```

This allows this kind of generation: (note p1 is unchanged by `derivative()`

):

```
Polynomial p1;
... populate p1...
Polynomial p2prime = p1.derivative();
```

And for something really enjoyable:

```
Polynomial p1;
... populate p1...
Polynomial p2prime2 = p1.derivative().derivative();
```

Anyway, I hope that makes sense.