Misez p'tit, optimisez n°60 : Calculons Pi comme Viète

[remy]

Très bien vu le CLEAR Jérôme. C'est moins cher qu'un B=0.

[jvernet]

Très bien vu le CLEAR Jérôme. C'est moins cher qu'un B=0.

On peut faire encore mieux avec les Sharp, avec la touche DEF. Sauf que je sais plus comment ça marche: tu tapes 10 DEF A
en mode RUN et tu peux lire la valeur tapée avec le DEF A dans le programme. Je faisais ça tout le temps avec mes programmes. MAIS tu ne peux pas utiliser CLEAR.

Tiens, je viens d'acquèrir un 1246S. Quelle merde . Mais j'adore ces machine: le 1247 est mon tout premier ordinateur. Quand est ce que tu nous colle ça dans Pockemul ?


JV

[remy]

C'est le AREAD qui permet de lire la valeur à l'cran et la stocker dans une variable.

Code : Tout sélectionner

10 "A" AREAD C

Mais ça prend le même nombre d'octets qu'un INPUT C

Le 1247 utilise le proc SC61720, pas d'info donc pas d'émulo.
Mais tu peux utiliser le PC-1245 qui lui est émulé dans PockEmul. Tu peux même le programmer en C (enfin je crois, je ne souvient plus si j'ai développé les libs pour ce modèle)

[Gilles59]

Sur certains langages, il doit être possible d'augmenter la precision (le nombre de decimales), par exemple avec un double en c. Les BASIC Microsoft avaient cette possibilité, quels autres ?

Sur les HP49G+/50G avec la library long float 3.93 on peut calculer avec un nombre arbitraire de chiffres significatifs (la seule limite est la mémoire)

Exemple:

Code : Tout sélectionner

20 'DIGITS' STO      @ Calculer avec 20 chiffres significatifs
'COS(PI/6)' ->FNUM   @ Evaluer la formule en 'long float'

0.86602540378443864676

Code : Tout sélectionner

«
 'DIGITS'     STO  @ Nombre de chiffres significatifs pour les calculs
 'N'          STO  @ Nombre d'itération pour calculer PI
 2 R<->F 'F2' STO  @ 2 en réel long

 0 R<->F F2
 1 N START
     F2 FMULT SWAP F2 FADD FSQRT DUP UNROT FDIV 
 NEXT
 
 NIP
»
'FViete' STO

Usage :
Nb_Itération Nb_chiffres_significatifs FViete

Ex :
170 102 FViete

retourne en 170 itérations les 100 premières décimales de PI correctes :

Code : Tout sélectionner

314159265358979323846264338327950288419716939937510582097494459230781640628620899862803482534211706786.E-101

[/size]

Cette library est vraiment très bien faite.Par exemple, la fonction ->FNUM calcule toute formule algébrique exacte (CAS) avec la précision souhaitée (100 décimales si vous voulez ou bien plus même). Genre 'PI' ->FNUM vous donne les 1000 premières décimales de PI ! Voilà une library qui va rester sur mon HP ;D

[gege]

Bonjour,
C'est impressionnant, mais il utilise une librairie toute faite...
Ca serait sympa un truc 100% fait sur la calculatrice.
G.E.

[Gilles59]

Bonjour,
C'est impressionnant, mais il utilise une librairie toute faite...
Ca serait sympa un truc 100% fait sur la calculatrice.
G.E.

Salut Gege !
Je sens bien C.RET sur ce coup ;D

[babaorhum]

Bonjour à tous,

... suis très en retard sur ce MPO ... j'ai bricolé ma proposition ce soir sur ma 42S, qui ressemble à la belle proposition de zpalm avec sa 41C :

Code : Tout sélectionner

01 LBL "V"
02 2
03 ENTER
04 LBL 01
05 SQRT
06 STO / ST Y
07 2	
08 STO x ST Z
09 +	
10 DSE ST Z
11 GTO 01
12 X<>Y

Entrer le nombre d'itérations voulues et XEQ "V" -
Ma HP indique une taille de 22 byte pour ce petit programme.

Je suis au max de la précision de la machine avec un 19 XEQ"V" qui trouve 3,14159265364 en 3 secondes. Je remarque que la valeur de Pi est donné (sur la même machine ) par 3,159265359 soit un écart de 5E-11. J'obtiens donc la valeur de pi avec une précision inférieure à 1E-10 , pas mal quand même !

Il était fort ce VIETE et elle est toujours aussi chouette ma 42s !!!

[badaze]

Quatrième jet pour TI 57 II. Si on peut entrer le nombre d'itérations.
16 pas. Donne 3.1415914 pour 10 itérations en 14,5 secondes.

Code : Tout sélectionner

CM
STO 0
2
STO 2
LBL 1
2
STO + 1 (SUM 1 sur TI 57 LED)
STO X 2
RCL 1
Racine x
STO 1
STO / 2 (Inv Prd 2 sur TI 57 LED)
Dsz
GTO 1
RCL 2
R/S

[Gilles59]

Une adaptation directe de la version CASIO 602P ...

Code : Tout sélectionner

SAC 
Min00 
2 
LBL0
 * 2  / 2 M+08 MR08 √ Min08 
DSZ GOTO0
=

[/size]

... pour TI57 classique :

Code : Tout sélectionner

C.T
STO 0
2
LBL1
* 
2 
/ 
2 
SUM 7
RCL 7
SQRT
STO 7
DSZ
GTO 1
= 
R/S

donne 3.1415914 pour 10 boucles.
je ne sais pour le temps l'émulateur étant beaucoup plus rapide....

Testé sur l'émulateur TI57 de la HP50 (qui s'appuie sur le microcode TI 57, voir http://www.hrastprogrammer.com/emulators.htm
16 pas soit 1 pas de plus que la 602 à cause du R/S

La version de Badaze sur TI57 II s'adapte facilement sur TI 57 classique :
Remplacer CM par C.T (je n'ai trouvé de CM sur TI57 "classique",ou j'ai loupé un truc ??)
Remplacer la mémoire 1 par la mémoire 7

[Gilles59]

Quatrième jet pour TI 57 II. Si on peut entrer le nombre d'itérations.
16 pas. Donne 3.1415914 pour 10 itérations en 14,5 secondes.

J'ai l'intuition qu'il va être difficile de faire mieux ...
Belle optimisation depuis le début ;D

[Gilles59]

Et un octet de plus gagné sur 502/602/603 ;D

14 pas :

Code : Tout sélectionner

SAC
Min00
2
LBL0
 * 2 M+08 / MR08 √ Min08
DSZ GOTO0
=

[Hobiecat]

J'ai l'intuition qu'il va être difficile de faire mieux ...
Belle optimisation depuis le début ;D

L'expérience des MPO montre qu'il ne faut jamais dire jamais, même s'il est vrai que sur ces dernières versions, il semble ne plus y avoir grand'chose à gagner...

[Marge]

Une adaptation directe de la version CASIO 602P ...

Code : Tout sélectionner

SAC 
Min00 
2 
LBL0
 * 2  / 2 M+08 MR08 √ Min08 
DSZ GOTO0
=

[/size]

... pour TI57 classique :

Code : Tout sélectionner

C.T
STO 0
2
LBL1
* 
2 
/ 
2 
SUM 7
RCL 7
SQRT
STO 7
DSZ
GTO 1
= 
R/S

Je ne comprends les calculs *2/2 dans les deux programmes.

[C.Ret]

Je sens bien C.RET sur ce coup ;D

Je le suis effectivement, mais avec un peu de retard, j'étais à l'usine tout mon W.E..

La version multiprécision pour HP-28S ressemble pour le moment à cela :

Code : Tout sélectionner

VVIETE:
1:                   { size }  @  Taille multiprécision
« 0 CON                        @  0.000…0 avec 6*(s-1) décimales
  DUP                          @  Copy valeur pour test de fin
  DUP 1 2 PUT                  @  2.000…0
  DO                           @  1 9 START
     SWAP                      @     SWAP
     1 DUP2 GET 2 + PUT VSQRT  @     2 + √
     [ 2 ] VRDM                @     Ajuste dimension selon argument initial
     OVER VDIV                 @     2.000…0 OVER /
     ROT VMULT VRDM VDISP      @     ROT * 
  UNTIL                        @  NEXT
     VSAME?                    @  Boucle jusqu'à résultat identique
  END DROP2 CLMF               @  
»  

1E6 'VEb' STO                  @  Base représentation multi en ARRaY 

Il faut effectivement au préalable avoir saisi la bilbiothèque gérant les nombres décimaux multiprécision.
Ce sont en fait des vecteurs ; le premier élément donnant la partie entière et les éléments suivant les décimales regroupées par 6. Ce qui permet d'eviter les erreurs de calcul, l'HP28S effectuant les calcul sur 12 chiffres.

Pour faciliter le développemnt, le regroupement est mémorisé dans une constante 'VEb' ce qui permet de changer la base à
plus facilement.


Les principaux membre de la bibliothèque sont :
° VMULT qui effectue une multiplication
° VDIV qui effectue une division
* VSQRT qui extrait une racine carré
Les deux derniers programme limite la profondeur de calcul en fonction de la taille (nombre de groupe de décimales) donné par l'argument.
Pour éviter les erreur d'arrondi, les calculs sont effectué à l'intérieur de ces deux programme avec un groupe de plus que demandé.
Le résultat final est donnée quand le calcul ne modifie plus les décimales des groupes demandé.

Le programme VViete procède de la même façon, il augmente le nombre de (groupes de) décimales jusqu"à convergé pour la précision demandée.

Pour cela ces trois programme utilise VRDM et VSAME évitant la répétition de séquences d'instructions identiques pour justemetn limiter la précision ou arrêtre les calculs.

VCARRY est un sous-programme important car il permet de gérer les retenues et donc de re-formater le vecteur décrivant un nombre décimal en multi-précision.

VDISP ->V et V-> sont utilisés pour afficher et convertir les valeurs.

Code : Tout sélectionner

==================================================================
VMULT:
« → A B
  « A DIM B DIM + 1 -                 @ Résultat fait (a+b-1) éléments
    {} + 0 CON                        @ Mise à zéro accumulateur "final size"
    A VRDM                            @ Multiplicante initial à la taille finale
    1 B DIM FOR k               
       DUP B k GET  *                 @ Multiplication par i-ème facteur B
        ROT + VCARRY←                 @ Ajout dans accumulateur et traitement retenues
        0 ROT ARRY→ SWAP DROP →ARRY   @ Décalage à droite du multiplicante
    NEXT
    DROP » »
==================================================================
VDIV:
« OVER DIM → s                        @ Limite taille résultat à celle de A
  « VRDM                              @ Ajuste taille du diviseur
    1 s START
       OVER V→ OVER V→ / IP           @ Effectue division partielle
       DUP2 * 4 ROLL - NEG VCARRY→    @ Calcule reste 
       ARRY→ 0 SWAP →ARRY             @ Décale d'une "unité" et abaisse un zéro 
       1 DUP2 GET 4 ROLL VEb * + PUT  @ Ajoute la retenue 
       ROT                            @ Prépare division suivante 
    NEXT   
    DROP2  
    s →ARRY » »
==================================================================
VSQRT:
« DUP DUP                             @ Copie argument inital
  DO 
     DUP2 VDIV + .5 →V VMULT          @ Voir algorithme M.P.O. n° 46
     VRDM                             @ Limite taille à argument inital
  UNTIL VSAME? END                    @ Boucle jusqu'à racine exacte
  DROP2                               
» 
==================================================================
VCARRY←:
« 0 SWAP                             @ Initiate carry
  DUP DIM 1 FOR i
       i DUP2 GET                    @  Get i-th value 
       4 ROLL +                      @  Add previous carry 
       VEb MOD                       @  Keep remaining in vector
       LAST / FLOOR 4 ROLLD          @  Store next carry
       PUT                           @  Put value back in vector
  -1 STEP 
  IF SWAP THEN 
      "Overflow" 1 DISP 1 SF         @  Display error message and set flag 
  END »

1E6 'VEb' STO                        @  Base représentation multi en ARRaY 
==================================================================

C'est bien pratique pour avoir la racine de 3 avec 18 décimales il me suffit de taper [ 3 0 0 0 ] VSQRT et mon HP28S produit le vecteur [ 1 732050 807568 877293 ] et VDISp affiche l'approximation décimale suivante 1.732050 807568 877293



Et les programmes secondaires :

Code : Tout sélectionner

==================================================================
→V:                            @ Converti en multi-précision
« DEPTH 1 - → d0
  « DO
       IP
       LAST FP VEb *
    UNTIL DUP FP NOT END
    DEPTH d0 - →ARRY » »

1E6 'VEb' STO                  @  Base représentation multi en ARRaY 
====================================================================
V→:                                 @ Transforme en son approximation 
« DUP DIM → s
  « 1 
    2 s START DUP VEb / NEXT
    s →ARRY DOT » »
====================================================================
VDISP:                              @ Affiche et imprime proprement
« VEb LOG 1 - → t                   @ Un nombre en multi précision
  « 1 SF "" OVER 1 
    DO
       GETI 
       IF 1 FS?C 
       THEN →STR "." + 
       ELSE VEb / →STR "000000000000" + 2 DUP t + SUB " " + END
       4 ROLL SWAP +
       IF DUP SIZE 24 MOD 23 t - > THEN 10 CHR + END
       ROT ROT
    UNTIL DUP 1 == END
    DROP2 PR1 1 DISP » »

1E6 'VEb' STO                  @  Base représentation multi en ARRaY 
====================================================================

Le programme DIM est ssu de ma bibliothèque personnelle, il donne la longeur des chaine de caractère, le nombre d'élements des listes, vecteur et matrices.:

Code : Tout sélectionner

==================================================================
DIM:
« SIZE                         @ Like SIZE, DIM returns :
  IF DUP TYPE 5 ==             @  * nb of caracters for Strings
  THEN LIST→                   @  * nb of elements for Lists
     IF 2 == THEN * END        @  * vectors or arrays
  END »                              
 
Ex: "CH3OH" DIM    ---> 5
    [3 14 15 ]     ---> 3
    [[ 1 2 3 ]
     [ 4 5 6 ]]    ---> 6
==================================================================

Les instructions suivantes sont issues de l'analyse des codes générés.
Il s'agit d'éviter les répétition et d'optimiser le code et misant petit.

Code : Tout sélectionner

====================================================================
VRDM:
« OVER SIZE RDM »              @ Réajuste taille à partir du niveau 2:
====================================================================
VSAME?:
« SWAP OVER DUP 5 ROLL SAME » @ Compare résultat actuel avec précédent
====================================================================

Il s'agit d'un MPO, je défit quiconque de trouver le moyen de faire plus court sur HP-28S

Evidemment c'est loin d'être rapide

[bernouilli92]

Il s'agit d'un MPO, je défit quiconque de trouver le moyen de faire plus court sur HP-28S

On peut déjà gagner un octet en remplaçant
"000000000000"
par
"000000" DUP +
Ensuite on peut remplacer "Overflow" par "OVL err"
Je suis sûr qu'on peut encore grappiller des octets par-ci par-là.