Kurvendiskussion

[Schnuffelluff]

Hallo,

also meine schlaue Lehrerin hatte letztens vorgeschlagen, dass wir doch mal ein Programm für eine Kurvendiskussion schreiben könnten. Ich fing also zu Hause damit an ein kleines Gerüst zu machen, weil es ja schon interessant ist, ob man das hinkriegt. Am nächsten Tag war ihr das doch zu schwer. Ich will das Programm aber auf alle Fälle weitermachen. Es kann ja schon die Ableitungen, das schlaue Ding .

Ich weiß allerdings nicht, wie ich das schreiben soll, dass der mir die Nullstellen für Funktionen 3. und 4. Grades berechnet. Muss man ja mit Polynomdivison, falls der User nicht gerade bei der Funktion 4. Grades y=ax^4+bx²+c eingibt. Dann kann ich das ja auch über die x1/2 Rechnung.

Kann mir mal einer helfen, wie ich das mit der Polynomdivison hinkriege. Hatte mir schon überlegt, dass ich das Programm über eine Schleife x ausrechnen lasse.

Habe es mit fpr versucht:

for(x=-10;y==0;x++)

{

y=ax*x*x+b*x*x+c*x+d;

}

cout<<x;

Ist nicht ganz richtig, denn das Ding gibt mir immer den Wert -10 aus, den ich in der for-Schleife deklariert habe.

Wäre über Hilfe sehr dankbar!!

[Manfred.Becker]

Hi,

Habe es mit fpr versucht:

for(x=-10;y==0;x++)

{

y=ax*x*x+b*x*x+c*x+d;

}

cout<<x;

ist's nur ein Tippfehler (das y==0 in der Schleife), oder Absicht?

Wenn's Absicht war, dann wird die Schleife genau einmal durchlaufen. Denn dabei wird ja y zugewiesen und ist somit höchstwahrscheinlich nicht mehr 0!

Ich würde das so machen:

for(x=-10;x<10;x++)

{

  y=a*x*x*x+b*x*x+c*x+d;

  cout "X=" << x << " Y=" << y;

}

Aber selbst das macht nur Sinn wenn eine Wertetabelle erstellt werden soll.

Schau dir mal das an:

Kurvendiskussion

[Schnuffelluff]

Das hilft mir absolut nicht weiter. Da wird nirgends beschrieben, wie ich das Programm dazu bringe, mir die Zahl auszugeben, die ich für die Polynomdivison brauche.

Ich brauche keine durchgerechnete Kurvendiskussion. Dann könnt ich auch in meinen Hefter gucken.

Ich brauch eine Lösung, wie ich sowas in ein Programm "umwandeln" kann. Und zwar nicht alles, sondern lediglich die Polynomdivison.

[Muadibb]

also:

Wenn ich mich recht dran erinnere ist das bei einer Funktion 3. Grades oder höher ja nicht so einfach, weil man ja eine Nullstelle kennen muss um eine Polynomdivision durchführen zu können.

Es gibt ein Näherungsverfahren, das da eventuell weiterhilft:

Newton

Ich vermute, dass es auch die genauere Methode ist, je nachdem welche Genauigkeit Du in Deinem Programm forderst.

Da Du ja die erste Ableitung kennst, kannst Du so die beiden Stellen berechnen. Deinen Startwert kannst Du ja frei wählen. Es kann dann eben nur lange dauern, bis du die geforderte Genauigkeit erreicht hast.

Hoffe, es hilft Dir

[Schnuffelluff]

Also nochmal

wenn man eine Polynomdivison in Mathe rechnen würde, würde man die Zahl z durch probieren herauskriegen.

damit ich dann rechnen kann:

(ax³+bx²+cx+d):(x-z)=Ergebnis

Ich muss es hinkriegen, dass das Programm "probiert", welche Zahl z herauskommen muss,genauso wie es ein Mensch tun würde.

[Muadibb]

ok,

angenommen Du startest bei einer Zahl und "probierst" in eine Richtung weiter, kann es ja auch sein, dass Du Dich immer weiter von der Nullstelle entfernst. Das heisst, Du musst 2 Werte berechnen und prüfen, ob Du mit dem zweiten Wert für y schon näher an Null liegst.

Für mich scheint hier ein Suchalgorithmus nötig zu sein.

-Du nimmst einen Startwert und einen 2. Wert,

-überprüfst dann, ob Du Dich y=0 genähert hast,

wenn ja nehme z.B. die Mitte von Wert 2 und 0 und mache weiter, bis Du Dich dem Wert Null auf Deine geforderte Genauigkeit genähert hast.

Hoffe, dass ich Dir so helfen konnte.

[Schnuffelluff]

Und wie soll das im Programm aussehen??

[Manfred.Becker]

Hi,

ich bin's nochmal.

Schau mal hier rein:

polynomdivision

Lass dir den Quelltext anzeigen. Damit hast du einen Lösungsweg.

[Schnuffelluff]

Ganz ehrlich, hilft mir diese Internetseite nicht wirklich.

Ich weiß nämlich immer noch nicht, wie ich das Umsetzung soll.

[Muadibb]

so, ich bin kein c++-Könner, aber ich versuche Dir nochmal zu helfen, da es eher ein Algorithmus-Problem ist:

Das Newtonverfahren ist genau das, was Du suchst. Du kennst keine nullstelle und musst eine raten. Das Newtonverfahren geht eben näherungsweise an eine zahl heran.

Eine Genauigkeit für dieses Verfahren könnte ungefähr so aussehen. Ich beziehe mich auf die Variablen beim Newtonverfahren:

x0 = Startwert, den Du selber bestimmst (feste Zahl)

x1 = gesuchter Wert

f(x0) = kannst mit Deiner Funktion berechnen

f'(x0) kannst Du auch berechnen, da Du gesgat hast Du kennst die Ableitung

Die Bedingung die Du für Deine Schleife brauchst sieht etwa so aus:

|f(xn)|=0,00001. Die Zahl 0,xxxx1 kannst Du frei wählen. Diese drückt die geforderte Genauigkeit Deiner Nullstelle aus.

Da ich nicht weiss, ob in C++ eine Math-Funktion für Betrag enthalten ist könntest Du das auch zur Not mit dem Quadrat des Funktionswertes überprüfen und musst dann eben Deine Genauigkeit auch quadrieren.

Newtonverfahren anwenden;

for(int i=1;(f(xi+1)^2=0,00001^2);i++ ){Newtonverfahren anwenden}

xo=0;

if (f(x0)^2=0,00001^2) {Nullstelle gefunden,Ausgabe}

else{Newtonverfahren anwenden;x0 mit dem berechnet Wert von x1 ersetzen}

}

Wie gesagt: Das sollte zumindest der richtige Ansatz sein. Es ist nicht ganz einfach jeden Fall spontan mit der Lösung abzudecken

[Bubble]

@Schnuffelluff:

Zuerst wäre zu klären, ob Du die Lösung numerisch oder per symbolischer Rechnung finden willst. Im zweiten Fall wird es Dir vermutlich nur für einfache Funktionen gelingen. Aber auch numerische Lösungswege sind nicht in jedem Fall für jede Funktion geeignet und gute Umsetzungen sind auch nicht trivial.