Numbers
system:sage

{{{id=17|
# Ein der wenigen syntaktischen Unterschiede zwischen Python und SAGE
# ist die Interpretation der Division. In SAGE ist das Ergebnis einer 
# Division ganzer Zahlen immer eine gekrzte rationale Zahl:
18/16
///

9/8
}}}

{{{id=21|
type(18/16)
///

<type 'sage.rings.rational.Rational'>
}}}

{{{id=22|
18/16 + 2/16
///

5/4
}}}

{{{id=23|
5/4 + 3/4
///

2
}}}

{{{id=42|
# Teilbarkeit lt sich mittels der Methode 'divides' testen:
(5.divides(7), 5.divides(10), 5.divides(0), 0.divides(0), 0.divides(1))
///

(False, True, True, True, False)
}}}

{{{id=18|
# Mchte man (so wie in Python) nur den ganzzahligen Anteil, dann
# sind zwei Schrgstriche zu verwenden:
17 // 5
///

3
}}}

{{{id=24|
18 // 3
///

6
}}}

{{{id=29|
# Dabei gilt:
# m//n ist eine ganze Zahl mit (m//n)*n %u2264 m, 
# und fr alle ganzen Zahlen q gilt: Wenn q*n %u2264 m, dann q %u2264 m//n.
# Dabei gilt stets m//n == floor(m/n)
(17//5, floor(17/5)), (-17//5, floor(-17/5)), (17//-5, floor(17/-5)), (-17//-5, floor(-17/-5))
///

((3, 3), (-4, -4), (-4, -4), (3, 3))
}}}

{{{id=19|
# Fr den Divisionsrest wird, so wie in vielen anderen Programmiersprachen auch, das
# Prozentzeichen verwendet.
17 % 5
///

2
}}}

{{{id=27|
-17 % 5
///

3
}}}

{{{id=26|
17 % -5
///

-3
}}}

{{{id=28|
-17 % -5
///

-2
}}}

{{{id=20|
# Es gilt stets: m = (m//n)*n + m%n
17//5 * 5 + 17 % 5, -17//5 * 5 + -17 % 5, 17//-5 * -5 + 17 %-5, -17//-5 * -5 + -17 % -5
///

(17, -17, 17, -17)
}}}

{{{id=36|
# Wenig berraschend erhalten wir hier eine Fehlermeldung:
5 // 0
///

Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
  File "/home3/home0/staff/xbx/.sage/sage_notebook/worksheets/admin/7/code/24.py", line 7, in <module>
    exec compile(ur'_sage_const_5  // _sage_const_0' + '\n', '', 'single')
  File "/opt/sage/local/lib/python2.5/site-packages/SQLAlchemy-0.4.6-py2.5.egg/", line 1, in <module>
    
  File "integer.pyx", line 1200, in sage.rings.integer.Integer.__floordiv__ (sage/rings/integer.c:9629)
ZeroDivisionError: other must be nonzero
}}}

{{{id=35|
# Eher berraschend ist Sie dagegen hier:
0 % 0
///

Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
  File "/home3/home0/staff/xbx/.sage/sage_notebook/worksheets/admin/7/code/25.py", line 7, in <module>
    exec compile(ur'_sage_const_0  % _sage_const_0' + '\n', '', 'single')
  File "/opt/sage/local/lib/python2.5/site-packages/SQLAlchemy-0.4.6-py2.5.egg/", line 1, in <module>
    
  File "integer.pyx", line 1848, in sage.rings.integer.Integer.__mod__ (sage/rings/integer.c:12912)
ZeroDivisionError: Integer modulo by zero
}}}

{{{id=43|
# Obwohl:
0.divides(0)
///

True
}}}

{{{id=37|
# Dies hat zur Folge, da wir Teilbarkeit nicht mittels  m % n == 0  testen drfen,
# was in allen anderen Fllen funktioniert.
(7 % 5 == 0, 10 % 5 == 0, 0 % 5 == 7)
///

(False, True, False)
}}}

{{{id=2|
# Wir definieren den ggt gem der Konstruktion im Beweis seiner Existenz.
def ggt(m,n):
  if n==0:
     return abs(m)
  else:
     return ggt(n,m % n)
///
}}}

{{{id=105|
ggt(24,28)
///

4
}}}

{{{id=45|
ggt(60,98)
///

2
}}}

{{{id=82|
# Dieses Problem htten wir auch durch eine Primfaktorzerlegung lsen knnen:
factor(60), factor(98)
///

(2^2 * 3 * 5, 2 * 7^2)
}}}

{{{id=92|
# Auch von wirklich groen Zahlen erhalten wir damit den ggt praktisch sofort:
ggt(85654527926966124210591853187430807448638121850941303307300668824,\
74198273747190018602944778888905918139269573801883572233987659581026233117195017196736753610921233936437773901840568941087989543880516173581816792)
///

2568
}}}

{{{id=93|
# Dagegen erfordert es schon ca 1 Minute, um die Primfaktorzerlegung des ersten Parameters zu bestimmen,
# obwohl der von SAGE verwendete Algorithmus dem Stand der Wissenschaft entspricht.
factor(8565452792696612421059185187430807448638121850941303307300668824)
# Die Primfaktorzerlegung des 2. Parameters schaffen auch die besten gegenwrtigen Computer nicht.
///
}}}

{{{id=46|
# Testen Sie weitere Beispiele.
# Vergessen Sie dabei auch nicht auf die trivialen Flle.
///
}}}

{{{id=104|
# Die in SAGE eingebaute Funktion heit gcd (Greatest Common Divisor):
gcd(60,98)
///

2
}}}

{{{id=95|
# Wie spt ist es 1000 Stunden nach Mittag?
(12 + 1000) % 24
///

4
}}}

{{{id=100|
# Oder so:
Mod(12,24)+1000
///

4
}}}

{{{id=101|
# 12 ist eine ganze Zahl;
# Mod(12,24) dagegen im Restklassenring modulo 24.
parent(12), parent(Mod(12,24))
///

(Integer Ring, Ring of integers modulo 24)
}}}

{{{id=59|
5 ^ 9 % 12
///

5
}}}

{{{id=96|
# Ebenfalls kein Problem:
Mod(5,12)^7823905823904580238086487123647812638461283461289376481273647812364891273648971236481273647891236489712364897123648912734
///

1
}}}

{{{id=60|
# Die Dezimaldarstellung von
#5^7823905823904580238086487123647812638461283461289376481273647812364891273648971236481273647891236489712364897123648912734
# knnte dagegen niemals berechnet werden, schon allein weil sie viel zu gro ist.
///
}}}

{{{id=56|
xx = Mod(7854,5000)
///
}}}

{{{id=98|
xx^17
///

384
}}}

{{{id=99|
7854^17
///

1646437494948781993505446390535333779127444764487795205894969360384
}}}

{{{id=102|
[d for d in range(24) if gcd(d,24)==1]
///

[1, 5, 7, 11, 13, 17, 19, 23]
}}}

{{{id=103|
[d for d in range(25) if gcd(d,25)==1]
///

[1, 2, 3, 4, 6, 7, 8, 9, 11, 12, 13, 14, 16, 17, 18, 19, 21, 22, 23, 24]
}}}

{{{id=63|
euler_phi(24), euler_phi(25)
///

(8, 20)
}}}

{{{id=11|
# Diese Funktion berechnet das Vorzeichen:
def sgn(x):
  if x<0:
    return -1
  elif x>0:
    return 1
  else:
    return 0
///
}}}

{{{id=12|
sgn(0), sgn(5), sgn(-7)
///

(0, 1, -1)
}}}

{{{id=3|
# Nun knnen wir den erweiterten Euklidschen Algorithmus definieren:
def xggt(m,n):
  if n==0:
     return abs(m),sgn(m),0
  else:
    q,r = div(m,n)
    d,x,y = xggt(n,r)
    return d,y, x - y*q
///
}}}

{{{id=113|
# Zum Dividieren verwenden wir:
def div(m,n):
  q = round(m/n)
  # Dies ist eine manchmal gnstige Alternative zu
  # q = floor(m/n)  bzw.  q = m//n 
  # So erhlt man den betragsmig kleinsten Rest!
  r = m - q*n
  return q,r
///
}}}

{{{id=110|
div(19,5)
///

(4, -1)
}}}

{{{id=5|
xggt(0,-1)
///

(1, 0, -1)
}}}

{{{id=114|
xggt(24,38)
///

(2, 8, -5)
}}}

{{{id=34|
# Auch diese Funktion ist in SAGE bereits eingebaut und heit xgcd.
xgcd(96,156)
///

(12, -34, 21)
}}}

{{{id=112|
xgcd(1024,817)
///

(1, 446, -559)
}}}

{{{id=118|
xgcd(17,30)
///

(1, -7, 4)
}}}

{{{id=119|

///
}}}