Übungen am 8.11.2001

Übungen zu "Computergestütztes symbolisches Rechnen" im Wintersemester 2001/02, Institut für Informatik der Universität München

Bemerkung: Eingaben werden immer durch SHIFT-RETURN abgeschlossen.

Wir wollen Varietäten auch durch Anschauung näherkommen.

<< Graphics`ImplicitPlot`

Dieser Befehl lädt erst das Grafik-Paket in Mathematica. Was das Paket leistet, erfährt man mittels

?ImplicitPlot

Cox et al, Seite 12, Aufgabe 1a:

ImplicitPlot[
        x^2 + 4  y^2 + 2  x - 16  y + 1 == 0, {y, 0, 4}];

Cox et al, Seite 12, Aufgabe 2

ImplicitPlot[
        y^2 - x (x - 1) (x - 2) == 0,  {y, -2, 
          2}];

Cox et al, Seite 12, Aufgabe 7

ImplicitPlot[(x^2 + y^2)^3 - 4  x^2  y^2 == 0, {x, -1, 
          1}];

Roots[(x^2 + y^2)^3 - 4  x^2  y^2 == 0, x]

Cox et al, Seite 12, Aufgabe 3

ImplicitPlot[{x^2 + y^2 - 4 == 0,  
          x y - 1 == 0}, {x, -3, 3}];

Cox et al, Seite 12, Aufgabe 4e

Reduce[{x^4 - z x == 0, x^3 - y x == 0}, x]

Reduce[{x^4 - z x == 0, x^3 - y x == 0}, y]

Gröbner-Basen

Zur Übung geben wir den Befehl FALSCH ein.

GroebnerBase[{x^2 + y^2 - 4,  x y - 1}, {x, y}]

?Groebner*

Remove[GroebnerBase]

?Groebner*

GroebnerBasis[{x^2 + y^2 - 4,  x y - 1}, {x, y}]

Man beachte, daß diese Polynome dieselbe Varietät ergeben, allerdings das erste die Variable x nicht enthält, weshalb man nun leicht eine geschlossene Lösung findet.

reg = Solve[1 - 4 (y^2) + (y^4) == 0, y]

Dies ergibt Ersetzungsregeln für die 4 möglichen Lösungen. Wir können sie einfach einsetzen in den Ausdruck für x, den wir aus dem zweiten Polynom der Gröbner-Basis erhalten.

4  y - y^3  /.  reg

Wir vereinfachen dieses Ergebnis, das wir mit % ansprechen.

Simplify[%]

Natürlich bekommt man das auch direkt mit dem leistungsfähigen Solve-Befehl:

Solve[{x^2 + y^2 - 4 == 0,  x y - 1 == 0}, {x, 
        y}]

Simplify[%]

Polynome

?*Polynomial*

PolynomialQ[x y - 5  x^3/y, {x, y}]

PolynomialQ[x y - 5  x^3/x, {x, y}]

PolynomialQ[Sin[x]^2 + Cos[x]^2, {x}]

PolynomialQ[Simplify[Sin[x]^2 + Cos[x]^2], {x}]

Simplify[Sin[x]^2 + Cos[x]^2]

Dreidimensionales Plotten

?*Plot*

Plot3D[x^2 + y^2, {x, -3, 3}, {y, -3, 3}];

Man beachte den Strichpunkt am Befehlsende, der einen hier uninteressanten Ergebniswert unterdrückt. Die Farbinformation kann darüber hinaus auch programmiert werden. Dazu wollen wir eine höhere Auflösung.

Plot3D[{x^2 + y^2, Hue[1/2 + ((x - y)/6)]}, {x, -3, 
          3}, {y, -3, 3},  PlotPoints -> 30];

Die Fibonacci-Zahlen

Wir wollen hier auf einige Probleme mit der Definition von Funktionen in Mathematica hinweisen. In der Tat sind es nur Probleme im Umgang mit den vielfältigen Möglichkeiten.

?fib

fib[0] = 1

fib[1] = 1

?fib

Wir versuchen, einfach die Rekursionsgleichung als Definition hinzuschreiben.

fib[n] = fib[n - 1] + fib[n - 2]

Leider wird das nur für Argument n benutzt:

6 + fib[2]

6 + fib[n]

Ein neuer Versuch - nach Löschen des bisherigen Definitionen für fib mit als Patternvariable deklariertem n

Clear[fib];  fib[0] = 1; fib[1] = 1;

Folgende Eingabe verlangt nach Abbruch mit ALT-. (ALT-Taste links und . gleichzeitig drücken!)

fib[n_] = fib[n - 1] + fib[n - 2]

Leider ergab das nur eine definitorische Endlosschleife. Wir dürfen nicht gleich weiterrechnen! Dafür gibt es die verzögerte Zuweisung.

Clear[fib];  fib[0] = 1; fib[1] = 1;

fib[n_] := fib[n - 1] + fib[n - 2]

?fib

Table [fib[i], {i, 0, 10}]

Nur haben wir keine Einschränkung an den Definitionsbereich angegeben.

fib[-1]

fib[7/2]

Clear[fib];  fib[0] = 1; fib[1] = 1;

fib[n_] := 
      fib[n - 1] + fib[n - 2]  /;  n ≥ 2

fib[-1]

fib[7/2]

Um auch das letzte Problem zu beheben, schränken wir den Bereich für n weiter ein.

Clear[fib];  fib[0] = 1; fib[1] = 1;

fib[n_Integer] := 
      fib[n - 1] + fib[n - 2]  /;  n ≥ 2

fib[7/2]

Leider ist dieses Programm äußerst ineffizient, weil alle Teilberechnungen immer wieder ausgeführt werden. So will man nicht auf das Ergebnis im folgenden Fall warten.

fib[30]

Die Idee ist nun, die schon berechneten Werte als Funktionswerte abzuspeichern.

Clear[fib];  fib[0] = 1; fib[1] = 1;

fib[n_Integer] := (fib[n] = fib[n - 1] + fib[n - 2])  /;  
        n ≥ 2

?fib

fib[4]

?fib

Table[fib[i], {i, 0, 100}]

Leider darf keine Rekursion mehr als 256 übereinanderliegende offene Rechnungen erreichen:

fib[355]

Leider verdirbt das die weiteren Rechnungen:

fib[102]

Dennoch können wir problemlos auch bis zum Index 10000 tabellieren, weil ja dann die Zwischenergebnisse schon berechnet sind. Wir wollen die Tabelle aber lieber nicht ausgeben...

Clear[fib];  fib[0] = 1; fib[1] = 1; 
    fib[n_Integer] := (fib[n] = fib[n - 1] + fib[n - 2])  /;  
        n ≥ 2; Table[fib[i], {i, 0, 10000}];

fib[10000]