Memento giac/xcas/qcas

Memento: Programmation (style Algorithmique)

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)

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 délimités avec des mots clefs. Les retours à la ligne ne changent pas la syntaxe.

Le programme retourne la dernière instruction. return/retourne sont facultatifs.

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; )

Pour les fonctions plus longue il faut regrouper les instructions, soit avec des {} comme dans la syntaxe classique, soit avec le mot clef fonction comme ci dessous:

fonction rfact(a,b,c) local d,r1,r2,x; d:=b^2-4*a*c; x:='x';//ou bien: assume(x,symbol) si d<0 alors retourne a*x^2+b*x+c; sinon r1:=(-b-sqrt(d))/(2*a); r2:=(-b+sqrt(d))/(2*a); retourne a*(x-r1)*(x-r2); fsi; ffonction;

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
- et , ou , non (synonymes: && , || , ! )
si condi alors instructions fsi
si condi alors instructions
sinon instructions fsi

Boucles principales

pour var de deb jusque fin pas p faire instructions fpour
On n'est pas obligé de préciser le pas s'il vaut 1.
- pour j de 0 jusque 9 faire afficher(j) fpour
  (on affiche les entiers de 0 à 9 par pas de 1.)
- pour j de 10 jusque 2 pas -3 faire print(j)fpour
  (on affiche les entiers de 10 à 2 par pas de -3. ie: 10,7,4)
tanque condi faire instructions ftanque
- j:=2; tantque j<10 faire j:=j*j ftantque

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

a

b

c

a:=0,1,2,3,4,5;
b:=(0,1),((2,3),4,5);
c:=seq(j,j=0..5);

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.

a1

a2

b

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