Les différentes instructions selon le mode choisi

# Chapitre 2 Les différentes instructions selon le mode choisi

Xcas propose un mode de compatibilité avec Maple, MuPAD et la TI89/92 :
pour cela, il suffit de le spécifier dans Prog style du menu de configuration du cas (bouton Config ou menu Cfg->Configuration du CAS) ou avec le menu Cfg->Mode (syntax). On peut choisir, en cliquant sur la flèche située à coté de Prog style : Xcas ou Maple ou MuPAD ou TI89/92.
On a aussi la possibilité d’importer une session Maple ou une archive TI89/92 en choisissant Importer du menu Fich, ou importer dans un niveau éditeur de programmes un fichier écrit en syntaxe Maple, Mupad ou TI89/92 par le menu Prog->Inserer.

On présente ici le mode Xcas qui est proche de la syntaxe C. On a aussi la possibilité d’avoir toutes les instructions en français de façon à être proche du langage Algorithmique.

## 2.1 Les commentaires

### 2.1.1 Traduction Algorithmique

Il faut prendre l’habitude de commenter les programmes. En algorithmique un commentaire commence par // et se termine par un passage à la ligne.
Exemple :
//ceci est un commentaire

### 2.1.2 Traduction Xcas

Avec Xcas un commentaire commence par // et se termine par un passage à la ligne.
Exemple :
//ceci est un commentaire

### 2.1.3 Traduction MapleV

Un commentaire commence par # et se termine par un passage à la ligne.
Exemple :
# ceci est un commentaire

### 2.1.4 Traduction MuPAD

Un commentaire est entouré de deux # ou commence par /* et se termine par */.
Exemple :
# ceci est un commentaire #
/* ceci est un commentaire */

### 2.1.5 Traduction TI89 92

Le commentaire commence par © (F2 9) et se termine par un passage à la ligne.
Exemple :
© ceci est un commentaire

## 2.2 Les variables

Voir aussi 1.5.3

### 2.2.1 Leurs noms

Ce sont les endroits où l’on peut stocker des valeurs, des nombres, des expressions.
Avec Xcas les noms des variables ou des fonctions commencent par une lettre et sont formés par des lettres ou des chiffres.
Par exemple :
azertyuiop:=2 met la valeur 2 dans la variable azertyuiop
azertyuio?:=1 renvoie un message d’erreur car azertyuio? contient ? qui n’est pas une lettre.
Étant donné que Xcas fait du calcul formel il faut quelquefois purger une variable var pour qu’elle redevienne formelle avec la commande purge(var) ou encore utiliser la commande assume(var,symbol) pour que var redevienne formelle.
On tape :
x:=2; x contient 2 et n’est pas formelle.
On tape :
purge(x) : cela renvoie la valeur x si x est affecté et x redevient une variable formelle, et, si x n’est pas affecté purge(x) renvoie "x not assigned".
ou bien, on tape :
assume(x,symbol)
et cela renvoie dans tous les cas DOM_SYMBOLIC.
Avec MapleV et MuPAD, un nom doit commencer par une lettre, ne pas contenir d’espace, de symbole opératoire (+, -, ...) et ne pas être un mot réservé comme D, I, ... pour MapleV.
On peut utiliser des noms ayant plus de 8 caractères.
Pour TI89/92 un nom doit commencer par une lettre, ne pas contenir d’espace, de symbole opératoire (+, -, ...), ne pas être un mot réservé et ne doit pas avoir plus de 8 caractères.

### 2.2.2 Notion de variables locales

Pour Xcas il faut définir les variables locales en début de programme en écrivant :
local a,b,c;
Attention
Dans un programme toutes les variables sont des variables qui sont initialisées par défaut à 0.
Mais ces variables peuvent être initialisées au moment de leur déclaration avec local, par exemple : local a,(b:=1),c;
Remarque
Xcas accepte qu’il y ait plusieurs local dans un programme, par exemple :

    essailoc(n):={
    local s:=0;
    local j;
    for (j:=1;j<=n;j++){
    s:=s+1/j;
    }
    return s;
    }

Pour MapleV, il faut définir les variables locales en début de programme en écrivant :
local a,b
Pour MuPAD, il faut définir les variables locales en début de programme en écrivant :
local a,b
Pour la TI89/92 il faut définir les variables locales en début de programme en écrivant :
:local a,b

## 2.3 Les paramètres

Quand on écrit une fonction il est possible d’utiliser des paramètres.
Par exemple si A et B sont les paramètres de la fonction PGCD on écrit :
PGCD(A,B)
Ces paramètres se comportent comme des variables locales, la seule différence est qu’ils sont initialisés lors de l’appel de la fonction. L’exécution se fait en demandant par exemple : PGCD(15,75)

### 2.3.1 Traduction Xcas

Avec Xcas on peut définir une fonction :

- en lui donnant un nom :
  on met alors le nom de la fonction puis, entre parenthèses et séparés par une virgule, le nom des paramètres, par exemple :
  addition(a,b):=a+b;
  L’exécution se fera alors en tapant : addition(2,5).
- en mettant le nom des paramètres entre parenthèses puis -> puis entre des accolades le corps de la fonction, par exemple :
  (a,b)->a+b;.
  cette façon d’écrire une fonction peut être utile quand on doit mettre une fonction comme argument d’une commande par exemple :
  makelist((j)->j`^`2+1,1..3) ou
  makelist((j)->j`^`2+1,1..9,2).
  Remarque
  Le langage de Xcas est fonctionnel puisque on peut passer des programmes ou des fonctions en paramètre.

Autre exemple :

    pgcd(a,b):={
      local r;
      while (b!=0){
      r:=irem(a,b);
      a:=b;
      b:=r;
      }
      return(a);
    };

ou encore :

    pgcd:=(a,b)-> {
      local r;
      while (b!=0){
      r:=irem(a,b);
      a:=b;
      b:=r;
      }
      return(a);
    };

L’exécution se fera alors en tapant : pgcd(15,75).

### 2.3.2 Traduction MapleV

PGCD:=proc(A,B)
....
....
end:
Attention
Ces paramètres NE se comportent PAS comme des variables locales : ils sont initialisés lors de l’appel de la fonction mais ne peuvent pas être changés au cours de la procédure. L’exécution se fait en demandant par exemple : PGCD(15,75)

### 2.3.3 Traduction MuPAD

PGCD:=proc(A,B)
begin
....
end_proc:
Ces paramètres se comportent comme des variables locales, la seule différence est qu’ils sont initialisés lors de l’appel de la fonction. L’exécution se fait en demandant par exemple : PGCD(15,75)

### 2.3.4 Traduction TI89/92

Pour les TI 89/92 on met le nom des paramètres dans le nom de la fonction par exemple :
:addition(a,b)
:pgcd(a,b)

## 2.4 Les Entrées

### 2.4.1 Traduction Algorithmique

Pour que l’utilisateur puisse entrer une valeur dans la variable A au cours de l’exécution d’un programme, on écrira, en algorithmique :
saisir A
Et pour entrer des valeurs dans A et B on écrira :
saisir A,B

### 2.4.2 Traduction Xcas

On écrit :
input(A);
ou
saisir(A);

### 2.4.3 Traduction MapleV

On peut utiliser :
A := readline() ; ou
A:=readstat(’A=?’);

### 2.4.4 Traduction MuPAD

input("A=",A)
input("A=",A,"B=",B )

### 2.4.5 Traduction TI89/92

:Prompt A
:Prompt A,B
ou encore :
:Input ‘‘A=’’,A

## 2.5 Les Sorties

### 2.5.1 Traduction Algorithmique

En algorithmique on écrit :
afficher A
ou si on veut connaitre le nom de la variable qui est affichée
afficher "A=",A

### 2.5.2 Traduction Xcas

On écrit :
A:=2;B:=3;
print(A);
ou
afficher(A);
On obtient, en bleu dans la zone intermédaire 2,3
print(A,B);
ou
afficher(A,B);
On obtient, en bleu dans la zone intermédaire 2,3
ou encore
print("A=",A);
ou
afficher("A=",A); On obtient, en bleu dans la zone intermédaire "A=",2
ou encore
print("A="+A);
ou
afficher("A="+A); On obtient, en bleu dans la zone intermédaire A=2
print("A=",A,"B=",B);
ou
afficher("A=",A,"B=",B); On obtient, en bleu dans la zone intermédaire "A=",2,"B=",3
print ou afficher permet de réaliser des affichages en cours de programmme.
Ces affichages s’écriront alors en bleu dans la zone intermédaire .
On tape par exemple dans un niveau éditeur de programmes (que l’on ouvre avec Alt+p) :

    carres(n):={
    local j;
    for (j:=1;j<n+1;j++) {
    print(j^2);
    }
    return n^2;
    }

Puis on complile ce programme en cliquant sur OK.
On tape ensuite dans une ligne de commandes : carres(5)
On obtient :
1
4
9
16
25
écrit en bleu dans la zone intermédaire
et
25
le résultat écrit en noir dans la zone des réponses.

### 2.5.3 Traduction MapleV

print(‘A=‘.A):
On préférera ‘ (accent grave) à " (guillemet), comme délimiteur de chaîne, car le premier n’est pas affiché, alors que le deuxième l’est.

### 2.5.4 Traduction MuPAD

print("A=",A)
Il fait savoir que lorsqu’une procèdure est appelée, la suite d’instructions entre begin et end_proc est exécutée, et le résultat est égal au résultat de la dernière évaluation.

### 2.5.5 Traduction TI89/92

:Disp "A=",A
:ClrIO efface l’écran.
:ClrHome efface l’écran pour la TI 83+.
:Pause arrête le programme (on appuie sur ENTER pour reprendre l’exécution).

## 2.6 La séquence d’instructions ou action ou bloc

Une action ou bloc est une séquence d’une ou plusieurs instructions.
En langage algorithmique, on utilisera l’espace ou le passage à la ligne pour terminer une instruction.

### 2.6.1 Traduction Xcas

Avec Xcas la séquence d’instructions est parenthèsées par { }. La séquence d’instructions est appelée un bloc ou une action et ; termine chaque instruction. Seule la dernière instruction d’un programme génére la réponse. Si on veut des sorties intermédiaires il faudra le faire à l’aide de la commade print ou afficher et ces sorties se feront alors avant la réponse, dans la zone intermédaire en écriture bleue.
Par exemple si on écrit dans un niveau éditeur de programmes (que l’on ouvre avec Alt+p) :

    pgcd(a,b):={
      local r;
      while (b!=0){
      r:=irem(a,b);
      print(r);
      a:=b;
      b:=r;
      }
      return(a);
    };

On compile en appuyant sur OK et on tape :
pgcd(15,25)
On obtient :
5 comme réponse et :
r:15
r:10
r:5
r:0
s’écrivent en bleu dans un écran appelé zone intermédaire qui se met avant la réponse.
Si la dernière instruction est géométrique, elle génère une sortie dans unécran géométrique. Les instructions print ou afficher se feront alors en bleu dans la zone intermédaire située avant l’écran géométrique où se trouve la réponse. Mais les instructions géométriques intermédiaires se feront dans l’écran DispG qui est un écran géométrique que l’on obtient avec la commande DispG() ou avec le menu Cfg->Montrer->DispG.
Par exemple si on écrit dans un niveau éditeur de programmes (que l’on ouvre avec Alt+p) :

    pgcdg(a,b):={
      local r;
      while (b!=0){
      r:=irem(a,b);
      print(r);
      point(a+i*b);
      segment(a+i*b,b+i*r);
      a:=b;
      b:=r;
      }
      return(point(a+i*b));
    };

On compile en appuyant sur OK et on tape :
A:=pgcdg(15,25)
On obtient :
Un écran de graphique s’ouvre avec le point A de coordonnées (0;5) et :
r:15
r:10
r:5
r:0
s’écrivent en bleu dans un écran appelé zone intermédaire qui se met avant l’écran de géométrie.
On ouvre l’écran géométrique DispG (avec la commande DispG() ou avec le menu Cfg->Montrer->DispG) Sur l’écran DispG il y a les différents segments et les points (sans la lettre A) Pour tout voir, vous devez soit appuyer sur le bouton auto de l’écran DispG, soit changer la configuration avec le bouton cfg de l’écran DispG.

### 2.6.2 Traduction MapleV

: ou ; indique la fin d’une instruction.
Une instruction terminée par point-virgule ( ; ) génére une sortie et celle terminée par deux points ( : ) n’en génére pas.

### 2.6.3 Traduction MuPAD

Le : ou ; est un séparateur d’ instructions.
Le ; génére une sortie alors que le : n’en génére pas.

### 2.6.4 Traduction TI89/92

: indique la fin d’une instruction. Il faut noter qu’à chaque passage à la ligne le : est mis automatiquement.

## 2.7 L’instruction d’affectation

L’affectation est utilisée pour stocker une valeur ou une expression dans une variable.

### 2.7.1 Traduction Algorithmique

En algorithmique on écrira par exemple :
3=>A
2*A=>B
pour stocker 3 dans A, 2*A (c’est à dire 6) dans B

### 2.7.2 Traduction Xcas

Avec Xcas on écrira :
a:=3;
b:=2*a;
ou encore
3=>a;
2*a=>b;
pour stocker 3 dans a, 2*a (c’est à dire 6) dans b

En tapant le nom d’une variable dans Xcas on peut voir le contenu de cette variable. Si on tape le nom d’une fonction, on verra la définition de la fonction.
Attention
On peut écrire :
(a,b):=(1,2) ou (a,b):=[1,2] ou [a,b]:=[1,2] ou [a,b]:=(1,2) qui est équivalent à a:=1;b:=2
c’est à dire ici à a:=1;b:=2 mais
a:=1;b:=2; (a,b):=(a+b,a-b) est équivalent à c:=a;a:=a+b;b:=c-b donc ici à a:=3;b:=-1
Donc si on tape :
(a,b):=(1,2);(a,b):=(a+b,a-b)
On obtient :
3 dans a et -1 dans b
Donc si on tape :
a:=1;(a,b):=(2,a) On obtient :
2 dans a et 1 dans b
mais purge(a);(a,b):=(2,a)
On obtient :
2 dans a et 2 dans b
Donc méfiance ....et utiliser (a,b):=(b,a) qu’avec prudence !

### 2.7.3 Traduction Maple

Avec Maple on écrit :
b:=2*a pour stocker 2*a dans b.

### 2.7.4 Traduction MuPAD

Avec MuPAD on écrit :
b:=2*a pour stocker 2*a dans b.

### 2.7.5 Traduction TI89/92

On écrit 2*A=>B pour stocker 2*A dans B.

## 2.8 L’instruction d’affectation par référence

L’affectation := est utilisée pour stocker une valeur ou une expression dans une variable. Mais lorsque Xcas réalise cette affectation il effectue une recopie de la valeur dans la variable ce qui peut être long lorsqu’il s’agit d’une liste de grande taille. C’est pourquoi quand la variable contient une liste, avec Xcas, il faut utiliser l’opérateur infixé =< qui stocke par référence le deuxième argument dans la variable donnée en premier argument.
On tape par exemple :
L=<makelist(x->x`^`2,0,10000):; puis, par exemple :
for(j:=0;j<=1000;j++) L[10*j]=<0

## 2.9 L’instruction pour faire des hypothèses sur une variable formelle

L’instruction assume ou supposons permet de faire une hypothèse sur une variable formelle par exemple d’attribuer une valeur à une variable pour faire une figure, tout en laissant cette variable reste formelle lorsqu’on l’utilise pour faire des calculs ou encore de supposer que n est une v ariable entère ce qui permet de simplifier certaines expressions comme cos(n*pi)....

### 2.9.1 Traduction Algorithmique

En algorithmique on écrira par exemple :
supposons(n,entier)
supposons(a>2)
supposons(a=2)

### 2.9.2 Traduction Xcas

Avec Xcas on écrira :
assume(n,integer); ou supposons(n,integer); puis par exemple cos(n*pi) et on obtient (-1)`^`n
assume(a>2);
On peut faire plusieurs hypothèses sur une variable avec assume et additionally par exemple, pour dire que n est un entier plus grand que 3, on tape :
assume(n,integer);additionally(n>3); Il faut noter que si on écrit dans l’écran de géométrie:
assume(a=2); ou supposons(a=2);
ou encore
assume(a:=2); ou supposons(a:=2);
cela a pour effet de mettre en haut et à droite un curseur noté a. En effet, cela veut dire que l’on va faire une figure de géométrie en donnant à a la valeur 2, mais que les différents calculs se feront avec a formelle. Bien sur la valeur donnée à a pourra être modifièe à l’aide du curseur et ainsi modifier la figure selon les valeurs de a.

### 2.9.3 Traduction Maple

Avec Maple on écrit :
assume(n,integer);
assume(a>2);

### 2.9.4 Traduction MuPAD

Avec MuPAD on écrit :
assume(n,integer);
assume(a>2);

### 2.9.5 Traduction TI89/92

Il n’y a pas d’hypothèse en mode TI.

## 2.10 L’instruction pour connaitre les contraintes d’une variable

### 2.10.1 Traduction Algorithmique

En algorithmique on écrira par exemple :
domaine(A)

### 2.10.2 Traduction Xcas

Avec Xcas on écrira :
about(a) ou domaine(a)
assume(a) ou supposons(a)

### 2.10.3 Traduction Maple

Avec Maple on écrit :
about(a) ou domaine(a)
assume(a)

### 2.10.4 Traduction MuPAD

Avec MuPAD on écrit :
getprop(a)

### 2.10.5 Traduction TI89/92

Il n’y a pas d’hypothèse en mode TI.

## 2.11 Les instructions conditionnelles

### 2.11.1 Traduction Algorithmique

si condition alors action fsi
si condition alors action1 sinon action2 fsi
Exemple :
si A = 10 ou A < B alors B-A=>B sinon A-B=>A fsi

### 2.11.2 Traduction Xcas

if (condition) {action;}
ou encore
if (condition) then action; end
ou encore
si (condition) alors action; fsi
et
if (condition) {
action1;
} else {
action2;
}
ou encore
if (condition) then
action1;
else action2;
end
ou encore
si (condition) alors
action1;
sinon action2;
fsi
Exemples
if ((a==10) or (a<b)) {b:=b-a;} else {a:=a-b;}

    essaiif(a,b):={
      if ((a==10) or (a<b)) {
        b:=b-a;
      } else {
        a:=a-b;
      }
      return([a,b]);
    };

    essaisi(a,b):={
      si ((a==10) or (a<b))
       alors
        b:=b-a;
       sinon
        a:=a-b;
      fsi;
      return([a,b]);
    };

    idivsi(a,b):={
      local (q:=0),(r:=a);
      if (b!=0){
        q:=iquo(a,b);
        r:=irem(a,b);
      }
      return([q,r]);
    };

    idivsi(a,b):={
      local (q:=0),(r:=a);
      si (b!=0)
       alors
        q:=iquo(a,b);
        r:=irem(a,b);
      fsi
      return([q,r]);
    };

Avec Xcas, lorsqu’il y a plusieurs if...else if... à la suite on peut aussi utiliser un elif qui est une écriture condensée de else if et se traduit par :
if (condition1) then
action1;
elif (condition2) then
action2;
elif (condition3) then
action3;
end
ou bien if (condition) then
action1;
elif (condition) then
action2;
elif (condition) then
action3;
else action4;
end
Exemples

    s(a):={
    local r;
    if a>=10 then
    r:=5;
    elif  a>=8 then
    r:=4;
    elif  a>=6 then
    r:=3;
    elif  a>=4 then
    r:=2
    else
    r:=1;
    end;
    return r;
    }

Avec Xcas, on peut aussi utiliser un "case" lorsque les différentes instructions à effectuer correspondantes à la valeur d’une expression qui doit être une valeur entière et qui se traduit par :

    switch (<nom_de_variable>){
    case val_de_la_variable : {
    .....
    break;
    }
    case val_de_la_variable : {
    .....
    break;
    } default : {
    ...
    }
    }

Exemple :

    s(a):={
    local r;
    switch(a) {
    case 1 :{
    r:=1;
    break;
    }
    case 2 :{
    r:=-1;
    break;
    }
    default :{
    r:=0;
    }
    }
    return r;
    }

### 2.11.3 Traduction MapleV

si ... alors
if <condition> then <action> fi;
si ... alors ... sinon ...
if <condition> then <action1> else <action2> fi;
Le schéma général à n cas :
if <condition_1> then <action_1>
elif <condition_2> then <action_2>
... elif <condition_n-1> then <action_n-1> else <action_n> fi ;

### 2.11.4 Traduction MuPAD

if <condition> then <action> end_if
if <condition> then <action1> else <action2> end_if
Exemple :
if a = 10 or A < B then b:=b-a else a:=a-b end_if
Lorsque il y a plusiuers if else à la suite on écrit elif au lieu de else if.

### 2.11.5 Traduction TI89/92

Si ..alors
:If condition Then : action : EndIf
Si..alors sinon
:If condition Then : action1 : Else : action2: EndIf
Exemple :
:If A = 10 or A < B Then : B-A=>B : Else : A-B=>A : EndIf

## 2.12 Les instructions "Pour"

On utilise l’instruction "pour" lorsqu’on connait le nombre de fois que l’on doit effectuer les instructions ("pour" peut aussi servir à faire des boucles complètement génériques).

### 2.12.1 Traduction Algorithmique

pour I de A jusque B faire action fpour
pour I de A jusque B (pas P) faire action fpour

### 2.12.2 Traduction Xcas

Attention si vous avez coché pas de test de i dans la configuration generale, on ne doit pas employer la variable i car i represente le nombre complexe de module 1 et d’argument π/2.
for (j:=1;j<=b;j:=j+1) {action;} ou encore
for (j:=1;j<=b;j:=j++) {action;}
ou encore
pour j de 1 jusque b faire action; fpour
et
for (j:=1;j<=b;j:=j+p) {action;}
ou encore
pour j de 1 jusque b pas p faire action; fpour

Exemples

    essaifor(a,b):={
      local s:=0;
      for (j:=a;j<b+1;j++){
        s:=s+1/j^2;
      }
      return(s);
    };

    essaiford(a,b):={
      local s:=0;
      for (j:=b;j>a-1;j--){
        s:=s+1/j^2;
      }
      return(s);
    };

### 2.12.3 Traduction MapleV

Voici la syntaxe exacte :
for <nom> from <expr> by <expr> to <expr>
do <action> od ;
Par exemple
for i from 1 to n do <action:> od
for i from 1 by p to n do <action:> od

### 2.12.4 Traduction MuPAD

for i from a to b do <action> end_for
for i from b downto a do <action> end_for
for i from a to b step p do <action> end_for
Vous pouvez aussi ouvrir le menu MuPAD sous menu Shapes et séléctionner for.

### 2.12.5 Traduction TI89 92

:For I,A,B : action : EndFor
:For I,A,B,P : action : EndFor

## 2.13 L’instruction "Tant que"

On effectue les instructions tant que la condition est vraie :
on teste la condition si elle est fausse on s’arrête (arret= (condition =fausse)) sinon on effectue les instructions etc ... On arrête la boucle quand la condition devient fausse c’est à dire :
tantque (non arret) on effectue les instructions.

### 2.13.1 Traduction Algorithmique

tantque condition faire
action
ftantque

### 2.13.2 Traduction Xcas

while (condition) {
action;
}
ou encore
tantque (condition) faire
action;
ftantque
Exemple

    essaiwhile(a,b):={
      while ((a==10) or (a<b)) {
        b:=b-a;
      }
      return([a,b]);
    };

### 2.13.3 Traduction MapleV

while <condition> do <action> od:

### 2.13.4 Traduction MuPAD

while <condition> do <action> end_while
Vous pouvez aussi ouvrir le menu MuPAD sous menu Shapes et séléctionner while.

### 2.13.5 Traduction TI89/92

:While condition :action :EndWhile

## 2.14 L’instruction "repeter"

On répéte les instructions jusqu’à ce que la condition devienne vraie. On fait les instructions (les instructions se font donc au moins une fois) puis on teste la condition si elle est vraie on s’arrête (arret= (condition=vraie)) sinon on effectue les instructions etc ...On arrête la boucle quand la condition devient vraie.

### 2.14.1 Traduction Algorithmique

repeter
action
jusqua condition

### 2.14.2 Traduction Xcas

repeat
action
until (condition)
ou encore
repeter
action
jusqua (condition)
L’instruction "repeter" est traduite en :
while (true){
action;
if (condition) break;
}
cette traduction reste invisible à l’utilisateur (tant qu’il n’exécute pas son programme au débugueur).

### 2.14.3 Traduction MapleV

Pas de schéma "repeter" en MapleV, on utilise une boucle infinie et un break
do action if condition then break; fi; od;

### 2.14.4 Traduction MuPAD

repeat
action
until condition
end_repeat

### 2.14.5 Traduction TI89/92

Pas de schéma "repeter" chez TI, on utilise une boucle infinie et un Exit
:Loop :action :If (condition) :Exit :Endloop

## 2.15 Les conditions ou expressions booléennes

Une condition est une fonction qui a comme valeur un booléen, à savoir elle est soit vraie soit fausse.

### 2.15.1 Les opérateurs relationnels

#### Traduction Algorithmique

Pour exprimer une condition simple on utilise en algorithmique les opérateurs :
= > < ≤ ≥ ≠

#### Traduction Xcas

Ces opérateurs se traduisent pour Xcas par :

    ==  >  <  <=  >=  !=

Attention pour Xcas l’égalité se traduit comme en langage C par : ==

#### Traduction MapleV, MuPAD, TI89/92

Ces opérateurs se traduisent pour MapleV, MuPAD et TI89/92 par :

    =  >  <  <=  >=  <>

### 2.15.2 Les opérateurs logiques

Pour traduire des conditions complexes, on utilise en algorithmique, les opérateurs logiques :
ou et non
Pour Xcas, ces opérateurs se traduisent par :
or and not ou encore par ∥ && !
Pour MapleV, MuPAD et TI89/92, ces opérateurs se traduisent par :
or and not

## 2.16 Les fonctions

Dans une fonction on ne fait pas de saisie de données : on utilise des paramètres qui seront initialisés lors de l’appel.
Les entrées se font donc par passage de paramètres.
Dans une fonction on veut pouvoir réutiliser le résultat :
en algorithmique, c’est la commande retourne qui renvoie la valeur de la fonction.
Si la fonction est utilisée seule, sa valeur sera affichée et si la fonction est utilisée dans une expression sa valeur sera utilisée pour calculer cette expression.

### 2.16.1 Traduction Algorithmique

On écrit par exemple en algorithmique :

    fonction addition(A,B)
    retourne A+B
    ffonction

Cela signifie que :
- Si on fait exécuter la fonction, ce qui se trouve juste après retourne sera la valeur de la fonction, mais les instructions qui suivent retourne seront ignorées (retourne fait sortir immédiatement de la fonction).
- On peut utiliser la fonction dans une expression ou directement dans la ligne de commande et, dans ce cas, sa valeur sera affichée.

### 2.16.2 Traduction Xcas

Xcas utilise return ou retourne.

    addition(a,b):={
      return(a+b);
    }

Remarques :

- return n’est pas obligatoire on peut aussi écrire :

      addition(a,b):=a+b;

- return fait sortir immédiatement de la fonction. Pour définir le minimum de 2 nombres on écrit soit avec 1 instruction

      mini1(a,b):={
      si(a>b) alors
       return b
      sinon
       return a;
      fsi
      }

  soit avec 2 instructions

      mini2(a,b):={
      si(a>b) alors
       return b;
      fsi
      return a;
      }

### 2.16.3 Traduction MapleV

retourne se traduit par RETURN

    addition:= proc(a,b)
    RETURN(a+b);
    end:

Remarque
RETURN fait sortir immédiatement de la fonction.

### 2.16.4 Traduction MuPAD

retourne se traduit MuPAD par return :

    addition:=proc(a,b)
    begin
    return(a+b)
    end_proc;

Remarque
return fait sortir immédiatement de la fonction.

### 2.16.5 Traduction TI89 92

    :addition(a,b)
    :Func
    :Return a+b
    :EndFunc

Remarque
Return fait sortir immédiatement de la fonction.

## 2.17 Les listes

### 2.17.1 Traduction Algorithmique

On utilise les { } pour délimiter une liste.
Attention!!!
En algorithmique, on a choisi cette notation car c’est celle qui est employée par les calculatrices...à ne pas confondre avec la notion d’ensemble en mathématiques : dans un ensemble l’ordre des éléments n’a pas d’importance mais dans une liste l’ordre est important...
Par exemple {} désigne la liste vide et {1, 2, 3} est une liste de 3 éléments.
concat sera utilisé pour concaténer 2 listes ou une liste et un élément ou un élément et une liste :
{1, 2, 3}=>TAB
concat(TAB,4)=>TAB (maintenant TAB désigne {1, 2, 3, 4}
TAB[2] désigne le deuxième élément de TAB ici 2.

### 2.17.2 Traduction Xcas

Avec Xcas il existe différentes notions : la liste ou le vecteur, la séquence et l’ensemble.

- Les listes et les vecteurs
  Une liste ou un vecteur est délimité par [ ] et les éléments situés à l’intérieur des crochets sont séparés par des virgules.
- Les séquences
  Une séquence n’a pas de délimiteurs, les éléments sont séparés par des virgules, mais on doit parfois parenthèser par ( ) (on écrit 1,2,3,4 ou (1,2,3,4) ou encore seq[1,2,3]).
- Les ensembles
  Un ensemble est délimité par %{ %} et les éléments situés à l’intérieur des délimiteurs sont séparés par des virgules (on écrit %{ 1,2,3,4%} ou encore set[1,2,3,4]).

#### Les fonctions pour les listes

La liste vide est désignée par [ ] et la séquence vide par NULL.
La commande makelist permet de fabriquer une liste à partir d’une fonction f. Les paramètres sont : la fonction, l’intervalle de variation de l’argument de f et le pas de son incrémentation.
On tape :
f(x):=x2
l:=makelist(f,2,10,3) ou encore
l:=makelist(x->x2,2,10,3) ou encore
l:=makelist(x->x2,2..10,3) ou encore
l:=makelist(sq,2,10,3)
On obtient l= [4,25,64]
Pour avoir une liste constante on peut taper par exemple :
l:=makelist(3,1..5) on obtient l= [3,3,3,3,3]]
On peut écrire l:=[1,2,3].
Attention Les éléments sont indicés à partir de zéro (contrairement à Maple ou MuPAD qui commencent les indices à 1):
dans l’exemple l[0] vaut 1.
Si on tape ensuite :
l[0]:=4 : après cette instruction l sera la liste [4,2,3].
La commande append(l,elem) permet de mettre à la fin d’une liste l, un élément (ou une liste) elem.
La commande prepend(l,elem) permet de mettre au début d’une liste l, un élément (ou une liste) elem.
La commande tail(l) renvoie la liste l privée de son premier élément et,
la commande head(l) renvoie le premier élément de la liste.
La commande concat permet de concaténer deux listes ou une liste et un élément.
La commande augment permet de concaténer deux listes.
La commande size ou nops renvoie la longueur d’une liste ou d’une séquence.

#### Les fonctions pour les séquences

La commande op transforme une liste en une séquence.
On a la relation :
si l est une liste op(l) est une séquence.
Exemple
l:=[1,2,3]
s:=op(l) (s est la séquence 1,2,3),
a:=[s] (a est la liste l égale à [1,2,3]),
Pour concaténer deux séquences il suffit d’écrire :
s1:=(1,2,3)
s:=(s1,4,5)
ou encore
s:=s1,4,5 car la virgule (,) est prioritaire par rapport à l’affectation (:=).
La commande seq permet de fabriquer une séquence à partir d’une expression. Les paramètres sont : l’expression, la variable=l’intervalle de variation (le pas d’incrémentation de la variable est toujours 1).
On tape :
seq(j`^`2,j=1..4)
On obtient ;
(1,4,9,16)
On peut aussi utiliser $ qui est une fonction infixée.
On tape :
(j`^`2) $ (j=1..4)
On obtient ;
(1,4,9,16)

#### Les fonctions pour les ensembles

Soit A:=set[1,2,3,4]; B:=set[3,4,4,6]; union(A,B) désigne l’union de A et B,
intersect(A,B) désigne l’intersection de A et B,
minus(A,B) désigne la différence de A et B.
On a :
union(A,B)=set[1,2,3,4,5,6]
intersect(A,B)=set[3,4]
minus(A,B)=set[1,2]

### 2.17.3 Traduction MapleV

En Maple on utilise { }, comme en mathématiques, pour représenter un ensemble.
Exemple : De := {1, 2, 3, 4, 5, 6}
Dans un ensemble, l’ordre n’a pas d’importance. La répétition est interdite.
Pour délimiter une liste, on utilise [ ].
L’ordre est pris en compte, la répétition est possible.
Exemple : [Pile, Face, Pile]
Une séquence est une suite d’objets, séparés par une virgule.
Si C est un ensemble ou une liste, op(C) est la séquence des objets de C.
nops(C) est le nombre d’éléments de C.
Ainsi, si L est une liste, {op(L)} est l’ensemble des objets (non répétés) de L.
Exemples
On écrit :
S:=NULL: (pour la séquence vide)
S:=S,A: (pour ajouter un élément à S)
Une liste est une séquence entourée de crochets :
L:=[S]:
L[i] est le iéme élément de la liste L.
On peut aussi revenir à la séquence : S:=op(L):

### 2.17.4 Traduction MuPAD

Une liste est une suite d’expressions entre un crochet ouvrant [ et un crochet fermant ].
[ ] désigne la liste vide.
Exemple :
l:=[1,2,2,3]
nops(l) renvoie le nombre d’éléments de la liste l.
l[1] ou op(l,1) renvoie le premier élément de la liste l : les éléments sont numérotés de 1 à nops(l).
op(l) renvoie 1,2,2,3
append(l,4) ajoute l’élément 4 à la fin de la liste l.
De plus, les listes peuvent être concaténées avec le signe . (un point), par exemple [1,2].[2,3]=[1,2,2,3].
Attention une suite d’expressions entre une accolade ouvrante { et une accolade fermante } désigne un ensemble.
Exemple d’ensembles et de fonctions agissant sur les ensembles :
A:={a,b,c}; B:={a,d}
A union B désigne {a,b,c,d}
A intersect B désigne {a}
A minus B désigne {b,c}

### 2.17.5 Traduction TI89/92

augment permet de concaténer deux listes.
{} désigne la liste vide. Pour travailler avec des listes, on peut initialiser une liste de n éléments avec la commande newlist, par exemple :
newlist(10)=>L (L est alors une liste de 10 éléments nuls).
On peut utiliser les commandes suivantes :
seq(i*i, i, 1, 10) qui désigne la liste des carrés des 10 premiers entiers, ou seq(i*i, i, 0, 10, 2) qui désigne la liste des carrés des 5 premiers entiers pairs (le pas est ici égal à 2).
Exemple :
seq(i*i, i, 0, 10, 2) =>L va par exemple créer la liste :
{0, 4, 16, 36, 64, 100} c’est à dire la liste des carrés de 0 à 10 avec un pas de 2 que l’on stocke dans L.
L[j] qui désigne le jème élément de la liste L.
On peut aussi écrire :
2=>L[2]
La liste L est alors {0, 2, 16, 36, 64, 100}
ou si L est de longueur n on peut rajouter un élément (par exemple 121) à L en écrivant :
121 => L[n+1]
Dans l’exemple précédent n=6 on peut donc écrire :
121 => L[7] (L est alors égale à {0, 2, 16, 36, 64, 100, 121}).
left (L, 5) désigne les 5 premiers éléments de la liste L.

## 2.18 Un exemple : le crible d’Eratosthène

### 2.18.1 Description

Pour trouver les nombres premiers inférieurs ou égaux à N :

1. On écrit les nombres de 2 à N dans une liste.
2. On met 2 dans la case P .
3. Si P × P ≤ N il faut traiter les éléments de P à N : on barre tous les multiples de P à partir de P × P.
4. On augmente P de 1.
   Si P× P est strictement supérieur à N, on arrête
5. On met le plus petit élément non barré de la liste dans la case P. On reprend à l’étape 3

### 2.18.2 Écriture de l’algorithme

    Fonction crible(N)
    local TAB PREM I P
    // TAB et PREM sont des listes
    {} =>TAB
    {} =>PREM
    //on suppose que les indices d'une liste debutent par 0
    //si ils commencent par 1, mettre pour I de 1 a N
    pour I de 0 a N faire
      concat(TAB, I) => TAB
    fpour
    //On met 0 dans TAB[1] car 1 n'est pas premier
    //barrer 1 a ete realise en le remplacant par 0
    0 => TAB[1]
    //TAB est la liste 0 0 2 3 4 ...N
    2 => P
    // On a fait les points 1 et 2
    tantque P*P <= N faire
      pour I de P a E(N/P) faire
    //E(N/P) designe la partie entiere de N/P
        0 => TAB[I*P]
      fpour
    // On a barre tous les multiples de P a partir de P*P
      P+1 => P
    //On cherche le plus petit nombre <= N non barre (non nul)
    // entre P et N
      tantque (P*P <= N) et (TAB[P]=0) faire
        P+1 => P
      ftantque
    ftantque
    //on ecrit le resultat dans une liste PREM
    pour I de 2 a N faire
      si TAB[I]!= 0 alors
         concat(PREM, I) => PREM
      fsi
    fpour
    retourne PREM

### 2.18.3 Traduction Xcas

    //renvoie la liste des nombres premiers<=n selon eratosthene
    crible(n):={
      local tab,prem,p,j;
      tab:=[0,0];
      prem:=[];
      for (j:=2;j<=n;j++){
        tab:=append(tab,j);
      }
      p:=2;
      while (p*p<=n) {
        for (j:=p;j*p<=n;j++){
          tab[eval(j*p)]:=0;
        }
        p:=p+1;
        while ((p*p<=n) and (tab[p]==0)) {
          p:=p+1;
        }
      }
      for (j:=2;j<=n;j++) {
        if (tab[j]!=0) {
          prem:=append(prem,j);
        }
      }
      return(prem);
    };

ou avec les instructions françaises

    //renvoie la liste des nombres premiers<=n selon eratosthene
    crible(n):={
      local tab,prem,p,j;
      [0,0]=>tab;
      []=>prem;
      pour j de 2 jusque n faire
        append(tab,j)=>tab;
      fpour;
      2=>p;
      tantque (p*p<=n) faire
        pour j de p jusque n/p faire
          0=>tab[eval(j*p)];
        fpour
        p+1=>p;
        tantque ((p*p<=n) et (tab[p]==0)) faire
          p+1=>p;
        ftantque;
      ftantque;
      pour j de 2 jusque n faire
        si (tab[j]!=0) alors
          append(prem,j)=>prem;
        fsi
      fpour
      retourne(prem);
    };

### 2.18.4 Traduction TI89/92

Voici la fonction crible :
- n est le paramètre de cette fonction.
- crible(n) est égal à la liste des nombres premiers inférieurs ou égaux à n.

    :crible(n)
    :Func
    :local tab,prem,i,p
    :newList(n)=>tab
    :newList(n)=>prem
    :seq(i,i,1,n) =>tab
    :0 => tab[1]
    :2 => p
    :While p*p <= n
    :For i,p,floor(n/p)
    :0 => tab[i*p]
    :EndFor
    :p+1 => p
    :While p*p<= n and tab[p]=0
    :p+1 => p
    :EndWhile
    :EndWhile
    :0 => p
    :For i,2,n
    :If tab[i]!= 0 Then
    :p+1 =>p
    :i =>prem[p]
    :EndIf
    :EndFor
    :Return left(prem,p)
    :EndFunc

## 2.19 Un exemple de fonction vraiement récursive

### 2.19.1 La définition

Voici la définition de la fonction a dite fonction de ackermann qui est une fonction de ℕ×ℕ dans ℕ :

    a(0,y)=y+1,
    a(x,0)=a(x-1,1) si x>0,
    a(x,y)=a(x-1,a(x,y-1) si x>0 et si y>0.

Ainsi on a :
a(0,0)=1
a(1,0)=a(0,1)=2
a(1,1)=a(0,a(1,0))=a(0,2)=3
a(1,2)=a(0,a(1,1))=4
a(1,n)=a(0,a(1,n-1))=1+a(1,n-1)=...=n+2
a(2,0)=a(1,1)=3
a(2,1)=a(1,a(2,0))=a(1,3)=5
a(2,2)=a(1,a(2,1))=2+a(2,1)=7
a(2,n)=a(1,a(2,n-1))=2+a(2,n-1)=2n+3
a(3,0)=a(2,1)=5
a(3,1)=a(2,a(3,0))=2*a(3,0)+3=13
a(3,2)=a(2,a(3,1))=2*a(3,1)+3=29
a(3,n)=a(2,a(3,n-1))=2*a(3,n-1)+3
=2`^`(n+1)+3*(2`^`n+2`^`(n-1)...+1)
=2`^`(n+1)+3*(2`^`(n+1)-1)= 2`^`(n+3)-3
On a donc par exemple : a(3,5)=2`^`8-3=253
Les calculs sont vite gigantesques on a par exemple :
a(4,1)=a(3,a(4,0))=a(3,a(3,1))=a(3,13)=65533
a(4,2)=a(3,a(4,1))=a(3,65533)=2`^`65536-3
a(4,3)=a(3,a(4,2))=a(3,2`^`65533-3)=2`^`(2`^`65536-3)-3
On a donc :
a(4,y)=a(3,a(4,y-1))=2`^`(a(4,y-1)+3)-3
=2`^`(2`^`(a(4,y-2)+3)-3+3)-3=2`^`(2`^`(a(4,y-2)+3))-3
et donc
a(4,y)=2`^`(2`^`..(2`^`(a(4,0)+3))..)-3= 2`^`(2`^`..(2`^`16)..)-3,
avec 2`^` qui se répète y fois, et comme 16=2`^`(2`^`2) on a,
a(4,y)=2`^`(2`^`..(2`^`2)..)-3,
avec 2 qui se répète y+3 fois.

### 2.19.2 Le programme

Voici un premier programme :

    akc(x,y):={
    if (x==0) return y+1;
    if (y==0) return akc(x-1,1);
    return ack(x-1,ack(x,y-1));
    }

ou bien en utilisant ifte :

    ack(x,y):=ifte(x==0,y+1,
                   ifte(y==0,ack(x-1,1),ack(x-1,ack(x,y-1))));

On remarque que le temps pour calculer la valeur pour a(3,5) est de 5.06s ce qui est tres long, mais on peut donc améliorer le programme en arrêtant la récursivité lorsque x==3.
On écrit :

    a(x,y):={
    if (x==0) return y+1;
    if (x==1) return y+2;
    if (x==2) return 2*y+1;
    if (x==3) return 2^(y+3)-3;
    if (y==0) return a(x-1,1);
    return a(x-1,a(x,y-1));
    }

On peut aussi améliorer le programme en arrêtant la récursivité lorsque x==4.
On écrit :

    a(x,y):={
    if (x==0) return y+1;
    if (x==1) return y+2;
    if (x==2) return 2*y+1;
    if (x==3) return 2^(y+3)-3;
    if (x==4) {
    local p:=1;
    for (j:=1;j<=y+3;j++) p:=2^p;
    return p-3;
    }
    if (y==0) return a(x-1,1);
    return a(x-1,a(x,y-1));
    }

Essayez a(4,1)=65533, a(4,2)....