Ticket #9725: interactive_shell.rst

File interactive_shell.rst, 29.1 KB (added by mardaus, 9 years ago)
Line 
1.. _chapter-interactive_shell:
2
3*****************************
4Die interaktive Kommandozeile
5*****************************
6In den meisten Teilen dieses Tutorials, gehen wir davon aus, dass Sie
7Sage mit dem ``sage`` Befehl starten. Dieser startet eine angepasste
8Version der IPython Kommandozeile und läd Funktionen und Klassen, sodass
9sie in der Kommandozeile genutzt werden können. Weitere Anpassungen können
10Sie in der Datei ``$SAGE_ROOT/ipythonrc`` vornehmen. Nach dem Start von Sage
11sehen Sie etwa folgendes:
12
13.. skip
14
15::
16
17    ----------------------------------------------------------------------
18    | SAGE Version 4.5.2, Release Date: 2010-08-05                       |
19    | Type notebook() for the GUI, and license() for information.        |
20    ----------------------------------------------------------------------
21   
22   
23    sage:
24
25Um Sage zu beenden drücken Sie Strg-D oder geben Sie
26``quit`` oder ``exit`` ein.
27
28.. skip
29
30::
31
32    sage: quit
33    Exiting SAGE (CPU time 0m0.00s, Wall time 0m0.89s)
34
35Unter "wall time" finden Sie die vergangene Echtzeit (der Uhr an Ihrer Wand).
36Diese ist nötig, da die CPU Zeit Unterprozesse wie GAP oder Singular nicht
37berücksichtigt.
38
39(Vermeiden Sie es den Sage Prozess mit ``kill -9`` in der Konsole zu beenden,
40da so möglicherweise Unterprozesse wie z.B. Maple Prozesse nicht beendet oder
41temporäre Dateien in ``$HOME/.sage/tmp`` nicht gelöscht würden.)
42
43
44Ihre Sage Sitzung
45=================
46
47Unter Sitzung verstehen wir ist die Ein- und Ausgaben vom Starten bis zum
48Beenden von Sage. Sage speichert alle Eingaben mittels IPython. Wenn Sie
49die interaktive Kommandozeile nutzen (im Gegensatz zur Browser-Oberfläche "Notebook"),
50so können Sie jederzeit mittels ``%hist`` eine Liste aller bisher getätigten Eingaben sehen.
51Sie können auch ``?`` eingeben, um mehr über IPython zu erfahren.
52Z.B. "IPython unterstützt Zeilennummerierung ... sowie Ein- und Ausgabezwischenspeicherung.
53Alle Eingaben werden gespeichert und können in Variablen abgerufen werden (neben der normalen Pfeiltasten-Navigation).
54Die folgenden globalen Variablen existieren immer (also bitte überschreiben Sie sie nicht!)":
55
56::
57
58      _:  letzte Eingabe (interaktive Kommandozeile und Browser-Oberfläche)
59      __: vorletzte Eingabe (nur in der Kommandozeile)
60      _oh : Liste aller Eingaben (nur in der Kommandozeile)
61
62Hier ein Beispiel:
63
64.. skip
65
66::
67
68    sage: factor(100)
69     _1 = 2^2 * 5^2
70    sage: kronecker_symbol(3,5)
71     _2 = -1
72    sage: %hist   # funktioniert nur in der Kommandozeile, nicht im Browser.
73    1: factor(100)
74    2: kronecker_symbol(3,5)
75    3: %hist
76    sage: _oh
77     _4 = {1: 2^2 * 5^2, 2: -1}
78    sage: _i1
79     _5 = 'factor(ZZ(100))\n'
80    sage: eval(_i1)
81     _6 = 2^2 * 5^2
82    sage: %hist
83    1: factor(100)
84    2: kronecker_symbol(3,5)
85    3: %hist
86    4: _oh
87    5: _i1
88    6: eval(_i1)
89    7: %hist
90
91Wir lassen die Zeilennummerierung im restlichen Tutorial sowie der weiteren Sage Dokumentation weg.
92
93Sie können auch eine Liste von Eingaben einer Sitzung in einem Makro für diese Sitzung speichern.
94
95.. skip
96
97::
98
99    sage: E = EllipticCurve([1,2,3,4,5])
100    sage: M = ModularSymbols(37)
101    sage: %hist
102    1: E = EllipticCurve([1,2,3,4,5])
103    2: M = ModularSymbols(37)
104    3: %hist
105    sage: %macro em 1-2
106    Macro `em` created. To execute, type its name (without quotes).
107
108
109.. skip
110
111::
112
113    sage: E
114    Elliptic Curve defined by y^2 + x*y + 3*y = x^3 + 2*x^2 + 4*x + 5 over
115    Rational Field
116    sage: E = 5
117    sage: M = None
118    sage: em
119    Executing Macro...
120    sage: E
121    Elliptic Curve defined by y^2 + x*y + 3*y = x^3 + 2*x^2 + 4*x + 5 over
122    Rational Field
123
124Während Sie die interaktive Kommandozeile nutzen können Sie jeden UNIX-Kommandozeilenbefehl
125in Sage ausführen, indem Sie ihm ein Ausrufezeichen ``!`` voranstellen. Zum Beispiel gibt
126
127.. skip
128
129::
130
131    sage: !ls
132    auto  example.sage glossary.tex  t  tmp  tut.log  tut.tex
133
134den Inhalt des aktuellen Verzeichnises aus.
135
136In der ``PATH``-Variablen steht das Sage "bin" Verzeichnis vorne. Wenn Sie also
137``gp``, ``gap``, ``singular``, ``maxima``, usw. eingeben, starten Sie die Versionen
138aus Sage.
139
140.. skip
141
142::
143
144    sage: !gp
145    Reading GPRC: /etc/gprc ...Done.
146   
147                               GP/PARI CALCULATOR Version 2.2.11 (alpha)
148                      i686 running linux (ix86/GMP-4.1.4 kernel) 32-bit version
149    ...
150    sage: !singular
151                         SINGULAR                             /  Development
152     A Computer Algebra System for Polynomial Computations   /   version 3-1-0
153                                                           0<
154         by: G.-M. Greuel, G. Pfister, H. Schoenemann        \   Mar 2009
155    FB Mathematik der Universitaet, D-67653 Kaiserslautern    \
156
157Ein- und Ausgaben loggen
158========================
159
160Die Sage Sitzung loggen bzw. speichern ist nicht das Gleiche (siehe :ref:`section-save`).
161Um Eingaben (und optional auch Ausgaben) zu loggen nutzen Sie den Befehl ``logstart``.
162Geben Sie ``logstart?`` ein um weitere Informationen zu erhalten.
163Sie können diesen Befehl nutzen um alle Eingaben und Ausgaben zu loggen, und diese sogar
164wiederholen in einer zukünftigen Sitzung (indem Sie einfach die Log-Datei laden).
165
166.. skip
167
168::
169
170    was@form:~$ sage
171    ----------------------------------------------------------------------
172    | SAGE Version 4.5.2, Release Date: 2010-08-05                       |
173    | Type notebook() for the GUI, and license() for information.        |
174    ----------------------------------------------------------------------
175   
176    sage: logstart setup
177    Activating auto-logging. Current session state plus future input saved.
178    Filename       : setup
179    Mode           : backup
180    Output logging : False
181    Timestamping   : False
182    State          : active
183    sage: E = EllipticCurve([1,2,3,4,5]).minimal_model()
184    sage: F = QQ^3
185    sage: x,y = QQ['x,y'].gens()
186    sage: G = E.gens()
187    sage:
188    Exiting SAGE (CPU time 0m0.61s, Wall time 0m50.39s).
189    was@form:~$ sage
190    ----------------------------------------------------------------------
191    | SAGE Version 4.5.2, Release Date: 2010-08-05                       |
192    | Type notebook() for the GUI, and license() for information.        |
193    ----------------------------------------------------------------------
194   
195    sage: load "setup"
196    Loading log file <setup> one line at a time...
197    Finished replaying log file <setup>
198    sage: E
199    Elliptic Curve defined by y^2 + x*y  = x^3 - x^2 + 4*x + 3 over Rational
200    Field
201    sage: x*y
202    x*y
203    sage: G
204    [(2 : 3 : 1)]
205
206Wenn sie Sage in der Linux KDE Konsole ``konsole`` verwenden, können Sie
207Ihre Sitzung wie folgt speichern: nachdem Sie Sage in ``konsole`` gestartet
208haben, wählen Sie "Einstellungen", dann "Verlauf...", dann "auf unbegrenzt" setzen.
209Wenn Sie soweit sind Ihre Sitzung zu speichern, wählen Sie "Bearbeiten" und dann "Verlauf speichern unter..."
210und geben Sie einen Namen ein, um den Text ihrer Sitzung auf dem Computer zu speichern.
211Nach dem Speichern der Datei, können Sie sie in einem Editor wie xemacs öffnen und ausdrucken.
212
213
214Einfügen ignoriert Eingabeaufforderungen
215========================================
216
217Stellen Sie sich vor, Sie lesen eine Sitzung von Sage oder Python Berechnungen und
218wollen sie in Sage kopieren, aber überall sind noch die störenden ``>>>`` oder ``sage:`` Eingabeaufforderungen.
219Tatsächlich können Sie einfach die gewünschte Stelle mit Eingabeaufforderungen in Sage einfügen. Der Sage Parser
220wird standardmäßig die führenden ``>>>`` oder ``sage:`` Eingabeaufforderungen entfernen bevor er es an Python
221weitergibt. Zum Beispiel:
222
223.. skip
224
225::
226
227    sage: 2^10
228    1024
229    sage: sage: sage: 2^10
230    1024
231    sage: >>> 2^10
232    1024
233
234Befehle zur Zeitmessung
235=======================
236
237Wenn Sie den ``%time`` Befehl vor eine Eingabe schreiben, wird die Zeit, die
238der Aufruf benötigt, ausgegeben nachdem er gelaufen ist.
239Zum Beispiel können wir die Laufzeit einer bestimmten Potenzierung auf verschiedene
240Arten vergleichen. Die unten genannte Laufzeit wird unter Umständen weit von der Laufzeit
241auf Ihrem Computer, oder sogar zwischen verschiedenen Sage Versionen, abweichen.
242Zuerst natives Python:
243
244.. skip
245
246::
247
248    sage: %time a = int(1938)^int(99484)
249    CPU times: user 0.66 s, sys: 0.00 s, total: 0.66 s
250    Wall time: 0.66
251
252Das bedeutet insgesamt 0,66 Sekunden wurden benötigt, und die vergangene "Wall time",
253also die vergangene Echtzeit (auf ihrer Wanduhr), betrug auch 0,66 Sekunden.
254Wenn auf Ihrem Computer viele andere Programme gleichzeitig laufen, kann die "Wall time"
255wesentlich größer als die CPU Zeit sein.
256
257Als nächstes messen wir die Laufzeit der Potenzierung unter Verwendung des nativen Sage Ganzzahl-Typs,
258der (in Cython implementiert ist und) die GMP Bibliothek nutzt:
259
260.. skip
261
262::
263
264    sage: %time a = 1938^99484
265    CPU times: user 0.04 s, sys: 0.00 s, total: 0.04 s
266    Wall time: 0.04
267
268Unter Verwendung der PARI C-Bibliothek:
269
270.. skip
271
272::
273
274    sage: %time a = pari(1938)^pari(99484)
275    CPU times: user 0.05 s, sys: 0.00 s, total: 0.05 s
276    Wall time: 0.05
277
278GMP ist also ein bisschen besser (wie erwartet, da die für Sage verwendete PARI Version GMP für Ganzzahlarithmetik nutzt).
279
280Sie können ebenso Befehlsblöcke messen, indem Sie ``cputime`` wie unten verwenden:
281
282::
283
284    sage: t = cputime()
285    sage: a = int(1938)^int(99484)
286    sage: b = 1938^99484
287    sage: c = pari(1938)^pari(99484)
288    sage: cputime(t)                       # ein wenig zufällige Ausgabe
289    0.64                                     
290
291.. skip
292
293::
294
295    sage: cputime?
296    ...
297        Return the time in CPU second since SAGE started, or with optional
298        argument t, return the time since time t.
299        INPUT:
300            t -- (optional) float, time in CPU seconds
301        OUTPUT:
302            float -- time in CPU seconds
303
304Der ``walltime`` Befehl entspricht ``cputime``, nur misst dieser die Echtzeit.
305
306Wir können die oben genannte Potenz auch in einigen der Computer Algebra System, die Sage
307mitbringt berechnen. In jedem Fall führen wir einen trivialen Befehl aus, um den entsprechenden
308Server dieses Programmes zu starten. Sollte es erhebliche Unterschiede zwischen Echtzeit und CPU-Zeit
309geben, deutet dies auf ein Leistungsproblem hin, dem man nachgehen sollte.
310
311.. skip
312
313::
314
315    sage: time 1938^99484;
316    CPU times: user 0.01 s, sys: 0.00 s, total: 0.01 s
317    Wall time: 0.01
318    sage: gp(0)
319    0
320    sage: time g = gp('1938^99484')
321    CPU times: user 0.00 s, sys: 0.00 s, total: 0.00 s
322    Wall time: 0.04
323    sage: maxima(0)
324    0
325    sage: time g = maxima('1938^99484')
326    CPU times: user 0.00 s, sys: 0.00 s, total: 0.00 s
327    Wall time: 0.30
328    sage: kash(0)
329    0
330    sage: time g = kash('1938^99484')
331    CPU times: user 0.00 s, sys: 0.00 s, total: 0.00 s
332    Wall time: 0.04
333    sage: mathematica(0)
334            0
335    sage: time g = mathematica('1938^99484')
336    CPU times: user 0.00 s, sys: 0.00 s, total: 0.00 s
337    Wall time: 0.03
338    sage: maple(0)
339    0
340    sage: time g = maple('1938^99484')
341    CPU times: user 0.00 s, sys: 0.00 s, total: 0.00 s
342    Wall time: 0.11
343    sage: gap(0)
344    0
345    sage: time g = gap.eval('1938^99484;;')
346    CPU times: user 0.00 s, sys: 0.00 s, total: 0.00 s
347    Wall time: 1.02
348
349Achten Sie darauf, dass GAP und Maxima am langsamsten in diesem Test
350sind (er lief auf dem Computer ``sage.math.washington.edu``). Aufgrund
351des "Pexpect interface overhead"#TODO ist es aber vielleicht unfair
352diese mit Sage zu vergleichen, welches am schnellsten war.
353
354Fehlerbehandlung
355================
356
357Wenn irgendetwas schief geht werden Sie normalerweise eine Pythonfehlermeldung sehen.
358Python macht sogar einen Vorschlag, was den Fehler ausgelöst hat. Oft sehen Sie den Namen
359der Fehlermeldung, z.B. ``NameError`` oder ``ValueError`` (vgl. Python Reference Manual [Py]_ für eine komplette Liste der Fehlermeldungen).
360Zum Beispiel:
361
362.. skip
363
364::
365
366    sage: 3_2
367    ------------------------------------------------------------
368       File "<console>", line 1
369         ZZ(3)_2
370               ^
371    SyntaxError: invalid syntax
372   
373    sage: EllipticCurve([0,infinity])
374    ------------------------------------------------------------
375    Traceback (most recent call last):
376    ...
377    TypeError: Unable to coerce Infinity (<class 'sage...Infinity'>) to Rational
378
379Der interaktive Debugger ist manchmal hilfreich um zu verstehen was schiefgelaufen ist.
380Sie können ihn ein- oder ausschalten indem die ``%pdb`` eingeben (standardmäßig ist er ausgeschaltet).
381Die Eingabeaufforderung ``ipdb>`` erscheint wenn eine Fehlermeldung geworfen wird und der Debugger eingeschaltet ist.
382Im Debugger können Sie den Status jeder lokalen Variable ausgeben oder im "Ausführungsstapel" hoch- und runterspringen.
383Zum Beispiel:
384
385.. skip
386
387::
388
389    sage: %pdb
390    Automatic pdb calling has been turned ON
391    sage: EllipticCurve([1,infinity])
392    ---------------------------------------------------------------------------
393    <type 'exceptions.TypeError'>             Traceback (most recent call last)
394    ...
395   
396    ipdb>
397
398For a list of commands in the debugger, type ``?`` at the ``ipdb>``
399prompt:
400
401::
402
403    ipdb> ?
404   
405    Documented commands (type help <topic>):
406    ========================================
407    EOF    break  commands   debug    h       l     pdef   quit    tbreak   
408    a      bt     condition  disable  help    list  pdoc   r       u     
409    alias  c      cont       down     ignore  n     pinfo  return  unalias
410    args   cl     continue   enable   j       next  pp     s       up
411    b      clear  d          exit     jump    p     q      step    w
412    whatis where
413   
414    Miscellaneous help topics:
415    ==========================
416    exec  pdb
417   
418    Undocumented commands:
419    ======================
420    retval  rv
421
422Drücken Sie Strg-D oder geben Sie ``quit`` ein um zu Sage zurückzukehren.
423
424.. _section-tabcompletion:
425
426Rückwärtssuche und Tab-Vervollständigung
427========================================
428
429Definieren Sie zuerst einen dreidimensionalen Vektorraum :math:`V=\QQ^3` wie folgt:
430
431::
432
433    sage: V = VectorSpace(QQ,3)
434    sage: V             
435    Vector space of dimension 3 over Rational Field
436
437Sie können auch die folgende verkürzte Schreibweise verwenden:
438
439::
440
441    sage: V = QQ^3
442
443Schreiben Sie den Anfang eines Befehls und drücken Sie dann ``Strg-p`` (oder
444drücken Sie einfach die Pfeil-nach-oben-Taste) um zur vorher eingegebenen Zeile zu gelangen, die ebenfalls
445so beginnt. Das funktioniert auch nach einem kompletten Sage-Neustart noch.
446Sie können den Verlauf auch mit ``Strg-r`` rückwärts durchsuchen.
447Diese Funktionalität wird vom ``readline`` Paket bereitgestellt, welches in nahezu jeder Linux-Distribution
448verfügbar ist.
449
450Es ist sehr einfach alle Unterfunktionen für :math:`V` mittels Tab-Vervollständigung
451aufzulisten, indem sie erst ``V.`` eingeben, und dann die ``[Tabulator Taste]`` drücken:
452
453.. skip
454
455::
456
457    sage: V.[tab key]
458    V._VectorSpace_generic__base_field
459    ...
460    V.ambient_space
461    V.base_field
462    V.base_ring
463    V.basis
464    V.coordinates
465    ...
466    V.zero_vector
467
468Wenn Sie die ersten paar Buchstaben einer Funktion tippen und dann die ``[Tabulator Taste]`` drücken,
469bekommen sie nur die Funktionen, die so beginnen angezeigt.
470
471.. skip
472
473::
474
475    sage: V.i[tab key]
476    V.is_ambient  V.is_dense    V.is_full     V.is_sparse
477
478Wenn sie wissen wollen, was eine bestimmte Funktion tut, z.B. die "coordinates"-Funktion, so geben Sie
479``V.coordinates?`` ein um die Hilfe und ``V.coordinates??`` um den Quelltext der Funktion zu sehen.
480
481
482
483Integriertes Hilfesystem
484========================
485
486Sage hat ein integriertes Hilfesystem. Hängen Sie an einen beliebigen Funktionsnamen ein ``?``
487um die Dokumentation dazu aufzurufen.
488
489.. skip
490
491::
492
493    sage: V = QQ^3
494    sage: V.coordinates?
495    Type:           instancemethod
496    Base Class:     <type 'instancemethod'>
497    String Form:    <bound method FreeModule_ambient_field.coordinates of Vector
498    space of dimension 3 over Rational Field>
499    Namespace:      Interactive
500    File:           /home/was/s/local/lib/python2.4/site-packages/sage/modules/f
501    ree_module.py
502    Definition:     V.coordinates(self, v)
503    Docstring:
504        Write v in terms of the basis for self.
505   
506        Returns a list c such that if B is the basis for self, then
507   
508                sum c_i B_i = v.
509   
510        If v is not in self, raises an ArithmeticError exception.
511   
512        EXAMPLES:
513            sage: M = FreeModule(IntegerRing(), 2); M0,M1=M.gens()
514            sage: W = M.submodule([M0 + M1, M0 - 2*M1])
515            sage: W.coordinates(2*M0-M1)
516            [2, -1]
517
518Wie Sie sehen, beinhaltet die Ausgabe den Typ des Objekts, den
519Dateinamen in welcher die Funktion definiert ist und eine Beschreibung der Funktionalität
520mit Beispielen, die Sie direkt in Ihre aktuelle Sitzung einfügen können.
521Fast alle dieser Beispiele werden regelmäßig automatisch getestet um sicherzustellen, dass sie
522genau wie beschrieben funktionieren.
523
524Eine andere Funktionalität, die sehr eng in Verbindung mit dem "open source"-Gedanken steht ist,
525dass Sie sich zu jeder Funktion den Quelltext anzeigen lassen können. Sei ``f`` eine Sage oder Python Funktion,
526dann können Sie mit ``f??`` den Quellcode, der ``f`` definiert anzeigen. Zum Beispiel:
527
528.. skip
529
530::
531
532    sage: V = QQ^3
533    sage: V.coordinates??
534    Type:           instancemethod
535    ...
536    Source:
537    def coordinates(self, v):
538            """
539            Write $v$ in terms of the basis for self.
540            ...
541            """
542            return self.coordinate_vector(v).list()
543
544Das zeigt uns, dass die ``coordinates`` Funktion nichts anderes tut, als ``coordinates_vector`` Funktion
545aufruft und das Ergebnis in eine Liste umwandelt.
546Aber was tut die ``coordinates`` Funktion?
547
548.. skip
549
550::
551
552    sage: V = QQ^3
553    sage: V.coordinate_vector??
554    ...
555    def coordinate_vector(self, v):
556            ...
557            return self.ambient_vector_space()(v)
558
559Die ``coordinate_vector`` Funktion steckt ihre Eingabe in den umgebenden Raum,
560was zur Folge hat, dass der Koeffizientenvektor von :math:`v` zur Basis des Vektorraums :math:`V` ausgerechnet wird.
561Der Raum :math:`V` schon der umgebende, nämlich grade :math:`\QQ^3`.
562Es gibt auch eine ``coordinate_vector`` Funktion für Unterräume, und sie funktioniert anders.
563Wir definieren einen Unterraum und schauen uns das an:
564
565.. skip
566
567::
568
569    sage: V = QQ^3; W = V.span_of_basis([V.0, V.1])
570    sage: W.coordinate_vector??
571    ...
572    def coordinate_vector(self, v):
573            """
574             ...
575            """
576            # First find the coordinates of v wrt echelon basis.
577            w = self.echelon_coordinate_vector(v)
578            # Next use transformation matrix from echelon basis to
579            # user basis.
580            T = self.echelon_to_user_matrix()
581            return T.linear_combination_of_rows(w)
582
583(Wenn Sie der Meinung sind, dass diese Implementation ineffizient ist, helfen Sie uns bitte
584unsere Lineare Algebra zu optimieren.)
585
586Sie können auch ``help(command_name)`` oder ``help(class)`` eingeben um eine manpage-artige Hilfe zu bekommen.
587
588
589.. skip
590
591::
592
593    sage: help(VectorSpace)
594    Help on class VectorSpace ...
595   
596    class VectorSpace(__builtin__.object)
597     |  Create a Vector Space.
598     |
599     |  To create an ambient space over a field with given dimension
600     |  using the calling syntax ...
601     :
602     :
603
604Wenn sie ``q`` drücken um das Hilfesystem zu verlassen, kommen Sie genau
605dahin zurück, wo Sie Ihre Sitzung verlassen haben. Die ``help`` Anzeige
606bleibt nicht in Ihrer Sitzung zurück im Gegensatz zu ``funktion?``.
607Es ist besonders hilfreich ``help(modul_name)`` zu nutzen. Zum Beispiel sind
608Vektorräume in ``sage.modules.free_module`` definiert. Geben Sie also
609``help(sage.modules.free_module)`` ein, um die Dokumentation des ganzen Moduls zu sehen.
610Wenn Sie sich Die Dokumentation mit ``help`` ansehen, können Sie mit ``/`` vorwärts
611und mit ``?`` rückwärts suchen.
612
613Speichern und Laden von individuellen Objekten
614==============================================
615
616Angenommen Sie berechnen eine Matrix oder schlimmer, einen komplizierten
617Modulsymbolraum, und Sie wollen ihn für später speichern. Was können Sie tun?
618Es gibt mehere Möglichkeiten für Computer Algebra Systeme solche individuellen
619Objekte zu speichern.
620
621
622#. **Spiel speichern:** Unterstützt nur das Speichern und Laden kompletter
623   Sitzungen (z.B. GAP, Magma).
624
625#. **Einheitliche Ein-/Ausgabe:** Bringen Sie jedes Objekt in eine Form, die
626         Sie wieder einlesen können in (GP/PARI).
627
628#. **Eval**: Machen Sie beliebigen Code auswertbar im Interpreter (z.B. Sigular, PARI).
629
630
631Da Sage Python nutzt, braucht es einen anderen Ansatz, nämlich dass
632jedes Objekt serialisiert werden kann. Das heißt es in eine Zeichenkette
633umzuwandeln, die man wieder einlesen kann. Das ist im Prinzip ähnlich zum
634Einheitlichen Ein-/Ausgabe Ansatz von PARI, abgesehen von der zu komplizierten
635Darstellung auf dem Bildschirm. Ausserdem ist das Laden und Speichern (meistens)
636vollautomatisch und benötigt nicht einmal speziellen Programmieraufwand; es ist
637einfach ein Merkmal, das von Grund auf in Python war.
638
639Fast alle Objekte x in Sage können in komprimierter Form gespeichert werden
640via ``save(x, Dateiname)`` (oder in vielen Fällen ``x.save(Dateiname)``).
641Um das Objekt wieder zu laden, nutzen Sie ``load(Dateiname)``.
642
643.. skip
644
645::
646
647    sage: A = MatrixSpace(QQ,3)(range(9))^2
648    sage: A
649    [ 15  18  21]
650    [ 42  54  66]
651    [ 69  90 111]
652    sage: save(A, 'A')
653
654Sie sollten Sage nun schließen und neu starten. Dann können Sie ``A`` wieder laden:
655
656.. skip
657
658::
659
660    sage: A = load('A')
661    sage: A
662    [ 15  18  21]
663    [ 42  54  66]
664    [ 69  90 111]
665
666Sie können das selbe mit komplizierteren Objekten wie etwa elliptischen
667Kurven machen. Alle Daten über das Objekt sind zwischengespeichert und werden
668mit dem Objekt gespeichert. Zum Beispiel:
669
670.. skip
671
672::
673
674    sage: E = EllipticCurve('11a')
675    sage: v = E.anlist(100000)              # dauert etwas länger
676    sage: save(E, 'E')
677    sage: quit
678
679Die gespeicherte Version von ``E`` braucht 153 Kilobyte, da die ersten
680100000 :math:`a_n` mitgespeichert werden.
681
682.. skip
683
684::
685
686    ~/tmp$ ls -l E.sobj
687    -rw-r--r--  1 was was 153500 2006-01-28 19:23 E.sobj
688    ~/tmp$ sage [...]
689    sage: E = load('E')
690    sage: v = E.anlist(100000)              # sofort!
691
692(In Python wird das Laden und Speichern mittels des ``cPickle``
693Moduls umgesetzt. Genauer: Ein Sage Objekt ``x`` kann mit
694``cPickle.dumps(x, 2)`` gespeichert werden.  Beachten Sie die ``2``!)
695
696Sage kann allerdings keine individuellen Objekte anderer Computer Algebra Systeme
697wie GAP, Singular, Maxima, usw. laden und speichern. Sie sind mit "invalid" gekennzeichnet nach dem Laden.
698In GAP werden viele Objekte in einer Form dargestellt die man wiederherstellen kann,
699viele andere allerdings nicht. Deshalb ist das wiederherstellen aus ihren Druckdarstellungen
700nicht erlaubt.
701
702.. skip
703
704::
705
706    sage: a = gap(2)
707    sage: a.save('a')
708    sage: load('a')
709    Traceback (most recent call last):
710    ...
711    ValueError: The session in which this object was defined is no longer
712    running.
713
714GP/PARI Objekte können hingegen gespeichert und geladen werden, da
715ihre Druckdarstellung ausreicht um sie wiederherzustellen.
716
717.. skip
718
719::
720
721    sage: a = gp(2)     
722    sage: a.save('a')
723    sage: load('a')
724    2
725
726Gespeicherte Objekte können auch auf Computern mit anderen Architekturen
727oder Betriebssystemen wieder geladen werden. Zum Beispiel können Sie
728eine riesige Matrix auf einem 32 Bit Mac OS X speichern und später auf
729einem 64 Bit Linux System laden, dort die Stufenform herstellen und dann
730wieder zurückladen. Ausserdem können Sie in den meisten Fällen auch Objekte
731laden, die mit anderen Sage Versionen gespeichert wurden, solange der Quelltext
732des Objekts nicht zu verschieden ist. Alle Attribute eines Objekts werden zusammen
733mit seiner Klasse (aber nicht dem Quellcode) gespeichert. Sollte diese Klasse
734in einer neueren Sage Version nicht mehr existieren, kann das Objekt in dieser
735neueren Sage Version nicht mehr geladen werden. Aber Sie könnten es in der alten
736Sage Version laden, die Objekt Diktionäre mit ``x.__dict__`` laden und das Objekt
737zusammen mit diesem in der neuen Sage Version laden.
738
739Als Text speichern
740------------------
741
742Sie können die ASCII Text Darstellung eines Objekts in eine Klartextdatei
743schreiben, indem Sie die Datei einfach mit Schreibzugriff öffnen und die
744Textdarstellung des Objekts hineinkopieren. (Sie können auch viele andere
745Objekte auf diese Art speichern.) Wenn Sie alle Objekte hineinkopiert haben,
746schließen Sie die Datei einfach.
747
748.. skip
749
750::
751
752    sage: R.<x,y> = PolynomialRing(QQ,2)
753    sage: f = (x+y)^7
754    sage: o = open('file.txt','w')
755    sage: o.write(str(f))
756    sage: o.close()
757
758.. _section-save:
759
760Speichern und Laden kompletter Sitzungen
761========================================
762
763Sage hat eine sehr flexible Unterstützung für das Speichern und Laden
764kompletter Sitzungen.
765
766Der Befehl ``save_session(sitzungsname)`` speichert alle Variablen,
767die sie während dieser Sitzung definiert haben als einem Wörterbuch
768``sessionname``. (Im seltenen Fall, dass eine Variable nicht gespeichert
769werden kann, fehlt sie anschließend einfach im Wörterbuch.)
770Die erzeugte Datei ist eine ``.sobj``-Datei und kann genau wie jedes andere
771Objekt geladen werden. Wenn Sie Objekte aus einer Sitzung laden, werden Sie
772diese in einem Wörterbuch finden. Dessen Schlüssel sind die Variablen und
773dessen Werte sind die Objekte.
774
775Sie können den ``load_session(sitzungsname)`` Befehl nutzen um die Variablen
776aus ``sitzungsname`` in die aktuelle Sitzung zu laden. Beachten Sie, dass
777dieses Vorgehen nicht die Variablen der aktuellen Sitzung löscht, vielmehr
778werden beide Sitzungen vereinigt.
779
780Starten wir also zunächst Sage und definieren einige Variablen.
781
782.. skip
783
784::
785
786    sage: E = EllipticCurve('11a')
787    sage: M = ModularSymbols(37)
788    sage: a = 389
789    sage: t = M.T(2003).matrix(); t.charpoly().factor()
790     _4 = (x - 2004) * (x - 12)^2 * (x + 54)^2
791
792Als nächstes speichern wir unsere Sitzung, was jede der Variablen
793in eine Datei speichert. Dann sehen wir uns die Datei, die etwa
7943 Kilobyte groß ist an.
795
796.. skip
797
798::
799
800    sage: save_session('misc')
801    Saving a
802    Saving M
803    Saving t
804    Saving E
805    sage: quit
806    was@form:~/tmp$ ls -l misc.sobj
807    -rw-r--r--  1 was was 2979 2006-01-28 19:47 misc.sobj
808
809Zuletzt starten wir Sage neu, definieren uns eine extra Variable, und laden
810unsere gespeicherte Sitzung.
811
812.. skip
813
814::
815
816    sage: b = 19
817    sage: load_session('misc')
818    Loading a
819    Loading M
820    Loading E
821    Loading t
822
823Jede der gepeicherten Variablen ist wieder verfügbar und die
824Variable ``b`` wurde nicht überschrieben.
825
826.. skip
827
828::
829
830    sage: M
831    Full Modular Symbols space for Gamma_0(37) of weight 2 with sign 0
832    and dimension 5 over Rational Field
833    sage: E
834    Elliptic Curve defined by y^2 + y = x^3 - x^2 - 10*x - 20 over Rational
835    Field
836    sage: b
837    19
838    sage: a
839    389
840
841
842
843.. _section-notebook:
844
845Die Notebook Umgebung
846=====================
847
848Das Sage Browser Notebook wird mit
849
850.. skip
851
852::
853
854    sage: notebook()
855
856in der Sage Kommandozeile gestartet. Der Befehl startet das Sage Notebook
857und startet Ihren Standardbrowser um es anzuzeigen. Die Serverstatusdateien liegen unter
858``$HOME/.sage/sage\_notebook``.
859
860Die andere Optionen enthalten z.B.
861
862.. skip
863
864::
865
866    sage: notebook("Verzeichnis")
867
868was einen neuen Notebook Server mit den Dateien aus dem angegebenen Verzeichnis
869startet (anstelle des Standardverzeichnises ``$HOME/.sage/sage_notebook``).
870Das kann hilfreich sein, wenn Sie einige Worksheets für ein Projekt oder
871verschiedene gleichzeitig laufende Notebook Server von einander trennen wollen.
872
873Wenn Sie das Notebook starten, werden zuerst die folgenden Dateien erzeugt
874in ``$HOME/.sage/sage_notebook``:
875
876::
877
878    nb.sobj       (Die notebook SAGE Objekt Datei)
879    objects/      (Ein Verzeichnis, das SAGE Objekte enthält)
880    worksheets/   (Ein Verzeichnis das SAGE worksheets enthält).
881
882Nach dem Anlegen dieser Dateien, startet das notebook als Webserver.
883
884Ein "Notebook" ist eine Sammlung an Benutzerkonten, vom dem jeder verschiedene
885worksheets enthalten kann. Wenn Sie ein neues worksheet erstellen, werden alle
886zugehörigen Daten unter ``worksheets/username/number`` gespeichert.
887In jedem solchen Verzeichnis ist eine Klartextdatei namens ``worksheet.txt`` - sollte
888mit Ihren worksheets oder Sage irgendetwas Unvorhergesehenes passieren, enthält diese
889Datei alles was Sie benötigen um Ihre worksheets wiederherzustellen.
890
891Innerhalb von Sage können Sie mit ``notebook?`` mehr Informationen zum Start eines
892Notebook-Servers erhalten.
893
894Das folgende Diagramm veranschaulicht die Architektur eines Sage Notebooks.
895
896::
897
898    ----------------------
899    |                    |
900    |                    |
901    |   firefox/safari   |
902    |                    |
903    |     javascript     |
904    |      programm      |
905    |                    |
906    |                    |
907    ----------------------
908          |      ^
909          | AJAX |
910          V      |
911    ----------------------
912    |                    |
913    |       sage         |                SAGE Prozess 1
914    |       web          | ------------>  SAGE Prozess 2    (Python Prozesse)
915    |      server        |   pexpect      SAGE Prozess 3
916    |                    |                    .
917    |                    |                    .
918    ----------------------                    .
919
920Um Hilfe zu einem Sage Befehl ``befehl`` im Notebook-Browser zu bekommen
921geben Sie ``befehl?`` ein und drücken Sie ``<esc>`` (nicht ``<shift-enter>``).
922
923Für Informationen zu Tastenbefehlen des Notebook-Browsers, klicken Sie auf
924den ``Help`` Link.