Affectation, égalité et arithmétique

A quelques exceptions mineures près, Sage utilise le langage de programmation Python, si bien que la plupart des ouvrages d’introduction à Python vous aideront à apprendre Sage.

Sage utilise = pour les affectations. Il utilise ==, <=, >=, < et > pour les comparaisons.

sage: a = 5
sage: a
5
sage: 2 == 2
True
sage: 2 == 3
False
sage: 2 < 3
True
sage: a == 5
True

>>> from sage.all import *
>>> a = Integer(5)
>>> a
5
>>> Integer(2) == Integer(2)
True
>>> Integer(2) == Integer(3)
False
>>> Integer(2) < Integer(3)
True
>>> a == Integer(5)
True

a = 5
a
2 == 2
2 == 3
2 < 3
a == 5

Sage fournit toutes les opérations mathématiques de base :

sage: 2**3    #  ** désigne l'exponentiation
8
sage: 2^3     #  ^ est un synonyme de ** (contrairement à Python)
8
sage: 10 % 3  #  pour des arguments entiers, % signifie mod, i.e., le reste dans la division euclidienne
1
sage: 10/4
5/2
sage: 10//4   #  pour des arguments entiers, // renvoie le quotient dans la division euclidienne
2
sage: 4 * (10 // 4) + 10 % 4 == 10
True
sage: 3^2*4 + 2%5
38

>>> from sage.all import *
>>> Integer(2)**Integer(3)    #  ** désigne l'exponentiation
8
>>> Integer(2)**Integer(3)     #  ^ est un synonyme de ** (contrairement à Python)
8
>>> Integer(10) % Integer(3)  #  pour des arguments entiers, % signifie mod, i.e., le reste dans la division euclidienne
1
>>> Integer(10)/Integer(4)
5/2
>>> Integer(10)//Integer(4)   #  pour des arguments entiers, // renvoie le quotient dans la division euclidienne
2
>>> Integer(4) * (Integer(10) // Integer(4)) + Integer(10) % Integer(4) == Integer(10)
True
>>> Integer(3)**Integer(2)*Integer(4) + Integer(2)%Integer(5)
38

2**3    #  ** désigne l'exponentiation
2^3     #  ^ est un synonyme de ** (contrairement à Python)
10 % 3  #  pour des arguments entiers, % signifie mod, i.e., le reste dans la division euclidienne
10/4
10//4   #  pour des arguments entiers, // renvoie le quotient dans la division euclidienne
4 * (10 // 4) + 10 % 4 == 10
3^2*4 + 2%5

Le calcul d’une expression telle que 3^2*4 + 2%5 dépend de l’ordre dans lequel les opérations sont effectuées ; ceci est expliqué dans l’annexe Priorité des opérateurs arithmétiques binaires Priorité des opérateurs arithmétiques binaires.

Sage fournit également un grand nombre de fonctions mathématiques usuelles ; en voici quelques exemples choisis :

sage: sqrt(3.4)
1.84390889145858
sage: sin(5.135)
-0.912021158525540
sage: sin(pi/3)
1/2*sqrt(3)

>>> from sage.all import *
>>> sqrt(RealNumber('3.4'))
1.84390889145858
>>> sin(RealNumber('5.135'))
-0.912021158525540
>>> sin(pi/Integer(3))
1/2*sqrt(3)

sqrt(3.4)
sin(5.135)
sin(pi/3)

Comme le montre le dernier de ces exemples, certaines expressions mathématiques renvoient des valeurs “exactes” plutôt que des approximations numériques. Pour obtenir une approximation numérique, on utilise au choix la fonction n ou la méthode n (chacun de ces noms possède le nom plus long numerical_approx, la fonction N est identique à n). Celles-ci acceptent, en argument optionnel, prec, qui indique le nombre de bits de précisions requis, et digits, qui indique le nombre de décimales demandées ; par défaut, il y a 53 bits de précision.

sage: exp(2)
e^2
sage: n(exp(2))
7.38905609893065
sage: sqrt(pi).numerical_approx()
1.77245385090552
sage: sin(10).n(digits=5)
-0.54402
sage: N(sin(10),digits=10)
-0.5440211109
sage: numerical_approx(pi, prec=200)
3.1415926535897932384626433832795028841971693993751058209749

>>> from sage.all import *
>>> exp(Integer(2))
e^2
>>> n(exp(Integer(2)))
7.38905609893065
>>> sqrt(pi).numerical_approx()
1.77245385090552
>>> sin(Integer(10)).n(digits=Integer(5))
-0.54402
>>> N(sin(Integer(10)),digits=Integer(10))
-0.5440211109
>>> numerical_approx(pi, prec=Integer(200))
3.1415926535897932384626433832795028841971693993751058209749

exp(2)
n(exp(2))
sqrt(pi).numerical_approx()
sin(10).n(digits=5)
N(sin(10),digits=10)
numerical_approx(pi, prec=200)

Python est doté d’un typage dynamique. Ainsi la valeur à laquelle fait référence une variable est toujours associée à un type donné, mais une variable donnée peut contenir des valeurs de plusieurs types Python au sein d’une même portée :

sage: a = 5   # a est un entier
sage: type(a)
<class 'sage.rings.integer.Integer'>
sage: a = 5/3  # a est maintenant un rationnel...
sage: type(a)
<class 'sage.rings.rational.Rational'>
sage: a = 'hello'  # ...et maintenant une chaîne
sage: type(a)
<... 'str'>

>>> from sage.all import *
>>> a = Integer(5)   # a est un entier
>>> type(a)
<class 'sage.rings.integer.Integer'>
>>> a = Integer(5)/Integer(3)  # a est maintenant un rationnel...
>>> type(a)
<class 'sage.rings.rational.Rational'>
>>> a = 'hello'  # ...et maintenant une chaîne
>>> type(a)
<... 'str'>

a = 5   # a est un entier
type(a)
a = 5/3  # a est maintenant un rationnel...
type(a)
a = 'hello'  # ...et maintenant une chaîne
type(a)

Le langage de programmation C, qui est statiquement typé, est bien différent : une fois déclarée de type int, une variable ne peut contenir que des int au sein de sa portée.