Memento: Programmation
Instructions élémentaires
On sépare les différentes instructions avec des ;
- Affectation usuelle d'une variable:
a:=1;
mais aussi: a,b,c:=1,2,3;
- Effectuer sans afficher avec
:;
a:=2^10000:;
-
purge(a,b)
(libère les variables a et b)
Mise à part l'affectation, la syntaxe par défaut de giac/xcas est celle du C.
Fonctions
- Dans une fonction les variables non explicitement déclarées locales grâce à l'instruction
local
sont globales.
- Les variables locales doivent être initialisées. Donc pour utiliser un symbole formel dans une fonction, soit on utilisera une variable globale qui n'a pas été affectée, soit on fera comme dans l'exemple
rfact
ci dessous.
- Les blocs d'instructions sont entre des
{ }
. On peut aller à la ligne dans un même bloc.
- Le programme retourne la dernière instruction.
return
est facultatif.
- N'utilisez pas
i
comme variable dans une bloucle car il est réservé pour le nombre complexe racine de -1.
f(x,y):=x+y;
( Synonyme: f:=(x,y) -> x+y;
)
rfact(a,b,c):={
local d,r1,r2,x;
d:=b^2-4*a*c;
x:='x';//ou bien: assume(x,symbol)
if(d<0){
return a*x^2+b*x+c;
}
else{
r1:=(-b-sqrt(d))/(2*a);
r2:=(-b+sqrt(d))/(2*a);
return a*(x-r1)*(x-r2);
}
}
Tests
- Comparaison entre x et y
-
x==y
, x!=y
( égaux, différents. Synonymes: x=y
, x<>y
)
-
x<y
, x<=y
, x>y
, x>=y
-
and
, or
, not
(synonymes: &&
, ||
, !
)
if( condi ){ instructions ;}
if( condi ){ instructions ;}
else{ instructions ;}
Boucles principales
NB: Les parenthèses et accolades dans for, while sont obligatoires.
for( ini; condi; incr ){ instructions ;}
for(j:=0; j<10;j++){ print(j);}
(on affiche les entiers de 0 à 9 par pas de 1)
for(j:=10; j>1;j:=j-3){ print(j);}
(on affiche les entiers strictements supérieurs à 1 à partir de 10 par pas de -3. ie: 10,7,4)
while(condi){ instructions ;}
j:=2;while(j<10){j:=j*j ;}
Séquences ( , , )
et Listes [ , , ]
Les séquences et listes sont numérotées à partir de 0 (sauf en mode maple). on accède aux éléments avec des crochets:
a[0]
est le premier élément de la liste ou séquence a
Les séquences ( , , )
sont des objets ordonnés séparés par des virgules. Les parenthèses sont simplifiées. Les opérations +,* ... n'ont rien à voir avec celles des vecteurs
Ci dessous, a
, b
et c
sont identiques
-
a:=0,1,2,3,4,5;
-
b:=(0,1),((2,3),4,5);
-
c:=seq(j,j=0..5);
Pour initialiser une séquence vide on utilise le mot clef NULL
-
d:=NULL;d:=d,1;d:=d,2;
Les listes [ , , ]
sont des objets entre crochets séparés par des virgules. Les objets sont ordonnés et aucun crochet n'est simplifié. On les utilise pour les vecteurs et les matrices.
Ci dessous, a1
et a2
sont identiques et sont des vecteurs. Ils diffèrent de b
qui est une matrice à 2 lignes 3 colonnes.
-
a1:=[0,1,2,3,4,5];
-
a2:=[seq(j,j=0..5)];
-
b:=[[0,1,2],[3,4,5]];
-
a1+2*a2; ker(b);
-
op(a1)
permet d'enlever les crochets externes pour passer d'une liste à une séquence. -
-
[seq(j*j, j=a1)];
(on crée la liste des carrés des éléments de la liste a1
)
-
a3:=newList(10^7);
(permet de créer rapidement une liste de zéros)
Notions avancées
- L'affectation
:=
est une affectation par valeurs. Elle recopie les données, même avec des listes ou matrices.
Pour des raisons d'efficacité, on dispose aussi d'une affectation par référence:
=<
est l'affectation par référence:
Ex: a:=[1,2,3];b=<a;b[1]=<0;
maintenant a
vaut aussi [1,0,3]
. En revanche, si l'on avait fait b[1]:=0
cela aurait crée une nouvelle liste b
par recopie et a
n'aurait pas été modifié
-
#
permet de créer une variable à partir d'une chaine de caractères:
Ex1: "a1"
est une chaine de caractères et #"a1"
est une variable.
Ex2: S:=sum(#("a"+j),j=0..9);normal(S^5);
développe (a0+a1+...+a9)^5.
- Les syntaxes de programmation de type maple:
Ces syntaxes sont déconseillées si l'on n'est pas en mode maple. Par exemple en mode xcas dans le cas du while, condi n'a pas le droit d'être entre parenthèses.
if condi then instrutions fi
for j from 1 to 5 do instruc od
while condi do instrutions od