Ticket #9725: trac_9725.patch

File trac_9725.patch, 208.1 KB (added by phil, 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  
    44
    55import os
    66SAGE_DOC = os.environ['SAGE_DOC']
    7 LANGUAGES = ['en', 'fr']
     7LANGUAGES = ['de', 'en', 'fr']
    88SPHINXOPTS = ""
    99PAPER = ""
    1010OMIT = ["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********
     2Nachwort
     3********
     4
     5Warum Python?
     6=============
     7
     8Vorteile von Python
     9-------------------
     10
     11Sage ist hautsächlich in der Programmiersprache Python implementiert (siehe [Py]_).
     12Jedoch ist Code, bei dem Geschwindigkeit ausschlaggebend ist, in einer
     13kompilierten 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
     68Der Pre-Parser: Unterschiede zwischen Sage und Python
     69-----------------------------------------------------
     70
     71Aus mathematischer Sicht kann Python in verschiedener Weise verwirrend
     72sein, 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
     137Anstatt den Python-Interpreter zu verändern (wie es mache Leute für
     138interne Projekte getan haben), benutzen wir die Sprache Python
     139unverändert und haben einen Prä-Parser geschrieben, so dass sich
     140die Kommandozeilen-IPython-Version so verhält, wie es Mathematiker
     141erwarten würden. Dies bedeutet, dass bereits existierender Python-Code
     142in Sage so verwendet werden kann wie er ist. Man muss jedoch immernoch
     143die standardmäßigen Python-Regeln beachten, wenn man Pakete schreibt,
     144die in Sage importiert werden können.
     145
     146(Um eine Python-Bibliothek zu installieren, die Sie zum Beispiel im
     147Internet gefunden haben, folgen Sie den Anweisungen, aber verwenden
     148sie ``sage -python`` anstelle von ``python``.  Oft bedeutet dies, dass
     149``sage -python setup.py install`` eingegeben werden muss.)
     150
     151
     152Ich möchte einen Beitrag zu Sage leisten. Wie kann ich dies tun?
     153================================================================
     154
     155Falls Sie für Sage einen Beitrag leisten möchten, wird Ihre Hilfe hoch
     156geschätzt! Sie kann von wesentlichen Code-Beiträge bis zum Hinzufügen
     157zur Sage-Dokumention oder zum Berichten von Fehlern reichen.
     158
     159
     160Schauen Sie sich die Sage-Webseite an um Informationen für Entwickler
     161zu erhalten; neben anderen Dingen können Sie eine lange Liste nach
     162Priorität und Kategorie geordneter, zu Sage gehörender Projekte finden.
     163Auch der `Sage Developer's Guide <http://www.sagemath.org/doc/developer/>`_
     164beinhaltet hilfreiche Informationen, und Sie können der ``sage-devel``
     165Google-Group beitreten.
     166
     167
     168Wie zitiere ich Sage?
     169=====================
     170
     171Falls Sie ein Paper schreiben, das Sage verwendet, zitieren Sie bitte
     172die Berechnungen die Sie mithilfe von Sage durchgeführt haben, indem
     173Sie
     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
     180in Ihrem Literaturverzeichnis hinzufügen. (Ersetzen Sie hierbei 4.3 mit der von
     181Ihnen benutzten Version von Sage.) Versuchen Sie bitte weiterhin
     182festzustellen welche Komponenten von Sage in Ihrer Berechnung
     183verwendet wurden, z.B. PARI?, GAP?, Singular? Maxima? und zitieren Sie
     184diese Systeme ebenso. Falls Sie nicht sicher sind welche Software Ihre
     185Berechnung verwendet, können Sie dies gerne in der ``sage-devel``
     186Google-Gruppe fragen. Lesen Sie :ref:`section-univariate` um weitere
     187Information darüber zu erhalten.
     188
     189------------
     190
     191Falls Sie gerade das Tutorial vollständig durchgelesen haben, und noch
     192wissen wie lange Sie hierfür gebraucht haben, lassen Sie und dies bitte
     193in der ``sage-devel`` Google-Gruppe wissen.
     194
     195Viel Spass mit Sage!
  • new file doc/de/tutorial/appendix.rst

    diff -r 361a4ad7d52c -r aad4d26889c1 doc/de/tutorial/appendix.rst
    - +  
     1******
     2Anhang
     3******
     4
     5.. _section-precedence:
     6
     7Binäre arithmetische Operatorrangfolge
     8========================================
     9
     10Was ist ``3^2*4 + 2%5``? Der Wert (38) wird durch diese
     11"Operatorrangfolge-Tabelle" festgelegt. Die Tabelle unterhalb basiert
     12auf der Tabelle in Abschnitt § 5.15 des *Python Language Reference
     13Manual* von G. Rossum und F. Drake. Die Operatoren sind hier in
     14aufsteigender Ordnung der Bindungstärke aufgelistet.
     15
     16
     17==========================  =================
     18Operatoren                  Beschreibung
     19==========================  =================
     20or                          Boolesches oder
     21and                         Boolesches und
     22not                         Boolesches nicht
     23in, not in                  Zugehörigkeit
     24is, is not                  Identitätstest
     25>, <=, >, >=, ==, !=, <>    Vergleich
     26+, -                        Addition, Subtraktion
     27\*, /, %                    Multiplikation, Division, Restbildung
     28\*\*, ^                     Exponentiation
     29==========================  =================
     30
     31Um also ``3^2*4 + 2%5`` zu berechnen klammert Sage den Ausdruck in
     32folgender Weise: ``((3^2)*4) + (2%5)``. Es wird daher zuerst ``3^2``,
     33was ``9`` ist, dann wird sowohl ``(3^2)*4`` als auch ``2%5`` berechnet,
     34und 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********************
     2Literaturverzeichnis
     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
     14import sys, os
     15sys.path.append(os.environ['SAGE_DOC'])
     16from common.conf import *
     17
     18# General information about the project.
     19project = u"Sage Tutorial"
     20name = u'SageTutorial-de'
     21language = "de"
     22
     23# The name for this set of Sphinx documents.  If None, it defaults to
     24# "<project> v<release> documentation".
     25html_title = project + " v"+release
     26
     27# Output file base name for HTML help builder.
     28htmlhelp_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]).
     32latex_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
     5Willkommen beim Sage Tutorial!
     6==============================
     7
     8Sage ist eine freie, Open-Source-Software, die Forschung und
     9Lehre in Algebra, Geometrie, Zahlentheorie, Kryptographie, numerischen
     10Berechnungen und verwandten Gebieten unterstützt. Sowohl das
     11Entwicklungsmodell von Sage als auch die Technologie in Sage zeichnen
     12sich durch eine extrem starke Betonung von Offenheit, Gemeinschaft,
     13Kooperation und Zusammenarbeit aus. Wir bauen das Auto und erfinden
     14nicht das Rad neu. Das Ziel von Sage ist es, eine aktiv gepflegte,
     15freie Open-Source-Alternative zu Magma, Maple, Mathematica und Matlab
     16zu entwickeln.
     17
     18Dieses Tutorial ist die beste Möglichkeit mit Sage in wenigen Stunden
     19vertraut zu werden. Sie können es im HTML- oder PDF-Format
     20lesen oder im Sage-Notebook. Dazu klicken Sie zuerst auf ``Help`` und
     21``Tutorial``, um innerhalb von Sage interaktiv mit dem
     22Tutorial zu arbeiten.
     23
     24Diese Arbeit ist lizenziert unter einer  `Creative Commons Attribution-Share Alike
     253.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
     43Indizes 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*****************************
     4Die interaktive Kommandozeile
     5*****************************
     6In den meisten Teilen dieses Tutorials gehen wir davon aus, dass Sie
     7Sage mit dem ``sage``-Befehl starten. Dieser startet eine angepasste 
     8Version der IPython Kommandozeile und lädt Funktionen und Klassen,
     9sodass sie in der Kommandozeile genutzt werden können. Weitere
     10Anpassungen können Sie in der Datei ``$SAGE_ROOT/ipythonrc``
     11vornehmen. 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
     25Um Sage zu beenden drücken Sie Strg-D oder geben Sie
     26``quit`` oder ``exit`` ein.
     27
     28.. skip
     29
     30::
     31
     32    sage: quit
     33    Exiting SAGE (CPU time 0m0.00s, Wall time 0m0.89s)
     34
     35Unter "wall time" finden Sie die vergangene Echtzeit (der Uhr an Ihrer
     36Wand). Diese ist nötig, da die CPU Zeit Unterprozesse wie GAP oder
     37Singular nicht berücksichtigt.
     38
     39(Vermeiden Sie es den Sage Prozess mit ``kill -9`` in der Konsole zu
     40beenden, da so möglicherweise Unterprozesse wie z.B. Maple-Prozesse
     41nicht beendet oder temporäre Dateien in ``$HOME/.sage/tmp`` nicht
     42gelöscht würden.)
     43
     44
     45Ihre Sage Sitzung
     46=================
     47
     48Unter einer Sitzung verstehen wir die Ein- und Ausgaben von Sage vom
     49Starten bis zum Beenden. Sage speichert alle Eingaben mittels IPython. Wenn
     50Sie die interaktive Kommandozeile nutzen (im Gegensatz zur
     51Browser-Oberfläche "Notebook"), so können Sie jederzeit mittels
     52``%hist`` eine Liste aller bisher getätigten Eingaben sehen. Sie
     53können auch ``?`` eingeben, um mehr über IPython zu
     54erfahren. Z.B. "IPython unterstützt Zeilennummerierung ... sowie Ein-
     55und Ausgabezwischenspeicherung.  Alle Eingaben werden gespeichert und
     56können in Variablen abgerufen werden (neben der normalen
     57Pfeiltasten-Navigation). Die folgenden globalen Variablen existieren
     58immer (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
     66Hier 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
     95Wir lassen die Zeilennummerierung im restlichen Tutorial sowie in der
     96weiteren Sage-Dokumentation weg. Sie können auch eine Liste von
     97Eingaben 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
     128Während Sie die interaktive Kommandozeile nutzen, können Sie jeden
     129UNIX-Kommandozeilenbefehl in Sage ausführen, indem Sie ihm ein
     130Ausrufezeichen ``!`` 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
     139den Inhalt des aktuellen Verzeichnisses aus.
     140
     141In der ``PATH``-Variablen steht das Sage "bin" Verzeichnis vorne. Wenn
     142Sie also ``gp``, ``gap``, ``singular``, ``maxima``, usw. eingeben,
     143starten 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
     162Ein- und Ausgaben loggen
     163========================
     164
     165Die Sage Sitzung loggen bzw. speichern ist nicht das Gleiche (siehe
     166:ref:`section-save`). Um Eingaben (und optional auch Ausgaben) zu
     167loggen nutzen Sie den Befehl ``logstart``. Geben Sie ``logstart?`` ein
     168um weitere Informationen zu erhalten. Sie können diesen Befehl nutzen
     169um alle Eingaben und Ausgaben zu loggen, und diese sogar wiederholen
     170in 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
     212Wenn Sie Sage in der Linux KDE Konsole ``konsole`` verwenden, können
     213Sie Ihre Sitzung wie folgt speichern: Nachdem Sie Sage in ``konsole``
     214gestartet haben, wählen Sie "Einstellungen", dann "Verlauf...", dann
     215"auf unbegrenzt" setzen. Wenn Sie soweit sind Ihre Sitzung zu
     216speichern, wählen Sie "Bearbeiten" und dann "Verlauf speichern
     217unter..."  und geben einen Namen ein, um den Text ihrer Sitzung
     218auf dem Computer zu speichern. Nach dem Speichern der Datei können Sie
     219jene in einem Editor wie GNU Emacs öffnen und ausdrucken. 
     220
     221
     222Einfügen ignoriert Eingabeaufforderungen
     223========================================
     224
     225Stellen Sie sich vor, Sie lesen eine Sitzung von Sage oder Python
     226Berechnungen und  wollen sie in Sage kopieren, aber überall sind noch
     227die störenden ``>>>`` oder ``sage:``
     228Eingabeaufforderungen. Tatsächlich können Sie einfach die gewünschte
     229Stelle mit Eingabeaufforderungen in Sage einfügen. Der Sage Parser
     230wird standardmäßig die führenden ``>>>`` oder ``sage:``
     231Eingabeaufforderungen entfernen bevor er es an Python weitergibt. Zum
     232Beispiel:
     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
     245Befehle zur Zeitmessung
     246=======================
     247
     248Wenn Sie den ``%time`` Befehl vor eine Eingabe schreiben wird die
     249Zeit, die der Aufruf benötigt, ausgegeben nachdem er gelaufen ist.
     250Zum Beispiel können wir die Laufzeit einer bestimmten Potenzierung auf
     251verschiedene Arten vergleichen. Die unten genannte Laufzeit wird unter
     252Umständen weit von der Laufzeit auf Ihrem Computer oder sogar zwischen
     253verschiedenen 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
     263Das bedeutet insgesamt 0,66 Sekunden wurden benötigt und die
     264vergangene "Wall time", also die vergangene Echtzeit (auf Ihrer
     265Wanduhr), betrug auch 0,66 Sekunden. Wenn auf Ihrem Computer viele
     266andere Programme gleichzeitig laufen kann die "Wall time"
     267wesentlich größer als die CPU Zeit sein.
     268
     269Als nächstes messen wir die Laufzeit der Potenzierung unter Verwendung
     270des nativen Sage Ganzzahl-Typs, der (in Cython implementiert ist und)
     271die 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
     281Unter 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
     291GMP ist also ein bisschen besser (wie erwartet, da die für Sage
     292verwendete PARI Version GMP für Ganzzahlarithmetik nutzt).
     293Sie können ebenso Befehlsblöcke messen, indem Sie ``cputime`` wie
     294unten 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
     318Der ``walltime`` Befehl entspricht ``cputime``, nur misst dieser die Echtzeit.
     319
     320Wir können die oben genannte Potenz auch in einigen der Computer
     321Algebra Systeme, die Sage mitbringt berechnen. In jedem Fall führen wir
     322einen trivialen Befehl aus, um den entsprechenden Server dieses
     323Programms zu starten. Sollte es erhebliche Unterschiede zwischen
     324Echtzeit und CPU-Zeit geben, deutet dies auf ein Leistungsproblem hin,
     325dem 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
     365Achten Sie darauf, dass GAP und Maxima am langsamsten in diesem Test
     366sind (er lief auf dem Computer ``sage.math.washington.edu``). Aufgrund
     367des Pexpect-Schnittstellen-Overheads ist es aber vielleicht unfair
     368diese mit Sage zu vergleichen, welches am schnellsten war.
     369
     370Fehlerbehandlung
     371================
     372
     373Wenn irgendetwas schief geht, werden Sie normalerweise eine
     374Python-Fehlermeldung sehen. Python macht sogar einen Vorschlag, was den
     375Fehler ausgelöst hat. Oft sehen Sie den Namen der Fehlermeldung,
     376z.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
     396Der interaktive Debugger ist manchmal hilfreich um zu verstehen was
     397schiefgelaufen ist. Sie können ihn ein- oder ausschalten indem Sie
     398``%pdb`` eingeben (standardmäßig ist er ausgeschaltet). Die
     399Eingabeaufforderung ``ipdb>`` erscheint wenn eine Fehlermeldung
     400geworfen wird und der Debugger eingeschaltet ist. Im Debugger können
     401Sie den Status jeder lokalen Variable ausgeben oder im Ausführungstack
     402hoch- und runterspringen. 
     403Zum 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
     418Tippen Sie ``?`` in der ``ipdb>``-Eingabeaufforderung  um eine Liste
     419der 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
     442Drücken Sie Strg-D oder geben Sie ``quit`` ein um zu Sage zurückzukehren.
     443
     444.. _section-tabcompletion:
     445
     446Rückwärtssuche und Tab-Vervollständigung
     447========================================
     448
     449Definieren 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
     458Sie können auch die folgende verkürzte Schreibweise verwenden:
     459
     460::
     461
     462    sage: V = QQ^3
     463
     464Schreiben 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
     466eingegebenen Zeile zu gelangen, die ebenfalls so beginnt. Das
     467funktioniert auch nach einem kompletten Sage-Neustart noch. Sie können
     468den Verlauf auch mit ``Strg-r`` rückwärts durchsuchen.  Diese
     469Funktionalität wird vom ``readline``-Paket bereitgestellt, welches in
     470nahezu jeder Linux-Distribution verfügbar ist.
     471
     472Es ist sehr einfach alle Unterfunktionen für :math:`V` mittels
     473Tab-Vervollständigung  aufzulisten, indem Sie erst ``V.`` eingeben,
     474und 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
     491Wenn Sie die ersten paar Buchstaben einer Funktion tippen und dann die
     492``[Tabulator Taste]`` drücken, bekommen Sie nur die Funktionen, die so
     493beginnen 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
     502Wenn sie wissen wollen, was eine bestimmte Funktion tut, z.B. die
     503"coordinates"-Funktion, so geben Sie ``V.coordinates?`` ein um die
     504Hilfe, und ``V.coordinates??`` um den Quelltext der Funktion zu
     505sehen.
     506
     507
     508
     509Integriertes Hilfesystem
     510========================
     511
     512Sage hat ein integriertes Hilfesystem. Hängen Sie an einen beliebigen
     513Funktionsnamen 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
     544Wie Sie sehen, beinhaltet die Ausgabe den Typ des Objekts, den
     545Dateinamen in welcher die Funktion definiert ist und eine Beschreibung der Funktionalität
     546mit Beispielen, die Sie direkt in Ihre aktuelle Sitzung einfügen können.
     547Fast alle dieser Beispiele werden regelmäßig automatisch getestet um sicherzustellen, dass sie
     548genau wie beschrieben funktionieren.
     549
     550Eine andere Funktionalität, die sehr eng in Verbindung mit Open-Source-Gedanken steht ist,
     551dass Sie sich zu jeder Funktion den Quelltext anzeigen lassen
     552kö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
     571Das zeigt uns, dass die ``coordinates``-Funktion nichts anderes tut,
     572als ``coordinates_vector``-Funktion aufruft und das Ergebnis in eine
     573Liste 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
     586Die ``coordinate_vector``-Funktion steckt ihre Eingabe in den
     587umgebenden Raum, was zur Folge hat, dass der Koeffizientenvektor von
     588:math:`v` zur Basis des Vektorraums :math:`V` ausgerechnet wird.
     589Der Raum :math:`V` ist schon der umgebende, nämlich gerade
     590:math:`\QQ^3`. Es gibt auch eine ``coordinate_vector``-Funktion für
     591Unterräume, und sie funktioniert anders.
     592Wir 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,
     613helfen Sie uns bitte unsere Lineare Algebra zu optimieren.)
     614
     615Sie können auch ``help(command_name)`` oder ``help(class)`` eingeben
     616um 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
     634Wenn Sie ``q`` drücken um das Hilfesystem zu verlassen, kommen Sie genau
     635dahin zurück, wo Sie Ihre Sitzung verlassen haben. Die ``help`` Anzeige
     636bleibt nicht in Ihrer Sitzung zurück im Gegensatz zu ``funktion?``.
     637Es ist besonders hilfreich ``help(modul_name)`` zu nutzen. Zum Beispiel sind
     638Vektorräume in ``sage.modules.free_module`` definiert. Geben Sie also
     639``help(sage.modules.free_module)`` ein, um die Dokumentation des
     640ganzen Moduls zu sehen. Wenn Sie sich Die Dokumentation mit ``help``
     641ansehen, können Sie mit ``/`` vorwärts und mit ``?`` rückwärts suchen.
     642
     643Speichern und Laden von individuellen Objekten
     644==============================================
     645
     646Angenommen Sie berechnen eine Matrix oder schlimmer, einen
     647komplizierten Modulsymbolraum, und Sie wollen ihn für später
     648speichern. Was können Sie tun? Es gibt mehrere Möglichkeiten für
     649Computer 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
     661Da Sage Python nutzt, braucht es einen anderen Ansatz, nämlich dass
     662jedes Objekt serialisiert werden kann. Das heißt es in eine Zeichenkette
     663umzuwandeln, die man wieder einlesen kann. Das ist im Prinzip ähnlich zum
     664einheitlichen Ein-/Ausgabe Ansatz von PARI, abgesehen von der zu komplizierten
     665Darstellung auf dem Bildschirm. Außerdem ist das Laden und Speichern (meistens)
     666vollautomatisch und benötigt nicht einmal speziellen Programmieraufwand; es ist
     667einfach ein Merkmal, das von Grund auf in Python war.
     668
     669Fast alle Objekte x in Sage können in komprimierter Form gespeichert werden
     670via ``save(x, Dateiname)`` (oder in vielen Fällen ``x.save(Dateiname)``).
     671Um 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
     684Sie 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
     696Sie können das selbe mit komplizierteren Objekten, wie etwa elliptischen
     697Kurven machen. Alle Daten über das Objekt sind zwischengespeichert und
     698werden 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
     709Die gespeicherte Version von ``E`` braucht 153 Kilobyte, da die ersten
     710100000 :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``
     723Moduls umgesetzt. Genauer: Ein Sage Objekt ``x`` kann mit
     724``cPickle.dumps(x, 2)`` gespeichert werden.  Beachten Sie die ``2``!)
     725
     726Sage kann allerdings keine individuellen Objekte anderer Computer Algebra Systeme
     727wie GAP, Singular, Maxima, usw. laden und speichern. Sie sind mit "invalid" gekennzeichnet nach dem Laden.
     728In GAP werden viele Objekte in einer Form dargestellt, die man wiederherstellen kann,
     729viele andere allerdings nicht. Deshalb ist das Wiederherstellen aus ihren Druckdarstellungen
     730nicht 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
     744GP/PARI Objekte können hingegen gespeichert und geladen werden, da
     745ihre 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
     756Gespeicherte Objekte können auch auf Computern mit anderen Architekturen
     757oder Betriebssystemen wieder geladen werden. Zum Beispiel können Sie
     758eine riesige Matrix auf einem 32 Bit Mac OS X speichern und später auf
     759einem 64 Bit Linux System laden, dort die Stufenform herstellen und dann
     760wieder zurückladen. Außerdem können Sie in den meisten Fällen auch Objekte
     761laden, die mit anderen Sage Versionen gespeichert wurden, solange der Quelltext
     762des Objekts nicht zu verschieden ist. Alle Attribute eines Objekts werden zusammen
     763mit seiner Klasse (aber nicht dem Quellcode) gespeichert. Sollte diese Klasse
     764in einer neueren Sage Version nicht mehr existieren, kann das Objekt in dieser
     765neueren Sage Version nicht mehr geladen werden. Aber Sie könnten es in der alten
     766Sage Version laden, die Objekt Dictionaries mit ``x.__dict__`` laden und das Objekt
     767zusammen mit diesem in der neuen Sage Version laden.
     768
     769Als Text speichern
     770------------------
     771
     772Sie können die ASCII Text Darstellung eines Objekts in eine Klartextdatei
     773schreiben, indem Sie die Datei einfach mit Schreibzugriff öffnen und die
     774Textdarstellung des Objekts hineinkopieren. (Sie können auch viele andere
     775Objekte auf diese Art speichern.) Wenn Sie alle Objekte hineinkopiert haben,
     776schließ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
     790Speichern und Laden kompletter Sitzungen
     791========================================
     792
     793Sage hat eine sehr flexible Unterstützung für das Speichern und Laden
     794kompletter Sitzungen.
     795
     796Der Befehl ``save_session(sitzungsname)`` speichert alle Variablen,
     797die Sie während dieser Sitzung definiert haben als ein Dictionary
     798``sessionname``. (Im seltenen Fall, dass eine Variable nicht gespeichert
     799werden kann, fehlt sie anschließend einfach im Dictionary.)
     800Die erzeugte Datei ist eine ``.sobj``-Datei und kann genau wie jedes andere
     801Objekt geladen werden. Wenn Sie Objekte aus einer Sitzung laden, werden Sie
     802diese in einem Dictionary finden. Dessen Schlüssel sind die Variablen und
     803dessen Werte sind die Objekte.
     804
     805Sie können den ``load_session(sitzungsname)`` Befehl nutzen um die Variablen
     806aus ``sitzungsname`` in die aktuelle Sitzung zu laden. Beachten Sie, dass
     807dieses Vorgehen nicht die Variablen der aktuellen Sitzung löscht, vielmehr
     808werden beide Sitzungen vereinigt.
     809
     810Starten 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
     822Als nächstes speichern wir unsere Sitzung, was jede der Variablen
     823in eine Datei speichert. Dann sehen wir uns die Datei, die etwa
     8243 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
     839Zuletzt starten wir Sage neu, definieren uns eine extra Variable, und laden
     840unsere 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
     853Jede der gespeicherten Variablen ist wieder verfügbar und die
     854Variable ``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
     875Die Notebook Umgebung
     876=====================
     877
     878Das Sage Browser Notebook wird mit
     879
     880.. skip
     881
     882::
     883
     884    sage: notebook()
     885
     886in der Sage Kommandozeile gestartet. Der Befehl startet das Sage
     887Notebook und ebenso Ihren Standardbrowser. Die Serverstatus-Dateien
     888liegen unter ``$HOME/.sage/sage\_notebook``.
     889
     890Die andere Optionen enthalten z.B.
     891
     892.. skip
     893
     894::
     895
     896    sage: notebook("Verzeichnis")
     897
     898was einen neuen Notebook Server mit den Dateien aus dem angegebenen Verzeichnis
     899startet (anstelle des Standardverzeichnises ``$HOME/.sage/sage_notebook``).
     900Das kann hilfreich sein, wenn Sie einige Worksheets für ein Projekt oder
     901verschiedene gleichzeitig laufende Notebook Server von einander trennen wollen.
     902
     903Wenn Sie das Notebook starten, werden zuerst die folgenden Dateien erzeugt
     904in ``$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
     912Nach dem Anlegen dieser Dateien, startet das notebook als Webserver.
     913
     914Ein "Notebook" ist eine Sammlung von Benutzerkonten, von dem jedes
     915verschiedene Worksheets enthalten kann. Wenn Sie ein neues Worksheet
     916erstellen, werden alle zugehörigen Daten unter
     917``Worksheets/username/number`` gespeichert. In jedem solchen
     918Verzeichnis ist eine Klartextdatei namens ``Worksheet.txt`` - sollte
     919mit Ihren Worksheets oder Sage irgendetwas Unvorhergesehenes
     920passieren, enthält diese Datei alles was Sie benötigen um Ihre
     921Worksheets wiederherzustellen.
     922
     923Innerhalb von Sage können Sie mit ``notebook?`` mehr Informationen zum Start eines
     924Notebook-Servers erhalten.
     925
     926Das 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
     952Um Hilfe zu einem Sage-Befehl ``befehl`` im Notebook-Browser zu bekommen
     953geben Sie ``befehl?`` ein und drücken Sie ``<esc>`` (nicht ``<shift-enter>``).
     954
     955Für Informationen zu Tastenbefehlen des Notebook-Browsers klicken Sie auf
     956den ``Help`` Link.
  • new file doc/de/tutorial/interfaces.rst

    diff -r 361a4ad7d52c -r aad4d26889c1 doc/de/tutorial/interfaces.rst
    - +  
     1**************
     2Schnittstellen
     3**************
     4
     5Ein zentraler Aspekt von Sage ist, dass es Berechnungen mit Objekten
     6vieler verschiedener Computer Algebra Systeme unter einem Dach durch eine
     7einheitliche Schnittstelle und Programmiersprache vereinigt.
     8
     9Die ``console`` und ``interact`` Methoden einer Schnittstelle unterstützen
     10viele verschiedene Dinge. Zum Beispiel, anhand von GAP:
     11
     12
     13#. ``gap.console()``: Öffnet die GAP Konsole und übergibt GAP die
     14   Kontrolle. Hier ist Sage nichts weiter als ein praktischer
     15   Programmstarter, ähnlich einer Linux-Bash-Konsole.
     16
     17#. ``gap.interact()``: Ist eine einfache Art mit einer GAP Instanz
     18   zu interagieren, die Sage Objekte enthalten kann. Sie können Sage
     19   Objekte in diese GAP Sitzung importieren (sogar von der interaktiven
     20   Schnittstelle aus), usw.
     21
     22.. index: PARI; GP
     23
     24GP/PARI
     25=======
     26
     27PARI ist ein kompaktes, sehr ausgereiftes, stark optimiertes C-Programm,
     28dessen primärer Fokus Zahlentheorie ist. Es gibt zwei sehr verschiedene
     29Schnittstellen, die Sie in Sage nutzen können:
     30
     31
     32-  ``gp`` - Der "**G** o **P** ARI" Interpreter und
     33
     34-  ``pari`` - Die PARI-C-Bibliothek.
     35
     36
     37Die folgenden Zeilen zum Beispiel sind zwei Wege, genau das gleiche zu
     38tun. Sie sehen identisch aus, aber die Ausgabe ist verschieden, und was
     39hinter den Kulissen passiert ist völlig unterschiedlich.
     40
     41::
     42
     43    sage: gp('znprimroot(10007)')
     44    Mod(5, 10007)
     45    sage: pari('znprimroot(10007)')
     46    Mod(5, 10007)
     47
     48Im ersten Fall wird eine separate Kopie des GP-Interpreters als Server
     49gestartet, die Zeichenkette ``'znprimroot(10007)'`` übergeben,
     50von GP ausgewertet und das Ergebnis wird einer Variable in GP zugewiesen
     51(was Platz im Speicher des GP-Unterprozesses benötigt, der nicht wieder
     52freigegeben wird). Dann wird der Wert der Variablen erst angezeigt.
     53Im zweiten Fall wird kein separates Programm gestartet, stattdessen
     54wird die Zeichenkette ``'znprimroot(10007)'`` von einer bestimmten
     55PARI-C-Bibliotheksfunktion ausgewertet. Das Ergebnis wird im Speicher
     56von Python gehalten, welcher freigegeben wird wenn die Variable nicht
     57mehr referenziert wird. Die Objekte haben 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
     66Welche Variante sollten Sie also nutzen? Das kommt darauf an was
     67Sie tun. Die GP-Schnittstelle kann alles was ein normales
     68GP/PARI-Konsolenprogramm könnte, da es das Programm
     69startet. Genauergesagt könnten Sie komplizierte PARI-Programme laden
     70und laufen lassen. Im Gegensatz dazu ist die PARI-Schnittstelle
     71(mittels C-Bibliothek) wesentlich restriktiver. Zuerst einmal sind
     72nicht alle Unterfunktionen implementiert. Außerdem
     73wird relativ viel Quellcode nicht in der PARI-Schnittstelle funktionieren,
     74z.B. numerisches Integrieren. Abgesehen davon ist die PARI-Schnittstelle
     75wesentlich schneller und robuster als die von GP.
     76
     77(Wenn der GP-Schnittstelle der Speicher ausgeht beim Auswerten einer
     78Zeile, wird sie automatisch und unbemerkt den Speicherbereich
     79verdoppeln und das Auswerten erneut versuchen. Dadurch wird Ihre
     80Berechnung nicht abstürzen, falls Sie den benötigen Speicher falsch
     81eingeschätzt haben. Das ist eine  hilfreiche Erweiterung, die der
     82gewöhnliche GP-Interpreter nicht bietet. Die PARI-C-Bibliothek
     83hingegen kopiert jedes neue Objekt sofort vom PARI-Stack, daher wird
     84der Stapel nicht größer. Allerdings muss jedes Objekt kleiner als 100
     85MB sein, da ansonsten der Stapel "überläuft", wenn das Objekt erstellt
     86wird. Dieses zusätzliche Kopieren erzeugt allerdings ein wenig
     87Leistungseinbußen.)
     88
     89Zusammengefasst nutzt Sage also die PARI-C-Bibliothek um Funktionalitäten
     90eines GP/PARI-Interpreters bereitzustellen, allerdings mit einer anderen
     91komplizierten Speicherverwaltung und der Programmiersprache Python.
     92
     93Zuerst 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
     103Jedes PARI-Objekt ist vom Typ ``py_pari.gen``. Den PARI Typ des vorliegenden
     104Objekts können Sie mit der ``type`` Unterfunktion herausfinden.
     105
     106.. link
     107
     108::
     109
     110    sage: v.type()
     111    't_VEC'
     112
     113Um eine elliptische Kurve in PARI zu erstellen geben Sie
     114``ellinit([1,2,3,4,5])`` ein. Bei Sage ist es ähnlich, nur
     115dass ``ellinit`` eine Methode ist, die von jedem PARI-Objekt
     116aus 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
     128Jetzt haben wir eine elliptische Kurve als Objekt und können einige
     129Dinge 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
     147GAP
     148===
     149
     150Sage enthält ausserdem GAP für diskrete Mathematik, insbesondere
     151Gruppentheorie.
     152
     153Hier ist ein Beispiel für GAP's ``IdGroup``-Funktion, die die optionale kleine
     154Gruppen 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
     168Wir können die gleiche Berechnung in Sage durchführen ohne vorher explizit
     169die 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
     182installieren. Geben Sie ``sage -optional`` ein, um eine Liste zu
     183erhalten und  wählen Sie das Paket aus, das etwa so aussieht
     184``gap\_packages-x.y.z``.
     185Geben Sie dann ``sage -i gap\_packages-x.y.z`` ein. Das gleiche machen
     186Sie bitte mit ``database\_gap-x.y.z``.
     187Einige nicht-GPL Pakete können installiert
     188werden, indem Sie sie von der GAP-Website [GAPkg]_ herunter laden und
     189nach ``$SAGE_ROOT/local/lib/gap-4.4.10/pkg`` entpacken.)
     190
     191
     192Singular
     193========
     194
     195Singular bietet eine sehr gute, ausgereifte Bibliothek für Gröbnerbasen,
     196größte gemeinsame Teiler von mehrdimensionalen Polynomen, Basen von
     197Riemann-Roch Räumen einer planaren Kurve und Faktorisierungen unter anderem.
     198Wir zeigen hier die Faktorisierung mehrdimensionaler Polynome mit
     199Sages 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
     214Wir 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
     234Genau wie im GAP Beispiel in :ref:`section-gap`, können wir diese Faktorisierung
     235berechnen ohne explizit die Singular-Schnittstelle zu nutzen.
     236(Dennoch nutzt Sage im Hintergrund die Singular-Schnittstelle für die Berechnung.)
     237Bitte 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
     250Maxima
     251======
     252
     253Das in Lisp implementierte Maxima ist ein Teil von Sage. Hingegen wird
     254das gnuplot-Paket (welches Maxima standardmäßig zum plotten nutzt) als
     255optionales Sage-Paket angeboten. Neben anderen Dingen rechnet Maxima
     256mit Symbolen. Maxima integriert und differenziert Funktionen
     257symbolisch, löst gewöhnliche Differentialgleichungen ersten Grades
     258sowie viele lineare Differentialgleichungen zweiten Grades und besitzt
     259eine Methode zur Laplace Transformation linearer
     260Differentialgleichungen von beliebigem Grad. Maxima kennt eine große
     261Zahl spezieller Funktionen, plottet mittels gnuplot und hat Methoden,
     262um Polynomgleichungen oder Matrizen zu lösen oder zu verändern
     263(z.B. Zeilenelimination oder Eigenwerte und Eigenvektoren berechnen).
     264
     265Wir zeigen die Sage/Maxima Schnittstelle, indem wir die Matrix konstruieren,
     266deren :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
     282Hier 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
     307Zuletzt noch ein Beispiel wie man Sage zum Plotten mittels
     308``openmath`` nutzt. Einige von ihnen wurden (verändert) aus dem Maxima
     309Benutzerhandbuch entnommen.
     310
     311Ein 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
     318Ein "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
     327Der 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
     335Und 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**********
     2Einleitung
     3**********
     4
     5Um dieses Tutorial vollständig durchzuarbeiten sollten 3 bis 4 Stunden
     6genügen. Sie können es im HTML oder PDF Format
     7lesen oder im Sage Notebook. Dazu klicken Sie zuerst auf ``Help`` und
     8``Tutorial``, um innerhalb von Sage interaktiv mit dem
     9Tutorial zu arbeiten.
     10
     11Obwohl große Teile von Sage mithilfe von Python implementiert sind,
     12ist kein tieferes Verständnis von Python notwendig um dieses Tutorial
     13lesen zu können. Sie werden Python zu einem gewissen Zeitpunkt lernen
     14wollen (Python kann sehr viel Spass bereiten) und es gibt viele
     15ausgezeichnete freie Quellen, wozu auch [PyT]_ und [Dive]_ gehören.
     16Wenn Sie nur kurz etwas in Sage ausprobieren möchten, ist dieses
     17Tutorial 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
     61Installation
     62============
     63
     64Falls Sie Sage auf Ihrem Computer nicht installiert haben und nur ein
     65paar Befehle ausführen möchten, können Sie es online unter
     66http://www.sagenb.org benutzen.
     67
     68Schauen Sie sich den `Sage Installation Guide <http://www.sagemath.org/doc/installation/index.html>`_ an, um Anleitungen
     69zur Installation von Sage auf Ihrem Computer zu erhalten.
     70Hier 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
     108Wie man Sage benutzen kann
     109==========================
     110
     111Sie 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
     125Langfristige 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****************************
     2Sage, LaTeX und ihre Freunde
     3****************************
     4
     5Sage und der TeX-Dialekt LaTeX haben eine sehr synergetische
     6Beziehung. Dieses Kapitel hat das Ziel die Vielfalt an Interaktionen,
     7von den einfachsten bis hin zu den ungewöhnlichen und fast schon
     8magischen, vorzustellen. (Sie sollten also nicht gleich das ganze
     9Kapitel im ersten Durchgang durch das Tutorial lesen.)
     10
     11Überblick
     12=========
     13
     14Es ist wahrscheinlich am einfachsten die verschiedenen
     15Einsatzmöglichkeiten von LaTeX zu verstehen, wenn man sich die drei
     16grundsä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       
     65Hier 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
     83Grundlegende jsMath Funktionen gibt es im Notebook weitgehend automatisch,
     84aber wir können es teilweise mit Hilfe der ``JSMath`` Klasse demonstrieren.
     85Die ``eval`` Funktion dieser Klasse konvertiert ein Sage-Objekt in
     86seine LaTeX-Darstellung und dann in HTML mit der CSS ``math`` Klasse,
     87die 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   
     103Grundlegende Nutzung
     104====================
     105
     106Wie schon im Überblick angekündigt, ist der einfachste Weg Sage's
     107LaTeX-Unterstützung zu nutzen die ``latex()`` Funktion um eine
     108legitime LaTeX-Darstellung eines mathematischen Objekts zu erhalten.
     109Diese Zeichenketten können dann in unabhängigen LaTeX-Dokumenten
     110genutzt werden. Das funktioniert im Notebook genauso wie in der
     111Sage-Kommandozeile.
     112
     113Das andere Extrem ist der ``view()``-Befehl. In der Sage-Kommandozeile
     114wird der Befehl ``view()`` die LaTeX-Darstellung von ``foo`` in ein
     115einfaches  LaTeX Dokument packen, und dann dieses mit der systemweiten
     116TeX-Installation aufrufen. Zuletzt wird das passende Programm zum
     117Anzeigen der Ausgabe von TeX aufgerufen. Welche Version von TeX
     118genutzt wird, und damit auch wie die Ausgabe aussieht und welches
     119Anzeigeprogramm aufgerufen wird, kann angepasst werden (siehe
     120:ref:`sec-custom-processing`).
     121
     122Im Notebook schafft der ``view(foo)`` Befehl die nötige Kombination
     123von HTML und CSS sodass jsMath die LaTeX Darstellung im Arbeitsblatt
     124anzeigt. Für den Anwender erstellt er einfach eine schön formatierte
     125Ausgabe, die sich von der normalen ASCII Ausgabe aus Sage
     126unterscheidet. Nicht jedes mathematische Objekt in Sage hat eine
     127LaTeX-Darstellung, die die eingeschränkten Möglichkeiten von jsMath
     128unterstützt. In diesen Fällen kann die jsMath Darstellung umgangen
     129werden, und stattdessen die systemweite TeX-Installation aufgerufen
     130werden. Dessen Ausgabe kann dann als Bild im Arbeitsblatt angezeigt
     131werden. Die Einstellungen und Auswirkungen dieses Prozesses wird im
     132Kapitel :ref:`sec-custom-generation` dargestellt.
     133
     134Der interne ``pretty_print()`` Befehl zeigt die Konvertierung von Sage
     135Objekten 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
     143Das Notebook hat zwei weitere Möglichkeiten TeX zu nutzen. Die erste
     144ist der "Typeset"-Knopf über der ersten Zelle eines Arbeitsblatts,
     145rechts von den vier Drop-Down-Boxen. Ist er ausgewählt werden die
     146Ausgaben aller folgenden Berechnungen von jsMath
     147interpretiert. Beachten Sie, dass dieser Befehl nicht rückwirkend ist
     148-- alle vorher berechneten Zellen werden nicht neu berechnet. Im
     149Grunde ist der "Typeset"-Knopf gleichzusetzen mit dem Aufruf des
     150``view()``-Befehls in allen Zellen.
     151
     152Die zweite Möglichkeit im Notebook ist das Eingeben von TeX
     153Kommentaren in einem Arbeitsblatt. Wenn der Cursor zwischen zwei
     154Zellen steht, und der erscheinende blaue Balken mit gedrückter Shift
     155Taste geklickt wird, wird ein  kleiner Texteditor TinyMCE
     156geöffnet. Dieser erlaubt die Eingabe von HTML und CSS formatiertem
     157Text mit einem WYSIWYG-Editor. Es ist also möglich den so formatierten
     158Text als Kommentar in einem  Arbeitsblatt unterzubringen. Text den Sie
     159hier zwischen ``$...$`` oder ``$$...$$`` eingeben wird ebenfalls von
     160jsMath in einer "inline" bzw. "display math" Umgebung gesetzt. 
     161
     162.. _sec-custom-generation:
     163
     164
     165Anpassen der LaTeX-Generierung
     166==============================
     167
     168Es gibt verschiedene Arten den vom ``latex()``-Befehl generierten
     169LaTeX-Code anzupassen. Im Notebook und der Sage Kommandozeile gibt es
     170ein vordefiniertes Objekt Namens ``latex``, das verschiedene Methoden
     171hat, die Sie sich auflisten lassen können indem Sie ``latex.``
     172eingeben und die Tab Taste drücken (beachten Sie den Punkt).
     173
     174Ein gutes Beispiel ist die ``latex.matrix_delimiters`` Methode. Es
     175kann benutzt werden um die Darstellung der Matrizen zu beeinflussen --
     176runde Klammern, eckige Klammern, geschwungene Klammern oder senkrechte
     177Striche. Sie müssen sich nicht für eine Darstellung entscheiden, Sie
     178können verschiedene miteinander kombinieren, wie Sie es
     179wünschen. Beachten Sie dass die in LaTeX benötigten  Backslashes einen
     180zusätzlichen Slash benötigen damit sie in Python korrekt erkannt
     181werden. ::
     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
     202Die ``latex.vector_delimiters`` Methode funktioniert ähnlich.
     203
     204Die Darstellung von Ringen und Körpern (ganze, rationale, reelle
     205Zahlen, etc.) kann mit der ``latex.blackboard_bold`` Methode verändert
     206werden. Diese Mengen werden in standardmäßig in fett gedruckt,
     207alternativ können sie auch mit Doppelstrichen geschrieben
     208werden. Hierfür wird das  ``\Bold{}``-Makro genutzt, das in Sage
     209integriert 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
     222Dank der Erweiterbarkeit von TeX können Sie selbst Makros und Pakete
     223einbinden. Individuelle Makros können hinzugefügt werden, die dann von
     224jsMath 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
     240Zusätzliche Makros, die so hinzugefügt wurden, werden auch vom
     241systemweiten TeX genutzt, wenn jsMath an seine Grenzen gestoßen ist.
     242Der Befehl ``latex_extra_preamble`` kann genutzt werden um eine
     243Präambel eines kompletten LaTeX Dokuments zu erzeugen, das folgende
     244Beispiel zeigt wie. Beachten Sie wiederrum die doppelten Backslashes
     245in 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
     262Für größere oder kompliziertere LaTeX-Ausdrücke können mit
     263``latex.add_to_preamble`` Pakete (oder ähnliches) zur LaTeX-Präambel
     264hinzugefügt werden. Der zweite Befehl
     265``latex.add_package_to_preamble_if_available``  prüft hingegen erst ob
     266das Paket vorhanden ist, bevor es eingebunden wird.
     267
     268Hier fügen wir das geometry-Paket zur Präambel hinzu, um die
     269Seitenränder einzustellen. Achten Sie wieder auf die doppelten
     270Backslashes 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
     286Ein bestimmtes Paket, dessen Existenz nicht sicher ist, wird wie folgt
     287eingebunden. ::
     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
     301Anpassen der LaTeX-Verarbeitung
     302===============================
     303
     304Es ist möglich zu entscheiden welche Variante von TeX für einen
     305systemweiten Aufruf genutzt werden soll, und somit auch wie die
     306Ausgabe aussehen soll. Ebenso ist es möglich zu beeinflussen, ob das
     307Notebook jsMath oder die systemweite LaTeX Installation nutzt.
     308
     309Der Befehl ``latex.engine()`` entscheidet, ob die systemweiten
     310Anwendungen ``latex``, ``pdflatex`` oder ``xelatex`` genutzt werden
     311für kompliziertere LaTeX-Ausdrücke. Wenn ``view()`` in der Sage
     312Kommandozeile aufgerufen wird, und ``latex`` als Prozessor eingestellt
     313ist, wird eine .dvi Datei erzeugt, die dann mit einem dvi
     314Anzeigeprogramm (wie xdvi) angezeigt wird. Im Gegensatz hierzu wird
     315bei Aufruf von ``view()`` mit dem Prozessor ``pdflatex`` eine .PDF
     316Datei erzeugt, die mit dem Standard-PDF-Programm angezeigt
     317wird. (acrobat, okular, evince, etc.).
     318
     319Im Notebook kann es nötig sein, dem System die Entscheidung
     320abzunehmen, ob jsMath für einige TeX-Schnipsel, oder das systemweite
     321LaTeX für kompliziertere Ausdrücke genutzt werden soll. Es gibt eine
     322Liste von Befehlen, die wenn einer von ihnen in einem Stück LaTeX-Code
     323erkannt wird, die Ausgabe von LaTeX (oder welcher Prozessor auch immer
     324durch ``latex.engine()`` gesetzt ist) statt von jsMath erstellen
     325lä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
     342Nehmen wir an ein LaTeX-Ausdruck wurde im Notebook durch ``view()``
     343oder während aktiviertem "Typeset" Knopf erzeugt. Und dann wird
     344festgestellt, dass er die externe LaTeX-Installation benötigt, weil
     345er in der ``jsmath_avoid_list`` steht. Der Ausdruck wird nun vom
     346ausgewählten (durch ``latex.engine()``) Prozessor erzeugt, und statt
     347der Anzeige in einem externen Programm (was in der Kommandozeile
     348passieren  würde) wird Sage versuchen das Ergebnis in einem einzigen,
     349leicht beschnittenen Bild in der Ausgabezelle darzustellen.
     350
     351Wie diese Umwandlung abläuft hängt von einigen Faktoren ab,
     352hauptsächlich vom verwendeten LaTeX-Prozessor und davon welche
     353Konvertierungswerkzeuge auf dem System vorhanden sind. Vier nützliche
     354Konverter, 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
     357wieder im Arbeitsblatt eingebunden werden kann. Wenn ein
     358LaTeX-Ausdruck erfolgreich von ``latex`` in eine .dvi Datei verwandelt
     359wird, dann sollte dvipng die Umwandlung vornehmen. Wenn der LaTeX
     360Ausdruck und der gewählte LaTeX-Prozessor eine .dvi Datei mit
     361Erweiterungen erstellt, die dvipng nicht unterstützt, so wird dvips
     362eine PostScript-Datei erzeugen. So eine PostScript-Datei, oder eine
     363.pdf Datei aus dem Prozessor ``pdflatex``, wird dann von ``convert``
     364in eine .png Datei gewandelt. Das Vorhandensein von zweier solcher
     365Konverter kann mit Hilfe der ``have_dvipng()`` und ``have_convert()``
     366Routinen überprüft werden.
     367
     368Diese Umwandlungen werden automatisch ausgeführt, wenn Sie die nötigen
     369Konverter installiert haben; falls nicht wird Ihnen eine Fehlermeldung
     370angezeigt, die Ihnen sagt was fehlt und wo Sie es herunterladen können.
     371
     372Für ein konkretes Beispiel wie komplizierte LaTeX-Ausdrücke
     373verarbeitet werden können, sehen Sie sich das Beispiel des
     374``tkz-graph`` Pakets zum Erstellen von hochwertigen kombinatorischen
     375Graphen im nächsten Abschnitt (:ref:`sec-tkz-graph`) an. Für weitere
     376Beispiele gibt es einige vorgepackte Testfälle. Um diese zu nutzen,
     377müssen Sie das ``sage.misc.latex.latex_examples`` Objekt
     378importieren. Dieses ist eine Instanz der
     379``sage.misc.latex.LatexExamples`` Klasse, wie unten beschrieben. Diese
     380Klasse enthält momentan Beispiele von kommutativen Diagrammen,
     381kombinatorischen Graphen, Knotentheorie und Beispiele für Graphen mit
     382pstricks. Es werden damit die folgenden Pakete getestet: xy,
     383tkz-graph, xypic, pstricks.  Nach dem Import können Sie mittels
     384Tab-Vervollständigung von ``latex_examples`` die vorgepackten
     385Beispiele sehen. Bei Aufruf vom jedem Beispiel erhalten Sie eine
     386Erklärung was nötig ist, damit das Beispiel korrekt dargestellt
     387wird. Um die Darstellung tatsächlich zu sehen müssen Sie ``view()``
     388benutzen (sofern die Präambel, der LaTeX-Prozessor, etc richtig
     389eingestellt 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
     407Ein Beispiel: Kombinatorische Graphen mit tkz-graph
     408===================================================
     409
     410Hochwertige Darstellungen von kombinatorischen Graphen (fortan nur
     411noch "Graphen") sind mit Hilfe des ``tkz-graph`` Pakets möglich.
     412Dieses Paket wurde ausbauend auf das ``tikz`` front-end der ``pgf``
     413Bibliothek entwickelt. Es müssen also all diese Komponenten Teil der
     414systemweiten TeX-Installation sein, und es ist möglich, dass sie nicht
     415in ihrer neusten Version in der TeX-Implementation vorliegen. Es ist
     416also unter Umständen nötig oder ratsam diese Teile separat in Ihrem
     417persönlichen texmf Baum zu installieren. Das Erstellen, Anpassen und
     418Warten einer systemweiten oder persönlichen TeX-Installation würde
     419allerdings den Rahmen dieses Dokuments sprengen. Es sollte aber
     420einfach sein Anleitungen hierzu zu finden. Die nötigen Dateien sind
     421unter :ref:`sec-system-wide-tex` aufgeführt.
     422
     423Um also zu beginnen, müssen wir sicher sein, dass die relevanten
     424Pakete eingefügt werden, indem wir sie in die Präambel des
     425LaTeX-Dokuments hinzufügen. Die Bilder der Graphen werden nicht
     426korrekt formatiert sein, wenn eine .dvi Datei als Zwischenergebnis
     427erzeugt 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
     430erfolgreich eine .pdf Datei mit einem  Bild vom kompletten `K_4`
     431Graphen erzeugen.
     432
     433Um das Gleiche im Notebook zu erstellen, müssen Sie jsMath
     434für die Verarbeitung von LaTeX-Code ausschalten, indem Sie
     435die "jsmath avoid list" benutzen. Graphen werden in einer
     436``tikzpicture`` Umgebung eingebunden, das ist also eine gute Wahl
     437für die Zeichenkette für die Ausschlussliste. Jetzt sollte
     438``view(graphs.CompleteGraph(4))`` in einem Arbeitsblatt
     439eine .pdf Datei mit pdflatex erstellen, mit dem
     440``convert`` Werkzeug eine .png Grafik erstellen und in die Ausgabezelle
     441des Arbeitsblatts einfügen.
     442Die folgenden Befehle veranschaulichen die Schritte einen Graphen
     443mittels 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
     454Beachten Sie, dass es eine Vielzahl von Optionen gibt, die die
     455Darstellung des Graphen in LaTeX mit ``tkz-graph`` beeinflussen. Auch
     456das wiederrum ist nicht Ziel dieses Abschnitts. Sehen Sie sich hierfür
     457den Abschnitt "LaTeX-Optionen für Graphen" aus dem Handbuch für
     458weitere Anleitungen und Details an.
     459
     460.. _sec-system-wide-tex:
     461
     462Eine vollfunktionsfähige TeX-Installation
     463=========================================
     464Viele der erweiterten Integrationsmöglichkeiten von
     465TeX in Sage benötigen eine systemweite Installation von TeX.
     466Viele Linuxdistributionen bieten bereits TeX-Pakete basierend auf
     467TeX-live, für OSX gibt es TeXshop und für Windows MikTeX.
     468Das ``convert`` Werkzeug ist Teil der
     469`ImageMagick <http://www.imagemagick.org/>`_ Suite (welche ein
     470Paket oder zumindest ein simpler Download sein sollte). Die drei
     471Programme ``dvipng``, ``ps2pdf``, und ``dvips`` sind wahrscheinlich
     472bereits Teil Ihrer TeX Distribution.  Die ersten beiden sollten
     473auch von http://sourceforge.net/projects/dvipng/ als Teil von
     474`Ghostscript <http://www.ghostscript.com/>`_ bezogen werden können.
     475
     476Um kombinatorische Graphen darstellen zu können, wird eine aktuelle Version
     477der PGF Bibliothek und die Dateien ``tkz-graph.sty``, ``tkz-arith.sty``
     478und eventuell ``tkz-berge.sty`` benötigt, allesamt verfügbar auf der `Altermundus Seite
     479<http://altermundus.com/pages/graph.html>`_.
     480
     481Externe Programme
     482=================
     483
     484Es sind drei Programme verfügbar um TeX weiter in Sage zu integrieren.
     485Das erste ist sagetex. Eine kurze Beschreibung von sagetex wäre: Es ist
     486eine Sammlung von TeX-Makros, die es einem LaTeX-Dokument erlauben
     487Anweisungen einzubinden, mit denen Sage genutzt wird um verschiedene
     488Objekte zu berechnen und/oder mittels eingebauter ``latex()``-Funktion darzustellen.
     489Als Zwischenschritt zum Kompilieren eines LaTeX-Dokuments werden also
     490alle Berechnungs- oder LaTeX-Formatierungseigenschaften von Sage automatisch genutzt.
     491Als Beispiel hierfür kann in einer mathematischen Betrachtung die korrekte Reihenfolge
     492von Fragen und Antworten beibehalten werden, indem sagetex dazu genutzt wird Sage die einen
     493aus den anderen berechnen zu lassen. Siehe hierfür auch :ref:`sec-sagetex`
     494
     495tex2sws beginnt mit einem LaTeX-Dokument, aber definiert einige zusätzliche
     496Umgebungen für Sage Code. Wenn es richtig genutzt wird, ist das Ergebnis ein
     497Sage Arbeitsblatt mit korrekt von jsMath formatiertem Inhalt und dem dazugehörigen
     498Sage Code in den Eingabezellen. Ein Lehrbuch oder Artikel kann also mit Sage Code Blöcken
     499in LaTeX gesetzt werden und es kann "live" das ganze Dokument in ein Sage Arbeitsblatt überführt werden;
     500unter Beibehaltung der Sage Code Blöcke und mit schön formatiertem mathematischen Text.
     501Momentan in Arbeit, siehe `tex2sws @ BitBucket
     502<http://bitbucket.org/rbeezer/tex2sws/>`_ .
     503
     504sws2tex kehrt den Prozess um, indem es mit einem Sage Arbeitsblatt beginnt, und
     505es in ein legitimes LaTeX-Dokument zur weiteren Bearbeitung mit allen
     506LaTeX-Werkzeugen verwandelt.
     507Momentan 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**************
     2Programmierung
     3**************
     4
     5.. _section-loadattach:
     6
     7Sage-Dateien Laden und Anhängen
     8===============================
     9
     10Als nächstes zeigen wir wie man Programme, die einer separaten Datei
     11geschrieben 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
     21Sie 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
     32Sie können auch eine Sage-Datei an eine laufende Sitzung anhängen,
     33indem Sie den ``attach``-Befehl verwenden:
     34
     35.. skip
     36
     37::
     38
     39    sage: attach "beispiel.sage"
     40    Hello World
     41    8
     42
     43Wenn Sie nun ``beispiel.sage`` verändern und eine Leerzeile in Sage eingeben
     44(d.h. ``return`` drüchen) wird der Inhalt von ``beispiel.sage``
     45automatisch in Sage neu geladen.
     46
     47Insbesondere lädt der ``attach``-Befehl eine Datei jedesmal, wenn
     48diese verändert wird automatisch neu, was beim Debuggen von Code
     49nützlich sein kann, wobei der ``load``-Befehl eine Datei nur einmal lädt.
     50
     51Wenn Sage die Datei ``beispiel.sage`` lädt, wird sie zu Python-Code konvertiert,
     52welcher dann vom Python-Interpreter ausgeführt wird. Diese
     53Konvertierung ist geringfügig; sie besteht hautsächlich daraus
     54Integer-Literale mit ``Integer()`` und Fließkomma-Literale mit
     55``RealNumber()`` zu versehen, ``^`` durch ``**`` zu ersetzen und
     56z.B. ``R.2`` durch ``R.gen(2)`` auszutauschen. Die konvertierte
     57Version von ``beispiel.sage`` befindet sich im gleichen Verzeichnis wie
     58``beispiel.sage`` und ist ``beispiel.sage.py`` genannt. Diese Datei
     59enthält den folgenden Code:
     60
     61::
     62
     63    print "Hello World"
     64    print Integer(2)**Integer(3)
     65
     66Integer-Literale wurden mit Integer() versehen und das ``^`` wurde
     67durch ein ``**`` ersetzt.
     68(In Python bedeutet ``^`` "exklusives oder" und ``**`` bedeutet
     69"Exponentiation".)
     70
     71Dieses "preparsing" ist in ``sage/misc/interpreter.py`` implementiert.)
     72
     73Sie können mehrzeiligen eingerückten Code in Sage einfügen, solange
     74Zeilenenden neue Blöcke kenntlich machen (dies ist in Dateien nicht notwendig).
     75Jedoch beseht die beste Möglichkeit solchen Code in Sage einzufügen darin,
     76diesen in einer Datei zu speichern und ``attach`` wie oben beschrieben zu verwenden.
     77
     78
     79.. _section-compile:
     80
     81Kompilierten Code erzeugen
     82==========================
     83
     84Geschwindigkeit ist bei mathematischen Berechnungen äußerst
     85wichtig. Python ist zwar eine komfortable Programmiersprache mit sehr
     86hohen Abstraktionsniveau, jedoch können bestimmte Berechnungen
     87mehrere Größenordnungen schneller als in Python sein, wenn sie in
     88einer kompilierten Sprache mit statischen Datentypen implementiert
     89wurden. Manche Teile von Sage würden zu langsam sein, wenn sie
     90komplett in Python geschrieben wären. Um dies zu berücksichtigen
     91unterstützt Sage eine kompilierte "Version" von Python, welche Cython
     92([Cyt]_ und [Pyr]_) genannt wird. Cython ist gleichzeitig sowohl zu Python,
     93als auch zu C ähnlich. Die meisten von Pythons Konstruktionen,
     94einschließlich "list comprehensions", bedingte Ausdrücke und Code wie
     95``+=`` sind erlaubt; Sie können auch Code importieren, den Sie in
     96anderen Python-Modulen geschrieben haben. Darüberhinaus können Sie
     97beliebige C Variablen definieren und beliebe C-Bibliothekaufrufe
     98direkt ausführen. Der daraus entstehende Code wird nach C konvertiert
     99und mithilfe eines C-Compilers kompiliert.
     100
     101Um eigenen kompilierten Sagecode zu erstellen, geben Sie der Datei eine
     102``.spyx`` Endung (anstelle von ``.sage``). Falls Sie mit der
     103Kommandozeile arbeiten, können Sie kompilierten Code genau wie
     104interpretierten Code anhängen und laden. (Im Moment wird das Anhängen
     105von Cythoncode vom Notebook aus nicht unterstützt).
     106Die tatsächliche Kompilierung wird "hinter den Kulissen" durchgeführt
     107ohne dass Sie explizit etwas tun müssen. Schauen Sie sich
     108``$SAGE_ROOT/examples/programming/sagex/factorial.spyx`` an, um ein
     109Beispiel einer kompilierten Implementation der Fakultätsfunktion zu
     110sehen, welche die GMP-C-Bibliothek unmittelbar benutzt. Um dies
     111selbst auszuprobierten, wechseln Sie in das Verzeichnis
     112``$SAGE_ROOT/examples/programming/sagex/`` und führen Sie Folgendes
     113aus:
     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
     129Hier gibt das abschließende L ein "Python long integer" zu erkennen
     130(Lesen Sie :ref:`section-mathannoy`).
     131
     132Beachten Sie, dass Sage ``factorial.spyx`` neu kompiliert falls Sie
     133Sage beenden und neustarten.
     134Die komplierte "shared object library" wird unter
     135``$HOME/.sage/temp/hostname/pid/spyx`` gespeichert. Diese Dateien
     136werden gelöscht wenn Sie Sage beenden.
     137
     138Auf spyx-Dateien wird kein "preparsing" angewendet, d.h. ``1/3`` wird
     139in einer spyx-Datei zu 0 ausgewertet, anstelle der rationalen Zahl
     140:math:`1/3`.
     141Wenn ``foo`` eine Funktion in der Sage-Bibliothek ist die Sie
     142verwenden 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
     151Auf C-Funktionen in separaten Dateien zugreifen
     152-----------------------------------------------
     153
     154Es ist auch nicht schwer auf C-Funktions zuzugreifen  welche in
     155separaten \*.c Dateien definiert sind. Hier ist ein Beispiel. Erzeugen
     156Sie die Dateien ``test.c`` und ``test.spyx`` in dem gleichen
     157Verzeichnis mit den Inhalten:
     158
     159Der reine C-Code: ``test.c``
     160
     161::
     162
     163    int add_one(int n) {
     164      return n + 1;
     165    }
     166
     167Der 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
     177Dann 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
     188Wenn die zusätzliche Bibliothek ``foo`` gebraucht wird um den C-Code,
     189der aus einer Cython-Datei generiert wurde zu kompilieren, fügen Sie
     190die Zeile ``clib foo`` zu dem Cython-Quellcode hinzu. Auf ähnliche
     191Weise kann eine zusätzliche Datei ``bar`` zu der Kompilierung mit der
     192Deklaration ``cfile bar`` hinzugefügt werden.
     193
     194.. _section-standalone:
     195
     196eigenständige Python/Sage Skripte
     197=================================
     198
     199Das folgende eigenständige Sageskript faktorisiert ganze Zahlen,
     200Polynome, 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
     216Um dieses Skript benutzen zu können muss ``SAGE_ROOT`` in ihrer
     217PATH-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
     227Datentypen
     228==========
     229
     230Jedes Objekt hat in Sage einen wohldefinierten Datentyp. Python
     231besitzt eine Vielzahl von standardmäßiger elementarer Datentypen und die
     232Sage-Bibliothek fügt noch viele weitere hinzu. Zu Pythons
     233standardmäßigen Datentypen gehören Strings, Listen, Tupel, Ganzzahlen und
     234Gleitkommazahlen, 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
     251Hierzu 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
     260Nur bestimmte Funktionen können auf ``V`` aufgerufen werden. In
     261anderen mathematischen Softwaresystemem würde dies mit der
     262"Funktionalen"-Notation ``foo(V,...)`` geschehen. In Sage sind
     263bestimmte Funktionen an den Typ (oder der Klasse) von ``V`` angehängt,
     264und diese werden unter Benutzung einer objektorientierten Syntax,
     265wie in Java oder C++ aufgerufen. Zum Beispiel ``V.foo(...)``. Dies
     266hilft dabei eine Überfüllung des globalen Namensraums mit tausenden
     267von Funktionen zu vermeiden. Das bedeutet auch, dass viele
     268verschiedene Funktionen mit unterschiedlichen Funktionsweisen foo
     269genannt werden können, ohne dass der Typ des Arguments überprüft (oder
     270Case-Anweisungen ausgeführt) werden muss, um zu entscheiden welche
     271aufgerufen werden soll. Weiterhin ist die Funktion auch dann noch
     272verfügbar, wenn ihr Name zu einem anderen Zweck verwendet wurde. (Zum
     273Beispiel wenn Sie etwas ``zeta`` nennen und dann den Wert der
     274Riemannschen Zeta-Funktion bei 0.5 berechnen wollen, können Sie
     275immernoch ``s=.5; s.zeta()`` benutzen).
     276
     277::
     278
     279    sage: zeta = -1
     280    sage: s=.5; s.zeta()     
     281    -1.46035450880959
     282
     283In manchen sehr oft auftretenden Fällen wird auch die gewöhnliche
     284funktionale Notation unterstützt, da dies bequem ist und manche
     285mathematische Ausdrücke in objektorientierter Notation verwirrend
     286aussehen 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
     315Um alle Member-Funktionen von :math:`A` anzuzeigen, können Sie die
     316Tab-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
     320Listen, Tupel, und Folgen
     321=========================
     322
     323Der Listen-Datentyp speichert Elemente eines beliebigen Typs. Wie in
     324C, C++, usw. (jedoch anders als in vielen gewöhnlichen
     325Computer-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
     340kein Python int ist!)
     341Mit einem Sage-Integer (oder Rational, oder mit allem anderen mit einer ``__index__`` Methode)
     342funktioniert 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
     355Die ``range``-Funktion erzeugt eine Liste von Python int's (nicht
     356Sage-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
     363Dies ist nützlich wenn man List-Comprehensions verwendet um Listen zu
     364konstruieren:
     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
     378Um mehr darüber zu erfahren wie man Listen mit Hilfe von
     379List-Comprehensions erzeugt, lesen Sie [PyT]_.
     380
     381List-Slicing ist eine wunderbare Eigenschaft. Wenn ``L`` eine Liste
     382ist, dann gibt ``L[m:n]`` die Teilliste von ``L`` zurück, die erhalten
     383wird 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
     398Tupel sind ähnlich wie Listen, außer dass sie unveränderbar sind, was
     399bedeutet dass sie, sobald sie erzeugt wurden, nicht mehr verändert werden
     400kö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
     413Folgen sind ein dritter an Listen angelehnter Sage-Datentyp. Anders
     414als Listen und Tupel, sind Folgen kein gewöhnlicher Python-Datentyp.
     415Standardmäßig sind Folgen veränderbar, mit der
     416``Sequence``-Klassenmethode ``set_immutable`` können sie auf unveränderbar
     417gestellt werden, wie das folgende Beispiel zeigt. Alle Elemente einer
     418Folge 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
     439Folgen sind von Listen abgeleitet und können überall dort verwendet werden, wo auch
     440Listen 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
     452Ein weiteres Beispiel von unveränderbaren Folgen sind Basen von
     453Vektorrä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
     472Dictionaries
     473============
     474
     475Ein Dictionary (manchmal auch assoziativer Array genannt) ist eine
     476Abbildung von 'hashbaren' Objekten (z.B. Strings, Zahlen und Tupel;
     477Lesen Sie die Python documentation
     478http://docs.python.org/tut/node7.html und
     479http://docs.python.org/lib/typesmapping.html für weitere Details) zu
     480beliebigen 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
     496Der dritte "key" zeigt, dass Indizes eines Dictionaries kompliziert,
     497also beispielsweise der Ring der ganzen Zahlen, sein können.
     498
     499Sie können das obige Dictionary auch in eine Liste mit den gleichen
     500Daten umwandeln:
     501
     502.. link
     503
     504::
     505
     506    sage: d.items()
     507    [(1, 5), ('sage', 17), (Integer Ring, Finite Field of size 7)]
     508
     509Eine häufig vorkommende Ausdrucksweise ist über einem Paar in einem
     510Dictionary 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
     518Ein Dictionary ist ungeordnet, wie die letzte Ausgabe verdeutlicht.
     519
     520Mengen
     521======
     522
     523Python hat einen standardmäßigen Mengen-Datentyp. Sein Hauptmerkmal
     524ist, neben weiteren typischen Mengenoperationen, dass das Nachschlagen
     525ob 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
     541Sage besitzt auch einen eigenen Mengen-Datentyp, welcher (manchmal)
     542mit Hilfe des standardmäßigen Python-Mengen-Datentyps implementiert
     543ist, jedoch darüberhinaus manche Sage-spezifischen Funktionen
     544aufweist. Sie können eine Sage-Menge erzeugen indem Sie ``Set(...)``
     545verwenden. 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
     561Iteratoren
     562==========
     563
     564Iteratoren sind seit Version 2.2 ein Teil von Python und erweisen sich
     565in mathematischen Anwendungen als besonders nützlich. Wir geben hier
     566ein paar Beispiele an; Lesen Sie [PyT]_ um weitere Details zu
     567erfahren. Wir erstellen einen Iterator über die Quadrate der
     568nichtnegativen 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
     580Nun erzeugen wir einen Iterator über den Primzahlen der Form :math:`4p+1`
     581wobei 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
     595Bestimmte Ringe, z. B. endliche Körper und die ganzen Zahlen, haben
     596zugehö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
     611Schleifen, Funktionen, Kontrollstrukturen und Vergleiche
     612========================================================
     613
     614Wir 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
     629Beachten Sie den Doppelpunkt am Ende der for-Anweisung (dort befindet
     630sich kein "do" oder "od" wie in GAP oder Maple) und die Einrückung
     631vor dem Schleifenrumpf, dem ``print(i)``. Diese Einrückung ist
     632wichtig. In Sage wird die Einrückung automatisch hinzugefügt wenn Sie
     633nach einem ":" die ``enter``-Taste drücken, wie etwa im Folgenden
     634Beispiel.
     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
     647Das Symbol ``=`` wird bei Zuweisungen verwendet.
     648Das 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
     664Behalten Sie im Gedächtnis, dass die Block-Struktur von ``if``,
     665``for`` und ``while`` Ausdrücken durch die Einrückung bestimmt
     666wird:
     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
     682Natürlich ist dies keine effiziente Implementierung des
     683Legendre-Symbols! Dies soll nur bestimmte Aspekte won Python/Sage
     684verdeutlichen. Die Funktion {kronecker}, welche zu Sage gehört,
     685berechnet das Legendre-Symbol effizient mittels eines Aufrufs von
     686PARIs C-Bibliothek.
     687
     688Schließlich merken wir an, dass Vergleiche wie ``==``, ``!=``, ``<=``,
     689``>=``, ``>``, ``<`` von zwei Zahlen automatisch beide Zahlen in den
     690gleichen 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
     701Fast immer können zwei beliebige Objekte verglichen werden. Es gibt
     702keine Voraussetzung die besagt, dass die Objekte mit einer totalen Ordnung
     703versehen 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
     713Nutzen 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
     722Beim Vergleichen von Objekten unterschiedlichen Typs versucht Sage in
     723den meisten Fällen eine kanonische Umwandlung beider Objekte in einen
     724gemeinsamen Typ zu finden. Falls erfolgreich wird der Vergleich auf den
     725umgewandelten Objekten durchgeführt; Falls nicht erfolgreich werden
     726die Objekte als ungleich angesehen. Um zu Testen, ob zwei Variablen
     727auf 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
     738In den folgenden zwei Zeilen ist der erste Gleichheitstest ``False``,
     739da es keinen kanonischen Morphismus :math:`\QQ\ \to \GF{5}` gibt,
     740also gibt es keine kanonische Möglichkeit die  :math:`1` in :math:`\GF{5}`
     741mit der :math:`1 \in \QQ` zu vergleichen. Im Gegensatz dazu gibt es
     742eine kanonische Abbildung :math:`\ZZ \to \GF{5}`, also ist der zweite
     743Gleichheitstest ``True``. Beachten Sie auch, dass die Reihenfolge
     744keine 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
     757WARNUNG: Vergleiche in Sage sind restriktiver als in Magma, welches
     758die :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
     765Profiling
     766=========
     767
     768Autor des Abschnitts: Martin Albrecht (malb@informatik.uni-bremen.de)
     769
     770    "Premature optimization is the root of all evil." - Donald Knuth
     771
     772
     773Manchmal ist es nützlich nach Engstellen im Code zu suchen, um zu
     774verstehen welche Abschnitte die meiste Berechnungszeit beanspruchen;
     775dies kann ein guter Hinweis darauf sein, welche Teile optimiert werden
     776sollten. Python, und daher auch Sage, stellen mehrere "Profiling" -- so
     777wird dieser Prozess genannt -- Optionen zur Verfügung.
     778
     779Am einfachsten zu Benutzen ist das ``prun``-Kommando in der
     780interaktiven Shell. Es gibt eine Zusammenfassung zurück, die
     781beschreibt welche Funktionen wie viel Berechnungszeit veranschlagt haben.
     782Um die (zu diesem Zeitpunkt langsame) Matrixmultiplikation über
     783endlichen 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
     810Hier ist ``ncalls`` die Anzahl der Aufrufe, ``tottime`` ist die
     811Gesamtzeit, die für die Funktion verwendet wurde (ausgenommen der
     812Zeit, die für Unterfunktionsaufrufe verwendet wurde), ``percall`` ist
     813der Quotient von  ``tottime`` geteilt durch ``ncalls``. ``cumtime``
     814ist die Gesamtzeit, die für diese Funktion und alle
     815Unterfunktionsaufrufe (d.h., vom Aufruf bis zum Ende) verwendet
     816wurde, ``percall`` ist der Quotient von ``cumtime`` geteilt durch die
     817Zeit elementarer Funktionsaufrufe, und ``filename:lineno(function)``
     818stellt die entsprechenden Daten jeder Funktion zur Verfügung. Die
     819Daumenregel ist hier: Je höher die Funktion in dieser Liste steht,
     820desto teurer ist sie. Also ist sie interessanter für Optimierungen.
     821
     822Wie sonst auch stellt ``prun?`` Details zur Benutzung des Profilers
     823und zum Verstehen seines Outputs zur Verfügung.
     824
     825Die Profilierungsdaten können auch in ein Objekt geschrieben werden um
     826eine weitere Untersuchung zu ermöglichen:
     827
     828.. skip
     829
     830::
     831
     832    sage: %prun -r A*A
     833    sage: stats = _
     834    sage: stats?
     835
     836Beachten Sie: das Eingeben von ``stats = prun -r A\*A`` erzeugt eine
     837Syntaxfehlermeldung, da prun ein IPython-Shell-Kommando ist und keine
     838reguläre Funktion.
     839
     840Um eine schöne graphische Repräsentation der Profilerdaten zu
     841erhalten, können Sie den "hotshot-Profiler", ein kleines Skript
     842genannt ``hotshot2cachetree`` und das Programm ``kcachegrind`` (nur
     843fü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
     863Dies führt zu einer Datei ``pythongrind.prof`` in aktuellen
     864Datenverzeichnis. Diese kann nun zur Visualisierung in das
     865cachegrind-Format konvertiert werden.
     866
     867Tippen Sie in einer System-Shell:
     868
     869.. skip
     870
     871::
     872
     873    hotshot2calltree -o cachegrind.out.42 pythongrind.prof
     874
     875Die Ausgabedatei ``cachegrind.out.42`` kann nun mit ``kcachegrind``
     876untersucht 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**************
     4SageTeX nutzen
     5**************
     6
     7Das SageTeX Paket ermöglicht es Ihnen die Ergebnisse von Sage Berechnungen
     8direkt in ein LaTeX-Dokument zu setzen. Es wird standardmäßig mit Sage
     9installiert. Um es zu nutzen müssen Sie es lediglich in Ihrem lokalen
     10TeX-System "installieren", wobei "installieren" hier eine einzige Datei
     11kopieren bedeutet. Siehe hierfür auch :ref:`installation` in diesem
     12Tutorial 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
     15Installationsanleitung führen) um weitere Informationen zu erhalten.
     16
     17Hier stellen wir ein sehr kurzes Beispiel vor wie man SageTeX nutzt.
     18Die komplette Dokumentation finden Sie unter ``SAGE_ROOT/local/share/texmf/tex/generic/sagetex``,
     19wobei ``SAGE_ROOT`` das Installationsverzeichnis von Sage ist. Dieses Verzeichnis
     20enthält die Dokumentation, eine Beispieldatei und einige nützliche Python Skripte.
     21
     22Um zu sehen wie SageTeX funktioniert, folgen Sie den Anweisungen zur Installation von
     23SageTeX (in :ref:`installation`) und kopieren Sie den folgenden Text in eine Datei namens -
     24sagen 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
     64Lassen Sie LaTeX ganz normal über ``st_example.tex`` laufen. Beachten Sie dabei, dass LaTeX
     65sich ü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
     75Beachten Sie, dass zusätzlich zu den Dateien, die LaTeX normalerweise produziert
     76noch eine Datei ``st_example.sage`` erscheint. Das ist das Sage Skript, das
     77erstellt wurde als Sie LaTeX mit ``st_example.tex`` aufgerufen haben. Wie Ihnen die
     78Warnmeldung mitteilte sollten Sie Sage über die Datei ``st_example.sage`` laufen lassen,
     79also 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
     81Datei namens ``st_example.sout`` von Sage erstellt wurde. Diese Datei enthält die Ergebnisse
     82von Sages Berechnungen in einem Format, das LaTeX nutzen kann um es in Ihren Text einzufügen.
     83Ein neues Verzeichnis mit einer .eps Datei Ihres Plots wurde ebenfalls erstellt.
     84Lassen Sie LaTeX nun erneut laufen, und Sie werden sehen, dass alles was Sage berechnet und
     85geplottet hat nun in Ihrem Dokument erscheint.
     86
     87Die verschiednenen verwendeten Makros sollten einfach zu verstehen sein.
     88Eine ``sageblock`` Umgebung setzt Ihren Code unverändert und führt ihn auch
     89aus wenn Sie Sage laufen lassen. Wenn Sie etwa ``\sage{foo}`` schreiben, wird
     90das Ergebnis des Aufrufs ``latex(foo)`` (in Sage) in Ihrem Dokument erscheinen.
     91Plot-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')``
     93in Sage aufrufen würden.
     94
     95Grundsä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
     101Sie können das Aufrufen von Sage weglassen, wenn Sie keine Änderung
     102an den Sage Befehlen in Ihrem Dokument vorgenommen haben.
     103
     104Es gibt noch viel mehr über SageTeX zu sagen, aber da sowohl Sage alsauch
     105LaTeX 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*********************
     2Eine begleitende Tour
     3*********************
     4
     5Dieser Abschnitt ist eine begleitende Tour einiger in Sage vorhandener
     6Funktionen. Um viele weitere Beispiele zu sehen, schauen Sie sich
     7`Sage Constructions
     8<http://www.sagemath.org/doc/constructions/index.html>`_ an. Dies ist
     9dazu gedacht, die allgemeine Frage  "Wie konstruiere ich ... in Sage?"
     10zu beantworten. Schauen Sie sich auch das `Sage Reference Manual
     11<http://www.sagemath.org/doc/reference/index.html>`_  an, welches
     12Tausende weiterer Beispiele beinhaltet. Beachten Sie auch, dass Sie
     13diese Tour interaktiv im Sage-Notebook durcharbeiten können,
     14indem 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
     18Eingabe sogar verändern bevor Sie ``shift-enter`` drücken. Auf einigen Macs
     19mü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
    - +  
     1Etwas weiter fortgeschrittene Mathematik
     2========================================
     3
     4Algebraische Geometrie
     5----------------------
     6
     7Sie können in Sage beliebige algebraische Varietäten definieren, aber
     8manchmal ist die nichttriviale Funktionalität auf Ringe über
     9:math:`\QQ` oder endliche Körper beschränkt. Zum Beispiel können wir
     10die Vereinigung zweier affiner, planarer Kurven berechnen, und dann
     11die 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
     30Wir können auch alle Punkte im Schnitt der beiden Kurven finden, indem
     31wir 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
     51Also sind zum Beispiel :math:`(1,0)` und :math:`(0,1)` auf beiden
     52Kurven (wie man sofort sieht), genauso wie bestimmte (quadratischen)
     53Punkte, deren :math:`y` Koordinaten :math:`2y^2 + 4y + 3=0` erfüllen.
     54
     55Sage kann auch das torische Ideal der gedrehten Kubik im
     56dreidimensionalen 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
     79Elliptische Kurven
     80------------------
     81
     82Die Funktionalität elliptischer Kurven beinhaltet die meisten von
     83PARIs Funktionen zu elliptischen Kurven, den Zugriff auf die Daten von
     84Cremonas Online-Tabellen (dies benötigt ein optionales
     85Datenbankpaket), die Funktionen von mwrank, d.h.
     862-Abstiege mit der Berechnung der vollen Mordell-Weil-Gruppe, der SEA
     87Algorithmus, Berechnung aller Isogenien, viel neuem Code für Kurven
     88über :math:`\QQ` und Teile von Denis Simons "algebraic descent" Software.
     89
     90Der Befehl ``EllipticCurve`` zum Erzeugen von Elliptischen Kurven hat
     91viele 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
     122Wir 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
     144Das 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
     146in Sage zu erzeugen, geben Sie ``E([0,0])`` ein. Sage kann auf einer
     147solchen elliptischen Kurve Punkte addieren (erinnern Sie sich:
     148elliptische Kurven haben eine additive Gruppenstruktur, wobei der unendlich
     149ferne Punkt das Nullelement ist, und drei kollineare Punkte auf
     150der 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
     167Die 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
     180Wenn wir eine Kurve mit der gleichen :math:`j`-Invarianten wie
     181:math:`E` erstellen, muss diese nicht isomorph zu :math:`E` sein. Im
     182folgenden Beispiel sind die Kurven nicht isomorph, da ihre Führer
     183unterschiedlich sind.
     184
     185::
     186
     187    sage: F = EllipticCurve_from_j(110592/37)
     188    sage: F.conductor()
     189    37
     190
     191Jedoch 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
     204Wir können die Koeffizienten :math:`a_n` der zur elliptischen Kurve
     205gehörenden :math:`L`-Reihe oder der Modulform
     206:math:`\sum_{n=0}^\infty a_nq^n` berechnen.
     207Die 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
     217Alle Koeffizienten :math:`a_n` bis zu :math:`n\leq 10^5` zu berechnen
     218dauert 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
     228Elliptische Kurven können mit Hilfe ihres Cremona-Labels konstruiert
     229werden. Dies lädt die Kurve zusammen mit Informationen über ihren Rank, mit
     230Tamagawa 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
     247Wir 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
     260Die Objekte, die aus der Datenbank zurückgegeben werden, sind nicht
     261vom Typ ``EllipticCurve``. Sie sind Elemente einer Datenbank und haben
     262ein paar Komponenten, und das war's. Es gibt eine kleine Version von
     263Cremonas Datenbank, die standardmäßig zu Sage gehört und beschränkte
     264Information zu elliptischen Kurven mit Führer :math:`\leq 10000`
     265enthält. Es gibt auch eine große optionale Version, welche ausgiebige
     266Daten zu allen elliptischen Kurven mit Führer bis zu :math:`120000`
     267enthält (Stand Oktober 2005). Es gibt auch ein riesiges (2GB großes)
     268optionales Datenbank-Paket für Sage, das in der Stein-Watkins
     269Datenbank hunderte Millionen von elliptischen Kurven enthält.
     270
     271Dirichlet-Charaktere
     272--------------------
     273
     274Ein *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`
     277mit :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
     293Nachdem wir dies Gruppe erzeugt haben, erstellen wir als nächstes ein
     294Element 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
     317Es ist auch möglich die Operation der Galoisgruppe
     318:math:`\text{Gal}(\QQ(\zeta_N)/\QQ)` auf diesen Charakteren zu
     319berechnen, sowie die Zerlegung in direkte Produkte, die der
     320Faktorisierung 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
     343Als nächstes konstruieren wir die Gruppe der Dirichlet-Charaktere
     344mod 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
     354Nun 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
     371In diesem Beispiel erzeugen wir einen Dirichlet-Charakter mit Werten
     372in einem Zahlenfeld. Wir geben die Wahl der Einheitswurzel im dritten
     373Argument 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
     391Hier teilt ``NumberField(x^4 + 1, 'a')`` Sage mit, dass es das Symbol "a"
     392beim Ausgeben dessen was ``K`` ist (ein Zahlenfeld mit definierendem Polynom
     393:math:`x^4 + 1`) benutzen soll. Der Name "a" ist zu diesem Zeitpunkt
     394nicht deklariert. Sobald ``a = K.0`` (oder äquivalent ``a = K.gen()``)
     395evaluiert wurde, repräsentiert das Symbol "a" eine Wurzel des
     396erzeugenden Polynoms :math:`x^4+1`.
     397
     398
     399Modulformen
     400-------------
     401
     402Sage kann einige Berechnungen im Zusammenhang mit Modulformen
     403durchführen, einschließlich Dimensionsberechnungen, das Berechnen von Räumen von
     404Symbolen von Modulformen, Hecke-Operatoren, und Dekompositionen.
     405
     406Es stehen mehrere Funktionen für das Berechnen von Dimensionen von
     407Rä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
     418Als nächstes illustrieren wir die Berechnung von Hecke-Operatoren auf
     419einem 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
     441Wir können auch Räume für :math:`\Gamma_0(N)` und :math:`\Gamma_1(N)`
     442erzeugen.
     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
     453Nun 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
     474Wir 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
     497Hier ist ein weiteres Beispiel davon wie Sage mit den Operationen von
     498Hecke-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
     530Sei :math:`T_p` die Bezeichnung der gewöhnlichen Hecke-Operatoren (:math:`p`
     531prim). 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
    - +  
     1Elementare Algebra und Analysis
     2===============================
     3
     4Sage kann viele zur elementaren Algebra und Analysis gehörende
     5Probleme lösen. Zum Beispiel: Lösungen von Gleichungen finden,
     6Differentiation, Integration, und Laplace-Transformationen
     7berechnen. Lesen Sie die `Sage Constructions
     8<http://www.sagemath.org/doc/constructions/>`_ Dokumentation um
     9weitere Beispiele zu finden.
     10
     11Lösen von Gleichungen
     12---------------------
     13
     14Gleichungen exakt lösen
     15~~~~~~~~~~~~~~~~~~~~~~~
     16
     17Die ``solve`` Funktion löst Gleichungen. Legen Sie zunächst Variablen
     18an, bevor Sie diese benutzen; Die Argumente von ``solve`` sind eine
     19Gleichung (oder ein System von Gleichungen) zusammen mit den
     20Variablen, 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
     28Sie können eine Gleichung nach einer Variablen, in Abhängigkeit von den
     29anderen, 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
     37Sie 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
     45Das folgende Beispiel, in dem Sage benutzt wird um ein System von
     46nichtlinearen Gleichungen zu lösen, stammt von Jason Grout. Zunächst
     47lö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
     60Um eine numerische Approximation der Lösungen zu erhalten können Sie
     61stattdessen 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
     73Argument ist die Anzahl der Bits an Genauigkeit.)
     74
     75Gleichungen numerisch lösen
     76~~~~~~~~~~~~~~~~~~~~~~~~~~~
     77
     78Oftmals kann ``solve`` keine exakte Lösung der angegebenen Gleichung
     79bzw. Gleichungen finden. Wenn dies passiert können Sie ``find_root``
     80verwenden um eine numerische Approximation zu finden. Beispielsweise
     81gibt ``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
     87Wir können jedoch ``find_root`` verwenden um eine Lösung der obigen
     88Gleichung 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
     94Differentiation, Integration, etc.
     95----------------------------------
     96
     97Sage weiß wie man viele Funktionen differenziert und integriert. Zum
     98Beispiel 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
     107Um 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
     114Um die partiellen Ableitungen von :math:`x^2+17y^2` nach *x*
     115beziehungsweise *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
     126Wir machen weiter mit Integralen, sowohl bestimmt als auch
     127unbestimmt. 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
     137Die 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
     147Lösen von Differentialgleichungen
     148---------------------------------
     149
     150Sie können Sage verwenden um gewöhnliche Differentialgleichungen zu
     151berechnen. 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
     161Dies benutzt Sages Schnittstelle zu Maxima [Max]_, daher kann sich die
     162Ausgabe ein wenig von anderen Ausgaben in Sage unterscheiden. In
     163diesem Fall wird mitgeteilt, dass :math:`x(t) = e^{-t}(e^{t}+c)`
     164die allgemeine Lösung der Differentialgleichung ist.
     165
     166Sie können auch Laplace-Transformationen berechnen:
     167Die Laplace-Transformation von :math:`t^2e^t -\sin(t)` wird wie folgt
     168berechnet:
     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
     178Hier ist ein komplizierteres Beispiel. Die Verschiebung des
     179Gleichgewichts einer verkoppelten Feder, die an der linken Wand
     180befestigt ist,
     181
     182::
     183
     184    |------\/\/\/\/\---|Masse1|----\/\/\/\/\/----|Masse2|
     185             Feder1                  Feder2
     186
     187wird durch dieses System der Differentialgleichungen zweiter Ordnung
     188modelliert,
     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
     198wobei :math:`m_{i}` die Masse des Objekts *i*, :math:`x_{i}` die
     199Verschiebung des Gleichgewichts der Masse *i* und :math:`k_{i}` die
     200Federkonstante der Feder *i* ist.
     201
     202**Beispiel:** Benutzen Sie Sage um das obige Problem mit folgenden
     203Werten 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
     208Lö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
     217Das 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
     223Anfangsbuchstaben :math:`x(t)` die Funktion mit großem
     224Anfangsbuchstaben :math:`X(s)` ist). Berechnen Sie die
     225Laplace-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
     233Dies besagt
     234
     235.. math:: -Y'(0) + s^2Y(s) + 2Y(s) - 2X(s) - sy(0) = 0.
     236
     237
     238Setzen 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,
     240die 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
     251Berechnen Sie jetzt die inverse Laplace-Transformierte um die Antwort
     252zu 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
     263Also 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
     268Die 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
     277Die 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
     286Um mehr über das Plotten zu erfahren lesen Sie :ref:`section-plot`. Lesen
     287Sie Abschnitt 5.5 von [NagleEtAl2004]_ um weitere Informationen über
     288Differentialgleichungen zu erhalten.
     289
     290
     291Das Euler-Verfahren zur Lösung von Systemen von Differentialgleichungen
     292-----------------------------------------------------------------------
     293
     294Im nächsten Beispiel illustrieren wir das Euler-Verfahren für ODEs erster
     295und zweiter Ordnung. Wir rufen zunächst die grundlegende Idee für
     296Differentialgleichungen erster Ordnung in Erinnerung. Sei ein
     297Anfangswertproblem der Form
     298
     299.. math::
     300
     301    y'=f(x,y), \quad y(a)=c,
     302
     303gegeben. Wir möchten eine Approximation des Wertes der Lösung bei
     304:math:`x=b` mit :math:`b>a` finden.
     305
     306Machen Sie sich anhand der Definition der Ableitung klar, dass
     307
     308.. math::  y'(x) \approx \frac{y(x+h)-y(x)}{h},
     309
     310
     311wobei :math:`h>0` vorgegeben und klein ist. Zusammen mit der
     312Differentialgleichung 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
     318Wenn 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*"
     320nennen, kann diese Approximation neu ausgedrückt werden als:
     321
     322.. math::   y_{new} \approx y_{old} + h*f(x,y_{old}).
     323
     324
     325Wenn wir das Intervall von *a* bis *b* in *n* Teilintervalle
     326aufteilen, so dass :math:`h=\frac{b-a}{n}` gilt, können wir die
     327Information 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
     340Unser Ziel ist zeilenweise alle leeren Einträge der Tabelle
     341auszufüllen, bis wir den Eintrag ??? erreichen, welcher die
     342Approximation des Euler-Verfahrens für :math:`y(b)` ist.
     343
     344Die 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
     350Wir müssen die ODE zweiter Ordnung auf ein System von zwei
     351Differentialgleichungen 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
     366Also ist :math:`z(1)\approx 0.75`.
     367
     368Wir können auch die Punkte :math:`(x,y)` plotten um ein ungefähres
     369Bild der Kurve zu erhalten. Die Funktion ``eulers_method_2x2_plot``
     370macht dies; um sie zu benutzen, müssen wir die Funktionen  *f* und *g*
     371definieren, welche ein Argument mit drei Koordinaten (*t*, *x*, *y*)
     372erwarten.
     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
     380Zu diesem Zeitpunkt enthält ``P`` die beiden Plots ``P[0]`` (der Plot
     381von *x* nach *t*) und ``P[1]`` (der Plot von *y* nach *t*). Wir können
     382beide 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
     392Spezielle Funktionen
     393--------------------
     394
     395Mehrere orthogonale Polynome und spezielle Funktionen sind
     396implementiert, wobei sowohl PARI [GP]_ als auch Maxima [Max]_
     397verwendet wird. Sie sind in den dazugehörigen Abschnitten ("Orthogonal polynomials"
     398beziehungsweise "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
     412Zum jetzigen Zeitpunkt, enthält Sage nur Wrapper-Funktionen für
     413numerische Berechnungen. Um symbolisch zu rechen, rufen Sie die
     414Maxima-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
    - +  
     1Zuweisung, Gleichheit und Arithmetik
     2====================================
     3
     4Bis auf wenige Ausnahmen benutzt Sage die Programmiersprache Python,
     5deshalb werden Ihnen die meisten einführenden Bücher über Python dabei
     6helfen Sage zu lernen.
     7
     8Sage 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
     25Sage 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
     45Die Berechnung eines Ausdrucks wie ``3^2*4 + 2%5`` hängt von der
     46Reihenfolge ab, in der die Operationen ausgeführt werden. Dies wird in
     47der "Operatorrangfolge-Tabelle" in :ref:`section-precedence` festgelegt.
     48
     49Sage stellt auch viele bekannte mathematische Funktionen zur
     50Verfü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
     61Wie das letzte Beispiel zeigt, geben manche mathematische Ausdrücke
     62'exakte' Werte anstelle von numerischen Approximationen zurück. Um
     63eine numerische Approximation zu bekommen, können Sie entweder die
     64Funktion ``n`` oder die Methode ``n`` verwenden (beide haben auch
     65den längeren Namen, ``numerical_approx``, und die Funktion ``N`` ist
     66die 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
     69ist, 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
     86Python ist dynamisch typisiert, also ist dem Wert, auf den jede Variable
     87weist, ein Typ zugeordnet; jedoch darf eine Variable Werte eines
     88beliebigen 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
     102Die Programmiersprache C, welche statisch typisiert ist, unterscheidet
     103sich hierzu stark; eine Variable, die dazu deklariert ist eine Ganzzahl (int)
     104aufzunehmen, kann in ihrem Sichtbarkeitsbereich auch nur ganze Zahlen aufnehmen.
     105
     106Für Verwirrung in Python sorgt häufig, dass Integer Literale, die mit
     107Null 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
     119Dies 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
    - +  
     1s.. _section-functions-issues:
     2
     3Häufige Probleme mit Funktionen
     4===============================
     5
     6Das Definieren von Funktionen kann in mancher Hinsicht verwirrend sein
     7(z.B. beim Ableiten oder Plotten). In diesem Abschnitt versuchen wir
     8die relevanten Probleme anzusprechen.
     9
     10Nun erläutern wir verschiedene Möglichkeiten Dinge zu definieren, die das
     11Recht haben könnten "Funktionen" genannt zu werden:
     12
     131. Definition einer Python-Funktion wie in :ref:`section-functions`
     14beschrieben. Diese Funktionen können geplottet, aber nicht abgeleitet
     15oder 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
     26Beachten Sie die Syntax in der letzten Zeile. Falls Sie stattdessen
     27``plot(f(z), 0, 2)`` verwenden, erhalten Sie einen Fehler, da ``z``
     28eine Dummy-Variable in der Definition von ``f`` ist, und außerhalb
     29dieser nicht definiert ist. In der Tat gibt sogar nur ``f(z)`` einen
     30Fehler zurück. Das Folgende funktioniert in diesem Fall, obwohl es im
     31Allgemeinen Probleme verursachen kann und deshalb vermieden werden
     32sollte. (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
     44Nun ist `f(z)`` ein symbolischer Ausdruck. Dies ist unser nächster Stichpunkt
     45unserer Aufzählung.
     46
     472. Definition eines  "aufrufbaren symbolischen Ausdrucks".  Diese
     48kö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
     65Beachten Sie, dass während ``g`` ein aufrufbarer symbolischer Ausdruck
     66ist, ``g(x)`` ein verwandtes aber unterschiedliches Objekt ist,
     67welches auch geplottet, differenziert, usw. werden kann - wenn auch
     68mit einigen Problemen: Lesen Sie den 5. Stichpunkt unterhalb, um eine
     69Erlä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
     833. Benutzung einer vordefinierten 'trigonometrischen Sage-Funktion'.
     84Diese können mit ein wenig Hilfestellung differenziert und integriert
     85werden.
     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       
     96Alleinestehend kann ``sin`` nicht differenziert werden, zumindest nicht
     97um ``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
     108es ist wohl noch besser ``f(x) = sin(x)`` zu benutzen, um einen
     109aufrufbaren symbolischen Ausdruck zu definieren.
     110
     111::
     112   
     113       sage: S(x) = sin(x)
     114       sage: S.derivative()
     115       x |--> cos(x)
     116       
     117Hier 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
     129Das Problem: ``plot(h(x), 0, 4)`` zeichnet die Linie `y=x-2` und nicht
     130die mehrzeilige Funktion, welche durch ``h`` definiert wird.  Der
     131Grund? In dem Befehl ``plot(h(x), 0, 4)`` wird zuerst ``h(x)``
     132ausgewertet: Das bedeutet, dass ``x`` in die Funktion ``h`` eingesetzt
     133wird, 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
     142Wenn eine symbolische Gleichung ausgewertet wird, wie in der
     143Definition von ``h``, wird falls sie nicht offensichtlicherweise wahr
     144ist, False zurück gegeben. Also wird ``h(x)`` zu ``x-2`` ausgewertet
     145und dies ist die Funktion, die geplottet wird.
     146
     147Die 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
     164Das 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
     177zugehörigen Variablen, und man kann in sie nichts einsetzen.
     178
     179Die 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
     220Schließlich ist hier noch eine Möglichkeit den Unterschied zwischen der
     221Ableitung 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       
     238Wie dieses Beispiel verdeutlichen sollte, nimmt ``h`` keine Argumente
     239an, 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
    - +  
     1Endliche und abelsche Gruppen
     2=============================
     3
     4Sage unterstützt das Rechnen mit Permutationsgruppen,
     5endlichen klassischen Gruppen (wie z.B. :math:`SU(n,q)`), endlichen
     6Matrixgruppen (mit Ihren eigenen Erzeugern), und abelschen Gruppen
     7(sogar unendlichen). Vieles davon ist mit Hilfe der GAP-Schnittstelle
     8implementiert.
     9
     10Zum Beispiel können Sie, um eine Permuationsgruppe zu erzeugen, die
     11Liste 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
     32Sie können in Sage auch die Tabelle der Charaktere (im LaTeX-Format)
     33erhalten:
     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
     46Sage 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
     76Sie 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
     3Hilfe
     4=====
     5
     6Sage hat eine umfassende eingebaute Dokumentation, auf die zugegriffen
     7werden kann, indem der Name der Funktion oder Konstanten (zum
     8Beispiel) 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
     97Sage stellt auch eine 'Tab-Vervollständigung' zur Verfügung: Schreiben Sie die
     98ersten Buchstaben einer Funktion und drücken Sie danach die Tabulatortaste.
     99Wenn Sie zum Beispiel ``ta`` gefolgt von ``TAB`` eingeben, wird Sage
     100``tachyon, tan, tanh, taylor`` ausgeben. Dies ist eine gute
     101Möglichkeit den Namen von Funktionen und anderen Strukturen in Sage herauszufinden.
     102
     103
     104.. _section-functions:
     105
     106Funktionen, Einrückungen, und Zählen
     107====================================
     108
     109Um in Sage eine neue Funktion zu definieren, können Sie den ``def``
     110Befehl und einen Doppelpunkt nach der Liste der Variablennamen
     111benutzen. 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
     123Anmerkung: Abhängig von der Version des Tutorials, das Sie gerade lesen,
     124sehen Sie vielleicht drei Punkte ``...`` in der zweiten Zeile dieses
     125Beispiels. Tippen Sie diese nicht; sie sind nur da um zu
     126verdeutlichen, dass der Code eingerückt ist. Wann immer dies der Fall
     127ist, drücken Sie [Return/Enter] einmal am Ende des Blocks um eine
     128Leerzeile einzufügen und die Funktionsdefinition zu beenden.
     129
     130Sie bestimmen den Typ ihrer Eingabeargumente nicht. Sie können mehrere
     131Argumente festlegen, jedes davon kann einen optionalen Standardwert haben.
     132Zum 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
     146Sie können auch ein oder mehrere Eingabeargumente explizit angeben
     147wenn Sie die Funktion aufrufen; wenn Sie die Eingaben explizit
     148angeben, 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
     159In Python werden Codeblöcke nicht mit geschweiften Klammern oder
     160"begin-" und "end-Blöcken" kenntlich gemacht. Stattdessen werden
     161Codeblöcke durch Einrückungen bestimmt, welche exakt zusammenpassen
     162müssen. Zum Beispiel ist das Folgende ein Syntaxfehler, da die
     163``return`` Anweisung nicht genauso weit eingerückt ist wie die anderen
     164Zeilen 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
     179Wenn 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
     192Semikola sind an den Zeilenenden nicht notwendig; sie können jedoch
     193mehrere 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
     200Falls Sie möchten, dass sich eine einzelne Codezeile über mehrere
     201Zeilen erstreckt, können Sie einen terminierenden Backslash verwenden:
     202
     203::
     204
     205    sage: 2 + \
     206    ...      3
     207    5
     208
     209In Sage können Sie zählen indem Sie über einen Zahlenbereich
     210iterieren. 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
     221Die 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
     231Das dritte Argument bestimmt die Schrittweite, also ist das Folgende
     232gleichwertig 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
     243Oft will man eine schöne Tabelle erstellen, um die mit Sage
     244berechneten Zahlen auszugeben. Eine einfache Möglichkeit dies zu tun
     245ist String-Formatierung zu verwenden. Unten erstellen wir drei Spalten,
     246jede genau 6 Zeichen breit, und erzeugen somit eine Tabelle mit
     247Quadrat- 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
     259Die elementarste Datenstruktur in Sage ist die Liste. Sie ist -- wie
     260der Name schon sagt -- nichts anderes als eine Liste beliebiger
     261Objekte. Zum Beispiel erzeugt der ``range`` Befehl, den wir schon
     262verwendet haben, eine Liste:
     263
     264::
     265
     266    sage: range(2,10)
     267    [2, 3, 4, 5, 6, 7, 8, 9]
     268
     269Hier 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
     277Listenindizierung 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
     288Benutzen Sie ``len(v)`` um die Länge von ``v`` zu erhalten, benutzen
     289Sie ``v.append(obj)`` um ein neues Objekt an das Ende von ``v``
     290anzuhängen, und benutzen Sie ``del v[i]`` um den :math:`i^{ten}`
     291Eintrag 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
     306Eine weitere wichtige Datenstruktur ist das Dictionary (oder
     307assoziatives Array). Dies funktioniert wie eine Liste, außer dass
     308es mit fast jedem Objekt indiziert werden kann (die Indizes müssen
     309jedoch 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
     319Sie können auch neue Datentypen definieren, indem Sie Klassen
     320verwenden. Mathematische Objekte mit Klassen zusammenzufassen ist eine
     321mächtige Technik, die dabei helfen kann Sage-Programme zu vereinfachen
     322und zu organisieren. Unten definieren wir eine Klasse, welche die Liste
     323der geraden Zahlen bis *n* darstellt;
     324Sie 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
     335Die ``__init__`` Methode wird aufgerufen um das Objekt zu
     336initialisieren, wenn es erzeugt wird; die ``__repr__`` Method gibt
     337einen Objekt-String aus. Wir rufen die Listen-Konstruktor-Methode in
     338der 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
     349Beachten Sie, dass die Ausgabe von ``e`` die ``__repr__`` Methode
     350verwendet, die wir definiert haben. Um die eigentliche Liste
     351sehen 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
     360Wir können auch das ``n`` Attribut verwenden oder ``e`` wie eine Liste
     361behandeln.
     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
     3Lineare Algebra
     4===============
     5
     6Sage stellt standardmäßige Konstruktionen der Linearen Algebra zur
     7Verfügung. Zum Beispiel das charakteristische Polynom, die
     8Zeilenstufenform, die Spur, die Zerlegung von Matrizen, usw..
     9
     10
     11Das Erzeugen von Matrizen und die Matrixmultiplikation sind einfach
     12und 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
     27Beachten Sie, dass in Sage der Kern einer Matrix :math:`A` der "linke
     28Kern", d.h. der Raum der Vektoren :math:`w` mit :math:`wA=0` ist.
     29
     30Mit der Methode ``solve_right`` können Matrixgleichungen einfach
     31gelö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
     45Anstelle von ``solve_right`` kann auch ein Backslash ``\`` verwendet
     46werden. 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
     55Falls 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
     66Auf ähnliche Weisen können Sie ``A.solve_left(Y)`` benutzen um nach :math:`X` in
     67:math:`XA=Y` aufzulösen.
     68
     69Sage 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
     83Tripeln: (Eigenwert, Eigenvektor, Vielfachheit).) Eigenwerte und
     84Eigenvektoren über ``QQ`` oder ``RR`` können auch unter Verwendung von
     85Maxima berechnen werden (Lesen Sie :ref:`section-maxima` unterhalb).
     86
     87Wie in :ref:`section-rings` bemerkt wurde, beeinflusst der Ring, über
     88dem die Matrix definiert ist, einige ihrer Eigenschaften. Im Folgenden
     89gibt erste Argument des ``matrix``-Befehls Sage zu verstehen, dass die
     90Matrix als Matrix über den ganzen Zahlen (``ZZ``), als Matrix über den
     91rationalen 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
     107Matrizenräume
     108-------------
     109
     110Wir erzeugen den Raum :math:`\text{Mat}_{3\times 3}(\QQ)` der  `3 \times
     1113` 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
     119angegeben wurde, ist diese standardmäßig gleich der Anzahl der Zeilen,
     120so dass ``MatrixSpace(QQ,3)`` ein Synonym für ``MatrixSpace(QQ,3,3)``
     121ist.) 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
     135Wir 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
     146Als 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
     161Nun zeigen wir, wie man Matrizen berechnen, die über
     162endlichen 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
     182Wir erstellen den Unterraum von `\GF{2}^8`, der von den obigen Zeilen
     183aufgespannt 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
     204Die Basis von `S`, die von Sage benutzt wird, wird aus den von Null
     205verschiedenen Zeilen der reduzierten Zeilenstufenform der Matrix der
     206Generatoren von `S` erhalten.
     207
     208Lineare Algebra mit dünnbesetzten Matrizen
     209------------------------------------------
     210
     211Sage unterstützt Lineare Algebra mit dünnbesetzten Matrizen über
     212Hauptidealringen.
     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
     221Der multi-modulare Algorithmus kann bei quadratischen Matrizen gut
     222angewendet 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
     233Beachten 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
    - +  
     1Zahlentheorie
     2=============
     3
     4Sage hat für Zahlentheorie eine ausgiebige Funktionsvielfalt. Zum
     5Beispiel 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
     23Sage 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
     44Perfekt!
     45
     46Sages ``sigma(n,k)``-Funktion summiert die :math:`k^{ten}` Potenzen der
     47Teiler von ``n``:
     48
     49::
     50
     51    sage: sigma(28,0); sigma(28,1); sigma(28,2)
     52    6
     53    56
     54    1050
     55
     56Als nächstes illustrieren wir den erweiterten euklidischen
     57Algorithmus, Eulers :math:`\phi`-Funktion, und den chinesischen
     58Restsatz:
     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
     79Als 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
     91Schließ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
     115Der Körper der :math:`p`-adischen Zahlen ist in Sage
     116implementiert. Beachten Sie, dass sobald Sie einen :math:`p`-adischer Körper
     117erzeugt 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
     130In die Implementierung von weiteren Ringen von Zahlen über :math:`p`-adischen
     131Körpern ist viel Arbeit geflossen. Der interessierte Leser ist dazu
     132eingelanden, die Experten in der ``sage-support`` Google-Gruppe nach
     133weiteren Details zu fragen.
     134
     135Eine Vielzahl relevanter Methoden sind schon in der NumberField Klasse
     136implementiert.
     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
     3Plotten
     4=======
     5
     6Sage kann zwei- und dreidimensionale Plots erzeugen.
     7
     8Zweidimensionale Plots
     9----------------------
     10
     11Sage kann in zwei Dimensionen Kreise, Linien und Polygone zeichnen,
     12sowie Plots von Funktionen in kartesischen Koordinaten und Plots in
     13Polarkoordinaten, Konturplots und Plots von Vektorfeldern. Wir geben
     14davon im Folgenden einige Beispiele an. Für weitere Beispiele zum
     15Plotten 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
     19Dieser Befehl erstellt einen gelben Kreis vom Radius 1 mit dem
     20Ursprung als Zentrum:
     21
     22::
     23
     24    sage: circle((0,0), 1, rgbcolor=(1,1,0))
     25
     26Sie können auch einen ausgefüllten Kreis erzeugen:
     27
     28::
     29
     30    sage: circle((0,0), 1, rgbcolor=(1,1,0), fill=True)
     31
     32Sie können einen Kreis auch erstellen, indem Sie ihn einer Variable
     33zuweisen; so wird kein Plot gezeigt.
     34
     35::
     36
     37    sage: c = circle((0,0), 1, rgbcolor=(1,1,0))
     38
     39Um den Plot zu zeigen, benutzen Sie ``c.show()`` oder ``show(c)`` wie
     40folgt:
     41
     42.. link
     43
     44::
     45
     46    sage: c.show()
     47
     48Alternativ führt das Auswerten von ``c.save('filename.png')`` dazu,
     49dass der Plot in der angegebenen Datei gespeichert wird.
     50
     51Noch sehen diese 'Kreise' jedoch eher wie Ellipsen aus, da die Achsen
     52unterschiedlich skaliert sind. Sie können dies korrigieren:
     53
     54.. link
     55
     56::
     57
     58    sage: c.show(aspect_ratio=1)
     59
     60Der Befehl ``show(c, aspect_ratio=1)`` erreicht das Gleiche. Sie
     61können das Bild auch speichern, indem Sie ``c.save('filename.png',
     62aspect_ratio=1)`` benutzen.
     63
     64Es ist einfach elementare Funktionen zu plotten:
     65
     66::
     67
     68    sage: plot(cos, (-5,5))
     69
     70Sobald Sie einen Variablennamen angegeben haben, können Sie
     71parametrische 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
     78Es ist wichtig zu beachten, dass sich die Achsen eines Plots nur
     79schneiden, wenn sich der Ursprung im angezeigten Bildbereich des
     80Graphen befindet und ab einer bestimmten Größe der Werte wird die
     81wissenschaftliche Notation benutzt:
     82::
     83
     84    sage: plot(x^2,(x,300,500))
     85
     86Sie 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
     96Eine gute Möglichkeit ausgefüllte Figuren zu erstellen ist, eine Liste
     97von Punkten zu erzeugen (``L`` im folgenden Beispiel) und dann den
     98``polygon`` Befehl zu verwenden um die Figur mit dem, durch die Punkte
     99bestimmten, 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
     108Geben Sie ``show(p, axes=false)`` ein, um dies ohne Achsen zu sehen.
     109
     110Sie 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
     120Analysis Lehrer zeichnen häufig den folgenden Plot an die Tafel:
     121nicht nur einen Zweig von der arcsin Funktion, sondern mehrere, also den
     122Plot 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
     124Befehl 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
     131Da die Tangensfunktion einen größeren Wertebereich als die
     132Sinusfunktion besitzt, sollten Sie, falls Sie den gleichen Trick
     133anwenden um die Inverse der Tangensfunktion zu plotten, das Minimum
     134und 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
     141Sage berechnet auch Plots in Polarkoordinaten, Konturplots, Plots von
     142Vektorfeldern (für besondere Arten von Funktionen). Hier ist ein
     143Beispiel eines Konturplots:
     144
     145::
     146
     147    sage: f = lambda x,y: cos(x*y)
     148    sage: contour_plot(f, (-4, 4), (-4, 4))
     149
     150Dreidimensionale Plots
     151----------------------
     152
     153Sage kann auch dazu verwendet werden dreidimensionale Plots zu zeichnen.
     154Sowohl im Notebook, als auch von der Kommandozeile aus werden diese
     155Plots standardmäßig mit den Open-Source-Paket [Jmol]_ angezeigt,
     156welches interaktives Drehen und Zoomen der Grafik mit Hilfe der
     157Maus unterstützt.
     158
     159Benutzen 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
     166Alternativ können Sie auch ``parametric_plot3d`` verwenden um eine
     167parametrisierte Fläche zu zeichnen, wobei jede der Variablen `x, y, z`
     168durch eine Funktion einer oder zweier Variablen bestimmt ist. (Die
     169Argumente sind typischerweise `u` und `v`). Der vorherige Plot kann
     170wie 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
     180Die 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
     183Sphä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
     190Hier 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
     203Die `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
     214Ein 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
     225Die `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
     3Polynome
     4========
     5
     6In diesem Abschnitt erläutern wir, wie man in Sage Polynome erzeugt
     7und benutzt.
     8
     9
     10.. _section-univariate:
     11
     12Polynome in einer Unbestimmten
     13------------------------------
     14
     15Es 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
     23Dies erzeugt einen Polynomring und teilt Sage mit (den String) 't' als
     24Unbestimmte bei Ausgaben auf dem Bildschirm zu verwenden.
     25Jedoch definiert dies nicht das Symbol ``t`` zur Verwendung in Sage,
     26Sie können es also nicht verwenden um ein Polynom (wie
     27z.B. :math:`t^2+1`) einzugeben, welches zu ``R`` gehört.
     28
     29Eine alternative Möglichkeit ist:
     30
     31.. link
     32
     33::
     34
     35    sage: S = QQ['t']
     36    sage: S == R
     37    True
     38
     39Dies verhält sich bezüglich ``t`` gleich.
     40
     41Eine dritte sehr bequeme Möglichkeit ist:
     42
     43::
     44
     45    sage: R.<t> = PolynomialRing(QQ)
     46
     47oder
     48
     49::
     50
     51    sage: R.<t> = QQ['t']
     52
     53oder sogar nur
     54
     55::
     56
     57    sage: R.<t> = QQ[]
     58
     59Dies hat den zusätzlichen Nebeneffekt, dass die Variable ``t`` als
     60Unbestimmte des Polynomrings definiert wird, Sie können daher nun wie
     61folgt auf einfache Weise Elemente von ``R`` definieren. (Beachten Sie,
     62dass die dritte Möglichkeit sehr ähnlich zu der Konstruktor-Notation
     63in Magma ist und, genau wie in Magma, kann Sie dazu verwendet werden
     64eine 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
     75Unabhängig davon wie Sie den Polynomring definieren, können Sie die
     76Unbestimmte 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
     85Beachten Sie, dass Sie bei den komplexen Zahlen eine ähnliche
     86Konstruktion verwenden können: Sie können die komplexen Zahlen
     87ansehen, als wären sie von dem Symbol ``i`` über den reellen Zahlen
     88erzeugt; 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
     97Beim Erzeugen von Polynomringen kann man sowohl den Ring, als auch den
     98Erzeuger, 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
     107Schließ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
     128Beachten Sie, dass die Faktorisierung die Einheit korrekt in Betracht
     129zieht und ausgibt.
     130
     131Falls Sie zum Beispiel die ``R.cyclotomic_polynomial``-Funktion in
     132einem Forschungsprojekt viel verwenden würden, sollten Sie neben Sage
     133zu zitieren, auch versuchen herauszufinden welche Komponente von Sage verwendet
     134wird um das zyklotomische Polynom zu berechnen, und diese ebenso angeben.
     135In diesen Fall sehen Sie im Quellcode der Funktion, welchen Sie mit
     136``R.cyclotomic_polynomial??`` erhalten schnell die Zeile ``f =
     137pari.polcyclo(n)``, was bedeutet, dass PARI verwendet wird um das
     138zyklotomische Polynom zu berechnen. Zitieren Sie PARI ebenso in Ihrer Arbeit.
     139
     140Wenn 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
     152Mit Hilfe von Laurentreihen können Sie die Reihenentwicklung im
     153Quotientenkö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
     162Wenn wir die Variablen unterschiedlich benennen, erhalten wir einen
     163unterschiedlichen 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
     178Der Ring wird durch die Variable bestimmt. Beachten Sie, dass das
     179Erzeugen eines weiteren Rings mit einer ``x`` genannten Variablen
     180keinen 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
     193Sage unterstützt auch Ringe von Potenz- und Laurentreihen über
     194beliebigen 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))`
     196zu 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
     210Sie können einen Potenzreihenring auch mit der Kurzschreibweise,
     211doppelter eckiger Klammern erzeugen:
     212
     213::
     214
     215    sage: GF(7)[['T']]
     216    Power Series Ring in T over Finite Field of size 7
     217
     218Polynome in mehreren Unbestimmten
     219---------------------------------
     220
     221Um mit Polynomringen in mehreren Variablen zu arbeiten, deklarieren
     222wir 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
     230Genau wie bei dem Definieren von Polynomringen in einer Variablen,
     231gibt 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
     240Falls die Variablennamen nur einen Buchstaben lang sein sollen, können
     241Sie 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
     248Als 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
     258Sie können auch eine mathematisch etwas weiter verbreitete
     259Schreibweise 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
     272Polynomringe in mehreren Variablen sind in Sage mit Hilfe von
     273Python-Dictionaries und der "distributiven Darstellung" eines Polynoms
     274implementiert. Sage benutzt Singular [Si]_, zum Beispiel bei der
     275Berechnung 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
     285Als 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
     303unveränderliche Folge. Das bedeutet das sie die Attribute "universe" und
     304"parent" besitzt und nicht verändert werden kann. (Dies ist nützlich,
     305da nach dem Ändern der Basis andere Routinen, welche die Gröbnerbasis
     306verwenden, 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
     322Etwas (damit meinen wir: nicht so viel wie wir gerne hätten)
     323kommutative Algebra ist in Sage, mit Hilfe von Singular implementiert,
     324vorhanden. Zum Beispiel können wir die Zerlegung in Primideale und die
     325assoziierten 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
     3Wichtige Ringe
     4==============
     5
     6Wenn wir Matrizen, Vektoren oder Polynome definieren ist es manchmal
     7nützlich, und manchmal notwendig, den "Ring" anzugeben, über dem diese
     8definiert sind. Ein *Ring* ist ein mathematisches Objekt, für das es
     9die wohldefinierten Operationen Addition und Multiplikation gibt; Falls
     10Sie davon noch nie gehört haben, brauchen Sie wahrscheinlich nur die
     11folgenden 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
     20Sie müssen diese Unterschiede kennen, da das gleiche Polynom zum
     21Beispiel, unterschiedlich, abhängig von dem Ring über dem es definiert
     22ist, behandelt werden kann. Zum Beispiel hat das Polynom `x^2-2` die
     23beiden Nullstellen `\pm \sqrt{2}`.  Diese Nullstellen sind nicht
     24rational, wenn Sie also mit Polynomen über rationalen Koeffizienten
     25arbeiten, lässt sich das Polynom nicht faktorisieren. Mit reellen
     26Koeffizienten lässt es sich faktorisieren. Deshalb müssen Sie den Ring
     27angeben, um sicher zu gehen, dass Sie die Information
     28erhalten, die Sie erwarten. Die folgenden beiden Befehle definieren
     29jeweils die Mengen der Polynome mit rationalen und reellen
     30Koeffizienten. Diese Mengen werden "ratpoly" und "realpoly" genannt,
     31aber das ist hier nicht wichtig; beachten Sie jedoch, dass die Strings
     32".<t>" und ".<z>" die *Variablen* benennen, die in beiden Fällen benutzt
     33werden. ::
     34
     35    sage: ratpoly.<t> = PolynomialRing(QQ)
     36    sage: realpoly.<z> = PolynomialRing(RR)
     37
     38Jetzt 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
     50eine Matrix kann vom Ring abhängen, über dem sie definiert ist,
     51genauso wie ihre Eigenwerte und Eigenvektoren. Um mehr über das
     52Konstruieren von Polynomen zu erfahren, lesen Sie :ref:`section-poly`,
     53und für mehr über Matrizen, lesen Sie :ref:`section-linalg`.
     54
     55Das Symbol ``I`` steht für die Quadratwurzel von :math:`-1`; ``i`` ist
     56ein 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
     63Beachten Sie: Der obige Code kann möglicherweise nicht wie erwartet
     64funktionieren. Zum Beispiel wenn der Variablen ``i`` ein
     65unterschiedlicher Wert, etwa wenn diese als Schleifenvariable
     66verwendet wurde, zugewiesen wurde. Falls dies der Fall ist, tippen Sie ::
     67
     68    sage: reset('i')
     69
     70um den ursprünglichen komplexen Wert der Variable ``i`` zu erhalten.
     71
     72Es ist noch eine Feinheit beim Definieren von komplexen Zahlen zu
     73beachten: Wie oben erwähnt wurde, stellt das Symbol ``i`` eine
     74Quadratwurzel 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
     102Hier sind weitere Beispiele von Ringen in Sage. Wie oben angemerkt,
     103kann auf den Ring der rationalen Zahlen mit ``QQ`` zugegriffen werden,
     104ebenso wie mit ``RationalField()`` (ein  *Körper* (engl. *field*) ist
     105ein Ring in dem die Multiplikation kommutativ ist, und in dem jedes von
     106Null verschiedene Element in dem Ring einen Kehrwehrt besitzt. Die
     107rationalen Zahlen bilden also auch einen Körper, die ganzen Zahlen
     108jedoch nicht)::
     109
     110
     111    sage: RationalField()
     112    Rational Field
     113    sage: QQ
     114    Rational Field
     115    sage: 1/2 in QQ
     116    True
     117
     118Die Dezimalzahl ``1.2`` wird als rationale Zahl in ``QQ`` gesehen:
     119Dezimalzahlen, die auch rational sind, können in rationale Zahlen
     120"umgewandelt" (engl. "coerced") werden. Die Zahlen `\pi` und `\sqrt{2}`
     121sind 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
     134Für die Verwendung in der höheren Mathematik kennt Sage noch weitere
     135Ringe, wie z.B. endliche Körper, `p`-adische Zahlen, den Ring der
     136algebraischen Zahlen, Polynomringe und Matrizenringe. Hier sind
     137Konstruktionen 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