Ticket #9725: trac_9725.patch
File trac_9725.patch, 208.1 KB (added by , 9 years ago) |
---|
-
doc/common/build_options.py
# HG changeset patch # User Philipp Schneider <Philipp.Schneider@mathe.stud.uni-erlangen.de> # Date 1305137992 -7200 # Node ID aad4d26889c159d329efaa54b070fa91059e0710 # Parent 361a4ad7d52c69b64ae2e658ffd0820af0d87e93 trac 9725: add German translation of the tutorial diff -r 361a4ad7d52c -r aad4d26889c1 doc/common/build_options.py
a b 4 4 5 5 import os 6 6 SAGE_DOC = os.environ['SAGE_DOC'] 7 LANGUAGES = [' en', 'fr']7 LANGUAGES = ['de', 'en', 'fr'] 8 8 SPHINXOPTS = "" 9 9 PAPER = "" 10 10 OMIT = ["introspect"] # docs/dirs to omit when listing and building 'all' -
new file doc/de/tutorial/afterword.rst
diff -r 361a4ad7d52c -r aad4d26889c1 doc/de/tutorial/afterword.rst
- + 1 ******** 2 Nachwort 3 ******** 4 5 Warum Python? 6 ============= 7 8 Vorteile von Python 9 ------------------- 10 11 Sage ist hautsächlich in der Programmiersprache Python implementiert (siehe [Py]_). 12 Jedoch ist Code, bei dem Geschwindigkeit ausschlaggebend ist, in einer 13 kompilierten Sprache implementiert. Python hat folgende Vorteile: 14 15 16 - **Speichern von Objekten** wird in Python gut unterstützt. Für das 17 Speichern von (nahezu) beliebigen Objekten auf Festplatten oder in 18 Datenbanken sind in Python weitgehende Hilfsmittel vorhanden. 19 20 - Exzellente Unterstütztung für die **Dokumentation** von Funktionen 21 und Paketen im Quellcode, einschließlich der automatischen 22 Erstellung der Dokumentation und automatisches Testen aller 23 Beispiele. Die Beispiele werden regelmäßig automatisch getestet und 24 es wird garantiert, dass sie wie angegeben funktionieren. 25 26 - **Speicherverwaltung**: Python besitzt nun einen gut durchdachten 27 und robusten Speicherverwalter und einen Speicherbereiniger, der 28 zirkuläre Referenzen korrekt behandelt und lokale Variablen in 29 Dateien berücksichtigt. 30 31 - Python besitzt mittlerweile **viele Pakete**, die für Sagenutzer 32 sehr reizvoll sein könnten: numerische Analysis und lineare 33 Algebra, 2D und 3D Visualisierungen, Vernetzungen (für verteilte 34 Berechnungen und Server, z.B. mithilfe von twisted), 35 Datenbankunterstützung, usw. 36 37 - **Portabilität:** Python kann auf den meisten Systemen 38 unkompliziert, innerhalb von Minuten aus dem Quellcode kompiliert 39 werden. 40 41 - **Fehlerbehandlung:** Python besitzt ein ausgeklügeltes und wohl 42 durchdachtes System für die Behandlung von Ausnahmebedingunen, 43 mit dem Programme sinnvoll weiterarbeiten können, sogar wenn bei 44 ihrem Aufruf Fehler auftreten. 45 46 - **Debugger:** Python beinhaltet einen Debugger. Folglich kann der 47 Benutzer, falls der Code aus irgendeinem Grund fehlschlägt, auf 48 eine ausgiebige Stack-Ablaufverfolgung zugreifen, den Zustand 49 aller relevanter Variablen betrachten, und sich auf dem Stack nach 50 oben oder unten bewegen. 51 52 - **Profiler:** Es gibt einen Python-Profiler, welcher Code 53 ausführt und einen Bericht erstellt, in dem detailliert 54 aufgestellt wurde wie oft und wie lange jede Funkion aufgerufen 55 wurde. 56 57 - **Eine Sprache:** Anstatt eine **neue Sprache** für mathematische 58 Software zu schreiben, wie es für Magma, Maple, Mathematica, Matlab, 59 GP/PARI, GAP, Macaulay 2, Simath, usw. gemacht wurde, benutzen wir 60 die Programmiersprache Python, eine beliebte Programmiersprache, die 61 von hunderten begabten Softwareingenieuren rege weiterentwickelt und 62 optimiert wird. Python ist eine bedeutete Open-Source 63 Erfolgsgeschichte mit einem ausgereiften Entwicklungsprozess. (siehe [PyDev]_). 64 65 66 .. _section-mathannoy: 67 68 Der Pre-Parser: Unterschiede zwischen Sage und Python 69 ----------------------------------------------------- 70 71 Aus mathematischer Sicht kann Python in verschiedener Weise verwirrend 72 sein, also verhält sich Sage an manchen Stellen anders als Python. 73 74 - **Notation für Exponentiation:** ``**`` versus ``^``. In Python 75 bedeutet ``^`` "xor", und nicht Exponentiation, also gilt in 76 Python: 77 78 :: 79 80 >>> 2^8 81 10 82 >>> 3^2 83 1 84 >>> 3**2 85 9 86 87 Diese Benutzung von ``^`` kann merkwürdig erscheinen und sie ist 88 ineffizient für mathematische Anwender, da die 89 "Exklusives-Oder"-Funktion nur selten verwendet wird. 90 Um dies zu beheben parst Sage alle Kommandozeilen bevor es diese zu 91 Python weitergibt und ersetzt jedes Auftreten ``^``, das in keinem 92 String vorkommt mit ``**``: 93 94 :: 95 96 sage: 2^8 97 256 98 sage: 3^2 99 9 100 sage: "3^2" 101 '3^2' 102 103 - **Integerdivision:** Der Pythonaudruck ``2/3`` verhält sich nicht 104 so, wie es Mathematiker erwarten würden. In Python wird, falls ``m`` und 105 ``n`` Integer sind, auch ``m/n`` als Integer behandelt, es ist 106 nämlich der Quotient von ``m`` geteilt durch ``n``. Daher ist 107 ``2/3=0``. Es wurde in der Pythoncommunity darüber geredet, ob in 108 Python die Division geändert werden sollte, so dass ``2/3`` die 109 Gleitkommazahl ``0.6666...`` zurückgibt und ``2//3`` das Ergebnis 110 ``0`` hat. 111 112 Wir berücksichtigen dies im Sage-Interpreter indem wir 113 Integer-Literale mit ``Integer( )`` versehen und die Division als 114 Konstruktor für rationale Zahlen behandeln. Zum Beispiel: 115 116 :: 117 118 sage: 2/3 119 2/3 120 sage: (2/3).parent() 121 Rational Field 122 sage: 2//3 123 0 124 sage: int(2)/int(3) 125 0 126 127 - **Große ganze Zahlen:** Python besitzt von Hause aus Unterstützung 128 für beliebig große ganze Zahlen zusätzlich zu C-ints. Diese sind 129 bedeutend langsamer als die von GMP zur Verfügung gestellten und sie 130 haben die Eigenschaft, dass die mit einem ``L`` am Ende ausgegeben 131 werden um sie von ints unterscheiden zu können (und dies wird sich 132 in naher Zeit nicht ändern). Sage implementiert beliebig große 133 Integers mit Hilfe der GMP C-Bibliothek, und diese werden ohne 134 ``L`` ausgegeben. 135 136 137 Anstatt den Python-Interpreter zu verändern (wie es mache Leute für 138 interne Projekte getan haben), benutzen wir die Sprache Python 139 unverändert und haben einen Prä-Parser geschrieben, so dass sich 140 die Kommandozeilen-IPython-Version so verhält, wie es Mathematiker 141 erwarten würden. Dies bedeutet, dass bereits existierender Python-Code 142 in Sage so verwendet werden kann wie er ist. Man muss jedoch immernoch 143 die standardmäßigen Python-Regeln beachten, wenn man Pakete schreibt, 144 die in Sage importiert werden können. 145 146 (Um eine Python-Bibliothek zu installieren, die Sie zum Beispiel im 147 Internet gefunden haben, folgen Sie den Anweisungen, aber verwenden 148 sie ``sage -python`` anstelle von ``python``. Oft bedeutet dies, dass 149 ``sage -python setup.py install`` eingegeben werden muss.) 150 151 152 Ich möchte einen Beitrag zu Sage leisten. Wie kann ich dies tun? 153 ================================================================ 154 155 Falls Sie für Sage einen Beitrag leisten möchten, wird Ihre Hilfe hoch 156 geschätzt! Sie kann von wesentlichen Code-Beiträge bis zum Hinzufügen 157 zur Sage-Dokumention oder zum Berichten von Fehlern reichen. 158 159 160 Schauen Sie sich die Sage-Webseite an um Informationen für Entwickler 161 zu erhalten; neben anderen Dingen können Sie eine lange Liste nach 162 Priorität und Kategorie geordneter, zu Sage gehörender Projekte finden. 163 Auch der `Sage Developer's Guide <http://www.sagemath.org/doc/developer/>`_ 164 beinhaltet hilfreiche Informationen, und Sie können der ``sage-devel`` 165 Google-Group beitreten. 166 167 168 Wie zitiere ich Sage? 169 ===================== 170 171 Falls Sie ein Paper schreiben, das Sage verwendet, zitieren Sie bitte 172 die Berechnungen die Sie mithilfe von Sage durchgeführt haben, indem 173 Sie 174 175 :: 176 177 [Sage] William A. Stein et al., Sage Mathematics Software (Version 4.3). 178 The Sage Development Team, 2009, http://www.sagemath.org. 179 180 in Ihrem Literaturverzeichnis hinzufügen. (Ersetzen Sie hierbei 4.3 mit der von 181 Ihnen benutzten Version von Sage.) Versuchen Sie bitte weiterhin 182 festzustellen welche Komponenten von Sage in Ihrer Berechnung 183 verwendet wurden, z.B. PARI?, GAP?, Singular? Maxima? und zitieren Sie 184 diese Systeme ebenso. Falls Sie nicht sicher sind welche Software Ihre 185 Berechnung verwendet, können Sie dies gerne in der ``sage-devel`` 186 Google-Gruppe fragen. Lesen Sie :ref:`section-univariate` um weitere 187 Information darüber zu erhalten. 188 189 ------------ 190 191 Falls Sie gerade das Tutorial vollständig durchgelesen haben, und noch 192 wissen wie lange Sie hierfür gebraucht haben, lassen Sie und dies bitte 193 in der ``sage-devel`` Google-Gruppe wissen. 194 195 Viel Spass mit Sage! -
new file doc/de/tutorial/appendix.rst
diff -r 361a4ad7d52c -r aad4d26889c1 doc/de/tutorial/appendix.rst
- + 1 ****** 2 Anhang 3 ****** 4 5 .. _section-precedence: 6 7 Binäre arithmetische Operatorrangfolge 8 ======================================== 9 10 Was ist ``3^2*4 + 2%5``? Der Wert (38) wird durch diese 11 "Operatorrangfolge-Tabelle" festgelegt. Die Tabelle unterhalb basiert 12 auf der Tabelle in Abschnitt § 5.15 des *Python Language Reference 13 Manual* von G. Rossum und F. Drake. Die Operatoren sind hier in 14 aufsteigender Ordnung der Bindungstärke aufgelistet. 15 16 17 ========================== ================= 18 Operatoren Beschreibung 19 ========================== ================= 20 or Boolesches oder 21 and Boolesches und 22 not Boolesches nicht 23 in, not in Zugehörigkeit 24 is, is not Identitätstest 25 >, <=, >, >=, ==, !=, <> Vergleich 26 +, - Addition, Subtraktion 27 \*, /, % Multiplikation, Division, Restbildung 28 \*\*, ^ Exponentiation 29 ========================== ================= 30 31 Um also ``3^2*4 + 2%5`` zu berechnen klammert Sage den Ausdruck in 32 folgender Weise: ``((3^2)*4) + (2%5)``. Es wird daher zuerst ``3^2``, 33 was ``9`` ist, dann wird sowohl ``(3^2)*4`` als auch ``2%5`` berechnet, 34 und schließlich werden diese beiden Werte addiert. -
new file doc/de/tutorial/bibliography.rst
diff -r 361a4ad7d52c -r aad4d26889c1 doc/de/tutorial/bibliography.rst
- + 1 ******************** 2 Literaturverzeichnis 3 ******************** 4 5 .. [Cyt] Cython, http://www.cython.org/. 6 7 .. [Dive] Dive into Python, online frei verfügbar unter 8 http://diveintopython.org/. 9 10 .. [GAP] The GAP Group, GAP - Groups, Algorithms, and 11 Programming, Version 4.4; 2005, http://www.gap-system.org/. 12 13 .. [GAPkg] GAP Packages, 14 http://www.gap-system.org/Packages/packages.html/. 15 16 .. [GP] PARI/GP, http://pari.math.u-bordeaux.fr/. 17 18 .. [Ip] The IPython shell, http://ipython.scipy.org/. 19 20 .. [Jmol] Jmol: an open-source Java viewer for chemical 21 structures in 3D, http://www.jmol.org/. 22 23 .. [Mag] Magma, http://magma.maths.usyd.edu.au/magma/. 24 25 .. [Max] Maxima, http://maxima.sf.net/. 26 27 .. [NagleEtAl2004] Nagle, Saff, and Snider. 28 *Fundamentals of Differential Equations*. 6th edition, Addison-Wesley, 29 2004. 30 31 .. [Py] The Python language, http://www.python.org/ 32 Reference Manual, http://docs.python.org/ref/ref.html/. 33 34 .. [PyDev] Guido, Some Guys, and a Mailing List: How Python is 35 Developed, 36 http://www.python.org/dev/dev_intro.html/. 37 38 .. [Pyr] Pyrex, http://www.cosc.canterbury.ac.nz/~greg/python/Pyrex/. 39 40 .. [PyT] The Python Tutorial, http://docs.python.org/tutorial/. 41 42 .. [SA] Sage web site, http://www.sagemath.org/. 43 44 .. [Si] W. Decker, G.-M. Greuel, G. Pfister, and 45 H. Schönemann. Singular 3.3.1. A Computer Algebra System for 46 Polynomial Computations. University of Kaiserslautern (2010), 47 http://www.singular.uni-kl.de/. 48 49 .. [SJ] William Stein, David Joyner, Sage: System for Algebra and 50 Geometry Experimentation, Comm. Computer Algebra {39}(2005)61-64. 51 -
new file doc/de/tutorial/conf.py
diff -r 361a4ad7d52c -r aad4d26889c1 doc/de/tutorial/conf.py
- + 1 # -*- coding: utf-8 -*- 2 # 3 # Sage documentation build configuration file, based on that created by 4 # sphinx-quickstart on Thu Aug 21 20:15:55 2008. 5 # 6 # This file is execfile()d with the current directory set to its containing dir. 7 # 8 # The contents of this file are pickled, so don't put values in the namespace 9 # that aren't pickleable (module imports are okay, they're removed automatically). 10 # 11 # All configuration values have a default; values that are commented out 12 # serve to show the default. 13 14 import sys, os 15 sys.path.append(os.environ['SAGE_DOC']) 16 from common.conf import * 17 18 # General information about the project. 19 project = u"Sage Tutorial" 20 name = u'SageTutorial-de' 21 language = "de" 22 23 # The name for this set of Sphinx documents. If None, it defaults to 24 # "<project> v<release> documentation". 25 html_title = project + " v"+release 26 27 # Output file base name for HTML help builder. 28 htmlhelp_basename = name 29 30 # Grouping the document tree into LaTeX files. List of tuples 31 # (source start file, target name, title, author, document class [howto/manual]). 32 latex_documents = [ 33 ('index', name+'.tex', project, 34 u'The Sage Group', 'manual'), 35 ] 36 -
new file doc/de/tutorial/index.rst
diff -r 361a4ad7d52c -r aad4d26889c1 doc/de/tutorial/index.rst
- + 1 .. Sage documentation master file, created by sphinx-quickstart on Thu Aug 21 20:15:55 2008. 2 You can adapt this file completely to your liking, but it should at least 3 contain the root `toctree` directive. 4 5 Willkommen beim Sage Tutorial! 6 ============================== 7 8 Sage ist eine freie, Open-Source-Software, die Forschung und 9 Lehre in Algebra, Geometrie, Zahlentheorie, Kryptographie, numerischen 10 Berechnungen und verwandten Gebieten unterstützt. Sowohl das 11 Entwicklungsmodell von Sage als auch die Technologie in Sage zeichnen 12 sich durch eine extrem starke Betonung von Offenheit, Gemeinschaft, 13 Kooperation und Zusammenarbeit aus. Wir bauen das Auto und erfinden 14 nicht das Rad neu. Das Ziel von Sage ist es, eine aktiv gepflegte, 15 freie Open-Source-Alternative zu Magma, Maple, Mathematica und Matlab 16 zu entwickeln. 17 18 Dieses Tutorial ist die beste Möglichkeit mit Sage in wenigen Stunden 19 vertraut zu werden. Sie können es im HTML- oder PDF-Format 20 lesen oder im Sage-Notebook. Dazu klicken Sie zuerst auf ``Help`` und 21 ``Tutorial``, um innerhalb von Sage interaktiv mit dem 22 Tutorial zu arbeiten. 23 24 Diese Arbeit ist lizenziert unter einer `Creative Commons Attribution-Share Alike 25 3.0 Lizenz`__. 26 27 __ http://creativecommons.org/licenses/by-sa/3.0/ 28 29 .. toctree:: 30 :maxdepth: 2 31 32 introduction 33 tour 34 interactive_shell 35 interfaces 36 latex 37 programming 38 sagetex 39 afterword 40 appendix 41 bibliography 42 43 Indizes und Tabellen 44 ==================== 45 46 * :ref:`genindex` 47 * :ref:`modindex` 48 * :ref:`search` -
new file doc/de/tutorial/interactive_shell.rst
diff -r 361a4ad7d52c -r aad4d26889c1 doc/de/tutorial/interactive_shell.rst
- + 1 .. _chapter-interactive_shell: 2 3 ***************************** 4 Die interaktive Kommandozeile 5 ***************************** 6 In den meisten Teilen dieses Tutorials gehen wir davon aus, dass Sie 7 Sage mit dem ``sage``-Befehl starten. Dieser startet eine angepasste 8 Version der IPython Kommandozeile und lädt Funktionen und Klassen, 9 sodass sie in der Kommandozeile genutzt werden können. Weitere 10 Anpassungen können Sie in der Datei ``$SAGE_ROOT/ipythonrc`` 11 vornehmen. Nach dem Start von Sage sehen 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 25 Um 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 35 Unter "wall time" finden Sie die vergangene Echtzeit (der Uhr an Ihrer 36 Wand). Diese ist nötig, da die CPU Zeit Unterprozesse wie GAP oder 37 Singular nicht berücksichtigt. 38 39 (Vermeiden Sie es den Sage Prozess mit ``kill -9`` in der Konsole zu 40 beenden, da so möglicherweise Unterprozesse wie z.B. Maple-Prozesse 41 nicht beendet oder temporäre Dateien in ``$HOME/.sage/tmp`` nicht 42 gelöscht würden.) 43 44 45 Ihre Sage Sitzung 46 ================= 47 48 Unter einer Sitzung verstehen wir die Ein- und Ausgaben von Sage vom 49 Starten bis zum Beenden. Sage speichert alle Eingaben mittels IPython. Wenn 50 Sie die interaktive Kommandozeile nutzen (im Gegensatz zur 51 Browser-Oberfläche "Notebook"), so können Sie jederzeit mittels 52 ``%hist`` eine Liste aller bisher getätigten Eingaben sehen. Sie 53 können auch ``?`` eingeben, um mehr über IPython zu 54 erfahren. Z.B. "IPython unterstützt Zeilennummerierung ... sowie Ein- 55 und Ausgabezwischenspeicherung. Alle Eingaben werden gespeichert und 56 können in Variablen abgerufen werden (neben der normalen 57 Pfeiltasten-Navigation). Die folgenden globalen Variablen existieren 58 immer (also bitte überschreiben Sie sie nicht!)": 59 60 :: 61 62 _: letzte Eingabe (interaktive Kommandozeile und Browser-Oberfläche) 63 __: vorletzte Eingabe (nur in der Kommandozeile) 64 _oh: Liste aller Eingaben (nur in der Kommandozeile) 65 66 Hier ein Beispiel: 67 68 .. skip 69 70 :: 71 72 sage: factor(100) 73 _1 = 2^2 * 5^2 74 sage: kronecker_symbol(3,5) 75 _2 = -1 76 sage: %hist # funktioniert nur in der Kommandozeile, nicht im Browser. 77 1: factor(100) 78 2: kronecker_symbol(3,5) 79 3: %hist 80 sage: _oh 81 _4 = {1: 2^2 * 5^2, 2: -1} 82 sage: _i1 83 _5 = 'factor(ZZ(100))\n' 84 sage: eval(_i1) 85 _6 = 2^2 * 5^2 86 sage: %hist 87 1: factor(100) 88 2: kronecker_symbol(3,5) 89 3: %hist 90 4: _oh 91 5: _i1 92 6: eval(_i1) 93 7: %hist 94 95 Wir lassen die Zeilennummerierung im restlichen Tutorial sowie in der 96 weiteren Sage-Dokumentation weg. Sie können auch eine Liste von 97 Eingaben einer Sitzung in einem Makro für diese Sitzung speichern. 98 99 .. skip 100 101 :: 102 103 sage: E = EllipticCurve([1,2,3,4,5]) 104 sage: M = ModularSymbols(37) 105 sage: %hist 106 1: E = EllipticCurve([1,2,3,4,5]) 107 2: M = ModularSymbols(37) 108 3: %hist 109 sage: %macro em 1-2 110 Macro `em` created. To execute, type its name (without quotes). 111 112 113 .. skip 114 115 :: 116 117 sage: E 118 Elliptic Curve defined by y^2 + x*y + 3*y = x^3 + 2*x^2 + 4*x + 5 over 119 Rational Field 120 sage: E = 5 121 sage: M = None 122 sage: em 123 Executing Macro... 124 sage: E 125 Elliptic Curve defined by y^2 + x*y + 3*y = x^3 + 2*x^2 + 4*x + 5 over 126 Rational Field 127 128 Während Sie die interaktive Kommandozeile nutzen, können Sie jeden 129 UNIX-Kommandozeilenbefehl in Sage ausführen, indem Sie ihm ein 130 Ausrufezeichen ``!`` voranstellen. Zum Beispiel gibt 131 132 .. skip 133 134 :: 135 136 sage: !ls 137 auto example.sage glossary.tex t tmp tut.log tut.tex 138 139 den Inhalt des aktuellen Verzeichnisses aus. 140 141 In der ``PATH``-Variablen steht das Sage "bin" Verzeichnis vorne. Wenn 142 Sie also ``gp``, ``gap``, ``singular``, ``maxima``, usw. eingeben, 143 starten Sie die in Sage enthaltenden Versionen. 144 145 .. skip 146 147 :: 148 149 sage: !gp 150 Reading GPRC: /etc/gprc ...Done. 151 152 GP/PARI CALCULATOR Version 2.2.11 (alpha) 153 i686 running linux (ix86/GMP-4.1.4 kernel) 32-bit version 154 ... 155 sage: !singular 156 SINGULAR / Development 157 A Computer Algebra System for Polynomial Computations / version 3-1-0 158 0< 159 by: G.-M. Greuel, G. Pfister, H. Schoenemann \ Mar 2009 160 FB Mathematik der Universitaet, D-67653 Kaiserslautern \ 161 162 Ein- und Ausgaben loggen 163 ======================== 164 165 Die Sage Sitzung loggen bzw. speichern ist nicht das Gleiche (siehe 166 :ref:`section-save`). Um Eingaben (und optional auch Ausgaben) zu 167 loggen nutzen Sie den Befehl ``logstart``. Geben Sie ``logstart?`` ein 168 um weitere Informationen zu erhalten. Sie können diesen Befehl nutzen 169 um alle Eingaben und Ausgaben zu loggen, und diese sogar wiederholen 170 in einer zukünftigen Sitzung (indem Sie einfach die Log-Datei laden). 171 172 .. skip 173 174 :: 175 176 was@form:~$ sage 177 ---------------------------------------------------------------------- 178 | SAGE Version 4.5.2, Release Date: 2010-08-05 | 179 | Type notebook() for the GUI, and license() for information. | 180 ---------------------------------------------------------------------- 181 182 sage: logstart setup 183 Activating auto-logging. Current session state plus future input saved. 184 Filename : setup 185 Mode : backup 186 Output logging : False 187 Timestamping : False 188 State : active 189 sage: E = EllipticCurve([1,2,3,4,5]).minimal_model() 190 sage: F = QQ^3 191 sage: x,y = QQ['x,y'].gens() 192 sage: G = E.gens() 193 sage: 194 Exiting SAGE (CPU time 0m0.61s, Wall time 0m50.39s). 195 was@form:~$ sage 196 ---------------------------------------------------------------------- 197 | SAGE Version 4.5.2, Release Date: 2010-08-05 | 198 | Type notebook() for the GUI, and license() for information. | 199 ---------------------------------------------------------------------- 200 201 sage: load "setup" 202 Loading log file <setup> one line at a time... 203 Finished replaying log file <setup> 204 sage: E 205 Elliptic Curve defined by y^2 + x*y = x^3 - x^2 + 4*x + 3 over Rational 206 Field 207 sage: x*y 208 x*y 209 sage: G 210 [(2 : 3 : 1)] 211 212 Wenn Sie Sage in der Linux KDE Konsole ``konsole`` verwenden, können 213 Sie Ihre Sitzung wie folgt speichern: Nachdem Sie Sage in ``konsole`` 214 gestartet haben, wählen Sie "Einstellungen", dann "Verlauf...", dann 215 "auf unbegrenzt" setzen. Wenn Sie soweit sind Ihre Sitzung zu 216 speichern, wählen Sie "Bearbeiten" und dann "Verlauf speichern 217 unter..." und geben einen Namen ein, um den Text ihrer Sitzung 218 auf dem Computer zu speichern. Nach dem Speichern der Datei können Sie 219 jene in einem Editor wie GNU Emacs öffnen und ausdrucken. 220 221 222 Einfügen ignoriert Eingabeaufforderungen 223 ======================================== 224 225 Stellen Sie sich vor, Sie lesen eine Sitzung von Sage oder Python 226 Berechnungen und wollen sie in Sage kopieren, aber überall sind noch 227 die störenden ``>>>`` oder ``sage:`` 228 Eingabeaufforderungen. Tatsächlich können Sie einfach die gewünschte 229 Stelle mit Eingabeaufforderungen in Sage einfügen. Der Sage Parser 230 wird standardmäßig die führenden ``>>>`` oder ``sage:`` 231 Eingabeaufforderungen entfernen bevor er es an Python weitergibt. Zum 232 Beispiel: 233 234 .. skip 235 236 :: 237 238 sage: 2^10 239 1024 240 sage: sage: sage: 2^10 241 1024 242 sage: >>> 2^10 243 1024 244 245 Befehle zur Zeitmessung 246 ======================= 247 248 Wenn Sie den ``%time`` Befehl vor eine Eingabe schreiben wird die 249 Zeit, die der Aufruf benötigt, ausgegeben nachdem er gelaufen ist. 250 Zum Beispiel können wir die Laufzeit einer bestimmten Potenzierung auf 251 verschiedene Arten vergleichen. Die unten genannte Laufzeit wird unter 252 Umständen weit von der Laufzeit auf Ihrem Computer oder sogar zwischen 253 verschiedenen Sage Versionen abweichen. Zuerst natives Python: 254 255 .. skip 256 257 :: 258 259 sage: %time a = int(1938)^int(99484) 260 CPU times: user 0.66 s, sys: 0.00 s, total: 0.66 s 261 Wall time: 0.66 262 263 Das bedeutet insgesamt 0,66 Sekunden wurden benötigt und die 264 vergangene "Wall time", also die vergangene Echtzeit (auf Ihrer 265 Wanduhr), betrug auch 0,66 Sekunden. Wenn auf Ihrem Computer viele 266 andere Programme gleichzeitig laufen kann die "Wall time" 267 wesentlich größer als die CPU Zeit sein. 268 269 Als nächstes messen wir die Laufzeit der Potenzierung unter Verwendung 270 des nativen Sage Ganzzahl-Typs, der (in Cython implementiert ist und) 271 die GMP Bibliothek nutzt: 272 273 .. skip 274 275 :: 276 277 sage: %time a = 1938^99484 278 CPU times: user 0.04 s, sys: 0.00 s, total: 0.04 s 279 Wall time: 0.04 280 281 Unter Verwendung der PARI C-Bibliothek: 282 283 .. skip 284 285 :: 286 287 sage: %time a = pari(1938)^pari(99484) 288 CPU times: user 0.05 s, sys: 0.00 s, total: 0.05 s 289 Wall time: 0.05 290 291 GMP ist also ein bisschen besser (wie erwartet, da die für Sage 292 verwendete PARI Version GMP für Ganzzahlarithmetik nutzt). 293 Sie können ebenso Befehlsblöcke messen, indem Sie ``cputime`` wie 294 unten verwenden: 295 296 :: 297 298 sage: t = cputime() 299 sage: a = int(1938)^int(99484) 300 sage: b = 1938^99484 301 sage: c = pari(1938)^pari(99484) 302 sage: cputime(t) # random output 303 0.64 304 305 .. skip 306 307 :: 308 309 sage: cputime? 310 ... 311 Return the time in CPU second since SAGE started, or with optional 312 argument t, return the time since time t. 313 INPUT: 314 t -- (optional) float, time in CPU seconds 315 OUTPUT: 316 float -- time in CPU seconds 317 318 Der ``walltime`` Befehl entspricht ``cputime``, nur misst dieser die Echtzeit. 319 320 Wir können die oben genannte Potenz auch in einigen der Computer 321 Algebra Systeme, die Sage mitbringt berechnen. In jedem Fall führen wir 322 einen trivialen Befehl aus, um den entsprechenden Server dieses 323 Programms zu starten. Sollte es erhebliche Unterschiede zwischen 324 Echtzeit und CPU-Zeit geben, deutet dies auf ein Leistungsproblem hin, 325 dem man nachgehen sollte. 326 327 .. skip 328 329 :: 330 331 sage: time 1938^99484; 332 CPU times: user 0.01 s, sys: 0.00 s, total: 0.01 s 333 Wall time: 0.01 334 sage: gp(0) 335 0 336 sage: time g = gp('1938^99484') 337 CPU times: user 0.00 s, sys: 0.00 s, total: 0.00 s 338 Wall time: 0.04 339 sage: maxima(0) 340 0 341 sage: time g = maxima('1938^99484') 342 CPU times: user 0.00 s, sys: 0.00 s, total: 0.00 s 343 Wall time: 0.30 344 sage: kash(0) 345 0 346 sage: time g = kash('1938^99484') 347 CPU times: user 0.00 s, sys: 0.00 s, total: 0.00 s 348 Wall time: 0.04 349 sage: mathematica(0) 350 0 351 sage: time g = mathematica('1938^99484') 352 CPU times: user 0.00 s, sys: 0.00 s, total: 0.00 s 353 Wall time: 0.03 354 sage: maple(0) 355 0 356 sage: time g = maple('1938^99484') 357 CPU times: user 0.00 s, sys: 0.00 s, total: 0.00 s 358 Wall time: 0.11 359 sage: gap(0) 360 0 361 sage: time g = gap.eval('1938^99484;;') 362 CPU times: user 0.00 s, sys: 0.00 s, total: 0.00 s 363 Wall time: 1.02 364 365 Achten Sie darauf, dass GAP und Maxima am langsamsten in diesem Test 366 sind (er lief auf dem Computer ``sage.math.washington.edu``). Aufgrund 367 des Pexpect-Schnittstellen-Overheads ist es aber vielleicht unfair 368 diese mit Sage zu vergleichen, welches am schnellsten war. 369 370 Fehlerbehandlung 371 ================ 372 373 Wenn irgendetwas schief geht, werden Sie normalerweise eine 374 Python-Fehlermeldung sehen. Python macht sogar einen Vorschlag, was den 375 Fehler ausgelöst hat. Oft sehen Sie den Namen der Fehlermeldung, 376 z.B. ``NameError`` oder ``ValueError`` (vgl. Python Reference Manual 377 [Py]_ für eine komplette Liste der Fehlermeldungen). Zum Beispiel: 378 379 .. skip 380 381 :: 382 383 sage: 3_2 384 ------------------------------------------------------------ 385 File "<console>", line 1 386 ZZ(3)_2 387 ^ 388 SyntaxError: invalid syntax 389 390 sage: EllipticCurve([0,infinity]) 391 ------------------------------------------------------------ 392 Traceback (most recent call last): 393 ... 394 TypeError: Unable to coerce Infinity (<class 'sage...Infinity'>) to Rational 395 396 Der interaktive Debugger ist manchmal hilfreich um zu verstehen was 397 schiefgelaufen ist. Sie können ihn ein- oder ausschalten indem Sie 398 ``%pdb`` eingeben (standardmäßig ist er ausgeschaltet). Die 399 Eingabeaufforderung ``ipdb>`` erscheint wenn eine Fehlermeldung 400 geworfen wird und der Debugger eingeschaltet ist. Im Debugger können 401 Sie den Status jeder lokalen Variable ausgeben oder im Ausführungstack 402 hoch- und runterspringen. 403 Zum Beispiel: 404 405 .. skip 406 407 :: 408 409 sage: %pdb 410 Automatic pdb calling has been turned ON 411 sage: EllipticCurve([1,infinity]) 412 --------------------------------------------------------------------------- 413 <type 'exceptions.TypeError'> Traceback (most recent call last) 414 ... 415 416 ipdb> 417 418 Tippen Sie ``?`` in der ``ipdb>``-Eingabeaufforderung um eine Liste 419 der Befehle des Debuggers zu erhalten. 420 421 :: 422 423 ipdb> ? 424 425 Documented commands (type help <topic>): 426 ======================================== 427 EOF break commands debug h l pdef quit tbreak 428 a bt condition disable help list pdoc r u 429 alias c cont down ignore n pinfo return unalias 430 args cl continue enable j next pp s up 431 b clear d exit jump p q step w 432 whatis where 433 434 Miscellaneous help topics: 435 ========================== 436 exec pdb 437 438 Undocumented commands: 439 ====================== 440 retval rv 441 442 Drücken Sie Strg-D oder geben Sie ``quit`` ein um zu Sage zurückzukehren. 443 444 .. _section-tabcompletion: 445 446 Rückwärtssuche und Tab-Vervollständigung 447 ======================================== 448 449 Definieren Sie zuerst einen dreidimensionalen Vektorraum 450 :math:`V=\QQ^3` wie folgt: 451 452 :: 453 454 sage: V = VectorSpace(QQ,3) 455 sage: V 456 Vector space of dimension 3 over Rational Field 457 458 Sie können auch die folgende verkürzte Schreibweise verwenden: 459 460 :: 461 462 sage: V = QQ^3 463 464 Schreiben Sie den Anfang eines Befehls und drücken Sie dann ``Strg-p`` 465 (oder drücken Sie einfach die Pfeil-nach-oben-Taste) um zur vorher 466 eingegebenen Zeile zu gelangen, die ebenfalls so beginnt. Das 467 funktioniert auch nach einem kompletten Sage-Neustart noch. Sie können 468 den Verlauf auch mit ``Strg-r`` rückwärts durchsuchen. Diese 469 Funktionalität wird vom ``readline``-Paket bereitgestellt, welches in 470 nahezu jeder Linux-Distribution verfügbar ist. 471 472 Es ist sehr einfach alle Unterfunktionen für :math:`V` mittels 473 Tab-Vervollständigung aufzulisten, indem Sie erst ``V.`` eingeben, 474 und dann die ``[Tabulator Taste]`` drücken: 475 476 .. skip 477 478 :: 479 480 sage: V.[tab key] 481 V._VectorSpace_generic__base_field 482 ... 483 V.ambient_space 484 V.base_field 485 V.base_ring 486 V.basis 487 V.coordinates 488 ... 489 V.zero_vector 490 491 Wenn Sie die ersten paar Buchstaben einer Funktion tippen und dann die 492 ``[Tabulator Taste]`` drücken, bekommen Sie nur die Funktionen, die so 493 beginnen angezeigt. 494 495 .. skip 496 497 :: 498 499 sage: V.i[tab key] 500 V.is_ambient V.is_dense V.is_full V.is_sparse 501 502 Wenn sie wissen wollen, was eine bestimmte Funktion tut, z.B. die 503 "coordinates"-Funktion, so geben Sie ``V.coordinates?`` ein um die 504 Hilfe, und ``V.coordinates??`` um den Quelltext der Funktion zu 505 sehen. 506 507 508 509 Integriertes Hilfesystem 510 ======================== 511 512 Sage hat ein integriertes Hilfesystem. Hängen Sie an einen beliebigen 513 Funktionsnamen ein ``?`` an, um die Dokumentation dazu aufzurufen. 514 515 .. skip 516 517 :: 518 519 sage: V = QQ^3 520 sage: V.coordinates? 521 Type: instancemethod 522 Base Class: <type 'instancemethod'> 523 String Form: <bound method FreeModule_ambient_field.coordinates of Vector 524 space of dimension 3 over Rational Field> 525 Namespace: Interactive 526 File: /home/was/s/local/lib/python2.4/site-packages/sage/modules/f 527 ree_module.py 528 Definition: V.coordinates(self, v) 529 Docstring: 530 Write v in terms of the basis for self. 531 532 Returns a list c such that if B is the basis for self, then 533 534 sum c_i B_i = v. 535 536 If v is not in self, raises an ArithmeticError exception. 537 538 EXAMPLES: 539 sage: M = FreeModule(IntegerRing(), 2); M0,M1=M.gens() 540 sage: W = M.submodule([M0 + M1, M0 - 2*M1]) 541 sage: W.coordinates(2*M0-M1) 542 [2, -1] 543 544 Wie Sie sehen, beinhaltet die Ausgabe den Typ des Objekts, den 545 Dateinamen in welcher die Funktion definiert ist und eine Beschreibung der Funktionalität 546 mit Beispielen, die Sie direkt in Ihre aktuelle Sitzung einfügen können. 547 Fast alle dieser Beispiele werden regelmäßig automatisch getestet um sicherzustellen, dass sie 548 genau wie beschrieben funktionieren. 549 550 Eine andere Funktionalität, die sehr eng in Verbindung mit Open-Source-Gedanken steht ist, 551 dass Sie sich zu jeder Funktion den Quelltext anzeigen lassen 552 können. Sei ``f`` eine Sage oder Python Funktion, dann können Sie mit 553 ``f??`` den Quellcode, der ``f`` definiert anzeigen. Zum Beispiel: 554 555 .. skip 556 557 :: 558 559 sage: V = QQ^3 560 sage: V.coordinates?? 561 Type: instancemethod 562 ... 563 Source: 564 def coordinates(self, v): 565 """ 566 Write $v$ in terms of the basis for self. 567 ... 568 """ 569 return self.coordinate_vector(v).list() 570 571 Das zeigt uns, dass die ``coordinates``-Funktion nichts anderes tut, 572 als ``coordinates_vector``-Funktion aufruft und das Ergebnis in eine 573 Liste umwandelt. Aber was tut die ``coordinates``-Funktion? 574 575 .. skip 576 577 :: 578 579 sage: V = QQ^3 580 sage: V.coordinate_vector?? 581 ... 582 def coordinate_vector(self, v): 583 ... 584 return self.ambient_vector_space()(v) 585 586 Die ``coordinate_vector``-Funktion steckt ihre Eingabe in den 587 umgebenden Raum, was zur Folge hat, dass der Koeffizientenvektor von 588 :math:`v` zur Basis des Vektorraums :math:`V` ausgerechnet wird. 589 Der Raum :math:`V` ist schon der umgebende, nämlich gerade 590 :math:`\QQ^3`. Es gibt auch eine ``coordinate_vector``-Funktion für 591 Unterräume, und sie funktioniert anders. 592 Wir definieren einen Unterraum und schauen uns das an: 593 594 .. skip 595 596 :: 597 598 sage: V = QQ^3; W = V.span_of_basis([V.0, V.1]) 599 sage: W.coordinate_vector?? 600 ... 601 def coordinate_vector(self, v): 602 """ 603 ... 604 """ 605 # First find the coordinates of v wrt echelon basis. 606 w = self.echelon_coordinate_vector(v) 607 # Next use transformation matrix from echelon basis to 608 # user basis. 609 T = self.echelon_to_user_matrix() 610 return T.linear_combination_of_rows(w) 611 612 (Wenn Sie der Meinung sind, dass diese Implementation ineffizient ist, 613 helfen Sie uns bitte unsere Lineare Algebra zu optimieren.) 614 615 Sie können auch ``help(command_name)`` oder ``help(class)`` eingeben 616 um eine manpage-artige Hilfe zu bekommen. 617 618 619 .. skip 620 621 :: 622 623 sage: help(VectorSpace) 624 Help on class VectorSpace ... 625 626 class VectorSpace(__builtin__.object) 627 | Create a Vector Space. 628 | 629 | To create an ambient space over a field with given dimension 630 | using the calling syntax ... 631 : 632 : 633 634 Wenn Sie ``q`` drücken um das Hilfesystem zu verlassen, kommen Sie genau 635 dahin zurück, wo Sie Ihre Sitzung verlassen haben. Die ``help`` Anzeige 636 bleibt nicht in Ihrer Sitzung zurück im Gegensatz zu ``funktion?``. 637 Es ist besonders hilfreich ``help(modul_name)`` zu nutzen. Zum Beispiel sind 638 Vektorräume in ``sage.modules.free_module`` definiert. Geben Sie also 639 ``help(sage.modules.free_module)`` ein, um die Dokumentation des 640 ganzen Moduls zu sehen. Wenn Sie sich Die Dokumentation mit ``help`` 641 ansehen, können Sie mit ``/`` vorwärts und mit ``?`` rückwärts suchen. 642 643 Speichern und Laden von individuellen Objekten 644 ============================================== 645 646 Angenommen Sie berechnen eine Matrix oder schlimmer, einen 647 komplizierten Modulsymbolraum, und Sie wollen ihn für später 648 speichern. Was können Sie tun? Es gibt mehrere Möglichkeiten für 649 Computer Algebra Systeme solche individuellen Objekte zu speichern. 650 651 652 #. **speichern Ihres Spiels:** Unterstützt nur das Speichern und Laden kompletter 653 Sitzungen (z.B. GAP, Magma). 654 655 #. **Einheitliche Ein-/Ausgabe:** Bringen Sie jedes Objekt in eine Form, die 656 Sie wieder einlesen können in (GP/PARI). 657 658 #. **Eval**: Machen Sie beliebigen Code auswertbar im Interpreter (z.B. Sigular, PARI). 659 660 661 Da Sage Python nutzt, braucht es einen anderen Ansatz, nämlich dass 662 jedes Objekt serialisiert werden kann. Das heißt es in eine Zeichenkette 663 umzuwandeln, die man wieder einlesen kann. Das ist im Prinzip ähnlich zum 664 einheitlichen Ein-/Ausgabe Ansatz von PARI, abgesehen von der zu komplizierten 665 Darstellung auf dem Bildschirm. Außerdem ist das Laden und Speichern (meistens) 666 vollautomatisch und benötigt nicht einmal speziellen Programmieraufwand; es ist 667 einfach ein Merkmal, das von Grund auf in Python war. 668 669 Fast alle Objekte x in Sage können in komprimierter Form gespeichert werden 670 via ``save(x, Dateiname)`` (oder in vielen Fällen ``x.save(Dateiname)``). 671 Um das Objekt wieder zu laden, nutzen Sie ``load(Dateiname)``. 672 673 .. skip 674 675 :: 676 677 sage: A = MatrixSpace(QQ,3)(range(9))^2 678 sage: A 679 [ 15 18 21] 680 [ 42 54 66] 681 [ 69 90 111] 682 sage: save(A, 'A') 683 684 Sie sollten Sage nun schließen und neu starten. Dann können Sie ``A`` wieder laden: 685 686 .. skip 687 688 :: 689 690 sage: A = load('A') 691 sage: A 692 [ 15 18 21] 693 [ 42 54 66] 694 [ 69 90 111] 695 696 Sie können das selbe mit komplizierteren Objekten, wie etwa elliptischen 697 Kurven machen. Alle Daten über das Objekt sind zwischengespeichert und 698 werden mit dem Objekt gespeichert. Zum Beispiel: 699 700 .. skip 701 702 :: 703 704 sage: E = EllipticCurve('11a') 705 sage: v = E.anlist(100000) # dauert etwas länger 706 sage: save(E, 'E') 707 sage: quit 708 709 Die gespeicherte Version von ``E`` braucht 153 Kilobyte, da die ersten 710 100000 :math:`a_n` mitgespeichert werden. 711 712 .. skip 713 714 :: 715 716 ~/tmp$ ls -l E.sobj 717 -rw-r--r-- 1 was was 153500 2006-01-28 19:23 E.sobj 718 ~/tmp$ sage [...] 719 sage: E = load('E') 720 sage: v = E.anlist(100000) # sofort! 721 722 (In Python wird das Laden und Speichern mittels des ``cPickle`` 723 Moduls umgesetzt. Genauer: Ein Sage Objekt ``x`` kann mit 724 ``cPickle.dumps(x, 2)`` gespeichert werden. Beachten Sie die ``2``!) 725 726 Sage kann allerdings keine individuellen Objekte anderer Computer Algebra Systeme 727 wie GAP, Singular, Maxima, usw. laden und speichern. Sie sind mit "invalid" gekennzeichnet nach dem Laden. 728 In GAP werden viele Objekte in einer Form dargestellt, die man wiederherstellen kann, 729 viele andere allerdings nicht. Deshalb ist das Wiederherstellen aus ihren Druckdarstellungen 730 nicht erlaubt. 731 732 .. skip 733 734 :: 735 736 sage: a = gap(2) 737 sage: a.save('a') 738 sage: load('a') 739 Traceback (most recent call last): 740 ... 741 ValueError: The session in which this object was defined is no longer 742 running. 743 744 GP/PARI Objekte können hingegen gespeichert und geladen werden, da 745 ihre Druckdarstellung ausreicht um sie wiederherzustellen. 746 747 .. skip 748 749 :: 750 751 sage: a = gp(2) 752 sage: a.save('a') 753 sage: load('a') 754 2 755 756 Gespeicherte Objekte können auch auf Computern mit anderen Architekturen 757 oder Betriebssystemen wieder geladen werden. Zum Beispiel können Sie 758 eine riesige Matrix auf einem 32 Bit Mac OS X speichern und später auf 759 einem 64 Bit Linux System laden, dort die Stufenform herstellen und dann 760 wieder zurückladen. Außerdem können Sie in den meisten Fällen auch Objekte 761 laden, die mit anderen Sage Versionen gespeichert wurden, solange der Quelltext 762 des Objekts nicht zu verschieden ist. Alle Attribute eines Objekts werden zusammen 763 mit seiner Klasse (aber nicht dem Quellcode) gespeichert. Sollte diese Klasse 764 in einer neueren Sage Version nicht mehr existieren, kann das Objekt in dieser 765 neueren Sage Version nicht mehr geladen werden. Aber Sie könnten es in der alten 766 Sage Version laden, die Objekt Dictionaries mit ``x.__dict__`` laden und das Objekt 767 zusammen mit diesem in der neuen Sage Version laden. 768 769 Als Text speichern 770 ------------------ 771 772 Sie können die ASCII Text Darstellung eines Objekts in eine Klartextdatei 773 schreiben, indem Sie die Datei einfach mit Schreibzugriff öffnen und die 774 Textdarstellung des Objekts hineinkopieren. (Sie können auch viele andere 775 Objekte auf diese Art speichern.) Wenn Sie alle Objekte hineinkopiert haben, 776 schließen Sie die Datei einfach. 777 778 .. skip 779 780 :: 781 782 sage: R.<x,y> = PolynomialRing(QQ,2) 783 sage: f = (x+y)^7 784 sage: o = open('file.txt','w') 785 sage: o.write(str(f)) 786 sage: o.close() 787 788 .. _section-save: 789 790 Speichern und Laden kompletter Sitzungen 791 ======================================== 792 793 Sage hat eine sehr flexible Unterstützung für das Speichern und Laden 794 kompletter Sitzungen. 795 796 Der Befehl ``save_session(sitzungsname)`` speichert alle Variablen, 797 die Sie während dieser Sitzung definiert haben als ein Dictionary 798 ``sessionname``. (Im seltenen Fall, dass eine Variable nicht gespeichert 799 werden kann, fehlt sie anschließend einfach im Dictionary.) 800 Die erzeugte Datei ist eine ``.sobj``-Datei und kann genau wie jedes andere 801 Objekt geladen werden. Wenn Sie Objekte aus einer Sitzung laden, werden Sie 802 diese in einem Dictionary finden. Dessen Schlüssel sind die Variablen und 803 dessen Werte sind die Objekte. 804 805 Sie können den ``load_session(sitzungsname)`` Befehl nutzen um die Variablen 806 aus ``sitzungsname`` in die aktuelle Sitzung zu laden. Beachten Sie, dass 807 dieses Vorgehen nicht die Variablen der aktuellen Sitzung löscht, vielmehr 808 werden beide Sitzungen vereinigt. 809 810 Starten wir also zunächst Sage und definieren einige Variablen. 811 812 .. skip 813 814 :: 815 816 sage: E = EllipticCurve('11a') 817 sage: M = ModularSymbols(37) 818 sage: a = 389 819 sage: t = M.T(2003).matrix(); t.charpoly().factor() 820 _4 = (x - 2004) * (x - 12)^2 * (x + 54)^2 821 822 Als nächstes speichern wir unsere Sitzung, was jede der Variablen 823 in eine Datei speichert. Dann sehen wir uns die Datei, die etwa 824 3 Kilobyte groß ist an. 825 826 .. skip 827 828 :: 829 830 sage: save_session('misc') 831 Saving a 832 Saving M 833 Saving t 834 Saving E 835 sage: quit 836 was@form:~/tmp$ ls -l misc.sobj 837 -rw-r--r-- 1 was was 2979 2006-01-28 19:47 misc.sobj 838 839 Zuletzt starten wir Sage neu, definieren uns eine extra Variable, und laden 840 unsere gespeicherte Sitzung. 841 842 .. skip 843 844 :: 845 846 sage: b = 19 847 sage: load_session('misc') 848 Loading a 849 Loading M 850 Loading E 851 Loading t 852 853 Jede der gespeicherten Variablen ist wieder verfügbar und die 854 Variable ``b`` wurde nicht überschrieben. 855 856 .. skip 857 858 :: 859 860 sage: M 861 Full Modular Symbols space for Gamma_0(37) of weight 2 with sign 0 862 and dimension 5 over Rational Field 863 sage: E 864 Elliptic Curve defined by y^2 + y = x^3 - x^2 - 10*x - 20 over Rational 865 Field 866 sage: b 867 19 868 sage: a 869 389 870 871 872 873 .. _section-notebook: 874 875 Die Notebook Umgebung 876 ===================== 877 878 Das Sage Browser Notebook wird mit 879 880 .. skip 881 882 :: 883 884 sage: notebook() 885 886 in der Sage Kommandozeile gestartet. Der Befehl startet das Sage 887 Notebook und ebenso Ihren Standardbrowser. Die Serverstatus-Dateien 888 liegen unter ``$HOME/.sage/sage\_notebook``. 889 890 Die andere Optionen enthalten z.B. 891 892 .. skip 893 894 :: 895 896 sage: notebook("Verzeichnis") 897 898 was einen neuen Notebook Server mit den Dateien aus dem angegebenen Verzeichnis 899 startet (anstelle des Standardverzeichnises ``$HOME/.sage/sage_notebook``). 900 Das kann hilfreich sein, wenn Sie einige Worksheets für ein Projekt oder 901 verschiedene gleichzeitig laufende Notebook Server von einander trennen wollen. 902 903 Wenn Sie das Notebook starten, werden zuerst die folgenden Dateien erzeugt 904 in ``$HOME/.sage/sage_notebook``: 905 906 :: 907 908 nb.sobj (Die notebook SAGE Objekt Datei) 909 objects/ (Ein Verzeichnis, das SAGE Objekte enthält) 910 Worksheets/ (Ein Verzeichnis das SAGE Worksheets enthält). 911 912 Nach dem Anlegen dieser Dateien, startet das notebook als Webserver. 913 914 Ein "Notebook" ist eine Sammlung von Benutzerkonten, von dem jedes 915 verschiedene Worksheets enthalten kann. Wenn Sie ein neues Worksheet 916 erstellen, werden alle zugehörigen Daten unter 917 ``Worksheets/username/number`` gespeichert. In jedem solchen 918 Verzeichnis ist eine Klartextdatei namens ``Worksheet.txt`` - sollte 919 mit Ihren Worksheets oder Sage irgendetwas Unvorhergesehenes 920 passieren, enthält diese Datei alles was Sie benötigen um Ihre 921 Worksheets wiederherzustellen. 922 923 Innerhalb von Sage können Sie mit ``notebook?`` mehr Informationen zum Start eines 924 Notebook-Servers erhalten. 925 926 Das folgende Diagramm veranschaulicht die Architektur eines Sage Notebooks. 927 928 :: 929 930 ---------------------- 931 | | 932 | | 933 | firefox/safari | 934 | | 935 | javascript | 936 | programm | 937 | | 938 | | 939 ---------------------- 940 | ^ 941 | AJAX | 942 V | 943 ---------------------- 944 | | 945 | sage | SAGE Prozess 1 946 | web | ------------> SAGE Prozess 2 (Python Prozesse) 947 | server | pexpect SAGE Prozess 3 948 | | . 949 | | . 950 ---------------------- . 951 952 Um Hilfe zu einem Sage-Befehl ``befehl`` im Notebook-Browser zu bekommen 953 geben Sie ``befehl?`` ein und drücken Sie ``<esc>`` (nicht ``<shift-enter>``). 954 955 Für Informationen zu Tastenbefehlen des Notebook-Browsers klicken Sie auf 956 den ``Help`` Link. -
new file doc/de/tutorial/interfaces.rst
diff -r 361a4ad7d52c -r aad4d26889c1 doc/de/tutorial/interfaces.rst
- + 1 ************** 2 Schnittstellen 3 ************** 4 5 Ein zentraler Aspekt von Sage ist, dass es Berechnungen mit Objekten 6 vieler verschiedener Computer Algebra Systeme unter einem Dach durch eine 7 einheitliche Schnittstelle und Programmiersprache vereinigt. 8 9 Die ``console`` und ``interact`` Methoden einer Schnittstelle unterstützen 10 viele 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 24 GP/PARI 25 ======= 26 27 PARI ist ein kompaktes, sehr ausgereiftes, stark optimiertes C-Programm, 28 dessen primärer Fokus Zahlentheorie ist. Es gibt zwei sehr verschiedene 29 Schnittstellen, 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 37 Die folgenden Zeilen zum Beispiel sind zwei Wege, genau das gleiche zu 38 tun. Sie sehen identisch aus, aber die Ausgabe ist verschieden, und was 39 hinter 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 48 Im ersten Fall wird eine separate Kopie des GP-Interpreters als Server 49 gestartet, die Zeichenkette ``'znprimroot(10007)'`` übergeben, 50 von GP ausgewertet und das Ergebnis wird einer Variable in GP zugewiesen 51 (was Platz im Speicher des GP-Unterprozesses benötigt, der nicht wieder 52 freigegeben wird). Dann wird der Wert der Variablen erst angezeigt. 53 Im zweiten Fall wird kein separates Programm gestartet, stattdessen 54 wird die Zeichenkette ``'znprimroot(10007)'`` von einer bestimmten 55 PARI-C-Bibliotheksfunktion ausgewertet. Das Ergebnis wird im Speicher 56 von Python gehalten, welcher freigegeben wird wenn die Variable nicht 57 mehr referenziert wird. Die Objekte haben außerdem 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 66 Welche Variante sollten Sie also nutzen? Das kommt darauf an was 67 Sie tun. Die GP-Schnittstelle kann alles was ein normales 68 GP/PARI-Konsolenprogramm könnte, da es das Programm 69 startet. Genauergesagt könnten Sie komplizierte PARI-Programme laden 70 und laufen lassen. Im Gegensatz dazu ist die PARI-Schnittstelle 71 (mittels C-Bibliothek) wesentlich restriktiver. Zuerst einmal sind 72 nicht alle Unterfunktionen implementiert. Außerdem 73 wird relativ viel Quellcode nicht in der PARI-Schnittstelle funktionieren, 74 z.B. numerisches Integrieren. Abgesehen davon ist die PARI-Schnittstelle 75 wesentlich schneller und robuster als die von GP. 76 77 (Wenn der GP-Schnittstelle der Speicher ausgeht beim Auswerten einer 78 Zeile, wird sie automatisch und unbemerkt den Speicherbereich 79 verdoppeln und das Auswerten erneut versuchen. Dadurch wird Ihre 80 Berechnung nicht abstürzen, falls Sie den benötigen Speicher falsch 81 eingeschätzt haben. Das ist eine hilfreiche Erweiterung, die der 82 gewöhnliche GP-Interpreter nicht bietet. Die PARI-C-Bibliothek 83 hingegen kopiert jedes neue Objekt sofort vom PARI-Stack, daher wird 84 der Stapel nicht größer. Allerdings muss jedes Objekt kleiner als 100 85 MB sein, da ansonsten der Stapel "überläuft", wenn das Objekt erstellt 86 wird. Dieses zusätzliche Kopieren erzeugt allerdings ein wenig 87 Leistungseinbußen.) 88 89 Zusammengefasst nutzt Sage also die PARI-C-Bibliothek um Funktionalitäten 90 eines GP/PARI-Interpreters bereitzustellen, allerdings mit einer anderen 91 komplizierten Speicherverwaltung und der Programmiersprache Python. 92 93 Zuerst erstellen wir eine PARI-Liste aus einer Python-Liste. 94 95 :: 96 97 sage: v = pari([1,2,3,4,5]) 98 sage: v 99 [1, 2, 3, 4, 5] 100 sage: type(v) 101 <type 'sage.libs.pari.gen.gen'> 102 103 Jedes PARI-Objekt ist vom Typ ``py_pari.gen``. Den PARI Typ des vorliegenden 104 Objekts können Sie mit der ``type`` Unterfunktion herausfinden. 105 106 .. link 107 108 :: 109 110 sage: v.type() 111 't_VEC' 112 113 Um eine elliptische Kurve in PARI zu erstellen geben Sie 114 ``ellinit([1,2,3,4,5])`` ein. Bei Sage ist es ähnlich, nur 115 dass ``ellinit`` eine Methode ist, die von jedem PARI-Objekt 116 aus aufgerufen werden kann, z.B. unser ``t\_VEC v``. 117 118 .. link 119 120 :: 121 122 sage: e = v.ellinit() 123 sage: e.type() 124 't_VEC' 125 sage: pari(e)[:13] 126 [1, 2, 3, 4, 5, 9, 11, 29, 35, -183, -3429, -10351, 6128487/10351] 127 128 Jetzt haben wir eine elliptische Kurve als Objekt und können einige 129 Dinge mit ihr berechnen. 130 131 .. link 132 133 :: 134 135 sage: e.elltors() 136 [1, [], []] 137 sage: e.ellglobalred() 138 [10351, [1, -1, 0, -1], 1] 139 sage: f = e.ellchangecurve([1,-1,0,-1]) 140 sage: f[:5] 141 [1, -1, 0, 4, 3] 142 143 .. index: GAP 144 145 .. _section-gap: 146 147 GAP 148 === 149 150 Sage enthält ausserdem GAP für diskrete Mathematik, insbesondere 151 Gruppentheorie. 152 153 Hier ist ein Beispiel für GAP's ``IdGroup``-Funktion, die die optionale kleine 154 Gruppen Datenbank benötigt, die separat installiert werden muss, wie unten beschrieben. 155 156 :: 157 158 sage: G = gap('Group((1,2,3)(4,5), (3,4))') 159 sage: G 160 Group( [ (1,2,3)(4,5), (3,4) ] ) 161 sage: G.Center() 162 Group( () ) 163 sage: G.IdGroup() 164 [ 120, 34 ] 165 sage: G.Order() 166 120 167 168 Wir können die gleiche Berechnung in Sage durchführen ohne vorher explizit 169 die GAP-Schnittstelle aufzurufen: 170 171 :: 172 173 sage: G = PermutationGroup([[(1,2,3),(4,5)],[(3,4)]]) 174 sage: G.center() 175 Permutation Group with generators [()] 176 sage: G.group_id() # benötigt das optionale database_gap Paket 177 [120, 34] 178 sage: n = G.order(); n 179 120 180 181 (Für einige GAP-Funktionen sollten Sie zwei optionale Sage Pakete 182 installieren. Geben Sie ``sage -optional`` ein, um eine Liste zu 183 erhalten und wählen Sie das Paket aus, das etwa so aussieht 184 ``gap\_packages-x.y.z``. 185 Geben Sie dann ``sage -i gap\_packages-x.y.z`` ein. Das gleiche machen 186 Sie bitte mit ``database\_gap-x.y.z``. 187 Einige nicht-GPL Pakete können installiert 188 werden, indem Sie sie von der GAP-Website [GAPkg]_ herunter laden und 189 nach ``$SAGE_ROOT/local/lib/gap-4.4.10/pkg`` entpacken.) 190 191 192 Singular 193 ======== 194 195 Singular bietet eine sehr gute, ausgereifte Bibliothek für Gröbnerbasen, 196 größte gemeinsame Teiler von mehrdimensionalen Polynomen, Basen von 197 Riemann-Roch Räumen einer planaren Kurve und Faktorisierungen unter anderem. 198 Wir zeigen hier die Faktorisierung mehrdimensionaler Polynome mit 199 Sages Singular-Schnittstelle (ohne die ``...``): 200 201 :: 202 203 sage: R1 = singular.ring(0, '(x,y)', 'dp') 204 sage: R1 205 // characteristic : 0 206 // number of vars : 2 207 // block 1 : ordering dp 208 // : names x y 209 // block 2 : ordering C 210 sage: f = singular('9*y^8 - 9*x^2*y^7 - 18*x^3*y^6 - 18*x^5*y^6 + \ 211 ... 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 - \ 212 ... 9*x^12*y^3 - 18*x^13*y^2 + 9*x^16') 213 214 Wir haben also das Polynom :math:`f` definiert, nun geben wir es aus und faktorisieren es. 215 216 .. link 217 218 :: 219 220 sage: f 221 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 222 sage: f.parent() 223 Singular 224 sage: F = f.factorize(); F 225 [1]: 226 _[1]=9 227 _[2]=x^6-2*x^3*y^2-x^2*y^3+y^4 228 _[3]=-x^5+y^2 229 [2]: 230 1,1,2 231 sage: F[1][2] 232 x^6-2*x^3*y^2-x^2*y^3+y^4 233 234 Genau wie im GAP Beispiel in :ref:`section-gap`, können wir diese Faktorisierung 235 berechnen ohne explizit die Singular-Schnittstelle zu nutzen. 236 (Dennoch nutzt Sage im Hintergrund die Singular-Schnittstelle für die Berechnung.) 237 Bitte geben Sie ein ohne ``...``: 238 239 :: 240 241 sage: x, y = QQ['x, y'].gens() 242 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\ 243 ... + 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\ 244 ... - 18*x^13*y^2 + 9*x^16 245 sage: factor(f) 246 (9) * (-x^5 + y^2)^2 * (x^6 - 2*x^3*y^2 - x^2*y^3 + y^4) 247 248 .. _section-maxima: 249 250 Maxima 251 ====== 252 253 Das in Lisp implementierte Maxima ist ein Teil von Sage. Hingegen wird 254 das gnuplot-Paket (welches Maxima standardmäßig zum plotten nutzt) als 255 optionales Sage-Paket angeboten. Neben anderen Dingen rechnet Maxima 256 mit Symbolen. Maxima integriert und differenziert Funktionen 257 symbolisch, löst gewöhnliche Differentialgleichungen ersten Grades 258 sowie viele lineare Differentialgleichungen zweiten Grades und besitzt 259 eine Methode zur Laplace Transformation linearer 260 Differentialgleichungen von beliebigem Grad. Maxima kennt eine große 261 Zahl spezieller Funktionen, plottet mittels gnuplot und hat Methoden, 262 um Polynomgleichungen oder Matrizen zu lösen oder zu verändern 263 (z.B. Zeilenelimination oder Eigenwerte und Eigenvektoren berechnen). 264 265 Wir zeigen die Sage/Maxima Schnittstelle, indem wir die Matrix konstruieren, 266 deren :math:`i,j` Eintrag gerade :math:`i/j` ist, für :math:`i,j=1,\ldots,4`. 267 268 :: 269 270 sage: f = maxima.eval('ij_entry[i,j] := i/j') 271 sage: A = maxima('genmatrix(ij_entry,4,4)'); A 272 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]) 273 sage: A.determinant() 274 0 275 sage: A.echelon() 276 matrix([1,1/2,1/3,1/4],[0,0,0,0],[0,0,0,0],[0,0,0,0]) 277 sage: A.eigenvalues() 278 [[0,4],[3,1]] 279 sage: A.eigenvectors() 280 [[[0,4],[3,1]],[[[1,0,0,-4],[0,1,0,-2],[0,0,1,-4/3]],[[1,2,3,4]]]] 281 282 Hier ein anderes Beispiel: 283 284 :: 285 286 sage: A = maxima("matrix ([1, 0, 0], [1, -1, 0], [1, 3, -2])") 287 sage: eigA = A.eigenvectors() 288 sage: V = VectorSpace(QQ,3) 289 sage: eigA 290 [[[-2,-1,1],[1,1,1]],[[[0,0,1]],[[0,1,3]],[[1,1/2,5/6]]]] 291 sage: v1 = V(sage_eval(repr(eigA[1][0][0]))); lambda1 = eigA[0][0][0] 292 sage: v2 = V(sage_eval(repr(eigA[1][1][0]))); lambda2 = eigA[0][0][1] 293 sage: v3 = V(sage_eval(repr(eigA[1][2][0]))); lambda3 = eigA[0][0][2] 294 295 sage: M = MatrixSpace(QQ,3,3) 296 sage: AA = M([[1,0,0],[1, - 1,0],[1,3, - 2]]) 297 sage: b1 = v1.base_ring() 298 sage: AA*v1 == b1(lambda1)*v1 299 True 300 sage: b2 = v2.base_ring() 301 sage: AA*v2 == b2(lambda2)*v2 302 True 303 sage: b3 = v3.base_ring() 304 sage: AA*v3 == b3(lambda3)*v3 305 True 306 307 Zuletzt noch ein Beispiel wie man Sage zum Plotten mittels 308 ``openmath`` nutzt. Einige von ihnen wurden (verändert) aus dem Maxima 309 Benutzerhandbuch entnommen. 310 311 Ein 2D-Plot verschiedener Funktionen (ohne ``...`` eingeben): 312 313 :: 314 315 sage: maxima.plot2d('[cos(7*x),cos(23*x)^4,sin(13*x)^3]','[x,0,1]',\ 316 ... '[plot_format,openmath]') 317 318 Ein "live" 3D-Plot, den man mit der Maus bewegen kann: 319 320 :: 321 322 sage: maxima.plot3d ("2^(-u^2 + v^2)", "[u, -3, 3]", "[v, -2, 2]",\ 323 ... '[plot_format, openmath]') # nicht getestet 324 sage: maxima.plot3d("atan(-x^2 + y^3/4)", "[x, -4, 4]", "[y, -4, 4]",\ 325 ... "[grid, 50, 50]",'[plot_format, openmath]') # nicht getestet 326 327 Der nächste Plot ist das berühmte Möbiusband: 328 329 :: 330 331 sage: maxima.plot3d("[cos(x)*(3 + y*cos(x/2)), sin(x)*(3 + y*cos(x/2)),\ 332 ... y*sin(x/2)]", "[x, -4, 4]", "[y, -4, 4]",\ 333 ... '[plot_format, openmath]') # nicht getestet 334 335 Und der letzte ist die berühmte Kleinsche Flasche: 336 337 :: 338 339 sage: maxima("expr_1: 5*cos(x)*(cos(x/2)*cos(y) + sin(x/2)*sin(2*y)+ 3.0)\ 340 ... - 10.0") 341 5*cos(x)*(sin(x/2)*sin(2*y)+cos(x/2)*cos(y)+3.0)-10.0 342 sage: maxima("expr_2: -5*sin(x)*(cos(x/2)*cos(y) + sin(x/2)*sin(2*y)+ 3.0)") 343 -5*sin(x)*(sin(x/2)*sin(2*y)+cos(x/2)*cos(y)+3.0) 344 sage: maxima("expr_3: 5*(-sin(x/2)*cos(y) + cos(x/2)*sin(2*y))") 345 5*(cos(x/2)*sin(2*y)-sin(x/2)*cos(y)) 346 sage: maxima.plot3d ("[expr_1, expr_2, expr_3]", "[x, -%pi, %pi]",\ 347 ... "[y, -%pi, %pi]", "['grid, 40, 40]",\ 348 ... '[plot_format, openmath]') # nicht getestet 349 -
new file doc/de/tutorial/introduction.rst
diff -r 361a4ad7d52c -r aad4d26889c1 doc/de/tutorial/introduction.rst
- + 1 ********** 2 Einleitung 3 ********** 4 5 Um dieses Tutorial vollständig durchzuarbeiten sollten 3 bis 4 Stunden 6 genügen. Sie können es im HTML oder PDF Format 7 lesen oder im Sage Notebook. Dazu klicken Sie zuerst auf ``Help`` und 8 ``Tutorial``, um innerhalb von Sage interaktiv mit dem 9 Tutorial zu arbeiten. 10 11 Obwohl große Teile von Sage mithilfe von Python implementiert sind, 12 ist kein tieferes Verständnis von Python notwendig um dieses Tutorial 13 lesen zu können. Sie werden Python zu einem gewissen Zeitpunkt lernen 14 wollen (Python kann sehr viel Spass bereiten) und es gibt viele 15 ausgezeichnete freie Quellen, wozu auch [PyT]_ und [Dive]_ gehören. 16 Wenn Sie nur kurz etwas in Sage ausprobieren möchten, ist dieses 17 Tutorial der richtige Ort um damit anzufangen. Zum Beispiel: 18 19 :: 20 21 sage: 2 + 2 22 4 23 sage: factor(-2007) 24 -1 * 3^2 * 223 25 26 sage: A = matrix(4,4, range(16)); A 27 [ 0 1 2 3] 28 [ 4 5 6 7] 29 [ 8 9 10 11] 30 [12 13 14 15] 31 32 sage: factor(A.charpoly()) 33 x^2 * (x^2 - 30*x - 80) 34 35 sage: m = matrix(ZZ,2, range(4)) 36 sage: m[0,0] = m[0,0] - 3 37 sage: m 38 [-3 1] 39 [ 2 3] 40 41 sage: E = EllipticCurve([1,2,3,4,5]); 42 sage: E 43 Elliptic Curve defined by y^2 + x*y + 3*y = x^3 + 2*x^2 + 4*x + 5 44 over Rational Field 45 sage: E.anlist(10) 46 [0, 1, 1, 0, -1, -3, 0, -1, -3, -3, -3] 47 sage: E.rank() 48 1 49 50 sage: k = 1/(sqrt(3)*I + 3/4 + sqrt(73)*5/9); k 51 1/(I*sqrt(3) + 5/9*sqrt(73) + 3/4) 52 sage: N(k) 53 0.165495678130644 - 0.0521492082074256*I 54 sage: N(k,30) # 30 "bits" 55 0.16549568 - 0.052149208*I 56 sage: latex(k) 57 \frac{1}{i \, \sqrt{3} + \frac{5}{9} \, \sqrt{73} + \frac{3}{4}} 58 59 .. _installation: 60 61 Installation 62 ============ 63 64 Falls Sie Sage auf Ihrem Computer nicht installiert haben und nur ein 65 paar Befehle ausführen möchten, können Sie es online unter 66 http://www.sagenb.org benutzen. 67 68 Schauen Sie sich den `Sage Installation Guide <http://www.sagemath.org/doc/installation/index.html>`_ an, um Anleitungen 69 zur Installation von Sage auf Ihrem Computer zu erhalten. 70 Hier geben wir nur ein paar Kommentare ab. 71 72 73 74 #. Die herunterladbare Sage-Datei wurde nach der *batteries included* 75 Philosophie zusammengestellt. In anderen Worten, obwohl Sage 76 Python, IPython, PARI, GAP, Singular, Maxima, NTL, GMP und so 77 weiter benutzt, müssen Sie diese Programme nicht separat 78 installieren, da diese in der Sage-Distribution enthalten 79 sind. Jedoch müssen Sie, um bestimmte Sage Zusatzfunktionen, zum 80 Beispiel Macaulay oder KASH, nutzen zu können, diese entsprechenden 81 optionalen Pakete installieren, oder zumindest die relevanten 82 Programme auf ihrem Computer schon installiert haben. Macaulay und 83 KASH sind Sage-Pakete (um eine Liste aller verfügbaren Sage-Pakete 84 zu sehen, geben Sie ``sage -optional`` ein, oder rufen Sie die 85 "Download" Seite auf der Sage Webseite auf). 86 87 #. Die vorkompilierte Binärversion von Sage (zu finden auf der 88 Sage-Webseite) ist vielleicht einfacher und 89 schneller zu installieren als die Quellcode-Version. Sie müssen 90 die Datei nur entpacken und das Kommando ``sage`` ausführen. 91 92 #. Falls Sie das SageTeX-Paket benutzen möchten (mit welchem Sie 93 die Ergebnisse von Sage Berechnungen in eine LaTeX-Datei 94 einbauen können), müssen Sie SageTeX Ihrer TeX-Distribution bekannt 95 machen. Um dies zu tun, lesen Sie den Abschnitt `Make SageTeX known 96 to TeX <http://www.sagemath.org/doc/installation/sagetex.html>`_ im 97 Sage Installation Guide 98 (`Dieser Link <../../en/installation/index.html>`_ sollte Sie zu 99 eine lokalen Kopie des Installation Guides führen). Es ist ziemlich 100 einfach; Sie müssen nur eine Umgebungsvariable setzen oder eine 101 einzige Datei in ein Verzeichnis kopieren, welches TeX durchsucht. 102 103 Die Dokumentation für SageTeX befindet sich in 104 ``$SAGE_ROOT/local/share/texmf/tex/generic/sagetex/``, wobei 105 "``$SAGE_ROOT``" auf das Verzeichnis zeigt, in welches Sie Sage 106 installiert haben, zum Beispiel ``/opt/sage-4.2.1``. 107 108 Wie man Sage benutzen kann 109 ========================== 110 111 Sie können Sage auf verschiedene Weise benutzen. 112 113 - **graphisches Notebook-Interface:** lesen Sie den Abschnitt 114 zum Notebook im Referenzhandbuch und :ref:`section-notebook` weiter unten, 115 116 - **interaktive Kommandozeile:** lesen Sie :ref:`chapter-interactive_shell`, 117 118 - **Programme:** Indem Sie interpretierte und kompilierte Programme in 119 Sage schreiben (lesen Sie :ref:`section-loadattach` und :ref:`section-compile`), und 120 121 - **Skripte:** indem Sie eigenständige Pythonskripte schreiben, welche 122 die Sage-Bibliothek benutzen (lesen Sie :ref:`section-standalone`). 123 124 125 Langfristige Ziele von Sage 126 ============================= 127 128 - **nützlich**: Sages Zielgruppen sind Mathematikstudenten (von der 129 Schule bis zur Universität), Lehrer und forschende 130 Mathematiker. Das Ziel ist es, Software bereitzustellen, die benutzt 131 werden kann, um mathematische Konstruktionen in der Algebra, 132 Geometrie, Zahlentheorie, Analysis, Numerik, usw. zu erforschen und 133 mit ihnen zu experimentieren. Sage hilft dabei, einfacher mit 134 mathematischen Objekten experimentieren zu können. 135 136 - **effizient:** Schnell sein. Sage benutzt hochoptimierte 137 ausgereifte Software wie GMP, PARI, GAP und NTL, und ist somit bei 138 vielen Aufgaben sehr schnell. 139 140 - **frei und Open-Source:** Der Quellcode muss frei verfügbar und 141 lesbar sein, damit Benutzer verstehen können, was das System gerade 142 macht, und es einfacher erweitern zu können. Genauso wie 143 Mathematiker ein tieferes Verständnis eines Theorems erlangen, 144 indem sie den Beweis sorgfältig lesen oder zumindest überfliegen, 145 sollten Leute, die Berechnungen durchführen, verstehen, wie die 146 Berechnungen zustande kommen, indem sie den dokumentierten 147 Quellcode lesen. Falls Sie Sage verwenden, um Berechnungen für ein 148 Paper durchzuführen, welches Sie veröffentlichen, können Sie 149 sicher sein, dass Ihre Leser immer freien Zugang zu Sage und 150 seinem Quellcode haben und Sie dürfen sogar Ihre Sage Version 151 archivieren und weiterverteilen. 152 153 - **einfach zu kompilieren:** Sage sollte für GNU/Linux, Mac OS X und 154 Windowsbenutzer einfach aus dem Quellcode kompiliert werden können. 155 156 - **kooperativ** Sage stellt robuste Schnittstelle zu vielen anderen 157 Computeralgebrasystemen, einschließlich PARI, GAP, Singular, Maxima, 158 KASH, Magma, Maple und Mathematica zur Verfügung. Sage ist dazu 159 gedacht, bestehende Mathematik-Software zu vereinheitlichen und zu erweitern. 160 161 - **gut dokumentiert:** Es gibt ein Tutorial, einen Programmierguide, 162 ein Referenzhandbuch und Howtos mit zahlreichen Beispielen und 163 Erläuterungen der dahinterstehenden Mathematik. 164 165 - **erweiterbar:** Es ist möglich, neue Datentypen zu definieren oder 166 von eingebauten Typen abzuleiten und Code vieler verschiedener Sprachen zu benutzen. 167 168 - **benutzerfreundlich**: Es sollte einfach sein zu verstehen, welche 169 Funktionalität für ein bestimmtes Objekt zur Verfügung gestellt 170 wird und die Dokumentation und den Quellcode zu betrachten. Weiterhin sollte ein 171 hochwertiger Benutzersupport erreicht werden. 172 -
new file doc/de/tutorial/latex.rst
diff -r 361a4ad7d52c -r aad4d26889c1 doc/de/tutorial/latex.rst
- + 1 **************************** 2 Sage, LaTeX und ihre Freunde 3 **************************** 4 5 Sage und der TeX-Dialekt LaTeX haben eine sehr synergetische 6 Beziehung. Dieses Kapitel hat das Ziel die Vielfalt an Interaktionen, 7 von den einfachsten bis hin zu den ungewöhnlichen und fast schon 8 magischen, vorzustellen. (Sie sollten also nicht gleich das ganze 9 Kapitel im ersten Durchgang durch das Tutorial lesen.) 10 11 Überblick 12 ========= 13 14 Es ist wahrscheinlich am einfachsten die verschiedenen 15 Einsatzmöglichkeiten von LaTeX zu verstehen, wenn man sich die drei 16 grundsätzlichen Methoden in Sage ansieht. 17 18 #. Jedes Objekt in Sage muss eine LaTeX Darstellung haben. 19 Sie können diese Darstellung erreichen, indem Sie im Notebook 20 oder der Kommandozeile ``latex(foo)`` ausführen, wobei ``foo`` 21 ein Objekt in Sage ist. Die Ausgabe ist eine Zeichenkette, die 22 eine recht genaue Darstellung im mathematischen Modus von TeX 23 bietet (z.B. zwischen jeweils zwei Dollarzeichen). Einige 24 Beispiele hierfür folgen unten. 25 26 So kann Sage effektiv genutzt werden um Teile eines 27 LaTeX-Dokuments zu erstellen: 28 Erstellen oder berechnen Sie ein Objekt in Sage, drucken Sie es 29 mit dem ``latex()``-Befehl aus und fügen Sie es in Ihr Dokument ein. 30 31 #. Die Notebook Schnittstelle ist konfiguriert 32 `jsMath <http://www.math.union.edu/~dpvc/jsMath/>`_ 33 zu nutzen um mathematische Ausdrücke im Browser darzustellen. 34 jsMath ist eine Kollektion aus JavaScript-Routinen und 35 zugehörigen Schriftarten. Es ist also nichts zusätzlich 36 einzustellen um mathematische Ausdrücke in Ihrem Browser 37 anzuzeigen, wenn Sie das Sage-Notebook nutzen. 38 39 jsMath wurde entwickelt um einen großen, aber nicht vollständigen 40 Teil von TeX darstellen zu können. Es gibt keine Unterstützung 41 für Dinge, wie komplizierte Tabellen, Kapiteleinteilung oder 42 Dokument Management, da es für genaues Darstellen von TeX 43 Ausdrücken konzipiert wurde. Die nahtlose Darstellung von 44 mathematischen Ausdrücken im Sage Notebook wird durch 45 Konvertierung der ``latex()``-Darstellung in jsMath 46 gewährleistet. 47 48 Da jsMath seine eigenen skalierbaren Schriftarten nutzt, ist es 49 anderen Methoden überlegen, die auf Konvertierung in kleine 50 Bilder beruhen. 51 52 jsMath wird möglicherweise von MathJAX abgelöst werden, einer 53 ähnlichen Technik, die vom gleichen Author stammt und eine 54 breite Unterstützung von Technikern und professionellen 55 Vereinen hat. 56 57 #. Sollte in der Sage Kommandozeile oder im Notebook mehr 58 LaTeX-Code vorkommen als jsMath verarbeiten kann, kann eine 59 systemweite Installation von LaTeX aushelfen. Sage beinhaltet 60 fast alles, das Sie brauchen um Sage weiter zu entwickeln und 61 zu nutzen. Eine Ausnahme hierzu ist TeX selbst. In diesen 62 Situationen müssen also TeX und verschiedene Konverter 63 installiert sein, um alle Möglichkeiten nutzen zu können. 64 65 Hier führen wir einige grundlegenden Funktionen von ``latex()`` vor. :: 66 67 sage: var('z') 68 z 69 sage: latex(z^12) 70 z^{12} 71 sage: latex(integrate(z^4, z)) 72 \frac{1}{5} \, z^{5} 73 sage: latex('a string') 74 \texttt{a string} 75 sage: latex(QQ) 76 \Bold{Q} 77 sage: latex(matrix(QQ, 2, 3, [[2,4,6],[-1,-1,-1]])) 78 \left(\begin{array}{rrr} 79 2 & 4 & 6 \\ 80 -1 & -1 & -1 81 \end{array}\right) 82 83 Grundlegende jsMath Funktionen gibt es im Notebook weitgehend automatisch, 84 aber wir können es teilweise mit Hilfe der ``JSMath`` Klasse demonstrieren. 85 Die ``eval`` Funktion dieser Klasse konvertiert ein Sage-Objekt in 86 seine LaTeX-Darstellung und dann in HTML mit der CSS ``math`` Klasse, 87 die dann jsMath verwendet. :: 88 89 sage: from sage.misc.latex import JSMath 90 sage: js = JSMath() 91 sage: var('z') 92 z 93 sage: js(z^12) 94 <html><div class="math">\newcommand{\Bold}[1]{\mathbf{#1}}z^{12}</div></html> 95 sage: js(QQ) 96 <html><div class="math">\newcommand{\Bold}[1]{\mathbf{#1}}\Bold{Q}</div></html> 97 sage: js(ZZ[x]) 98 <html><div class="math">\newcommand{\Bold}[1]{\mathbf{#1}}\Bold{Z}[x]</div></html> 99 sage: js(integrate(z^4, z)) 100 <html><div class="math">\newcommand{\Bold}[1]{\mathbf{#1}}\frac{1}{5} \, z^{5}</div></html> 101 102 103 Grundlegende Nutzung 104 ==================== 105 106 Wie schon im Überblick angekündigt, ist der einfachste Weg Sage's 107 LaTeX-Unterstützung zu nutzen die ``latex()`` Funktion um eine 108 legitime LaTeX-Darstellung eines mathematischen Objekts zu erhalten. 109 Diese Zeichenketten können dann in unabhängigen LaTeX-Dokumenten 110 genutzt werden. Das funktioniert im Notebook genauso wie in der 111 Sage-Kommandozeile. 112 113 Das andere Extrem ist der ``view()``-Befehl. In der Sage-Kommandozeile 114 wird der Befehl ``view()`` die LaTeX-Darstellung von ``foo`` in ein 115 einfaches LaTeX Dokument packen, und dann dieses mit der systemweiten 116 TeX-Installation aufrufen. Zuletzt wird das passende Programm zum 117 Anzeigen der Ausgabe von TeX aufgerufen. Welche Version von TeX 118 genutzt wird, und damit auch wie die Ausgabe aussieht und welches 119 Anzeigeprogramm aufgerufen wird, kann angepasst werden (siehe 120 :ref:`sec-custom-processing`). 121 122 Im Notebook schafft der ``view(foo)`` Befehl die nötige Kombination 123 von HTML und CSS sodass jsMath die LaTeX Darstellung im Arbeitsblatt 124 anzeigt. Für den Anwender erstellt er einfach eine schön formatierte 125 Ausgabe, die sich von der normalen ASCII Ausgabe aus Sage 126 unterscheidet. Nicht jedes mathematische Objekt in Sage hat eine 127 LaTeX-Darstellung, die die eingeschränkten Möglichkeiten von jsMath 128 unterstützt. In diesen Fällen kann die jsMath Darstellung umgangen 129 werden, und stattdessen die systemweite TeX-Installation aufgerufen 130 werden. Dessen Ausgabe kann dann als Bild im Arbeitsblatt angezeigt 131 werden. Die Einstellungen und Auswirkungen dieses Prozesses wird im 132 Kapitel :ref:`sec-custom-generation` dargestellt. 133 134 Der interne ``pretty_print()`` Befehl zeigt die Konvertierung von Sage 135 Objekten in HTML Code der jsMath nutzt im Notebook. :: 136 137 sage: from sage.misc.latex import pretty_print 138 sage: pretty_print(x^12) 139 <html><span class="math">\newcommand{\Bold}[1]{\mathbf{#1}}x^{12}</span></html> 140 sage: pretty_print(integrate(sin(x), x)) 141 <html><span class="math">\newcommand{\Bold}[1]{\mathbf{#1}}-\cos\left(x\right)</span></html> 142 143 Das Notebook hat zwei weitere Möglichkeiten TeX zu nutzen. Die erste 144 ist der "Typeset"-Knopf über der ersten Zelle eines Arbeitsblatts, 145 rechts von den vier Drop-Down-Boxen. Ist er ausgewählt werden die 146 Ausgaben aller folgenden Berechnungen von jsMath 147 interpretiert. Beachten Sie, dass dieser Befehl nicht rückwirkend ist 148 -- alle vorher berechneten Zellen werden nicht neu berechnet. Im 149 Grunde ist der "Typeset"-Knopf gleichzusetzen mit dem Aufruf des 150 ``view()``-Befehls in allen Zellen. 151 152 Die zweite Möglichkeit im Notebook ist das Eingeben von TeX 153 Kommentaren in einem Arbeitsblatt. Wenn der Cursor zwischen zwei 154 Zellen steht, und der erscheinende blaue Balken mit gedrückter Shift 155 Taste geklickt wird, wird ein kleiner Texteditor TinyMCE 156 geöffnet. Dieser erlaubt die Eingabe von HTML und CSS formatiertem 157 Text mit einem WYSIWYG-Editor. Es ist also möglich den so formatierten 158 Text als Kommentar in einem Arbeitsblatt unterzubringen. Text den Sie 159 hier zwischen ``$...$`` oder ``$$...$$`` eingeben wird ebenfalls von 160 jsMath in einer "inline" bzw. "display math" Umgebung gesetzt. 161 162 .. _sec-custom-generation: 163 164 165 Anpassen der LaTeX-Generierung 166 ============================== 167 168 Es gibt verschiedene Arten den vom ``latex()``-Befehl generierten 169 LaTeX-Code anzupassen. Im Notebook und der Sage Kommandozeile gibt es 170 ein vordefiniertes Objekt Namens ``latex``, das verschiedene Methoden 171 hat, die Sie sich auflisten lassen können indem Sie ``latex.`` 172 eingeben und die Tab Taste drücken (beachten Sie den Punkt). 173 174 Ein gutes Beispiel ist die ``latex.matrix_delimiters`` Methode. Es 175 kann benutzt werden um die Darstellung der Matrizen zu beeinflussen -- 176 runde Klammern, eckige Klammern, geschwungene Klammern oder senkrechte 177 Striche. Sie müssen sich nicht für eine Darstellung entscheiden, Sie 178 können verschiedene miteinander kombinieren, wie Sie es 179 wünschen. Beachten Sie dass die in LaTeX benötigten Backslashes einen 180 zusätzlichen Slash benötigen damit sie in Python korrekt erkannt 181 werden. :: 182 183 sage: A = matrix(ZZ, 2, 2, range(4)) 184 sage: latex(A) 185 \left(\begin{array}{rr} 186 0 & 1 \\ 187 2 & 3 188 \end{array}\right) 189 sage: latex.matrix_delimiters(left='[', right=']') 190 sage: latex(A) 191 \left[\begin{array}{rr} 192 0 & 1 \\ 193 2 & 3 194 \end{array}\right] 195 sage: latex.matrix_delimiters(left='\\{', right='\\}') 196 sage: latex(A) 197 \left\{\begin{array}{rr} 198 0 & 1 \\ 199 2 & 3 200 \end{array}\right\} 201 202 Die ``latex.vector_delimiters`` Methode funktioniert ähnlich. 203 204 Die Darstellung von Ringen und Körpern (ganze, rationale, reelle 205 Zahlen, etc.) kann mit der ``latex.blackboard_bold`` Methode verändert 206 werden. Diese Mengen werden in standardmäßig in fett gedruckt, 207 alternativ können sie auch mit Doppelstrichen geschrieben 208 werden. Hierfür wird das ``\Bold{}``-Makro genutzt, das in Sage 209 integriert ist. :: 210 211 sage: latex(QQ) 212 \Bold{Q} 213 sage: from sage.misc.latex import JSMath 214 sage: js=JSMath() 215 sage: js(QQ) 216 <html><div class="math">\newcommand{\Bold}[1]{\mathbf{#1}}\Bold{Q}</div></html> 217 sage: latex.blackboard_bold(True) 218 sage: js(QQ) 219 <html><div class="math">\newcommand{\Bold}[1]{\mathbb{#1}}\Bold{Q}</div></html> 220 sage: latex.blackboard_bold(False) 221 222 Dank der Erweiterbarkeit von TeX können Sie selbst Makros und Pakete 223 einbinden. Individuelle Makros können hinzugefügt werden, die dann von 224 jsMath als TeX-Schnipsel interpretiert werden. :: 225 226 sage: latex.extra_macros() 227 '' 228 sage: latex.add_macro("\\newcommand{\\foo}{bar}") 229 sage: latex.extra_macros() 230 '\\newcommand{\\foo}{bar}' 231 sage: var('x y') 232 (x, y) 233 sage: latex(x+y) 234 x + y 235 sage: from sage.misc.latex import JSMath 236 sage: js=JSMath() 237 sage: js(x+y) 238 <html><div class="math">\newcommand{\Bold}[1]{\mathbf{#1}}\newcommand{\foo}{bar}x + y</div></html> 239 240 Zusätzliche Makros, die so hinzugefügt wurden, werden auch vom 241 systemweiten TeX genutzt, wenn jsMath an seine Grenzen gestoßen ist. 242 Der Befehl ``latex_extra_preamble`` kann genutzt werden um eine 243 Präambel eines kompletten LaTeX Dokuments zu erzeugen, das folgende 244 Beispiel zeigt wie. Beachten Sie wiederrum die doppelten Backslashes 245 in den Python Zeichenketten. :: 246 247 248 sage: latex.extra_macros('') 249 sage: latex.extra_preamble('') 250 sage: from sage.misc.latex import latex_extra_preamble 251 sage: print latex_extra_preamble() 252 \newcommand{\ZZ}{\Bold{Z}} 253 ... 254 \newcommand{\Bold}[1]{\mathbf{#1}} 255 sage: latex.add_macro("\\newcommand{\\foo}{bar}") 256 sage: print latex_extra_preamble() 257 \newcommand{\ZZ}{\Bold{Z}} 258 ... 259 \newcommand{\Bold}[1]{\mathbf{#1}} 260 \newcommand{\foo}{bar} 261 262 Für größere oder kompliziertere LaTeX-Ausdrücke können mit 263 ``latex.add_to_preamble`` Pakete (oder ähnliches) zur LaTeX-Präambel 264 hinzugefügt werden. Der zweite Befehl 265 ``latex.add_package_to_preamble_if_available`` prüft hingegen erst ob 266 das Paket vorhanden ist, bevor es eingebunden wird. 267 268 Hier fügen wir das geometry-Paket zur Präambel hinzu, um die 269 Seitenränder einzustellen. Achten Sie wieder auf die doppelten 270 Backslashes in Python. :: 271 272 273 sage: from sage.misc.latex import latex_extra_preamble 274 sage: latex.extra_macros('') 275 sage: latex.extra_preamble('') 276 sage: latex.add_to_preamble('\\usepackage{geometry}') 277 sage: latex.add_to_preamble('\\geometry{letterpaper,total={8in,10in}}') 278 sage: latex.extra_preamble() 279 '\\usepackage{geometry}\\geometry{letterpaper,total={8in,10in}}' 280 sage: print latex_extra_preamble() 281 \usepackage{geometry}\geometry{letterpaper,total={8in,10in}} 282 \newcommand{\ZZ}{\Bold{Z}} 283 ... 284 \newcommand{\Bold}[1]{\mathbf{#1}} 285 286 Ein bestimmtes Paket, dessen Existenz nicht sicher ist, wird wie folgt 287 eingebunden. :: 288 289 sage: latex.extra_preamble('') 290 sage: latex.extra_preamble() 291 '' 292 sage: latex.add_to_preamble('\\usepackage{foo-bar-unchecked}') 293 sage: latex.extra_preamble() 294 '\\usepackage{foo-bar-unchecked}' 295 sage: latex.add_package_to_preamble_if_available('foo-bar-checked') 296 sage: latex.extra_preamble() 297 '\\usepackage{foo-bar-unchecked}' 298 299 .. _sec-custom-processing: 300 301 Anpassen der LaTeX-Verarbeitung 302 =============================== 303 304 Es ist möglich zu entscheiden welche Variante von TeX für einen 305 systemweiten Aufruf genutzt werden soll, und somit auch wie die 306 Ausgabe aussehen soll. Ebenso ist es möglich zu beeinflussen, ob das 307 Notebook jsMath oder die systemweite LaTeX Installation nutzt. 308 309 Der Befehl ``latex.engine()`` entscheidet, ob die systemweiten 310 Anwendungen ``latex``, ``pdflatex`` oder ``xelatex`` genutzt werden 311 für kompliziertere LaTeX-Ausdrücke. Wenn ``view()`` in der Sage 312 Kommandozeile aufgerufen wird, und ``latex`` als Prozessor eingestellt 313 ist, wird eine .dvi Datei erzeugt, die dann mit einem dvi 314 Anzeigeprogramm (wie xdvi) angezeigt wird. Im Gegensatz hierzu wird 315 bei Aufruf von ``view()`` mit dem Prozessor ``pdflatex`` eine .PDF 316 Datei erzeugt, die mit dem Standard-PDF-Programm angezeigt 317 wird. (acrobat, okular, evince, etc.). 318 319 Im Notebook kann es nötig sein, dem System die Entscheidung 320 abzunehmen, ob jsMath für einige TeX-Schnipsel, oder das systemweite 321 LaTeX für kompliziertere Ausdrücke genutzt werden soll. Es gibt eine 322 Liste von Befehlen, die wenn einer von ihnen in einem Stück LaTeX-Code 323 erkannt wird, die Ausgabe von LaTeX (oder welcher Prozessor auch immer 324 durch ``latex.engine()`` gesetzt ist) statt von jsMath erstellen 325 lässt. Diese Liste wird verwaltet durch die Befehle 326 ``latex.add_to_jsmath_avoid_list`` und 327 ``latex.jsmath_avoid_list``. :: 328 329 sage: latex.jsmath_avoid_list([]) 330 sage: latex.jsmath_avoid_list() 331 [] 332 sage: latex.jsmath_avoid_list(['foo', 'bar']) 333 sage: latex.jsmath_avoid_list() 334 ['foo', 'bar'] 335 sage: latex.add_to_jsmath_avoid_list('tikzpicture') 336 sage: latex.jsmath_avoid_list() 337 ['foo', 'bar', 'tikzpicture'] 338 sage: latex.jsmath_avoid_list([]) 339 sage: latex.jsmath_avoid_list() 340 [] 341 342 Nehmen wir an ein LaTeX-Ausdruck wurde im Notebook durch ``view()`` 343 oder während aktiviertem "Typeset" Knopf erzeugt. Und dann wird 344 festgestellt, dass er die externe LaTeX-Installation benötigt, weil 345 er in der ``jsmath_avoid_list`` steht. Der Ausdruck wird nun vom 346 ausgewählten (durch ``latex.engine()``) Prozessor erzeugt, und statt 347 der Anzeige in einem externen Programm (was in der Kommandozeile 348 passieren würde) wird Sage versuchen das Ergebnis in einem einzigen, 349 leicht beschnittenen Bild in der Ausgabezelle darzustellen. 350 351 Wie diese Umwandlung abläuft hängt von einigen Faktoren ab, 352 hauptsächlich vom verwendeten LaTeX-Prozessor und davon welche 353 Konvertierungswerkzeuge auf dem System vorhanden sind. Vier nützliche 354 Konverter, die alle Eventualitäten abdecken sind ``dvips``, 355 ``ps2pdf``, ``dvipng`` und aus dem ``ImageMagick`` Paket, 356 ``convert``. Das Ziel ist die Erzeugung einer .png Datei, die später 357 wieder im Arbeitsblatt eingebunden werden kann. Wenn ein 358 LaTeX-Ausdruck erfolgreich von ``latex`` in eine .dvi Datei verwandelt 359 wird, dann sollte dvipng die Umwandlung vornehmen. Wenn der LaTeX 360 Ausdruck und der gewählte LaTeX-Prozessor eine .dvi Datei mit 361 Erweiterungen erstellt, die dvipng nicht unterstützt, so wird dvips 362 eine PostScript-Datei erzeugen. So eine PostScript-Datei, oder eine 363 .pdf Datei aus dem Prozessor ``pdflatex``, wird dann von ``convert`` 364 in eine .png Datei gewandelt. Das Vorhandensein von zweier solcher 365 Konverter kann mit Hilfe der ``have_dvipng()`` und ``have_convert()`` 366 Routinen überprüft werden. 367 368 Diese Umwandlungen werden automatisch ausgeführt, wenn Sie die nötigen 369 Konverter installiert haben; falls nicht wird Ihnen eine Fehlermeldung 370 angezeigt, die Ihnen sagt was fehlt und wo Sie es herunterladen können. 371 372 Für ein konkretes Beispiel wie komplizierte LaTeX-Ausdrücke 373 verarbeitet werden können, sehen Sie sich das Beispiel des 374 ``tkz-graph`` Pakets zum Erstellen von hochwertigen kombinatorischen 375 Graphen im nächsten Abschnitt (:ref:`sec-tkz-graph`) an. Für weitere 376 Beispiele gibt es einige vorgepackte Testfälle. Um diese zu nutzen, 377 müssen Sie das ``sage.misc.latex.latex_examples`` Objekt 378 importieren. Dieses ist eine Instanz der 379 ``sage.misc.latex.LatexExamples`` Klasse, wie unten beschrieben. Diese 380 Klasse enthält momentan Beispiele von kommutativen Diagrammen, 381 kombinatorischen Graphen, Knotentheorie und Beispiele für Graphen mit 382 pstricks. Es werden damit die folgenden Pakete getestet: xy, 383 tkz-graph, xypic, pstricks. Nach dem Import können Sie mittels 384 Tab-Vervollständigung von ``latex_examples`` die vorgepackten 385 Beispiele sehen. Bei Aufruf vom jedem Beispiel erhalten Sie eine 386 Erklärung was nötig ist, damit das Beispiel korrekt dargestellt 387 wird. Um die Darstellung tatsächlich zu sehen müssen Sie ``view()`` 388 benutzen (sofern die Präambel, der LaTeX-Prozessor, etc richtig 389 eingestellt sind). 390 :: 391 392 sage: from sage.misc.latex import latex_examples 393 sage: latex_examples.diagram() 394 LaTeX example for testing display of a commutative diagram produced 395 by xypic. 396 <BLANKLINE> 397 To use, try to view this object -- it won't work. Now try 398 'latex.add_to_preamble("\\usepackage[matrix,arrow,curve,cmtip]{xy}")', 399 and try viewing again -- it should work in the command line but not 400 from the notebook. In the notebook, run 401 'latex.add_to_jsmath_avoid_list("xymatrix")' and try again -- you 402 should get a picture (a part of the diagram arising from a filtered 403 chain complex). 404 405 .. _sec-tkz-graph: 406 407 Ein Beispiel: Kombinatorische Graphen mit tkz-graph 408 =================================================== 409 410 Hochwertige Darstellungen von kombinatorischen Graphen (fortan nur 411 noch "Graphen") sind mit Hilfe des ``tkz-graph`` Pakets möglich. 412 Dieses Paket wurde ausbauend auf das ``tikz`` front-end der ``pgf`` 413 Bibliothek entwickelt. Es müssen also all diese Komponenten Teil der 414 systemweiten TeX-Installation sein, und es ist möglich, dass sie nicht 415 in ihrer neusten Version in der TeX-Implementation vorliegen. Es ist 416 also unter Umständen nötig oder ratsam diese Teile separat in Ihrem 417 persönlichen texmf Baum zu installieren. Das Erstellen, Anpassen und 418 Warten einer systemweiten oder persönlichen TeX-Installation würde 419 allerdings den Rahmen dieses Dokuments sprengen. Es sollte aber 420 einfach sein Anleitungen hierzu zu finden. Die nötigen Dateien sind 421 unter :ref:`sec-system-wide-tex` aufgeführt. 422 423 Um also zu beginnen, müssen wir sicher sein, dass die relevanten 424 Pakete eingefügt werden, indem wir sie in die Präambel des 425 LaTeX-Dokuments hinzufügen. Die Bilder der Graphen werden nicht 426 korrekt formatiert sein, wenn eine .dvi Datei als Zwischenergebnis 427 erzeugt wird. Es ist also ratsam, den LaTeX-Prozessor auf 428 ``pdflatex`` zu stellen. Nun sollte ein Befehl wie 429 ``view(graphs.CompleteGraph(4))`` in der Sage-Kommandozeile 430 erfolgreich eine .pdf Datei mit einem Bild vom kompletten `K_4` 431 Graphen erzeugen. 432 433 Um das Gleiche im Notebook zu erstellen, müssen Sie jsMath 434 für die Verarbeitung von LaTeX-Code ausschalten, indem Sie 435 die "jsmath avoid list" benutzen. Graphen werden in einer 436 ``tikzpicture`` Umgebung eingebunden, das ist also eine gute Wahl 437 für die Zeichenkette für die Ausschlussliste. Jetzt sollte 438 ``view(graphs.CompleteGraph(4))`` in einem Arbeitsblatt 439 eine .pdf Datei mit pdflatex erstellen, mit dem 440 ``convert`` Werkzeug eine .png Grafik erstellen und in die Ausgabezelle 441 des Arbeitsblatts einfügen. 442 Die folgenden Befehle veranschaulichen die Schritte einen Graphen 443 mittels LaTeX in einem Notebook darzustellen. :: 444 445 sage: from sage.graphs.graph_latex import setup_latex_preamble 446 sage: setup_latex_preamble() 447 sage: latex.extra_preamble() # random - depends on system's TeX installation 448 '\\usepackage{tikz}\n\\usepackage{tkz-graph}\n\\usepackage{tkz-berge}\n' 449 sage: latex.engine('pdflatex') 450 sage: latex.add_to_jsmath_avoid_list('tikzpicture') 451 sage: latex.jsmath_avoid_list() 452 ['tikzpicture'] 453 454 Beachten Sie, dass es eine Vielzahl von Optionen gibt, die die 455 Darstellung des Graphen in LaTeX mit ``tkz-graph`` beeinflussen. Auch 456 das wiederrum ist nicht Ziel dieses Abschnitts. Sehen Sie sich hierfür 457 den Abschnitt "LaTeX-Optionen für Graphen" aus dem Handbuch für 458 weitere Anleitungen und Details an. 459 460 .. _sec-system-wide-tex: 461 462 Eine vollfunktionsfähige TeX-Installation 463 ========================================= 464 Viele der erweiterten Integrationsmöglichkeiten von 465 TeX in Sage benötigen eine systemweite Installation von TeX. 466 Viele Linuxdistributionen bieten bereits TeX-Pakete basierend auf 467 TeX-live, für OSX gibt es TeXshop und für Windows MikTeX. 468 Das ``convert`` Werkzeug ist Teil der 469 `ImageMagick <http://www.imagemagick.org/>`_ Suite (welche ein 470 Paket oder zumindest ein simpler Download sein sollte). Die drei 471 Programme ``dvipng``, ``ps2pdf``, und ``dvips`` sind wahrscheinlich 472 bereits Teil Ihrer TeX Distribution. Die ersten beiden sollten 473 auch von http://sourceforge.net/projects/dvipng/ als Teil von 474 `Ghostscript <http://www.ghostscript.com/>`_ bezogen werden können. 475 476 Um kombinatorische Graphen darstellen zu können, wird eine aktuelle Version 477 der PGF Bibliothek und die Dateien ``tkz-graph.sty``, ``tkz-arith.sty`` 478 und eventuell ``tkz-berge.sty`` benötigt, allesamt verfügbar auf der `Altermundus Seite 479 <http://altermundus.com/pages/graph.html>`_. 480 481 Externe Programme 482 ================= 483 484 Es sind drei Programme verfügbar um TeX weiter in Sage zu integrieren. 485 Das erste ist sagetex. Eine kurze Beschreibung von sagetex wäre: Es ist 486 eine Sammlung von TeX-Makros, die es einem LaTeX-Dokument erlauben 487 Anweisungen einzubinden, mit denen Sage genutzt wird um verschiedene 488 Objekte zu berechnen und/oder mittels eingebauter ``latex()``-Funktion darzustellen. 489 Als Zwischenschritt zum Kompilieren eines LaTeX-Dokuments werden also 490 alle Berechnungs- oder LaTeX-Formatierungseigenschaften von Sage automatisch genutzt. 491 Als Beispiel hierfür kann in einer mathematischen Betrachtung die korrekte Reihenfolge 492 von Fragen und Antworten beibehalten werden, indem sagetex dazu genutzt wird Sage die einen 493 aus den anderen berechnen zu lassen. Siehe hierfür auch :ref:`sec-sagetex` 494 495 tex2sws beginnt mit einem LaTeX-Dokument, aber definiert einige zusätzliche 496 Umgebungen für Sage Code. Wenn es richtig genutzt wird, ist das Ergebnis ein 497 Sage Arbeitsblatt mit korrekt von jsMath formatiertem Inhalt und dem dazugehörigen 498 Sage Code in den Eingabezellen. Ein Lehrbuch oder Artikel kann also mit Sage Code Blöcken 499 in LaTeX gesetzt werden und es kann "live" das ganze Dokument in ein Sage Arbeitsblatt überführt werden; 500 unter Beibehaltung der Sage Code Blöcke und mit schön formatiertem mathematischen Text. 501 Momentan in Arbeit, siehe `tex2sws @ BitBucket 502 <http://bitbucket.org/rbeezer/tex2sws/>`_ . 503 504 sws2tex kehrt den Prozess um, indem es mit einem Sage Arbeitsblatt beginnt, und 505 es in ein legitimes LaTeX-Dokument zur weiteren Bearbeitung mit allen 506 LaTeX-Werkzeugen verwandelt. 507 Momentan in Arbeit, siehe `sws2tex @ BitBucket 508 <http://bitbucket.org/whuss/sws2tex/>`_ . -
new file doc/de/tutorial/programming.rst
diff -r 361a4ad7d52c -r aad4d26889c1 doc/de/tutorial/programming.rst
- + 1 ************** 2 Programmierung 3 ************** 4 5 .. _section-loadattach: 6 7 Sage-Dateien Laden und Anhängen 8 =============================== 9 10 Als nächstes zeigen wir wie man Programme, die einer separaten Datei 11 geschrieben wurden in Sage lädt. Erstellen Sie eine Datei, welche Sie 12 ``beispiel.sage`` nennen mit folgendem Inhalt: 13 14 .. skip 15 16 :: 17 18 print "Hello World" 19 print 2^3 20 21 Sie können ``beispiel.sage`` einlesen und ausführen, indem Sie den 22 ``load``-Befehl verwenden. 23 24 .. skip 25 26 :: 27 28 sage: load "beispiel.sage" 29 Hello World 30 8 31 32 Sie können auch eine Sage-Datei an eine laufende Sitzung anhängen, 33 indem Sie den ``attach``-Befehl verwenden: 34 35 .. skip 36 37 :: 38 39 sage: attach "beispiel.sage" 40 Hello World 41 8 42 43 Wenn Sie nun ``beispiel.sage`` verändern und eine Leerzeile in Sage eingeben 44 (d.h. ``return`` drüchen) wird der Inhalt von ``beispiel.sage`` 45 automatisch in Sage neu geladen. 46 47 Insbesondere lädt der ``attach``-Befehl eine Datei jedesmal, wenn 48 diese verändert wird automatisch neu, was beim Debuggen von Code 49 nützlich sein kann, wobei der ``load``-Befehl eine Datei nur einmal lädt. 50 51 Wenn Sage die Datei ``beispiel.sage`` lädt, wird sie zu Python-Code konvertiert, 52 welcher dann vom Python-Interpreter ausgeführt wird. Diese 53 Konvertierung ist geringfügig; sie besteht hautsächlich daraus 54 Integer-Literale mit ``Integer()`` und Fließkomma-Literale mit 55 ``RealNumber()`` zu versehen, ``^`` durch ``**`` zu ersetzen und 56 z.B. ``R.2`` durch ``R.gen(2)`` auszutauschen. Die konvertierte 57 Version von ``beispiel.sage`` befindet sich im gleichen Verzeichnis wie 58 ``beispiel.sage`` und ist ``beispiel.sage.py`` genannt. Diese Datei 59 enthält den folgenden Code: 60 61 :: 62 63 print "Hello World" 64 print Integer(2)**Integer(3) 65 66 Integer-Literale wurden mit Integer() versehen und das ``^`` wurde 67 durch ein ``**`` ersetzt. 68 (In Python bedeutet ``^`` "exklusives oder" und ``**`` bedeutet 69 "Exponentiation".) 70 71 Dieses "preparsing" ist in ``sage/misc/interpreter.py`` implementiert.) 72 73 Sie können mehrzeiligen eingerückten Code in Sage einfügen, solange 74 Zeilenenden neue Blöcke kenntlich machen (dies ist in Dateien nicht notwendig). 75 Jedoch beseht die beste Möglichkeit solchen Code in Sage einzufügen darin, 76 diesen in einer Datei zu speichern und ``attach`` wie oben beschrieben zu verwenden. 77 78 79 .. _section-compile: 80 81 Kompilierten Code erzeugen 82 ========================== 83 84 Geschwindigkeit ist bei mathematischen Berechnungen äußerst 85 wichtig. Python ist zwar eine komfortable Programmiersprache mit sehr 86 hohen Abstraktionsniveau, jedoch können bestimmte Berechnungen 87 mehrere Größenordnungen schneller als in Python sein, wenn sie in 88 einer kompilierten Sprache mit statischen Datentypen implementiert 89 wurden. Manche Teile von Sage würden zu langsam sein, wenn sie 90 komplett in Python geschrieben wären. Um dies zu berücksichtigen 91 unterstützt Sage eine kompilierte "Version" von Python, welche Cython 92 ([Cyt]_ und [Pyr]_) genannt wird. Cython ist gleichzeitig sowohl zu Python, 93 als auch zu C ähnlich. Die meisten von Pythons Konstruktionen, 94 einschließlich "list comprehensions", bedingte Ausdrücke und Code wie 95 ``+=`` sind erlaubt; Sie können auch Code importieren, den Sie in 96 anderen Python-Modulen geschrieben haben. Darüberhinaus können Sie 97 beliebige C Variablen definieren und beliebe C-Bibliothekaufrufe 98 direkt ausführen. Der daraus entstehende Code wird nach C konvertiert 99 und mithilfe eines C-Compilers kompiliert. 100 101 Um eigenen kompilierten Sagecode zu erstellen, geben Sie der Datei eine 102 ``.spyx`` Endung (anstelle von ``.sage``). Falls Sie mit der 103 Kommandozeile arbeiten, können Sie kompilierten Code genau wie 104 interpretierten Code anhängen und laden. (Im Moment wird das Anhängen 105 von Cythoncode vom Notebook aus nicht unterstützt). 106 Die tatsächliche Kompilierung wird "hinter den Kulissen" durchgeführt 107 ohne dass Sie explizit etwas tun müssen. Schauen Sie sich 108 ``$SAGE_ROOT/examples/programming/sagex/factorial.spyx`` an, um ein 109 Beispiel einer kompilierten Implementation der Fakultätsfunktion zu 110 sehen, welche die GMP-C-Bibliothek unmittelbar benutzt. Um dies 111 selbst auszuprobierten, wechseln Sie in das Verzeichnis 112 ``$SAGE_ROOT/examples/programming/sagex/`` und führen Sie Folgendes 113 aus: 114 115 .. skip 116 117 :: 118 119 sage: load "factorial.spyx" 120 *************************************************** 121 Recompiling factorial.spyx 122 *************************************************** 123 sage: factorial(50) 124 30414093201713378043612608166064768844377641568960512000000000000L 125 sage: time n = factorial(10000) 126 CPU times: user 0.03 s, sys: 0.00 s, total: 0.03 s 127 Wall time: 0.03 128 129 Hier gibt das abschließende L ein "Python long integer" zu erkennen 130 (Lesen Sie :ref:`section-mathannoy`). 131 132 Beachten Sie, dass Sage ``factorial.spyx`` neu kompiliert falls Sie 133 Sage beenden und neustarten. 134 Die komplierte "shared object library" wird unter 135 ``$HOME/.sage/temp/hostname/pid/spyx`` gespeichert. Diese Dateien 136 werden gelöscht wenn Sie Sage beenden. 137 138 Auf spyx-Dateien wird kein "preparsing" angewendet, d.h. ``1/3`` wird 139 in einer spyx-Datei zu 0 ausgewertet, anstelle der rationalen Zahl 140 :math:`1/3`. 141 Wenn ``foo`` eine Funktion in der Sage-Bibliothek ist die Sie 142 verwenden möchten, müssen Sie ``sage.all`` importieren und 143 ``sage.all.foo`` benutzen. 144 145 :: 146 147 import sage.all 148 def foo(n): 149 return sage.all.factorial(n) 150 151 Auf C-Funktionen in separaten Dateien zugreifen 152 ----------------------------------------------- 153 154 Es ist auch nicht schwer auf C-Funktions zuzugreifen welche in 155 separaten \*.c Dateien definiert sind. Hier ist ein Beispiel. Erzeugen 156 Sie die Dateien ``test.c`` und ``test.spyx`` in dem gleichen 157 Verzeichnis mit den Inhalten: 158 159 Der reine C-Code: ``test.c`` 160 161 :: 162 163 int add_one(int n) { 164 return n + 1; 165 } 166 167 Der Cython-Code: ``test.spyx``: 168 169 :: 170 171 cdef extern from "test.c": 172 int add_one(int n) 173 174 def test(n): 175 return add_one(n) 176 177 Dann funktioniert das Folgende: 178 179 .. skip 180 181 :: 182 183 sage: attach "test.spyx" 184 Compiling (...)/test.spyx... 185 sage: test(10) 186 11 187 188 Wenn die zusätzliche Bibliothek ``foo`` gebraucht wird um den C-Code, 189 der aus einer Cython-Datei generiert wurde zu kompilieren, fügen Sie 190 die Zeile ``clib foo`` zu dem Cython-Quellcode hinzu. Auf ähnliche 191 Weise kann eine zusätzliche Datei ``bar`` zu der Kompilierung mit der 192 Deklaration ``cfile bar`` hinzugefügt werden. 193 194 .. _section-standalone: 195 196 eigenständige Python/Sage Skripte 197 ================================= 198 199 Das folgende eigenständige Sageskript faktorisiert ganze Zahlen, 200 Polynome, usw.: 201 202 :: 203 204 #!/usr/bin/env sage -python 205 206 import sys 207 from sage.all import * 208 209 if len(sys.argv) != 2: 210 print "Usage: %s <n>"%sys.argv[0] 211 print "Outputs the prime factorization of n." 212 sys.exit(1) 213 214 print factor(sage_eval(sys.argv[1])) 215 216 Um dieses Skript benutzen zu können muss ``SAGE_ROOT`` in ihrer 217 PATH-Umgebungsvariable enthalten sein. Falls das das obige Skript 218 ``factor`` genannt wurde, ist hier ein beispielhafter Aufruf: 219 220 :: 221 222 bash $ ./factor 2006 223 2 * 17 * 59 224 bash $ ./factor "32*x^5-1" 225 (2*x - 1) * (16*x^4 + 8*x^3 + 4*x^2 + 2*x + 1) 226 227 Datentypen 228 ========== 229 230 Jedes Objekt hat in Sage einen wohldefinierten Datentyp. Python 231 besitzt eine Vielzahl von standardmäßiger elementarer Datentypen und die 232 Sage-Bibliothek fügt noch viele weitere hinzu. Zu Pythons 233 standardmäßigen Datentypen gehören Strings, Listen, Tupel, Ganzzahlen und 234 Gleitkommazahlen, wie hier zu sehen ist: 235 236 :: 237 238 sage: s = "sage"; type(s) 239 <type 'str'> 240 sage: s = 'sage'; type(s) # Sie können einfache oder doppelte Anführungszeichen verwenden 241 <type 'str'> 242 sage: s = [1,2,3,4]; type(s) 243 <type 'list'> 244 sage: s = (1,2,3,4); type(s) 245 <type 'tuple'> 246 sage: s = int(2006); type(s) 247 <type 'int'> 248 sage: s = float(2006); type(s) 249 <type 'float'> 250 251 Hierzu fügt Sage noch viele weitere hinzu. Zum Beispiel Vektorräume: 252 253 :: 254 255 sage: V = VectorSpace(QQ, 1000000); V 256 Vector space of dimension 1000000 over Rational Field 257 sage: type(V) 258 <class 'sage.modules.free_module.FreeModule_ambient_field_with_category'> 259 260 Nur bestimmte Funktionen können auf ``V`` aufgerufen werden. In 261 anderen mathematischen Softwaresystemem würde dies mit der 262 "Funktionalen"-Notation ``foo(V,...)`` geschehen. In Sage sind 263 bestimmte Funktionen an den Typ (oder der Klasse) von ``V`` angehängt, 264 und diese werden unter Benutzung einer objektorientierten Syntax, 265 wie in Java oder C++ aufgerufen. Zum Beispiel ``V.foo(...)``. Dies 266 hilft dabei eine Überfüllung des globalen Namensraums mit tausenden 267 von Funktionen zu vermeiden. Das bedeutet auch, dass viele 268 verschiedene Funktionen mit unterschiedlichen Funktionsweisen foo 269 genannt werden können, ohne dass der Typ des Arguments überprüft (oder 270 Case-Anweisungen ausgeführt) werden muss, um zu entscheiden welche 271 aufgerufen werden soll. Weiterhin ist die Funktion auch dann noch 272 verfügbar, wenn ihr Name zu einem anderen Zweck verwendet wurde. (Zum 273 Beispiel wenn Sie etwas ``zeta`` nennen und dann den Wert der 274 Riemannschen Zeta-Funktion bei 0.5 berechnen wollen, können Sie 275 immernoch ``s=.5; s.zeta()`` benutzen). 276 277 :: 278 279 sage: zeta = -1 280 sage: s=.5; s.zeta() 281 -1.46035450880959 282 283 In manchen sehr oft auftretenden Fällen wird auch die gewöhnliche 284 funktionale Notation unterstützt, da dies bequem ist und manche 285 mathematische Ausdrücke in objektorientierter Notation verwirrend 286 aussehen könnten. Hier sind einige Beispiele: 287 288 :: 289 290 sage: n = 2; n.sqrt() 291 sqrt(2) 292 sage: sqrt(2) 293 sqrt(2) 294 sage: V = VectorSpace(QQ,2) 295 sage: V.basis() 296 [ 297 (1, 0), 298 (0, 1) 299 ] 300 sage: basis(V) 301 [ 302 (1, 0), 303 (0, 1) 304 ] 305 sage: M = MatrixSpace(GF(7), 2); M 306 Full MatrixSpace of 2 by 2 dense matrices over Finite Field of size 7 307 sage: A = M([1,2,3,4]); A 308 [1 2] 309 [3 4] 310 sage: A.charpoly('x') 311 x^2 + 2*x + 5 312 sage: charpoly(A, 'x') 313 x^2 + 2*x + 5 314 315 Um alle Member-Funktionen von :math:`A` anzuzeigen, können Sie die 316 Tab-Vervollständigung benutzen. Tippen Sie einfach ``A.``, dann die 317 ``[tab]``-Taste auf Ihrer Tastatur, wie es in 318 :ref:`section-tabcompletion` beschrieben ist. 319 320 Listen, Tupel, und Folgen 321 ========================= 322 323 Der Listen-Datentyp speichert Elemente eines beliebigen Typs. Wie in 324 C, C++, usw. (jedoch anders als in vielen gewöhnlichen 325 Computer-Algebra-Systemen), die Elemente der Liste werden bei 326 :math:`0` beginnend indiziert: 327 328 :: 329 330 sage: v = [2, 3, 5, 'x', SymmetricGroup(3)]; v 331 [2, 3, 5, 'x', Symmetric group of order 3! as a permutation group] 332 sage: type(v) 333 <type 'list'> 334 sage: v[0] 335 2 336 sage: v[2] 337 5 338 339 (Wenn man auf ein Listenelement zugreift ist es OK wenn der Index 340 kein Python int ist!) 341 Mit einem Sage-Integer (oder Rational, oder mit allem anderen mit einer ``__index__`` Methode) 342 funktioniert es genauso. 343 344 :: 345 346 sage: v = [1,2,3] 347 sage: v[2] 348 3 349 sage: n = 2 # SAGE Integer 350 sage: v[n] # Perfectly OK! 351 3 352 sage: v[int(n)] # Also OK. 353 3 354 355 Die ``range``-Funktion erzeugt eine Liste von Python int's (nicht 356 Sage-Integers): 357 358 :: 359 360 sage: range(1, 15) 361 [1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14] 362 363 Dies ist nützlich wenn man List-Comprehensions verwendet um Listen zu 364 konstruieren: 365 366 :: 367 368 sage: L = [factor(n) for n in range(1, 15)] 369 sage: print L 370 [1, 2, 3, 2^2, 5, 2 * 3, 7, 2^3, 3^2, 2 * 5, 11, 2^2 * 3, 13, 2 * 7] 371 sage: L[12] 372 13 373 sage: type(L[12]) 374 <class 'sage.structure.factorization_integer.IntegerFactorization'> 375 sage: [factor(n) for n in range(1, 15) if is_odd(n)] 376 [1, 3, 5, 7, 3^2, 11, 13] 377 378 Um mehr darüber zu erfahren wie man Listen mit Hilfe von 379 List-Comprehensions erzeugt, lesen Sie [PyT]_. 380 381 List-Slicing ist eine wunderbare Eigenschaft. Wenn ``L`` eine Liste 382 ist, dann gibt ``L[m:n]`` die Teilliste von ``L`` zurück, die erhalten 383 wird wenn man mit dem :math:`m^{ten}` Element beginnt und bei dem 384 :math:`(n-1)^{ten}` Element aufhört, wie unten gezeigt wird. 385 386 :: 387 388 sage: L = [factor(n) for n in range(1, 20)] 389 sage: L[4:9] 390 [5, 2 * 3, 7, 2^3, 3^2] 391 sage: print L[:4] 392 [1, 2, 3, 2^2] 393 sage: L[14:4] 394 [] 395 sage: L[14:] 396 [3 * 5, 2^4, 17, 2 * 3^2, 19] 397 398 Tupel sind ähnlich wie Listen, außer dass sie unveränderbar sind, was 399 bedeutet dass sie, sobald sie erzeugt wurden, nicht mehr verändert werden 400 können. 401 402 :: 403 404 sage: v = (1,2,3,4); v 405 (1, 2, 3, 4) 406 sage: type(v) 407 <type 'tuple'> 408 sage: v[1] = 5 409 Traceback (most recent call last): 410 ... 411 TypeError: 'tuple' object does not support item assignment 412 413 Folgen sind ein dritter an Listen angelehnter Sage-Datentyp. Anders 414 als Listen und Tupel, sind Folgen kein gewöhnlicher Python-Datentyp. 415 Standardmäßig sind Folgen veränderbar, mit der 416 ``Sequence``-Klassenmethode ``set_immutable`` können sie auf unveränderbar 417 gestellt werden, wie das folgende Beispiel zeigt. Alle Elemente einer 418 Folge haben einen gemeinsamen Obertyp, der das Folgenuniversum genannt wird. 419 420 :: 421 422 sage: v = Sequence([1,2,3,4/5]) 423 sage: v 424 [1, 2, 3, 4/5] 425 sage: type(v) 426 <class 'sage.structure.sequence.Sequence'> 427 sage: type(v[1]) 428 <type 'sage.rings.rational.Rational'> 429 sage: v.universe() 430 Rational Field 431 sage: v.is_immutable() 432 False 433 sage: v.set_immutable() 434 sage: v[0] = 3 435 Traceback (most recent call last): 436 ... 437 ValueError: object is immutable; please change a copy instead. 438 439 Folgen sind von Listen abgeleitet und können überall dort verwendet werden, wo auch 440 Listen benutzt werden können. 441 442 :: 443 444 sage: v = Sequence([1,2,3,4/5]) 445 sage: isinstance(v, list) 446 True 447 sage: list(v) 448 [1, 2, 3, 4/5] 449 sage: type(list(v)) 450 <type 'list'> 451 452 Ein weiteres Beispiel von unveränderbaren Folgen sind Basen von 453 Vektorräumen. Es ist wichtig, dass sie nicht verändert werden können. 454 455 :: 456 457 sage: V = QQ^3; B = V.basis(); B 458 [ 459 (1, 0, 0), 460 (0, 1, 0), 461 (0, 0, 1) 462 ] 463 sage: type(B) 464 <class 'sage.structure.sequence.Sequence'> 465 sage: B[0] = B[1] 466 Traceback (most recent call last): 467 ... 468 ValueError: object is immutable; please change a copy instead. 469 sage: B.universe() 470 Vector space of dimension 3 over Rational Field 471 472 Dictionaries 473 ============ 474 475 Ein Dictionary (manchmal auch assoziativer Array genannt) ist eine 476 Abbildung von 'hashbaren' Objekten (z.B. Strings, Zahlen und Tupel; 477 Lesen Sie die Python documentation 478 http://docs.python.org/tut/node7.html und 479 http://docs.python.org/lib/typesmapping.html für weitere Details) zu 480 beliebigen Objekten. 481 482 :: 483 484 sage: d = {1:5, 'sage':17, ZZ:GF(7)} 485 sage: type(d) 486 <type 'dict'> 487 sage: d.keys() 488 [1, 'sage', Integer Ring] 489 sage: d['sage'] 490 17 491 sage: d[ZZ] 492 Finite Field of size 7 493 sage: d[1] 494 5 495 496 Der dritte "key" zeigt, dass Indizes eines Dictionaries kompliziert, 497 also beispielsweise der Ring der ganzen Zahlen, sein können. 498 499 Sie können das obige Dictionary auch in eine Liste mit den gleichen 500 Daten umwandeln: 501 502 .. link 503 504 :: 505 506 sage: d.items() 507 [(1, 5), ('sage', 17), (Integer Ring, Finite Field of size 7)] 508 509 Eine häufig vorkommende Ausdrucksweise ist über einem Paar in einem 510 Dictionary zu iterieren: 511 512 :: 513 514 sage: d = {2:4, 4:16, 3:9} 515 sage: [a*b for a, b in d.iteritems()] 516 [8, 27, 64] 517 518 Ein Dictionary ist ungeordnet, wie die letzte Ausgabe verdeutlicht. 519 520 Mengen 521 ====== 522 523 Python hat einen standardmäßigen Mengen-Datentyp. Sein Hauptmerkmal 524 ist, neben weiteren typischen Mengenoperationen, dass das Nachschlagen 525 ob ein Element zu der Menge gehört oder nicht, sehr schnell geht. 526 527 :: 528 529 sage: X = set([1,19,'a']); Y = set([1,1,1, 2/3]) 530 sage: X 531 set(['a', 1, 19]) 532 sage: Y 533 set([1, 2/3]) 534 sage: 'a' in X 535 True 536 sage: 'a' in Y 537 False 538 sage: X.intersection(Y) 539 set([1]) 540 541 Sage besitzt auch einen eigenen Mengen-Datentyp, welcher (manchmal) 542 mit Hilfe des standardmäßigen Python-Mengen-Datentyps implementiert 543 ist, jedoch darüberhinaus manche Sage-spezifischen Funktionen 544 aufweist. Sie können eine Sage-Menge erzeugen indem Sie ``Set(...)`` 545 verwenden. Zum Beispiel, 546 547 :: 548 549 sage: X = Set([1,19,'a']); Y = Set([1,1,1, 2/3]) 550 sage: X 551 {'a', 1, 19} 552 sage: Y 553 {1, 2/3} 554 sage: X.intersection(Y) 555 {1} 556 sage: print latex(Y) 557 \left\{1, \frac{2}{3}\right\} 558 sage: Set(ZZ) 559 Set of elements of Integer Ring 560 561 Iteratoren 562 ========== 563 564 Iteratoren sind seit Version 2.2 ein Teil von Python und erweisen sich 565 in mathematischen Anwendungen als besonders nützlich. Wir geben hier 566 ein paar Beispiele an; Lesen Sie [PyT]_ um weitere Details zu 567 erfahren. Wir erstellen einen Iterator über die Quadrate der 568 nichtnegativen ganzen Zahlen bis :math:`10000000`. 569 570 :: 571 572 sage: v = (n^2 for n in xrange(10000000)) 573 sage: v.next() 574 0 575 sage: v.next() 576 1 577 sage: v.next() 578 4 579 580 Nun erzeugen wir einen Iterator über den Primzahlen der Form :math:`4p+1` 581 wobei auch :math:`p` prim ist und schauen uns die ersten Werte an. 582 583 :: 584 585 sage: w = (4*p + 1 for p in Primes() if is_prime(4*p+1)) 586 sage: w # in the next line, 0xb0853d6c is a random 0x number 587 <generator object at 0xb0853d6c> 588 sage: w.next() 589 13 590 sage: w.next() 591 29 592 sage: w.next() 593 53 594 595 Bestimmte Ringe, z. B. endliche Körper und die ganzen Zahlen, haben 596 zugehörige Iteratoren: 597 598 599 :: 600 601 sage: [x for x in GF(7)] 602 [0, 1, 2, 3, 4, 5, 6] 603 sage: W = ((x,y) for x in ZZ for y in ZZ) 604 sage: W.next() 605 (0, 0) 606 sage: W.next() 607 (0, 1) 608 sage: W.next() 609 (0, -1) 610 611 Schleifen, Funktionen, Kontrollstrukturen und Vergleiche 612 ======================================================== 613 614 Wir haben schon ein paar Beispiele gesehen in denen die 615 ``for``-Schleife üblicherweise Verwendung findet. In Python hat eine 616 ``for``-Schleife eine eingerückte Struktur, wie hier: 617 618 :: 619 620 >>> for i in range(5): 621 print(i) 622 623 0 624 1 625 2 626 3 627 4 628 629 Beachten Sie den Doppelpunkt am Ende der for-Anweisung (dort befindet 630 sich kein "do" oder "od" wie in GAP oder Maple) und die Einrückung 631 vor dem Schleifenrumpf, dem ``print(i)``. Diese Einrückung ist 632 wichtig. In Sage wird die Einrückung automatisch hinzugefügt wenn Sie 633 nach einem ":" die ``enter``-Taste drücken, wie etwa im Folgenden 634 Beispiel. 635 636 :: 637 638 sage: for i in range(5): 639 ... print(i) # now hit enter twice 640 0 641 1 642 2 643 3 644 4 645 646 647 Das Symbol ``=`` wird bei Zuweisungen verwendet. 648 Das Symbol ``==`` wird verwendet um Gleichheit zu testen: 649 650 :: 651 652 sage: for i in range(15): 653 ... if gcd(i,15) == 1: 654 ... print(i) 655 1 656 2 657 4 658 7 659 8 660 11 661 13 662 14 663 664 Behalten Sie im Gedächtnis, dass die Block-Struktur von ``if``, 665 ``for`` und ``while`` Ausdrücken durch die Einrückung bestimmt 666 wird: 667 668 :: 669 670 sage: def legendre(a,p): 671 ... is_sqr_modp=-1 672 ... for i in range(p): 673 ... if a % p == i^2 % p: 674 ... is_sqr_modp=1 675 ... return is_sqr_modp 676 677 sage: legendre(2,7) 678 1 679 sage: legendre(3,7) 680 -1 681 682 Natürlich ist dies keine effiziente Implementierung des 683 Legendre-Symbols! Dies soll nur bestimmte Aspekte won Python/Sage 684 verdeutlichen. Die Funktion {kronecker}, welche zu Sage gehört, 685 berechnet das Legendre-Symbol effizient mittels eines Aufrufs von 686 PARIs C-Bibliothek. 687 688 Schließlich merken wir an, dass Vergleiche wie ``==``, ``!=``, ``<=``, 689 ``>=``, ``>``, ``<`` von zwei Zahlen automatisch beide Zahlen in den 690 gleichen Typ konvertieren, falls dies möglich ist: 691 692 :: 693 694 sage: 2 < 3.1; 3.1 <= 1 695 True 696 False 697 sage: 2/3 < 3/2; 3/2 < 3/1 698 True 699 True 700 701 Fast immer können zwei beliebige Objekte verglichen werden. Es gibt 702 keine Voraussetzung die besagt, dass die Objekte mit einer totalen Ordnung 703 versehen sein müssen. 704 705 706 :: 707 708 sage: 2 < CC(3.1,1) 709 True 710 sage: 5 < VectorSpace(QQ,3) # output can be somewhat random 711 True 712 713 Nutzen Sie bool für symbolische Ungleichungen: 714 715 :: 716 717 sage: x < x + 1 718 x < x + 1 719 sage: bool(x < x + 1) 720 True 721 722 Beim Vergleichen von Objekten unterschiedlichen Typs versucht Sage in 723 den meisten Fällen eine kanonische Umwandlung beider Objekte in einen 724 gemeinsamen Typ zu finden. Falls erfolgreich wird der Vergleich auf den 725 umgewandelten Objekten durchgeführt; Falls nicht erfolgreich werden 726 die Objekte als ungleich angesehen. Um zu Testen, ob zwei Variablen 727 auf das gleiche Objekt zeigen, verwenden Sie ``is``. Zum Beispiel: 728 729 :: 730 731 sage: 1 is 2/2 732 False 733 sage: 1 is 1 734 False 735 sage: 1 == 2/2 736 True 737 738 In den folgenden zwei Zeilen ist der erste Gleichheitstest ``False``, 739 da es keinen kanonischen Morphismus :math:`\QQ\ \to \GF{5}` gibt, 740 also gibt es keine kanonische Möglichkeit die :math:`1` in :math:`\GF{5}` 741 mit der :math:`1 \in \QQ` zu vergleichen. Im Gegensatz dazu gibt es 742 eine kanonische Abbildung :math:`\ZZ \to \GF{5}`, also ist der zweite 743 Gleichheitstest ``True``. Beachten Sie auch, dass die Reihenfolge 744 keine Rolle spielt. 745 746 :: 747 748 sage: GF(5)(1) == QQ(1); QQ(1) == GF(5)(1) 749 False 750 False 751 sage: GF(5)(1) == ZZ(1); ZZ(1) == GF(5)(1) 752 True 753 True 754 sage: ZZ(1) == QQ(1) 755 True 756 757 WARNUNG: Vergleiche in Sage sind restriktiver als in Magma, welches 758 die :math:`1 \in \GF{5}` gleich der :math:`1 \in \QQ` festlegt. 759 760 :: 761 762 sage: magma('GF(5)!1 eq Rationals()!1') # optional magma required 763 true 764 765 Profiling 766 ========= 767 768 Autor des Abschnitts: Martin Albrecht (malb@informatik.uni-bremen.de) 769 770 "Premature optimization is the root of all evil." - Donald Knuth 771 772 773 Manchmal ist es nützlich nach Engstellen im Code zu suchen, um zu 774 verstehen welche Abschnitte die meiste Berechnungszeit beanspruchen; 775 dies kann ein guter Hinweis darauf sein, welche Teile optimiert werden 776 sollten. Python, und daher auch Sage, stellen mehrere "Profiling" -- so 777 wird dieser Prozess genannt -- Optionen zur Verfügung. 778 779 Am einfachsten zu Benutzen ist das ``prun``-Kommando in der 780 interaktiven Shell. Es gibt eine Zusammenfassung zurück, die 781 beschreibt welche Funktionen wie viel Berechnungszeit veranschlagt haben. 782 Um die (zu diesem Zeitpunkt langsame) Matrixmultiplikation über 783 endlichen Körpern zu Profilieren, geben Sie z.B. folgendes ein: 784 785 :: 786 787 sage: k,a = GF(2**8, 'a').objgen() 788 sage: A = Matrix(k,10,10,[k.random_element() for _ in range(10*10)]) 789 790 .. skip 791 792 :: 793 794 sage: %prun B = A*A 795 32893 function calls in 1.100 CPU seconds 796 797 Ordered by: internal time 798 799 ncalls tottime percall cumtime percall filename:lineno(function) 800 12127 0.160 0.000 0.160 0.000 :0(isinstance) 801 2000 0.150 0.000 0.280 0.000 matrix.py:2235(__getitem__) 802 1000 0.120 0.000 0.370 0.000 finite_field_element.py:392(__mul__) 803 1903 0.120 0.000 0.200 0.000 finite_field_element.py:47(__init__) 804 1900 0.090 0.000 0.220 0.000 finite_field_element.py:376(__compat) 805 900 0.080 0.000 0.260 0.000 finite_field_element.py:380(__add__) 806 1 0.070 0.070 1.100 1.100 matrix.py:864(__mul__) 807 2105 0.070 0.000 0.070 0.000 matrix.py:282(ncols) 808 ... 809 810 Hier ist ``ncalls`` die Anzahl der Aufrufe, ``tottime`` ist die 811 Gesamtzeit, die für die Funktion verwendet wurde (ausgenommen der 812 Zeit, die für Unterfunktionsaufrufe verwendet wurde), ``percall`` ist 813 der Quotient von ``tottime`` geteilt durch ``ncalls``. ``cumtime`` 814 ist die Gesamtzeit, die für diese Funktion und alle 815 Unterfunktionsaufrufe (d.h., vom Aufruf bis zum Ende) verwendet 816 wurde, ``percall`` ist der Quotient von ``cumtime`` geteilt durch die 817 Zeit elementarer Funktionsaufrufe, und ``filename:lineno(function)`` 818 stellt die entsprechenden Daten jeder Funktion zur Verfügung. Die 819 Daumenregel ist hier: Je höher die Funktion in dieser Liste steht, 820 desto teurer ist sie. Also ist sie interessanter für Optimierungen. 821 822 Wie sonst auch stellt ``prun?`` Details zur Benutzung des Profilers 823 und zum Verstehen seines Outputs zur Verfügung. 824 825 Die Profilierungsdaten können auch in ein Objekt geschrieben werden um 826 eine weitere Untersuchung zu ermöglichen: 827 828 .. skip 829 830 :: 831 832 sage: %prun -r A*A 833 sage: stats = _ 834 sage: stats? 835 836 Beachten Sie: das Eingeben von ``stats = prun -r A\*A`` erzeugt eine 837 Syntaxfehlermeldung, da prun ein IPython-Shell-Kommando ist und keine 838 reguläre Funktion. 839 840 Um eine schöne graphische Repräsentation der Profilerdaten zu 841 erhalten, können Sie den "hotshot-Profiler", ein kleines Skript 842 genannt ``hotshot2cachetree`` und das Programm ``kcachegrind`` (nur 843 für Unix) benutzen. Hier ist das gleiche Beispiel mit dem "hotshot-Profiler": 844 845 .. skip 846 847 :: 848 849 sage: k,a = GF(2**8, 'a').objgen() 850 sage: A = Matrix(k,10,10,[k.random_element() for _ in range(10*10)]) 851 sage: import hotshot 852 sage: filename = "pythongrind.prof" 853 sage: prof = hotshot.Profile(filename, lineevents=1) 854 855 .. skip 856 857 :: 858 859 sage: prof.run("A*A") 860 <hotshot.Profile instance at 0x414c11ec> 861 sage: prof.close() 862 863 Dies führt zu einer Datei ``pythongrind.prof`` in aktuellen 864 Datenverzeichnis. Diese kann nun zur Visualisierung in das 865 cachegrind-Format konvertiert werden. 866 867 Tippen Sie in einer System-Shell: 868 869 .. skip 870 871 :: 872 873 hotshot2calltree -o cachegrind.out.42 pythongrind.prof 874 875 Die Ausgabedatei ``cachegrind.out.42`` kann nun mit ``kcachegrind`` 876 untersucht werden. Bitte beachten Sie, dass die Namenskonvention 877 ``cachegrind.out.XX`` erhalten bleiben muss. -
new file doc/de/tutorial/sagetex.rst
diff -r 361a4ad7d52c -r aad4d26889c1 doc/de/tutorial/sagetex.rst
- + 1 .. _sec-sagetex: 2 3 ************** 4 SageTeX nutzen 5 ************** 6 7 Das SageTeX Paket ermöglicht es Ihnen die Ergebnisse von Sage Berechnungen 8 direkt in ein LaTeX-Dokument zu setzen. Es wird standardmäßig mit Sage 9 installiert. Um es zu nutzen müssen Sie es lediglich in Ihrem lokalen 10 TeX-System "installieren", wobei "installieren" hier eine einzige Datei 11 kopieren bedeutet. Siehe hierfür auch :ref:`installation` in diesem 12 Tutorial und den Abschnitt "Make SageTeX known to TeX" des `Sage installation guide 13 <http://sagemath.org/doc/installation/index.html>`_ (`dieser Link 14 <../installation/index.html>`_ sollte Sie zu einer lokalen Kopie der 15 Installationsanleitung führen) um weitere Informationen zu erhalten. 16 17 Hier stellen wir ein sehr kurzes Beispiel vor wie man SageTeX nutzt. 18 Die komplette Dokumentation finden Sie unter ``SAGE_ROOT/local/share/texmf/tex/generic/sagetex``, 19 wobei ``SAGE_ROOT`` das Installationsverzeichnis von Sage ist. Dieses Verzeichnis 20 enthält die Dokumentation, eine Beispieldatei und einige nützliche Python Skripte. 21 22 Um zu sehen wie SageTeX funktioniert, folgen Sie den Anweisungen zur Installation von 23 SageTeX (in :ref:`installation`) und kopieren Sie den folgenden Text in eine Datei namens - 24 sagen wir ``st_example.tex``: 25 26 .. warning:: 27 28 Der folgende Text wird mehrere Fehler bezüglich unbekannten Kontrollsequenzen 29 anzeigen, wenn Sie ihn in der "live" Hilfe ansehen. Nutzen Sie stattdessen 30 die statische Version um den korrekten Text zu sehen. 31 32 .. code-block:: latex 33 34 \documentclass{article} 35 \usepackage{sagetex} 36 37 \begin{document} 38 39 Wenn Sie Sage\TeX nutzen, können Sie Sage nutzen um Dinge auszurechen und 40 sie direkt in ein \LaTeX{} Dokument zu setzen. Zum Beispiel gibt es 41 $\sage{number_of_partitions(1269)}$ ganzzahlige Partitionen von $1269$. 42 Sie müssen die Zahl nicht selbst ausrechnen, oder aus einem anderen 43 Programm herauskopieren. 44 45 Hier ein wenig Sage Code: 46 47 \begin{sageblock} 48 f(x) = exp(x) * sin(2*x) 49 \end{sageblock} 50 51 Die zweite Ableitung von $f$ ist 52 53 \[ 54 \frac{\mathrm{d}^{2}}{\mathrm{d}x^{2}} \sage{f(x)} = 55 \sage{diff(f, x, 2)(x)}. 56 \] 57 58 Hier ein Plot von $f$ von $-1$ bis $1$: 59 60 \sageplot{plot(f, -1, 1)} 61 62 \end{document} 63 64 Lassen Sie LaTeX ganz normal über ``st_example.tex`` laufen. Beachten Sie dabei, dass LaTeX 65 sich über einige Dinge beschwert, z.B.:: 66 67 Package sagetex Warning: Graphics file 68 sage-plots-for-st_example.tex/plot-0.eps on page 1 does not exist. Plot 69 command is on input line 25. 70 71 Package sagetex Warning: There were undefined Sage formulas and/or 72 plots. Run Sage on st_example.sage, and then run LaTeX on 73 st_example.tex again. 74 75 Beachten Sie, dass zusätzlich zu den Dateien, die LaTeX normalerweise produziert 76 noch eine Datei ``st_example.sage`` erscheint. Das ist das Sage Skript, das 77 erstellt wurde als Sie LaTeX mit ``st_example.tex`` aufgerufen haben. Wie Ihnen die 78 Warnmeldung mitteilte sollten Sie Sage über die Datei ``st_example.sage`` laufen lassen, 79 also tun Sie das bitte. Ihnen wird gesagt werden, dass Sie LaTeX erneut über die Datei 80 ``st_example.tex`` laufen lassen sollen; bevor Sie dies tun beachten Sie, dass eine neue 81 Datei namens ``st_example.sout`` von Sage erstellt wurde. Diese Datei enthält die Ergebnisse 82 von Sages Berechnungen in einem Format, das LaTeX nutzen kann um es in Ihren Text einzufügen. 83 Ein neues Verzeichnis mit einer .eps Datei Ihres Plots wurde ebenfalls erstellt. 84 Lassen Sie LaTeX nun erneut laufen, und Sie werden sehen, dass alles was Sage berechnet und 85 geplottet hat nun in Ihrem Dokument erscheint. 86 87 Die verschiednenen verwendeten Makros sollten einfach zu verstehen sein. 88 Eine ``sageblock`` Umgebung setzt Ihren Code unverändert und führt ihn auch 89 aus wenn Sie Sage laufen lassen. Wenn Sie etwa ``\sage{foo}`` schreiben, wird 90 das Ergebnis des Aufrufs ``latex(foo)`` (in Sage) in Ihrem Dokument erscheinen. 91 Plot-Befehle sind etwas komplizierter, aber in Ihrer einfachsten Form fügt 92 ``\sageplot{foo}`` das Bild ein, das Sie erhalten wenn Sie ``foo.save('filename.eps')`` 93 in Sage aufrufen würden. 94 95 Grundsätzlich gilt: 96 97 - lassen Sie LaTeX über Ihre .tex Datei laufen; 98 - lassen Sie Sage über die neu generierte .sage Datei laufen; 99 - lassen Sie LaTeX erneut laufen. 100 101 Sie können das Aufrufen von Sage weglassen, wenn Sie keine Änderung 102 an den Sage Befehlen in Ihrem Dokument vorgenommen haben. 103 104 Es gibt noch viel mehr über SageTeX zu sagen, aber da sowohl Sage alsauch 105 LaTeX komplexe und mächtige Werkzeuge sind, sollten Sie die Dokumentation 106 über SageTeX in ``SAGE_ROOT/local/share/texmf/tex/generic/sagetex`` lesen. -
new file doc/de/tutorial/tour.rst
diff -r 361a4ad7d52c -r aad4d26889c1 doc/de/tutorial/tour.rst
- + 1 ********************* 2 Eine begleitende Tour 3 ********************* 4 5 Dieser Abschnitt ist eine begleitende Tour einiger in Sage vorhandener 6 Funktionen. Um viele weitere Beispiele zu sehen, schauen Sie sich 7 `Sage Constructions 8 <http://www.sagemath.org/doc/constructions/index.html>`_ an. Dies ist 9 dazu gedacht, die allgemeine Frage "Wie konstruiere ich ... in Sage?" 10 zu beantworten. Schauen Sie sich auch das `Sage Reference Manual 11 <http://www.sagemath.org/doc/reference/index.html>`_ an, welches 12 Tausende weiterer Beispiele beinhaltet. Beachten Sie auch, dass Sie 13 diese Tour interaktiv im Sage-Notebook durcharbeiten können, 14 indem Sie auf den ``Help`` Link klicken. 15 16 (Falls Sie dieses Tutorial im Sage-Notebook sehen, drücken Sie 17 ``shift-enter`` um die Eingabe-Zellen auszuwerten. Sie können die 18 Eingabe sogar verändern bevor Sie ``shift-enter`` drücken. Auf einigen Macs 19 müssen Sie vielleicht ``shift-return`` anstelle von ``shift-enter`` drücken.) 20 21 .. toctree:: 22 23 tour_assignment 24 tour_help 25 tour_algebra 26 tour_plotting 27 tour_functions 28 tour_rings 29 tour_linalg 30 tour_polynomial 31 tour_groups 32 tour_numtheory 33 tour_advanced -
new file doc/de/tutorial/tour_advanced.rst
diff -r 361a4ad7d52c -r aad4d26889c1 doc/de/tutorial/tour_advanced.rst
- + 1 Etwas weiter fortgeschrittene Mathematik 2 ======================================== 3 4 Algebraische Geometrie 5 ---------------------- 6 7 Sie können in Sage beliebige algebraische Varietäten definieren, aber 8 manchmal ist die nichttriviale Funktionalität auf Ringe über 9 :math:`\QQ` oder endliche Körper beschränkt. Zum Beispiel können wir 10 die Vereinigung zweier affiner, planarer Kurven berechnen, und dann 11 die Kurven als irreduzible Komponenten der Vereinigung zurück erhalten. 12 13 :: 14 15 sage: x, y = AffineSpace(2, QQ, 'xy').gens() 16 sage: C2 = Curve(x^2 + y^2 - 1) 17 sage: C3 = Curve(x^3 + y^3 - 1) 18 sage: D = C2 + C3 19 sage: D 20 Affine Curve over Rational Field defined by 21 x^5 + x^3*y^2 + x^2*y^3 + y^5 - x^3 - y^3 - x^2 - y^2 + 1 22 sage: D.irreducible_components() 23 [ 24 Closed subscheme of Affine Space of dimension 2 over Rational Field defined by: 25 x^2 + y^2 - 1, 26 Closed subscheme of Affine Space of dimension 2 over Rational Field defined by: 27 x^3 + y^3 - 1 28 ] 29 30 Wir können auch alle Punkte im Schnitt der beiden Kurven finden, indem 31 wir diese schneiden und dann die irreduziblen Komponenten berechnen. 32 33 .. link 34 35 :: 36 37 sage: V = C2.intersection(C3) 38 sage: V.irreducible_components() 39 [ 40 Closed subscheme of Affine Space of dimension 2 over Rational Field defined by: 41 y - 1, 42 x, 43 Closed subscheme of Affine Space of dimension 2 over Rational Field defined by: 44 y, 45 x - 1, 46 Closed subscheme of Affine Space of dimension 2 over Rational Field defined by: 47 x + y + 2, 48 2*y^2 + 4*y + 3 49 ] 50 51 Also sind zum Beispiel :math:`(1,0)` und :math:`(0,1)` auf beiden 52 Kurven (wie man sofort sieht), genauso wie bestimmte (quadratischen) 53 Punkte, deren :math:`y` Koordinaten :math:`2y^2 + 4y + 3=0` erfüllen. 54 55 Sage kann auch das torische Ideal der gedrehten Kubik im 56 dreidimensionalen projektiven Raum berechnen: 57 58 59 :: 60 61 sage: R.<a,b,c,d> = PolynomialRing(QQ, 4) 62 sage: I = ideal(b^2-a*c, c^2-b*d, a*d-b*c) 63 sage: F = I.groebner_fan(); F 64 Groebner fan of the ideal: 65 Ideal (b^2 - a*c, c^2 - b*d, -b*c + a*d) of Multivariate Polynomial Ring 66 in a, b, c, d over Rational Field 67 sage: F.reduced_groebner_bases () 68 [[-c^2 + b*d, -b*c + a*d, -b^2 + a*c], 69 [c^2 - b*d, -b*c + a*d, -b^2 + a*c], 70 [c^2 - b*d, b*c - a*d, -b^2 + a*c, -b^3 + a^2*d], 71 [c^2 - b*d, b*c - a*d, b^3 - a^2*d, -b^2 + a*c], 72 [c^2 - b*d, b*c - a*d, b^2 - a*c], 73 [-c^2 + b*d, b^2 - a*c, -b*c + a*d], 74 [-c^2 + b*d, b*c - a*d, b^2 - a*c, -c^3 + a*d^2], 75 [c^3 - a*d^2, -c^2 + b*d, b*c - a*d, b^2 - a*c]] 76 sage: F.polyhedralfan() 77 Polyhedral fan in 4 dimensions of dimension 4 78 79 Elliptische Kurven 80 ------------------ 81 82 Die Funktionalität elliptischer Kurven beinhaltet die meisten von 83 PARIs Funktionen zu elliptischen Kurven, den Zugriff auf die Daten von 84 Cremonas Online-Tabellen (dies benötigt ein optionales 85 Datenbankpaket), die Funktionen von mwrank, d.h. 86 2-Abstiege mit der Berechnung der vollen Mordell-Weil-Gruppe, der SEA 87 Algorithmus, Berechnung aller Isogenien, viel neuem Code für Kurven 88 über :math:`\QQ` und Teile von Denis Simons "algebraic descent" Software. 89 90 Der Befehl ``EllipticCurve`` zum Erzeugen von Elliptischen Kurven hat 91 viele Formen: 92 93 94 - EllipticCurve([:math:`a_1`, :math:`a_2`, :math:`a_3`, :math:`a_4`, :math:`a_6`]): 95 Gibt die elliptische Kurve 96 97 .. math:: y^2+a_1xy+a_3y=x^3+a_2x^2+a_4x+a_6, 98 99 100 zurück, wobei die :math:`a_i`'s umgewandelt werden zum Typ von 101 :math:`a_1`. Falls alle :math:`a_i` den Typ :math:`\ZZ` haben, 102 werden sie zu :math:`\QQ` umgewandelt. 103 104 - EllipticCurve([:math:`a_4`, :math:`a_6`]): Das Gleiche wie oben, 105 jedoch ist :math:`a_1=a_2=a_3=0`. 106 107 - EllipticCurve(label): Gibt die elliptische Kurve aus der Datenbank 108 von Cremona mit dem angegebenen (neuen!) Cremona-Label zurück. Das 109 Label ist ein String, wie z.B. ``"11a"`` oder ``"37b2"``. Die 110 Buchstaben müssen klein geschrieben sein (um sie von dem alten 111 Label unterscheiden zu können). 112 113 - EllipticCurve(j): Gibt die elliptische Kurve mit 114 :math:`j`-Invariante :math:`j` zurück. 115 116 - EllipticCurve(R, 117 [:math:`a_1`, :math:`a_2`, :math:`a_3`, :math:`a_4`, :math:`a_6`]): 118 Erzeugt die elliptische Kurve über dem Ring :math:`R` mit 119 vorgegebenen :math:`a_i`'s wie oben. 120 121 122 Wir veranschaulichen jede dieser Konstruktionen: 123 124 :: 125 126 sage: EllipticCurve([0,0,1,-1,0]) 127 Elliptic Curve defined by y^2 + y = x^3 - x over Rational Field 128 129 sage: EllipticCurve([GF(5)(0),0,1,-1,0]) 130 Elliptic Curve defined by y^2 + y = x^3 + 4*x over Finite Field of size 5 131 132 sage: EllipticCurve([1,2]) 133 Elliptic Curve defined by y^2 = x^3 + x + 2 over Rational Field 134 135 sage: EllipticCurve('37a') 136 Elliptic Curve defined by y^2 + y = x^3 - x over Rational Field 137 138 sage: EllipticCurve_from_j(1) 139 Elliptic Curve defined by y^2 + x*y = x^3 + 36*x + 3455 over Rational Field 140 141 sage: EllipticCurve(GF(5), [0,0,1,-1,0]) 142 Elliptic Curve defined by y^2 + y = x^3 + 4*x over Finite Field of size 5 143 144 Das Paar :math:`(0,0)` ist ein Punkt auf der elliptischen Kurve 145 :math:`E` definiert durch :math:`y^2 + y = x^3 - x`. Um diesen Punkt 146 in Sage zu erzeugen, geben Sie ``E([0,0])`` ein. Sage kann auf einer 147 solchen elliptischen Kurve Punkte addieren (erinnern Sie sich: 148 elliptische Kurven haben eine additive Gruppenstruktur, wobei der unendlich 149 ferne Punkt das Nullelement ist, und drei kollineare Punkte auf 150 der Kurve sich zu Null addieren): 151 152 :: 153 154 sage: E = EllipticCurve([0,0,1,-1,0]) 155 sage: E 156 Elliptic Curve defined by y^2 + y = x^3 - x over Rational Field 157 sage: P = E([0,0]) 158 sage: P + P 159 (1 : 0 : 1) 160 sage: 10*P 161 (161/16 : -2065/64 : 1) 162 sage: 20*P 163 (683916417/264517696 : -18784454671297/4302115807744 : 1) 164 sage: E.conductor() 165 37 166 167 Die elliptischen Kurven über den komplexen Zahlen sind durch die 168 :math:`j`-Invariante parametrisiert. Sage berechnet 169 :math:`j`-Invarianten wie folgt: 170 171 :: 172 173 sage: E = EllipticCurve([0,0,0,-4,2]); E 174 Elliptic Curve defined by y^2 = x^3 - 4*x + 2 over Rational Field 175 sage: E.conductor() 176 2368 177 sage: E.j_invariant() 178 110592/37 179 180 Wenn wir eine Kurve mit der gleichen :math:`j`-Invarianten wie 181 :math:`E` erstellen, muss diese nicht isomorph zu :math:`E` sein. Im 182 folgenden Beispiel sind die Kurven nicht isomorph, da ihre Führer 183 unterschiedlich sind. 184 185 :: 186 187 sage: F = EllipticCurve_from_j(110592/37) 188 sage: F.conductor() 189 37 190 191 Jedoch ergibt der Twist von :math:`F` mit 2 eine isomorphe Kurve. 192 193 .. link 194 195 :: 196 197 sage: G = F.quadratic_twist(2); G 198 Elliptic Curve defined by y^2 = x^3 - 4*x + 2 over Rational Field 199 sage: G.conductor() 200 2368 201 sage: G.j_invariant() 202 110592/37 203 204 Wir können die Koeffizienten :math:`a_n` der zur elliptischen Kurve 205 gehörenden :math:`L`-Reihe oder der Modulform 206 :math:`\sum_{n=0}^\infty a_nq^n` berechnen. 207 Die Berechnung benutzt die PARI C-Bibliothek: 208 209 :: 210 211 sage: E = EllipticCurve([0,0,1,-1,0]) 212 sage: print E.anlist(30) 213 [0, 1, -2, -3, 2, -2, 6, -1, 0, 6, 4, -5, -6, -2, 2, 6, -4, 0, -12, 0, -4, 214 3, 10, 2, 0, -1, 4, -9, -2, 6, -12] 215 sage: v = E.anlist(10000) 216 217 Alle Koeffizienten :math:`a_n` bis zu :math:`n\leq 10^5` zu berechnen 218 dauert nur eine Sekunde: 219 220 .. skip 221 222 :: 223 224 sage: %time v = E.anlist(100000) 225 CPU times: user 0.98 s, sys: 0.06 s, total: 1.04 s 226 Wall time: 1.06 227 228 Elliptische Kurven können mit Hilfe ihres Cremona-Labels konstruiert 229 werden. Dies lädt die Kurve zusammen mit Informationen über ihren Rank, mit 230 Tamagawa Zahlen, Regulatoren, usw.. 231 232 :: 233 234 sage: E = EllipticCurve("37b2") 235 sage: E 236 Elliptic Curve defined by y^2 + y = x^3 + x^2 - 1873*x - 31833 over Rational 237 Field 238 sage: E = EllipticCurve("389a") 239 sage: E 240 Elliptic Curve defined by y^2 + y = x^3 + x^2 - 2*x over Rational Field 241 sage: E.rank() 242 2 243 sage: E = EllipticCurve("5077a") 244 sage: E.rank() 245 3 246 247 Wir können auch direkt auf die Cremona-Datenbank zugreifen. 248 249 :: 250 251 sage: db = sage.databases.cremona.CremonaDatabase() 252 sage: db.curves(37) 253 {'a1': [[0, 0, 1, -1, 0], 1, 1], 'b1': [[0, 1, 1, -23, -50], 0, 3]} 254 sage: db.allcurves(37) 255 {'a1': [[0, 0, 1, -1, 0], 1, 1], 256 'b1': [[0, 1, 1, -23, -50], 0, 3], 257 'b2': [[0, 1, 1, -1873, -31833], 0, 1], 258 'b3': [[0, 1, 1, -3, 1], 0, 3]} 259 260 Die Objekte, die aus der Datenbank zurückgegeben werden, sind nicht 261 vom Typ ``EllipticCurve``. Sie sind Elemente einer Datenbank und haben 262 ein paar Komponenten, und das war's. Es gibt eine kleine Version von 263 Cremonas Datenbank, die standardmäßig zu Sage gehört und beschränkte 264 Information zu elliptischen Kurven mit Führer :math:`\leq 10000` 265 enthält. Es gibt auch eine große optionale Version, welche ausgiebige 266 Daten zu allen elliptischen Kurven mit Führer bis zu :math:`120000` 267 enthält (Stand Oktober 2005). Es gibt auch ein riesiges (2GB großes) 268 optionales Datenbank-Paket für Sage, das in der Stein-Watkins 269 Datenbank hunderte Millionen von elliptischen Kurven enthält. 270 271 Dirichlet-Charaktere 272 -------------------- 273 274 Ein *Dirichlet Charakter* ist die Erweiterung eines Homomorphismus 275 :math:`(\ZZ/N\ZZ)^* \to R^*`, für einen Ring :math:`R`, zu der Abbildung 276 :math:`\ZZ \to R`, welche erhalten wird, wenn man diese ganzen Zahlen :math:`x` 277 mit :math:`\gcd(N,x)>1` nach :math:`0` schickt. 278 279 :: 280 281 sage: G = DirichletGroup(12) 282 sage: G.list() 283 [Dirichlet character modulo 12 of conductor 1 mapping 7 |--> 1, 5 |--> 1, 284 Dirichlet character modulo 12 of conductor 4 mapping 7 |--> -1, 5 |--> 1, 285 Dirichlet character modulo 12 of conductor 3 mapping 7 |--> 1, 5 |--> -1, 286 Dirichlet character modulo 12 of conductor 12 mapping 7 |--> -1, 5 |--> -1] 287 sage: G.gens() 288 (Dirichlet character modulo 12 of conductor 4 mapping 7 |--> -1, 5 |--> 1, 289 Dirichlet character modulo 12 of conductor 3 mapping 7 |--> 1, 5 |--> -1) 290 sage: len(G) 291 4 292 293 Nachdem wir dies Gruppe erzeugt haben, erstellen wir als nächstes ein 294 Element und rechnen damit. 295 296 .. link 297 298 :: 299 300 sage: G = DirichletGroup(21) 301 sage: chi = G.1; chi 302 Dirichlet character modulo 21 of conductor 7 mapping 8 |--> 1, 10 |--> zeta6 303 sage: chi.values() 304 [0, 1, zeta6 - 1, 0, -zeta6, -zeta6 + 1, 0, 0, 1, 0, zeta6, -zeta6, 0, -1, 305 0, 0, zeta6 - 1, zeta6, 0, -zeta6 + 1, -1] 306 sage: chi.conductor() 307 7 308 sage: chi.modulus() 309 21 310 sage: chi.order() 311 6 312 sage: chi(19) 313 -zeta6 + 1 314 sage: chi(40) 315 -zeta6 + 1 316 317 Es ist auch möglich die Operation der Galoisgruppe 318 :math:`\text{Gal}(\QQ(\zeta_N)/\QQ)` auf diesen Charakteren zu 319 berechnen, sowie die Zerlegung in direkte Produkte, die der 320 Faktorisierung des Moduls entsprechen. 321 322 323 .. link 324 325 :: 326 327 sage: chi.galois_orbit() 328 [Dirichlet character modulo 21 of conductor 7 mapping 8 |--> 1, 10 |--> zeta6, 329 Dirichlet character modulo 21 of conductor 7 mapping 8 |--> 1, 10 |--> -zeta6 + 1] 330 331 sage: go = G.galois_orbits() 332 sage: [len(orbit) for orbit in go] 333 [1, 2, 2, 1, 1, 2, 2, 1] 334 335 sage: G.decomposition() 336 [ 337 Group of Dirichlet characters of modulus 3 over Cyclotomic Field of order 338 6 and degree 2, 339 Group of Dirichlet characters of modulus 7 over Cyclotomic Field of order 340 6 and degree 2 341 ] 342 343 Als nächstes konstruieren wir die Gruppe der Dirichlet-Charaktere 344 mod 20, jedoch mit Werten in :math:`\QQ(i)`: 345 346 :: 347 348 sage: K.<i> = NumberField(x^2+1) 349 sage: G = DirichletGroup(20,K) 350 sage: G 351 Group of Dirichlet characters of modulus 20 over Number Field in i with defining polynomial x^2 + 1 352 353 354 Nun berechnen wir mehrere Invarianten von ``G``: 355 356 .. link 357 358 :: 359 360 sage: G.gens() 361 (Dirichlet character modulo 20 of conductor 4 mapping 11 |--> -1, 17 |--> 1, 362 Dirichlet character modulo 20 of conductor 5 mapping 11 |--> 1, 17 |--> i) 363 364 sage: G.unit_gens() 365 [11, 17] 366 sage: G.zeta() 367 i 368 sage: G.zeta_order() 369 4 370 371 In diesem Beispiel erzeugen wir einen Dirichlet-Charakter mit Werten 372 in einem Zahlenfeld. Wir geben die Wahl der Einheitswurzel im dritten 373 Argument von ``DirichletGroup`` an. 374 375 :: 376 377 sage: x = polygen(QQ, 'x') 378 sage: K = NumberField(x^4 + 1, 'a'); a = K.0 379 sage: b = K.gen(); a == b 380 True 381 sage: K 382 Number Field in a with defining polynomial x^4 + 1 383 sage: G = DirichletGroup(5, K, a); G 384 Group of Dirichlet characters of modulus 5 over Number Field in a with 385 defining polynomial x^4 + 1 386 sage: chi = G.0; chi 387 Dirichlet character modulo 5 of conductor 5 mapping 2 |--> a^2 388 sage: [(chi^i)(2) for i in range(4)] 389 [1, a^2, -1, -a^2] 390 391 Hier teilt ``NumberField(x^4 + 1, 'a')`` Sage mit, dass es das Symbol "a" 392 beim Ausgeben dessen was ``K`` ist (ein Zahlenfeld mit definierendem Polynom 393 :math:`x^4 + 1`) benutzen soll. Der Name "a" ist zu diesem Zeitpunkt 394 nicht deklariert. Sobald ``a = K.0`` (oder äquivalent ``a = K.gen()``) 395 evaluiert wurde, repräsentiert das Symbol "a" eine Wurzel des 396 erzeugenden Polynoms :math:`x^4+1`. 397 398 399 Modulformen 400 ------------- 401 402 Sage kann einige Berechnungen im Zusammenhang mit Modulformen 403 durchführen, einschließlich Dimensionsberechnungen, das Berechnen von Räumen von 404 Symbolen von Modulformen, Hecke-Operatoren, und Dekompositionen. 405 406 Es stehen mehrere Funktionen für das Berechnen von Dimensionen von 407 Räumen von Modulformen zur Verfügung. Zum Beispiel, 408 409 :: 410 411 sage: dimension_cusp_forms(Gamma0(11),2) 412 1 413 sage: dimension_cusp_forms(Gamma0(1),12) 414 1 415 sage: dimension_cusp_forms(Gamma1(389),2) 416 6112 417 418 Als nächstes illustrieren wir die Berechnung von Hecke-Operatoren auf 419 einem Raum von Modulformen von Level :math:`1` und Gewicht :math:`12`. 420 421 :: 422 423 sage: M = ModularSymbols(1,12) 424 sage: M.basis() 425 ([X^8*Y^2,(0,0)], [X^9*Y,(0,0)], [X^10,(0,0)]) 426 sage: t2 = M.T(2) 427 sage: t2 428 Hecke operator T_2 on Modular Symbols space of dimension 3 for Gamma_0(1) 429 of weight 12 with sign 0 over Rational Field 430 sage: t2.matrix() 431 [ -24 0 0] 432 [ 0 -24 0] 433 [4860 0 2049] 434 sage: f = t2.charpoly('x'); f 435 x^3 - 2001*x^2 - 97776*x - 1180224 436 sage: factor(f) 437 (x - 2049) * (x + 24)^2 438 sage: M.T(11).charpoly('x').factor() 439 (x - 285311670612) * (x - 534612)^2 440 441 Wir können auch Räume für :math:`\Gamma_0(N)` und :math:`\Gamma_1(N)` 442 erzeugen. 443 444 :: 445 446 sage: ModularSymbols(11,2) 447 Modular Symbols space of dimension 3 for Gamma_0(11) of weight 2 with sign 448 0 over Rational Field 449 sage: ModularSymbols(Gamma1(11),2) 450 Modular Symbols space of dimension 11 for Gamma_1(11) of weight 2 with 451 sign 0 and over Rational Field 452 453 Nun berechnen wir ein paar charakteristische Polynome und 454 :math:`q`-Entwicklungen. 455 456 :: 457 458 sage: M = ModularSymbols(Gamma1(11),2) 459 sage: M.T(2).charpoly('x') 460 x^11 - 8*x^10 + 20*x^9 + 10*x^8 - 145*x^7 + 229*x^6 + 58*x^5 - 360*x^4 461 + 70*x^3 - 515*x^2 + 1804*x - 1452 462 sage: M.T(2).charpoly('x').factor() 463 (x - 3) * (x + 2)^2 * (x^4 - 7*x^3 + 19*x^2 - 23*x + 11) 464 * (x^4 - 2*x^3 + 4*x^2 + 2*x + 11) 465 sage: S = M.cuspidal_submodule() 466 sage: S.T(2).matrix() 467 [-2 0] 468 [ 0 -2] 469 sage: S.q_expansion_basis(10) 470 [ 471 q - 2*q^2 - q^3 + 2*q^4 + q^5 + 2*q^6 - 2*q^7 - 2*q^9 + O(q^10) 472 ] 473 474 Wir können sogar Räume von Modulsymbolen mit Charakteren berechnen. 475 476 :: 477 478 sage: G = DirichletGroup(13) 479 sage: e = G.0^2 480 sage: M = ModularSymbols(e,2); M 481 Modular Symbols space of dimension 4 and level 13, weight 2, character 482 [zeta6], sign 0, over Cyclotomic Field of order 6 and degree 2 483 sage: M.T(2).charpoly('x').factor() 484 (x - 2*zeta6 - 1) * (x - zeta6 - 2) * (x + zeta6 + 1)^2 485 sage: S = M.cuspidal_submodule(); S 486 Modular Symbols subspace of dimension 2 of Modular Symbols space of 487 dimension 4 and level 13, weight 2, character [zeta6], sign 0, over 488 Cyclotomic Field of order 6 and degree 2 489 sage: S.T(2).charpoly('x').factor() 490 (x + zeta6 + 1)^2 491 sage: S.q_expansion_basis(10) 492 [ 493 q + (-zeta6 - 1)*q^2 + (2*zeta6 - 2)*q^3 + zeta6*q^4 + (-2*zeta6 + 1)*q^5 494 + (-2*zeta6 + 4)*q^6 + (2*zeta6 - 1)*q^8 - zeta6*q^9 + O(q^10) 495 ] 496 497 Hier ist ein weiteres Beispiel davon wie Sage mit den Operationen von 498 Hecke-Operatoren auf dem Raum von Modulformen rechnen kann. 499 500 :: 501 502 sage: T = ModularForms(Gamma0(11),2) 503 sage: T 504 Modular Forms space of dimension 2 for Congruence Subgroup Gamma0(11) of 505 weight 2 over Rational Field 506 sage: T.degree() 507 2 508 sage: T.level() 509 11 510 sage: T.group() 511 Congruence Subgroup Gamma0(11) 512 sage: T.dimension() 513 2 514 sage: T.cuspidal_subspace() 515 Cuspidal subspace of dimension 1 of Modular Forms space of dimension 2 for 516 Congruence Subgroup Gamma0(11) of weight 2 over Rational Field 517 sage: T.eisenstein_subspace() 518 Eisenstein subspace of dimension 1 of Modular Forms space of dimension 2 519 for Congruence Subgroup Gamma0(11) of weight 2 over Rational Field 520 sage: M = ModularSymbols(11); M 521 Modular Symbols space of dimension 3 for Gamma_0(11) of weight 2 with sign 522 0 over Rational Field 523 sage: M.weight() 524 2 525 sage: M.basis() 526 ((1,0), (1,8), (1,9)) 527 sage: M.sign() 528 0 529 530 Sei :math:`T_p` die Bezeichnung der gewöhnlichen Hecke-Operatoren (:math:`p` 531 prim). Wie operieren die Hecke-Operatoren :math:`T_2`, :math:`T_3`, 532 :math:`T_5` auf dem Raum der Modulsymbole? 533 534 .. link 535 536 :: 537 538 sage: M.T(2).matrix() 539 [ 3 0 -1] 540 [ 0 -2 0] 541 [ 0 0 -2] 542 sage: M.T(3).matrix() 543 [ 4 0 -1] 544 [ 0 -1 0] 545 [ 0 0 -1] 546 sage: M.T(5).matrix() 547 [ 6 0 -1] 548 [ 0 1 0] 549 [ 0 0 1] -
new file doc/de/tutorial/tour_algebra.rst
diff -r 361a4ad7d52c -r aad4d26889c1 doc/de/tutorial/tour_algebra.rst
- + 1 Elementare Algebra und Analysis 2 =============================== 3 4 Sage kann viele zur elementaren Algebra und Analysis gehörende 5 Probleme lösen. Zum Beispiel: Lösungen von Gleichungen finden, 6 Differentiation, Integration, und Laplace-Transformationen 7 berechnen. Lesen Sie die `Sage Constructions 8 <http://www.sagemath.org/doc/constructions/>`_ Dokumentation um 9 weitere Beispiele zu finden. 10 11 Lösen von Gleichungen 12 --------------------- 13 14 Gleichungen exakt lösen 15 ~~~~~~~~~~~~~~~~~~~~~~~ 16 17 Die ``solve`` Funktion löst Gleichungen. Legen Sie zunächst Variablen 18 an, bevor Sie diese benutzen; Die Argumente von ``solve`` sind eine 19 Gleichung (oder ein System von Gleichungen) zusammen mit den 20 Variablen, nach welchen Sie auflösen möchten: 21 22 :: 23 24 sage: x = var('x') 25 sage: solve(x^2 + 3*x + 2, x) 26 [x == -2, x == -1] 27 28 Sie können eine Gleichung nach einer Variablen, in Abhängigkeit von den 29 anderen, auflösen: 30 31 :: 32 33 sage: x, b, c = var('x b c') 34 sage: solve([x^2 + b*x + c == 0],x) 35 [x == -1/2*b - 1/2*sqrt(b^2 - 4*c), x == -1/2*b + 1/2*sqrt(b^2 - 4*c)] 36 37 Sie können auch nach mehreren Variablen auflösen: 38 39 :: 40 41 sage: x, y = var('x, y') 42 sage: solve([x+y==6, x-y==4], x, y) 43 [[x == 5, y == 1]] 44 45 Das folgende Beispiel, in dem Sage benutzt wird um ein System von 46 nichtlinearen Gleichungen zu lösen, stammt von Jason Grout. Zunächst 47 lösen wir das System symbolisch: 48 49 :: 50 51 sage: var('x y p q') 52 (x, y, p, q) 53 sage: eq1 = p+q==9 54 sage: eq2 = q*y+p*x==-6 55 sage: eq3 = q*y^2+p*x^2==24 56 sage: solve([eq1,eq2,eq3,p==1],p,q,x,y) 57 [[p == 1, q == 8, x == -4/3*sqrt(10) - 2/3, y == 1/6*sqrt(2)*sqrt(5) - 2/3], 58 [p == 1, q == 8, x == 4/3*sqrt(10) - 2/3, y == -1/6*sqrt(2)*sqrt(5) - 2/3]] 59 60 Um eine numerische Approximation der Lösungen zu erhalten können Sie 61 stattdessen wie folgt vorgehen: 62 63 .. link 64 65 :: 66 67 sage: solns = solve([eq1,eq2,eq3,p==1],p,q,x,y, solution_dict=True) 68 sage: [[s[p].n(30), s[q].n(30), s[x].n(30), s[y].n(30)] for s in solns] 69 [[1.0000000, 8.0000000, -4.8830369, -0.13962039], 70 [1.0000000, 8.0000000, 3.5497035, -1.1937129]] 71 72 (Die Funktion ``n`` gibt eine numerische Approximation zurück, ihr 73 Argument ist die Anzahl der Bits an Genauigkeit.) 74 75 Gleichungen numerisch lösen 76 ~~~~~~~~~~~~~~~~~~~~~~~~~~~ 77 78 Oftmals kann ``solve`` keine exakte Lösung der angegebenen Gleichung 79 bzw. Gleichungen finden. Wenn dies passiert können Sie ``find_root`` 80 verwenden um eine numerische Approximation zu finden. Beispielsweise 81 gibt ``solve`` bei folgender Gleichung nichts brauchbares zurück:: 82 83 sage: theta = var('theta') 84 sage: solve(cos(theta)==sin(theta), theta) 85 [sin(theta) == cos(theta)] 86 87 Wir können jedoch ``find_root`` verwenden um eine Lösung der obigen 88 Gleichung im Bereich :math:`0 < \phi < \pi/2` zu finden:: 89 90 sage: phi = var('phi') 91 sage: find_root(cos(phi)==sin(phi),0,pi/2) 92 0.785398163397448... 93 94 Differentiation, Integration, etc. 95 ---------------------------------- 96 97 Sage weiß wie man viele Funktionen differenziert und integriert. Zum 98 Beispiel können Sie folgendes eingeben um :math:`\sin(u)` nach 99 :math:`u` abzuleiten: 100 101 :: 102 103 sage: u = var('u') 104 sage: diff(sin(u), u) 105 cos(u) 106 107 Um die vierte Ableitung :math:`\sin(x^2)` zu berechnen: 108 109 :: 110 111 sage: diff(sin(x^2), x, 4) 112 16*x^4*sin(x^2) - 48*x^2*cos(x^2) - 12*sin(x^2) 113 114 Um die partiellen Ableitungen von :math:`x^2+17y^2` nach *x* 115 beziehungsweise *y* zu berechnen: 116 117 :: 118 119 sage: x, y = var('x,y') 120 sage: f = x^2 + 17*y^2 121 sage: f.diff(x) 122 2*x 123 sage: f.diff(y) 124 34*y 125 126 Wir machen weiter mit Integralen, sowohl bestimmt als auch 127 unbestimmt. Die Berechnung von :math:`\int x\sin(x^2)\, dx` und 128 :math:`\int_0^1 \frac{x}{x^2+1}\, dx`: 129 130 :: 131 132 sage: integral(x*sin(x^2), x) 133 -1/2*cos(x^2) 134 sage: integral(x/(x^2+1), x, 0, 1) 135 1/2*log(2) 136 137 Die Partialbruchzerlegung von :math:`\frac{1}{x^2-1}`: 138 139 :: 140 141 sage: f = 1/((1+x)*(x-1)) 142 sage: f.partial_fraction(x) 143 1/2/(x - 1) - 1/2/(x + 1) 144 145 .. _section-systems: 146 147 Lösen von Differentialgleichungen 148 --------------------------------- 149 150 Sie können Sage verwenden um gewöhnliche Differentialgleichungen zu 151 berechnen. Die Gleichung :math:`x'+x-1=0` berechnen Sie wie folgt: 152 153 :: 154 155 sage: t = var('t') # definiere die Variable t 156 sage: x = function('x',t) # definiere x als Funktion dieser Variablen 157 sage: DE = diff(x, t) + x - 1 158 sage: desolve(DE, [x,t]) 159 (c + e^t)*e^(-t) 160 161 Dies benutzt Sages Schnittstelle zu Maxima [Max]_, daher kann sich die 162 Ausgabe ein wenig von anderen Ausgaben in Sage unterscheiden. In 163 diesem Fall wird mitgeteilt, dass :math:`x(t) = e^{-t}(e^{t}+c)` 164 die allgemeine Lösung der Differentialgleichung ist. 165 166 Sie können auch Laplace-Transformationen berechnen: 167 Die Laplace-Transformation von :math:`t^2e^t -\sin(t)` wird wie folgt 168 berechnet: 169 170 :: 171 172 sage: s = var("s") 173 sage: t = var("t") 174 sage: f = t^2*exp(t) - sin(t) 175 sage: f.laplace(t,s) 176 2/(s - 1)^3 - 1/(s^2 + 1) 177 178 Hier ist ein komplizierteres Beispiel. Die Verschiebung des 179 Gleichgewichts einer verkoppelten Feder, die an der linken Wand 180 befestigt ist, 181 182 :: 183 184 |------\/\/\/\/\---|Masse1|----\/\/\/\/\/----|Masse2| 185 Feder1 Feder2 186 187 wird durch dieses System der Differentialgleichungen zweiter Ordnung 188 modelliert, 189 190 .. math:: 191 192 m_1 x_1'' + (k_1+k_2) x_1 - k_2 x_2 = 0 193 194 m_2 x_2''+ k_2 (x_2-x_1) = 0, 195 196 197 198 wobei :math:`m_{i}` die Masse des Objekts *i*, :math:`x_{i}` die 199 Verschiebung des Gleichgewichts der Masse *i* und :math:`k_{i}` die 200 Federkonstante der Feder *i* ist. 201 202 **Beispiel:** Benutzen Sie Sage um das obige Problem mit folgenden 203 Werten zu lösen: 204 :math:`m_{1}=2`, :math:`m_{2}=1`, :math:`k_{1}=4`, 205 :math:`k_{2}=2`, :math:`x_{1}(0)=3`, :math:`x_{1}'(0)=0`, 206 :math:`x_{2}(0)=3`, :math:`x_{2}'(0)=0`. 207 208 Lösung: Berechnen Sie die Laplace-Transformierte der ersten Gleichung 209 (mit der Notation :math:`x=x_{1}`, :math:`y=x_{2}`): 210 211 :: 212 213 sage: de1 = maxima("2*diff(x(t),t, 2) + 6*x(t) - 2*y(t)") 214 sage: lde1 = de1.laplace("t","s"); lde1 215 2*(-?%at('diff(x(t),t,1),t=0)+s^2*'laplace(x(t),t,s)-x(0)*s)-2*'laplace(y(t),t,s)+6*'laplace(x(t),t,s) 216 217 Das ist schwierig zu lesen, es besagt jedoch, dass 218 219 .. math:: -2x'(0) + 2s^2*X(s) - 2sx(0) - 2Y(s) + 6X(s) = 0 220 221 222 (wobei die Laplace-Transformierte der Funktion mit kleinem 223 Anfangsbuchstaben :math:`x(t)` die Funktion mit großem 224 Anfangsbuchstaben :math:`X(s)` ist). Berechnen Sie die 225 Laplace-Transformierte der zweiten Gleichung: 226 227 :: 228 229 sage: de2 = maxima("diff(y(t),t, 2) + 2*y(t) - 2*x(t)") 230 sage: lde2 = de2.laplace("t","s"); lde2 231 -?%at('diff(y(t),t,1),t=0)+s^2*'laplace(y(t),t,s)+2*'laplace(y(t),t,s)-2*'laplace(x(t),t,s)-y(0)*s 232 233 Dies besagt 234 235 .. math:: -Y'(0) + s^2Y(s) + 2Y(s) - 2X(s) - sy(0) = 0. 236 237 238 Setzen Sie die Anfangsbedingungen für :math:`x(0)`, :math:`x'(0)`, 239 :math:`y(0)` und :math:`y'(0)` ein, und lösen die beiden Gleichungen, 240 die Sie so erhalten: 241 242 :: 243 244 sage: var('s X Y') 245 (s, X, Y) 246 sage: eqns = [(2*s^2+6)*X-2*Y == 6*s, -2*X +(s^2+2)*Y == 3*s] 247 sage: solve(eqns, X,Y) 248 [[X == 3*(s^3 + 3*s)/(s^4 + 5*s^2 + 4), 249 Y == 3*(s^3 + 5*s)/(s^4 + 5*s^2 + 4)]] 250 251 Berechnen Sie jetzt die inverse Laplace-Transformierte um die Antwort 252 zu erhalten: 253 254 :: 255 256 sage: var('s t') 257 (s, t) 258 sage: inverse_laplace((3*s^3 + 9*s)/(s^4 + 5*s^2 + 4),s,t) 259 cos(2*t) + 2*cos(t) 260 sage: inverse_laplace((3*s^3 + 15*s)/(s^4 + 5*s^2 + 4),s,t) 261 -cos(2*t) + 4*cos(t) 262 263 Also ist die Lösung: 264 265 .. math:: x_1(t) = \cos(2t) + 2\cos(t), \quad x_2(t) = 4\cos(t) - \cos(2t). 266 267 268 Die kann folgenderweise parametrisiert geplottet werden: 269 270 :: 271 272 sage: t = var('t') 273 sage: P = parametric_plot((cos(2*t) + 2*cos(t), 4*cos(t) - cos(2*t) ),\ 274 ... (t, 0, 2*pi), rgbcolor=hue(0.9)) 275 sage: show(P) 276 277 Die einzelnen Komponenten können so geplottet werden: 278 279 :: 280 281 sage: t = var('t') 282 sage: p1 = plot(cos(2*t) + 2*cos(t), (t,0, 2*pi), rgbcolor=hue(0.3)) 283 sage: p2 = plot(4*cos(t) - cos(2*t), (t,0, 2*pi), rgbcolor=hue(0.6)) 284 sage: show(p1 + p2) 285 286 Um mehr über das Plotten zu erfahren lesen Sie :ref:`section-plot`. Lesen 287 Sie Abschnitt 5.5 von [NagleEtAl2004]_ um weitere Informationen über 288 Differentialgleichungen zu erhalten. 289 290 291 Das Euler-Verfahren zur Lösung von Systemen von Differentialgleichungen 292 ----------------------------------------------------------------------- 293 294 Im nächsten Beispiel illustrieren wir das Euler-Verfahren für ODEs erster 295 und zweiter Ordnung. Wir rufen zunächst die grundlegende Idee für 296 Differentialgleichungen erster Ordnung in Erinnerung. Sei ein 297 Anfangswertproblem der Form 298 299 .. math:: 300 301 y'=f(x,y), \quad y(a)=c, 302 303 gegeben. Wir möchten eine Approximation des Wertes der Lösung bei 304 :math:`x=b` mit :math:`b>a` finden. 305 306 Machen Sie sich anhand der Definition der Ableitung klar, dass 307 308 .. math:: y'(x) \approx \frac{y(x+h)-y(x)}{h}, 309 310 311 wobei :math:`h>0` vorgegeben und klein ist. Zusammen mit der 312 Differentialgleichung gibt dies :math:`f(x,y(x))\approx 313 \frac{y(x+h)-y(x)}{h}`. Jetzt lösen wir nach :math:`y(x+h)` auf: 314 315 .. math:: y(x+h) \approx y(x) + h*f(x,y(x)). 316 317 318 Wenn wir :math:`h f(x,y(x))` den "Korrekturterm", :math:`y(x)` den 319 "alten Wert von *y*" und :math:`y(x+h)` den "neuen Wert von *y*" 320 nennen, kann diese Approximation neu ausgedrückt werden als: 321 322 .. math:: y_{new} \approx y_{old} + h*f(x,y_{old}). 323 324 325 Wenn wir das Intervall von *a* bis *b* in *n* Teilintervalle 326 aufteilen, so dass :math:`h=\frac{b-a}{n}` gilt, können wir die 327 Information in folgender Tabelle festhalten. 328 329 ============== ================== ================ 330 :math:`x` :math:`y` :math:`hf(x,y)` 331 ============== ================== ================ 332 :math:`a` :math:`c` :math:`hf(a,c)` 333 :math:`a+h` :math:`c+hf(a,c)` ... 334 :math:`a+2h` ... 335 ... 336 :math:`b=a+nh` ??? ... 337 ============== ================== ================ 338 339 340 Unser Ziel ist zeilenweise alle leeren Einträge der Tabelle 341 auszufüllen, bis wir den Eintrag ??? erreichen, welcher die 342 Approximation des Euler-Verfahrens für :math:`y(b)` ist. 343 344 Die Idee für Systeme von ODEs ist ähnlich. 345 346 **Beispiel:** Approximiere :math:`z(t)`, mit 4 Schritten der 347 Eulermethode numerisch bei :math:`t=1` , wobei :math:`z''+tz'+z=0`, 348 :math:`z(0)=1` und :math:`z'(0)=0` ist. 349 350 Wir müssen die ODE zweiter Ordnung auf ein System von zwei 351 Differentialgleichungen erster Ordnung reduzieren (wobei :math:`x=z`, 352 :math:`y=z'`) und das Euler-Verfahren anwenden: 353 354 :: 355 356 sage: t,x,y = PolynomialRing(RealField(10),3,"txy").gens() 357 sage: f = y; g = -x - y * t 358 sage: eulers_method_2x2(f,g, 0, 1, 0, 1/4, 1) 359 t x h*f(t,x,y) y h*g(t,x,y) 360 0 1 0.00 0 -0.25 361 1/4 1.0 -0.062 -0.25 -0.23 362 1/2 0.94 -0.12 -0.48 -0.17 363 3/4 0.82 -0.16 -0.66 -0.081 364 1 0.65 -0.18 -0.74 0.022 365 366 Also ist :math:`z(1)\approx 0.75`. 367 368 Wir können auch die Punkte :math:`(x,y)` plotten um ein ungefähres 369 Bild der Kurve zu erhalten. Die Funktion ``eulers_method_2x2_plot`` 370 macht dies; um sie zu benutzen, müssen wir die Funktionen *f* und *g* 371 definieren, welche ein Argument mit drei Koordinaten (*t*, *x*, *y*) 372 erwarten. 373 374 :: 375 376 sage: f = lambda z: z[2] # f(t,x,y) = y 377 sage: g = lambda z: -sin(z[1]) # g(t,x,y) = -sin(x) 378 sage: P = eulers_method_2x2_plot(f,g, 0.0, 0.75, 0.0, 0.1, 1.0) 379 380 Zu diesem Zeitpunkt enthält ``P`` die beiden Plots ``P[0]`` (der Plot 381 von *x* nach *t*) und ``P[1]`` (der Plot von *y* nach *t*). Wir können 382 beide wie folgt anzeigen: 383 384 .. link 385 386 :: 387 388 sage: show(P[0] + P[1]) 389 390 (Um mehr über das Plotten zu erfahren, lesen Sie :ref:`section-plot`.) 391 392 Spezielle Funktionen 393 -------------------- 394 395 Mehrere orthogonale Polynome und spezielle Funktionen sind 396 implementiert, wobei sowohl PARI [GP]_ als auch Maxima [Max]_ 397 verwendet wird. Sie sind in den dazugehörigen Abschnitten ("Orthogonal polynomials" 398 beziehungsweise "Special functions") des Sage Referenzhandbuchs dokumentiert. 399 400 :: 401 402 sage: x = polygen(QQ, 'x') 403 sage: chebyshev_U(2,x) 404 4*x^2 - 1 405 sage: bessel_I(1,1,"pari",250) 406 0.56515910399248502720769602760986330732889962162109200948029448947925564096 407 sage: bessel_I(1,1) 408 0.565159103992485 409 sage: bessel_I(2,1.1,"maxima") # last few digits are random 410 0.16708949925104899 411 412 Zum jetzigen Zeitpunkt, enthält Sage nur Wrapper-Funktionen für 413 numerische Berechnungen. Um symbolisch zu rechen, rufen Sie die 414 Maxima-Schnittstelle bitte, wie im folgenden Beispiel, direkt auf 415 416 :: 417 418 sage: maxima.eval("f:bessel_y(v, w)") 419 'bessel_y(v,w)' 420 sage: maxima.eval("diff(f,w)") 421 '(bessel_y(v-1,w)-bessel_y(v+1,w))/2' -
new file doc/de/tutorial/tour_assignment.rst
diff -r 361a4ad7d52c -r aad4d26889c1 doc/de/tutorial/tour_assignment.rst
- + 1 Zuweisung, Gleichheit und Arithmetik 2 ==================================== 3 4 Bis auf wenige Ausnahmen benutzt Sage die Programmiersprache Python, 5 deshalb werden Ihnen die meisten einführenden Bücher über Python dabei 6 helfen Sage zu lernen. 7 8 Sage benutzt ``=`` für Zuweisungen und ``==``, ``<=``, ``>=``, 9 ``<`` und ``>`` für Vergleiche. 10 11 :: 12 13 sage: a = 5 14 sage: a 15 5 16 sage: 2 == 2 17 True 18 sage: 2 == 3 19 False 20 sage: 2 < 3 21 True 22 sage: a == 5 23 True 24 25 Sage unterstützt alle grundlegenden mathematischen Operationen: 26 27 :: 28 29 sage: 2**3 # ** bedeutet hoch 30 8 31 sage: 2^3 # ^ ist ein Synonym für ** (anders als in Python) 32 8 33 sage: 10 % 3 # für ganzzahlige Argumente bedeutet % mod, d.h. Restbildung 34 1 35 sage: 10/4 36 5/2 37 sage: 10//4 # für ganzzahlige Argumente gibt // den \ 38 ....: # ganzzahligen Quotienten zurück 39 2 40 sage: 4 * (10 // 4) + 10 % 4 == 10 41 True 42 sage: 3^2*4 + 2%5 43 38 44 45 Die Berechnung eines Ausdrucks wie ``3^2*4 + 2%5`` hängt von der 46 Reihenfolge ab, in der die Operationen ausgeführt werden. Dies wird in 47 der "Operatorrangfolge-Tabelle" in :ref:`section-precedence` festgelegt. 48 49 Sage stellt auch viele bekannte mathematische Funktionen zur 50 Verfügung; hier sind nur ein paar Beispiele 51 52 :: 53 54 sage: sqrt(3.4) 55 1.84390889145858 56 sage: sin(5.135) 57 -0.912021158525540 58 sage: sin(pi/3) 59 1/2*sqrt(3) 60 61 Wie das letzte Beispiel zeigt, geben manche mathematische Ausdrücke 62 'exakte' Werte anstelle von numerischen Approximationen zurück. Um 63 eine numerische Approximation zu bekommen, können Sie entweder die 64 Funktion ``n`` oder die Methode ``n`` verwenden (beide haben auch 65 den längeren Namen, ``numerical_approx``, und die Funktion ``N`` ist 66 die gleiche wie ``n``). Diese nehmen auch die optionalen Argumente 67 ``prec``, welches die gewünschte Anzahl von Bit an Genauigkeit ist und 68 ``digits``, welches die gewünschte Anzahl Dezimalstellen an Genauigkeit 69 ist, entgegen; der Standardwert ist 53 Bit Genauigkeit. 70 71 :: 72 73 sage: exp(2) 74 e^2 75 sage: n(exp(2)) 76 7.38905609893065 77 sage: sqrt(pi).numerical_approx() 78 1.77245385090552 79 sage: sin(10).n(digits=5) 80 -0.54402 81 sage: N(sin(10),digits=10) 82 -0.5440211109 83 sage: numerical_approx(pi, prec=200) 84 3.1415926535897932384626433832795028841971693993751058209749 85 86 Python ist dynamisch typisiert, also ist dem Wert, auf den jede Variable 87 weist, ein Typ zugeordnet; jedoch darf eine Variable Werte eines 88 beliebigen Python-Typs innerhalb eines Sichtbarkeitsbereich aufnehmen. 89 90 :: 91 92 sage: a = 5 # a ist eine ganze Zahl 93 sage: type(a) 94 <type 'sage.rings.integer.Integer'> 95 sage: a = 5/3 # jetzt ist a eine rationale Zahl 96 sage: type(a) 97 <type 'sage.rings.rational.Rational'> 98 sage: a = 'hello' # jetzt ist a ein String 99 sage: type(a) 100 <type 'str'> 101 102 Die Programmiersprache C, welche statisch typisiert ist, unterscheidet 103 sich hierzu stark; eine Variable, die dazu deklariert ist eine Ganzzahl (int) 104 aufzunehmen, kann in ihrem Sichtbarkeitsbereich auch nur ganze Zahlen aufnehmen. 105 106 Für Verwirrung in Python sorgt häufig, dass Integer Literale, die mit 107 Null beginnen als Oktalzahl, d.h. als Zahl zur Basis 8, behandelt werden. 108 109 :: 110 111 sage: 011 112 9 113 sage: 8 + 1 114 9 115 sage: n = 011 116 sage: n.str(8) # Darstellung von n als String zur Basis 8 117 '11' 118 119 Dies ist konsistent mit der Programmiersprache C. -
new file doc/de/tutorial/tour_functions.rst
diff -r 361a4ad7d52c -r aad4d26889c1 doc/de/tutorial/tour_functions.rst
- + 1 s.. _section-functions-issues: 2 3 Häufige Probleme mit Funktionen 4 =============================== 5 6 Das Definieren von Funktionen kann in mancher Hinsicht verwirrend sein 7 (z.B. beim Ableiten oder Plotten). In diesem Abschnitt versuchen wir 8 die relevanten Probleme anzusprechen. 9 10 Nun erläutern wir verschiedene Möglichkeiten Dinge zu definieren, die das 11 Recht haben könnten "Funktionen" genannt zu werden: 12 13 1. Definition einer Python-Funktion wie in :ref:`section-functions` 14 beschrieben. Diese Funktionen können geplottet, aber nicht abgeleitet 15 oder integriert werden. 16 17 :: 18 19 sage: def f(z): return z^2 20 sage: type(f) 21 <type 'function'> 22 sage: f(3) 23 9 24 sage: plot(f, 0, 2) 25 26 Beachten Sie die Syntax in der letzten Zeile. Falls Sie stattdessen 27 ``plot(f(z), 0, 2)`` verwenden, erhalten Sie einen Fehler, da ``z`` 28 eine Dummy-Variable in der Definition von ``f`` ist, und außerhalb 29 dieser nicht definiert ist. In der Tat gibt sogar nur ``f(z)`` einen 30 Fehler zurück. Das Folgende funktioniert in diesem Fall, obwohl es im 31 Allgemeinen Probleme verursachen kann und deshalb vermieden werden 32 sollte. (Beachten Sie unten den 4. Punkt) 33 34 .. link 35 36 :: 37 38 sage: var('z') # z wird als Variable definiert 39 z 40 sage: f(z) 41 z^2 42 sage: plot(f(z), 0, 2) 43 44 Nun ist `f(z)`` ein symbolischer Ausdruck. Dies ist unser nächster Stichpunkt 45 unserer Aufzählung. 46 47 2. Definition eines "aufrufbaren symbolischen Ausdrucks". Diese 48 können geplottet, differenziert und integriert werden. 49 50 :: 51 52 sage: g(x) = x^2 53 sage: g # g bildet x auf x^2 ab 54 x |--> x^2 55 sage: g(3) 56 9 57 sage: Dg = g.derivative(); Dg 58 x |--> 2*x 59 sage: Dg(3) 60 6 61 sage: type(g) 62 <type 'sage.symbolic.expression.Expression'> 63 sage: plot(g, 0, 2) 64 65 Beachten Sie, dass während ``g`` ein aufrufbarer symbolischer Ausdruck 66 ist, ``g(x)`` ein verwandtes aber unterschiedliches Objekt ist, 67 welches auch geplottet, differenziert, usw. werden kann - wenn auch 68 mit einigen Problemen: Lesen Sie den 5. Stichpunkt unterhalb, um eine 69 Erläuterung zu erhalten. 70 71 .. link 72 73 :: 74 75 sage: g(x) 76 x^2 77 sage: type(g(x)) 78 <type 'sage.symbolic.expression.Expression'> 79 sage: g(x).derivative() 80 2*x 81 sage: plot(g(x), 0, 2) 82 83 3. Benutzung einer vordefinierten 'trigonometrischen Sage-Funktion'. 84 Diese können mit ein wenig Hilfestellung differenziert und integriert 85 werden. 86 87 :: 88 89 sage: type(sin) 90 <class 'sage.functions.trig.Function_sin'> 91 sage: plot(sin, 0, 2) 92 sage: type(sin(x)) 93 <type 'sage.symbolic.expression.Expression'> 94 sage: plot(sin(x), 0, 2) 95 96 Alleinestehend kann ``sin`` nicht differenziert werden, zumindest nicht 97 um ``cos`` zu erhalten. 98 99 :: 100 101 sage: f = sin 102 sage: f.derivative() 103 Traceback (most recent call last): 104 ... 105 AttributeError: ... 106 107 ``f = sin(x)`` anstelle von ``sin`` zu benutzen funktioniert, aber 108 es ist wohl noch besser ``f(x) = sin(x)`` zu benutzen, um einen 109 aufrufbaren symbolischen Ausdruck zu definieren. 110 111 :: 112 113 sage: S(x) = sin(x) 114 sage: S.derivative() 115 x |--> cos(x) 116 117 Hier sind ein paar häufige Probleme mit Erklärungen: 118 119 \4. Versehentliche Auswertung. 120 121 :: 122 123 sage: def h(x): 124 ... if x<2: 125 ... return 0 126 ... else: 127 ... return x-2 128 129 Das Problem: ``plot(h(x), 0, 4)`` zeichnet die Linie `y=x-2` und nicht 130 die mehrzeilige Funktion, welche durch ``h`` definiert wird. Der 131 Grund? In dem Befehl ``plot(h(x), 0, 4)`` wird zuerst ``h(x)`` 132 ausgewertet: Das bedeutet, dass ``x`` in die Funktion ``h`` eingesetzt 133 wird, was wiederum bedeutet, dass ``x<2`` ausgewertet wird. 134 135 .. link 136 137 :: 138 139 sage: type(x<2) 140 <type 'sage.symbolic.expression.Expression'> 141 142 Wenn eine symbolische Gleichung ausgewertet wird, wie in der 143 Definition von ``h``, wird falls sie nicht offensichtlicherweise wahr 144 ist, False zurück gegeben. Also wird ``h(x)`` zu ``x-2`` ausgewertet 145 und dies ist die Funktion, die geplottet wird. 146 147 Die Lösung: verwenden Sie nicht ``plot(h(x), 0, 4)``; benutzen Sie stattdessen: 148 149 .. link 150 151 :: 152 153 sage: plot(h, 0, 4) 154 155 \5. Versehentliches Erzeugen einer Konstanten anstelle von einer Funktion. 156 157 :: 158 159 sage: f = x 160 sage: g = f.derivative() 161 sage: g 162 1 163 164 Das Problem: ``g(3)``, zum Beispiel, gibt folgenden Fehler zurück: 165 "ValueError: the number of arguments must be less than or equal to 0." 166 167 .. link 168 169 :: 170 171 sage: type(f) 172 <type 'sage.symbolic.expression.Expression'> 173 sage: type(g) 174 <type 'sage.symbolic.expression.Expression'> 175 176 ``g`` ist keine Funktion, es ist eine Konstante, hat also keine 177 zugehörigen Variablen, und man kann in sie nichts einsetzen. 178 179 Die Lösung: Es gibt mehrere Möglichkeiten. 180 181 - Definieren Sie ``f`` anfangs als symbolischen Ausdruck. 182 183 :: 184 185 sage: f(x) = x # statt 'f = x' 186 sage: g = f.derivative() 187 sage: g 188 x |--> 1 189 sage: g(3) 190 1 191 sage: type(g) 192 <type 'sage.symbolic.expression.Expression'> 193 194 - Oder mit der ursprünglichen Definition von ``f``, definieren Sie 195 ``g`` als symbolischen Ausdruck. 196 197 :: 198 199 sage: f = x 200 sage: g(x) = f.derivative() # statt 'g = f.derivative()' 201 sage: g 202 x |--> 1 203 sage: g(3) 204 1 205 sage: type(g) 206 <type 'sage.symbolic.expression.Expression'> 207 208 - Oder mit den ursprünglichen Definitionen von ``f`` and ``g``, geben 209 Sie die Variable an, in diese Sie den Wert einsetzen. 210 211 :: 212 213 sage: f = x 214 sage: g = f.derivative() 215 sage: g 216 1 217 sage: g(x=3) # statt 'g(3)' 218 1 219 220 Schließlich ist hier noch eine Möglichkeit den Unterschied zwischen der 221 Ableitung von ``f = x`` und der von ``f(x) = x`` zu erkennen: 222 223 :: 224 225 sage: f(x) = x 226 sage: g = f.derivative() 227 sage: g.variables() # Die in g präsenten Variablen 228 () 229 sage: g.arguments() # Die Argumente die in g gesteckt werden können 230 (x,) 231 sage: f = x 232 sage: h = f.derivative() 233 sage: h.variables() 234 () 235 sage: h.arguments() 236 () 237 238 Wie dieses Beispiel verdeutlichen sollte, nimmt ``h`` keine Argumente 239 an, und deshalb gibt ``h(3)`` einen Fehler zurück. -
new file doc/de/tutorial/tour_groups.rst
diff -r 361a4ad7d52c -r aad4d26889c1 doc/de/tutorial/tour_groups.rst
- + 1 Endliche und abelsche Gruppen 2 ============================= 3 4 Sage unterstützt das Rechnen mit Permutationsgruppen, 5 endlichen klassischen Gruppen (wie z.B. :math:`SU(n,q)`), endlichen 6 Matrixgruppen (mit Ihren eigenen Erzeugern), und abelschen Gruppen 7 (sogar unendlichen). Vieles davon ist mit Hilfe der GAP-Schnittstelle 8 implementiert. 9 10 Zum Beispiel können Sie, um eine Permuationsgruppe zu erzeugen, die 11 Liste der Erzeuger wie folgt angeben. 12 13 :: 14 15 sage: G = PermutationGroup(['(1,2,3)(4,5)', '(3,4)']) 16 sage: G 17 Permutation Group with generators [(3,4), (1,2,3)(4,5)] 18 sage: G.order() 19 120 20 sage: G.is_abelian() 21 False 22 sage: G.derived_series() # random-ish output 23 [Permutation Group with generators [(1,2,3)(4,5), (3,4)], 24 Permutation Group with generators [(1,5)(3,4), (1,5)(2,4), (1,3,5)]] 25 sage: G.center() 26 Permutation Group with generators [()] 27 sage: G.random_element() # random output 28 (1,5,3)(2,4) 29 sage: print latex(G) 30 \langle (3,4), (1,2,3)(4,5) \rangle 31 32 Sie können in Sage auch die Tabelle der Charaktere (im LaTeX-Format) 33 erhalten: 34 35 :: 36 37 sage: G = PermutationGroup([[(1,2),(3,4)], [(1,2,3)]]) 38 sage: latex(G.character_table()) 39 \left(\begin{array}{rrrr} 40 1 & 1 & 1 & 1 \\ 41 1 & 1 & -\zeta_{3} - 1 & \zeta_{3} \\ 42 1 & 1 & \zeta_{3} & -\zeta_{3} - 1 \\ 43 3 & -1 & 0 & 0 44 \end{array}\right) 45 46 Sage beinhaltet auch klassische und Matrixgruppen über endlichen Körpern: 47 48 :: 49 50 sage: MS = MatrixSpace(GF(7), 2) 51 sage: gens = [MS([[1,0],[-1,1]]),MS([[1,1],[0,1]])] 52 sage: G = MatrixGroup(gens) 53 sage: G.conjugacy_class_representatives() 54 [ 55 [1 0] 56 [0 1], 57 [0 1] 58 [6 1], 59 ... 60 [6 0] 61 [0 6] 62 ] 63 sage: G = Sp(4,GF(7)) 64 sage: G._gap_init_() 65 'Sp(4, 7)' 66 sage: G 67 Symplectic Group of rank 2 over Finite Field of size 7 68 sage: G.random_element() # random output 69 [5 5 5 1] 70 [0 2 6 3] 71 [5 0 1 0] 72 [4 6 3 4] 73 sage: G.order() 74 276595200 75 76 Sie können auch mit (endlichen oder unendlichen) abelschen Gruppen rechnen. 77 78 :: 79 80 sage: F = AbelianGroup(5, [5,5,7,8,9], names='abcde') 81 sage: (a, b, c, d, e) = F.gens() 82 sage: d * b**2 * c**3 83 b^2*c^3*d 84 sage: F = AbelianGroup(3,[2]*3); F 85 Multiplicative Abelian Group isomorphic to C2 x C2 x C2 86 sage: H = AbelianGroup([2,3], names="xy"); H 87 Multiplicative Abelian Group isomorphic to C2 x C3 88 sage: AbelianGroup(5) 89 Multiplicative Abelian Group isomorphic to Z x Z x Z x Z x Z 90 sage: AbelianGroup(5).order() 91 +Infinity -
new file doc/de/tutorial/tour_help.rst
diff -r 361a4ad7d52c -r aad4d26889c1 doc/de/tutorial/tour_help.rst
- + 1 .. _chapter-help: 2 3 Hilfe 4 ===== 5 6 Sage hat eine umfassende eingebaute Dokumentation, auf die zugegriffen 7 werden kann, indem der Name der Funktion oder Konstanten (zum 8 Beispiel) gefolgt von einem Fragezeichen eingegeben wird: 9 10 .. skip 11 12 :: 13 14 sage: tan? 15 Type: <class 'sage.calculus.calculus.Function_tan'> 16 Definition: tan( [noargspec] ) 17 Docstring: 18 19 The tangent function 20 21 EXAMPLES: 22 sage: tan(pi) 23 0 24 sage: tan(3.1415) 25 -0.0000926535900581913 26 sage: tan(3.1415/4) 27 0.999953674278156 28 sage: tan(pi/4) 29 1 30 sage: tan(1/2) 31 tan(1/2) 32 sage: RR(tan(1/2)) 33 0.546302489843790 34 sage: log2? 35 Type: <class 'sage.functions.constants.Log2'> 36 Definition: log2( [noargspec] ) 37 Docstring: 38 39 The natural logarithm of the real number 2. 40 41 EXAMPLES: 42 sage: log2 43 log2 44 sage: float(log2) 45 0.69314718055994529 46 sage: RR(log2) 47 0.693147180559945 48 sage: R = RealField(200); R 49 Real Field with 200 bits of precision 50 sage: R(log2) 51 0.69314718055994530941723212145817656807550013436025525412068 52 sage: l = (1-log2)/(1+log2); l 53 (1 - log(2))/(log(2) + 1) 54 sage: R(l) 55 0.18123221829928249948761381864650311423330609774776013488056 56 sage: maxima(log2) 57 log(2) 58 sage: maxima(log2).float() 59 .6931471805599453 60 sage: gp(log2) 61 0.6931471805599453094172321215 # 32-bit 62 0.69314718055994530941723212145817656807 # 64-bit 63 sage: sudoku? 64 File: sage/local/lib/python2.5/site-packages/sage/games/sudoku.py 65 Type: <type 'function'> 66 Definition: sudoku(A) 67 Docstring: 68 69 Solve the 9x9 Sudoku puzzle defined by the matrix A. 70 71 EXAMPLE: 72 sage: A = matrix(ZZ,9,[5,0,0, 0,8,0, 0,4,9, 0,0,0, 5,0,0, 73 0,3,0, 0,6,7, 3,0,0, 0,0,1, 1,5,0, 0,0,0, 0,0,0, 0,0,0, 2,0,8, 0,0,0, 74 0,0,0, 0,0,0, 0,1,8, 7,0,0, 0,0,4, 1,5,0, 0,3,0, 0,0,2, 75 0,0,0, 4,9,0, 0,5,0, 0,0,3]) 76 sage: A 77 [5 0 0 0 8 0 0 4 9] 78 [0 0 0 5 0 0 0 3 0] 79 [0 6 7 3 0 0 0 0 1] 80 [1 5 0 0 0 0 0 0 0] 81 [0 0 0 2 0 8 0 0 0] 82 [0 0 0 0 0 0 0 1 8] 83 [7 0 0 0 0 4 1 5 0] 84 [0 3 0 0 0 2 0 0 0] 85 [4 9 0 0 5 0 0 0 3] 86 sage: sudoku(A) 87 [5 1 3 6 8 7 2 4 9] 88 [8 4 9 5 2 1 6 3 7] 89 [2 6 7 3 4 9 5 8 1] 90 [1 5 8 4 6 3 9 7 2] 91 [9 7 4 2 1 8 3 6 5] 92 [3 2 6 7 9 5 4 1 8] 93 [7 8 2 9 3 4 1 5 6] 94 [6 3 5 1 7 2 8 9 4] 95 [4 9 1 8 5 6 7 2 3] 96 97 Sage stellt auch eine 'Tab-Vervollständigung' zur Verfügung: Schreiben Sie die 98 ersten Buchstaben einer Funktion und drücken Sie danach die Tabulatortaste. 99 Wenn Sie zum Beispiel ``ta`` gefolgt von ``TAB`` eingeben, wird Sage 100 ``tachyon, tan, tanh, taylor`` ausgeben. Dies ist eine gute 101 Möglichkeit den Namen von Funktionen und anderen Strukturen in Sage herauszufinden. 102 103 104 .. _section-functions: 105 106 Funktionen, Einrückungen, und Zählen 107 ==================================== 108 109 Um in Sage eine neue Funktion zu definieren, können Sie den ``def`` 110 Befehl und einen Doppelpunkt nach der Liste der Variablennamen 111 benutzen. Zum Beispiel: 112 113 :: 114 115 sage: def is_even(n): 116 ... return n%2 == 0 117 ... 118 sage: is_even(2) 119 True 120 sage: is_even(3) 121 False 122 123 Anmerkung: Abhängig von der Version des Tutorials, das Sie gerade lesen, 124 sehen Sie vielleicht drei Punkte ``...`` in der zweiten Zeile dieses 125 Beispiels. Tippen Sie diese nicht; sie sind nur da um zu 126 verdeutlichen, dass der Code eingerückt ist. Wann immer dies der Fall 127 ist, drücken Sie [Return/Enter] einmal am Ende des Blocks um eine 128 Leerzeile einzufügen und die Funktionsdefinition zu beenden. 129 130 Sie bestimmen den Typ ihrer Eingabeargumente nicht. Sie können mehrere 131 Argumente festlegen, jedes davon kann einen optionalen Standardwert haben. 132 Zum Beispiel wird in der Funktion unterhalb standardmäßig der Wert 133 ``divisor=2`` benutzt, falls ``divisor`` nicht angegeben wurde. 134 135 :: 136 137 sage: def is_divisible_by(number, divisor=2): 138 ... return number%divisor == 0 139 sage: is_divisible_by(6,2) 140 True 141 sage: is_divisible_by(6) 142 True 143 sage: is_divisible_by(6, 5) 144 False 145 146 Sie können auch ein oder mehrere Eingabeargumente explizit angeben 147 wenn Sie die Funktion aufrufen; wenn Sie die Eingaben explizit 148 angeben, können Sie dies in beliebiger Reihenfolge tun: 149 150 .. link 151 152 :: 153 154 sage: is_divisible_by(6, divisor=5) 155 False 156 sage: is_divisible_by(divisor=2, number=6) 157 True 158 159 In Python werden Codeblöcke nicht mit geschweiften Klammern oder 160 "begin-" und "end-Blöcken" kenntlich gemacht. Stattdessen werden 161 Codeblöcke durch Einrückungen bestimmt, welche exakt zusammenpassen 162 müssen. Zum Beispiel ist das Folgende ein Syntaxfehler, da die 163 ``return`` Anweisung nicht genauso weit eingerückt ist wie die anderen 164 Zeilen zuvor. 165 166 .. skip 167 168 :: 169 170 sage: def even(n): 171 ... v = [] 172 ... for i in range(3,n): 173 ... if i % 2 == 0: 174 ... v.append(i) 175 ... return v 176 Syntax Error: 177 return v 178 179 Wenn Sie die Einrückung korrigieren, funktioniert die Funktion: 180 181 :: 182 183 sage: def even(n): 184 ... v = [] 185 ... for i in range(3,n): 186 ... if i % 2 == 0: 187 ... v.append(i) 188 ... return v 189 sage: even(10) 190 [4, 6, 8] 191 192 Semikola sind an den Zeilenenden nicht notwendig; sie können jedoch 193 mehrere Anweisungen, mit Semikola getrennt, in eine Zeile schreiben: 194 195 :: 196 197 sage: a = 5; b = a + 3; c = b^2; c 198 64 199 200 Falls Sie möchten, dass sich eine einzelne Codezeile über mehrere 201 Zeilen erstreckt, können Sie einen terminierenden Backslash verwenden: 202 203 :: 204 205 sage: 2 + \ 206 ... 3 207 5 208 209 In Sage können Sie zählen indem Sie über einen Zahlenbereich 210 iterieren. Zum Beispiel ist nächste Zeile unterhalb gleichwertig zu 211 ``for(i=0; i<3; i++)`` in C++ oder Java: 212 213 :: 214 215 sage: for i in range(3): 216 ... print i 217 0 218 1 219 2 220 221 Die nächste Zeile unterhalb ist gleichwertig zu ``for(i=2;i<5;i++)``. 222 223 :: 224 225 sage: for i in range(2,5): 226 ... print i 227 2 228 3 229 4 230 231 Das dritte Argument bestimmt die Schrittweite, also ist das Folgende 232 gleichwertig zu 233 ``for(i=1;i<6;i+=2)``. 234 235 :: 236 237 sage: for i in range(1,6,2): 238 ... print i 239 1 240 3 241 5 242 243 Oft will man eine schöne Tabelle erstellen, um die mit Sage 244 berechneten Zahlen auszugeben. Eine einfache Möglichkeit dies zu tun 245 ist String-Formatierung zu verwenden. Unten erstellen wir drei Spalten, 246 jede genau 6 Zeichen breit, und erzeugen somit eine Tabelle mit 247 Quadrat- und Kubikzahlen. 248 249 :: 250 251 sage: for i in range(5): 252 ... print '%6s %6s %6s'%(i, i^2, i^3) 253 0 0 0 254 1 1 1 255 2 4 8 256 3 9 27 257 4 16 64 258 259 Die elementarste Datenstruktur in Sage ist die Liste. Sie ist -- wie 260 der Name schon sagt -- nichts anderes als eine Liste beliebiger 261 Objekte. Zum Beispiel erzeugt der ``range`` Befehl, den wir schon 262 verwendet haben, eine Liste: 263 264 :: 265 266 sage: range(2,10) 267 [2, 3, 4, 5, 6, 7, 8, 9] 268 269 Hier ist eine etwas kompliziertere Liste: 270 271 :: 272 273 sage: v = [1, "hello", 2/3, sin(x^3)] 274 sage: v 275 [1, 'hello', 2/3, sin(x^3)] 276 277 Listenindizierung beginnt, wie in vielen Programmiersprachen, bei 0. 278 279 .. link 280 281 :: 282 283 sage: v[0] 284 1 285 sage: v[3] 286 sin(x^3) 287 288 Benutzen Sie ``len(v)`` um die Länge von ``v`` zu erhalten, benutzen 289 Sie ``v.append(obj)`` um ein neues Objekt an das Ende von ``v`` 290 anzuhängen, und benutzen Sie ``del v[i]`` um den :math:`i^{ten}` 291 Eintrag von ``v`` zu löschen: 292 293 .. link 294 295 :: 296 297 sage: len(v) 298 4 299 sage: v.append(1.5) 300 sage: v 301 [1, 'hello', 2/3, sin(x^3), 1.50000000000000] 302 sage: del v[1] 303 sage: v 304 [1, 2/3, sin(x^3), 1.50000000000000] 305 306 Eine weitere wichtige Datenstruktur ist das Dictionary (oder 307 assoziatives Array). Dies funktioniert wie eine Liste, außer dass 308 es mit fast jedem Objekt indiziert werden kann (die Indizes müssen 309 jedoch unveränderbar sein): 310 311 :: 312 313 sage: d = {'hi':-2, 3/8:pi, e:pi} 314 sage: d['hi'] 315 -2 316 sage: d[e] 317 pi 318 319 Sie können auch neue Datentypen definieren, indem Sie Klassen 320 verwenden. Mathematische Objekte mit Klassen zusammenzufassen ist eine 321 mächtige Technik, die dabei helfen kann Sage-Programme zu vereinfachen 322 und zu organisieren. Unten definieren wir eine Klasse, welche die Liste 323 der geraden Zahlen bis *n* darstellt; 324 Sie wird von dem Standard-Typ ``list`` abgeleitet. 325 326 :: 327 328 sage: class Evens(list): 329 ... def __init__(self, n): 330 ... self.n = n 331 ... list.__init__(self, range(2, n+1, 2)) 332 ... def __repr__(self): 333 ... return "Even positive numbers up to n." 334 335 Die ``__init__`` Methode wird aufgerufen um das Objekt zu 336 initialisieren, wenn es erzeugt wird; die ``__repr__`` Method gibt 337 einen Objekt-String aus. Wir rufen die Listen-Konstruktor-Methode in 338 der zweite Zeile der ``__init__`` Methode. Ein Objekt der Klasse 339 ``Evens`` erzeugen wir wie folgt: 340 341 .. link 342 343 :: 344 345 sage: e = Evens(10) 346 sage: e 347 Even positive numbers up to n. 348 349 Beachten Sie, dass die Ausgabe von ``e`` die ``__repr__`` Methode 350 verwendet, die wir definiert haben. Um die eigentliche Liste 351 sehen zu können, benutzen wir die ``list``-Funktion: 352 353 .. link 354 355 :: 356 357 sage: list(e) 358 [2, 4, 6, 8, 10] 359 360 Wir können auch das ``n`` Attribut verwenden oder ``e`` wie eine Liste 361 behandeln. 362 363 .. link 364 365 :: 366 367 sage: e.n 368 10 369 sage: e[2] 370 6 -
new file doc/de/tutorial/tour_linalg.rst
diff -r 361a4ad7d52c -r aad4d26889c1 doc/de/tutorial/tour_linalg.rst
- + 1 .. _section-linalg: 2 3 Lineare Algebra 4 =============== 5 6 Sage stellt standardmäßige Konstruktionen der Linearen Algebra zur 7 Verfügung. Zum Beispiel das charakteristische Polynom, die 8 Zeilenstufenform, die Spur, die Zerlegung von Matrizen, usw.. 9 10 11 Das Erzeugen von Matrizen und die Matrixmultiplikation sind einfach 12 und natürlich: 13 14 :: 15 16 sage: A = Matrix([[1,2,3],[3,2,1],[1,1,1]]) 17 sage: w = vector([1,1,-4]) 18 sage: w*A 19 (0, 0, 0) 20 sage: A*w 21 (-9, 1, -2) 22 sage: kernel(A) 23 Free module of degree 3 and rank 1 over Integer Ring 24 Echelon basis matrix: 25 [ 1 1 -4] 26 27 Beachten Sie, dass in Sage der Kern einer Matrix :math:`A` der "linke 28 Kern", d.h. der Raum der Vektoren :math:`w` mit :math:`wA=0` ist. 29 30 Mit der Methode ``solve_right`` können Matrixgleichungen einfach 31 gelöst werden. Das Auswerten von ``A.solve_right(Y)`` gibt eine Matrix 32 (oder einen Vektor) :math:`X` zurück, so dass :math:`AX=Y` gilt: 33 34 .. link 35 36 :: 37 38 sage: Y = vector([0, -4, -1]) 39 sage: X = A.solve_right(Y) 40 sage: X 41 (-2, 1, 0) 42 sage: A * X # wir überprüfen unsere Antwort... 43 (0, -4, -1) 44 45 Anstelle von ``solve_right`` kann auch ein Backslash ``\`` verwendet 46 werden. Benutzen Sie ``A \ Y`` anstelle von ``A.solve_right(Y)``. 47 48 .. link 49 50 :: 51 52 sage: A \ Y 53 (-2, 1, 0) 54 55 Falls keine Lösung existiert, gibt Sage einen Fehler zurück: 56 57 .. skip 58 59 :: 60 61 sage: A.solve_right(w) 62 Traceback (most recent call last): 63 ... 64 ValueError: matrix equation has no solutions 65 66 Auf ähnliche Weisen können Sie ``A.solve_left(Y)`` benutzen um nach :math:`X` in 67 :math:`XA=Y` aufzulösen. 68 69 Sage kann auch Eigenwerte und Eigenvektoren berechnen:: 70 71 sage: A = matrix([[0, 4], [-1, 0]]) 72 sage: A.eigenvalues () 73 [-2*I, 2*I] 74 sage: B = matrix([[1, 3], [3, 1]]) 75 sage: B.eigenvectors_left() 76 [(4, [ 77 (1, 1) 78 ], 1), (-2, [ 79 (1, -1) 80 ], 1)] 81 82 (Die Syntax der Ausgabe von ``eigenvectors_left`` ist eine Liste von 83 Tripeln: (Eigenwert, Eigenvektor, Vielfachheit).) Eigenwerte und 84 Eigenvektoren über ``QQ`` oder ``RR`` können auch unter Verwendung von 85 Maxima berechnen werden (Lesen Sie :ref:`section-maxima` unterhalb). 86 87 Wie in :ref:`section-rings` bemerkt wurde, beeinflusst der Ring, über 88 dem die Matrix definiert ist, einige ihrer Eigenschaften. Im Folgenden 89 gibt erste Argument des ``matrix``-Befehls Sage zu verstehen, dass die 90 Matrix als Matrix über den ganzen Zahlen (``ZZ``), als Matrix über den 91 rationalen Zahlen (``QQ``), oder als Matrix über den reellen Zahlen 92 (``RR``), aufgefasst werden soll:: 93 94 sage: AZ = matrix(ZZ, [[2,0], [0,1]]) 95 sage: AQ = matrix(QQ, [[2,0], [0,1]]) 96 sage: AR = matrix(RR, [[2,0], [0,1]]) 97 sage: AZ.echelon_form() 98 [2 0] 99 [0 1] 100 sage: AQ.echelon_form() 101 [1 0] 102 [0 1] 103 sage: AR.echelon_form() 104 [ 1.00000000000000 0.000000000000000] 105 [0.000000000000000 1.00000000000000] 106 107 Matrizenräume 108 ------------- 109 110 Wir erzeugen den Raum :math:`\text{Mat}_{3\times 3}(\QQ)` der `3 \times 111 3` Matrizen mit rationalen Einträgen:: 112 113 sage: M = MatrixSpace(QQ,3) 114 sage: M 115 Full MatrixSpace of 3 by 3 dense matrices over Rational Field 116 117 (Um den Raum der 3 mal 4 Matrizen anzugeben würden Sie 118 ``MatrixSpace(QQ,3,4)`` benutzen. Falls die Anzahl der Spalten nicht 119 angegeben wurde, ist diese standardmäßig gleich der Anzahl der Zeilen, 120 so dass ``MatrixSpace(QQ,3)`` ein Synonym für ``MatrixSpace(QQ,3,3)`` 121 ist.) Der Matrizenraum hat eine Basis, die Sage als Liste speichert: 122 123 .. link 124 125 :: 126 127 sage: B = M.basis() 128 sage: len(B) 129 9 130 sage: B[1] 131 [0 1 0] 132 [0 0 0] 133 [0 0 0] 134 135 Wir erzeugen eine Matrix als ein Element von ``M``. 136 137 .. link 138 139 :: 140 141 sage: A = M(range(9)); A 142 [0 1 2] 143 [3 4 5] 144 [6 7 8] 145 146 Als nächstes berechnen wir die reduzierte Zeilenstufenform und den Kern. 147 148 .. link 149 150 :: 151 152 sage: A.echelon_form() 153 [ 1 0 -1] 154 [ 0 1 2] 155 [ 0 0 0] 156 sage: A.kernel() 157 Vector space of degree 3 and dimension 1 over Rational Field 158 Basis matrix: 159 [ 1 -2 1] 160 161 Nun zeigen wir, wie man Matrizen berechnen, die über 162 endlichen Körpern definiert sind: 163 164 :: 165 166 sage: M = MatrixSpace(GF(2),4,8) 167 sage: A = M([1,1,0,0, 1,1,1,1, 0,1,0,0, 1,0,1,1, 168 ... 0,0,1,0, 1,1,0,1, 0,0,1,1, 1,1,1,0]) 169 sage: A 170 [1 1 0 0 1 1 1 1] 171 [0 1 0 0 1 0 1 1] 172 [0 0 1 0 1 1 0 1] 173 [0 0 1 1 1 1 1 0] 174 sage: rows = A.rows() 175 sage: A.columns() 176 [(1, 0, 0, 0), (1, 1, 0, 0), (0, 0, 1, 1), (0, 0, 0, 1), 177 (1, 1, 1, 1), (1, 0, 1, 1), (1, 1, 0, 1), (1, 1, 1, 0)] 178 sage: rows 179 [(1, 1, 0, 0, 1, 1, 1, 1), (0, 1, 0, 0, 1, 0, 1, 1), 180 (0, 0, 1, 0, 1, 1, 0, 1), (0, 0, 1, 1, 1, 1, 1, 0)] 181 182 Wir erstellen den Unterraum von `\GF{2}^8`, der von den obigen Zeilen 183 aufgespannt wird. 184 185 .. link 186 187 :: 188 189 sage: V = VectorSpace(GF(2),8) 190 sage: S = V.subspace(rows) 191 sage: S 192 Vector space of degree 8 and dimension 4 over Finite Field of size 2 193 Basis matrix: 194 [1 0 0 0 0 1 0 0] 195 [0 1 0 0 1 0 1 1] 196 [0 0 1 0 1 1 0 1] 197 [0 0 0 1 0 0 1 1] 198 sage: A.echelon_form() 199 [1 0 0 0 0 1 0 0] 200 [0 1 0 0 1 0 1 1] 201 [0 0 1 0 1 1 0 1] 202 [0 0 0 1 0 0 1 1] 203 204 Die Basis von `S`, die von Sage benutzt wird, wird aus den von Null 205 verschiedenen Zeilen der reduzierten Zeilenstufenform der Matrix der 206 Generatoren von `S` erhalten. 207 208 Lineare Algebra mit dünnbesetzten Matrizen 209 ------------------------------------------ 210 211 Sage unterstützt Lineare Algebra mit dünnbesetzten Matrizen über 212 Hauptidealringen. 213 214 215 :: 216 217 sage: M = MatrixSpace(QQ, 100, sparse=True) 218 sage: A = M.random_element(density = 0.05) 219 sage: E = A.echelon_form() 220 221 Der multi-modulare Algorithmus kann bei quadratischen Matrizen gut 222 angewendet werden (bei nicht quadratischen Matrizen ist er nicht so gut): 223 224 :: 225 226 sage: M = MatrixSpace(QQ, 50, 100, sparse=True) 227 sage: A = M.random_element(density = 0.05) 228 sage: E = A.echelon_form() 229 sage: M = MatrixSpace(GF(2), 20, 40, sparse=True) 230 sage: A = M.random_element() 231 sage: E = A.echelon_form() 232 233 Beachten Sie, dass Python zwischen Klein- und Großschreibung unterscheidet: 234 235 :: 236 237 sage: M = MatrixSpace(QQ, 10,10, Sparse=True) 238 Traceback (most recent call last): 239 ... 240 TypeError: MatrixSpace() got an unexpected keyword argument 'Sparse' -
new file doc/de/tutorial/tour_numtheory.rst
diff -r 361a4ad7d52c -r aad4d26889c1 doc/de/tutorial/tour_numtheory.rst
- + 1 Zahlentheorie 2 ============= 3 4 Sage hat für Zahlentheorie eine ausgiebige Funktionsvielfalt. Zum 5 Beispiel können wir Arithmetik in :math:`\ZZ/N\ZZ` wie folgt betreiben: 6 7 :: 8 9 sage: R = IntegerModRing(97) 10 sage: a = R(2) / R(3) 11 sage: a 12 33 13 sage: a.rational_reconstruction() 14 2/3 15 sage: b = R(47) 16 sage: b^20052005 17 50 18 sage: b.modulus() 19 97 20 sage: b.is_square() 21 True 22 23 Sage enthält standardmäßige zahlentheoretische Funktionen. Zum Beispiel: 24 25 :: 26 27 sage: gcd(515,2005) 28 5 29 sage: factor(2005) 30 5 * 401 31 sage: c = factorial(25); c 32 15511210043330985984000000 33 sage: [valuation(c,p) for p in prime_range(2,23)] 34 [22, 10, 6, 3, 2, 1, 1, 1] 35 sage: next_prime(2005) 36 2011 37 sage: previous_prime(2005) 38 2003 39 sage: divisors(28); sum(divisors(28)); 2*28 40 [1, 2, 4, 7, 14, 28] 41 56 42 56 43 44 Perfekt! 45 46 Sages ``sigma(n,k)``-Funktion summiert die :math:`k^{ten}` Potenzen der 47 Teiler von ``n``: 48 49 :: 50 51 sage: sigma(28,0); sigma(28,1); sigma(28,2) 52 6 53 56 54 1050 55 56 Als nächstes illustrieren wir den erweiterten euklidischen 57 Algorithmus, Eulers :math:`\phi`-Funktion, und den chinesischen 58 Restsatz: 59 60 :: 61 62 sage: d,u,v = xgcd(12,15) 63 sage: d == u*12 + v*15 64 True 65 sage: n = 2005 66 sage: inverse_mod(3,n) 67 1337 68 sage: 3 * 1337 69 4011 70 sage: prime_divisors(n) 71 [5, 401] 72 sage: phi = n*prod([1 - 1/p for p in prime_divisors(n)]); phi 73 1600 74 sage: euler_phi(n) 75 1600 76 sage: prime_to_m_part(n, 5) 77 401 78 79 Als nächstes verifizieren wir ein Beispiel des :math:`3n+1` Problems. 80 81 :: 82 83 sage: n = 2005 84 sage: for i in range(1000): 85 ... n = 3*odd_part(n) + 1 86 ... if odd_part(n)==1: 87 ... print i 88 ... break 89 38 90 91 Schließlich illustrieren wir den chinesischen Restsatz. 92 93 :: 94 95 sage: x = crt(2, 1, 3, 5); x 96 11 97 sage: x % 3 # x mod 3 = 2 98 2 99 sage: x % 5 # x mod 5 = 1 100 1 101 sage: [binomial(13,m) for m in range(14)] 102 [1, 13, 78, 286, 715, 1287, 1716, 1716, 1287, 715, 286, 78, 13, 1] 103 sage: [binomial(13,m)%2 for m in range(14)] 104 [1, 1, 0, 0, 1, 1, 0, 0, 1, 1, 0, 0, 1, 1] 105 sage: [kronecker(m,13) for m in range(1,13)] 106 [1, -1, 1, 1, -1, -1, -1, -1, 1, 1, -1, 1] 107 sage: n = 10000; sum([moebius(m) for m in range(1,n)]) 108 -23 109 sage: list(partitions(4)) 110 [(1, 1, 1, 1), (1, 1, 2), (2, 2), (1, 3), (4,)] 111 112 :math:`p`-adische Zahlen 113 ------------------------ 114 115 Der Körper der :math:`p`-adischen Zahlen ist in Sage 116 implementiert. Beachten Sie, dass sobald Sie einen :math:`p`-adischer Körper 117 erzeugt haben, dessen Genauigkeit nicht mehr ändern können. 118 119 :: 120 121 sage: K = Qp(11); K 122 11-adic Field with capped relative precision 20 123 sage: a = K(211/17); a 124 4 + 4*11 + 11^2 + 7*11^3 + 9*11^5 + 5*11^6 + 4*11^7 + 8*11^8 + 7*11^9 125 + 9*11^10 + 3*11^11 + 10*11^12 + 11^13 + 5*11^14 + 6*11^15 + 2*11^16 126 + 3*11^17 + 11^18 + 7*11^19 + O(11^20) 127 sage: b = K(3211/11^2); b 128 10*11^-2 + 5*11^-1 + 4 + 2*11 + O(11^18) 129 130 In die Implementierung von weiteren Ringen von Zahlen über :math:`p`-adischen 131 Körpern ist viel Arbeit geflossen. Der interessierte Leser ist dazu 132 eingelanden, die Experten in der ``sage-support`` Google-Gruppe nach 133 weiteren Details zu fragen. 134 135 Eine Vielzahl relevanter Methoden sind schon in der NumberField Klasse 136 implementiert. 137 138 :: 139 140 sage: R.<x> = PolynomialRing(QQ) 141 sage: K = NumberField(x^3 + x^2 - 2*x + 8, 'a') 142 sage: K.integral_basis() 143 [1, 1/2*a^2 + 1/2*a, a^2] 144 145 .. link 146 147 :: 148 149 sage: K.galois_group(type="pari") 150 Galois group PARI group [6, -1, 2, "S3"] of degree 3 of the Number Field 151 in a with defining polynomial x^3 + x^2 - 2*x + 8 152 153 .. link 154 155 :: 156 157 sage: K.polynomial_quotient_ring() 158 Univariate Quotient Polynomial Ring in a over Rational Field with modulus 159 x^3 + x^2 - 2*x + 8 160 sage: K.units() 161 [3*a^2 + 13*a + 13] 162 sage: K.discriminant() 163 -503 164 sage: K.class_group() 165 Class group of order 1 of Number Field in a with defining polynomial x^3 + x^2 - 2*x + 8 166 sage: K.class_number() 167 1 -
new file doc/de/tutorial/tour_plotting.rst
diff -r 361a4ad7d52c -r aad4d26889c1 doc/de/tutorial/tour_plotting.rst
- + 1 .. _section-plot: 2 3 Plotten 4 ======= 5 6 Sage kann zwei- und dreidimensionale Plots erzeugen. 7 8 Zweidimensionale Plots 9 ---------------------- 10 11 Sage kann in zwei Dimensionen Kreise, Linien und Polygone zeichnen, 12 sowie Plots von Funktionen in kartesischen Koordinaten und Plots in 13 Polarkoordinaten, Konturplots und Plots von Vektorfeldern. Wir geben 14 davon im Folgenden einige Beispiele an. Für weitere Beispiele zum 15 Plotten mit Sage lesen Sie :ref:`section-systems` und 16 :ref:`section-maxima`, sowie die `Sage Constructions 17 <http://www.sagemath.org/doc/constructions/>`_ Dokumentation. 18 19 Dieser Befehl erstellt einen gelben Kreis vom Radius 1 mit dem 20 Ursprung als Zentrum: 21 22 :: 23 24 sage: circle((0,0), 1, rgbcolor=(1,1,0)) 25 26 Sie können auch einen ausgefüllten Kreis erzeugen: 27 28 :: 29 30 sage: circle((0,0), 1, rgbcolor=(1,1,0), fill=True) 31 32 Sie können einen Kreis auch erstellen, indem Sie ihn einer Variable 33 zuweisen; so wird kein Plot gezeigt. 34 35 :: 36 37 sage: c = circle((0,0), 1, rgbcolor=(1,1,0)) 38 39 Um den Plot zu zeigen, benutzen Sie ``c.show()`` oder ``show(c)`` wie 40 folgt: 41 42 .. link 43 44 :: 45 46 sage: c.show() 47 48 Alternativ führt das Auswerten von ``c.save('filename.png')`` dazu, 49 dass der Plot in der angegebenen Datei gespeichert wird. 50 51 Noch sehen diese 'Kreise' jedoch eher wie Ellipsen aus, da die Achsen 52 unterschiedlich skaliert sind. Sie können dies korrigieren: 53 54 .. link 55 56 :: 57 58 sage: c.show(aspect_ratio=1) 59 60 Der Befehl ``show(c, aspect_ratio=1)`` erreicht das Gleiche. Sie 61 können das Bild auch speichern, indem Sie ``c.save('filename.png', 62 aspect_ratio=1)`` benutzen. 63 64 Es ist einfach elementare Funktionen zu plotten: 65 66 :: 67 68 sage: plot(cos, (-5,5)) 69 70 Sobald Sie einen Variablennamen angegeben haben, können Sie 71 parametrische Plots erzeugen: 72 73 :: 74 75 sage: x = var('x') 76 sage: parametric_plot((cos(x),sin(x)^3),(x,0,2*pi),rgbcolor=hue(0.6)) 77 78 Es ist wichtig zu beachten, dass sich die Achsen eines Plots nur 79 schneiden, wenn sich der Ursprung im angezeigten Bildbereich des 80 Graphen befindet und ab einer bestimmten Größe der Werte wird die 81 wissenschaftliche Notation benutzt: 82 :: 83 84 sage: plot(x^2,(x,300,500)) 85 86 Sie können mehrere Plots zusammenfügen indem Sie diese addieren: 87 88 :: 89 90 sage: x = var('x') 91 sage: p1 = parametric_plot((cos(x),sin(x)),(x,0,2*pi),rgbcolor=hue(0.2)) 92 sage: p2 = parametric_plot((cos(x),sin(x)^2),(x,0,2*pi),rgbcolor=hue(0.4)) 93 sage: p3 = parametric_plot((cos(x),sin(x)^3),(x,0,2*pi),rgbcolor=hue(0.6)) 94 sage: show(p1+p2+p3, axes=false) 95 96 Eine gute Möglichkeit ausgefüllte Figuren zu erstellen ist, eine Liste 97 von Punkten zu erzeugen (``L`` im folgenden Beispiel) und dann den 98 ``polygon`` Befehl zu verwenden um die Figur mit dem, durch die Punkte 99 bestimmten, Rand zu zeichnen. Zum Beispiel ist hier ein grünes Deltoid: 100 101 :: 102 103 sage: L = [[-1+cos(pi*i/100)*(1+cos(pi*i/100)),\ 104 ... 2*sin(pi*i/100)*(1-cos(pi*i/100))] for i in range(200)] 105 sage: p = polygon(L, rgbcolor=(1/8,3/4,1/2)) 106 sage: p 107 108 Geben Sie ``show(p, axes=false)`` ein, um dies ohne Achsen zu sehen. 109 110 Sie können auch Text zu einem Plot hinzufügen: 111 112 :: 113 114 sage: L = [[6*cos(pi*i/100)+5*cos((6/2)*pi*i/100),\ 115 ... 6*sin(pi*i/100)-5*sin((6/2)*pi*i/100)] for i in range(200)] 116 sage: p = polygon(L, rgbcolor=(1/8,1/4,1/2)) 117 sage: t = text("hypotrochoid", (5,4), rgbcolor=(1,0,0)) 118 sage: show(p+t) 119 120 Analysis Lehrer zeichnen häufig den folgenden Plot an die Tafel: 121 nicht nur einen Zweig von der arcsin Funktion, sondern mehrere, also den 122 Plot von :math:`y=\sin(x)` für :math:`x` zwischen :math:`-2\pi` und 123 :math:`2\pi`, an der 45 Grad Linie gespiegelt. Der folgende Sage 124 Befehl erzeugt dies: 125 126 :: 127 128 sage: v = [(sin(x),x) for x in srange(-2*float(pi),2*float(pi),0.1)] 129 sage: line(v) 130 131 Da die Tangensfunktion einen größeren Wertebereich als die 132 Sinusfunktion besitzt, sollten Sie, falls Sie den gleichen Trick 133 anwenden um die Inverse der Tangensfunktion zu plotten, das Minimum 134 und Maximum der Koordinaten für die *x*-Achse ändern: 135 136 :: 137 138 sage: v = [(tan(x),x) for x in srange(-2*float(pi),2*float(pi),0.01)] 139 sage: show(line(v), xmin=-20, xmax=20) 140 141 Sage berechnet auch Plots in Polarkoordinaten, Konturplots, Plots von 142 Vektorfeldern (für besondere Arten von Funktionen). Hier ist ein 143 Beispiel eines Konturplots: 144 145 :: 146 147 sage: f = lambda x,y: cos(x*y) 148 sage: contour_plot(f, (-4, 4), (-4, 4)) 149 150 Dreidimensionale Plots 151 ---------------------- 152 153 Sage kann auch dazu verwendet werden dreidimensionale Plots zu zeichnen. 154 Sowohl im Notebook, als auch von der Kommandozeile aus werden diese 155 Plots standardmäßig mit den Open-Source-Paket [Jmol]_ angezeigt, 156 welches interaktives Drehen und Zoomen der Grafik mit Hilfe der 157 Maus unterstützt. 158 159 Benutzen Sie ``plot3d`` um eine Funktion der Form `f(x, y) = z` zu zeichnen: 160 161 :: 162 163 sage: x, y = var('x,y') 164 sage: plot3d(x^2 + y^2, (x,-2,2), (y,-2,2)) 165 166 Alternativ können Sie auch ``parametric_plot3d`` verwenden um eine 167 parametrisierte Fläche zu zeichnen, wobei jede der Variablen `x, y, z` 168 durch eine Funktion einer oder zweier Variablen bestimmt ist. (Die 169 Argumente sind typischerweise `u` und `v`). Der vorherige Plot kann 170 wie folgt parametrisiert angegeben werden: 171 172 :: 173 174 sage: u, v = var('u, v') 175 sage: f_x(u, v) = u 176 sage: f_y(u, v) = v 177 sage: f_z(u, v) = u^2 + v^2 178 sage: parametric_plot3d([f_x, f_y, f_z], (u, -2, 2), (v, -2, 2)) 179 180 Die dritte Möglichkeit eine 3D Oberfläche zuplotten ist 181 ``implicit_plot3d``, dies zeichnet eine Kontur einer Funktion mit 182 `f(x, y, z) = 0` (so wird eine Punktmenge definiert). Wir können die 183 Sphäre mithilfe einer klassischen Formel zeichnen: 184 185 :: 186 187 sage: x, y, z = var('x, y, z') 188 sage: implicit_plot3d(x^2 + y^2 + z^2 - 4, (x,-2, 2), (y,-2, 2), (z,-2, 2)) 189 190 Hier sind noch ein paar Beispiele: 191 192 `Whitneys Regenschirm <http://en.wikipedia.org/wiki/Whitney_umbrella>`__: 193 194 :: 195 196 sage: u, v = var('u,v') 197 sage: fx = u*v 198 sage: fy = u 199 sage: fz = v^2 200 sage: parametric_plot3d([fx, fy, fz], (u, -1, 1), (v, -1, 1), 201 ... frame=False, color="yellow") 202 203 Die `Kreuz-Kappe <http://de.wikipedia.org/wiki/Kreuzhaube>`__: 204 205 :: 206 207 sage: u, v = var('u,v') 208 sage: fx = (1+cos(v))*cos(u) 209 sage: fy = (1+cos(v))*sin(u) 210 sage: fz = -tanh((2/3)*(u-pi))*sin(v) 211 sage: parametric_plot3d([fx, fy, fz], (u, 0, 2*pi), (v, 0, 2*pi), 212 ... frame=False, color="red") 213 214 Ein gedrehter Torus: 215 216 :: 217 218 sage: u, v = var('u,v') 219 sage: fx = (3+sin(v)+cos(u))*cos(2*v) 220 sage: fy = (3+sin(v)+cos(u))*sin(2*v) 221 sage: fz = sin(u)+2*cos(v) 222 sage: parametric_plot3d([fx, fy, fz], (u, 0, 2*pi), (v, 0, 2*pi), 223 ... frame=False, color="red") 224 225 Die `Lemniskate <http://de.wikipedia.org/wiki/Lemniskate>`__: 226 227 :: 228 229 sage: x, y, z = var('x,y,z') 230 sage: f(x, y, z) = 4*x^2 * (x^2 + y^2 + z^2 + z) + y^2 * (y^2 + z^2 - 1) 231 sage: implicit_plot3d(f, (x, -0.5, 0.5), (y, -1, 1), (z, -1, 1)) -
new file doc/de/tutorial/tour_polynomial.rst
diff -r 361a4ad7d52c -r aad4d26889c1 doc/de/tutorial/tour_polynomial.rst
- + 1 .. _section-poly: 2 3 Polynome 4 ======== 5 6 In diesem Abschnitt erläutern wir, wie man in Sage Polynome erzeugt 7 und benutzt. 8 9 10 .. _section-univariate: 11 12 Polynome in einer Unbestimmten 13 ------------------------------ 14 15 Es gibt drei Möglichkeiten Polynomringe zu erzeugen. 16 17 :: 18 19 sage: R = PolynomialRing(QQ, 't') 20 sage: R 21 Univariate Polynomial Ring in t over Rational Field 22 23 Dies erzeugt einen Polynomring und teilt Sage mit (den String) 't' als 24 Unbestimmte bei Ausgaben auf dem Bildschirm zu verwenden. 25 Jedoch definiert dies nicht das Symbol ``t`` zur Verwendung in Sage, 26 Sie können es also nicht verwenden um ein Polynom (wie 27 z.B. :math:`t^2+1`) einzugeben, welches zu ``R`` gehört. 28 29 Eine alternative Möglichkeit ist: 30 31 .. link 32 33 :: 34 35 sage: S = QQ['t'] 36 sage: S == R 37 True 38 39 Dies verhält sich bezüglich ``t`` gleich. 40 41 Eine dritte sehr bequeme Möglichkeit ist: 42 43 :: 44 45 sage: R.<t> = PolynomialRing(QQ) 46 47 oder 48 49 :: 50 51 sage: R.<t> = QQ['t'] 52 53 oder sogar nur 54 55 :: 56 57 sage: R.<t> = QQ[] 58 59 Dies hat den zusätzlichen Nebeneffekt, dass die Variable ``t`` als 60 Unbestimmte des Polynomrings definiert wird, Sie können daher nun wie 61 folgt auf einfache Weise Elemente von ``R`` definieren. (Beachten Sie, 62 dass die dritte Möglichkeit sehr ähnlich zu der Konstruktor-Notation 63 in Magma ist und, genau wie in Magma, kann Sie dazu verwendet werden 64 eine Vielzahl von Objekten zu definieren.) 65 66 .. link 67 68 :: 69 70 sage: poly = (t+1) * (t+2); poly 71 t^2 + 3*t + 2 72 sage: poly in R 73 True 74 75 Unabhängig davon wie Sie den Polynomring definieren, können Sie die 76 Unbestimmte als den :math:`0^{th}` Erzeuger zurückerhalten: 77 78 :: 79 80 sage: R = PolynomialRing(QQ, 't') 81 sage: t = R.0 82 sage: t in R 83 True 84 85 Beachten Sie, dass Sie bei den komplexen Zahlen eine ähnliche 86 Konstruktion verwenden können: Sie können die komplexen Zahlen 87 ansehen, als wären sie von dem Symbol ``i`` über den reellen Zahlen 88 erzeugt; wir erhalten also Folgendes: 89 90 :: 91 92 sage: CC 93 Complex Field with 53 bits of precision 94 sage: CC.0 # 0th generator of CC 95 1.00000000000000*I 96 97 Beim Erzeugen von Polynomringen kann man sowohl den Ring, als auch den 98 Erzeuger, oder nur den Erzeuger wie folgt erhalten: 99 100 :: 101 102 sage: R, t = QQ['t'].objgen() 103 sage: t = QQ['t'].gen() 104 sage: R, t = objgen(QQ['t']) 105 sage: t = gen(QQ['t']) 106 107 Schließlich treiben wir etwas Arithmetik in :math:`\QQ[t]`. 108 109 :: 110 111 sage: R, t = QQ['t'].objgen() 112 sage: f = 2*t^7 + 3*t^2 - 15/19 113 sage: f^2 114 4*t^14 + 12*t^9 - 60/19*t^7 + 9*t^4 - 90/19*t^2 + 225/361 115 sage: cyclo = R.cyclotomic_polynomial(7); cyclo 116 t^6 + t^5 + t^4 + t^3 + t^2 + t + 1 117 sage: g = 7 * cyclo * t^5 * (t^5 + 10*t + 2) 118 sage: g 119 7*t^16 + 7*t^15 + 7*t^14 + 7*t^13 + 77*t^12 + 91*t^11 + 91*t^10 + 84*t^9 120 + 84*t^8 + 84*t^7 + 84*t^6 + 14*t^5 121 sage: F = factor(g); F 122 (7) * t^5 * (t^5 + 10*t + 2) * (t^6 + t^5 + t^4 + t^3 + t^2 + t + 1) 123 sage: F.unit() 124 7 125 sage: list(F) 126 [(t, 5), (t^5 + 10*t + 2, 1), (t^6 + t^5 + t^4 + t^3 + t^2 + t + 1, 1)] 127 128 Beachten Sie, dass die Faktorisierung die Einheit korrekt in Betracht 129 zieht und ausgibt. 130 131 Falls Sie zum Beispiel die ``R.cyclotomic_polynomial``-Funktion in 132 einem Forschungsprojekt viel verwenden würden, sollten Sie neben Sage 133 zu zitieren, auch versuchen herauszufinden welche Komponente von Sage verwendet 134 wird um das zyklotomische Polynom zu berechnen, und diese ebenso angeben. 135 In diesen Fall sehen Sie im Quellcode der Funktion, welchen Sie mit 136 ``R.cyclotomic_polynomial??`` erhalten schnell die Zeile ``f = 137 pari.polcyclo(n)``, was bedeutet, dass PARI verwendet wird um das 138 zyklotomische Polynom zu berechnen. Zitieren Sie PARI ebenso in Ihrer Arbeit. 139 140 Wenn Sie zwei Polynome teilen, erzeugen Sie ein Element des Quotientenkörpers 141 (den Sage automatisch erzeugt). 142 143 :: 144 145 sage: x = QQ['x'].0 146 sage: f = x^3 + 1; g = x^2 - 17 147 sage: h = f/g; h 148 (x^3 + 1)/(x^2 - 17) 149 sage: h.parent() 150 Fraction Field of Univariate Polynomial Ring in x over Rational Field 151 152 Mit Hilfe von Laurentreihen können Sie die Reihenentwicklung im 153 Quotientenkörper von ``QQ[x]`` berechnen: 154 155 :: 156 157 sage: R.<x> = LaurentSeriesRing(QQ); R 158 Laurent Series Ring in x over Rational Field 159 sage: 1/(1-x) + O(x^10) 160 1 + x + x^2 + x^3 + x^4 + x^5 + x^6 + x^7 + x^8 + x^9 + O(x^10) 161 162 Wenn wir die Variablen unterschiedlich benennen, erhalten wir einen 163 unterschiedlichen Polynomring. 164 165 :: 166 167 sage: R.<x> = PolynomialRing(QQ) 168 sage: S.<y> = PolynomialRing(QQ) 169 sage: x == y 170 False 171 sage: R == S 172 False 173 sage: R(y) 174 x 175 sage: R(y^2 - 17) 176 x^2 - 17 177 178 Der Ring wird durch die Variable bestimmt. Beachten Sie, dass das 179 Erzeugen eines weiteren Rings mit einer ``x`` genannten Variablen 180 keinen unterschiedlichen Ring zurück gibt. 181 182 :: 183 184 sage: R = PolynomialRing(QQ, "x") 185 sage: T = PolynomialRing(QQ, "x") 186 sage: R == T 187 True 188 sage: R is T 189 True 190 sage: R.0 == T.0 191 True 192 193 Sage unterstützt auch Ringe von Potenz- und Laurentreihen über 194 beliebigen Ringen. Im folgenden Beispiel erzeugen wir ein Element aus 195 :math:`\GF{7}[[T]]` und teilen es um ein Element aus :math:`\GF{7}((T))` 196 zu erhalten. 197 198 :: 199 200 sage: R.<T> = PowerSeriesRing(GF(7)); R 201 Power Series Ring in T over Finite Field of size 7 202 sage: f = T + 3*T^2 + T^3 + O(T^4) 203 sage: f^3 204 T^3 + 2*T^4 + 2*T^5 + O(T^6) 205 sage: 1/f 206 T^-1 + 4 + T + O(T^2) 207 sage: parent(1/f) 208 Laurent Series Ring in T over Finite Field of size 7 209 210 Sie können einen Potenzreihenring auch mit der Kurzschreibweise, 211 doppelter eckiger Klammern erzeugen: 212 213 :: 214 215 sage: GF(7)[['T']] 216 Power Series Ring in T over Finite Field of size 7 217 218 Polynome in mehreren Unbestimmten 219 --------------------------------- 220 221 Um mit Polynomringen in mehreren Variablen zu arbeiten, deklarieren 222 wir zunächst den Ring und die Variablen. 223 224 :: 225 226 sage: R = PolynomialRing(GF(5),3,"z") # here, 3 = number of variables 227 sage: R 228 Multivariate Polynomial Ring in z0, z1, z2 over Finite Field of size 5 229 230 Genau wie bei dem Definieren von Polynomringen in einer Variablen, 231 gibt es mehrere Möglichkeiten: 232 233 :: 234 235 sage: GF(5)['z0, z1, z2'] 236 Multivariate Polynomial Ring in z0, z1, z2 over Finite Field of size 5 237 sage: R.<z0,z1,z2> = GF(5)[]; R 238 Multivariate Polynomial Ring in z0, z1, z2 over Finite Field of size 5 239 240 Falls die Variablennamen nur einen Buchstaben lang sein sollen, können 241 Sie auch die folgende Kurzschreibweise verwenden: 242 243 :: 244 245 sage: PolynomialRing(GF(5), 3, 'xyz') 246 Multivariate Polynomial Ring in x, y, z over Finite Field of size 5 247 248 Als nächstes treiben wir wieder etwas Arithmetik. 249 250 :: 251 252 sage: z = GF(5)['z0, z1, z2'].gens() 253 sage: z 254 (z0, z1, z2) 255 sage: (z[0]+z[1]+z[2])^2 256 z0^2 + 2*z0*z1 + z1^2 + 2*z0*z2 + 2*z1*z2 + z2^2 257 258 Sie können auch eine mathematisch etwas weiter verbreitete 259 Schreibweise verwenden um den Polynomring zu definieren. 260 261 :: 262 263 sage: R = GF(5)['x,y,z'] 264 sage: x,y,z = R.gens() 265 sage: QQ['x'] 266 Univariate Polynomial Ring in x over Rational Field 267 sage: QQ['x,y'].gens() 268 (x, y) 269 sage: QQ['x'].objgens() 270 (Univariate Polynomial Ring in x over Rational Field, (x,)) 271 272 Polynomringe in mehreren Variablen sind in Sage mit Hilfe von 273 Python-Dictionaries und der "distributiven Darstellung" eines Polynoms 274 implementiert. Sage benutzt Singular [Si]_, zum Beispiel bei der 275 Berechnung von ggTs und Gröbnerbasen von Idealen. 276 277 :: 278 279 sage: R, (x, y) = PolynomialRing(RationalField(), 2, 'xy').objgens() 280 sage: f = (x^3 + 2*y^2*x)^2 281 sage: g = x^2*y^2 282 sage: f.gcd(g) 283 x^2 284 285 Als nächstes erstellen wir das Ideal :math:`(f,g)` welches von 286 :math:`f` und :math:`g` erzeugt wird, indem wir einfach ``(f,g)`` mit 287 ``R`` multiplizieren (wir könnten auch ``ideal([f,g])`` oder 288 ``ideal(f,g)``) schreiben. 289 290 .. link 291 292 :: 293 294 sage: I = (f, g)*R; I 295 Ideal (x^6 + 4*x^4*y^2 + 4*x^2*y^4, x^2*y^2) of Multivariate Polynomial 296 Ring in x, y over Rational Field 297 sage: B = I.groebner_basis(); B 298 [x^6, x^2*y^2] 299 sage: x^2 in I 300 False 301 302 Übrigens ist die obige Gröbnerbasis keine Liste, sondern eine 303 unveränderliche Folge. Das bedeutet das sie die Attribute "universe" und 304 "parent" besitzt und nicht verändert werden kann. (Dies ist nützlich, 305 da nach dem Ändern der Basis andere Routinen, welche die Gröbnerbasis 306 verwenden, nicht mehr funktionieren könnten) 307 308 .. link 309 310 :: 311 312 sage: B.parent() 313 Category of sequences in Multivariate Polynomial Ring in x, y over Rational 314 Field 315 sage: B.universe() 316 Multivariate Polynomial Ring in x, y over Rational Field 317 sage: B[1] = x 318 Traceback (most recent call last): 319 ... 320 ValueError: object is immutable; please change a copy instead. 321 322 Etwas (damit meinen wir: nicht so viel wie wir gerne hätten) 323 kommutative Algebra ist in Sage, mit Hilfe von Singular implementiert, 324 vorhanden. Zum Beispiel können wir die Zerlegung in Primideale und die 325 assoziierten Primideale von :math:`I` berechnen. 326 327 .. link 328 329 :: 330 331 sage: I.primary_decomposition() 332 [Ideal (x^2) of Multivariate Polynomial Ring in x, y over Rational Field, 333 Ideal (y^2, x^6) of Multivariate Polynomial Ring in x, y over Rational Field] 334 sage: I.associated_primes() 335 [Ideal (x) of Multivariate Polynomial Ring in x, y over Rational Field, 336 Ideal (y, x) of Multivariate Polynomial Ring in x, y over Rational Field] -
new file doc/de/tutorial/tour_rings.rst
diff -r 361a4ad7d52c -r aad4d26889c1 doc/de/tutorial/tour_rings.rst
- + 1 .. _section-rings: 2 3 Wichtige Ringe 4 ============== 5 6 Wenn wir Matrizen, Vektoren oder Polynome definieren ist es manchmal 7 nützlich, und manchmal notwendig, den "Ring" anzugeben, über dem diese 8 definiert sind. Ein *Ring* ist ein mathematisches Objekt, für das es 9 die wohldefinierten Operationen Addition und Multiplikation gibt; Falls 10 Sie davon noch nie gehört haben, brauchen Sie wahrscheinlich nur die 11 folgenden vier häufig verwendeten Ringe zu kennen. 12 13 * die ganzen Zahlen `\{..., -1, 0, 1, 2, ...\}`, welche ``ZZ`` in Sage 14 genannt werden. 15 * die rationalen Zahlen -- d.h Brüche oder Quotienten von ganzen 16 Zahlen, welche ``QQ`` in Sage genannt werden. 17 * die reellen Zahlen, welche ``RR`` in Sage genannt werden. 18 * die komplexen Zahlen, welche ``CC`` in Sage genannt werden. 19 20 Sie müssen diese Unterschiede kennen, da das gleiche Polynom zum 21 Beispiel, unterschiedlich, abhängig von dem Ring über dem es definiert 22 ist, behandelt werden kann. Zum Beispiel hat das Polynom `x^2-2` die 23 beiden Nullstellen `\pm \sqrt{2}`. Diese Nullstellen sind nicht 24 rational, wenn Sie also mit Polynomen über rationalen Koeffizienten 25 arbeiten, lässt sich das Polynom nicht faktorisieren. Mit reellen 26 Koeffizienten lässt es sich faktorisieren. Deshalb müssen Sie den Ring 27 angeben, um sicher zu gehen, dass Sie die Information 28 erhalten, die Sie erwarten. Die folgenden beiden Befehle definieren 29 jeweils die Mengen der Polynome mit rationalen und reellen 30 Koeffizienten. Diese Mengen werden "ratpoly" und "realpoly" genannt, 31 aber das ist hier nicht wichtig; beachten Sie jedoch, dass die Strings 32 ".<t>" und ".<z>" die *Variablen* benennen, die in beiden Fällen benutzt 33 werden. :: 34 35 sage: ratpoly.<t> = PolynomialRing(QQ) 36 sage: realpoly.<z> = PolynomialRing(RR) 37 38 Jetzt verdeutlichen wir die Behauptung über das Faktorisieren von `x^2-2`: 39 40 .. link 41 42 :: 43 44 sage: factor(t^2-2) 45 t^2 - 2 46 sage: factor(z^2-2) 47 (z - 1.41421356237310) * (z + 1.41421356237310) 48 49 Ähnliche Kommentare treffen auf Matrizen zu: Die zeilenreduzierte Form 50 eine Matrix kann vom Ring abhängen, über dem sie definiert ist, 51 genauso wie ihre Eigenwerte und Eigenvektoren. Um mehr über das 52 Konstruieren von Polynomen zu erfahren, lesen Sie :ref:`section-poly`, 53 und für mehr über Matrizen, lesen Sie :ref:`section-linalg`. 54 55 Das Symbol ``I`` steht für die Quadratwurzel von :math:`-1`; ``i`` ist 56 ein Synonym für ``I``. Natürlich ist dies keine rationale Zahl:: 57 58 sage: i # Wurzel von -1 59 I 60 sage: i in QQ 61 False 62 63 Beachten Sie: Der obige Code kann möglicherweise nicht wie erwartet 64 funktionieren. Zum Beispiel wenn der Variablen ``i`` ein 65 unterschiedlicher Wert, etwa wenn diese als Schleifenvariable 66 verwendet wurde, zugewiesen wurde. Falls dies der Fall ist, tippen Sie :: 67 68 sage: reset('i') 69 70 um den ursprünglichen komplexen Wert der Variable ``i`` zu erhalten. 71 72 Es ist noch eine Feinheit beim Definieren von komplexen Zahlen zu 73 beachten: Wie oben erwähnt wurde, stellt das Symbol ``i`` eine 74 Quadratwurzel von `-1` dar, es ist jedoch eine *formale* oder 75 *symbolische* Quadratwurzel von `-1`. Das Aufrufen von ``CC(i)`` oder 76 ``CC.0``, gibt die *komplexe* Quadratwurzel von `-1` zurück. :: 77 78 sage: i = CC(i) # komplexe Gleitkommazahl 79 sage: i == CC.0 80 True 81 sage: a, b = 4/3, 2/3 82 sage: z = a + b*i 83 sage: z 84 1.33333333333333 + 0.666666666666667*I 85 sage: z.imag() # Imaginärteil 86 0.666666666666667 87 sage: z.real() == a # automatische Umwandlung vor dem Vergleich 88 True 89 sage: a + b 90 2 91 sage: 2*b == a 92 True 93 sage: parent(2/3) 94 Rational Field 95 sage: parent(4/2) 96 Rational Field 97 sage: 2/3 + 0.1 # automatische Umwandlung vor der Addition 98 0.766666666666667 99 sage: 0.1 + 2/3 # Umwandlungsregeln sind symmetrisch in SAGE 100 0.766666666666667 101 102 Hier sind weitere Beispiele von Ringen in Sage. Wie oben angemerkt, 103 kann auf den Ring der rationalen Zahlen mit ``QQ`` zugegriffen werden, 104 ebenso wie mit ``RationalField()`` (ein *Körper* (engl. *field*) ist 105 ein Ring in dem die Multiplikation kommutativ ist, und in dem jedes von 106 Null verschiedene Element in dem Ring einen Kehrwehrt besitzt. Die 107 rationalen Zahlen bilden also auch einen Körper, die ganzen Zahlen 108 jedoch nicht):: 109 110 111 sage: RationalField() 112 Rational Field 113 sage: QQ 114 Rational Field 115 sage: 1/2 in QQ 116 True 117 118 Die Dezimalzahl ``1.2`` wird als rationale Zahl in ``QQ`` gesehen: 119 Dezimalzahlen, die auch rational sind, können in rationale Zahlen 120 "umgewandelt" (engl. "coerced") werden. Die Zahlen `\pi` und `\sqrt{2}` 121 sind jedoch nicht rational:: 122 123 sage: 1.2 in QQ 124 True 125 sage: pi in QQ 126 False 127 sage: pi in RR 128 True 129 sage: sqrt(2) in QQ 130 False 131 sage: sqrt(2) in CC 132 True 133 134 Für die Verwendung in der höheren Mathematik kennt Sage noch weitere 135 Ringe, wie z.B. endliche Körper, `p`-adische Zahlen, den Ring der 136 algebraischen Zahlen, Polynomringe und Matrizenringe. Hier sind 137 Konstruktionen einiger von ihnen:: 138 139 sage: GF(3) 140 Finite Field of size 3 141 sage: GF(27, 'a') # Sie müssen den Names des Generators angeben \ 142 ....: # wenn es sich um keinen Primkörper handelt 143 Finite Field in a of size 3^3 144 sage: Zp(5) 145 5-adic Ring with capped relative precision 20 146 sage: sqrt(3) in QQbar # algebraischer Abschluss von QQ 147 True