PI - 1211

[Ben]

J'essaie de faire calculer les décimales de PI au PC-1211. Avec si peu de mémoire, c'est du sport

[leglatin]

Déjà lui en faire calculer 1 kilo ça prends trois plombles, alors si on pouvait l'étendre à 16 Ko ça prendrait des mois

[gege]

Bonjour,
Un article sur ce thème est paru dans Science & vie opposant PC1211, TI59 et HP 41 (ou 67, je ne sais plus).
On en a parlé sur le fofo.
Fais-nous partager ta tentative !
G.E.

[badaze]

Quelle mémoire ce gégé !
(J&S)

http://www.emmella.fr/page5799-6061-650 ... -3148.html

[Tipoucet]

A la page 58 paragraphe 4 de l'article montré par Badaze, je lis ce passage douloureux

il lui faut 28h pour calculer 250 chiffres de pi. Il est vrai que ce temps a pu être ramené à 14h par M. Molinaro grâce à des procédés subtils qui demandent de très bien connaître la machine

.
J'ai des vieilles machines, je suis content de jouer un peu avec, je sais les faire tourner, mais je n'ai pas cette connaissance intime qu'avaient tous les utilisateurs chevronnés (et que j'avais de ma TI-57). Cela appartient au passé, le vrai, et tenir en main en 2016 un HP67, ce n'est qu'effleurer ce passé ... Aïe ...

A + bon dimanche

[leglatin]

Il avait été dit dans cet article que la TI-57 ne pouvait pas effectuer ce genre de calcul,étant dépourvue d'aressage indirect. Qulques numéros plus tard, un complément à cet article fut paru, affirmant le contraire, notamment par un lecteur qui y avait réussi à programmer le calcul le Pi avec 57 chiffres mais sans, toutefois, en publier le programme...

J'avais alors voulu moi-même relever ce défi, et après quelques années, j'avais finalement réussi à écrire un tel programme. Il avait fallu regorger d'astuces, mais finalement ça avait fini par rentrer dans les 50 pas...

[gege]

Bonjour,
...et ?
Peux-tu nous montrer ce programme ?
Tu me tues avec ce suspens !
Je ne vois pas comment faire.
G.E.

[Ben]

Quelle mémoire ce gégé !
(J&S)

http://www.emmella.fr/page5799-6061-650 ... -3148.html

Merci pour le lien J'aurais peut être dû le lire avant de me lancer là dedans.

Bonjour,
...et ?
Peux-tu nous montrer ce programme ?
Tu me tues avec ce suspens !
Je ne vois pas comment faire.
G.E.

Je vous envoie ça ce soir.

C'est un code que j'ai chopé sur le net et que j'ai adapté d'abord sur un commodore 128. Il utilise un tableau pour stocker les valeurs intermédiaires. Evidemment, plus de mémoire disponible, plus le nombre de décimales peut être important.

Je vous mets le code du C128 (j'ai l'émulateur sous la main).

Code : Tout sélectionner

10 fast
20 color 5,6
30 scnclr:pudef "0"
40 print "calcul des decimales de pi"
50 print "--------------------------"
60 print "ql affichage se fait par bloque de 4 chiffres, donc le nombre de decim
ales doit":print "toujours etre un multiple de 4."
70 input "qcombien de decimales voulez-vous";li
80 if li/4=int(li/4) then 110
90 print "qattention, il faut un multiple de 4!"
100 goto 70
110 print:t=ti
120 li=int(li*3.32)
130 ca=0
140 dim ar(li)
150 for i=1 to li
160 ar(i)=2000
170 next i
180 for i=li to 1 step -14
190 su=0
200 for j=i to 1 step -1
210 su=su*j+10000*ar(j)
220 d=j*2-1
230 ar(j)=su-(int(su/d)*d)
240 su=int(su/d)
250 next j
260 print using "####";int(ca+su/10000);
270 ca=su-(int(su/10000)*10000)
280 next i
290 print:print "qtemps de calcul:";int((ti-t)/60);"sec"

Le lien pour le code
Je me suis inspiré de la version en C

[leglatin]

Peux-tu nous montrer ce programme ?
Tu me tues avec ce suspens !
Je ne vois pas comment faire.
G.E.

Désolé, le reste du dimanche je n'étais pas at thome...

Pour ma peine, deux prgms TI-57 pour le prix d'un : e et Pi

On commence par le calcul le plus simple : e. L'algorithme pour en obtenir les chiffres est une boucle de calcul ; plus on fait de boucles, plus on a de décimales. La boucle permettant d'obtenir e est la suivante (exemple de 10 boucles) : On prend 1, On divise par 10 puis on ajoute 1, qu'on divise par 9 puis on ajoute 1, su'on divise par 8 puis on ajoute 1 etc... Jusqu'à ce qu'on divise par 1 (inutile, en fait) puis on ajoute 1 : on obtient e.

Pour avoir n chiffres exacts, il faut faire un nombre de boucles b égal à Int(Log(n!)). Par exemple 64 chiffres il faudra faire 50 boucles (car la factorielle 50! = 3,0414093201 E64.)

Mon prgm peut calculer jusqu'à 64 chiffres. Chaque mémoire de la 57 peut contenir 11 chiffres, il en faut deux pour l'opérateur (b), reste donc 9 pour l'opérande : : 9*7=63 décimales + le chiffre des unités = 64.

Le listing :

Code : Tout sélectionner

00  32 0 STO 0     Nombre de boucles dans R0
01  86 0 Lbl 0     Boucle principale Dsz, de b à 1
02  33 0 RCL 0     Rappel du diviseur en cours : remplace le "+ 1" de la formule
03  61 1 SBR 1
04  61 1 SBR 1
05  61 1 SBR 1
06  61 1 SBR 1  
07  61 1 SBR 1
08  61 1 SBR 1
09  61 1 SBR 1     On fait 7 fois le calcul, car i y a 7 mémoires à traiter
10  56   Dsz       On baisse b de 1
11  51 0 GTO 0     Si B>0, c'est pas fini.
12  33 1 RCL 1     Si b=0 on arrête avec R1 affiché. Ouf.
13  81   R/S
14  86 1 Lbl 1	   Traitement d'une mémoire
15  42   EE
16  09   9
17 -42   INV EE
18  34 1 SUM 1     On ajoute le "+ 1" initial ou le modulo (voir pas 28 à 32) à R1
19  89   x         (Moyenne de x) on divise R1 par R0
20  49   Int       On garde que l'Int
21  38 7 Exc 7     Une fois la division faite de R1, on met le résultat dans R7
22  38 6 Exc 6     On met R7 dans R6
23  38 5 Exc 5     R6 dans R5
24  38 4 Exc 4     etc...
25  38 3 Exc 3
26  38 2 Exc 2
27  38 1 Exc 1     R2 dans R1 (Au prochain SBR1, ce sera donc R2 qui sera traité etc...), on récupère l'ancien R1
28  65   -
29  33 0 RCL 0
30  55   X
31  33 7 RCL 7     Contient le nouveau R1
32  85   =         On calcule le modulo à reporter...
33 -61   INV SBR   ...et on retourne pour traiter les autres mémoires, ou pour la boucle suivante

Saisir RST, b, R/S. Sur TI-57 "normale", ça dure environ 1/4 heure pour 64 décmales, je crois. Dans ce cas, on obtient :
RCL 1 = 2.718281828 E9
RCL 2 = 4.59045235 E8
RCL 3 = 3.60287471 E8
RCL 4 = 3.52662497 E8
RCL 5 = 7.57247093 E8
RCL 6 = 6.99959574 E8
RCL 7 = 9.66967627 E8

e = [RCL 1]/10^9+[RCL 2]/10^18+[RCL 3]/10^27+[RCL 4]/10^36+[RCL 5]/10^45+[RCL 6]/10^54+[RCL 7]/10^63
-> e = 2,718281828459045235360287471352662497757247093699959574966967627...

Le calcul de Pi est semblable, mais un peu plus complexe : Là pour chaque boucle, il faut multiplier par b puis, diviser par 2b+1, enfin ajouter 2.
Dans l'article de Renaud De La Taille, les prgms font une boucle pour la multiplication puis une boucle pour la division. Sur la 57, pas le choix : il faut faire les deux dans la même boucle... et déjà c'était pas gagné que ça rendtre dans 50 pas...

Pour avoir n chiffres exacts, il faut faire un nombre de boucles b égal à Int(n/log 2). Par exemple pour avoir les 57 chiffres il faudra faire 189 boucles.

Là on ne peut avoir que 57 chiffres : Par mémoire il faut non pas deux mais trois chiffres pour l'opérateur (b), reste donc 8 pour l'opérande : 8*7=56 décimales + le chiffre des unités = 57.

Le listing : (Je vous laisse l'analyser...)

Code : Tout sélectionner

00  32 0 STO 0
01  86 0 Lbl 0
02  33 0 RCL 0
03  34 0 SUM 0
04  38 0 Exc 0
05  61 1 SBR 1
06  61 1 SBR 1
07  61 1 SBR 1
08  61 1 SBR 1  
09  61 1 SBR 1
10  61 1 SBR 1
11  61 1 SBR 1
12  56   Dsz
13  51 0 GTO 0
14  08   8
15 -18   INV Log
16  34 1 SUM 1
17  34 1 SUM 1
18  33 1 RCL 1
19  81   R/S
20  86 1 Lbl 1
21  42   EE
22  09   8
23 -42   INV EE
34  38   Exc 0
25  39 1 Prd 1
26  38 0 Exc 0
27  34 1 SUM 1
28  02   2
29  39 0 PRD 0
30  01   1
31  34 0 SUM 0
32  89   x (Moyenne de x)
33  49   Int
34  38 7 Exc 7
35  38 6 Exc 6
36  38 5 Exc 5
37  38 4 Exc 4
38  38 3 Exc 3
39  38 2 Exc 2
40  38 1 Exc 1
41  65   -
42  33 0 RCL 0
43  55   X
44  56   Dsz
45  02   2
46 -39 0 INV Prd 0
47  33 7 RCL 7
48  85   =
49 -61   INV SBR

Saisir RST, b, R/S. Là, sur TI-57 "normale", il faut compter une heure. On obtient :

RCL 1 = 3.14159265 E8
RCL 2 = 35897932
RCL 3 = 38462643
RCL 4 = 38327950
RCL 5 = 28841971
RCL 6 = 69399374
RCL 7 = 1.10582097 E8
Pi=[RCL 1]/10^8+[RCL 2]/10^16+[RCL 3]/10^24+[RCL 4]/10^32+[RCL 5]/10^40+[RCL 6]/10^48+[RCL 7]/10^56. -> pi=3,14159265358979323846264338327950288419716939937510582097...

Voilà. Finalisés en 1992, j'avais essayé de les optimiser au mieux... A savoir que l'astuce des Exc successifs pour remplacer l'adressage indirect (partiellement évoqué dans l'article complémentaire de S&V) provient du TI PPC Notes : un astucieux programmeur avait proposé à l'époque un prgm de calcul de factorielle avec tous les chiffres...

[Ben]

Voici le code pour le PC1211

Code : Tout sélectionner

10 for a(127)=1 to 39
15 a(a(127))=2000
20 next a(127)
30 a(127)=39:a(131)=0
40 a(129)=0
50 for a(128)=a(127) to 1 step -1
60 a(129)=a(129)*a(128)+10000*a(a(128))
70 a(130)=a(128)*2-1
80 a(a(128))=a(129)-(int (a(129)/a(130))*a(130))
90 a(129)=int(a(129)/a(130))
100 next a(128)
105 beep 1
110 print int(a(131)+a(129)/10000)
120 a(131)=a(129)-(int a(129)/10000)*10000)
130 a(127)=a(127)-14
140 if a(127)>0 then 40

Le code gagnerait sûrement en efficacité en mettant regroupant plusieurs lignes

[C.Ret]

Certes, il gagnerai en efficacité, mais il perd aussi en lisibilité:

Par exemple, j'ai "compilé" le code ci-dessus en regroupant les lignes, mais aussi en décalant les registres afin d'éviter les A(127), ... A(131) qui font perdre mémoire, lisibilité et efficacité lors e l'exécution.

Code : Tout sélectionner

1:CLEAR :A=44
2:C=0:FOR B=A TO 6 STEP -1:IF F=0 LET A(B)=2Ê3
3:C=CB+Ê4A(B),D=2B-11,A(B)=C,C=INT (C/D),A(B)=A(B)-CD:NEXT B
4:BEEP 1:PRINT INT (E+Ê-4C):E=C-Ê4*INT Ê-4C,A=A-14:IF A>0 GOTO 2

où
 Ê  et le caractère "E gras" qui correspond à la touche exposant de dix [Exp] 

Les registres sont décalés,  a(1) est mémorisé en F - c'est à dire en  A(6) - afin de pouvoir utiliser les registres A, B, C, D et E pour les calculs et indices
1  :127:A
2  :128:B
3  :129:C
4  :130:D
5  :131:E
6  :  1:F
7  :  2:G
8  :  3:H
  ...
44 : 39 

J'utilise également à outrance la multiplication implicite pour économiser parenthèse.

L'initialisation des termes a(...) à 2000 est fait en ligne 2: lors de la première boucle de calcul. 

Je n'ai pas mon PC-1211sous la main, je testerai mercredi prochain

[Ben]

J'avais pensé inverser l'utilisation des variables, variables de travail devant (A,B,C, ...) et ensuite le tableau. Mais j'avais lu quelque part que pour le PC1211, c'est plus efficace d'utiliser les variables en "fin de zone". En clair, c'est mieux de faire

Code : Tout sélectionner

for z=1 to ...

que

Code : Tout sélectionner

for a=1 to ...