Idée de programme : dessin de nombres

Ici, on fait dans le petit, le LCD qui déchire sa race, on y cause même calculatrices quand on est en manque !

Modérateur : Politburo

Répondre
Avatar de l’utilisateur
gege
Fonctionne à 14400 bauds
Fonctionne à 14400 bauds
Messages : 6978
Inscription : 31 janv. 2008 15:24
Localisation : Banlieue Paârisienne
Contact :

Re: Idée de programme : dessin de nombres

Message par gege » 31 déc. 2010 00:08

Marcus von Cube a écrit :Le facteur .7 est une "chiffre magique". C'est l'inclinaison de la droite qui limite le graphe.
Oui mais non : c'est bien l'inclinaison de la droite, mais ça n'a rien de magique.

Allez, 1 minute de maths...
Donc le n ième nombre de Fibonacci vaut quasiment FFn = ((1+sqrt(5))/2)^n, donc son logarithme en base 2 (qui donne le nombre de chiffres binaires) est Cn = log(FFn) / log 2 soit Cn = n * (log ((1+sqrt(5))/2) / log 2), et le facteur en question vaut un peu plus de 0,69 que j'arrondis à 0,7 par sécurité.

C'est fini, vous pouvez retourner à vos occupations normales...
G.E.

Gilles59
Fonctionne à 2400 bauds
Fonctionne à 2400 bauds
Messages : 1424
Inscription : 27 oct. 2010 20:46

Re: Idée de programme : dessin de nombres

Message par Gilles59 » 31 déc. 2010 02:08

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
Dernière édition par Gilles59 le 31 déc. 2010 13:15, édité 9 fois.
Casio FX-502P /602P / 603P / FX180P+ / FX4000P / TI57 / TI66 / TI74 Basicalc / TI95 Procalc / HP12C / HP15C LE / DM41L / HP 30B / HP39GII / HP 48SX USA / 49G / 49G+ / 50G / 50G NewRPL / HP Prime / Oric 1 / Amstrad CPC 6128+

Avatar de l’utilisateur
gege
Fonctionne à 14400 bauds
Fonctionne à 14400 bauds
Messages : 6978
Inscription : 31 janv. 2008 15:24
Localisation : Banlieue Paârisienne
Contact :

Re: Idée de programme : dessin de nombres

Message par gege » 31 déc. 2010 09:14

Purée 9 secondes !!
Juste 15 fois plus rapide que mon truc... :oops:
Utiliser 2 entiers est une bonne idée, je vais essayer.
A+
G.E.

Gilles59
Fonctionne à 2400 bauds
Fonctionne à 2400 bauds
Messages : 1424
Inscription : 27 oct. 2010 20:46

Re: Idée de programme : dessin de nombres

Message par Gilles59 » 31 déc. 2010 11:44

gege a écrit :Purée 9 secondes !!
Juste 15 fois plus rapide que mon truc... :oops:
Utiliser 2 entiers est une bonne idée, je vais essayer.
A+
G.E.
Si tu a des AND et OR, ca peut le faire.

Pour la vitesse, le prog n'utilise aucune variable , juste la pile, çà aide aussi...
J'ai édité pour commenter le prog car çà n'est pas forcément clair à la premier lecture. En fait c'est assez simple finalement

PS : je copie le source depuis HPUsrEdit et remplace les caractère spéciaux à la main, j'espere ne pas en avoir loupé .... vais regarder si il y a une option de conversion automatique.
Casio FX-502P /602P / 603P / FX180P+ / FX4000P / TI57 / TI66 / TI74 Basicalc / TI95 Procalc / HP12C / HP15C LE / DM41L / HP 30B / HP39GII / HP 48SX USA / 49G / 49G+ / 50G / 50G NewRPL / HP Prime / Oric 1 / Amstrad CPC 6128+

Avatar de l’utilisateur
kweeky
Fonctionne à 2400 bauds
Fonctionne à 2400 bauds
Messages : 1662
Inscription : 05 oct. 2007 19:46
Localisation : Pas très loin de Bordeaux

Re: Idée de programme : dessin de nombres

Message par kweeky » 31 déc. 2010 11:54

Salut

Intéressant vos programmes. Et on apprend plein de trucs, merci.
Gilles59 a écrit :Le programme fait 683,5 octets ( les ,5 sont un héritage des HP48 qui avait un proc 4 bits je crois)
C'est aussi le cas sur les HP-48Gii, HP-49G+, et HP-50G. Si ces trois là sont équipées d'un processeur ARM 32 bits, ce dernier fait tourner un émulateur Saturn 4 bits afin de garder une compatibilité pleine et entière avec les précédentes. Ce qui fait que si tu décidais de programmer ta HP-50G en ASM, tu la programmerais en ASM Saturn 4 bits, sauf si tu décides de descendre plus loin dans le trrier du lapin blanc et de dépasser la couche d'émulation Saturn.

C'est le pourquoi du ,5 car effectivement le Saturn traite des données 4 bits, et les humains trouvent plus parlant une taille en octets. Ce qui est bien dommage, car il est beaucoup plus gratifiant de travailler en quartets : tu doubles ainsi instantanément et gratuitement la capacité de tes disques durs, clefs USB, barettes de RAM ! :mrgreen:

En fait le Saturn est utilisé sur pas mal de caltos HP (HP-71B, série "Pioneer", HP-28C/S, HP-48*.* (sauf Gii), HP-49G, HP-38G, HP-39/40G). Les dernières "HP" (en fait Kinpo) utilisent un ARM et une couche d'émulation Saturn (HP-39G+, 39GS, 40GS, 48GII, 49G+, 50G). C'est la présence de cette couche 'émulation qui explique la "lenteur relative" de ces modèles, car même s'ils sont plus rapides que leurs prédécesseurs, le gain de vitesse est ridicule quand on pense qu'on est passé d'un 4 bits à 2 ou 4 Mhz à un 32 bits à 75 MHz (oui car underclocké afin de ne pas trop bouffer de piles).

@+

Gilles59
Fonctionne à 2400 bauds
Fonctionne à 2400 bauds
Messages : 1424
Inscription : 27 oct. 2010 20:46

Re: Idée de programme : dessin de nombres

Message par Gilles59 » 31 déc. 2010 12:12

kweeky a écrit :Salut

Intéressant vos programmes. Et on apprend plein de trucs, merci.
Gilles59 a écrit :Le programme fait 683,5 octets ( les ,5 sont un héritage des HP48 qui avait un proc 4 bits je crois)
C'est aussi le cas sur les HP-48Gii, HP-49G+, et HP-50G. Si ces trois là sont équipées d'un processeur ARM 32 bits, ce dernier fait tourner un émulateur Saturn 4 bits afin de garder une compatibilité pleine et entière avec les précédentes. Ce qui fait que si tu décidais de programmer ta HP-50G en ASM, tu la programmerais en ASM Saturn 4 bits, sauf si tu décides de descendre plus loin dans le trrier du lapin blanc et de dépasser la couche d'émulation Saturn.

C'est le pourquoi du ,5 car effectivement le Saturn traite des données 4 bits, et les humains trouvent plus parlant une taille en octets. Ce qui est bien dommage, car il est beaucoup plus gratifiant de travailler en quartets : tu doubles ainsi instantanément et gratuitement la capacité de tes disques durs, clefs USB, barettes de RAM ! :mrgreen:

En fait le Saturn est utilisé sur pas mal de caltos HP (HP-71B, série "Pioneer", HP-28C/S, HP-48*.* (sauf Gii), HP-49G, HP-38G, HP-39/40G). Les dernières "HP" (en fait Kinpo) utilisent un ARM et une couche d'émulation Saturn (HP-39G+, 39GS, 40GS, 48GII, 49G+, 50G). C'est la présence de cette couche 'émulation qui explique la "lenteur relative" de ces modèles, car même s'ils sont plus rapides que leurs prédécesseurs, le gain de vitesse est ridicule quand on pense qu'on est passé d'un 4 bits à 2 ou 4 Mhz à un 32 bits à 75 MHz (oui car underclocké afin de ne pas trop bouffer de piles).

@+
Visiblement, il y des parties (des comandes) réécrites directement en ARM. Si je prends l'exemple de SREPL, c'est très clair. Ca te remplace 3000 caractéres par un autre dans un ensemble de 6000 quasiment instantanément, çà me semble difficile en émulation pure. Idem pour les calculs en entiers longs, j'ai pas ma 48 sous la main j'essaierai, mais j'essaierai de générer les 400 premiers nombre de fibonacci (quasiment instantanément sur la 50)
Casio FX-502P /602P / 603P / FX180P+ / FX4000P / TI57 / TI66 / TI74 Basicalc / TI95 Procalc / HP12C / HP15C LE / DM41L / HP 30B / HP39GII / HP 48SX USA / 49G / 49G+ / 50G / 50G NewRPL / HP Prime / Oric 1 / Amstrad CPC 6128+

Avatar de l’utilisateur
kweeky
Fonctionne à 2400 bauds
Fonctionne à 2400 bauds
Messages : 1662
Inscription : 05 oct. 2007 19:46
Localisation : Pas très loin de Bordeaux

Re: Idée de programme : dessin de nombres

Message par kweeky » 31 déc. 2010 12:34

Il n'est effectivement pas impossible que certaines commandes consommatrices de ressources contournent la couche d'émulation. Ceci pouvant expliquer cela !

Gilles59
Fonctionne à 2400 bauds
Fonctionne à 2400 bauds
Messages : 1424
Inscription : 27 oct. 2010 20:46

Re: Idée de programme : dessin de nombres

Message par Gilles59 » 31 déc. 2010 13:27

kweeky a écrit :Il n'est effectivement pas impossible que certaines commandes consommatrices de ressources contournent la couche d'émulation. Ceci pouvant expliquer cela !
Oui vu dans des forum. De même on peut "mélanger" du code Saturn émulé et du ARM natif. Je n'ai jamais programmé en Saturn ni en ARM, mais l'ARM me tente bien ;)
Casio FX-502P /602P / 603P / FX180P+ / FX4000P / TI57 / TI66 / TI74 Basicalc / TI95 Procalc / HP12C / HP15C LE / DM41L / HP 30B / HP39GII / HP 48SX USA / 49G / 49G+ / 50G / 50G NewRPL / HP Prime / Oric 1 / Amstrad CPC 6128+

Avatar de l’utilisateur
Marcus von Cube
Fonctionne à 1200 bauds
Fonctionne à 1200 bauds
Messages : 914
Inscription : 20 avr. 2006 13:48
Localisation : Wehrheim, Allemagne
Contact :

Re: Idée de programme : dessin de nombres

Message par Marcus von Cube » 31 déc. 2010 19:54

J'ai joué avec ma HP 40gs (en "BASIC"). Elle connaît bien des GROBs mais je ne suis pas encore arrivé à les créer dynamiquement. J'ai peur que c'est impossible sans de librairies spécialisés que je n'ai pas encore trouvé. Les paramètres du MAKEGROB sont constants. :?:

Avatar de l’utilisateur
gege
Fonctionne à 14400 bauds
Fonctionne à 14400 bauds
Messages : 6978
Inscription : 31 janv. 2008 15:24
Localisation : Banlieue Paârisienne
Contact :

Re: Idée de programme : dessin de nombres

Message par gege » 31 déc. 2010 21:26

Gilles59 a écrit :Si tu a des AND et OR, ca peut le faire.
Ben non justement.
Je jette l'éponge, parce que en utilisant un programme adapté pour travailler sur deux entiers de 10 chiffres, j'obtiens le même temps de 2 minutes.
Or en désactivant les "PxlOn" le programme tourne en 5 secondes.
Donc comme remarqué par Marcus c'est l'instruction PxlOn qui est ultra-lente.
Etant donné que sur cette machine on n'a aucun autre moyen d'afficher les pixels, la lutte est fort inégale et il est impossible de gagner quoi que ce soit sur les (2 minutes - 5 secondes) que la machine passe à afficher les pixels...
Dommage.
G.E.

Avatar de l’utilisateur
C.Ret
Fonctionne à 9600 bauds
Fonctionne à 9600 bauds
Messages : 2774
Inscription : 31 mai 2008 23:43
Localisation : N 49°22 E 6°10

Re: Idée de programme : dessin de nombres

Message par C.Ret » 01 janv. 2011 07:23

gege a écrit :Oui mais non : c'est bien l'inclinaison de la droite, mais ça n'a rien de magique.
Si, si la magie dont parlait Marcus, c'est justement cette magie des Matheux, pas celle des Magiciens.

Bonne Année à tous.


P.S.: J'irais acheter des piles quand les soldes auront commencés (et que les boutiques rouvriront).
Mais imprimer les 27 copies d'écrans d'une HP28s en quelques secondes me parait fort difficile, à moins d'utiliser la magie des Magiciens (je ne dispose que de celle des Matheux).
SHARP PC-1211+CE-121+CE-122 | Commodore 128D+Printer P-803+SD2iec | TI-57 LCD | HP-28S+HP82240A | TI-74 BASICalc | HP-41C+2mem+stat+IR | HP-15C | SHARP PC-1360+64Ko+CE-126 | HP Prime | TI-92 II | CASIO fx-602p+FA-1 | HP-71B 64K+JPC-ROM+HPIL+card reader | TI-58c+Master Library module | Sommaire des M.P.O. | Ma...dov'il sapone !.

"All science is either physics or stamp collecting. That which is not measurable is not science." - E. R.

Gilles59
Fonctionne à 2400 bauds
Fonctionne à 2400 bauds
Messages : 1424
Inscription : 27 oct. 2010 20:46

Re: Idée de programme : dessin de nombres

Message par Gilles59 » 01 janv. 2011 12:51

BONNE ANNEE à TOUS !!

Miroir, miroir ... J'ai eu un flash ce matin lol. Pourquoi se casser les pieds à inverser les bits chaque quartet alors qu'en inversant tout la chaine de quartet, je suis dans la même logique de 'miroir'...

Résultat 7"53 et un programme bien plus simple :

Code : Tout sélectionner

«
 TICKS                             @ Compteur temps macine 

 HEX                               @ mode héxadécimal pour les conversions -> Alpha
                                   @ Place des deux premier 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 premiers nombres de Fibonacci
   4 DUPN                          @ Duplique les 2 nbre (4 éléments de la pile
   ROT +                           @ Somme des entiers de poids fort
   UNROT +                         @ Somme des entiers de poids faibles
   DUP
   #1000000000000000h AND          @ Récup le premier bit du quartets le plus 'fort' 
   IF #1000000000000000h == THEN   @ de l'entier de poids faible et vérifie si il est 'levé' => retenue
    #0FFFFFFFFFFFFFFFh AND         @ Effacfer 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
   UNROT 
   #1000000000000000h OR           @ force le bit 61 a 1 
   "" + 4 18 SUB SWAP              @ convertit en chaine hexa et extrait de 4 à 14     
   #1000000000000000h OR           @ Idem pour l'entier binanaire de poids
   "" + 4 18 SUB 
   + +
 NEXT

 SREV                             @ Inverse la chaine résultat "ABCD" -> "DCBA"

 "GROB 120 127 " SWAP + OBJ->       @ On construit l'objet grahique
 PICT STO                          @ Le stocker dans l'écran
 TICKS SWAP - B->R 8192. / 
 2 RND  " Sec" +                 @ temps en seconde (Ticks_fin - Ticks_deb)/8192
 {} PVIEW                        @ Affiche le graphe en mode scrolling
»
Casio FX-502P /602P / 603P / FX180P+ / FX4000P / TI57 / TI66 / TI74 Basicalc / TI95 Procalc / HP12C / HP15C LE / DM41L / HP 30B / HP39GII / HP 48SX USA / 49G / 49G+ / 50G / 50G NewRPL / HP Prime / Oric 1 / Amstrad CPC 6128+

Avatar de l’utilisateur
Marcus von Cube
Fonctionne à 1200 bauds
Fonctionne à 1200 bauds
Messages : 914
Inscription : 20 avr. 2006 13:48
Localisation : Wehrheim, Allemagne
Contact :

Re: Idée de programme : dessin de nombres

Message par Marcus von Cube » 01 janv. 2011 16:12

J'ai écrit deux versions pour la HP-39/40 (gs). Le 39 ne connaît pas PXLTEST. Une liste avec une copie des pixels remplace ça. La première ligne est un header pour Conn3x.

Version 1 :

Code : Tout sélectionner

HP39AscD 7 FIBDRAW
HMS\->(Time)\|>T:
ERASE:
1\|>Xmin:131\|>Xmax:
1\|>Ymin:64\|>Ymax:
MAKELIST(0,Y,Ymin,Ymax,1)\|>L1:
1\|>L1(1):
L1\|>L2:
PIXON 1;Ymax:PIXON 2;Ymax:
FOR X=Xmin+2 TO Xmax;
  0\|>R:
  FOR Y=Ymin TO MIN(.7*X,Ymax);
    R+L1(Y)+L2(Y)\|>A:
    A\>=2\|>R:
    L1(Y)\|>L2(Y):
    IF A MOD 2 THEN
      PIXON X;1+Ymax-Y:
      1\|>L1(Y):
    ELSE
      0\|>L1(Y):
    END:
  END:
END:
HMS\->(Time)-T\|>T:
ROUND(\->HMS(T)*100,2)\|>T:
{0}\|>L1:{0}\|>L2:
DISPLAY\-> G0:
\->GROB G1;T;1:
REPLACE G0;(1,Ymin+8);G1:
\->DISPLAY G0:
FREEZE:
Temps d'exécution sur HP 40gs : ~20''56".

Version 2:

Code : Tout sélectionner

HP39AscD 8 FIBDRAW2
HMS\->(Time)\|>T:
1\|>Xmin:131\|>Xmax:
1\|>Ymin:64\|>Ymax:
MAKELIST(0,Y,Ymin,CEILING(Ymax/3),1)\|>L1:
1\|>L1(1):
L1\|>L2:
ERASE:
PIXON 1;Ymax:PIXON 2;Ymax:
DISPLAY\-> G0:
MAKEGROB G1;1 3 100000:
MAKEGROB G2;1 3 001000:
MAKEGROB G3;1 3 101000:
MAKEGROB G4;1 3 000010:
MAKEGROB G5;1 3 100010:
MAKEGROB G6;1 3 001010:
MAKEGROB G7;1 3 101010:

FOR X=Xmin+2 TO Xmax;
  0\|>R:0\|>I:
  FOR Y=1 TO MIN(.7*X,Ymax) STEP 3;
    I+1\|>I:
    R+L1(I)+L2(I)\|>A:
    INT(A/8)\|>R:
    A MOD 8\|>A:
    L1(I)\|>L2(I):A\|>L1(I):
    CASE
      IF A==1 THEN REPLACE G0;(X,1+Ymax-Y);G1:END
      IF A==2 THEN REPLACE G0;(X,1+Ymax-Y);G2:END
      IF A==3 THEN REPLACE G0;(X,1+Ymax-Y);G3:END
      IF A==4 THEN REPLACE G0;(X,1+Ymax-Y);G4:END
      IF A==5 THEN REPLACE G0;(X,1+Ymax-Y);G5:END
      IF A==6 THEN REPLACE G0;(X,1+Ymax-Y);G6:END
      IF A==7 THEN REPLACE G0;(X,1+Ymax-Y);G7:END
    END:
  END:
  \->DISPLAY G0:
END:
HMS\->(Time)-T\|>T:
ROUND(\->HMS(T)*100,2)\|>T:
{0}\|>L1:{0}\|>L2:
\->GROB G1;T;1:
REPLACE G0;(1,Ymin+8);G1:
\->DISPLAY G0:
FREEZE:
Version 2 dessine 3 pixels en bloque par un GROB. Je n'ai trouvé pas une méthode à construire un GROB d'une chaîne hexa variable. Pour ça, le programme utilise 7 GROBs G1 à G7 pour dessiner tous les combinaisons de trois pixels. Temps d'exécution sur HP 40gs : ~9'25".

Avatar de l’utilisateur
C.Ret
Fonctionne à 9600 bauds
Fonctionne à 9600 bauds
Messages : 2774
Inscription : 31 mai 2008 23:43
Localisation : N 49°22 E 6°10

Re: Idée de programme : dessin de nombres

Message par C.Ret » 01 janv. 2011 21:20

Les temps de calculs et d'impression sont à peu près les mêmes sur Commodore 8 bit (dans mon cas C128D). Le code présenté ci-dessous devrait pouvoir tourner aussi sur d'autre CBM, pourvu de suffisamment de mémoire pour un tableau d'entiers de 478 x 47:

Il se déroule en deux parties :
- la première caclule les nombres de Fibanocci en tronçons de 7 bits (0 à 127 décimal) afin d'avoir directement les valeurs binaires graphiques,
- la seconde parcourt simplement ce tableau et transmet les codes graphiques ligne à ligne à l'imprimante matricielle (périphèrique 4).

Code : Tout sélectionner

100 FAST:GRAPHIC CLR:GRAPHIC 5,1
110 N%=0:L%=0:X%=0:R%=0:M%=0
120 DIM F%(478,47)

130 REM ==== INITIALISE TABLEAU avec F(1) et F(2)  ======

140 F%(0,0)=1:F%(1,0)=1

200 REM ==========    COMPUTING FIB NUMBERS        ======

210 N%=2:M%=0
220 DO
230 :  R%=0:L%=0
240 :  DO
250 :  :  X%=F%(N%-2,L%)+F%(N%-1,L%)+R%
260 :  :  F%(N%,L%)=X% AND 127
270 :  :  R%=X%/128
280 :  :  L%=L%+1
290 :  LOOP UNTIL L%>M%
300 :  IF R% THEN M%=L%:F%(N%,L%)=R%
310 :  N%=N%+1
320 LOOP UNTIL N%>478

500 REM ==== PRINT ON COMMODORE MPS 803 =================

510 GR$=CHR$(8):TX$=CHR$(15):EN$=CHR$(14)
520 OPEN 4,4
530 :  PRINT#4,TX$+"-------------------------------------------------";
540 :  PRINT#4,TX$+"PIXEL BINARY FIBANOCCI NUMBERS 1 TO ";N%-1
550 :  PRINT#4,TX$+EN$+"COMMODORE MPS-803"+TX$+" DOT MATRIX PRINTER"
560 :  PRINT#4,TX$+"RUN ON Commodore C128D"
570 :  PRINT#4,TX$+"-------------------------------------------------";
580 :  FOR L=M% TO 0 STEP -1
590 :  :  PRINT#4,GR$;
600 :  :  :  FOR I=0 TO N%-1
610 :  :  :  PRINT#4,CHR$(128+F%(I,L));
620 :  :  NEXT I
630 :  :  PRINT#4
650 :  NEXT L
660 :  PRINT#4,TX$+"-------------------------------------------------"
670 :  PRINT#4
680 CLOSE 4
690 END
Il faut environ 11 à 12 min pour obtenir le graphique qui tient sur les 3/4 d'une feuille A4.

Image
Dernière édition par C.Ret le 24 mars 2022 00:09, édité 1 fois.
SHARP PC-1211+CE-121+CE-122 | Commodore 128D+Printer P-803+SD2iec | TI-57 LCD | HP-28S+HP82240A | TI-74 BASICalc | HP-41C+2mem+stat+IR | HP-15C | SHARP PC-1360+64Ko+CE-126 | HP Prime | TI-92 II | CASIO fx-602p+FA-1 | HP-71B 64K+JPC-ROM+HPIL+card reader | TI-58c+Master Library module | Sommaire des M.P.O. | Ma...dov'il sapone !.

"All science is either physics or stamp collecting. That which is not measurable is not science." - E. R.

Gilles59
Fonctionne à 2400 bauds
Fonctionne à 2400 bauds
Messages : 1424
Inscription : 27 oct. 2010 20:46

Re: Idée de programme : dessin de nombres

Message par Gilles59 » 01 janv. 2011 21:46

Intéressant tout cela.

Citius, Altius, Fortius

A croire que les bulles ( de champagne) donnent des idées. Pourquoi se compliquer la vie et refaire des commandes qui existent déjà en 49+ ou 50 !

271,5 octets et 4,2 secondes :

Code : Tout sélectionner

«
 #0h  #1h DUP2                     @ Entier 64 bits poids fort et faible pour initialiser la suite
 1. 125. START                      @ calcul les 125 + 2 premiers nombres de Fibonacci
   4. DUPN                         @ Duplique les 2 nbres (4 éléments de la pile)
   ROT +                           @ Somme des entiers de poids faible
   DUP
   #F000000000000000h AND          @ Récup le quartet fort de l'entier de poids faible
   IF #1000000000000000h SAME THEN @            et vérifie si le bit 1  il est 'levé' => retenue
    #0FFFFFFFFFFFFFFFh AND         @ Effacer la retenue
    SWAP #1h + SWAP                @ Ajouter 1 dans l'entier de poids fort
   END  
   UNROT + SWAP                    @ Somme des entiers de poids fort
 NEXT
 
 ""                                @ contiendra la chaine hexadécimale du graphe
 1. 127. START
   UNROT 
   ->H 11. 25. SUB SWAP              @ convertit en chaine hexa      
   ->H 11. 17. SUB 
   + +
 NEXT

 "GROB 88 127 " SWAP + OBJ->       @ On construit l'objet graphique
»
[/size]
Casio FX-502P /602P / 603P / FX180P+ / FX4000P / TI57 / TI66 / TI74 Basicalc / TI95 Procalc / HP12C / HP15C LE / DM41L / HP 30B / HP39GII / HP 48SX USA / 49G / 49G+ / 50G / 50G NewRPL / HP Prime / Oric 1 / Amstrad CPC 6128+

Répondre

Revenir vers « Tous les Pockets »