Funktion auf mehrere dateien verpacken- wo fehler?

[t1m0n]

Braunstein schrieb:

Ok naeherung ist auch falsch, weil es davon ausgeht, dass die Koeffizienten aufsteigend sortiert sind, es ist aber absteigend.

double fx = koeff[grad];
for(int i=grad;i<=1;--i)
{
    fx  += koeff[i] * potenz(xnull,i);  //summiert f(x)
    fxA += koeffA[i] * potenz(xnull,i-1); //summiert f'(x)
}

Mit den Koeffizienten ist das nicht ganz richtig gesagt. Ich gehe nur davon aus, das die Koeffizienten in Abhängigkeit zu den Exponenten absteigend eingegeben werden! Desweiteren stimme ich

fx  += koeff[i] * potenz(xnull,i);  //summiert f(x)

Ja nicht ganz zu weil es die Variable grad sein muss und nicht i die ausgewertet wird, da ja absteigend.
Und mit ^0 meintest du bestimmt, das 2^0 nicht 1 bei mir ergeben richtig?

Nun steht bei mir folgendes:

#include <iostream>
#include <cmath>
#include "ableitung.h"
using namespace std;
/* 
Diese Funktion führt das Newton'sche Näherungsverfahren durch
*/
const int MaxIter = 100;

double naeherung(int grad, double *koeff, double *koeffA, double xnull)
{
  double xeins;
  int iter(0);
  do
  {
     xeins=xnull;
     double fxA=0;
     double fx = koeff[0];
     for(int i=1;i<=grad;++i)
     {
         fx  += koeff[i] * pow(xnull,grad);  //summiert f(x)
         fxA += koeffA[i] * pow(xnull,grad-1); //summiert f'(x)
     }
     xnull -= fx/fxA; //neuer Näherungswert
     ++iter;
  } while(fabs(xeins-xnull) > 1.0e-10 && iter < MaxIter);
  return xnull;
}

Aber das Ergebnis ist immernoch verwirrend!

Und was ist mit dem i=1 in der for-Schleife? i=0 wäre doch sinnvoller nicht war?

[Braunstein]

Uups? Ist natürlich Quatsch was ich da geschrieben hab
So ist es besser.

double fx = koeff[grad];
for(int i=grad;i<=1;--i)
{
    fx  += koeff[grad - i] * potenz(xnull,i);  //summiert f(x)
    fxA += koeffA[grad - i] * potenz(xnull,i-1); //summiert f'(x)
}

[t1m0n]

Der Debugger zeigte hier einen Fehler:

fx  += koeff[grad - i] * potenz(xnull,i);  //summiert f(x)

Ich habe nun auf meine eigene potenz(); verzichtet und verwende nun pow(); aus cmath. Habs dementsprechend auch angepasst und somit den erwähnten Fehler behoben.
Nun gibt er -1,#INF wieder aus. Ich dachte das liegt an dieser Zeile:

for(int i=grad;i<=1;--i)

Habe deshalb die Bedingung auf <=0 angepasst aber komme auch hier zum gleichen Ergebnis. -> -1,#INF
Nicht ganz der gewünschte Wert!

Kurze Frage nebenbei: Kann ich mir eigentlich die standartbibliotheken angucken irgendwo? Möchte gerne wissen wie die pow() aufegbaut ist. Suche auch noch ein gutes Buch das ALLE Standartfunktionen erklärt. Jemand einen Tipp?

[Braunstein]

fx  += koeff[i] * pow(xnull,grad);  //summiert f(x)
fxA += koeffA[i] * pow(xnull,grad-1);

Das ist Unsinn. Du hast doch ein Polynom. Hier wäre doch jeder Exponent gleich.

Bei grad=3 würde das so aussehen.
f(x) = koeff[grad] * x^grad + koeff[grad-1] * x^grad + ... + koeff[0] * x^grad

das Ganze muß doch aber so aussehen
f(x) = koeff[grad] * x^grad + koeff[grad-1] * x^(grad-1) + ... + koeff[0] * x^0

die Ableitung dann so
f'(x) = koeff[grad] * grad * x^(grad-1) + koeff[grad-1] * (grad-1) * x^(grad-2) + ... + koeff[1] * x^0

CStoll hat dir doch den Link hier gegeben
http://www.cppreference.com
da stehen doch die Standardbibliotheken.
und darin steht auch pow
http://www.cppreference.com/stdmath/pow.html

[t1m0n]

for(int i=grad;i<=0;--i)

Versteh ich beispielsweise auch nicht weil i=grad schwachsinnig ist, sondern i=0 sinnvoller...

for(int i=0;i<=grad;i++)

wäre für mich erstmal sinnvoller
mhm.. und wie sollte es dann richtig aussehen?
Für sinnvoller halte ich folgendes:

#include <iostream>
#include <cmath>
#include "ableitung.h"
using namespace std;
/* 
Diese Funktion führt das Newton'sche Näherungsverfahren durch
*/
const int MaxIter = 100;

double naeherung(int grad, double *koeff, double *koeffA, double xnull)
{
  double xeins;
  int iter(0);
  do
  {
     xeins=xnull;
     double fxA=0;
     double fx = koeff[grad];
     for(int i=0;i<=grad;i++)
     {
      fx  += koeff[grad - i] * pow(xnull,grad);  //summiert f(x)
      fxA += koeffA[grad - i] * pow(xnull,grad-1); //summiert f'(x)
     }
     xnull -= fx/fxA; //neuer Näherungswert
     ++iter;
  } while(fabs(xeins-xnull) > 1.0e-10 && iter < MaxIter);
  return xnull;
}

Nun bekomme ich nämlich auch ein Ergebnis: 1.31624 für die oben genannte Funktion. Dies entspricht aber dennoch keiner wahren Nullstelle dieser funktion
-1.5 und 0 sind die Nullstellen bei dieser Funktion:
grad=2, koeff1=2, koeff2=3, xnull=-2

[Braunstein]

Wenn dann bitte schön so

double fx = koeff[grad];
for(int i=0;i<grad;++i)
{
    fx  += koeff[i] * pow(xnull,grad - i);  //summiert f(x)
    fxA += koeffA[i] * pow(xnull,grad - i - 1); //summiert f'(x)
}

Bitte lies auch nochmal meinen vorigen Post.

[t1m0n]

Braunstein schrieb:

Wenn dann bitte schön so

double fx = koeff[grad];
for(int i=0;i<grad;++i)
{
    fx  += koeff[i] * pow(xnull,grad - i);  //summiert f(x)
    fxA += koeffA[i] * pow(xnull,grad - i - 1); //summiert f'(x)
}

Bitte lies auch nochmal meinen vorigen Post.

Ja, aber dann bekommen wir wieder -1,#IND
Liegt das daran, dass die Größe des Double-Datentyps überschritten wird?

[Braunstein]

Wie deklarierst du eigentlich koeff und koeffA?
Wenn du grad eingeben läßt, sollte es etwa so aussehen.

double* koeff = new double[grad+1]; // du hast ja grad+1 Koeffizienten
double* koeffA = new double[grad]; // kann ja eins kleiner sein
// ganz zum Schluß dann noch
delete[] koeff;
delete[] koeffA;

Bei vorgegebenen konstanten grad reicht dann auch sowas

double koeff[grad+1];
double koeffA[grad];

[t1m0n]

Bei vorgegebenen konstanten grad reicht dann auch sowas

Was heißt das? Wozu delete? Die koeff wird bereits in der naeherung.cpp dekleriert. Das ist die datei über die die Werte eingegeben werden:

#include <iostream>
#include <conio.h>
#include "ableitung.h"
using namespace std;
/*Diese Funktion fragt lediglich alle Einzugebenen Daten ab.
grad steht für den Grad der Funktion.
koeff reserviert den Platz für die Koeffizienten, die Anzahl ist ja vom Grad abhängig.
xnull steht für den Startwert.
*/
int main(void)
{
    char r;
    int grad;
    double koeff[grad];

    //Die Eingabe des Grades und der Koeffizienten kann ggf. wiederholt werden
    do
    {
     int i;
     cout << "Bitte geben Sie den Grad der Funktion ein: ";
     cin >> grad;
     cout << "Bitte geben Sie jetzt die Koeffizienten ein (absteigende Reihenfolge der Exponenten und 0 beachten): " << endl;

     //Eingabe der Koeffizienten, bedingt durch den Grad der Funktion
     for(i=0;i<grad;i++)
     {
      cin >> koeff[i];
     }
     cout << "Ist das Ihre Funktionsgleichung: ";

     //Ausgabe der Koeffizienten, bedingt durch den Grad der Funktion
     for (i=0;i<grad;i++)
     { 
       cout << "+" << koeff[i] << "x^" << grad - i; 
     }
     cout << "? Wenn ja geben sie j ein und bestaetigen Sie mit Enter. Anderfalls geben Sie bitte n ein und bestaetigen dies: ";
     cin >> r;
    }while(r=='n');
    //Wenn die ausgegebene Funktionsgleichung mit der des Benutzers übereinstimmt geht es hier weiter, anderfalls wird die Eingabe wiederholt.

    //Eingabe des Startwertes
    double xnull;
    cout << "Bitte geben Sie den Startwert x0 fuer die Naeherung an: ";
    cin >> xnull;

    //Funktion zum Ableiten
    double koeffA[grad+1];
    ableitung(grad, koeff, koeffA);

    //Ausgabe der abgeleiteten Koeffizienten
    cout << endl << "Die abgeleiteten Koeffizienten sind: ";
    for(int i=0;i<grad;i++)
    {
     koeffA[i]=(grad - i)*koeff[i];
     cout << koeffA[i] << ", ";
    }

    //Funktion zum Nähern
    cout << naeherung(grad, koeff, koeffA, xnull);
    /*
    char re;
    do
    {
     cout << endl << "Moechten Sie die Naeherung erneut durchfuehren um ein exakteres Ergebnis zu erhalten? Wenn ja geben sie j ein und bestaetigen Sie mit Enter. Anderfalls geben Sie bitte n ein und bestaetigen dies: ";
     cin >> re;
    }while(re=='j');
    */
    getch();
    return 0;
}

Ich habe nun grad+1 in der Definition nun mal getestet, bekomme aber auch wieder -1.#IND ausgegeben. Die Änderung siehst du hier:

//Funktion zum Ableiten
    double koeffA[grad+1];

vorher nur grad! Die Dekleration kann aber nur von hier erfolgen weil die Koeffizienten übergeben werden.

[Braunstein]

Das hier funktioniert nicht

int grad;
double koeff[grad];

Wenn du koeff deklarierst hat grad doch noch gar keinen Wert. Da kann sonst was drin stehen. Lass es dir einfach mal ausgeben, dann wirst du sehen was ich meine.
Du kannst koeff und koeffA erst deklarieren wenn du grad kennst. Also nach dem Einlesen. Und dann mußt du new verwenden (und delete). Mich wundert schon, dass der Compiler das durchlässt.
Ich denke es wäre gut, wenn du ein Grundlagentutorial mal liest.
Dann noch
Nach Aufruf von Ableitung berechnest du deine Koeffizienten ja nochmal. Wozu das?

[t1m0n]

Braunstein schrieb:

Das hier funktioniert nicht

int grad;
double koeff[grad];

Wenn du koeff deklarierst hat grad doch noch gar keinen Wert. Da kann sonst was drin stehen. Lass es dir einfach mal ausgeben, dann wirst du sehen was ich meine.
Du kannst koeff und koeffA erst deklarieren wenn du grad kennst. Also nach dem Einlesen. Und dann mußt du new verwenden (und delete).

Verstehe dein bedenken, aber in die do kann ich das nicht reinstecken, dann streikt der Debugger! Wie mach ich das nun? Achja, aber wieso kann er dann ableiten? Weil die richtige Funktionsgleichung und die Ableitungskoeffizienten werden ausgegeben..

Korrigiere mich, hab es nun so gemacht:

int main(void)
{
    char r;
    int grad;
    double koeff[grad];
    //Die Eingabe des Grades und der Koeffizienten kann ggf. wiederholt werden
    do
    {
     int i;
     cout << "Bitte geben Sie den Grad der Funktion ein: ";
     cin >> grad;
     double koeff[grad];
     cout << "Bitte geben Sie jetzt die Koeffizienten ein (absteigende Reihenfolge der Exponenten und 0 beachten): " << endl;

     //Eingabe der Koeffizienten, bedingt durch den Grad der Funktion
     for(i=0;i<grad;i++)
     {
      cin >> koeff[i];
     }
     cout << "Ist das Ihre Funktionsgleichung: ";

     //Ausgabe der Koeffizienten, bedingt durch den Grad der Funktion
     for (i=0;i<grad;i++)
     { 
       cout << "+" << koeff[i] << "x^" << grad - i; 
     }
     cout << "? Wenn ja geben sie j ein und bestaetigen Sie mit Enter. Anderfalls geben Sie bitte n ein und bestaetigen dies: ";
     cin >> r;
    }while(r=='n');
    //Wenn die ausgegebene Funktionsgleichung mit der des Benutzers übereinstimmt geht es hier weiter, anderfalls wird die Eingabe wiederholt.

    //Eingabe des Startwertes
    double xnull;
    cout << "Bitte geben Sie den Startwert x0 fuer die Naeherung an: ";
    cin >> xnull;

    //Funktion zum Ableiten
    double koeffA[grad+1];
    ableitung(grad, koeff, koeffA);

    //Ausgabe der abgeleiteten Koeffizienten
    cout << endl << "Die abgeleiteten Koeffizienten sind: ";
    for(int i=0;i<grad;i++)
    {
     koeffA[i]=(grad - i)*koeff[i];
     cout << koeffA[i] << ", ";
    }

    //Funktion zum Nähern
    cout << naeherung(grad, koeff, koeffA, xnull);
    /*
    char re;
    do
    {
     cout << endl << "Moechten Sie die Naeherung erneut durchfuehren um ein exakteres Ergebnis zu erhalten? Wenn ja geben sie j ein und bestaetigen Sie mit Enter. Anderfalls geben Sie bitte n ein und bestaetigen dies: ";
     cin >> re;
    }while(re=='j');
    */
    getch();
    return 0;
}

Nun spuckt er aber durchgeknallte werte aus für die abgeleiteten Koeffizienten die nicht stimmen und am Näherungswert hat sich auch nichts geändert..

[t1m0n]

Ich habe dort double koeff[grad]; zweimal deklariert.
So geht es weitgehend aber mit der oben genannten Fehlermeldung. Also Unbrauchbar. Nun habe ich es so gemacht das nur noch nach der dekleration von grad, also innerhalb von do, die Dekleration stattfindet von koeff. Dann verweist der Compiler ab auf die Zeile wo die ableitungs-Funktion steht. Diese ist ja außerhalb der do-Schleife, demnach ist koeff hier halt nicht bekannt. Also was nun?

[Braunstein]

Bitte, Bitte lies dir eine Tutorial durch.
Ich geb dir jetzt mal einen funktionierenden Code. Schau ihn dir an und versuch ihn zu verstehen.

#include <iostream>
#include <cmath>
//#include "ableitung.h"
using namespace std;
/*Diese Funktion fragt lediglich alle Einzugebenen Daten ab.
grad steht für den Grad der Funktion.
koeff reserviert den Platz für die Koeffizienten, die Anzahl ist ja vom Grad abhängig.
xnull steht für den Startwert.
*/

int ableitung(int grad, double *koeff, double *koeffA)
{
    for(int i=0; i<grad; i++)
    {
       koeffA[i]=(grad - i)*koeff[i];
    }
}

double naeherung(int grad, double *koeff, double *koeffA, double xnull)
{
  const int MaxIter = 10;
  double xeins;
  int iter(0);
  do
  {
     xeins=xnull;
     double fxA=0;
    double fx = koeff[grad];
    for(int i=0;i<grad;++i)
    {
        fx  += koeff[i] * pow(xnull,grad - i);  //summiert f(x)
        fxA += koeffA[i] * pow(xnull,grad - i - 1); //summiert f'(x)
    }
    xnull -= fx/fxA; //neuer Näherungswert
    ++iter;
  } while(fabs(xeins-xnull) > 1.0e-10 && iter < MaxIter);
  return xnull;
}

int main(void)
{
    char r;
    int grad;
    double* koeff(0);
    double* koeffA(0);
    //Die Eingabe des Grades und der Koeffizienten kann ggf. wiederholt werden
    do
    {
     int i;
     cout << "Bitte geben Sie den Grad der Funktion ein: ";
     cin >> grad;
     cout << "Bitte geben Sie jetzt die Koeffizienten ein (absteigende Reihenfolge der Exponenten und 0 beachten): " << endl;
     koeff = new double[grad+1];
     koeffA = new double[grad+1]; // nur zur Sicherheit
     //Eingabe der Koeffizienten, bedingt durch den Grad der Funktion
     for(i=0;i<=grad;i++) // <= denn eine Funktion 5.Grades hat ja 6 Koeffizienten
     {
      cin >> koeff[i];
     }
     cout << "Ist das Ihre Funktionsgleichung? " << endl;

     //Ausgabe der Koeffizienten, bedingt durch den Grad der Funktion
     for (i=0;i<=grad;i++)
     {
       if( i<grad)
         cout << koeff[i] << "x^" << grad - i << "+" ;
       else
         cout << koeff[i];
     }
     cout << endl << "? Wenn ja geben sie j ein und bestaetigen Sie mit Enter. Anderfalls geben Sie bitte n ein und bestaetigen dies: ";
     cin >> r;
     if( r=='n')
     {
        delete[] koeff;
        delete[] koeffA;
     }
    }while(r=='n');
    //Wenn die ausgegebene Funktionsgleichung mit der des Benutzers übereinstimmt geht es hier weiter, anderfalls wird die Eingabe wiederholt.

    //Eingabe des Startwertes
    double xnull;
    cout << "Bitte geben Sie den Startwert x0 fuer die Naeherung an: ";
    cin >> xnull;

    //Funktion zum Ableiten
    ableitung(grad, koeff, koeffA);

    //Ausgabe der abgeleiteten Koeffizienten
    cout << endl << "Die abgeleiteten Koeffizienten sind: ";
    for(int i=0;i<grad;i++)
    {
     cout << koeffA[i] << ",  ";
    }

    //Funktion zum Nähern
    cout << endl << "Naeherung:  " << naeherung(grad, koeff, koeffA, xnull);
    delete[] koeff;
    delete[] koeffA;
    return 0;
}

[t1m0n]

Der Code geht aber nicht. Debugger sagt:

multiple definition of `naeherung(int, double*, double*, double)'
first defined here
ld returned 1 exit status
D:\Desktop-Save\c++\Aufträge + Übungen\08. Newton Näherungsverfahren\näherung\Makefile.win [Build Error] [Naeherungsverfahren.exe] Error 1

[LordJaxom]

...dann nimm die Datei aus dem Projekt wo Deine alte Funktion naeherung definiert ist...

[t1m0n]

Ihr habt irgendwas vergessen, oder ich übersehen, aber nun klappt es. Hab alles vorerst in eine Datei gepackt:

#include <iostream>
#include <cmath>
#include <conio.h>
//#include "ableitung.h"

using namespace std;
double naeherung(int grad, double *koeff, double *koeffA, double xnull);
double ableitung(int grad, double *koeff, double *koeffA);
/* 
Diese Funktion führt die eigentliche Ableitung durch.
Es müssen hier zwei Parameter übergeben werden:
Der Grad der Funktion und die Koeffizienten.
*/
double ableitung(int grad, double *koeff, double *koeffA)
{
    int i;
    for(i=0;i<grad;i++)
    {
     koeffA[i]=(grad - i)*koeff[i];
    }
    return 0;
}

/*Diese Funktion fragt lediglich alle Einzugebenen Daten ab.
grad steht für den Grad der Funktion.
koeff reserviert den Platz für die Koeffizienten, die Anzahl ist ja vom Grad abhängig.
xnull steht für den Startwert.
*/

double naeherung(int grad, double *koeff, double *koeffA, double xnull)
{
  const int MaxIter = 10;
  double xeins;
  int iter(0);
  do
  {
     xeins=xnull;
     double fxA=0;
    double fx = koeff[grad];
    for(int i=0;i<grad;++i)
    {
        fx  += koeff[i] * pow(xnull,grad - i);  //summiert f(x)
        fxA += koeffA[i] * pow(xnull,grad - i - 1); //summiert f'(x)
    }
    xnull -= fx/fxA; //neuer Näherungswert
    ++iter;
  } while(fabs(xeins-xnull) > 1.0e-10 && iter < MaxIter);
  return xnull;
}

int main(void)
{
    char r;
    int grad;
    double* koeff(0);
    double* koeffA(0);
    //Die Eingabe des Grades und der Koeffizienten kann ggf. wiederholt werden
    do
    {
     int i;
     cout << "Bitte geben Sie den Grad der Funktion ein: ";
     cin >> grad;
     cout << "Bitte geben Sie jetzt die Koeffizienten ein (absteigende Reihenfolge der Exponenten und 0 beachten): " << endl;
     koeff = new double[grad+1];
     koeffA = new double[grad+1]; // nur zur Sicherheit
     //Eingabe der Koeffizienten, bedingt durch den Grad der Funktion
     for(i=0;i<=grad;i++) // <= denn eine Funktion 5.Grades hat ja 6 Koeffizienten
     {
      cin >> koeff[i];
     }
     cout << "Ist das Ihre Funktionsgleichung? " << endl;

     //Ausgabe der Koeffizienten, bedingt durch den Grad der Funktion
     for (i=0;i<=grad;i++)
     {
       if( i<grad)
         cout << koeff[i] << "x^" << grad - i << "+" ;
       else
         cout << koeff[i];
     }
     cout << endl << "? Wenn ja geben sie j ein und bestaetigen Sie mit Enter. Anderfalls geben Sie bitte n ein und bestaetigen dies: ";
     cin >> r;
     if( r=='n')
     {
        delete[] koeff;
        delete[] koeffA;
     }
    }while(r=='n');
    //Wenn die ausgegebene Funktionsgleichung mit der des Benutzers übereinstimmt geht es hier weiter, anderfalls wird die Eingabe wiederholt.

    //Eingabe des Startwertes
    double xnull;
    cout << "Bitte geben Sie den Startwert x0 fuer die Naeherung an: ";
    cin >> xnull;

    //Funktion zum Ableiten
    ableitung(grad, koeff, koeffA);

    //Ausgabe der abgeleiteten Koeffizienten
    cout << endl << "Die abgeleiteten Koeffizienten sind: ";
    for(int i=0;i<grad;i++)
    {
     cout << koeffA[i] << ",  ";
    }

    //Funktion zum Nähern
    cout << endl << "Naeherung:  " << naeherung(grad, koeff, koeffA, xnull);
    delete[] koeff;
    delete[] koeffA;
    getch();
    return 0;
}

[t1m0n]

Kann mir denn jemand einen Tipp geben wo ich erklärungen finde was

delete[] koeff;

und

koeff = new double[grad+1];

genau bedeuten?
Achja und wozu

double* koeff(0);

Warum schreiben wir hier nicht die Standartdekleration wie es im Lehrbuch steht:

double* koeff=0;

Wo liegen die Unterschiede?

[Braunstein]

Also schau mal
http://www.volkard.de/vcppkold/zeiger.html
http://www.volkard.de/vcppkold/new_und_delete.html
http://www.volkard.de/vcppkold/arrays_und_zeiger.html
http://www.volkard.de/vcppkold/new_und_delete_fuer_arrays.html

Und nochmal
das hier
Initialisierung bzw. Konstruktoraufruf

double* koeff(0);

und das hier
Initialisierung

double* koeff=0;

bedeuten in diesem Fall das Gleiche

Hiermit erzeugst du ein Array in das grad+1 double-Zahlen passen

koeff = new double[grad+1];

und hiermit löschst du es wieder.

delete[] koeff;

[t1m0n]

Ok danke, ich schau es mir mal an!
Ich habe nun eine Funktion entwickelt für das Horner-Schema. Das war einfacher und klappte sofort:

#include <iostream>
#include <conio.h>
using namespace std;
int main(void)
{
    double fhorner=0;
    double koeff[4]={1, 3, -6, 8};
    int grad=3;
    double xnull=3;
    for(int i=0;i<grad+1;i++)
    {
            if(i!=0)
            {
            fhorner*=xnull;
            }
            fhorner=fhorner+koeff[i];
    }
    cout << "Nullstelle: " << fhorner << endl;
    delete[] koeff;
    getch();
}

Bisher sind es allerdings noch statische Werte, das wird später angepasst. Meine Frage betrifft nun etwas anderes als den Code.
Kann ich mit dem Horner-Schema denn eigentlich Nullstellen berechnen?
Ich habe nämlich nun vor gehabt das Hornerschema grad-1x durchlaufen zu lassen und den errechneten Wert dann als neuen x0-Wert für diese Funktion zu nehmen. Dann las ich aber das man damit nur einen Funktionswert bestimmen kann.
Kann mir jemand auf die Sprünge helfen?

[Braunstein]

Das Horner-Schema berechnet lediglich auf eine andere Art den Funktionswert eines Polynoms. Du könntest dir hier also die Verwendung von pow sparen. Das könnte bei großen Polynomen und häufigen Aufrufen Geschwindigkeit bringen.
Bezüglich der Ermittlung aller Nullstellen eines Polynom bringt es dir nicht viel.
Das Newton-Verfahren ermittelt dir die Nullstelle in der Nähe des Startwertes (sofern vorhanden). Das Problem ist halt, dass du nicht weißt, wie viele Nullstellen dein Polynom hat. Du kannst eigentlich nur sagen wieviele es maximal bzw. minimal haben kann. Polynome gerader Ordnung müssen überhaupt keine Nullstelle haben (deswegen das MaxIter).
Frag das doch mal im Mathe-Forum.