Discussion :

[Aezar]

Bonjour !

Voila, je voulais faire un programme calculant la suite de Fibonacci (0, 1, 1, 2, 3, 8, 13, 21, 34 ...) et je m'en suis plus ou moins sorti (en tout cas ça marche ).

Mais voila mon problème : voulant aller un peu plus loin dans le nombre de nombres trouvés dans la suite, je me suis dit, je vais mettre le type extended pour mes variables (j'utilisais longint avant, mais cela ne me permet de calculer que 47 nombres de la suite ).
J'ai donc changé le type de mes variable, mais j'ai eu l'erreur suivante : Error 116 : Must be in 8087 mode to compile this. Je vais donc voir la FAQ et je regle mon problème en allant cocher le bouton adequat dans Option.
Mais une nouvelle erreur est survenu, type mismatch, et je ne sais pas comment la regler !

Je vous montre le code au cas ou :

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
 Var i, n : extended ;
Var tab : array [0..47] of extended ;
 
BEGIN 
i := 0 ;
n := 0;
 
Repeat 
    tab[i] := n ;
    writeln (n) ;
        if n>0 then
            begin
                inc (n, tab[i-1]) ;
            end;
        if n=0 then
            begin
                inc (n, 1) ;
            end;
inc (i, 1) ;
until i = 47 ;
 
Readln ;
END.

Le code peut paraitre un peu lourd, mais bon je débute !

Et donc il me renvoit l'erreur type mismatch, en me mettant le curseur en dessous de tab[i] := n ;

Merci d'avance a tous !!!

[M.Dlb]

La vaiable i doit être de type entier, et non pas réel. Tu peux garder longint pour i.

Comme tu l'as dit, ton code est plutot lourd, car il n'y a pas besoin de tableau. Il te suffit juste de deux variables, pour les valeurs au rang n-2 et n-1.

[Aezar]

Merci pour tes réponses, mais même après avoir changer le type de la variable i en longint, il me dit Error 104 : Ordinal Variable expected., en designant la ligne Inc (n, tab[i-1]) ;.

Je pense que c'est a peu près le même problème qu'avec la variable i, mais je suis loin d'en être sur.

Sinon je ne savais pas si on pouvait récupérer la valeur précédente de la variable, c'est pour cela que j'ai préféré tout stocké dans un tableau.

[Eric Sigoillot]

L'utilisation de l'aide est une des premières choses à apprendre... Donc il suffit de se renseigner sur Inc pour voir sa déclaration :

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

procedure Inc(var X[; N: Longint]);

Par conséquent, la procédure Inc ne peut incrémenter qu'une variable entière, ce qui n'est pas le cas ici.
Il faut donc écrire :

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

n := n + tab[i-1];

Ce n'est pas sorcier.

De plus la suite de Fibonacci n'est consitutuée que d'entier. Le passage par des réels ne peut que poser des problèmes, car par exemple, pour un ordinateur, il est impossible de représenter certains nombres entiers en virgule flottante car ils ne se décomposent pas de manière finie en suite de puissance de 2.
Si le type Longint est insuffisant, il est possible d'utiliser le type Comp, qui bien que n'étant pas considéré comme un type entier à part entière, permet de stocker exclusivement des nombres entiers et apparaît donc bien plus aproprié.


En ce qui concerne l'utilisation d'un tableau, elle n'est bien entendu pas raisonnable car la suite allant en grandissant, il arrive un moment où la place en mémoire devient excessive par rapport à l'utilisation qu'on en fait. L'utilisation de deux variables comme le propose Wormful est bien plus simple. Un exemple pour mettre sur la piste.
Si on considère une suite de type : u(n+1) = 2*u(n) + 1 avec u(0) = 0, alors on peut écrire :

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
11
function u(n: Longint): Longint;
var
  Result: Longint;
begin
  if n = 0 then
    Result := 0
  else
    Result := 2 * u(n - 1) + 1;
 
  u := Result;
end;

A creuser et à adapter pour une suite à deux crans de récurrence. De plus, l'exemple donné est récurrent alors que l'utilisation d'une méthode itérative (avec une boucle for) permet de meilleures performances.

@++

[Aezar]

Merci pour l'aide apporté !

Donc si j'ai bien compris, si je veux faire une suite de Fibonacci, l'utilisation d'une variable de type réel est impossible, je peux uniquement utilisé des entiers (dites moi si je me trompe ...).

Sinon je pense que je vais réesayer de faire un code sans tableau, même si je ne suis pas sur d'avoir bien compris comment l'histoire avec les 2 variables marchait. Je vais un peu me creuser la tête et ça devrait venir

[pascal_damien]

Tu peux utiliser le type comp (dont le status est ambiguë) comme l'a dit hdd34.
L'utilisation de réels n'est pas nécessaire car la suite ne donne que des entiers (l'utilisation de réels est possible, mais tu perds en précision).

[Aezar]

Voila, j'ai réussi a refaire un code sans le tableau et en utilisant la boucle For..to..do et 2 variables :

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
Var i, n, n-1 : longint ;
 
BEGIN
    i := 0 ;
    n := 0 ;
    n1 := 0 ;
 
    For i := 0 to 30  do
        begin
            Writeln (n) ;
 
            If n=0 then
                begin
                    n := 1
                end ;
 
            If n>0 then
                begin
                    n := n1 + n ;
                    n1 := n - n1 ;
                end ;
        end ;
 
    Readln ;
END.

Mais pour l'utilisation du type comp, j'ai les mêmes erreurs qu'avec le type extended.

[Eric Sigoillot]

Mais pour l'utilisation du type comp, j'ai les mêmes erreurs qu'avec le type extended.

C'est normal, le type Comp est assimilé à un type réel bien que ce n'en soit pas un. Il faut faire avec.
Sur Delphi et les compilateurs 32 bits récents, tu peux t'orienter vers le type Int64, qui permet d'aller plus loin que les Longint.
Par contre, le type Int64 est lui parfaitement entier, et donc Inc fonctionne avec. Mais il ne faut pas compter l'utiliser avec TP7 par exemple

Pour ta suite de Fibonacci, je n'ai pas testé, j'espère qu'elle fonctionne. Selon ma définition, on a f(n) = f(n-1) + f(n-2)
Donc on pourrait avoir :

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
 
function Fib(n: Integer): Comp;
var
  i: Integer;
  Result: Comp;
  Prev, Prev2: Comp;
begin
  Result := 1;
  Prev := 0;
  Prev2 := 0;
 
  for i := 2 to n do
  begin
    Prev2 := Prev;
    Prev := Result;
    Result := Prev + Prev2;
  end;
 
  Fib := Result;
end;

Code non testé...

@++

[Aezar]

Merci beaucoup pour toutes vos réponses !

Mon code pour la suite de Fibonacci marche très bien rassure toi, je l'ai testé.
Par contre je n'ai pas testé la tienne, mais elle m'a l'air de marcher.

Sinon je crois que je vais me contenter de longint, vu que j'ai un peu de mal à comprendre toutes ces histoires de réel et d'entier...
J'ai compris que les entiers n'avaient pas de virgule, mais je n'ai pas bien saisie pourquoi j'obtenais une erreur avec des réels...

De toute façon je suis sous TP7, donc je ne vais pas aller loin

[Eric Sigoillot]

J'ai compris que les entiers n'avaient pas de virgule, mais je n'ai pas bien saisie pourquoi j'obtenais une erreur avec des réels...

En fait, il faut bien comprendre que les entiers et les réels, ce n'est pas la même chose
Un entier va être codé en mémoire en utilisant tous les bits à sa disposition (8, 16, 32 ou 64) correspondant à des puissances de 2.
Ainsi, le nombre 23 est égal à 1 + 2 + 4 + 16. Donc, en binaire, ça donne 2^0 + 2^1 + 2^2 + 2^4, ainsi les bits 0, 1, 2 et 4 sont positionnés à 1 et les autres positionnés à 0.
Ca donne au maximum, pour un entier sur 32 bits par exemple, une valeur de 2^32 - 1 si le nombre est non signé, et 2^31 - 1 s'il est signé, car on garde un bit de signe.

Pour les réels, c'est totalement différent. D'abord, il y a toujours un bit de signe, puis un certain nombre de bits pour la mantisse (en notation scientifique, par exemple 1.345 ou encore 7.0909) et le reste pour l'exposant, de sorte que la valeur du réel soit égale à : +/- Mantisse * 2^Exposant.

Le codage est totalement différent, donc les procédures comme Inc, qui se basent sur des optimisations du système, ne peuvent s'appliquer à la fois aux entiers et aux réels. Question de représentation...

@++