Ticket #14550: trac_14550_gymnasium_tutorial.patch

File trac_14550_gymnasium_tutorial.patch, 45.1 KB (added by navigium, 9 years ago)

New patch without pictures

  • new file doc/de/thematische_anleitungen/conf.py

    # HG changeset patch
    # User Beni Keller <navigium@grindcore.ch>
    # Date 1368087868 -7200
    # Node ID 7c0f32589880ea85afb046e06cf8f25a6979917e
    # Parent  1077314f416653b28e199c382667a1f11e444bdd
    Trac 14550: German tutorial for school teachers
    
    diff --git a/doc/de/thematische_anleitungen/conf.py b/doc/de/thematische_anleitungen/conf.py
    new file mode 100644
    - +  
     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"Thematische Anleitungen"
     20name = u'ThematischeAnleitungen-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/thematische_anleitungen/index.rst

    diff --git a/doc/de/thematische_anleitungen/index.rst b/doc/de/thematische_anleitungen/index.rst
    new file mode 100644
    - +  
     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
     5Sage thematische Anleitungen
     6=============================
     7Die folgenden Dokumente sind thematische Anleitungen, welche sich mit
     8speziellen Einsatzgebieten von Sage befassen.
     9
     10Die Anleitungen sind unter einer  `Creative Commons Attribution-Share Alike
     113.0 Lizenz`__ lizenziert.
     12
     13__ http://creativecommons.org/licenses/by-sa/3.0/
     14
     15.. toctree::
     16   :maxdepth: 1
     17
     18   sage_gymnasium
     19
  • new file doc/de/thematische_anleitungen/sage_gymnasium.rst

    diff --git a/doc/de/thematische_anleitungen/sage_gymnasium.rst b/doc/de/thematische_anleitungen/sage_gymnasium.rst
    new file mode 100644
    - +  
     1.. -*- coding: utf-8 -*-
     2
     3====================================
     4Sage als Taschenrechner im Gymnasium
     5====================================
     6
     7.. MODULEAUTHOR:: Beni Keller
     8
     9Einleitung
     10==========
     11
     12An wen richtet sich diese Anleitung?
     13------------------------------------
     14
     15Diese Anleitung richtet sich an Lehrpersonen, welche an Gymnasien im deutschsprachigen
     16Raum unterrichten. Das Ziel ist, eine Anleitung zur Verfügung zu stellen, welche erklärt,
     17wie das Computer-Algebra-System Sage anstelle der an Gymnasien häufig
     18eingesetzten CAS Taschenrechner verwendet werden kann.
     19
     20Als grober Leitfaden dienen Lehrpläne von Schweizer Gymnasien. Diese unterscheiden
     21sich nicht stark von Lehrplänen in anderen deutschsprachigen Ländern. Daher wird
     22diese Anleitung für alle deutschsprachigen Mathematiklehrpersonen nützliche Informationen
     23enthalten.
     24
     25Die bestehende englische Dokumentation von Sage ist sehr ausführlich und auf deutsch existiert
     26ein gutes Tutorial für den Einstieg in Sage [#tutorial]_. Es hat sich aber als schwer
     27herausgestellt, die für den gymnasialen Unterricht relevanten Funktionen zu finden,
     28da oft Fälle beschrieben werden, wie sie typischerweise in Hochschulmathematik anzutreffen sind.
     29
     30Daher soll diese Anleitung als eigenständige Dokumentation der Funktionen von Sage
     31aus Sicht einer Gymnasiallehrperson dienen. Dieses Dokument soll die Benutzung von Sage
     32für Gymnasiallehrpersonen vereinfachen, ohne Vorkenntnisse von Sage oder der
     33Programmiersprache Python vorauszusetzen.
     34
     35Was ist Sage?
     36-------------
     37
     38Sage ist ein quelloffenes Computer-Algebra-System, welches weltweit von
     39hunderten Studenten und Forschern an verschiedenen Universitäten entwickelt wird, aber auch Privatpersonen und Schüler haben Beiträge geleistet.
     40Es wurde und wird noch immer in vielen mathematischen Arbeiten
     41benutzt und im Zuge dessen auch immer weiterentwickelt. Daher ist es sehr mächtig
     42und löst komplexe Probleme in vielen, sehr spezialisierten Teilgebieten der
     43Mathematik.
     44
     45Trotzdem ist Sage auch als Computer-Algebra-System für an Gymnasien
     46unterrichtete Mathematik gut geeignet. Es bietet einen grossen Funktionsumfang
     47und kann kostenlos an Schulen eingesetzt werden und so teure Taschenrechner
     48und Software ersetzen.
     49
     50Die Tatsache, dass Sage quelloffen und kostenlos verfügbar ist, macht es speziell
     51geeignet für Schulen.  Das System kann von Schülern und Schulen problemlos
     52auf allen Rechnern installiert werden, ohne dass man sich um Lizenzkosten und
     53die Anzahl verfügbarer Lizenzen kümmern muss. Es kann auch verändert und angepasst
     54werden und jede Person kann helfen, es weiter zu entwickeln.
     55
     56Sage ist zum grossen Teil in der Programmiersprache Python geschrieben und kann auch
     57in Python programmiert werden. Diese Sprache wird von Schulen weltweit in
     58Einführungskursen ins Programmieren benutzt. Diese Tatsache macht Sage umso
     59geeigneter, um in Schulen - auch im Zusammenhang mit einer Einführung ins
     60Programmieren - eingesetzt zu werden.
     61
     62
     63Wo bekomme ich Sage?
     64---------------------
     65
     66Die Onlineversion dieser Anleitung bietet eine erste Möglichkeit, die
     67Beispiele direkt in Sage auszuprobieren und abzuändern, ohne selbst
     68Sage installiert zu haben.
     69
     70Sage kann aber auch lokal installiert oder online ausprobiert werden. Auf der
     71Sage-Webseite findet man weitere Informationen dazu:
     72
     73http://sagemath.org/
     74
     75Hilfe abfragen
     76---------------
     77
     78Bevor wir beginnen die für den gymnasialen (Mathematik-) Unterricht relevanten
     79Funktionen von Sage ausführlich zu betrachten, soll hier erklärt werden,
     80wie man für eine bestimmte Funktion die Dokumentation direkt in Sage abrufen
     81kann. Dies geschieht durch einfaches Anhängen eines Fragezeichens (?) an den Befehl,
     82über den man mehr wissen möchte.
     83
     84Wenn wir zum Beispiel wissen möchten, wie die Funktion ``limit`` eingesetzt
     85wird, geben wir folgendes ein::
     86
     87    sage: limit?                                                    # Not tested
     88
     89Sage gibt uns anstelle einer Evaluation der Funktion die komplette Hilfe für die
     90entsprechende Funktion zurück. Falls wir noch tiefer ins Innere von Sage schauen
     91möchten und sogar den Sourcecode der Funktion anschauen möchten, hängen wir ein
     92zweites Fragezeichen an::
     93
     94    sage: limit??                                                   # Not tested
     95
     96gibt uns den Python-Code der Funktion ``limit`` zurück. Dies ist natürlich
     97nur möglich, weil Sage ein quelloffenes System ist.
     98
     99
     100Allgemeine Funktionen
     101=====================
     102
     103Grundoperationen
     104----------------
     105
     106In Sage werden die Grundoperationen wie vielerorts üblich in der Infix-Notation
     107ausgedrückt. Dies bedeutet, dass das Operationszeichen wie gewohnt zwischen
     108den Operanden steht. Es stehen
     109die folgenden Grundoperationen zur Verfügung:
     110
     111=========  ===================================
     112Operation  Bedeutung
     113=========  ===================================
     114``+``      Addition
     115``-``      Subtraktion / negatives Vorzeichen
     116``*``      Multiplikation
     117``/``      Division (auch für Bruchterme)
     118``^``      Potenz
     119=========  ===================================
     120
     121Es gelten die üblichen Regeln zur Operatorassoziativität: Höchste Priorität
     122haben Potenzen, anschliessend werden Punktoperationen (``\`` und ``*``)
     123vor Strichoperationen (``+`` und ``-``) ausgeführt::
     124
     125    sage: 12 - 2*3^2
     126    -6
     127    sage: 12 - (2*(3^2))
     128    -6
     129    sage: 3^2 -1
     130    8
     131
     132Unerwarteterweise führt Sage mehrere Potenzen hintereinander nicht von
     133links nach rechts aus::
     134
     135    sage: 3^3^3
     136    7625597484987
     137    sage: 3^(3^3)
     138    7625597484987
     139
     140Wie üblich können Klammern ``()`` verwendet werden, um die Gruppierung der
     141Operationen zu verändern::
     142
     143    sage: -3^2
     144    -9
     145    sage: (-3)^2
     146    9
     147    sage: (12 - 2)*3^(3-1)
     148    90
     149    sage: (3^3)^3
     150    19683
     151
     152Weiter gibt es auch die Möglichkeit, eine ganzzahlige Division auszuführen:
     153
     154=========  ===================================
     155Operation  Bedeutung
     156=========  ===================================
     157``//``     Ganzzahliger Anteil einer Division
     158``%``      Divisionsrest
     159=========  ===================================
     160
     161So ist zum Beispiel `\frac{17}{3} = 5*3 + 2`::
     162
     163    sage: 17//3
     164    5
     165    sage: 17%3
     166    2
     167
     168Bei negativen Zahlen verhält sich die Division nicht wunschgemäss,
     169falls man damit den ganzzahligen Anteil und den Rest bestimmen möchte::
     170
     171    sage: -7//2
     172    -4
     173    sage: -7%2
     174    1
     175
     176Wurzeln
     177-------
     178
     179Sage kennt nur für die Quadratwurzel eine spezielle Funktion, nämlich ``sqrt()``. Alle anderen
     180Wurzeln müssen als Potenz mit rationalem Exponenten geschrieben werden. Quadratwurzeln werden
     181wie folgt berechnet::
     182
     183    sage: sqrt(9)
     184    3
     185    sage: sqrt(2)
     186    sqrt(2)
     187
     188Wurzeln werden so weit wie möglich vereinfacht, aber nicht numerisch evaluiert, solange dies
     189nicht explizit gefordert wird (mehr dazu weiter unten)::
     190
     191    sage: sqrt(18)
     192    3*sqrt(2)
     193
     194Natürlich kennt Sage auch komplexe Zahlen und evaluiert die Wurzel aus `-1`
     195als eine imaginäre Einheit::
     196
     197    sage: sqrt(-1)
     198    I
     199
     200Für die `n`-te Wurzel gibt es in Sage keine spezielle Funktion, da wir die
     201`n`-te Wuzel mit
     202
     203.. math:: \sqrt[n]{a} = a^\frac{1}{n}
     204
     205ausdrücken können. So berechnen wir zum Beispiel `\sqrt[3]{64}` mit::
     206
     207    sage: 64^(1/3)
     208    4
     209
     210Numerische Evaluation
     211---------------------
     212
     213Als Computer-Algebra-System rechnet Sage grundsätzlich immer symbolisch.
     214Dies bedeutet, dass es zwar Terme vereinfacht, aber immer ein exaktes Ergebnis
     215angibt. Hierfür gibt es zwei Ausnahmen. Zum einen können wir eine Kommazahl in der
     216Rechnung benutzen. Dann wird der Teil, welcher die Kommazahl enthält, numerisch evaluiert. Zum anderen können wir eine numerische Evaluation explizit fordern.
     217
     218Das folgende Beispiel zeigt, dass das Benutzen einer Kommazahl automatisch zu numerischem
     219Rechnen führt. Dies selbst, wenn die Kommazahl eigentlich eine ganze Zahl repräsentiert::
     220
     221    sage: sqrt(2.0)
     222    1.41421356237310
     223
     224Dies funktioniert aber nur, wenn der Term selbst keine weitere
     225Funktion oder symbolische Konstante enthält. Falls dies der Fall ist, wird nur ein Teil
     226des Terms numerisch ausgewertet::
     227
     228    sage: sqrt(pi/4.0)
     229    0.500000000000000*sqrt(pi)
     230    sage: sqrt(2)/1.41
     231    0.709219858156028*sqrt(2)
     232
     233Falls wir einen gesamten Term numerisch evaluieren möchten, benutzen wir die
     234Funktion ``n()``. Wird sie ohne Argument aufgerufen, so führt sie die Evaluation
     235mit einer vordefinierten Genauigkeit durch::
     236
     237    sage: sqrt(2).n()
     238    1.41421356237310
     239
     240Falls wir mehr oder weniger Stellen benötigen, können wir die Option ``digits`` benutzen.
     241Sie gibt aber nicht die Anzahl Nachkommastellen sondern die Anzahl Stellen insgesamt an::
     242
     243    sage: sqrt(2).n(digits=50)
     244    1.4142135623730950488016887242096980785696718753769
     245    sage: sqrt(10025).n(digits=5)
     246    100.12
     247
     248
     249Konstanten
     250----------
     251Sage kennt unter anderem die folgenden Konstanten:
     252
     253======   ========  ================
     254``pi``   `\pi`     Kreiszahl
     255``e``    `e`       Eulersche Zahl
     256``I``    `\imath`  Imaginäre Einheit
     257======   ========  ================
     258
     259Diese können auch numerisch ausgewertet werden::
     260
     261    sage: pi.n()
     262    3.14159265358979
     263    sage: e.n()
     264    2.71828182845905
     265
     266
     267Variablen
     268---------
     269
     270In Sage können sowohl Werte als auch Terme in einer Variable gespeichert werden. Als
     271Variablenname ist alles zulässig, was auch in Python zulässig ist. Dies heisst
     272insbesondere:
     273
     274* Variablennamen müssen mit einem Buchstaben oder einem Unterstrich (``_``)
     275  beginnen.
     276* Variablennamen dürfen nur Buchstaben, Zahlen und Unterstriche enthalten.
     277* Variablennamen unterscheiden Gross- und Kleinschreibung.
     278* Es dürfen keine in Python reservierten Worte benutzt werden. [#keywords]_
     279
     280Als Zuordnungsoperator wird das Zeichen ``=`` benutzt.
     281Wir können so zum Beispiel das Ergebnis einer Rechnung als Variable speichern::
     282
     283    sage: ergebnis = sin(pi/4)*2
     284
     285Im folgenden werden wir auch lernen, wie man Terme speichern kann. In einem
     286späteren Abschnitt ist auch beschrieben, wie Funktionen gespeichert werden.
     287
     288Wie jedes Computer-Algebra-System kann Sage symbolisch rechnen. Es muss
     289aber jeweils festgelegt werden, welche Buchstaben oder Zeichenketten
     290als Parameter benutzt werden sollen.
     291
     292Dies geschieht mit dem Befehl ``var``. Ihm wird als Argument eine
     293Zeichenkette übergeben, welche die durch Kommas getrennten Variablennamen
     294enthält. (Zeichenketten in Sage respektive Python werden mit ``'`` oder ``"``
     295gekennzeichnet.)
     296
     297Das folgende Beispiel definiert `x`, `y` und `z` als Variablen::
     298
     299    sage: var('x,y,z')
     300    (x, y, z)   
     301
     302
     303Arithmetik und Algebra
     304======================
     305
     306Terme
     307-----
     308
     309Sage kann mit symbolischen Ausdrücken rechnen. Ein Ausdruck wird als symbolischer
     310Ausdruck betrachtet, sobald eine Variable darin vorkommt.  Wir benutzen in den
     311folgenden Beispielen die Funktion ``type`` um herauszufinden, von welchem Typ
     312ein Ausdruck ist. Ein einfacher Term mit einer Variable ist ein symbolischer
     313Ausdruck::
     314
     315    sage: var('x')
     316    x
     317    sage: type(x*2)
     318    <type 'sage.symbolic.expression.Expression'>
     319
     320Auch eine Funktion (siehe unten) ist ein symbolischer Ausdruck::
     321
     322    sage: f(x) = x + 1
     323    sage: type(f)
     324    <type 'sage.symbolic.expression.Expression'>
     325
     326Benutzen wir jedoch eine Variable, um etwas zu speichern und nicht als symbolischen
     327Parameter, so ist ein Ausdruck, welcher sie enthält, nicht mehr ein symbolischer
     328Ausdruck::
     329
     330    sage: x = 3
     331    sage: type(x*2)
     332    <type 'sage.rings.integer.Integer'>
     333
     334Terme können auch in Variablen gespeichert werden. Dazu benutzen wir
     335wie bei Zahlenwerten den Operator ``=`` für die Zuordnung::
     336
     337    sage: var('x')
     338    x
     339    sage: term = 3*(x + 1)^2
     340    sage: term
     341    3*(x + 1)^2
     342
     343Diese Terme können wir an einer bestimmten Stelle auswerten, oder, anders
     344gesagt, für eine Variable einen Wert einsetzen. Dies geschieht wie folgt::
     345
     346    sage: var('x, a')
     347    (x, a)
     348    sage: term = 3*(x + 1)^a
     349    sage: term
     350    3*(x + 1)^a
     351    sage: term(a = 2)
     352    3*(x + 1)^2
     353    sage: term(x = 2, a = 2)
     354    27
     355
     356Variablen können nicht nur durch Zahlen sondern auch durch symbolische
     357Ausdrücke substituiert werden. Wenn wir im obigen Beispiel
     358`x` mit `a^2` substituieren möchten, geht dies wie erwartet::
     359
     360    sage: var('x, a')
     361    (x, a)
     362    sage: term = 3*(x + 1)^a
     363    sage: term(x = a^2)
     364    3*(a^2 + 1)^a
     365
     366
     367Vereinfachen
     368~~~~~~~~~~~~
     369
     370Beim symbolischen Rechnen mit Termen vereinfacht Sage diese nach dem
     371Eingeben. So wird zum Beispiel der Term `x\cdot x + x^2` vereinfacht::
     372
     373    sage: x*x + x^2
     374    2*x^2
     375
     376Komplexere Vereinfachungen werden nicht automatisch ausgeführt. So weiss
     377Sage zwar, dass `\sin^2(x) + \cos^2(x) = 1`. Wenn wir den Term aber
     378so eingeben, wird er nicht vereinfacht::
     379
     380    sage: sin(x)^2 + cos(x)^2
     381    sin(x)^2 + cos(x)^2
     382
     383Falls wir alle Terme so weit wie möglich vereinfachen möchten, erreichen
     384wir dies mit der ``simplify_full()`` Funktion::
     385
     386    sage: (sin(x)^2 + cos(x)^2).simplify_full()
     387    1
     388
     389Dabei werden auch Additionstheoreme für trigonometrische Funktionen und
     390Logarithmengesetzte eingesetzt::
     391
     392    sage: var('x, y, z')
     393    (x, y, z)
     394    sage: (sin(x + y)/(log(x) + log(y))).simplify_full()
     395    (sin(x)*cos(y) + sin(y)*cos(x))/log(x*y)
     396   
     397    sage: (log(8)/log(2)).simplify_full()
     398    3
     399
     400    sage: (sin(x)^2 + cos(x)^2).simplify_full()
     401    1
     402   
     403Faktorisieren und ausmultiplizieren
     404~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
     405
     406Mit dem Befehl ``expand()`` kann ein Term, der aus mehreren polynomialen
     407Faktoren besteht, ausmultipliziert werden. Umgekehrt wird ``factor()``
     408verwendet, um einen Term so weit als möglich zu faktorisieren::
     409
     410    sage: ((x + 1)*(2*x - 4)).expand()
     411    2*x^2 - 2*x - 4
     412
     413    sage: (2*x^2 - 2*x - 4).factor()
     414    2*(x - 2)*(x + 1)
     415
     416Gleichungen
     417-----------
     418In Sage können sowohl Gleichungen als auch Ungleichungen formuliert und
     419ausgewertet werden. Dazu verwendet man dieselben boolschen Operatoren
     420wie in Python:
     421
     422======  ===================
     423Symbol  Bedeutung
     424======  ===================
     425``==``  Gleichheit
     426``>=``  Grösser oder gleich
     427``<=``  Kleiner oder gleich
     428``>``   Grösser als
     429``<``   Kleiner als
     430``!=``  Unleichheit
     431======  ===================
     432
     433Symbolisch Lösen
     434~~~~~~~~~~~~~~~~~~
     435
     436Falls möglich löst Sage Gleichungen symbolisch. Falls dies nicht gelingen
     437sollte, bleibt einem noch das numerische Lösen von Gleichungen, welches
     438weiter unten beschrieben wird.
     439
     440Für symbolisches Lösen von Gleichungen steht der Befehl ``solve()`` zur
     441Verfügung. Dieser benötigt zwei Argumente: Zum einen die Gleichung, welche
     442gelöst werden soll und zum anderen die Variable, nach welcher die Gleichung
     443aufgelöst werden soll::
     444
     445    sage: solve(x^2 == 3, x)
     446    [x == -sqrt(3), x == sqrt(3)]
     447   
     448    sage: solve(x^3 - x^2 + x == 1, x)
     449    [x == -I, x == I, x == 1]
     450
     451Oft wird uns Sage auch komplexe Lösungen angeben. Um dies zu verhindern, können wir
     452Sage mit dem Befehl ``assume()`` angeben, dass eine Variable nur mit einer reellen Zahl
     453besetzt werden kann::
     454
     455    sage: var('x')
     456    x
     457    sage: assume(x, 'real')
     458    sage: solve(x^3 - x^2 + x == 1, x)
     459    [x == 1]
     460
     461Achtung, solche Annahmen sollten anschliessend mit ``forget()`` wieder rückgängig gemacht
     462werden. Ansonsten gelten sie für folgende Rechnungen noch immer.
     463
     464
     465Lösungen weiterverwenden
     466~~~~~~~~~~~~~~~~~~~~~~~~
     467
     468Es stellt sich das Problem, dass wir nun
     469zwei Gleichungen als Ergebnis erhalten und die Lösung nicht
     470direkt verwenden können, um weiterzurechnen.
     471
     472Wir erhalten von ``solve()`` immer eine Liste von Lösungen. Diese sind intern ab 0 nummeriert.
     473Die erste Lösung ist also die Lösung 0, die zweite die Lösung 1 usw. Wir können nun einzelne
     474Lösungen aus der Liste mit ihrer Nummer herausholen::
     475
     476    sage: solve(x^2 == 3, x)
     477    [x == -sqrt(3), x == sqrt(3)]
     478    sage: solve(x^2 == 3, x)[0]
     479    x == -sqrt(3)
     480    sage: solve(x^2 == 3, x)[1]
     481    x == sqrt(3)
     482
     483Die Lösungen werden uns aber wiederum als Gleichung angegeben und nicht als numerischen Wert. Daher können
     484wir das so erhaltene Ergebnis nicht in einer Variable abspeichern und weiterverwenden.  Um wirklich
     485die Lösung für `x` aus dem Term zu extrahieren, können wir die Funktion ``rhs()`` benutzen, was für "Right
     486Hand Side" steht und genau das tut, was der Name sagt: Es gibt uns die rechte Seite der Gleichung zurück. Dies benutzen
     487wir wie folgt, um den Wert für `x` aus dem Ergebnis zu extrahieren::
     488
     489    sage: (x == -sqrt(3)).rhs()
     490    -sqrt(3)
     491
     492    sage: solve(x^2 == 3, x)[0].rhs()
     493    -sqrt(3)
     494
     495Nun können wir den Wert in einer Variablen speichern oder numerisch auswerten. (Oder beides, wie uns
     496das folgende Beispiel vorführt)::
     497
     498    sage: erg = solve(x^2 == 3, x)[0].rhs()
     499    sage: erg
     500    -sqrt(3)
     501    sage: erg.n()
     502    -1.73205080756888
     503
     504Numerisch Lösen
     505~~~~~~~~~~~~~~~
     506
     507Sage kann gewisse Gleichungen nicht symbolisch lösen und gibt uns
     508daher eine leere Lösungsliste zurück, auch wenn die Gleichung eigentlich
     509eine Lösung besitzt. So findet Sage zum Beispiel für die Gleichung
     510
     511.. math:: \frac{2}{\sqrt{x}} - \frac{1}{x^2} = 0
     512
     513keine sinnvolle, explizite Lösung::
     514
     515    sage: solve(2/x^(1/2) - 1/(x^2) == 0, x)
     516    [x == -sqrt(1/2)*x^(1/4), x == sqrt(1/2)*x^(1/4)]
     517
     518Mit der Option ``explicit_solutions`` können wir Sage zwingen, nur explizite
     519Lösungen anzugeben. Im oben aufgezeigten Fall erhalten wir dann eine
     520leere Liste von Lösungen::
     521
     522    sage: solve(2/x^(1/2) - 1/(x^2) == 0, x, explicit_solutions=True)
     523    []
     524
     525Mit Hilfe von ``find_root()`` können wir Nullstellen numerisch berechnen.
     526Dafür müssen wir schon eine Ahnung haben, in welchem Bereich wir nach der
     527Nullstelle suchen. Wissen wir zum Beispiel, dass eine Funktion `f(x)` eine Nullstelle
     528auf dem Intervall `[a, b]` hat, finden wir eine numerische Approximation dieser Nullstelle
     529mit ``find_root(f == 0, a, b)``. Nun wollen wir also die Lösung der obigen Gleichung finden::
     530
     531  sage: f(x) = 2/x^(1/2) - 1/(x^2)
     532  sage: find_root(f, 0.5, 5)
     533  0.6299605249475858
     534
     535Funktionen
     536----------
     537
     538Wie oben gesehen, sind Funktionen in Sage auch symbolische Ausdrücke.
     539Sie unterscheiden sich daher auch von Funktionen in Python oder einer
     540anderen Programmiersprache. Es wird die Schreibweise
     541
     542.. math:: f(x) = x^3 + x
     543
     544für Funktionen benutzt. Dies ist ein Speichervorgang, welcher in Sage
     545keinen Rückgabewert hat::
     546
     547    sage: f(x) = x^3 + x
     548
     549Nun sind sowohl `f` als auch `f(x)` symbolische Ausdrücke mit
     550zwei verschiedenen Bedeutungen, wie das folgende Beispiel
     551deutlich macht::
     552
     553    sage: f(x) = x^3 + x
     554    sage: f
     555    x |--> x^3 + x
     556    sage: f(x)
     557    x^3 + x
     558
     559
     560Stückweise definierte Funktionen
     561~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
     562Mit der Funktion ``Piecewise()`` können wir in Sage auch mit stückweise definierten
     563Funktionen arbeiten. Die Syntax für den Befehl ist jedoch etwas umständlich. Wollen
     564wir zum Beispiel die Funktion
     565
     566.. math:: f(x)  = \begin{cases} -x^2 & \text{für }  x \le 0 \\ x^2 & \text{für }  x > 0 \end{cases}
     567
     568definieren, so müssen wir der Funktion eine Liste von Listen übergeben, wo jede einzelne Liste aus einem
     569Tupel besteht, welches das Interval des Definitionsbereichs angibt, also z.B. ``(-oo, 0)`` für das Interval
     570`[-\infty, 0]` und einer für das Interval geltende Funktionsgleichung. Als letztes Argument muss angegeben werden,
     571welche Variable durch die Funktion gebunden werden soll::
     572
     573    sage: f = Piecewise([[(-oo,0), -x^2],[(0,oo), x^2]], x)
     574    sage: f(3)
     575    9
     576    sage: f(-3)
     577    -9
     578
     579Die Zeichen ``-oo`` und ``oo`` werden in Sage für `-\infty`, respektive `\infty` benutzt. Mehr dazu wird im Abschnitt
     580über das Berechnen von Grenzwerten erklärt.
     581
     582
     583Partialbruchzerlegung
     584---------------------
     585
     586Vor allem in der Analysis wird im Gymnasium teilweise die Partialbruchzerlegung benutzt, um die Stammfunktion
     587einer rationalen Funktion zu finden. Diese Zerlegung kann auch mit Sage gemacht werden. Wenn wir die Funktion
     588
     589.. math:: f(x) = \frac{1}{x^2 - 1}
     590
     591betrachten, kann diese als Summe von zwei Brüchen geschrieben werden:
     592
     593.. math:: f(x) = \frac{1}{x^2 - 1} = \frac{\frac{1}{2}}{x^2-1} - \frac{\frac{1}{2}}{x^2+1}
     594
     595Diese Zerlegung findet ``partial_fraction()`` in Sage für uns::
     596
     597    sage: f(x) = 1/(x^2 -1)
     598    sage: f.partial_fraction()
     599    x |--> 1/2/(x - 1) - 1/2/(x + 1)
     600
     601Funktions-Graphen darstellen
     602----------------------------
     603
     604Im Folgenden werden die Grundlagen für das Darstellen von Funktionsgraphen
     605aufgezeigt. Der ``plot()`` Befehl kann auch für das Darstellen von Vektoren
     606oder Daten aus dem Fachbereich Stochastik benutzt werden. Dies wird aber im
     607entsprechenden Abschnitt beschrieben.
     608
     609Wir können den Graphen der Funktion `f(x)=x^2` mit dem folgenden Befehl
     610darstellen::
     611
     612    sage: f(x) = x^2
     613    sage: plot(f)
     614
     615Sage versucht einen vernünftigen Bereich von x-Werten zu finden, um den Funktionsgraphen
     616darzustellen. Falls dies nicht dem gewünschten Bereich entspricht, können wir diesen mit
     617den Optionen ``xmin`` und ``xmax`` für die x-Achse, respektive ``ymin`` und ``ymax`` für
     618die y-Achse den zu darstellenden Bereich festlegen::
     619
     620    sage: f(x) = x^2
     621    sage: plot(f, xmin=-12, xmax=12, ymin=-10, ymax=150)
     622
     623Wollen wir mehrere Funktionsgraphen im selben Koordinatensystem darstellen, können wir
     624die beiden Plots einzeln erstellen und in Variabeln abspeichern. Dies verhindert, dass
     625sie einzeln angezeigt werden. Anschliessend verwenden wir den Plot-Befehl erneut um beide
     626zusammen anzuzeigen. Die Plots werden mit einem ``+``-Zeichen zusammengefügt. Mit der Option
     627``color`` können wir die Farbe der einzelnen Graphen festlegen::
     628
     629    sage: graph1 = plot(x^2 + 1, color="green", xmin = 0, xmax = 3)
     630    sage: graph2 = plot(e^x, color="red", xmin = 0, xmax = 3)
     631    sage: plot(graph1 + graph2, )
     632
     633Optionen, welche für beide Plots gültig sind (z.B. ``xmin`` oder ``xmax``) müssen auch bei
     634beiden Plots angegeben werden, da sonst Sage sonst beim Graph, wo es nicht angegeben wird wie
     635üblich versucht, vernünftige Standartwerte auszuwählen.
     636
     637Polstellen darstellen
     638~~~~~~~~~~~~~~~~~~~~~
     639
     640Wollen wir eine Funktion mit Polstellen darstellen, zum Beispiel die Funktion
     641
     642.. math:: f(x) = \frac{x^2+1}{x^2-1}
     643
     644wird Sage uns keinen vernünfigen y-Wertebereich auswählen. Da die Funktionswerte an der
     645Polstelle gegen Unendlich streben, nimmt Sage an, dass wir an sehr grossen oder sehr kleinen
     646y-Werten interessiert sind und wählt die Auflösung der y-Achse entsprechend. Falls es sich
     647um eine ungerade Polstelle handelt, bei der die y-Werte vom Negativen ins Positive wechseln
     648oder umgekehrt, verbindet Sage den positiven und den negativen Teil des Graphen mit einer unerwünschten,
     649senkrechten Linie an der Polstelle.
     650
     651Wie wir oben gelernt haben, können wir den Wertebereich einfach einschränken::
     652
     653    sage: f(x)=(x^2 +1)/(x^2-1)
     654    sage: plot(f, xmin=-2, xmax=2, ymin=-10, ymax = 10)
     655
     656Nun haben wir nur noch das Problem, dass der Graph zwei unerwünschte senkrechte Linien an den
     657Polstellen hat. Dies kann mit der Option ``detect_poles`` verhindert werden. Falls wir die
     658Option auf ``True`` stellen, werden die Linien nicht mehr dargestellt::
     659
     660    sage: f(x)=(x^2 +1)/(x^2-1)
     661    sage: plot(f, xmin=-2, xmax=2, ymin=-10, ymax = 10, detect_poles=True)
     662
     663Möchten wir hingegen die vertikalen Asymptoten trotzdem darstellen, aber nicht in derselben
     664Farbe wie den Funktionsgraphen, können wir die Option ``detect_poles`` auf ``"show"`` stellen::
     665
     666    sage: f(x)=(x^2 +1)/(x^2-1)
     667    sage: plot(f, xmin=-2, xmax=2, ymin=-10, ymax = 10, detect_poles="show")
     668
     669Logarithmen
     670===========
     671
     672Im Folgenden wird beschrieben, wie in Sage Logarithmen benutzt werden können. Grundsätzlich
     673ist es so, dass in Sage der 10er Logarithmus keine spezielle Bedeutung hat. Fall bei einer
     674Logarithmusfunktion die Basis nicht angegeben wird, geht Sage immer vom natürlichen Logarithmus aus.
     675
     676Wenn wir also zum Beispiel `\log(10)` berechnen, wird Sage nichts tun, da sich dieser Term nicht
     677auf eine offensichtliche Art vereinfachen lässt. Berechnen wir jedoch `\log(e^5)`, wird uns Sage die
     678für den natürlichen Logarithmus zu erwartende Antwort geben, nämlich `5`::
     679
     680    sage: log(10)
     681    log(10)
     682
     683    sage: log(e^5)
     684    5
     685
     686Möchten wir die Logarithmusfunktion zu einer anderen Basis berechnen, müssen wir der ``log()`` Funktion
     687als zweites Argument die Basis übergeben. Wollen wir zum Beispiel `\log_{10}(10^5)` berechnen, geben wir
     688dies wie folgt ein::
     689
     690     sage: log(10^5, 10)
     691     5
     692
     693     sage: log(8,2)
     694     3
     695
     696Die oben betrachtete Funktion ``simplify_full()`` wendet auch die Logarithmengesetze an, um Terme zu vereinfachen.
     697So können wir zum Beispiel Sage die Zerlegung
     698
     699.. math:: \log(10^5) = 5\log(2) + 5\log(5)
     700
     701machen lassen::
     702
     703    sage: log(10^5).simplify_full()
     704    5*log(2) + 5*log(5)
     705
     706Trigonometrie
     707=============
     708
     709Winkelmass
     710----------
     711
     712Im folgenden Abschnitt möchten wir uns einen Überblick über die Trigonometrischen Funktionen in Sage verschaffen. Es macht Sinn, zuerst zu betrachten, wie Sage mit Winkelmassen umgeht.
     713
     714Grundsätzlich rechnet Sage immer im Bogenmass. Falls man ein Ergebnis im Gradmass erhalten oder ein Argument im Gradmass in eine Funktion eingeben möchte, muss man
     715dies immer von Hand konvertieren. Es gibt im Moment keine Möglichkeit, Sage so einzustellen, dass es allgemein im Gradmass
     716rechnet.
     717
     718Im Moment bietet Sage hierzu nur das sehr rudimentäre ``units`` Paket, mit welchem man Werte mit einer Einheit versehen und anschliessend auch umrechnen kann. Dies ist sehr umständlich und vermutlich ist es einfacher, die Umrechnung von Hand
     719vorzunehmen, in dem man mit `\frac{\pi}{180^\circ}` respektive `\frac{180^\circ}{\pi}` multipliziert um vom Gradmass ins Bogenmass
     720respektive vom Bogenmass ins Gradmass zu konvertieren::
     721
     722    sage: 45*(pi/180)
     723    1/4*pi
     724
     725    sage: pi/3*(180/pi)
     726    60
     727
     728Falls man dies viel benutzt, lohnt es sich natürlich, diese beiden Konvertierungen als Funktion abzuspeichern. Dies kann wie
     729erwartet mit den in früheren Kapiteln beschriebenen Funktionen geschehen::
     730
     731    sage: deg2rad(x) = x*(pi/180)
     732    sage: rad2deg(x) = x*(180/pi)
     733    sage: deg2rad(45)
     734    1/4*pi
     735    sage: rad2deg(pi/3)
     736    60
     737
     738In Zukunft wird diese Funktion vermutlich vom ``units`` Paket übernommen. Im Moment wird hier auf eine Dokumentation dieses
     739Pakets verzichtet, da es sich sehr schlecht mit den unten beschriebenen trigonometrischen Funktionen verträgt. Weitere Informationen finden sich in der Sage Dokumentation. [#units]_
     740
     741Trigonometrische Funktionen
     742---------------------------
     743
     744Wie oben beschrieben rechnen die trigonometrischen Funktionen in Sage nur im Bogenmass. Die Namen der in der Schule gebräuchlichen
     745trigonometrischen Funktionen sind wie erwartet ``sin()``, ``cos()``, ``tan()`` und ``cot()``. Diese können direkt benutzt werden,
     746falls wir im Bogenmass rechnen möchten. Ansonsten müssen wir wie oben beschrieben vom Gradmass in Bogenmass konvertieren::
     747
     748    sage: cos(pi/6)
     749    1/2*sqrt(3)
     750   
     751    sage: deg2rad(x)= x*(pi/180)
     752    sage: sin(deg2rad(45))
     753    1/2*sqrt(2)
     754    sage: tan(deg2rad(-60))
     755    -sqrt(3)
     756
     757Ihre Umkehrfunktionen sind auch mit den nicht sehr überraschenden Namen ``asin()``, ``acos()``, ``atan()`` und ``acot()`` versehen.
     758Sie geben uns aber wie oben erklärt nur Winkel im Bogenmass zurück. Möchten wir im Gradmass rechnen, müssen wir wieder
     759konvertieren. Die exakte Berechnung der Werte funktioniert in die Gegenrichtung nur, falls im ursprünglichen Wert keine
     760Wurzeln vorkommen::
     761
     762    sage: atan(1)
     763    1/4*pi
     764    sage: acos(1/2)
     765    1/3*pi
     766    sage: rad2deg(x) = x*(180/pi)
     767    sage: rad2deg(acos(-1/2))
     768    120
     769
     770Falls wir Wurzelterme verwenden, müssen wir mit der Funktion ``simplify_full()`` vereinfachen::
     771
     772    sage: acos(sqrt(3)/2)
     773    arccos(1/2*sqrt(3))
     774    sage: (acos(sqrt(3)/2)).simplify_full()
     775    1/6*pi
     776
     777Sage kann auch weitere Regeln für trigonometrische Funktionen anwenden, um Terme zu vereinfachen. Es kennt zum Beispiel auch die
     778Additionstheoreme::
     779
     780    sage: var('x, y')
     781    (x, y)
     782    sage: (sin(x+y)).simplify_full()
     783    sin(x)*cos(y) + sin(y)*cos(x)
     784    sage: (sin(x)^2 + cos(x)^2).simplify_full()
     785    1
     786
     787Vektorgeometrie
     788===============
     789
     790Ein Vektor in Sage kann mit dem Befehl ``vector()`` erstellt werden. Ihm
     791wird eine Liste der Komponenten als Argument übergeben::
     792
     793    sage: vector([3,2,-1])
     794    (3, 2, -1)
     795
     796Grundoperationen
     797----------------
     798
     799Sage kennt die üblichen Vektoroperationen. Es werden die üblichen Zeichen ``+`` für
     800die Addition sowie ``*`` für die Multiplikation mit einem Skalar verwendet::
     801
     802    sage: a = vector([3,2,-1])
     803    sage: b = vector([1,-2,2])
     804    sage: a + b
     805    (4, 0, 1)
     806    sage: 4 * b
     807    (4, -8, 8)
     808    sage: -b + 2*(a + b)
     809    (7, 2, 0)
     810
     811Innerhalb eines Vektors können auch Parameter verwendet werden. Natürlich müssen auch
     812diese zuerst mit ``var()`` als solche deklariert werden::
     813
     814    sage: var('vx, vy, vz')
     815    (vx, vy, vz)
     816    sage: v = vector([vx, vy, vz])
     817    sage: 2*v
     818    (2*vx, 2*vy, 2*vz)
     819
     820Länge eines Vektors
     821-------------------
     822
     823Die (euklidische) Länge eines Vektors wird mit dem Befehl ``norm()`` berechnet::
     824
     825    sage: norm(vector([9,6,2]))
     826    11
     827
     828Falls die Länge nicht ganzzahlig ist, wird natürlich auch ein vereinfachter
     829Term und kein numerischer Wert zurückgegeben::
     830
     831   sage: norm(vector([2,6,2]))
     832   2*sqrt(11)
     833   
     834
     835Skalar- und Vektorprodukt
     836-------------------------
     837
     838Das *Skalarprodukt* wird mit der Funktion ``dot_product()`` berechnet. Diese ist
     839eine Methode der Vektor-Klasse. Sie wird also als Methode eines Vektors
     840ausgeführt, welcher der zweite Vektor übergeben wird::
     841
     842    sage: v = vector([2,3,3])
     843    sage: w = vector([2,2,1])
     844    sage: v.dot_product(w)
     845    13
     846
     847Da das Skalarprodukt kommutativ ist, spielt es natürlich keine Rolle, von welchem
     848Vektor aus wir die Methode aufrufen::
     849
     850    sage: v = vector([2,3,3])
     851    sage: w = vector([2,2,1])
     852    sage: w.dot_product(v)
     853    13
     854
     855Das Skalarprodukt kann auch als Multiplikation zweier Vektoren mit ``*`` geschrieben
     856werden::
     857
     858    sage: v = vector([2,3,3])
     859    sage: w = vector([2,2,1])
     860    sage: v*w
     861    13
     862
     863Es besteht hier aber Verwechslungsgefahr mit der Skalarmultiplikation. Es ist
     864Vorsicht geboten.
     865
     866Das *Vektorprodukt* kann auf die gleiche Weise mit ``cross_product()`` berechnet werden.
     867Hier ist es natürlich relevant, von welchem Vektor aus die Methode ausgeführt
     868wird, da das Vektorprodukt antikommutativ ist.
     869
     870Wollen wir für zwei Vektoren `\vec{v}` und `\vec{w}` das Produkt
     871`\vec{v} \times \vec{w}` berechnen, wird die Methode von `\vec{v}` aus ausgeführt
     872und vice versa::
     873
     874    sage: v = vector([2,3,3])
     875    sage: w = vector([2,2,1])
     876    sage: v.cross_product(w)
     877    (-3, 4, -2)   
     878    sage: w.cross_product(v)
     879    (3, -4, 2)
     880
     881.. Hier wäre ein Abschnitt über das Lösen von Vektorgleichungen spannend, etwa um den Schnittpunkt
     882   einer Geraden mit einer Ebene zu finden. Doch es scheint, dass Sage dies im Moment nicht
     883   unterstützt.
     884
     885Vektoren grafisch darstellen
     886----------------------------
     887
     888Sage kann Vektoren nicht direkt graphisch darstellen. Das 2D Graphikmodul [#2dgraphics]_ kann jedoch Pfeile
     889darstellen, welche sehr gut geeignet sind, um zweidimensionale Vektorrechnungen zu veranschaulichen.
     890
     891Die Funktion ``arrow()`` erstellt einen Pfeil. Da wir keine Vektoren sondern Pfeile darstellen,
     892müssen wir immer einen Anfangspunkt und einen Endpunkt angeben. Mit der Option ``color`` können wir die Farbe
     893des Pfeils festlegen. Die erstellten Pfeile können anschliessend mit dem uns schon bekannten Befehl
     894``plot()`` dargestellt werden.
     895
     896Die Addition von Vektoren könnte also zum Beispiel wie folgt veranschaulicht werden::
     897
     898    sage: v1 = arrow((0,0), (3,4))
     899    sage: v2 = arrow((3,4), (6,1))
     900    sage: sum_v1_v2 = arrow((0,0), (6,1), color='red')
     901    sage: plot(v1 + v2 + sum_v1_v2)
     902
     903Falls die Vektorpfeile zu dick oder zu dünn sind, kann mit der ``width`` Option die Strichbreite angepasst werden.
     904Der Plot-Befehl besitzt eine ``gridlines`` option, welche wir auf ``true`` setzen können, falls Gitternetzlinien
     905in der Grafik erwünscht sind::
     906
     907    sage: v1 = arrow((0,0), (3,4), width=5)
     908    sage: v2 = arrow((3,4), (6,1), width=5)
     909    sage: sum_v1_v2 = arrow((0,0), (6,1), color='red', width=6)
     910    sage: plot(v1 + v2 + sum_v1_v2, gridlines=true)
     911
     912Analysis
     913========
     914
     915Folgen und Reihen
     916-----------------
     917
     918In der gymnasialen Mathematik werden oft Folgen betrachtet. Diese sind grundsätzlich
     919Funktionen von der Menge der natürlichen auf die reellen Zahlen. Sage hat einige
     920Funktionen, um mit Zahlenmengen zu arbeiten. Diese sind aber für unsere Zwecke ungeeignet.
     921
     922Es ist einfacher, Folgen als Funktion zu definieren und um zu verdeutlichen, dass
     923wir diese als Folge benutzen möchten, die Variable mit `n` zu benennen. So speichern wir die
     924Folge
     925
     926.. math:: a_n = \frac{1}{n^2}
     927
     928in Sage als::
     929
     930    sage: a(n) = 1/n^2
     931
     932Um nun Elemente der dazugehörigen Reihe (d.h. die Folge der Teilsummen) zu berechnen, können wir
     933den Befehl ``sum()`` benutzen. Die Summe
     934
     935.. math:: s_6 = \sum_{k=1}^{6}a_k = \sum_{k=1}^{6}\frac{1}{k^2}
     936
     937wird in Sage mit::
     938
     939    sage: var('k')
     940    k
     941    sage: a(n) = 1/n^2
     942    sage: sum(a(k), k, 1, 6)
     943    5369/3600
     944
     945berechnet. Allgemein wird die Summe
     946
     947.. math:: \sum_{k=a}^{b}\text{Ausdruck}
     948
     949mit ``sum(Ausdruck, k, a, b)`` berechnet. Wir können also die Reihe als Folge von Teilsummen
     950in Sage wieder als Funktion speichern::
     951
     952    sage: var('k')
     953    k
     954    sage: a(n) = n^2
     955    sage: s(n) = sum(a(k), k, 1, n)
     956    sage: s
     957    n |--> 1/3*n^3 + 1/2*n^2 + 1/6*n
     958    sage: s(6)
     959    91
     960   
     961Folgen und Reihen graphisch darstellen
     962~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
     963
     964Sage kennt die Funktion ``scatter_plot()`` welcher eine Liste von Tupeln
     965der Form ``(x, y)`` übergeben wird. [#scatterplot]_ Diese werden anschliessen als Punkte
     966dargestellt. Leider können wir dem Befehl aber keine Funktion der Form `a_n = \frac{1}{n^2}`
     967übergeben.
     968
     969Wir müssen also eine Liste von Punkten generieren, welche wir gerne darstellen möchten. Dazu können
     970wir sogenannte Python List Comprehensions [#listcomp]_ benutzen, um die Liste zu generieren::
     971
     972    sage: a(n) = 1/n^2
     973    sage: punkte = [(n, a(n)) for n in range(1,10)]
     974    sage: scatter_plot(punkte)
     975
     976
     977Mit den Funktion ``range()`` geben wir an, welchen Bereich wir gerne darstellen möchten. Dabei wird
     978immer die letzte Zahl ausgeschlossen. Im obigen Beispiel werden also Punkte für `n \in \{1, \dots, 9\}`
     979dargestellt.
     980
     981Wie im Abschnitt über das Darstellen von Funktionsgraphen können wir auch diese Plots kombinieren und
     982so zum Beispiel auch den Plot der Funktion ``a(n)`` hinter die Punkte legen, um die Tendenz der Folge
     983darzustellen::
     984
     985    sage: a(n) = 1/n^2
     986    sage: points = [(n, a(n)) for n in range(1,6)]
     987    sage: plot1 = scatter_plot(points)
     988    sage: plot2 = plot(a(x), xmin=1, xmax=5.4)
     989    sage: plot(plot1 + plot2)
     990
     991
     992Grenzwerte
     993----------
     994
     995Sage kann sowohl Grenzwerte berechnen, bei welchen eine Variable gegen
     996`\infty` oder `-\infty` strebt, sowie Grenzwerte an einer bestimmten Stelle.
     997
     998So können wir zum Beispiel den Grenzwert
     999
     1000.. math:: \lim_{x \rightarrow \infty} \frac{1}{x}
     1001
     1002wie folgt berechnen::
     1003
     1004    sage: var('x')
     1005    x
     1006    sage: ((2*x+1)/x).limit(x=oo)
     1007    2
     1008    sage: (1/x).limit(x=-oo)
     1009    0
     1010
     1011Wie schon bei Stückweise definierten Funktion erklärt wird für `\infty` zweimal der Kleinbuchstaben "o"
     1012also ``oo`` und für `-\infty`  entsprechend ``-oo`` benutzt.
     1013
     1014Grenzwerte an einer bestimmten Stelle werden genauso berechnet. Der Grenzwert
     1015
     1016.. math:: \lim_{x \rightarrow -2} \frac{(x+2)(x-3)}{(x+2)}
     1017
     1018kann wie folgt berechnet werden::
     1019
     1020    sage: var('x')
     1021    x
     1022    sage: term = (x + 2)*(x-3)/(x + 2)
     1023    sage: term.limit(x=-2)
     1024    -5
     1025
     1026In beiden Beispielen darf nicht vergessen werden, die Variable zuerst als
     1027solche zu definieren. Falls wir den links- und den rechtsseitigen Grenzwert
     1028einzeln berechnen wollen, können wir die Option ``dir`` verwenden::
     1029
     1030    sage: var('x')
     1031    x
     1032    sage: term = (x^2 + 1)/(x-1)
     1033    sage: term.limit(x=1)
     1034    Infinity
     1035    sage: term.limit(x=1, dir='+')
     1036    +Infinity
     1037    sage: term.limit(x=1, dir='-')
     1038    -Infinity
     1039
     1040Wir sehen, dass das Ergebnis ``Infinity`` unbestimmt ist. Es ist nicht klar,
     1041ob `+\infty` oder `-\infty` gemeint ist. Erst wenn wir die links- und rechtsseitigen
     1042Grenzwerte analysieren wird klar, in welchem Fall der Wert gegen `+\infty` respektive
     1043`-\infty` strebt.
     1044
     1045Möchte man den Grenzwert einer Summe berechnen, kann man dies direkt mit der Summenfunktion
     1046berechnen. Möchten wir zum Beispiel den Grenzwert
     1047
     1048.. math:: \sum_{k=1}^{\infty}\frac{1}{k^2}
     1049
     1050berechnen, tun wir dies in Sage wie folgt::
     1051
     1052    sage: var('k')
     1053    k
     1054    sage: sum(1/k^2, k, 1, oo)
     1055    1/6*pi^2
     1056
     1057
     1058Differenzial- und Integralrechnung
     1059-----------------------------------------
     1060
     1061Die Ableitung und das unbestimmte Integral (d.h. die Stammfunktion) einer
     1062Funktion `f(x)` wird in Sage mit den Funktionen ``diff()`` und ``integral()``
     1063berechnet. Wir können sowohl Funktionen sowie symbolische Ausdrücke integrieren und
     1064differenzieren. Funktionen können ohne Angabe einer Variable differenziert werden, es
     1065wird nach der durch die Funktionsdefinition gebundenen Variable differenziert.
     1066Da Sage Funktionen in mehreren Unbekannten zulässt, müssen wir bei der Integration
     1067die Integrationsvariable immer angeben.
     1068
     1069Bei einem symbolischen Ausdruck muss die Variable, nach welcher differenziert oder integriert
     1070wird, auf jeden Fall angegeben werden, da mehrere freie Variablen vorkommen können und keine
     1071davon durch die Funktionsschreibweise gebunden ist.
     1072
     1073Ableiten und integrieren einer Funktion in Sage::
     1074
     1075    sage: f(x) = x^2
     1076    sage: f.diff()
     1077    x |--> 2*x
     1078    sage: f.integral(x)
     1079    x |--> 1/3*x^3
     1080
     1081Wie wir sehen, erhalten wir beim Ableiten und Integrieren einer Funktion die Ableitungs-
     1082bzw. eine Stammfunktion wiederum als Sage-Funktionen zurück. Wie in Computer-Algebra-Systemen
     1083üblich wird die Stammfunktion ohne eine addierte Konstante zurückgegeben.
     1084
     1085Im Folgenden leiten wir keine Funktionen, sondern symbolische Ausdrücke ab. Das heisst,
     1086dass wir den Funktionen ``integrate()`` und ``diff()`` als erstes Argument die Variable
     1087übergeben, nach der wir integrieren respektive ableiten wollen::
     1088
     1089    sage: var('x, t')
     1090    (x, t)
     1091    sage: sin(x).diff(x)
     1092    cos(x)
     1093    sage: sin(x).diff(t)
     1094    0
     1095    sage: sin(x).integral(x)
     1096    -cos(x)
     1097    sage: (e^(2*t^2+1)).diff(t)
     1098    4*t*e^(2*t^2 + 1)
     1099
     1100Bestimmtes Integral
     1101~~~~~~~~~~~~~~~~~~~
     1102
     1103Die Funktion ``integral()`` berechnet in Sage auch bestimmte Integrale. Dazu werden die
     1104Integrationsgrenzen als weitere Argumente übergeben. Ein Integral der Form:
     1105
     1106.. math:: \int_{a}^{b}{f(x) \text{d}x}
     1107
     1108wird in Sage mit ``f.integral(x, a, b)`` berechnet. Auch hier gilt die Regel, dass die
     1109Integrationsvariable nur angegeben werden muss, falls es sich bei ``f`` um einen
     1110symbolischen Ausdruck handelt::
     1111
     1112    sage: var('t')
     1113    t
     1114    sage: f(x) = sqrt(4 - x^2)
     1115    sage: f.integral(x, -2, 2)
     1116    2*pi
     1117    sage: sin(t).integral(t, 0, pi)
     1118    2
     1119
     1120Stochastik
     1121==========
     1122
     1123Neben den Grundoperationen ist die in der Stochastik am häufigsten
     1124benutzte Funktion die Fakultät. Für eine Zahl `n \in \mathbb{N}` ist
     1125dies definiert als
     1126
     1127.. math:: n! = n(n-1)(n-2)\cdots 2 \cdot 1
     1128
     1129Sage berechnet dies mit der Funktion ``factorial()``. Im Folgenden wird
     1130die Fakultät von 5 berechnet::
     1131
     1132    sage: factorial(5)
     1133    120
     1134
     1135Sage kann mit Fakultäten auch symbolisch rechnen. Die Terme müssen
     1136aber mit der ``simplify_full()`` Funktion vereinfacht werden::
     1137
     1138    sage: var('n')
     1139    n
     1140    sage: (factorial(n)/factorial(n-2)).simplify_full()
     1141    n^2 - n
     1142
     1143
     1144Binomialkoeffizienten
     1145---------------------
     1146
     1147Um die Anzahl Möglichkeiten zu berechnen, mit denen wir eine Teilmenge
     1148mit `r` Elementen aus einer `n` elementigen Menge wählen können,
     1149benötigen wir den Binomialkoeffizienten. Dieser ist definiert als
     1150
     1151.. math:: \binom{n}{r} = \frac{n!}{(n-r)!n!}
     1152
     1153Diese Berechnung wird mit der Funktion ``binomial()`` ausgewertet,
     1154wobei diese die beiden Argumente `n` und `r` übernimmt::
     1155
     1156    sage: binomial(10, 7)
     1157    120
     1158
     1159Auch Terme, welche die ``binomial()`` Funktion benutzen können mit
     1160``simplify_full()`` vereinfacht werden::
     1161
     1162    sage: var('n, r')
     1163    (n, r)
     1164    sage: (binomial(n,r)*factorial(r)).simplify_full()
     1165    factorial(n)/factorial(n - r)
     1166
     1167Verschiedene nützliche Funktionen
     1168==================================
     1169
     1170Im folgenden Abschnitt sind einige nützliche Funktionen aufgeführt, welche bisher in keinem
     1171Kapitel dieser Anleitung sinnvoll untergebracht werden konnten.
     1172
     1173Die Funktionen ``gcd()`` und ``lcm()`` können benutzt werden, um den **grössten gemeinsamen Teiler** respektive
     1174das **kleinste gemeinsame Vielfache** zweier Zahlen zu finden::
     1175
     1176    sage: gcd(124, 56)
     1177    4
     1178    sage: lcm(21, 15)
     1179    105
     1180
     1181Für das Aufstellen von Aufgaben ist es oft nützlich, **Primzahlen** zu finden. Wir können uns mit dem Befehl ``prime_range()``
     1182einen ganzen Bereich von Primzahlen zwischen zwei Grenzen zurückgeben lassen::
     1183
     1184    sage: prime_range(1050, 1100)
     1185    [1051, 1061, 1063, 1069, 1087, 1091, 1093, 1097]
     1186
     1187Wissen wir genau, oberhalb oder unterhalb welcher Zahl wir eine Primzahl benötigen, können wir mit ``next_prime()``
     1188die nächst grössere Primzahl sowie mit ``previous_prime()`` die nächst kleinere Primzahl bestimmen::
     1189
     1190    sage: next_prime(1050)
     1191    1051
     1192    sage: previous_prime(1100)
     1193    1097
     1194
     1195Mit ``factor()`` können wir eine Zahl in ihre **Primfaktoren** zerlegen. Sind wir an allen Teilern einer Zahl interessiert,
     1196benutzen wir ``divisors()``::
     1197
     1198    sage: factor(156)
     1199    2^2 * 3 * 13
     1200    sage: divisors(156)
     1201    [1, 2, 3, 4, 6, 12, 13, 26, 39, 52, 78, 156]
     1202
     1203
     1204
     1205Weiterführende Links und Literatur
     1206==================================
     1207
     1208Das folgende Tutorial erklärt (auf englisch) wie Sage als einfacher Rechner benutzt werden kann. Hier
     1209finden sich auch viele Funktionen und Beispiele, welche für unsere Zwecke interessant sind.
     1210
     1211* http://www-rohan.sdsu.edu/~mosulliv/sagetutorial/sagecalc.html
     1212
     1213Die offizielle deutsche Dokumentation von Sage ist noch im Aufbau und weit entfernt von einer
     1214vollständigen Dokumentation. Das Einführungstutorial ist jedoch auch auf deutsch verfügbar. Die offizielle
     1215Seite der deutschen Version von Sage findet sich hier:
     1216
     1217* http://www.sagemath.org/de/
     1218
     1219
     1220.. rubric:: Footnotes
     1221
     1222.. [#keywords] http://docs.python.org/2/reference/lexical_analysis.html#keywords
     1223.. [#tutorial] http://www.sagemath.org/de/html/tutorial/
     1224.. [#units] http://www.sagemath.org/doc/reference/calculus/sage/symbolic/units.html
     1225.. [#2dgraphics] http://www.sagemath.org/doc/reference/plotting/index.html
     1226.. [#scatterplot] http://www.sagemath.org/doc/reference/plotting/sage/plot/scatter_plot.html
     1227.. [#listcomp] http://docs.python.org/2/tutorial/datastructures.html#list-comprehensions