Ticket #9725: interfaces.rst

File interfaces.rst, 11.6 KB (added by mardaus, 9 years ago)
Line 
1**************
2Schnittstellen
3**************
4
5Ein zentraler Gesichtspunkt von Sage ist, dass es Berechnungen mit Objekten
6vieler verschiedener Computer Algebra Systeme unter einem Dach durch eine
7einheitliche Schnittstelle und Programmiersprache vereinigt.
8
9Die ``console`` und ``interact`` Methoden einer Schnittstelle unterstützen
10viele verschiedene Dinge. Zum Beispiel, anhand von GAP:
11
12
13#. ``gap.console()``: Öffnet die GAP Konsole und übergibt GAP die
14   Kontrolle. Hier ist Sage nichts weiter als ein praktischer
15   Programmstarter, ähnlich einer Linux bash Konsole.
16
17#. ``gap.interact()``: Ist eine einfache Art mit einer GAP Instanz
18   zu interagieren, die Sage Objekte enthalten kann. Sie können Sage
19   Objekte in diese GAP Sitzung importieren (sogar von der interaktiven
20   Schnittstelle aus), usw.
21
22.. index: PARI; GP
23
24GP/PARI
25=======
26
27PARI ist ein kompaktes, sehr ausgereiftes, starkoptimiertes C Programm,
28dessen primärer Fokus Zahlentheorie ist. Es gibt zwei sehr verschiedene
29Schnittstellen, die Sie in Sage nutzen können:
30
31
32-  ``gp`` - Der "**G** o **P** ARI" Interpreter, und
33
34-  ``pari`` - Die PARI C Bibliothek.
35
36
37Die folgenden Zeilen zum Beispiel sind zwei Wege, genau das gleiche zu
38tun. Sie sehen identisch aus, aber die Ausgabe ist verschieden, und was
39hinter den Kulissen passiert ist völlig unterschiedlich.
40
41::
42
43    sage: gp('znprimroot(10007)')
44    Mod(5, 10007)
45    sage: pari('znprimroot(10007)')
46    Mod(5, 10007)
47
48Im ersten Fall wird eine seperate Kopie des GP Interpreters als Server
49gestartet, die Zeichenkette ``'znprimroot(10007)'`` übergeben,
50von GP ausgewertet und das Ergebnis wird einer Variable in GP zugewiesen
51(was Platz im Speicher des GP Unterprozesses benötigt, der nicht wieder
52freigegeben wird). Dann wird der Wert der Variablen erst angezeigt.
53Im zweiten Fall wird kein seperates Programm gestartet, stattdessen
54wird die Zeichenkette ``'znprimroot(10007)'`` von einer bestimmten
55PARI C Bibliotheksfunktion ausgewertet. Das Ergebnis wird im Speicher
56von Python gehalten, welcher freigegeben wird wenn die Variable nicht
57mehr referenziert wird. Die Objekte haben ausserdem verschiedene Typen:
58
59::
60
61    sage: type(gp('znprimroot(10007)'))
62    <class 'sage.interfaces.gp.GpElement'>
63    sage: type(pari('znprimroot(10007)'))
64    <type 'sage.libs.pari.gen.gen'>
65
66Welche Variante sollten Sie also nutzen? Das kommt darauf an was
67Sie tun. Die GP Schnittstelle kann alles was ein normales GP/PARI
68Konsolenprogramm könnte, da es das Programm startet. Genauergesagt könnten
69Sie komplzierte PARI Programme laden und laufen lassen. Im Gegensatz dazu
70ist die PARI Schnittstelle (mittels C Bibliothek) wesentlich restriktiver.
71Zuerst einmal sind nicht alle Unterfunktionen implementiert. Ausserdem
72wird relativ viel Quellcode nicht in der PARI Schnittstelle funktionieren,
73z.B. numerisches Integrieren. Abgesehen davon ist die PARI Schnittstelle
74wesentlich schneller und robuster als die von GP.
75
76(Wenn der GP Schnittstelle der Speicher ausgeht, beim Auswerten einer Zeile
77wird sie automatisch und unbemerkt den Speicherbereich verdoppeln und das
78Auswerten erneut versuchen. Dadurch wird Ihre Berechnung nicht abstürtzen,
79falls Sie den benötigen Speicher falsch eingeschätzt haben. Das ist eine
80hilfreiche Erweiterung, die der gewöhnliche GP Interpreter nicht bietet.
81Die PARI C Bibliothek hingegen kopiert jedes neue Objekt sofort vom PARI Stapel,
82daher wird der Stapel nicht größer. Allerdings muss jedes Objekt kleiner als 100
83MB sein, da ansonsten der Stapel "überläuft", wenn das Objekt erstellt wird. Dieses
84zusätzliche Kopieren erzeugt allerdings ein wenig Leistungseinbußen.)
85
86Zusammengefasst nutzt Sage also die PARI C Bibliothek um Funktionalitäten
87eines GP/PARI Interpreters bereitzustellen, allerdings mit einer anderen
88komplizierten Speicherverwaltung und der Programmiersprache Python.
89
90Zuerst erstellen wir eine PARI Liste aus einer Python Liste.
91
92::
93
94    sage: v = pari([1,2,3,4,5])
95    sage: v
96    [1, 2, 3, 4, 5]
97    sage: type(v)
98    <type 'sage.libs.pari.gen.gen'>
99
100Jedes PARI Objekt ist vom Typ ``py_pari.gen``. Den PARI Typ des vorliegenden
101Objekts können Sie mit der ``type`` Unterfunktion herausfinden.
102
103.. link
104
105::
106
107    sage: v.type()
108    't_VEC'
109
110Um eine elliptische Kurve in PARI zu erstellen geben Sie
111``ellinit([1,2,3,4,5])`` ein. Bei Sage ist es ähnlich, nur
112dass ``ellinit`` eine Methode ist, die von jedem PARI Objekt
113aus aufgerufen werden kann, z.B. unser ``t\_VEC v``.
114
115.. link
116
117::
118
119    sage: e = v.ellinit()
120    sage: e.type()         
121    't_VEC'
122    sage: pari(e)[:13]
123    [1, 2, 3, 4, 5, 9, 11, 29, 35, -183, -3429, -10351, 6128487/10351]
124
125Jetzt haben wir eine elliptische Kurve als Objekt und können einige
126Dinge mit ihr berechnen.
127
128.. link
129
130::
131
132    sage: e.elltors()
133    [1, [], []]
134    sage: e.ellglobalred()
135    [10351, [1, -1, 0, -1], 1]
136    sage: f = e.ellchangecurve([1,-1,0,-1])
137    sage: f[:5]
138    [1, -1, 0, 4, 3]
139
140.. index: GAP
141
142.. _section-gap:
143
144GAP
145===
146
147Sage enthält ausserdem GAP 4.4.10 für diskrete Mathematik, insbesondere
148Gruppentheorie.
149
150Hier ist ein Beispiel für GAP's ``IdGroup`` Funktion, die die optionale kleine
151Gruppen Datenbank benötigt, die seperat installiert werden muss, wie unten beschrieben.
152
153::
154
155    sage: G = gap('Group((1,2,3)(4,5), (3,4))')
156    sage: G
157    Group( [ (1,2,3)(4,5), (3,4) ] )
158    sage: G.Center()
159    Group( () )
160    sage: G.IdGroup()   
161    [ 120, 34 ]
162    sage: G.Order()
163    120
164
165Wir können die gleiche Berechnung in Sage durchführen ohne vorher explizit
166die GAP Schnittstelle aufzurufen:
167
168::
169
170    sage: G = PermutationGroup([[(1,2,3),(4,5)],[(3,4)]])
171    sage: G.center()
172    Permutation Group with generators [()]
173    sage: G.group_id()     # benötigt das optionale database_gap Paket
174    [120, 34]
175    sage: n = G.order(); n
176    120
177
178(Für einige GAP Funktionen sollten Sie zwei optionale Sage
179Pakete installieren.
180Geben Sie ``sage -optional`` ein, um eine Liste zu erhalten und
181wählen Sie das Paket aus, das etwa so aussieht ``gap\_packages-x.y.z``.
182Geben Sie dann ``sage -i gap\_packages-x.y.z`` ein.
183Das gleiche machen Sie bitte mit ``database\_gap-x.y.z``.
184Einige nicht-GPL Pakete können installiert werden, indem Sie sie von
185der GAP Website [GAPkg]_ herunter laden und nach ``$SAGE_ROOT/local/lib/gap-4.4.10/pkg``
186entpacken.)
187
188Singular
189========
190
191
192Singular bietet eine sehr gute, ausgereifte Bibliothek für Gröber Basen,
193größte gemeinsame Teiler von mehrdimensionalen Polynomen, Basen von
194Riemann-Roch Räumen einer planaren Kurve und Faktorisierungen unter anderem.
195Wir zeigen hier die Faktorisierung mehrdimensionaler Polynome mit Sages Singular
196Schnittstelle (ohne die ``...``):
197
198::
199
200    sage: R1 = singular.ring(0, '(x,y)', 'dp')
201    sage: R1
202    //   characteristic : 0
203    //   number of vars : 2
204    //        block   1 : ordering dp
205    //                  : names    x y
206    //        block   2 : ordering C
207    sage: f = singular('9*y^8 - 9*x^2*y^7 - 18*x^3*y^6 - 18*x^5*y^6 + \
208    ...   9*x^6*y^4 + 18*x^7*y^5 + 36*x^8*y^4 + 9*x^10*y^4 - 18*x^11*y^2 - \
209    ...   9*x^12*y^3 - 18*x^13*y^2 + 9*x^16')
210
211Wir haben also :math:`f` definiert, nun geben wir es aus und faktorisieren es.
212
213.. link
214
215::
216
217    sage: f
218    9*x^16-18*x^13*y^2-9*x^12*y^3+9*x^10*y^4-18*x^11*y^2+36*x^8*y^4+18*x^7*y^5-18*x^5*y^6+9*x^6*y^4-18*x^3*y^6-9*x^2*y^7+9*y^8
219    sage: f.parent()
220    Singular
221    sage: F = f.factorize(); F
222    [1]:
223       _[1]=9
224       _[2]=x^6-2*x^3*y^2-x^2*y^3+y^4
225       _[3]=-x^5+y^2
226    [2]:
227       1,1,2
228    sage: F[1][2]
229    x^6-2*x^3*y^2-x^2*y^3+y^4
230
231Genau wie im GAP Beispiel in :ref:`section-gap`, können wir diese Faktorisierung
232berechnen ohne explizit die Singular Schnittstelle zunutzen.
233(dennoch nutzt Sage im Hintergrund die Singularschnittstelle für die Berechnung)
234Bitte geben Sie ein ohne ``...``:
235
236::
237
238    sage: x, y = QQ['x, y'].gens()
239    sage: f = 9*y^8 - 9*x^2*y^7 - 18*x^3*y^6 - 18*x^5*y^6 + 9*x^6*y^4\
240    ...   + 18*x^7*y^5 + 36*x^8*y^4 + 9*x^10*y^4 - 18*x^11*y^2 - 9*x^12*y^3\
241    ...   - 18*x^13*y^2 + 9*x^16
242    sage: factor(f)
243    (9) * (-x^5 + y^2)^2 * (x^6 - 2*x^3*y^2 - x^2*y^3 + y^4)
244
245.. _section-maxima:
246
247Maxima
248======
249
250Maxima ist sowohl in Sage, alsauch in Lisp implementiert. Das gnuplot
251Paket (welches Maxima standardmäßig zum plotten nutzt) wird als
252optionales Sage Paket angeboten. Neben anderen Dingen rechnet Maxima
253mit Symbolen. Maxima integriert und differenziert Funktionen smybolisch,
254löst gewöhnliches Differentialgleichungen ersten Grades, sowie viele lineare
255Differentialgleichungen zweiten Grades und besitzt eine Methode zur
256Laplace Transformation linearer Differentialgleichungen von beliebigem Grad.
257Maxima kennt eine große Zahl spezieller Funktionen, plottet mittels gnuplot,
258und hat Methoden um Polynomgleichungen oder Matrizen zu lösen oder zu verändern (z.B. Zeilenelimination
259oder Eigenwerte und Eigenvektoren berechnen).
260
261Wir zeigen die Sage/Maxima Schnittstelle, indem wir die Matrix konstruieren,
262deren :math:`i,j` Eintrag gerade :math:`i/j` ist, für :math:`i,j=1,\ldots,4`.
263
264::
265
266    sage: f = maxima.eval('ij_entry[i,j] := i/j')
267    sage: A = maxima('genmatrix(ij_entry,4,4)'); A
268    matrix([1,1/2,1/3,1/4],[2,1,2/3,1/2],[3,3/2,1,3/4],[4,2,4/3,1])
269    sage: A.determinant()
270    0
271    sage: A.echelon()
272    matrix([1,1/2,1/3,1/4],[0,0,0,0],[0,0,0,0],[0,0,0,0])
273    sage: A.eigenvalues()
274    [[0,4],[3,1]]
275    sage: A.eigenvectors()
276    [[[0,4],[3,1]],[[[1,0,0,-4],[0,1,0,-2],[0,0,1,-4/3]],[[1,2,3,4]]]]
277
278Hier ein anderes Beispiel:
279
280::
281
282    sage: A = maxima("matrix ([1, 0, 0], [1, -1, 0], [1, 3, -2])")
283    sage: eigA = A.eigenvectors()
284    sage: V = VectorSpace(QQ,3)
285    sage: eigA
286    [[[-2,-1,1],[1,1,1]],[[[0,0,1]],[[0,1,3]],[[1,1/2,5/6]]]]
287    sage: v1 = V(sage_eval(repr(eigA[1][0][0]))); lambda1 = eigA[0][0][0]
288    sage: v2 = V(sage_eval(repr(eigA[1][1][0]))); lambda2 = eigA[0][0][1]
289    sage: v3 = V(sage_eval(repr(eigA[1][2][0]))); lambda3 = eigA[0][0][2]
290   
291    sage: M = MatrixSpace(QQ,3,3)
292    sage: AA = M([[1,0,0],[1, - 1,0],[1,3, - 2]])
293    sage: b1 = v1.base_ring()
294    sage: AA*v1 == b1(lambda1)*v1
295    True
296    sage: b2 = v2.base_ring()
297    sage: AA*v2 == b2(lambda2)*v2
298    True
299    sage: b3 = v3.base_ring()
300    sage: AA*v3 == b3(lambda3)*v3
301    True
302
303Zuletzt noch ein Beispiel wie man Sage zum Plotten nutzt mittels ``openmath``.
304Einige von ihnen wurden (verändert) aus dem Maxima Benutzerhandbuch entnommen.
305
306Ein 2D-Plot verschiedener Funktionen (ohne ``...`` eingeben):
307
308::
309
310    sage: maxima.plot2d('[cos(7*x),cos(23*x)^4,sin(13*x)^3]','[x,0,1]',\
311    ...   '[plot_format,openmath]') # not tested
312
313Ein "live" 3D-Plot, den man mit der Maus bewegen kann (ohne ``...`` eingeben):
314
315::
316
317    sage: maxima.plot3d ("2^(-u^2 + v^2)", "[u, -3, 3]", "[v, -2, 2]",\
318    ...   '[plot_format, openmath]') # nicht getestet
319    sage: maxima.plot3d("atan(-x^2 + y^3/4)", "[x, -4, 4]", "[y, -4, 4]",\
320    ...   "[grid, 50, 50]",'[plot_format, openmath]') # nicht getestet
321
322Der nächste Plot ist das berühmte Möbiusband. (ohne ``...`` eingeben):
323
324::
325
326    sage: maxima.plot3d("[cos(x)*(3 + y*cos(x/2)), sin(x)*(3 + y*cos(x/2)),\
327    ...   y*sin(x/2)]", "[x, -4, 4]", "[y, -4, 4]",\
328    ...   '[plot_format, openmath]') # nicht getestet
329
330Und der letzte ist die berühmte Klein'sche Flasche (ohne ``...`` eingeben):
331
332::
333
334    sage: maxima("expr_1: 5*cos(x)*(cos(x/2)*cos(y) + sin(x/2)*sin(2*y)+ 3.0)\
335    ...   - 10.0")
336    5*cos(x)*(sin(x/2)*sin(2*y)+cos(x/2)*cos(y)+3.0)-10.0
337    sage: maxima("expr_2: -5*sin(x)*(cos(x/2)*cos(y) + sin(x/2)*sin(2*y)+ 3.0)")
338    -5*sin(x)*(sin(x/2)*sin(2*y)+cos(x/2)*cos(y)+3.0)
339    sage: maxima("expr_3: 5*(-sin(x/2)*cos(y) + cos(x/2)*sin(2*y))")
340    5*(cos(x/2)*sin(2*y)-sin(x/2)*cos(y))
341    sage: maxima.plot3d ("[expr_1, expr_2, expr_3]", "[x, -%pi, %pi]",\
342    ...   "[y, -%pi, %pi]", "['grid, 40, 40]",\
343    ...   '[plot_format, openmath]') # nicht getestet
344