Quel est le document bref qui permet à un technicien d'écrire un miniscript en SageMath avec le moindre effort ? Ce document doit rappeler les concepts de base avec les syntaxes et les prédéclarations nécessaires, tout en étant conçis, et avec une table de matière permettant une redirection rapide.
Pour l'nstallation de SageMath sur une distribution Linux de la famille Debian, voir Installation
Lancez le logiciel sage dans un terminal à l'aide de la commande : sage
Commande |
Retourne |
Description |
a=5 |
Affectation | |
a==5 |
True |
Teste |
| bool(a==5) | ||
2^5 |
32 |
Elevation à la puissane |
2**5 |
32 |
|
10//3 |
3 |
Division entière |
10%3 |
1 |
Reste de la division entière |
sqrt(2) |
sqrt(2) |
Racine carré |
sqrt(2.0) |
1.41421356237310 |
|
sin(pi/3) |
1/2*sqrt(3) |
Sinus de pi sur 3 |
exp(2) |
e^2 |
Exponentielle |
n(exp(2)) |
7.38905609893065 |
Développe en float |
exp(2).n() |
7.38905609893065 |
|
n(exp(2), digits=5) |
7.3891 |
Précision à 5 décimals |
exp(2).n(digits=5) |
7.3891 |
|
n==N==numerical_approx |
True |
Approximation numérique |
pi.n(digits=3) |
3.14 |
Précision à 3 décimals |
a=5; type(a) |
<class 'sage.rings.integer.Integer'> | Integer |
a=3/4; type(a) |
<class 'sage.rings.rational.Rational'> | Rational |
a=1.2; type(a) |
<class 'sage.rings.real_mpfr.RealLiteral'> | Float |
a=i/2; type(a) |
<class 'sage.rings.number_field.number_field_element_quadratic.NumberFieldElement_gaussian'> | Complex rational |
a=i+1.2; type(a) |
<class 'sage.rings.complex_mpfr.ComplexNumber'> | Complex float |
| i==I==complex(0,1) | True | Complex i |
a=exp(2); type(a) |
<class 'sage.symbolic.expression.Expression'> | Expression |
a='bonjour'; type(a) |
<class 'str'> |
String |
type("hello") |
<class 'str'> | |
type([1,2,3]) |
<class 'list'> | |
type((1,2,3)) |
<class 'tuple'> | |
type(int(7)) |
<class 'int'> | |
type(float(7)) |
<class 'float'> |
|
type(e.n(200)) |
<class 'sage.rings.real_mpfr.RealNumber'> |
| pi? | Documentation intégrée |
| sin? | |
| x=5/3; x? |
| def f(x,y=1): return x^2-y |
Définition de la fonction f | |
| f(2,0) | 4 | |
| f(2) | 3 | |
| f(x=2) | 3 | |
| f(y=0,x=2) | 4 |
| 1+\ 2+\ 3 |
6 | Passage à la ligne dans une instruction |
| for i in range(2,4): print(i) |
2 3 |
|
| for i in range(2,5): print('%6s %6s %6s' % (i,i^2,i^3)) |
2 4 8 3 9 27 4 16 64 |
v=[2,'bo',pi] |
||
v[0] |
2 |
|
v[1] |
'bo' |
|
v[2] |
pi |
|
len(v) |
3 |
Longueur de la liste v |
v.append(77) |
Ajoute un élément à la fin de la liste | |
del v[1] |
Suppime un élément de la liste | |
v |
[2,pi,77] |
|
| list(range(4)) | [0,1,2,3] | Crée la liste des 4 premiers entiers naturels |
| [i^2 for i in range(10)] | [0,1,4,9,16,25,36,49,64,81] | Exemple de création de liste |
| L[:4] |
[0, 1, 4, 9] |
|
| L[4:6] | [16, 25] |
|
| L[6:] | [36, 49, 64, 81] |
| m={2:pi, sin:e, 'bo':32} | Dictionnaire | |
| m[sin] | e | Lire l'entrée sin dans le dictionnaire m |
| m[cos]=56 | Modifit ou ajoute cos:56 dans le dictionnaire | |
| del m[sin] | Supprime l'entré sin dans le disctionnaire | |
| m | {2:pi,'bo':32,cos:56} | |
| m={2:4, 3:9, 4:16} | ||
| m.items() | dict_items([(2, 4), (3, 9), (4, 16)]) | |
| list(m.items()) | [(2, 4), (3, 9), (4, 16)] | |
| [x*y for x, y in m.items()] | [8, 27, 64] |
| solve(x^2-2*x==3, x) |
[x == 3, x == -1] | Résoudre une équation |
| var('x,a') solve(x^2-2*a*x==3, x) |
x == a - sqrt(a^2 + 3), x == a + sqrt(a^2 + 3)] | Résoudre une équation avec variables |
| var('x,y') eq1 = x*y==1 eq2 = x-y==1 solve([eq1,eq2], x,y) |
[\ [x == -1/2*sqrt(5) + 1/2, y == -1/2*sqrt(5) - 1/2],\ [x == 1/2*sqrt(5) + 1/2, y == 1/2*sqrt(5) - 1/2]\ ] |
Résoudre un système d'équation |
| var('x') diff(sin(x),x) |
cos(x) | Dérivée selon x |
| diff(sin(x),x,4) | sin(x) | Dérivé 4ième selon x |
| var ('x,y') f=sin(x*y) diff(f,x) |
y*cos(x*y) | Dérivée partielle |
| integral(4*sin(x)^2,x) | 2*x - sin(2*x) | Intégrale |
| f=(x^3-2*x+1)/(x^3+2*x^2-1) f.partial_fraction(x) |
-2/(x + 1) + 1 | Décomposition |
| save(A, 'A') | Sauve l'objet A dans le fichier "A.sobj" | |
| A=load('A') | Charge l'objet A à partir du fichier "A.sobj" | |
| save_session("s1") | Sauve la session en cours dans le fichier "s1.sobj" | |
| load_session("s1") | Charge la session à partir du fichier "s1.sobj" (Cela fusionne avec la session courante) |
|
| load("a1.sage") | Exécute le programme "a1.sage" | |
| attach("a1.sage") | Exécute le programme "a1.sage" à chaque modification de "a1.sage" |
| A={'a',1,5,1,1} | ||
| A | {1, 5, 'a'} | |
| B=set([1,sin,'b']) | ||
| A.intersection(B) | {1} | |
| 'a' in A | True | |
| 5 in B | False | |
| B.add(7) | ||
| B.remove(7) |
ZZ |
IntegerRing( ) | Les entiers relatifs |
QQ |
RationalField( ) | Les rationnels |
RR |
RealField(53) | Les réels avec 53 bits de précision |
CC |
ComplexField(53) | Les complexes avec 53 bits de précision |
| HH.<i,j,k> = QuaternionAlgebra(RealField(53),-1,-1) | Les quaternions avec 53 bits de précision | |
| G.<a> = GF(p^n,"a") | Le coprs fini de p^n éléments avec l'élément nommé "a" comme générateur. | |
| P.<a> = PolynomialRing(ZZ) | L'anneau des polynomes en "a", à coéfficient entier relatif. | |
| MatrixSpace(CC,2) | La classe des matrices carrées 2×2 de complexes | |
Par exemple exemples, le corps fini à 2^3 éléments avec "a" comme élément générateur :
| G.<a>=GF(2^3,"a") for x in G: print(x) |
| 0 a a^2 a + 1 a^2 + a a^2 + a + 1 a^2 + 1 1 |
Résolutions d'un système d'équation utilisant une matrices et un vecteur de polynômes en "x" à coefficient dans le corps fini à 2^3 éléments avec "a" comme élément générateur :
| G.<a> = GF(2^3,"a") P.<x> = PolynomialRing(G) M = MatrixSpace(P,2) A=M([[a,x],[x+1,a*x^2]]) V=vector(P,[x,a]) R=A.solve_right(V) A*R==V |
| True |
---- 22 février 2024 ----