Les boucles

suivant: Les différentes instructions selon monter: Présentation générale des instructions précédent: Les tests Table des matières Index

Les boucles

Avec le langage Xcas les boucles ont soit une syntaxe similaire au langage C++ soit une version française proche du langage algorithmique.
Pour les boucles, les syntaxes admises sont :

la boucle for ou pour qui permet de faire des instructions un nombre de fois qui est connu :
for (init;condition;increment) instruction;
on met {..} lorsqu'il faut faire plusieurs instructions :
for (init;condition;increment) {instructions}
Le plus souvent (init;condition;increment) s'écrit en utilisant une variable (par exemple j ou k...mais pas i qui désigne un nombre complexe!!!). Cette variable sera initialisée dans init, utilisée dans condition et incrementée dans increment, on écrit par exemple :
(j:=1;j<=10;j++) (l'increment ou le pas est de 1) ou
(j:=10;j>=1;j-) (l'increment ou le pas est de -1) ou
(j:=1;j<=10;j:=j+2) (l'increment ou le pas est de 2)
ou
pour j de 1 jusque 10 faire instructions fpour;
ou
pour j de 10 jusque 1 pas -1 faire instructions fpour;
ou
pour j de 1 jusque 10 pas 2 faire instructions fpour;
On initialise j puis on teste la condition :
- si elle est vraie, on fait les instructions puis on incrémente j, puis, on teste la condition : si elle est vraie, on fait les instructions etc...
- si elle est fausse on ne fait rien c'est à dire on passe aux instructions qui suivent le for ou le pour.
Par exemple :
```
testfor1(a,b):={
local j,s:=0;
for (j:=a;j<=b;j++)
   s:=s+1/j^2;
return s;
};
```
ou
```
testpour1(a,b):={
local j,s:=0;
pour j de a jusque b faire
   s:=s+1/j^2;
fpour;
return s;
};
```
Si a>b, l'instruction ou le bloc d'instructions du for ou du pour ne se fera pas et la fonction retournera 0,
Si a<=b la variable j va prendre successivement les valeurs a, a+1,...b (on dit que le pas est de 1) et pour chacune de ces valeurs l'instruction ou le bloc d'instructions qui suit sera exécuté. Par exemple testfor1(1,2) renverra 1+1/4=5/4.
```
testfor2(a,b):={
local j,s:=0;
for (j:=b;j>=a;j--)
    s:=s+1/j^2;
return s;
};
```
ou
```
testpour2(a,b):={
local j,s:=0;
pour j de b jusque a pas -1 faire
   s:=s+1/j^2;
fpour;
return s;
};
```
Dans ce cas, si a<=b la variable j va prendre successivement les valeurs b, b-1,...a (on dit que le pas est de -1) et pour chacune de ces valeurs l'instruction ou le bloc d'instructions qui suit sera exécuté. Par exemple testfor2(1,2) renverra 1/4+1=5/4.
```
testfor3(a,b):={
local j,s:=0;
for (j:=a;j<=b;j:=j+3)
    s:=s+1/j^2;
return s;
};
```
ou
```
testpour3(a,b):={
local j,s:=0;
pour j de a jusque b pas 3 faire
   s:=s+1/j^2;
fpour;
return s;
};
```
Dans ce cas, si a<=b la variable j va prendre successivement les valeurs a, a+3,...a+3k avec k le quotient de b-a par 3 (3k<=b-a<3(k+1)) (on dit que le pas est de 3) et pour chacune de ces valeurs l'instruction ou le bloc d'instructions qui suit sera exécuté. Par exemple testfor3(1,5) renverra 1+1/16=17/16.
la boucle while ou tantque permet de faire plusieurs fois des instructions avec une condition d'arrêt au début de la boucle : while (condition) instruction;
on met {..} lorsqu'il faut faire plusieurs instructions :
while (condition) {instructions}
ou
tantque condition faire instructions ftantque;
On teste la condition :
- si elle est vraie, on fait les instructions puis, on teste la condition : si elle est vraie, on fait les instructions etc...
- si elle est fausse on ne fait rien c'est à dire on passe aux instructions qui suivent le while ou le tantque.
Par exemple :
```
testwhile(a,b):={
while (a==10 or a<b)
   b:=b-a;
return [a,b];
};
```
ou
```
testtantque(a,b):={
tantque a==10 or a<b faire
   b:=b-a;
ftantque;
return [a,b];
};
```
Un exemple : le PGCD d'entiers
- Version itérative
```
pgcd(a,b):={
 local r;
 while (b!=0) {
    r:=irem(a,b);
    a:=b;
    b:=r;
 }
 return a;
};
```
ou
```
pgcd(a,b):={
 local r;
 tantque b!=0 faire
    r:=irem(a,b);
    a:=b;
    b:=r;
 ftantque; 
 return a;
};
```
-Version récursive
```
pgcdr(a,b):={
 if (b==0) return a;
 return pgcdr(b,irem(a,b));
};
```
ou
```
pgcdr(a,b):=if (b==0) return a;
                else return pgcdr(b,irem(a,b));
```
La boucle repeat ou repeter permet de faire plusieurs fois des instructions avec une condition d'arrêt à la fin de la boucle :
repeat instructions until condition;
ou
repeter instructions jusqua condition;
ou
repeter instructions jusqu_a condition;
On fait les instructions, puis on teste la condition :
- si elle est vraie, on fait les instructions puis, on teste la condition etc...
- si elle est fausse on passe aux instructions qui suivent le repeat ou le repeter.
Par exemple :
```
f():={
  local a;
  repeat saisir("entrez un reel entre 1 et 10",a); until a>=1 && a<=10;
  return a;
}
```
ou
```
f():={
  local a;
  repeter saisir("entrez un reel entre 1 et 10",a); jusqua a>=1 et a<=10;
  return a;
}
```
Voici la fonction qui renvoie un point fixe de f en utilisant repeat. Cette fonction donne la solution à eps près de f(x)=x en utilisant au plus n itérations et x0 comme début de l'itération donné par le théorème du point fixe.
```
point_fixe(f,n,x0,eps):={
 local j,x1,x00;
 j:=0;
 repeat
   x1:=evalf(f(x0));
   j:=j+1;
   x00:=x0;
   x0:=x1;
 until (abs(x00-x0)<eps) or (j>=n);
 return j,x0;
}:;
```
ou
```
point_fixe(f,n,x0,eps):={
 local j,x1,x00;
 j:=0;
 repeter
   x1:=evalf(f(x0));
   j:=j+1;
   x00:=x0;
   x0:=x1;
 jusqua (abs(x00-x0)<eps) or (j>=n);
 return j,x0;
}:;
```

La boucle do instructions od ou faire instructions ffaire est une boucle infinie il faut donc mettre une condition d'arrêt avec un break ou un return dans le corps de la boucle.
Par exemple la fonction précédente en utilisant do :

point_fixe(f,n,x0,eps):={
 local j,x1;
 j:=0;
 do
   x1:=evalf(f(x0));
   if (abs(x1-x0)<eps) return x1;
   x0:=x1;
   j:=j+1;
   if (j>=n) break;
 od;
 return "non trouve au bout de ", n," iterations";
}:;

ou en utilisant faire

point_fixe(f,n,x0,eps):={
 local j,x1;
 j:=0;
 faire
   x1:=evalf(f(x0));
   if (abs(x1-x0)<eps) return x1;
   x0:=x1;
   j:=j+1;
   if (j>=n) break;
 ffaire;
 return "non trouve au bout de ", n," iterations";
}:;

On peut aussi écrire cela avec un for

point_fixe(f,n,x0,eps):={
 local j,x1;
 for (j:=0;j<n;j++){
   x1:=evalf(f(x0));
   if (abs(x1-x0)<eps) return x1;
   x0:=x1;
 }
 return "non trouve au bout de ", n," iteration";
}:;

point_fixe(x->cos(x),100,1.0,1e-12)=0.739085133215
On vérifie : cos(0.739085133215)=0.739085133215
Remarque Le for permet de faire tous les types de boucle à condition de mettre, soit for (;test_arrêt;)... soit et for (;;)... et une instruction break dans le corps du for, par exemple :

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

pgcd(a,b):={
local r;
for (;;) {
if (b==0) break;
r:=irem(a,b);
a:=b;
b:=r;
}
return a;
}
:;

suivant: Les différentes instructions selon monter: Présentation générale des instructions précédent: Les tests Table des matières Index

Documentation de giac écrite par Renée De Graeve