Christopher Frei

frei@math.tugraz.at

Steyrergasse 30, 2. Stock

Wo bekomme ich Sage?

  • Online am Jupyter-Server der Uni Graz: https://imsc.uni-graz.at/jupyter/ (Login via SSO über Uni Graz Online account)

Lokale Installation auf Ihrem eigenen Rechner:

  • unter Linux: wahrscheinlich in der Paketverwaltung Ihrer Distribution vorhanden

  • Herunterladen auf www.sagemath.org (den dortigen Installationsanweisungen folgen)

Kommerzielle Onlineversion:

  • www.cocalc.com

Die für die Übungen relevante Version ist Sage 10.7.

Was ist Sage?

Ein Computeralgebrasystem basierend auf der Programmiersprache Python. Also im Wesentlichen Python mit vielen zusätzlichen Mathematikfunktionen. Es kennt viele mathematische Objekte und Strukturen und kann mit diesen numerisch und exakt rechnen. Sage ist Open-Source. Viele seiner Funktionen sind aus anderen Open-Source-Mathematikprogrammen übernommen (z.B. Maxima, GAP).

Wir verwenden Sage über das Jupyter-Notebookinterface, das neben Python auch andere Programmiersprachen unterstützt. Man kann seinen Code hier auf mehrere Zellen aufteilen und diese getrennt voneinander ausführen.

Einfache Rechnungen

Zelle ausführen: Shift + Enter

In [1]:
1+1
Out[1]:
2
In [2]:
2*3
Out[2]:
6
In [3]:
2/3
Out[3]:
2/3
In [4]:
2/3+1/6
Out[4]:
5/6
In [5]:
_
Out[5]:
5/6
In [6]:
_^2
Out[6]:
25/36
In [7]:
14//3     # Ganzzahlige Division
Out[7]:
4
In [8]:
14 % 3    # Rest bei Division
Out[8]:
2
In [9]:
14.quo_rem(3)    # Division mit Rest als Sage-Methode
Out[9]:
(4, 2)
In [10]:
(14/3).n()     # Numerisch auswerten
Out[10]:
4.66666666666667

Variablen

In ausgeführten Zellen belegte Variablen bleiben im Speicher und können auch in späteren Zellen verwendet werden. Relevant ist die Reihenfolge, in der die Zellen ausgeführt werden, nicht ihre Reihenfolge im Notebook.

Damit hier keine Fehlermeldung kommt, muß die übernächste Zelle vor der nächsten ausgeführt werden.

In [13]:
a^3
Out[13]:
64
In [12]:
a=4        # Hier wird kein Output angezeigt. Will man den Wert von a nach der Zuweisung sehen, muss man das extra angeben.
In [14]:
a=1/2
a
Out[14]:
1/2
In [15]:
a=1/2; a
Out[15]:
1/2
In [16]:
show(a)    # schönere Ausgabe. Sie können den Bruch rechts anklicken und auch den LaTeX-Code erhalten.
\(\displaystyle \frac{1}{2}\)
In [17]:
b=sqrt(2)  # Irrationale Zahlen werden auch als symbolische Ausdrücke gespeichert.
b
Out[17]:
sqrt(2)
In [18]:
show(b)
\(\displaystyle \sqrt{2}\)
In [19]:
b.n()       # numerische Auswertung wie zuvor
Out[19]:
1.41421356237310
In [20]:
b^2
Out[20]:
2

Klassen und Objekte

Python, und daher auch Sage, sind objektorientiert: alles ist ein Objekt, und jedes Objekt gehört einer Klasse an. Die Klasse bestimmt, was man mit einem Objekt machen kann. Sie stellt Methoden bereit, das sind Funktionen, die mit ihren Objekten ausgeführt werden können.

In [21]:
a
Out[21]:
1/2
In [22]:
type(a)     # die Klasse des in der Variable a gespeicherten Objekts.
Out[22]:
<class 'sage.rings.rational.Rational'>

In sage definierte mathematische Objekte sind üblicherweise Elemente gewisser mathematischer Struktren. Diese sind ähnlich zu den Klassen in Python, aber anschaulicher.

In [23]:
parent(a)   # die Struktur, deren Element a ist; hier ist a eine rationale Zahl, und daher Element der Struktur Rational Field
Out[23]:
Rational Field
In [24]:
show(parent(a))
\(\displaystyle \newcommand{\Bold}[1]{\mathbf{#1}}\Bold{Q}\)
In [25]:
Rational Field        # Die Ausgabe der vorletzten Berechnung, "Rational Field", ist nur eine Beschreibung des Objekts parent(a). Solche Beschreibungen sind nicht dazu gedacht, auf die Objekte zuzugreifen, daher kommt hier eine Fehlermeldung

  Cell In [25], line 1
    Rational Field        # Die Ausgabe der vorletzten Berechnung, "Rational Field", ist nur eine Beschreibung des Objekts parent(a). Solche Beschreibungen sind nicht dazu gedacht, auf die Objekte zuzugreifen, daher kommt hier eine Fehlermeldung
             ^
SyntaxError: invalid syntax
In [26]:
f=parent(a)    # Hier wird parent(a) in einer neuen Variable f gespeichert und wir können damit weiterarbeiten
f
Out[26]:
Rational Field
In [27]:
type(f)
Out[27]:
<class 'sage.rings.rational_field.RationalField_with_category'>

Viele mathematische Objekte werden als symbolische Ausdrücke gespeichert.

In [28]:
b=sqrt(2)
type(b)
Out[28]:
<class 'sage.symbolic.expression.Expression'>
In [29]:
parent(b)
Out[29]:
Symbolic Ring
In [30]:
b^2
Out[30]:
2
In [31]:
parent(_)        # das Ergebnis 2 wird hier immer noch als symbolischer Ausdruck gespeichert, also nicht automatisch wieder als ganze Zahl gesehen
Out[31]:
Symbolic Ring
In [32]:
parent(2)        # ganze Zahlen sind Elemente der Struktur Integer Ring
Out[32]:
Integer Ring

Im nächsten Beispiel wird die Zahl 2, ein Element des Integer Ring, mit der Zahl 1/2, ein Element des Rational Field, multipliziert. Dazu wird intern zuerst 2 als Element des Rational Field betrachtet, und dann die für Rational Field definierte Multiplikation verwendet. Solche impliziten Typumwandlungen geschehen oft automatisch, wenn es eine kanonische Umwandlung gibt.

In [21]:
2*(1/2)
Out[21]:
1
In [22]:
type(_)     # Das Ergebnis, 1, wurde nicht automatisch wieder zu einem Element des Integer Ring umgewandelt, auch wenn das hier möglich wäre.
Out[22]:
<class 'sage.rings.rational.Rational'>
In [23]:
ZZ(2*(1/2))    # Hier geben wir durch ZZ(...) explizit an, dass das Ergebnis als Element des Integer Ring gesehen werden soll.
Out[23]:
1
In [24]:
type(_)
Out[24]:
<class 'sage.rings.integer.Integer'>
In [25]:
ZZ(1/2)     # Natürlich kann nicht jede rationale Zahl in eine ganze Zahl umgewandelt werden.

---------------------------------------------------------------------------
TypeError                                 Traceback (most recent call last)
Cell In[25], line 1
----> 1 ZZ(Integer(1)/Integer(2))     # Natürlich kann nicht jede rationale Zahl in eine ganze Zahl umgewandelt werden.

File /opt/sagemath/sage-10.5/src/sage/structure/parent.pyx:901, in sage.structure.parent.Parent.__call__()
    899 if mor is not None:
    900     if no_extra_args:
--> 901         return mor._call_(x)
    902     else:
    903         return mor._call_with_args(x, args, kwds)

File /opt/sagemath/sage-10.5/src/sage/rings/rational.pyx:4208, in sage.rings.rational.Q_to_Z._call_()
   4206 """
   4207 if not mpz_cmp_si(mpq_denref((<Rational>x).value), 1) == 0:
-> 4208     raise TypeError("no conversion of this rational to integer")
   4209 cdef Integer n = Integer.__new__(Integer)
   4210 n.set_from_mpz(mpq_numref((<Rational>x).value))

TypeError: no conversion of this rational to integer
In [26]:
sqrt(-1)
Out[26]:
I
In [27]:
I    # Die Variable I ist als Wert imaginäre Einheit vordefniert
Out[27]:
I
In [28]:
I^2
Out[28]:
-1
In [29]:
I=5    # I wird nicht vor Umdefinitionen geschützt!
In [30]:
sqrt(-1)   # Hier ist der Output trotzdem noch I, denn es handelt sich nur um eine Beschreibung des Wertes von sqrt(-1). Das ist unabhängig vom Wert der Variable I, den wir oben geändert haben.
Out[30]:
I
In [31]:
I^2
Out[31]:
25
In [32]:
restore('I')     # So kann man geänderte vordefinierte Variablen wieder auf ihren ursprünglichen Wert zurücksetzen.
In [33]:
I^2
Out[33]:
-1
In [34]:
pi     # Die Variable pi ist als die Kreiszahl vordefiniert
Out[34]:
pi
In [35]:
parent(pi)
Out[35]:
Symbolic Ring
In [36]:
pi.n(digits=5000)    # numerische Auswertung muß explizit gefordert werden. Hier: auf 5000 Ziffern genau
Out[36]:
3.1415926535897932384626433832795028841971693993751058209749445923078164062862089986280348253421170679821480865132823066470938446095505822317253594081284811174502841027019385211055596446229489549303819644288109756659334461284756482337867831652712019091456485669234603486104543266482133936072602491412737245870066063155881748815209209628292540917153643678925903600113305305488204665213841469519415116094330572703657595919530921861173819326117931051185480744623799627495673518857527248912279381830119491298336733624406566430860213949463952247371907021798609437027705392171762931767523846748184676694051320005681271452635608277857713427577896091736371787214684409012249534301465495853710507922796892589235420199561121290219608640344181598136297747713099605187072113499999983729780499510597317328160963185950244594553469083026425223082533446850352619311881710100031378387528865875332083814206171776691473035982534904287554687311595628638823537875937519577818577805321712268066130019278766111959092164201989380952572010654858632788659361533818279682303019520353018529689957736225994138912497217752834791315155748572424541506959508295331168617278558890750983817546374649393192550604009277016711390098488240128583616035637076601047101819429555961989467678374494482553797747268471040475346462080466842590694912933136770289891521047521620569660240580381501935112533824300355876402474964732639141992726042699227967823547816360093417216412199245863150302861829745557067498385054945885869269956909272107975093029553211653449872027559602364806654991198818347977535663698074265425278625518184175746728909777727938000816470600161452491921732172147723501414419735685481613611573525521334757418494684385233239073941433345477624168625189835694855620992192221842725502542568876717904946016534668049886272327917860857843838279679766814541009538837863609506800642251252051173929848960841284886269456042419652850222106611863067442786220391949450471237137869609563643719172874677646575739624138908658326459958133904780275900994657640789512694683983525957098258226205224894077267194782684826014769909026401363944374553050682034962524517493996514314298091906592509372216964615157098583874105978859597729754989301617539284681382686838689427741559918559252459539594310499725246808459872736446958486538367362226260991246080512438843904512441365497627807977156914359977001296160894416948685558484063534220722258284886481584560285060168427394522674676788952521385225499546667278239864565961163548862305774564980355936345681743241125150760694794510965960940252288797108931456691368672287489405601015033086179286809208747609178249385890097149096759852613655497818931297848216829989487226588048575640142704775551323796414515237462343645428584447952658678210511413547357395231134271661021359695362314429524849371871101457654035902799344037420073105785390621983874478084784896833214457138687519435064302184531910484810053706146806749192781911979399520614196634287544406437451237181921799983910159195618146751426912397489409071864942319615679452080951465502252316038819301420937621378559566389377870830390697920773467221825625996615014215030680384477345492026054146659252014974428507325186660021324340881907104863317346496514539057962685610055081066587969981635747363840525714591028970641401109712062804390397595156771577004203378699360072305587631763594218731251471205329281918261861258673215791984148488291644706095752706957220917567116722910981690915280173506712748583222871835209353965725121083579151369882091444210067510334671103141267111369908658516398315019701651511685171437657618351556508849099898599823873455283316355076479185358932261854896321329330898570642046752590709154814165498594616371802709819943099244889575712828905923233260972997120844335732654893823911932597463667305836041428138830320382490375898524374417029132765618093773444030707469211201913020330380197621101100449293215160842444859637669838952286847831235526582131449576857262433441893039686426243410773226978028073189154411010446823252716201052652272111660396665573092547110557853763466820653109896526918620564769312570586356620185581007293606598764861179104533488503461136576867532494416680396265797877185560845529654126654085306143444318586769751456614068007002378776591344017127494704205622305389945613140711270004078547332699390814546646458807972708266830634328587856983052358089330657574067954571637752542021149557615814002501262285941302164715509792592309907965473761255176567513575178296664547791745011299614890304639947132962107340437518957359614589019389713111790429782856475032031986915140287080859904801094121472213179476477726224142548545403321571853061422881375850430633217518297986622371721591607716692547487389866549494501146540628433663937900397692656721463853067360965712091807638327166416274888800786925602902284721040317211860820419000422966171196377921337575114959501566049631862947265473642523081770367515906735023507283540567040386743513622224771589150495309844489333096340878076932599397805419341447377441842631298608099888687413260472
In [37]:
# Sei o ein Objekt der Klasse k, und f eine Methode dieser Klasse. Um f für das Objekt o auszuführen, gibt es zwei äquivalente Möglichkeiten:
#
#   k.f(o)      ....  Sollte man nicht verwenden, da unnötig kompliziert
#   o.f()       ....  zu bevorzugen
In [38]:
type(pi)
Out[38]:
<class 'sage.symbolic.expression.Expression'>
In [39]:
Expression.n(pi,digits=40)        # so nicht machen!
Out[39]:
3.141592653589793238462643383279502884197
In [40]:
pi.n(digits=40)                   # hier wird genau dieselbe Funktion Expression.n() auf pi angewandt wie oben (mit zweitem Argument digits=40). Der Aufruf ist so übersichtlicher.
Out[40]:
3.141592653589793238462643383279502884197
In [41]:
numerical_approx(pi, digits=40)              # hier wird die globale Funktion numerical_approx() auf pi angewandt (wieder mit zweitem Argument digits=40). Intern führt das zur selben Funktion wie pi.n().
Out[41]:
3.141592653589793238462643383279502884197

Methoden und Funktionen mit demselben Namen machen nicht immer dasselbe, selbst wenn der Output gleich aussieht.

In [42]:
mod(42,9)        # Globale Funktion mod(), liefert die Restklasse von 42 modulo 9.
Out[42]:
6
In [43]:
parent(_)
Out[43]:
Ring of integers modulo 9
In [44]:
42.mod(9)        # Die Funktion Integer.mod(), liefert einen Repräsentanten in ZZ der Restklasse von 42 modulo 9.
Out[44]:
6
In [45]:
parent(_)
Out[45]:
Integer Ring

Dokumentation und Hilfe

Auto-Verfollständigung von Methodennamen mit TAB

Methodenname ohne Klammern mit ? liefert Dokumentation

Methodenname ohne Klammern mit ?? liefert Dokumentation + Quellcode

In [ ]:
pi.   # Druck auf Tabulatortaste liefert hier Liste aller Methoden der Klasse von pi, also von Expression.
In [ ]:
pi.n   # Druck auf TAB hier liefert alle Methoden, die min n beginnen
In [66]:
pi.n?

Docstring:     
   Alias for "numerical_approx()".

   EXAMPLES:

      sage: (2/3).n()
      0.666666666666667
Init docstring: Initialize self.  See help(type(self)) for accurate signature.
File:           /opt/sagemath/sage-10.1/src/sage/structure/element.pyx
Type:           builtin_function_or_method
In [67]:
pi.numerical_approx?

Docstring:     
   Return a numerical approximation of "self" with "prec" bits (or
   decimal "digits") of precision.

   No guarantee is made about the accuracy of the result.

   INPUT:

   * "prec" -- precision in bits

   * "digits" -- precision in decimal digits (only used if "prec" is
     not given)

   * "algorithm" -- which algorithm to use to compute this
     approximation

   If neither "prec" nor "digits" is given, the default precision is
   53 bits (roughly 16 digits).

   EXAMPLES:

      sage: sin(x).subs(x=5).n()
      -0.958924274663138
      sage: sin(x).subs(x=5).n(100)
      -0.95892427466313846889315440616
      sage: sin(x).subs(x=5).n(digits=50)
      -0.95892427466313846889315440615599397335246154396460
      sage: zeta(x).subs(x=2).numerical_approx(digits=50)
      1.6449340668482264364724151666460251892189499012068

      sage: cos(3).numerical_approx(200)
      -0.98999249660044545727157279473126130239367909661558832881409
      sage: numerical_approx(cos(3),200)
      -0.98999249660044545727157279473126130239367909661558832881409
      sage: numerical_approx(cos(3), digits=10)
      -0.9899924966
      sage: (i + 1).numerical_approx(32)
      1.00000000 + 1.00000000*I
      sage: (pi + e + sqrt(2)).numerical_approx(100)
      7.2740880444219335226246195788
Init docstring: Initialize self.  See help(type(self)) for accurate signature.
File:           /opt/sagemath/sage-10.1/src/sage/symbolic/expression.pyx
Type:           builtin_function_or_method
In [68]:
pi.numerical_approx??

Docstring:
   Return a numerical approximation of "self" with "prec" bits (or
   decimal "digits") of precision.

   No guarantee is made about the accuracy of the result.

   INPUT:

   * "prec" -- precision in bits

   * "digits" -- precision in decimal digits (only used if "prec" is
     not given)

   * "algorithm" -- which algorithm to use to compute this
     approximation

   If neither "prec" nor "digits" is given, the default precision is
   53 bits (roughly 16 digits).

   EXAMPLES:

      sage: sin(x).subs(x=5).n()
      -0.958924274663138
      sage: sin(x).subs(x=5).n(100)
      -0.95892427466313846889315440616
      sage: sin(x).subs(x=5).n(digits=50)
      -0.95892427466313846889315440615599397335246154396460
      sage: zeta(x).subs(x=2).numerical_approx(digits=50)
      1.6449340668482264364724151666460251892189499012068

      sage: cos(3).numerical_approx(200)
      -0.98999249660044545727157279473126130239367909661558832881409
      sage: numerical_approx(cos(3),200)
      -0.98999249660044545727157279473126130239367909661558832881409
      sage: numerical_approx(cos(3), digits=10)
      -0.9899924966
      sage: (i + 1).numerical_approx(32)
      1.00000000 + 1.00000000*I
      sage: (pi + e + sqrt(2)).numerical_approx(100)
      7.2740880444219335226246195788
Source:   
    def numerical_approx(self, prec=None, digits=None, algorithm=None):
        """
        Return a numerical approximation of ``self`` with ``prec`` bits
        (or decimal ``digits``) of precision.

        No guarantee is made about the accuracy of the result.

        INPUT:

        - ``prec`` -- precision in bits

        - ``digits`` -- precision in decimal digits (only used if
          ``prec`` is not given)

        - ``algorithm`` -- which algorithm to use to compute this
          approximation

        If neither ``prec`` nor ``digits`` is given, the default
        precision is 53 bits (roughly 16 digits).

        EXAMPLES::

            sage: sin(x).subs(x=5).n()
            -0.958924274663138
            sage: sin(x).subs(x=5).n(100)
            -0.95892427466313846889315440616
            sage: sin(x).subs(x=5).n(digits=50)
            -0.95892427466313846889315440615599397335246154396460
            sage: zeta(x).subs(x=2).numerical_approx(digits=50)
            1.6449340668482264364724151666460251892189499012068

            sage: cos(3).numerical_approx(200)
            -0.98999249660044545727157279473126130239367909661558832881409
            sage: numerical_approx(cos(3),200)
            -0.98999249660044545727157279473126130239367909661558832881409
            sage: numerical_approx(cos(3), digits=10)
            -0.9899924966
            sage: (i + 1).numerical_approx(32)
            1.00000000 + 1.00000000*I
            sage: (pi + e + sqrt(2)).numerical_approx(100)
            7.2740880444219335226246195788

        TESTS:

        We test the evaluation of different infinities available in Pynac::

            sage: t = x - oo; t
            -Infinity
            sage: t.n()
            -infinity
            sage: t = x + oo; t
            +Infinity
            sage: t.n()
            +infinity
            sage: t = x - unsigned_infinity; t
            Infinity
            sage: t.n()
            Traceback (most recent call last):
            ...
            ValueError: can only convert signed infinity to RR

        Some expressions cannot be evaluated numerically::

            sage: n(sin(x))
            Traceback (most recent call last):
            ...
            TypeError: cannot evaluate symbolic expression numerically
            sage: a = var('a')
            sage: (x^2 + 2*x + 2).subs(x=a).n()
            Traceback (most recent call last):
            ...
            TypeError: cannot evaluate symbolic expression numerically

        Make sure we've rounded up log(10,2) enough to guarantee
        sufficient precision (:trac:`10164`)::

            sage: ks = 4*10**5, 10**6
            sage: all(len(str(e.n(digits=k)))-1 >= k for k in ks)
            True

        Symbolic sums with definite endpoints are expanded (:trac:`9424`)::

            sage: (k,n) = var('k,n')
            sage: f(n) = sum(abs(-k*k+n),k,1,n)
            sage: ex = f(n=8); ex
            sum(abs(-k^2 + 8), k, 1, 8)
            sage: ex.n()
            162.000000000000
            sage: (ex+1).n()
            163.000000000000

        Check if :trac:`24418` is fixed::

            sage: numerical_approx(2^(450232897/4888643760))
            1.06591892580915
        """
        if prec is None:
            prec = digits_to_bits(digits)

        from sage.symbolic.expression_conversions import ExpressionTreeWalker

        class DefiniteSumExpander(ExpressionTreeWalker):
            def composition(self, ex, operator):
                if hasattr(operator, 'name') and operator.name() == 'sum' and (
                        is_a_numeric((<Expression>ex.operands()[2])._gobj)
                        and is_a_numeric((<Expression>ex.operands()[3])._gobj)):
                    from sage.calculus.calculus import symbolic_sum
                    return symbolic_sum(*(ex.operands()))
                return super().composition(ex, operator)

        s = DefiniteSumExpander(self)
        cdef Expression x = self._parent(s())
        from sage.rings.real_mpfr import RealField
        R = RealField(prec)
        kwds = {'parent': R, 'algorithm': algorithm}
        try:
            x = x._convert(kwds)
        except TypeError:  # numerical approximation for real number failed
            pass           # try again with complex
            kwds['parent'] = R.complex_field()
            x = x._convert(kwds)

        # we have to consider constants as well, since infinity is a constant
        # in pynac
        if is_a_numeric(x._gobj):
            res = py_object_from_numeric(x._gobj)
        elif is_a_constant(x._gobj):
            res = x.pyobject()
        else:
            raise TypeError("cannot evaluate symbolic expression numerically")

        # Important -- the  we get might not be a valid output for numerical_approx in
        # the case when one gets infinity.
        if isinstance(res, AnInfinity):
            return res.n(prec=prec, digits=digits)
        return res
File:      /opt/sagemath/sage-10.1/src/sage/symbolic/expression.pyx
Type:      builtin_function_or_method

Gleitkommazahlen

In [47]:
R=RealField()       # Körper der reellen Zahlen, in Sage implementiert als Gleitkommazahlen mit 53 bit (15 Dezimalstellen) Präzision
R
Out[47]:
Real Field with 53 bits of precision
In [48]:
R(1)
Out[48]:
1.00000000000000
In [49]:
R100=RealField(100)      # Körper der reellen Zahlen mit höherer Präzision
R100
Out[49]:
Real Field with 100 bits of precision
In [50]:
R100(1)
Out[50]:
1.0000000000000000000000000000
In [51]:
R100(1)/R100(3)
Out[51]:
0.33333333333333333333333333333
In [52]:
R100(1)/3      # Die ganze Zahl 3 wird für die Operation automatisch in ein Element von R100 umgewandelt
Out[52]:
0.33333333333333333333333333333
In [55]:
R100(1)/R(3)    # Hier wird R100(1) automatisch in eine relle Zahl mit mit niedrigerer Präzision umgewandelt, das Ergebnis hat auch niedrigere Präzision
Out[55]:
0.333333333333333
In [56]:
_.str(base=2)
Out[56]:
'0.010101010101010101010101010101010101010101010101010101'
In [57]:
R100(R100(1)/R(3))    # Hier wird das Ergebnis auf scheinbar beliebige Art wieder zu einer Zahl mit Präzision 100 gemacht. Wo kommen die zusätzlichen Stellen her?
Out[57]:
0.33333333333333331482961625625
In [58]:
_.str(base=2)      # Antwort: Intern wird alles in Binärdarstellung gespeichert, und in dieser Darstellung wurden einfach Nullen angehängt. Auf Dezimal umgerechnet ergibt das die obige Zahl.
Out[58]:
'0.01010101010101010101010101010101010101010101010101010100000000000000000000000000000000000000000000000'

Listen

In [94]:
l=[1,2,3,x,"abc",ZZ,2]        # Listen werden mit eckigen Klammern angegeben und können beliebige Objekte enthalten.
l
Out[94]:
[1, 2, 3, x, 'abc', Integer Ring, 2]
In [95]:
type(l)
Out[95]:
<class 'list'>
In [96]:
l[1]      # Zugriff auf Elemente via Indizes. Achtung: Indizes starten bei 0
Out[96]:
2
In [97]:
l[0]
Out[97]:
1
In [98]:
l[-1]     # das letzte Element
Out[98]:
2
In [99]:
l[-2]     # das vorletzte Element
Out[99]:
Integer Ring
In [100]:
len(l)     # Länge der Liste
Out[100]:
7
In [101]:
l.append(5)    # Ein Element am Ende anhängen. Hier wird die Liste direkt modifiziert, und nicht etwa eine neue Kopie mit dem zusätzlichen Element erstellt!
In [102]:
l
Out[102]:
[1, 2, 3, x, 'abc', Integer Ring, 2, 5]
In [103]:
del l[2]       # Das Element an dritter Stelle (Index 2) löschen. Auch hier wird die Liste direkt modifiziert.
In [104]:
l
Out[104]:
[1, 2, x, 'abc', Integer Ring, 2, 5]
In [105]:
l.remove(x)     # das Element x aus der Liste löschen
In [106]:
l
Out[106]:
[1, 2, 'abc', Integer Ring, 2, 5]
In [107]:
l.remove(2)      # nur das erste passende Element wird gelöscht, die zweite 2 bleibt in der Liste.
In [108]:
l
Out[108]:
[1, 'abc', Integer Ring, 2, 5]
In [109]:
l.insert(1,"u")
In [110]:
l
Out[110]:
[1, 'u', 'abc', Integer Ring, 2, 5]

Komplexe und ganze Zahlen

In [111]:
a=pi+I     
a
Out[111]:
pi + I
In [112]:
type(a)
Out[112]:
<class 'sage.symbolic.expression.Expression'>
In [113]:
a.n()
Out[113]:
3.14159265358979 + 1.00000000000000*I
In [114]:
CC     # bereits vordefiniert als die komplexen Zahlen mit 53 bits Präzision
Out[114]:
Complex Field with 53 bits of precision
In [115]:
RR
Out[115]:
Real Field with 53 bits of precision
In [116]:
ComplexField()      # Die Funktion ComplexField() liefert ein Objekt wie CC: die komplexen Zahlen mit 53 bits Präzision
Out[116]:
Complex Field with 53 bits of precision
In [117]:
CC(a)
Out[117]:
3.14159265358979 + 1.00000000000000*I
In [118]:
real(a)    # Realteil symbolisch
Out[118]:
pi
In [119]:
imag(a)    # Imaginärteil symbolisch
Out[119]:
1
In [120]:
b=CC(a)    # wandle um zu komplexer Fließkommazahl
b
Out[120]:
3.14159265358979 + 1.00000000000000*I
In [121]:
real(b)
Out[121]:
3.14159265358979
In [122]:
imag(b)
Out[122]:
1.00000000000000
In [123]:
parent(1)     # Ganze Zahlen sind in Sage Elemente der Struktur Integer Ring
Out[123]:
Integer Ring
In [124]:
gcd(77,135)   # ggT
Out[124]:
1
In [125]:
xgcd(77,335)   # erweiterter Euklidischer Algorithmus:  1 = ggT(77, 335) = -87*77 + 20*335
Out[125]:
(1, -87, 20)
In [126]:
-87*77+20*335
Out[126]:
1
In [127]:
lcm(77,335)      # kgV
Out[127]:
25795
In [128]:
77*335           # kgV = Produkt, da ggT=1
Out[128]:
25795
In [129]:
factor(335)      # Zerlegung in Primfaktoren
Out[129]:
5 * 67
In [130]:
77.is_prime()    # Primzahltest
Out[130]:
False
In [131]:
a=77

Viele weitere Methoden der Klasse Integer über a.<TAB> verfügbar.

In [132]:
a.divisors?

Docstring:     
   Return the list of all positive integer divisors of this integer,
   sorted in increasing order.

   EXAMPLES:

      sage: (-3).divisors()
      [1, 3]
      sage: 6.divisors()
      [1, 2, 3, 6]
      sage: 28.divisors()
      [1, 2, 4, 7, 14, 28]
      sage: (2^5).divisors()
      [1, 2, 4, 8, 16, 32]
      sage: 100.divisors()
      [1, 2, 4, 5, 10, 20, 25, 50, 100]
      sage: 1.divisors()
      [1]
      sage: 0.divisors()
      Traceback (most recent call last):
      ...
      ValueError: n must be nonzero
      sage: (2^3 * 3^2 * 17).divisors()
      [1, 2, 3, 4, 6, 8, 9, 12, 17, 18, 24, 34, 36, 51, 68, 72,
      102, 136, 153, 204, 306, 408, 612, 1224]
      sage: a = odd_part(factorial(31))
      sage: v = a.divisors()
      sage: len(v)
      172800
      sage: prod(e + 1 for p, e in factor(a))
      172800
      sage: all(t.divides(a) for t in v)
      True

      sage: n = 2^551 - 1
      sage: L = n.divisors()
      sage: len(L)
      256
      sage: L[-1] == n
      True

   Note:

     If one first computes all the divisors and then sorts it, the
     sorting step can easily dominate the runtime. Note, however, that
     (nonnegative) multiplication on the left preserves relative
     order. One can leverage this fact to keep the list in order as
     one computes it using a process similar to that of the merge sort
     algorithm.
Init docstring: Initialize self.  See help(type(self)) for accurate signature.
File:           /opt/sagemath/sage-10.5/src/sage/rings/integer.pyx
Type:           builtin_function_or_method
In [133]:
a.divisors()  # Liste der Teiler von a
Out[133]:
[1, 7, 11, 77]
In [134]:
a.next_prime()
Out[134]:
79
In [135]:
79.next_prime()
Out[135]:
83