Discussion :

[wiwaxia]

@ wiwaxia: ... Pascal est en effet plutôt clair comme langage; mais comme ton code restait pour moi obscur dans son but. Je l'ai compilé avec "Free pascal.
Il m'est sorti: "Illegal parameter: -Opentium3" ...

Je ne connais pas la signification de ce message, mais l'absence de plantage m'aurait stupéfait: il n'apparaît ici que le quart du programme !
Le but n'était pas la résolution de l'énoncé, mais de montrer le développement progressif et rationnel d'un code source, qui reste exécutable à chacune des étapes de sa croissance.

Je tâcherai de poster la version light qui se limite à l'inventaire des fractions et de leur valeur numérique. j'aurais dû le faire avant, car le programme s'est depuis alourdi de nouvelles tâches.

... Sales bêtes !

Mais non, mais non, il faut se montrer sympa avec les compilateurs, ils peuvent vous rendre de grands services (la preuve: #37).

[valentin03]

Je ne connais pas la signification de ce message, mais l'absence de plantage m'aurait stupéfait: il n'apparaît ici que le quart du programme !
Le but n'était pas la résolution de l'énoncé, mais de montrer le développement progressif et rationnel d'un code source, qui reste exécutable à chacune des étapes de sa croissance.

Ah ben d'accord, pas étonnant que je n'ai pas compris le but de l'ensemble.
Je me suis vu les pierres pour faire fonctionner gcc, je suppose que pour Pascal c'est la même bière; vive les interpréteurs.

[wiwaxia]

Voici le programme (*.pas) accompagné d'un second fichier à inclure (*.inc), qui contient les identificateurs et les procédures de confort - la dernière extension ".pas" doit être supprimée.
Il a suffi de "détricoter" le programme en chantier selon le processus inverse de celui précédemment décrit (#37) pour obtenir la version souhaitée.

On voit apparaître sur l'écran les listes d'entiers qui se vident ou se remplissent à partir de la droite (L*E, T*E).

En-dessous figurent les valeurs extrêmales de la fraction composée, et les séquences correspondantes pour les (N) tours de boucle effectués (valeur affichée en rouge):

L'enfoncement d'une touche de clavier arrête l'énumération et fait afficher les valeurs instantanées de la fraction courante de deux manières différentes,
- à partir des deux termes entiers des trois fractions successives (P₁/Q₁ , P₂/Q₂ , P₃/Q₃), puis calcul de la valeur réelle du dernier rapport (P₃/Q₃); le résultat final est consigné dans la liste d'enregistrements:
w = a + (P₃/Q₃) ;
- par le calcul des 4 quotients successifs - selon l'ordre naturel imposé par l'écriture de la fraction
Q = a + b/(c + d/(e + f/(g + h/i))) , dont le grave inconvénient est de cumuler des erreurs d'arrondi:

L'écart, généralement nul, ne dépasse pas 10^-19 ou 10^-18 en valeur absolue, et s'accorde avec la précision limite du logiciel (2^-63).
L'énumération reprend en ré-appuyant sur une touche du clavier.

Si cette digression brouille ta compréhension de l'algorithme, tu peux éliminer l'appel de l'affichage temporaire (AffTemp) en modifiant la fin de la ligne (132):

Code :

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

 ... ; A_ // AffTemp

L'énumération s'arrête alors à chaque étape, ce qui te donneras le loisir de contrôler la succession des 362880 combinaisons .
La suppression de l'instruction d'arrêt (A_) laisse l'énumération se dérouler jusqu'à son terme.

Ceci dit le démontage de ce programme peut constituer une bonne initiation au Pascal (version Virtual Pascal, disponible sur un site réputé pour Programmeurs Développeurs Pro).

Bon courage

Fraction9Chiffres_00.pas

Utilitaire.inc.pas

[tbc92]

Tu parles d'erreurs d'arrondis (négligeables, certes), mais puisque tu en parles, faisons ce qu'il faut pour les corriger.
Tu peux réduire au même dénominateur et reformuler l'expression F, pour que ce soit juste une division de 2 entiers (une seule division, au lieu de 4 divisions successives)
g+h/i, tu peux le réécrire en (gi+h)/i
f/(...), ça donne : fi/(gi+h)
e+(...) , ça donne : (egi+eh+fi)/(gi+h)
d/(...), ça donne : (dgi+dh)/(egi+eh+fi)
c+(...), ça donne : (cegi+ceh+cfi+dgi+dh)/(egi+eh+fi)
b/(...), ça donne : (begi+beh+bfi)/(cegi+ceh+cfi+dgi+dh)
et enfin, a+(...), ça donne : (acegi+aceh+acfi+adgi+adh+begi+beh+bfi)/(cegi+ceh+cfi+dgi+dh)
A vérifier quand même sur quelques valeurs.

Des additions /multiplications d'entiers, puis une division, tu réduis les erreurs d'arrondis.

[wiwaxia]

C'est précisément ce qui est fait par le programme:

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
 PROCEDURE EnumIghi
 ... / ...
                 P1_:= Tghi[Max - 2] * Tghi[Max];          // P1 = g*i + h
                 Inc(P1_, Tghi[Max - 1]); Q1_:= Tghi[Max]; // Q1 = i

 PROCEDURE EnumIdef
 ... / ...
                 P2_:= 0; Inc(P2_, Tdef[Max - 2] * P1);   // P2 = d * P1
                 Q2_:= 0; Inc(Q2_, Tdef[Max - 1] * P1);   // Q2 = e * P1 + f * Q1
                 Inc(Q2_, Tdef[Max] * Q1);

 PROCEDURE EnumIabc
 ... / ...
CalcFr(P2, Q2, T9E, ListeF[Ntb])
 ... / ... p:= T_9[2] * Q2_; q:= T_9[3] * Q2_;            // P3 = b * Q2 ; Q3 = c * Q2 + P2
     Inc(q, P2_);  r:= p / q;        s:= r + T_9[1];      // seul quotient carculé
     Frac.w:= s                                           // w = a + P3 / Q3

Calcul niveau CM₂ exécuté en précision absolue jusqu'à la dernière fraction.
L'algorithme évite les répétitions inutiles, et minimise le nombres d'opérations sur les entiers.

C'est le calcul en option qui travaille sur les réels:

Code :

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

1
2
3
4
5
6
7
8
9
10
 PROCEDURE CalcFr2(y: Byte; Frac: Fr_9ch);
   CONST C1 = 2; L1 = 15; Ca = 3; Cb = 14;
   VAR m: Byte; q, s: Reel;
   BEGIN
     WITH Frac DO  BEGIN
                     q:= t[8] / t[9]; s:= q + t[7];      //  S1 = g + h/i
                     q:= t[6] / s;    s:= q + t[5];      //  S2 = e + f/S1
                     q:= t[4] / s;    s:= q + t[3];      //  S3 = c + d/S2
                     q:= t[2] / s;    s:= q + t[1];      //  S4 = a + b/S3
                   END;

[Jipété]

'lut,

Voici le programme (*.pas) accompagné d'un second fichier à inclure (*.inc)

Où ça ?

T'aurais pas oublié le zip ou similaire ?

[wiwaxia]

... Où ça ?
T'aurais pas oublié le zip ou similaire ?

Effectivement, les dossiers en pièces jointes n'avaient pas suivi
Merci pour le signalement !

[valentin03]

Avec Virtual Pascal:
Make ---> Utilitaire.inc not found
Suppression de: ".pas" dans: "Utilitaire.inc.pas"
Make: --> Success
Build: --> Success
Mais où il a mis la chose buildée ?
Bon, c'est pas grave, c'est pas les résultats qui m'intéressent, c'est le code. et comme y a Success c'est qu'y a pas de lézard. Go on brain storming...

[Jipété]

Avec Virtual Pascal:
Make ---> Utilitaire.inc not found

Sans blague ? C'était pourtant écrit là :

Voici le programme (*.pas) accompagné d'un second fichier à inclure (*.inc), qui contient les identificateurs et les procédures de confort - la dernière extension ".pas" doit être supprimée.

À moi avec Free Pascal :

Code bash :

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

1
2
3
4
5
6
7
8
9
10
11
12
13
14
# fpc Fraction9Chiffres_00.pas 
Free Pascal Compiler version 2.6.2 [2013/03/17] for i386
Copyright (c) 1993-2012 by Florian Klaempfl and others
Target OS: Linux for i386
Compiling Fraction9Chiffres_00.pas
Fraction9Chiffres_00.pas(19,19) Note: Local variable "P3" not used
Fraction9Chiffres_00.pas(19,31) Note: Local variable "Q3" not used
Linking Fraction9Chiffres_00
252 lines compiled, 0.3 sec 
2 note(s) issued
# ls -rC1 Fr*
Fraction9Chiffres_00.pas
Fraction9Chiffres_00.o
Fraction9Chiffres_00

Bravo, wiwaxia, c'est très joli (sauf que ça m'a fait disparaître le curseur dans la fenêtre du terminal, mais ça n'est franchement pas grave, pi il suffit de taper une commande pour le voir revenir)

[wiwaxia]

Les notes:

Code :

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

1
2
Fraction9Chiffres_00.pas(19,19) Note: Local variable "P3" not used
Fraction9Chiffres_00.pas(19,31) Note: Local variable "Q3" not used

m'ont un peu intrigué: effectivement, le calcul de la fraction se termine dans CalcFr(P2, Q2, T9E, ListeF[Ntb]), sans appel des variables globales (P3, Q3) que l'on peut supprimer.

Vraiment bien, le Free Pascal.