Funktion auf mehrere dateien verpacken- wo fehler?

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.

t1m0n

Ich habe eine andere idee. Und zwar folgende...
Ich kann ja mit dem Hornerschema nicht nur einen anderen Funktionswert ausgeben sondern auch eine andere Funktion.
Stell dir die Tabelle einfach vor deinem inneren Auge vor:
Wenn ich nun die Koeffizienten die in der letzten Zeile stehe verwende und daraus eine Funktion grad-1 mache und das so oft wiederhole bis ich eine Funktion 2Grades habe kann ich doch die p/q-Formel anwenden richtig?
Daraus ergeben sich dann doch 2 Werte?

Meine Überlegung ist nur was ist bei Funktion 5 Grades.
Die hat ja ggf. 5 Nullstellen. Wenn ich nun das Naeherungsverfahren durchführe bekomme ich eine, verbleiben 4.
Die verwende ich für das Horner-Schema. Die daraus resultierende Funktion ist das grad-1. Also vierten Grades. Wenn ich das nun 2x mache bekomme ich eine Funktion 2 Grades. Dort kann ich dann p/q-Formel anwenden. Somit habe ich dann aber ja nur 3 Nullstellen von 5 möglichen. Kann mir hier jemand helfen der sich in der Mathematik auskennt?

CStoll

double koeff[]=...;
...
delete[]koeff;

Dazu fällt mir nur ein Wort ein - AUTSCH

Ansonsten: Wie Braunstein schon sagte: Mit dem Horner-Schema berechnest du NICHT die Nullstellen einer Funktion (für Polynome jenseits Grad 3 gibt es afaik keine allgemeine Formel) - das könntest du höchstens anstelle der alten for()-Schleife verwenden, um die Zwischenwerte für f(x) und f'(x) im Newton-Schema zu ermitteln.

t1m0n

CStoll schrieb:

double koeff[]=...;
...
delete[]koeff;
Dazu fällt mir nur ein Wort ein - AUTSCH

Wieso das? Was ist daran jetzt falsch?

CStoll

Mit delete[] darfst du nur Arrays freigeben, die du per new[] angelegt hast - lokale Arrays werden automatisch entsorgt, wenn sie aus dem Scope fallen.

t1m0n

CStoll schrieb:

Mit delete[] darfst du nur Arrays freigeben, die du per new[] angelegt hast - lokale Arrays werden automatisch entsorgt, wenn sie aus dem Scope fallen.

Ich danke dir, hab ich nicht gewusst. Muss mich dringend damit befassen!!
Auf diesem Wege noch: Ich habe mein Horner-Schema umgeschrieben:

#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 horner[grad+1];
    double xnull=3;
    /*
    Durchlauf des Horner-Schemas.
    */
     for(int i=0;i<grad+1;i++)
     {
      if(i!=0) //Ist erforderlich weil der erste Koeffizient mit 0 addiert werden muss
      {
       fhorner*=xnull;
      }
      fhorner=fhorner+koeff[i];
      horner[i]=fhorner;
      if(i<grad)
      {
                  cout << "Neuer Koeffizienten fuer x^" << grad-i-1 << ": " <<horner[i] << endl;
      }
     }
     cout << "Der Funktionswert an der Stelle x=" << xnull << " ist: " << horner[grad];
    getch();
    return 0;
}

Jetzt erfüllt es zwar noch keinen höheren Zweck, funktioniert aber weitgehend. Ist eigentlich jemand hier, der wie ich der Ansicht ist das man irgendwie doch alle Nullstellen bestimmen kann? Wenn ja, wie denn???

CStoll

Eine Möglichkeit wäre es, ausgehend von der ersten gefundenen Nullstelle die Funktion per Polynomdivision zu "verkleinern" und dann weiterzuarbeiten (f(x)=a*(x-x₁)(x-x₂)...*(x-x_n)). Eine andere Variante ist per Intervallschachtelung (wenn du ein hinreichend kleines Intervall durch den Definitionsbereich schiebst, solltest du alle Nullstellen treffen).

t1m0n

CStoll schrieb:

Eine Möglichkeit wäre es, ausgehend von der ersten gefundenen Nullstelle die Funktion per Polynomdivision zu "verkleinern" und dann weiterzuarbeiten

Und genau das erreichst du auch, wenn du die Koeffizienten in der unteren Zeile des Horner-Schemas verwendest. Compiliere das Programm mal bei dir und vergleiche das mit dem Ergebnis einer Polynomdivision