Recherche d'un nombre

[Rockleader]

Apres pour le mmorpg... tu mets la barre un peu haut

J'en suis conscient, pour l'instant, je dirais que ce n’est qu'un rêve, mais je ferais tout pour le transformer en réalité =)


J'écris une histoire depuis un moment que je vais adapter pour l'histoire...après suffira de trouver une équipe de graphiste et de développeur assez motivés pour faire ça. Si l'envie et les compétences sont là ça ne pourra que marcher.

[Rockleader]

Voilà ma version finalisé de ce programme, qui marche bien, j'ai tenu en comptes des conseils pour sortir de la boucle.

Voilà, j'attends vos commentaires, plus sur la forme que sur le fond puisque la discussions a un peu dérivé là dessus...par exemple est ce que mes commentaires sont vraiment utile etc etc...

Code: Tout sélectionner

--Recherche d'un nombre entré par l'utilisateur
with entrees_sorties;
use entrees_sorties;
procedure devinette is

v_Min:Integer:=1; -- Valeur minimale 1
v_Max:Integer:=100; -- Valeur maximale 100
Dial:Integer; --Dialogue avec la machine
nbre_Tentative:Integer:=0;
nbre_Choisi:Integer;

begin
   While (nbre_Tentative <= 7) loop
      nbre_Choisi := (v_Min + v_Max) / 2;
      put(nbre_Choisi);
      new_line;
      get(Dial);
      if (Dial = -1) then
         v_Max := nbre_Choisi;
      elsif (Dial = 1) then
         v_Min := nbre_Choisi;
      else
         put("Le nombre a été trouvé en ");
         put(nbre_Tentative);
         put(" tentatives");
         nbre_Tentative := 7; --afin de mettre fin à la boucle
      end if;
      nbre_Tentative := nbre_Tentative + 1;
   end loop;
   if(Dial /= 0) then --condit° afin d'afficher ssi nbre n'est pas trouvé
      put("Les 7 tentatives sont écoulées.");
   else   
      null;
   end if;   
end devinette;


[fatal_error]

v_Min:Integer:=1; -- Valeur minimale 1

autant écrire valeurMinimale:Integre:=1, commentaire inutile.

Dial:Integer; --Dialogue avec la machine

variable mal nommée, c'est pas un dialogue. c'est l'entrée de l'utilisateur. Appeles ca userInput, inputNumber ou je sais pas quoi, mais pas dial.

nbre_Tentative := 7; --afin de mettre fin à la boucle

ca c'est horrible. nbre_Tentative c'est le nombre de tentative, t'es pas censé t'en servir comme ca. Soit tu mets une autre condition dans le while comme proposé par C.ret, soit tu break pour sortir à l'arrache.

enfin, ton underscore ne sert à rien dans la mesure où tu écris tes variables de la forme
blabla_Toto, soit tu mets blablaToto, soit blabla_toto, mais _ suivi de majuscule c'est useless.
Tu noteras que Dial n'est pas cohérente avec tes autres variables car commence par une majuscule.

ton block

put("Le nombre a été trouvé en ");
put(nbre_Tentative);
put(" tentatives");
nbre_Tentative := 7; --afin de mettre fin à la boucle

pourrait être écrit dans ton else null (???) à la place comme préconisé une fois de plus par C.ret

put("Les 7 tentatives sont écoulées.");

dans la mesure où tu peux afficher ce que tu veux, autant écrire

put("Les 7 tentatives sont écoulées. Nombre non trouvé");

ca t'éviteras un commentaire inutile

edit:

nbre_Tentative := 7; --afin de mettre fin à la boucle

ce commentaire serait avisé si tu étais obligé de sortir du while ainsi, mais c'est pas le cas...

[Rockleader]

C'est un peu sec dis comme ça, mais j'apprécie c'est comme ça qu'on progresse !

Pour le nom des variables, j'acquisse c'et vrai que le commentaire qui suit est pas très utile sachant que la variable est assez explicite pour elle même.


Pour Dial : Ok, je le voyais pas comme ça, mais j'en prend note, en considérant que c'est une entrée de l'utilisateur, input prend bien tout son sens (parce que j'ai fais un peu de c peut être...)


Ensuite pour le underscore qui ne sers à rien par exemple nbre_Tentative...je suis daccord j'écrirais plutôt nbreTentative...mais la norme que l'on est censé respecté pour ada nous impose de séparer les mots par des underscore, la majuscule seule ne suffit pas....


SI j'avais gardé Dial, c'est vrai que j'aurais du modifier en dial puisque les noms de variables doivent commencer par une minuscule selon cette même norme.



En ce qui concerne le null c'est une instruction pour dire de ne rien faire...c'est vrai que j'aurais pu m'en passer.



Par contre, là o je n'ai pas tout suivi, c'est pour sortir de la boucle, comment aurait tu fais pour faire un break comme tu dis...j'ai bien essayer de faire un truc du genre

Si le nombre a été trouvé, alors fin du programme, mais à la compilation ça ne veut pas passer, c'ets pour sa que j'ai pensé à modifier la valeur du nombre de tentative en conséquences pour forcer l'arrêt de la boucle. Après j'aurais aussi pu utiliser une variable uniquement pour ça, mais le prof préfère que l'on en utilise le moins possible donc...


Je suis curieux e savoir quel moyen tu aurais employé pour forcer l'arrêt de la boucle autrement une fois le nombre trouvé.


Cordialement.

[fatal_error]

Après j'aurais aussi pu utiliser une variable uniquement pour ça, mais le prof préfère que l'on en utilise le moins possible donc...

si tu peux pas lui dire que c'est une bille, fais le lui comprendre. Utiliser une variable pour deux buts différents, c'est (tres) nul. Mais de toute façon la question de variable supplémentaire ne se pose pas ici.

Je suis curieux e savoir quel moyen tu aurais employé pour forcer l'arrêt de la boucle autrement une fois le nombre trouvé.

google, ada break loop
ou encore une fois relis mieux les postes de C.ret. :hum:

[Rockleader]

Ok dac -:)


Encore une dernière question, je viens de faire un algorithme qui dis la nature d'un nombre 'premier ou pas) compris entre deux bornes A et B.

Mais en annexe le prof nous demande quel moyen on pourrait utiliser pour accélerer l'algorithme. Et j'avoue que sur ces questions là je suis pas très calé...pourtant pour demander ça à des débutants ça doit pas être bien compliqué :help:

Voilà l'algorithme en question.

Code: Tout sélectionner

with entrees_sorties;
use entrees_sorties;
--Cherche les nombres premiers compris entre deux valeurs
procedure premiers is

A:Integer; --Borne inférieure de l'intervalle
B:Integer; --Borne supérieure de l'intervalle
Val:Integer; --compteur pour les valeurs
C:Integer;
D:Integer;

begin
  put("Donner la valeur minimale de l'intervalle:");
  get(A);
  put("Donner la valeur maximale de l'intervalle:");
  get(B);
  Val:=A;
  While (Val /= B) loop
    C := 2;
    D := 0;
    While (C < Val) loop
      if(Val mod C = 0) then
   D := D+1;
      end if;
      C := C+1;
    end loop;
    put(Val);
    if(D = 0) then
         put(" est un nombre premier");
    else
         put(" n'est pas un nombre premier");
    end if;
    Val := Val + 1;
  end loop;
end premiers;


[fatal_error]

je viens de faire un algorithme qui dis la nature d'un nombre 'premier ou pas) compris entre deux bornes A et B.

non tu as fait un algorithme qui dit si chacun des nombres entres A et B est premier. C'est pas un nombre c'est tous.

Ensuite, c'est trivial dans ton cas pour optimiser.
Quand tu trouves un modulo 0 (un nombre divisible), genre

Code: Tout sélectionner

 While (C < Val) loop
      if(Val mod C = 0) then
   D := D+1;
      end if;
      C := C+1;
    end loop;

tu continues à incrémenter C et à exécuter ta boucle. Alors que bon, si c'est divisible, ya pas besoin de tester les diviseurs suivants...

Deuxiemement, est-ce nécessaire de tester C jusqu'à Val?

Enfin pour dire un algo t'es pas obligé de faire de l'ada, du pseudo code reste quand même plus lisible...

[Rockleader]

Deuxiemement, est-ce nécessaire de tester C jusqu'à Val?

Si mes souvenirs de spé math sont bon, il suffirait de tester jusqu'à la racine carré de la valeur ?

tu continues à incrémenter C et à exécuter ta boucle. Alors que bon, si c'est divisible, ya pas besoin de tester les diviseurs suivants...

Hum, c'est vrai, mais d'un autre coté pour ceux dont ce n’est pas vrai dès le début, il faut quand même faire les autres jusqu'à en trouver (ou pas) dont le reste prend la valeur 0...Donc aau final je suis pas tellement sur que ça permette d'améliorer la vitesse du programme.

non tu as fait un algorithme qui dit si chacun des nombres entres A et B est premier. C'est pas un nombre c'est tous.

Je n'ai pas compris ce que tu as voulu dire ici...

[C.Ret]

Voilà ma version finalisé de ce programme, qui marche bien, j'ai tenu en comptes des conseils pour sortir de la boucle.

Je me joins au remarques de Fatal-Error surtout concernant le nom des variables. Et je dois reconnaitre aussi que sa philosophie concernant les commentaires rendu superflus par l'usage de noms de variable/procédure approprié est bonne.

Concernant la sortie de la boucle par un BREAK, c'est quelque chose qui peut être très bien fait.
Par contre, dans le cas de cet excercice, il faut bien se rendre à l'évidence que ce n'est pas le nombre de propositions que fait le programme qui est le facteur limitant, mais plutôt la réponse de l'utilisateur.

Si l'on ne devait utiliser qu'une seule variable, l'indicateur de sortie serait bien une réponse égale à 0.

Autre chose qui me choque c'est que le message qui affiche que la réponse n'a pas était trouvée avant les 7 proposition est dans une clause IF ... THEN qui ne teste pas le nombre de propositions, mais la réponse de l'utilisateur ??

Dans mon exemple, je teste bien la valeur donnée par l'utilisateur pour indiquer le nombre secret lorsqu'il a été trouvé par l'ordinateur tout seul et éviter de le faire si l'utilisateur vient de répondre 0. Car alors c'est évident que le nombre secret a été trouvé, l'utilisateur vient de le voir s'afficher.

Et mon algorithme boucle autant de fois que nécessaire, d'où le test sur le nombre de propositions pour indiquer l'éventuel dépassement.


Afin, en ADA il n'ya pas de BREAK, mais il existe une instruction EXIT ... WHEN :

Code: Tout sélectionner

Sys_Prop := 50;
Nb_Prop := 0;
Seek_Loop :
   LOOP
      Nb_Prop := Nb_Prop +1
      PUT(Sys_Prop);
      GET(User_Rep);
      EXIT Seek_Loop WHEN User_Rep == 0;
      Sys_Prop := Sys_Prop + SGN( User_Rep) * (Sys_Prop / 2);

   END LOOP  Seek_Loop;


P.S.: Je fais expres de mettre des noms Composé_Avec_Le_Underscore_Et_Des_Majuscule car cela est souvent l'usage dans les communauté ADA que j'ai fréquenté; d'ailleurs c'était une obligation dans certains cahiers des charges pour l'industrie d'armement.

Mais, ce n'est pas l'usage en C/C++ ... je sais chacun ses défauts !!



Concernant les nombres premiers , tout nombre est soit premier, soit composé (ou multiple) (c'est plus élégant que "pas premier" - et surtout cela montre que l'on a fait un minimum de recherche et de préparation au sujet !).


En ADA quand on connait les bornes d'une boucle, on peut utiliser

Code: Tout sélectionner

FOR i IN  A..B LOOP
 ...
 END LOOP


Je pense, que ce que demande le prof n'est pas de changer l'algorithme ou de trouver une méthode plus astucieuse pour détecter les nombre premier. Bien que cela soit tout à fait possible.

Dans un premiers temps, il faut observer le déroulement du code et voir où sont les boucles (surtout imbriquée), combien de fois chaque boucle est recommencer et comprendre la dynamique de tout cela (profiler).


Apparement D est un compteur, mais il compte quoi ? Est-il nécessaire pour chaque Val testée de compter tous les multiples ? Ne peut-on pas s'arrêter dès que le premier facteur est détecté ?


Par ailleurs, la variable C recommence à 2 pour chaque élément de l'intervalle [A B].
Ensuite la boucle de C fait 2,3,4, 5, ... Mais à quoi sert de tester 4 si on a déjà testé avec 2 ?
Pareil avec 3, tester ensuite par 6 ou 9 c'est pas bien malin...

Il y a peut-être une série de valeur à utiliser pour C qui permettrait de ne rien oublier mais avec bien moins de valeurs testé ?


De même pour la condition de fin, est-il nécessaire d'aller jusqu'à C < Val ? Supposons que la valeur Val soit un nombre composé, à un moment, Val est multiple de C; il existe donc un entier k tel que Val = C * k. On a testé C par valeur croissante à partir de 2 , donc on sait que k est supérieur ou égal à C. S'il était plus petit, on aurait déjà eut une division juste.

Il y a peut-être aussi quelque chose à faire pour ne pas avoir à refaire tout depuis le début à chaque valeur de l'intervalle.

Par exemple, si A est pair, alors A+2, A+4, etc... jsuqu'à B le seront aussi. Il est peut-être plus malin :
-I- de ne pas refaire la boucle concernant C "bêtement" en recommencant sans tenir compte des résultats précèdents ? Mais cela fait partie de la réflexion ci-dessus concernant les valeur de C à utiliser
-II- à ne pas tester les multiples suivant un nombre composé détecté.


Pour y voir plus clair, prenons un exemple concret :

Je veux déterminer les nombres premiers (et composés) entre 10 et 20 :

L'algorithme commence avec Val =10
On commence avec C = 2, test Val MOD 2

On remarque que cela est vrai aussi si par exemple A est multiple de 3, alors on sait déjà A+3, A+6, A+9, ... le seront aussi !

[fatal_error]

Hum, c'est vrai, mais d'un autre coté pour ceux dont ce n’est pas vrai dès le début, il faut quand même faire les autres jusqu'à en trouver (ou pas) dont le reste prend la valeur 0...Donc aau final je suis pas tellement sur que ça permette d'améliorer la vitesse du programme.

c'est incompréhensible.

non tu as fait un algorithme qui dit si chacun des nombres entres A et B est premier. C'est pas un nombre c'est tous.

ca veut dire que ta description

... qui dis la nature d'un nombre 'premier ou pas) compris entre deux bornes A et B.

est fausse. Ton algorithme ne donne pas la nature d'un nombre compris entre A et B mais de tous les nombres compris entre A et B. Un peu de rigueur!!

des noms Composé_Avec_Le_Underscore_Et_Des_Majuscule

fiou je suis heureux de ne pas avoir connu cette époque!

[C.Ret]

fiou je suis heureux de ne pas avoir connu cette époque!

Sans compter que l'environnement de l'époque en question nous insulté à chaque Majuscule/Mnuscule oubliée, chaque espace obligatoire entre les opérateurs oublié, ...

Le pire était que les variables des sous-routine, bien de déclarée localement, devait porter le nom de ladite sous_routine afin, lors de la revue, ne pas être confondu avec une variable de nom identique d'une autre partie du code !!!

C'était pas une containte imposé par l'environnement et l'interpréteur, c'était une contrainte imposée par le service qualité controle; ces mesieurs avaient peurs de s'enméler entre le 3000 ou 4000 sosu-procédure du projet !

Et encore, j'avais de la chance, je n'étais actif que sur un seul projet; car les QA/QC auraient suremetn trouvé le moyen d'imposer de mettre dans les noms de variable aussi la réfèrence du projet (crypté bien sûr avec une table (une de plus) de correspondance !!).

[Rockleader]

C'était pas une containte imposé par l'environnement et l'interpréteur, c'était une contrainte imposée par le service qualité controle; ces mesieurs avaient peurs de s'enméler entre le 3000 ou 4000 sosu-procédure du projet !

EN fait, chaque entreprise possède plus ou moins sa norme en terme d'écriture de langage si j'ai bien compris...il y a un guide général, mais après dans la pratique tout le monde y vass un peu de sa sauce j'ai l'impression...

est fausse. Ton algorithme ne donne pas la nature d'un nombre compris entre A et B mais de tous les nombres compris entre A et B. Un peu de rigueur!!

C'est vrai je n'y ai pas fais attention, c'est ma faute

Par ailleurs, la variable C recommence à 2 pour chaque élément de l'intervalle [A B]. Ensuite la boucle de C fait 2,3,4, 5, ... Mais à quoi sert de tester 4 si on a déjà testé avec 2 ? Pareil avec 3, tester ensuite par 6 ou 9 c'est pas bien malin...

Le plus astucieux ce serait donc de procéder un peu comme avec le crible d'ératostène, on élimine tous les multiples de 2, puis de 3 etc etc ?

[C.Ret]

Oui, c'est un peu (edit: bien exactement cela) l'idée. mais cela n'empêche pas aussi de tenir compte des astuces données par Fatal-Error

Mon idée est de ne faire la boucle de recherche des diviseurs qu'une seule fois pour tous les nombres entre A et B.

Les diviseurs que j'utilise sont (hors 2 et 3) de la forme 6n±1, ils sont presque tous premiers.
2 3 5 7 11 13 17 19 23 25 29 31 35 37 ...

J'utilise ces facteur dans cet ordre.

Mais j'arrête en fonction de la valeur de B (en fait un niveau de la racine carrée).

Comme les entiers entre A et B se suivent, il est facile de repèrer les nombres multiples uniquement à partir de la valeur de A.

On effet, (-A MOD F) donnera l'offset des multiples de F, c'est à dire leur position dans la succession de A à B. Tout ce passe comme si l'indice de A était 0, A+1 l'indice est 1, etc...

Pour ne pas refaire les tests, j'utilise un tableau de booléens pour marquer les nombres premiers (Vrai) et les composé (Faux). On pourrait utiliser ce tableau pour mémoriser le facteur de multiplicité qui a servi (ce peut être utile pour la mise au point du programme !).

Par exemple si je cherche à donner la nature des nombres entre 10 et 25
Je commence par chercher la position des multiples de 2.
On a -10 MOD 2 qui fait 0.
Donc les multiples de 2 sont 10 12 14 16 18 20 22 et 24 (offset 0, 2, 4, 6, 8 10 12 et 14).
J'enregistre que ces nombres sont composé dans le tableau PRIM(0 2 4 6 9 10 12 14) F Alors Marquer le nombre i comme étant composite PRIM(i) F THEN P(I)=F
50 : NEXT I
55 : F=NF : S=-S : IF S<0 THEN N=N+1
60 : NF=6*N+S
65 LOOP
70 PRINT : PRINT
75 FOR I=A TO B
80 : PRINT I;" en nombre ";
85 : IF P(I)=0 THEN PRINT "premier." ELSE PRINT "composé ( x";P(I);")"
90 NEXT I
95 END
[/CODE]


Exemeple d'exécution :

Code: Tout sélectionner

ENTER intervalle [ A , B ] ?  100,120
Testing 2 3 5 7

 100 est composé ( x 5 )
 101 est premier.
 102 est composé ( x 3 )
 103 est premier.
 104 est composé ( x 2 )
 105 est composé ( x 7 )
 106 est composé ( x 2 )
 107 est premier.
 108 est composé ( x 3 )
 109 est premier.
 110 est composé ( x 5 )
 111 est composé ( x 3 )
 112 est composé ( x 7 )
 113 est premier.
 114 est composé ( x 3 )
 115 est composé ( x 5 )
 116 est composé ( x 2 )
 117 est composé ( x 3 )
 118 est composé ( x 2 )
 119 est composé ( x 7 )
 120 est composé ( x 5 )
ready.


[Rockleader]

Ok, j'ai compris l'idée, par contre si je devais la mettre en pratique dans un programme, je sais pas si j'en serais capable, car pour tout vous dire j'ai un peu de mal avec les booléen.


Je comprends la définition qui dit que le booléen est censé ne pouvoir prendre que deux valeurs souvent 0 et 1, mais je n'en vois pas tellement l’intérêt d'avoir créer un type de variable exactement pour ça.
Car après tout, une variable de type integer donc entière, aurait le même effet avec des conditions qui n'accepterait que deux valeurs pour cette variable non ?

J'ai surement compris de travers, mais c'est vrai que j'ai un peu de mal avec les booléens, ça n'a pas pourtant l'air bien compliqué...

[C.Ret]

Bonjour,

ttention, il ne faut pas confondre la logique et son implémentation dans une machine donnée.

Un booléen c'est uniquement VRAI ou FAUX.


Après, le codage binaire numérique ou autre de ces deux valeur est quelque chose de diffèrent et il n'y a pas à s'en pré-occuper lors de la conception du programme. La valeur 0 ou 1 ( ou tout autres codes utilisé pour encoder FAUX ou VRAI) c'est uniquement quelque chose qui concerne la réalisation pratique du code sur une machine ou dans un système donné.

Si B est un booléen, on interpréte directement
IF B THEN { tache réalisée si B est vrai } ELSE { tache réalisée si B est faux } END IF

Dans la plupart des cas, on précise pour faciliter la lecture :

IF B est vrai THEN faire-ceci ELSE faire-cela END

C'est pour cela qu'il faut suivre le conseil très important que Fatal-Error a donné; lorsuqe l'on compose un algorithme, il ne faut pas le faire dans un language donné car sinon la maitrise des détail de ce language va interférer avec la logique et l'optimisation des astuces.

D'où l'idée d'écrire l'algorithme en pseudo-code pour s'affranchir de toute influence ou confusion avec une façon de faire ou de coder lié à un language donné.

Par exemple, le programme BASIC que j'ai donné ci-dessus n'aide pas à composer le programme équivalent en C, en PASCAL ou en ADA et encore moins en LISP ou J

Pourtant il suit scrupuleusement l'algorithme que j'ai indiqué précèdemment.

C'est pour cela, les excercice de ton prof nécessite une démarche en trois étapes :
-1 - interpréter le code donné; il faut utiliser ses connaissance en ADA pour bien comprendre les mécanismes et être capable de faire à la main le travail de la machine.

-2- analyser l'algorithme et l'optimiser afin d'en composer un qui corrige les travers et défauts du premier. Notons qu'à cette étapes, il n'y a plus besoin de connaissance en ADA; par contre il faut se documenter;
Qu'est-ce qu'unnombre premier ?
Quelle sont les algorithme utiliser pour les déterminer, les tester ?
Quelle loi ou propirété mathèmatiques de ce type d'objet peut être miese à contribution ?

-3- recomposer un code pour le tester sur une machine; il faut là avoir à nouveau des connaissance et compétence dans un lnguage de programmation. Par contre, ce n'et pas nécessairement en ADA. C'est ce que j'ai fais car j'avais sous la main (dans la poche en fait) une machine fonctionnant facilement en BASIC (language résident).


Ton prof n'est pas un prof d'informatique (comme ceux qui vous apprennent à cliquer sur les icones, ouvrir un fichier, utiliser un tableur, éteindre son ordinateur, se connecter à Internet), c'est un analyste programmateur.
De la même façon que tu dois bien comprendre quand tu es dans le système d'exploitation de l'ordinateur, sous Excel ou dans un jeu en ligne; il faut que tu fasse la diffèrence entre l'analyse et la programmation.

[Rockleader]

La méthode que tu as décrite je pense l'avoir bien saisi.

(C'est vrai que l'algorithme je l'ai posté en ADA et j'ai mal fais, mais je l'avais bien évidemment fait au préalable en pseudo code français).






Pour les booléen si j'ai bien compris, au final c'est simplement pour dire si une condition est vraie ou fausse ?
Seulement ensuite quand on code ce booléen, on va luit affecter des valeur (0 ou 1 le plus souvent) mais je pourrais très bien choisir arbitrairement autre chose comme O pour vrai et N pour faux.

[fatal_error]

Pour les booléen si j'ai bien compris, au final c'est simplement pour dire si une condition est vraie ou fausse ?

non.
Un booleen, c'est une variable. Pas une condition. Une variable. qui ne peut stocker que deux valeurs. Savoir ce que le booleen stocke, ca dépend à quel niveau tu regardes. Si tu regardes au niveau langage, alors probablement True ou False, si tu regardes au niveau machine, alors 0 ou 1.

mais je pourrais très bien choisir arbitrairement autre chose comme O pour vrai et N pour faux.

Si ton langage t'autorises...as-tu essayé?

[Rockleader]

Si ton langage t'autorises...as-tu essayé?

Pas vraiment, j'ai déjà du mal avec le cas basique.

Par exemple, en TD on a eu un exo sur les booléens, et j'avoue que j'ai pas compris...

on nous disait a et b sont des booléens, et il fallait simplifier des expressions.


False and a donnait false
true and a donnait a
true or a donnait true
not(not(not(b))) donnait not b


Rien que quelque chose d'aussi élementaire que ça, j'ai pas saisi le sens que ça avait...

[fatal_error]

Pas vraiment, j'ai déjà du mal avec le cas basique.

ca n'a rien à voir.

savoir comment ca marche, ca n'a rien à voir avec savoir comment ca s'utilise.

Est-ce que tu sais si tu as le droit d'assigner O à une variable booléenne en ADA?
si tu le sais pas, essaies d'écrire la syntaxe, ou recherche sur le net.

Concernant le problème de compréhension des booléens, prends toi un tutoriel sur l'algebre de boole. Par exemple le sdz

[C.Ret]

Bien le site Tutorial, dommage ils utilisent la convention 0/1 pour illustrer les états Faux/Vrais, ce qui va pas aider notre ami à faire la différence entre la logique booléenne et sa représentation informatique.

En ADA est un language extrêmement typé avec un contrôle dynamique rigoureux (digne héritier du PASCAL en se sens).

Par défaut le type le type booléen en ADA correspond à :

Code: Tout sélectionner

 TYPE Boolean IS (False, True);


Il s'agit donc d'un type d'énumération.


En fonction du paramètrage et de les régles de l'environnment utilisées, on peut avoir (généralement on n'a pas) le droit de redéfinir un type système prédéfinit; mais on peut facilement définir son propre type:

Code: Tout sélectionner

  TYPE RockLeader_Boolean IS ( 0 , 1);

  Cond: RockLeader_Boolean;

 IF Cond THEN ... ELSE ... END IF


Le soucis est lorsque l'on voudra utiliser une variable de ce type avec les opérateurs définis par défaut et donc pour le type système Boolean.
C'est pour cela qu'en général on n'overload pas un type aussi basique.