9"37 pour le graph complet du FIBO(127) qui nous sert de test ... Et pour 127 mètres lol . 100% UserRpl
Bon je vous accorde que le programme privilégie la rapidité à la clarté :O
Code : Tout sélectionner
«
TICKS @ Compteur temps machine
HEX @ mode héxadécimal pour les conversions -> Alpha
@ Place des deux premiers nbr de Fibo sur la pile
#1h #0h DUP2 @ Entier 64 bits poids faible / entier 64 bits poids fort
1. 125. START @ calcul les 125 + 2 premiers nombres de Fibonacci
4 DUPN @ Duplique les 2 nbres (4 éléments de la pile donc)
ROT + @ Somme des entiers de poids fort
UNROT + @ Somme des entiers de poids faibles
DUP
#1000000000000000h AND @ Récup le bit faible du quartets le plus 'fort'
IF #1000000000000000h == THEN @ de l'entier de poids faible et vérifie si il est 'levé' => retenue
#0FFFFFFFFFFFFFFFh AND @ Effacer la retenue
SWAP #1d + SWAP @ Ajouter 1 dans l'entier de poids fort
END
SWAP
NEXT
"" @ contiendra la chaine hexadécimale du graphe
1. 127. START @ On lance le dépilage pour générer le graphe. 2 entiers -> 1 ligne
UNROT
#1000000000000000h OR @ force le bit 61 a 1 pour que la conversion hexa mette des 0 au début
"" + 4 18 SUB SWAP @ convertit en chaine hexa et extrait la sous-chaine de 4 à 18
#1000000000000000h OR @ Idem pour l'autre entier binaire
"" + 4 18 SUB
+ + @ Concacténe tout çà dans la chaine résultat
NEXT
"1" "a" SREPL DROP @ Dans la chaine générée les bits des quartets
"2" "b" SREPL DROP @ ne sont pas "dans le bon sens"
"3" "c" SREPL DROP @ Il faut les retourner comme dans un miroir
"4" "d" SREPL DROP
"5" "e" SREPL DROP @ abcde f i
"7" "f" SREPL DROP @ 084C2A6E195D3B7F
"8" "1" SREPL DROP @ 0123456789ABCDEF
"A" "5" SREPL DROP
"B" "i" SREPL DROP @ Comme la substitution se fait quartet par quartet
"C" "3" SREPL DROP @ il faut des codes temporaires sinon tout se mélange !
"D" "B" SREPL DROP @ Pas chercher à optimiser ici, peut etre peut-on y
"E" "7" SREPL DROP @ arriver avec moins de codes temporaires mais pas sur
"a" "8" SREPL DROP @ SREPL remplace toute sous chaine d'une chaine par une autre
"b" "4" SREPL DROP @
"c" "C" SREPL DROP @ "Chaine à modifier"
"d" "2" SREPL DROP @ "Sous- chaine à chercher"
"e" "A" SREPL DROP @ "Sous chaine à substituer"
"f" "E" SREPL DROP @ REPL
"i" "D" SREPL DROP @ -> Chaine modifiée et nombre d'occurrences trouvées
"GROB 120 127 " SWAP + OBJ-> @ On construite l'objet graphique
PICT STO @ Le stocker dans l'écran
TICKS SWAP - B->R 8192. /
2 RND " Sec" + @ temps en secondes (Ticks_fin - Ticks_deb)/8192
{} PVIEW @ Affiche le graphe en mode scrolling
»
Il suffit de lancer le prog, et à la fin on peut scroller sur l'écran.
J'ai viré tout ce qui ralentit :
- Les entiers infinis (à cause de la division) : Je travaille avec deux entiers binaires de 64 bits et gère la retenue. Cela permet d'utiliser des opérateurs binaires.
- Les PIXON et autres PIX? : je génére directement le graphe en hexa. çà pose le problème d'une table de conversion mais la fonction SREPL de la 50 est incroyablement rapide (elle change toute les sous-chaines de caractère d'un chaine alpha par une autre sous-chaine). Ca me permet de remettre les bits des quartets dans le bon sens. En fait sans ce petit soucis, le prog serait court.
- Les listes : les 64 bits de poids fort et de poids faibles sont deux objets séparés sur la pile (pour info le même programme avec des listes met 14,8 sec, environ 50% de plus donc, mais gagne en lisibilité !)
Le programme fait 683,5 octets ( les ,5 sont un héritage des HP48 qui avait un proc 4 bits je crois). Chaque fois qu'il y a #xx en RPL çà prend de la place (64 bits au moins)...
Arrivé là, ca devient un peu de la perversion de vouloir optimiser encore, car autant le faire en assembleur
Le programme monte sans soucis jusque tout le dessin de FIBO(182) est dessinée en 13s9. Au dessus ca ne plante pas mais le dessin est tronqué. Il faudrait passer à 3 entiers de 64 bits pour calculer les pixels. Vu les jonglage avec la pile que ca implique, ca sera plus simple de passer par des listes genre
{ 60 premiers bits, bits 61 à 120 , bits 121 à 180, etc. } (en fait je me réserve le premier quartet pour les retenues)
La routine avec des listes est simple : ADD permet d'additionner 1 à 1 les éléments de 2 listes. Il faut juste gérer la retenue