9.6    Kurvendiskussion

Unter einer Kurvendiskussion versteht man die Untersuchung einer mathematischen Funktion, insbesondere im Hinblick auf den Verlauf ihres Funktionsgraphen, ihrer Nullstellen und Grenzwerte. Der Kurvenverlauf kann mit den Kalkülen der Differenzialrechnung vorhergesagt werden. Werden sie angewendet, dann müssen Sie unter Beweis stellen, dass Sie ihre Regeln verstanden haben.

Kurvendiskussionen sind didaktisch wertvoll und spielen auch heute eine wichtige Rolle, obwohl sie im digitalen Zeitalter überflüssig geworden zu sein scheinen, weil jeder Kurvenverlauf mit einem grafikfähigen Taschenrechner und einschlägigen Programmen ohne großen Aufwand dargestellt werden kann. Allerdings verlangt die grafische Darstellung durch einen Rechner keine Anstrengung des Denkens.

Ebenso interessant wie eine »klassische« Kurvendiskussion kann eine »umgekehrte« Kurvendiskussion [Greefrath:191] sein: Die Eigenschaften einer mathematischen Funktion, wie bestimmte Extrempunkte, Wende- und Nullstellen, werden vorgegeben, und aus diesen Vorgaben soll dann die Gleichung des Funktionsterms berechnet werden. Diesen Weg greife ich in Abschnitt 9.6.6 auf.

Eine vollständige Funktionsuntersuchung umfasst nach [Bossek: 171]:

1. Schritt: Bestimmung des Definitionsbereichs

2. Schritt: Untersuchung auf Symmetrieeigenschaften

3. Schritt: Untersuchung des Verhaltens im Unendlichen

4. Schritt: Untersuchung auf Stetigkeit/Unstetigkeit

5. Schritt: Ermitteln der Schnittpunkte mit der y-Achse

6. Schritt: Bestimmen der Nullstellen

7. Schritt: Ermitteln der Wendepunkte

8. Schritt: Berechnen der lokalen Extrempunkte

9. Schritt: Zeichnen des Funktionsgraphen

Ich beschränke mich hier auf die letzten vier Punkte. Für die Bestimmung der Extrem- und Wendepunkte benötigt man neben der 1. Ableitung auch noch höhere Ableitungen. Für die Berechnung der Nullstellen habe ich das Newton-Verfahren ausgewählt, weil es einfach anzuwenden ist und einen direkten Bezug zur Differenzialrechnung hat.

9.6.1    Statische Darstellung von Extremwerten und Wendepunkt

In einem ersten Schritt geht es darum, die Extremwerte und den Wendepunkt zusammen in einem Diagramm darzustellen, um einen einfachen Überblick über deren Zusammenhang zu geben.

Abbildung 9.5 stellt für das Polynom 3. Grades

die 1. und 2. Ableitung dar.

Abbildung 9.5     Polynom 3. Grades mit 1. und 2. Ableitung

Es ist deutlich zu erkennen, dass die Nullstelle der 1. Ableitung x = –2 das lokale Minimum von ƒ(–2) = –8 der Stammfunktion festlegt. Die zweite Nullstelle x = 2 der 1. Ableitung legt das lokale Maximum ƒ(2) = 0 der Stammfunktion fest.

Der Wendepunkt der Stammfunktion wird durch die Nullstelle der 2. Ableitung ƒ''(0) = 0 bestimmt. Er liegt im Nullpunkt des Koordinatensystems.

Die grafische Bestimmung von Extremwerten und Wendepunkten ist zwar anschaulich, aber noch zu ungenau. Sie muss also durch numerische Berechnung mithilfe anderer Programme weiter präzisiert werden.

Listing 9.9 zeigt, wie der Funktionsplot aus Abbildung 9.5 für das Polynom 3. Grades und dessen 1. und 2. Ableitung erstellt wird:

01  #09_plot_extremwerte.py
02  import numpy as np
03  import matplotlib.pyplot as plt
04  x1,x2=-5,5
05  y1,y2=-10,4
06  #Funktionsdefinition
07  def f(x):
08      return -x**3/4 + 3*x - 4
09  #zentraler Differenzenquotient
10  def ableitung(f,x,h=1e-3):
11      return (f(x+h)-f(x-h))/(2*h)
12  #1. Ableitung
13  def diff1(x):
14      return ableitung(f,x)
15  #2. Ableitung
16  def diff2(x):
17      return ableitung(diff1,x)
18  #Grafikbereich
19  fig, ax = plt.subplots()
20  x = np.linspace(x1, x2,500)
21  ax.plot(x,f(x),lw=2,color='r')
22  ax.plot(x,diff1(x),'b--',label='1. Ableitung')
23  ax.plot(x,diff2(x),'g-.',label='2. Ableitung')
24  ax.set_xlim(x1,x2)
25  ax.set_ylim(y1,y2)
26  ax.legend(loc='best')
27  ax.set(xlabel='x',ylabel='y')
28  ax.grid(True)
29  plt.show()

Listing 9.9     Polynom 3. Grades mit 1. und 2. Ableitung

Analyse

In Zeile 08 können Sie für weitere Testzwecke andere Funktionsterme eingeben. Gegebenenfalls müssen Sie dann die Bereiche in den Zeilen 04 und 05 anpassen.

In den Zeilen 14 und 17 berechnet die selbst definierte Python-Funktion ableitung(f, x,h=1e-3) (Zeilen 10 und 11) die 1. und 2. Ableitung der Funktion f(x) aus Zeile 08. Durch Variation der Schrittweite h in Zeile 10 können Sie die Genauigkeit der Darstellung testen.

9.6.2    Kriterien für Extremstellen

An den Extremstellen muss die Steigung 0 sein. Diese notwendige Bedingung liefert aber noch kein Kriterium dafür, ob ein lokales Maximum oder ein lokales Minimum vorliegt. Wie diese Unterscheidung vorgenommen werden muss, veranschaulicht Abbildung 9.6.

Abbildung 9.6     Kriterien für lokale Maxima und Minima

Aus Abbildung 9.6 können folgende Kriterien für die Unterscheidung abgelesen werden, ob ein lokales Maximum oder ein lokales Minimum vorliegt:

• lokales Maximum
  Die 1. Ableitung muss gleich 0 sein, und die 2. Ableitung muss negativ, also kleiner 0 sein. Das heißt, die 1. Ableitung muss eine negative Steigung haben.

• lokales Minimum
  Die 1. Ableitung muss gleich 0 sein, und die 2. Ableitung muss positiv, also größer 0 sein. Das heißt, die 1. Ableitung muss eine positive Steigung haben.

9.6.3    Simulation der Tangentensteigung für ein Polynom 3. Grades

Ein weiterer Bestandteil der Kurvendiskussion ist die Ermittlung von lokalen Extremwerten. An seinen Rändern gehen die Funktionswerte eines Polynoms gegen unendlich. Dazwischen befinden sich endliche Extremstellen, die entweder lokale Maxima oder Minima sein können. Mit dem Programm aus Abbildung 9.7 können Sie für das Polynom 3. Grades

solche Extremstellen näherungsweise ermitteln.

Abbildung 9.7     Simulation von lokalen Extremstellen und des Wendepunktes

Durch Verschiebung der Slider-Einstellung kann die Lage der Tangente geändert werden. Die aktuelle Steigung wird oben auf der Programmoberfläche angezeigt. Wenn die Steigung 0 ist, dann liegt entweder ein lokales Maximum oder ein lokales Minimum vor. Das lokale Minimum liegt an der Stelle x = –2, und das lokale Maximum liegt an der Stelle x = 2.

Der Wendepunkt liegt bei x = 0. Er kann experimentell ermittelt werden, indem man die Werte der Steigung genau beobachtet. Im Wendepunkt nimmt die Steigung ihren maximal möglichen Wert von m = 3 an.

Listing 9.10 zeigt, wie Sie die Programmoberfläche (siehe Abbildung 9.7) erzeugen können.

01  #10_sld_extremwerte.py
02  import numpy as np
03  import matplotlib.pyplot as plt
04  from matplotlib.widgets import Slider
05  #Polynom
06  def f(x):
07      return -x**3/4 + 3*x - 4
08  #zentraler Differenzenquotient
09  def ableitung(f,x,h=1e-3):
10      return (f(x+h)-f(x-h))/(2*h)
11  #Tangentengleichung
12  def tangente(x,x0):
13      m=ableitung(f,x0)
14      return m*(x-x0)+f(x0)
15  #Slider-Einstellung ermitteln
16  def update(val):
17      x0 = sldA.val
18      m=ableitung(f,x0)
19      xs=np.array([x0])
20      y1.set_data(x,f(x))
21      y2.set_data(x,tangente(x,x0))
22      y3.set_data(xs,f(xs))
23      txtM.set_text('m = %2.1f' %m)
24  #Grafikbereich

Listing 9.10     Simulation von lokalen Maxima und Minima (Auszug)

Analyse

In Zeile 07 steht die Funktionsgleichung y=-x**3/4+3*x-4 eines Polynoms 3. Grades.

In den Zeilen 09 und 10 wird die Python-Funktion ableitung() definiert. Diese Funktion berechnet in den Zeilen 13 und 18 die Steigung der Tangente.

Innerhalb der Ereignisverarbeitung (Zeile 16 bis 23) werden der Funktionsgraph y1 (Zeile 20), die Tangente y2 (Zeile 21) und der Berührungspunkt der Tangente y3 (Zeile 22) mit dem Funktionsgraphen abhängig von der Slider-Einstellung aktualisiert. Damit der aktuelle Wert der Steigung m auf der Programmoberfläche angezeigt wird, muss noch die Matplotlib-Methode set_text() in Zeile 23 implementiert werden.

9.6.4    Kurvendiskussion mit Numdifftools

Nachdem Sie nun gesehen haben, wie die einzelnen Teilbereiche einer Kurvendiskussion gelöst werden, können Sie sich einer komplexen Aufgabenstellung zuwenden: Die Extremwerte und Wendepunkte sollen numerisch mit den Modulen Numdifftools und SymPy berechnet werden. Als Erstes wird die Kurvendiskussion mit Numdifftools durchgeführt. Es sollen nur die Nullstellen, die Extremwerte und die Wendepunkte eines Polynoms berechnet werden.

Ermittlung der Extremwerte

Die Nullstellen der 1. Ableitung ƒ'(x) bestimmen entweder die lokalen Maxima oder die lokalen Minima. Es bedarf also eines weiteren Kriteriums, mit dem überprüft werden kann, ob es sich um ein Maximum oder ein Minimum handelt. Dazu muss die 2. Ableitung berechnet werden.

Kriterien der 2. Ableitung:

• Gilt ƒ''(x₀) < 0, so liegt bei x₀ ein Maximum vor.

• Gilt ƒ''(x₀) > 0, so liegt bei x₀ ein Minimum vor.

Die Wendepunkte werden durch die Nullstellen der 2. Ableitung bestimmt. Dies ist nur ein notwendiges Kriterium und muss eventuell noch mit der 3. Ableitung überprüft werden. Erst dann erhält man ein hinreichendes Kriterium für die Existenz der Wendepunkte. Um die Übersichtlichkeit des Programms zu bewahren, wird auf diese Überprüfung verzichtet und einfach angenommen, dass die Wendepunkte durch die Nullstellen der 2. Ableitung gegeben sind. Eine Überprüfung, ob die Wendepunkte plausibel berechnet wurden, erfolgt anhand der grafischen Ausgabe.

Der Algorithmus für die Kurvendiskussion hat folgende Grobstruktur:

Module importieren
mathematische Funktion definieren 
1. Ableitung berechnen
2. Ableitung berechnen
Nullstellen der Funktion berechnen
Nullstellen der 1. Ableitung berechnen
Nullstellen der 2. Ableitung berechnen
lokale Maxima berechnen
lokale Minima berechnen
Ausgabe

Für die Berechnung der lokalen Maxima und Minima muss der Algorithmus noch verfeinert werden:

for i in range(len(m)):
    if df_2(m[i])<0:
        print("Maxima x=",m[i],"y=",f(m[i]))
    elif df_2(m[i])>0:
        print("Minima x=",m[i],"y=",f(m[i]))

Innerhalb einer for-Schleife wird überprüft, ob die Nullstelle der 2. Ableitung df_2(m [i]) kleiner 0 ist (negative Steigung). Dann liegt ein lokales Maximum vor. Bei dem Array m[i] handelt es sich um die Nullstellen der 1. Ableitung. Ist die Nullstelle der 2. Ableitung größer 0 (positive Steigung), dann liegt ein lokales Minimum vor.

Listing 9.11 führt für das Polynom 5. Grades

die Kurvendiskussion durch. Es handelt sich um eine ungerade Funktion, also liegt keine Symmetrie bezüglich der y-Achse vor. Die y-Achse wird bei ƒ(0) = –120 geschnitten.

01  #11_plot_numdifftools_kurvendiskussion.py
02  import numpy as np
03  import matplotlib.pyplot as plt
04  from numdifftools import Derivative
05  from scipy.optimize import newton
06  x1,x2=0,5.5
07  y1,y2=-8,5
08  #Funktionsdefinition
09  def f(x):
10      y=x**5-15*x**4+85*x**3-225*x**2+274*x-120
11      return y
12  #1. Ableitung
13  def df_1(x):
14      df = Derivative(f,n=1)
15      return df(x)
16  #2. Ableitung 
17  def df_2(x):
18      df = Derivative(f,n=2)
19      return df(x)
20  #Berechnungen
21  x = np.linspace(x1, x2, 500)
22  xi=newton(f,[0.5,1.7,3.1,4.5,6])
23  m=newton(df_1,[1.3,2.5,3.6,4.6])
24  w=newton(df_2,[2.5,2,4])
25  print("Nullstellen\n",xi)
26  for i in range(len(m)):
27      if df_2(m[i])<0:
28          print("Maxima x =",m[i],"y =",f(m[i]))
29      elif df_2(m[i])>0:
30          print("Minima x =",m[i],"y =",f(m[i])) 
31  print("Wendepunkte\n",w)
32  #Grafikbereich
33  fig,ax=plt.subplots(figsize=(8,6))
34  ax.set_xlim(x1,x2)
35  ax.set_ylim(y1,y2)
36  ax.plot(x,f(x),lw=2,color='r',label='Funktion')
37  ax.plot(x,df_1(x),'b--',label='1. Ableitung')
38  ax.plot(x,df_2(x),'g-.',label='2. Ableitung')
39  ax.legend(loc='best')
40  ax.set(xlabel='x',ylabel='y')
41  ax.grid(True)
42  plt.show()

Listing 9.11     Kurvendiskussion für ein Polynom 5. Grades mit Nummdifftools

Ausgabe

Nullstellen
 [1. 2. 3. 4. 5.]
Maxima x= 1.3555676884028218 y= 3.6314322084427317
Minima x= 2.4560878999543956 y= -1.4186966255829248
Maxima x= 3.5439121000502216 y= 1.4186966255826974
Minima x= 4.644432311603694  y= -3.6314322084417654
Wendepunkte
 [3.    1.77525595    4.22474406]

Abbildung 9.8     Polynom 5. Grades mit 1. und 2. Ableitung

Analyse

In Zeile 04 wird die Funktion Derivative aus dem Modul numdifftools importiert.

In Zeile 10 können Sie eine neue Funktionsgleichung für ein Polynom eingeben. Das Programm ist aber nicht so konzipiert, dass es bestimmte Sonderfälle, z. B. mehrere Sattelpunkte, erfassen kann.

In Zeile 14 und Zeile 18 erfolgen die Funktionsdefinitionen für die 1. und die 2. Ableitung. Die Ableitungen werden mit der Numdifftools-Funktion Derivative(f,n=1) berechnet. Der Parameter n bestimmt die Ordnungszahl der Ableitungsfunktion.

In Zeile 22 berechnet die SciPy-Funktion newton() die Nullstellen des Polynoms. In Zeile 23 berechnet sie die Nullstellen der 1. Ableitung, und in Zeile 24 berechnet sie die Nullstellen der 2. Ableitung. Problematisch sind hier wieder die Startwerte, die als Array übergeben werden müssen.

Innerhalb der for-Schleife (Zeilen 26 bis 30) werden die lokalen Maxima und Minima berechnet und ausgegeben.

Abschließend wird das Polynom und dessen 1. und 2. Ableitung als Funktionsplot ausgegeben (Zeilen 36 bis 38).

Die in Zeile 24 berechneten Wendepunkte w werden in Zeile 31 ausgegeben.

Die nächste, mit SymPy programmierte Version ist wesentlich kompakter aufgebaut. Für die Berechnung der Nullstellen müssen keine Startwerte mehr angegeben werden.

9.6.5    Kurvendiskussion mit SymPy

Da SymPy symbolisch differenzieren kann, bietet es sich an, eine Kurvendiskussion auch mit diesem Modul durchzuführen. Als Testfunktion wird wieder das Polynom 5. Grades

verwendet. Der Algorithmus für die Berechnung der Extremwerte kann aus Listing 9.11 übernommen werden. Dabei muss darauf geachtet werden, dass mit der Methode subs(x,mx) die numerischen Werte der Nullstellen in die symbolischen Terme der 1. und 2. Ableitung eingesetzt werden.

Die Nullstellen berechnet das Programm mit der SymPy-Methode solve(). Der besondere Vorteil dieser Methode besteht darin, dass keine Startwerte vorgegeben werden müssen. Listing 9.12 zeigt, wie Sie mit SymPy eine Kurvendiskussion durchführen können:

01  #12_sympy_kurvendiskussion.py
02  from sympy import *
03  x=symbols('x')
04  x1,x2=0,5
05  fx=x**5-15*x**4+85*x**3-225*x**2+274*x-120
06  df1=diff(fx,x)
07  df2=diff(fx,x,2)
08  x0=solve(fx,x)
09  m=solve(df1,x,dict=True)
10  w=solve(df2,x,dict=True)
11  #Ausgabe
12  print("Funktionsterm\n",fx)
13  print("Nullstellen")
14  print(x0)
15  print("Extremwerte")
16  for i in range(len(m)):
17      mx=m[i][x].evalf(4)
18      if df2.subs(x,mx)<0:
19          print("Maxima x=",mx,"y=",fx.subs(x,mx))
20      elif df2.subs(x,mx)>0:
21          print("Minima x=",mx,"y=",fx.subs(x,mx))
22  print("Wendepunkte")
23  for i in range(len(w)):
24      wx=w[i][x].evalf(4)
25      print(wx,end="|")
26  #Darstellung
27  p=plot(fx,df1,(x,x1,x2),show=False,visible=False,ylim=(-8,4))
28  p[0].line_color='black'
29  p[1].line_color='red'
30  p.show()

Listing 9.12     Kurvendiskussion mit SymPy

Ausgabe

Funktionsterm
 x**5 - 15*x**4 + 85*x**3 - 225*x**2 + 274*x - 120
Nullstellen
[1, 2, 3, 4, 5]
Extremwerte
Minima x= 2.456 y= -1.422
Maxima x= 3.544 y= 1.438
Maxima x= 1.356 y= 3.633
Minima x= 4.644 y= -3.688
Wendepunkte
3.000|1.775|4.225|

Abbildung 9.9     SymPy-Funktionsplot für ein Polynom 5. Grades mit der 1. Ableitung

Analyse

Im Prinzip ist das SymPy-Programm ähnlich aufgebaut wie die SciPy-Version in Listing 9.11. Auf den ersten Blick fällt auf, dass das SymPy-Programm nur 30 Zeilen benötigt.

In Zeile 05 können Sie einen neuen Funktionsterm eingeben. Hier reicht eine einfache Zuweisung. Alle Eigenschaften des Polynoms werden in die Objektvariable fx gespeichert.

In den Zeilen 06 und 07 berechnet die Methode diff() die 1. und 2. Ableitung.

In den Zeilen 08 bis 10 berechnet die Methode solve() die Nullstellen des Polynoms sowie Nullstellen der 1. und 2. Ableitung. In den Zeilen 09 und 10 werden die Ergebnisse als dictionary zurückgegeben.

Innerhalb der for-Schleife (Zeilen 16 bis 21) werden die lokalen Maxima und Minima ermittelt. Dazu muss die Methode evalf(4) in Zeile 17 numerische Werte generieren. Das Objekt mx enthält alle numerischen Nullstellen der 1. Ableitung.

In den Zeilen 19 und 21 gibt print() die Koordinaten der lokalen Maxima bzw. Minima aus.

Die numerischen Werte der Wendepunkte werden innerhalb der nächsten for-Schleife (Zeilen 23 bis 25) aus den Nullstellen der 2. Ableitung w[i][x] ermittelt und in die Objektvariable wx gespeichert. Da als Rückgabeparameter dict=True in der Methode solve(..., dict=True) (Zeilen 09 und 10) gewählt wurde, steht die Variable x für den Wert (engl. value) und w[i] für den Schlüssel (engl. key) des Dictionarys (dict).

9.6.6    Umgekehrte Kurvendiskussion

Bisher haben wir Funktionsgleichungen dahingehend analysiert, welchen Verlauf deren Funktionsgraphen im Koordinatensystem einnehmen. Es gibt aber auch den umgekehrten Weg der Synthese, der auch als umgekehrte Kurvendiskussion bezeichnet wird. Aus bestimmten Vorgaben – z. B. Nullstellen, Extremwerten, Wendepunkten und dem Schnittpunkt mit der y-Achse – soll eine Funktionsgleichung berechnet werden. Das Beispiel für die hier vorgestellte umgekehrte Kurvendiskussion stammt aus [Kammermeyer: 88].

Für das Polynom 3.Grades

f(x) = ax³ + bx² + cx + d

mit der 1. und 2. Ableitung

f' (x) = 3ax² + 2bx + c

f''(x) = 6ax + 2b

sollen die Koeffizienten a bis c bestimmt werden. Es gelten folgende Bedingungen mit d = –4:

f(2) = 0 ⟺ 8a + 4b + 2c – 4 = 0

f' (–2) = 0 ⟺ 12a – 4b + 2c = 0

f'' (0) = 0 ⟺ 2b = 0

Die Lösung des Gleichungssystems ergibt für a = –1/4, b = 0 und c = 3.

Listing 9.13 löst das Gleichungssystem mit der SymPy-Methode solve().

01  #13_polynomgenerator.py
02  from sympy import *
03  x,a,b,c=symbols('x,a,b,c')
04  x1,x2=-6,4
05  d=-4
06  f=a*x**3+b*x**2+c*x+d
07  df1=diff(f,x,1)
08  df2=diff(f,x,2)
09  #Gleichungen
10  g1=f.subs(x,2)
11  g2=df1.subs(x,-2)
12  g3=df2.subs(x,0)
13  i=0
14  L=solve((g1,g2,g3),a,b,c,dict=True)
15  fx=f.subs({a:L[i][a],b:L[i][b],c:L[i][c]})
16  #Ausgabe
17  print("Lösungsmenge:\n",L)
18  print("a=",L[i][a])
19  print("b=",L[i][b])
20  print("c=",L[i][c])
21  print("f(x)=",fx)
22  #Darstellung
23  p=plot(fx,(x,x1,x2),show=False,visible=False,ylim=(-10,5))
24  p.show()

Listing 9.13     Polynomgenerator mit SymPy

Ausgabe

Lösungsmenge:
 [{a: -1/4, b: 0, c: 3}]
a= -1/4
b= 0
c= 3
f(x)= -x**3/4 + 3*x - 4

Abbildung 9.10     SymPy-Funktionsplot für ein Polynom 3. Grades

Analyse

Die Anweisung in Zeile 03 vereinbart die Symbole für die Variablen x, a, b und c. SymPy kann durch diese Vereinbarung mit diesen Variablen symbolische Berechnungen durchführen.

In Zeile 04 können Sie den Darstellungsbereich des Funktionsplots auf der x-Achse ändern. Zeile 05 legt den Schnittpunkt d der Funktionsgleichung mit der y-Achse fest.

In Zeile 06 wird der Term des Polynoms 3. Grades mit den Koeffizienten a, b, c und d der Objektvariablen f zugewiesen.

In den Zeilen 07 und 08 berechnet die Methode diff() die 1. und 2. Ableitung. Die Ergebnisse werden in die Objektvariablen g1, g2 und g3 gespeichert, und es werden die numerischen Werte für x, die sich aus den geforderten Bedingungen ergeben, mit der Methode subs() eingesetzt.

In den Zeilen 10 bis 12 wird das Gleichungssystem aufgestellt. Der Methode subs() werden als zweiter Parameter die Werte für ƒ(x_i), ƒ'(x_i) und ƒ''(x_i) übergeben.

Gelöst wird das Gleichungssystem in Zeile 14. Die Lösungsmenge wird in die Objektvariable L gespeichert. Die Werte für die drei Unbekannten a, b und c werden als Dictionary (dict) zurückgegeben. Mit L[schluessel][wert] lassen sich die numerischen Werte der Polynomkoeffizienten ermitteln.

In Zeile 15 werden der Objektvariablen fx alle Daten des Polynoms zugewiesen.

Die Ausgabe der Lösung erfolgt in den Zeilen 17 bis 21. Die Anweisungen in den Zeilen 23 und 24 zeichnen den Funktionsgraphen fx des Polynoms mit der plot-Methode von SymPy.