Idée de programme : dessin de nombres

[Marcus von Cube]

J'ai me mis encore à la version HP 39. Le temps d'exécution est réduit a 5'41". Cette fois le nombre de bits par boucle est 5 (0 à 63). Il n'y a plus que 10 variables pour GROBs mais il est possible de stocker des GROBs dans une liste. Voilà la solution :

Code : Tout sélectionner

HP39AscD 8 FIBDRAW3
HMS\->(Time)\|>T:
1\|>Xmin:131\|>Xmax:
1\|>Ymin:64\|>Ymax:
5\|>S:2^S\|>U:
MAKELIST(0,Y,Ymin,CEILING(Ymax/S),1)\|>L1:
1\|>L1(1):
L1\|>L2:
ERASE:
PIXON 1;Ymax:PIXON 2;Ymax:
MAKEGROB G0;1 5 1000000000:{G0}\|>L0:
MAKEGROB G0;1 5 0010000000:CONCAT(L0,{G0})\|>L0:
MAKEGROB G0;1 5 1010000000:CONCAT(L0,{G0})\|>L0:
MAKEGROB G0;1 5 0000100000:CONCAT(L0,{G0})\|>L0:
MAKEGROB G0;1 5 1000100000:CONCAT(L0,{G0})\|>L0:
MAKEGROB G0;1 5 0010100000:CONCAT(L0,{G0})\|>L0:
MAKEGROB G0;1 5 1010100000:CONCAT(L0,{G0})\|>L0:
MAKEGROB G0;1 5 0000001000:CONCAT(L0,{G0})\|>L0:
MAKEGROB G0;1 5 1000001000:CONCAT(L0,{G0})\|>L0:
MAKEGROB G0;1 5 0010001000:CONCAT(L0,{G0})\|>L0:
MAKEGROB G0;1 5 1010001000:CONCAT(L0,{G0})\|>L0:
MAKEGROB G0;1 5 0000101000:CONCAT(L0,{G0})\|>L0:
MAKEGROB G0;1 5 1000101000:CONCAT(L0,{G0})\|>L0:
MAKEGROB G0;1 5 0010101000:CONCAT(L0,{G0})\|>L0:
MAKEGROB G0;1 5 1010101000:CONCAT(L0,{G0})\|>L0:
MAKEGROB G0;1 5 0000000010:CONCAT(L0,{G0})\|>L0:
MAKEGROB G0;1 5 1000000010:CONCAT(L0,{G0})\|>L0:
MAKEGROB G0;1 5 0010000010:CONCAT(L0,{G0})\|>L0:
MAKEGROB G0;1 5 1010000010:CONCAT(L0,{G0})\|>L0:
MAKEGROB G0;1 5 0000100010:CONCAT(L0,{G0})\|>L0:
MAKEGROB G0;1 5 1000100010:CONCAT(L0,{G0})\|>L0:
MAKEGROB G0;1 5 0010100010:CONCAT(L0,{G0})\|>L0:
MAKEGROB G0;1 5 1010100010:CONCAT(L0,{G0})\|>L0:
MAKEGROB G0;1 5 0000001010:CONCAT(L0,{G0})\|>L0:
MAKEGROB G0;1 5 1000001010:CONCAT(L0,{G0})\|>L0:
MAKEGROB G0;1 5 0010001010:CONCAT(L0,{G0})\|>L0:
MAKEGROB G0;1 5 1010001010:CONCAT(L0,{G0})\|>L0:
MAKEGROB G0;1 5 0000101010:CONCAT(L0,{G0})\|>L0:
MAKEGROB G0;1 5 1000101010:CONCAT(L0,{G0})\|>L0:
MAKEGROB G0;1 5 0010101010:CONCAT(L0,{G0})\|>L0:
MAKEGROB G0;1 5 1010101010:CONCAT(L0,{G0})\|>L0:
DISPLAY\-> G0:

FOR X=Xmin+2 TO Xmax;
  0\|>R:0\|>I:
  FOR Y=1 TO MIN(.7*X,Ymax) STEP S;
    I+1\|>I:
    R+L1(I)+L2(I)\|>A:
    INT(A/U)\|>R:
    A MOD U\|>A:
    L1(I)\|>L2(I):A\|>L1(I):
    IF A\=/0 THEN
      REPLACE G0;(X,1+Ymax-Y);L0(A):
    END:
  END:
  \->DISPLAY G0:
END:
HMS\->(Time)-T\|>T:
ROUND(\->HMS(T)*100,2)\|>T:
{0}\|>L0:{0}\|>L1:{0}\|>L2:
\->GROB G1;T;1:
REPLACE G0;(1,Ymin+8);G1:
\->DISPLAY G0:
FREEZE:

J'admire les solutions plus large ou plus rapide. À l'autre coté, il fait plaisir de se mettre aux machines qu'ils sont moins capable.

Edit: Temps sur EMU48 (MacBook>Parallels>WinXP) : 0'12".
Temps sur HP 39G : 19'22".

[Gilles59]

C..Ret, Belle réalisation sur le Commodore !

Version XXL, big-fibo sur HP50 identique à celle du C128

Code : Tout sélectionner

«                                    @ Place des deux premier nbr de Fibo sur la pile
 { #1h,#0h,#0h,#0h,#0h,#0h } DUP     @ Entiers 64 bits poids faibles -> poids forts
 1. 474. START                       @ calcul les 474 + 2 premiers nombres de Fibonacci
   DUP2                              @ Duplique les 2 listes 
   ADD                               @ Somme des 2 listes élément par élément   
   1. 5. FOR i                       @ Gestion des retenues
    DUP i GET DUP   
    #F000000000000000h AND           @ Récup le premier bit du quartet le plus 'faible' 
    IF #1000000000000000h SAME THEN  @  et vérifie si il est 'levé' => retenue
      #0FFFFFFFFFFFFFFFh AND         @ Effacer la retenue 
      i SWAP PUTI
      DUP2 GET #1d + PUT             @ Ajouter 1 dans l'entier de poids fort    
    ELSE
      DROP
    END 
   NEXT    
  NEXT

 
 ""
 1. 476. START
   1. SWAP
   UNROT GETI ->H 11. 25. SUB        @ Générer le code hexa pour les 6 éléments
   UNROT GETI ->H 11. 25. SUB 
   UNROT GETI ->H 11. 25. SUB 
   UNROT GETI ->H 11. 25. SUB 
   UNROT GETI ->H 11. 25. SUB 
   UNROT GETI ->H 11. 25. SUB 
   UNROT DROP2 
   + + + + + +
 NEXT

 "GROB 360 476 " SWAP + OBJ->        @ On construit l'objet grahique
»

[/size]

Vitesse : 170 sec ( 2mn50)
Taille : 522 octets
Résultat :



Je me lance dans du plus grand encore, on va voir

[Gilles59]

Fibo 650 généré par la HP50G

Cliquer là : http://imagik.fr/uploads/346288 puis recliquer pour afficher en taille réelle.
J'ai fait un zoom x 2 pour mieux voir les détails du paysage tourmenté

[gege]

Sympa !
L'existence des triangles noirs ou blancs semble moins mystérieuse quand on peut bien voir ce qu'il se passe.
Je cherche une machine qui affiche les pixels moins lentement que les Casio... pas gagné.
G.E.

[oliverue]

Salut!

Apologies for replying in English, but I don't want to torture you with my French.

These implementations are really amazing! I eat my words about this not being able to be done on another calculcator (and corrected my write-up).

This is to let you know how long ND1, the reference in this case, takes for the task.
The (dumb) algorithm which simply calls fib() for each iteration, takes a little under 10s on an iPhone.

The tutorial hinted that it would be more efficient to compute the fib numbers on the fly, as you guys quickly figured out. The calculator ships with that optimized version in its demo.
That one puts the run-time for the first 400 Fibonacci numbers at 0.3s to compute, and 0.7s to compute and display.
That's in JavaScript, with code looking like this:

Code : Tout sélectionner

function (n) {          
    Bench.start();

    var padWidth = ceil(n*0.7/8)*2;
    var data = "0x";
    var padChar = string.toString("0");
    var a = BigInteger.ZERO;
    var one = BigInteger.ONE;
    var b = one;
    for (var i=0; i<n; i++) {
        var val = BigNum["+"](a, b);
        a = b; b = val;
        // convert number to hex string, slice off 0x, pad w/ zeroes, and concatenate with data string
        data += string.pad(string.toString(BigNum.toString(BigNum.toHex(val)).slice(2)), padWidth, padChar).slice(1, -1);
    }
    
    Bench.elapsedMsg(); // time to calculate

    var image = NDImage.toImage(string.toString("FibTri" + n), string.toString(data), padWidth*4, n);
    NDImage.toDisplay(image);

    Bench.elapsedMsg(); // time to calculate and draw

    return image;
}

Note, I stole the "magic" 0.7 from this thread (thanks for the math!). In its original form, its 0.1s slower.

The RPL version could have taken the same approach, and I estimate the overall time would be 1.0s. I didn't code that up but might, if there's interest.

Fib1024x720 takes 4.2s, in case you're curious, with almost >3s spent in display.

You notice that display takes longer than computation in this task. ND1 displays 32-bit RGBA images. There's the need for some bit-fiddling to expand each bit to 32-bit per pixel, which slows things down a lot.
The toDisplay implementation of the NDImage object looks like this:

Code : Tout sélectionner

	toDisplay: function(obj) {
		if (calculator.isADataURL(obj.data))
			display.showImage(obj);
		else {
			display.showGraphics(true);
			var ctx = canvas.getContext('2d');
			
			var image = ctx.createImageData(obj.width, obj.height);
			var imageData = image.data;
			var index = 0;
			for (var i=0; i<imageData.length; index+=2) {
				var val = parseInt(obj.data.substring(index,index+2), 16);
				if (obj.isBinary) {
					for (var s=7; s>=0; s--, i+=4) {
						var bitVal = val&(1<<s);
						imageData[i] = imageData[i+1] = imageData[i+2] = (bitVal ? 255 : 0);
						imageData[i+3] = 255; // alpha set to "opaque"
					}
				}
				else { // gray interpretation
					imageData[i] = imageData[i+1] = imageData[i+2] = val;
					imageData[i+3] = 255; // alpha set to "opaque"
					i += 4;
				}
			}

			ctx.putImageData(image, 0, 0);
		}

I'm sure you guys would figure out a more optimal way to write this!

Again, my hat's off to your beautiful implementations.
If anyone of you feels like playing on their iPhone or iPod touch, I'll glad donate a free copy of ND1. Just email me.

A+

Oliver
(Author of ND1)

[Marcus von Cube]

Welcome to our forum! No problem to write in English here. (For me its way easier then French but most of the time I try to be polite to my friends here .)

The most astonishing implementation in my eyes is the RPL version. Its about 100 times faster than my HP39 version written in the limited user programming language of this machine. The hardware (50g vs. 39gs/40gs) is essentially the same.

I own an iPod touch. I'm interested in your software.

[Gilles59]

Salut!

That's in JavaScript, with code looking like this:

Code : Tout sélectionner

function (n) {          
    ...
        // convert number to hex string, slice off 0x, pad w/ zeroes, and concatenate with data string
        data += string.pad(string.toString(BigNum.toString(BigNum.toHex(val)).slice(2)), padWidth, padChar).slice(1, -1);
....
}

A+

Oliver

Bonsoir Oliver ... En User Rpl il n'existe pas à ma connaissance de commande du genre BigNum.toHex(val). SI çà existait le programme ferait quelques lignes. En fait les entiers longs (sans limites) sont codés comme suit :

123
H->3210 (je laisse tomber l'en-tête - le dernier chiffre est le signe, 9 si négatif). Et vu ce codage, je ne vois pas de manière rapide de convertir en hexa-binaire

Code : Tout sélectionner

<<  1 1   #3d #720d START DUP2 + NEXT >>

génère sur la pile les 700 premiers nombre avec tous les chiffres en 2,01 seconde.
Mais aucun moyen simple d'afficher la représentation binaire de tout cela....

Sinon , j'ai vérifié, la 50 peut bien être programmée en ARM (et en Saturn émulé et bien sur SystemRPL), il y a même un compilateur ARM intégré :MASD. Je vais regarder par là

[gege]

Oliver
(Author of ND1)

Hello Oliver, thank you for visiting, I have much respect for people who DO things, like your nice ND1.
Your example was just taken as a nice programming challenge.
I don't have an iPhone but hope you meet deserved success.
Thank you for your offer,
Bye
G.E.

[Marcus von Cube]

Version 4 pour HP39G :

Code : Tout sélectionner

HP39AscD 8 FIBDRAW4
HMS\->(Time)\|>T:
1\|>Xmin:131\|>Xmax:
1\|>Ymin:64\|>Ymax:
35\|>S:2^S\|>U:
MAKELIST(0,Y,Ymin,CEILING(Ymax/S),1)\|>L1:
1\|>L1(1):
L1\|>L2:
MAKEGROB G0;1 1 1:{G0}\|>L0:
MAKEGROB G0;1 2 001:CONCAT(L0,{G0})\|>L0:
MAKEGROB G0;1 2 101:CONCAT(L0,{G0})\|>L0:
MAKEGROB G0;1 3 00001:CONCAT(L0,{G0})\|>L0:
MAKEGROB G0;1 3 10001:CONCAT(L0,{G0})\|>L0:
MAKEGROB G0;1 3 00101:CONCAT(L0,{G0})\|>L0:
MAKEGROB G0;1 3 10101:CONCAT(L0,{G0})\|>L0:
MAKEGROB G0;1 4 0000001:CONCAT(L0,{G0})\|>L0:
MAKEGROB G0;1 4 1000001:CONCAT(L0,{G0})\|>L0:
MAKEGROB G0;1 4 0010001:CONCAT(L0,{G0})\|>L0:
MAKEGROB G0;1 4 1010001:CONCAT(L0,{G0})\|>L0:
MAKEGROB G0;1 4 0000101:CONCAT(L0,{G0})\|>L0:
MAKEGROB G0;1 4 1000101:CONCAT(L0,{G0})\|>L0:
MAKEGROB G0;1 4 0010101:CONCAT(L0,{G0})\|>L0:
MAKEGROB G0;1 4 1010101:CONCAT(L0,{G0})\|>L0:
MAKEGROB G0;1 5 000000001:CONCAT(L0,{G0})\|>L0:
MAKEGROB G0;1 5 100000001:CONCAT(L0,{G0})\|>L0:
MAKEGROB G0;1 5 001000001:CONCAT(L0,{G0})\|>L0:
MAKEGROB G0;1 5 101000001:CONCAT(L0,{G0})\|>L0:
MAKEGROB G0;1 5 000010001:CONCAT(L0,{G0})\|>L0:
MAKEGROB G0;1 5 100010001:CONCAT(L0,{G0})\|>L0:
MAKEGROB G0;1 5 001010001:CONCAT(L0,{G0})\|>L0:
MAKEGROB G0;1 5 101010001:CONCAT(L0,{G0})\|>L0:
MAKEGROB G0;1 5 000000101:CONCAT(L0,{G0})\|>L0:
MAKEGROB G0;1 5 100000101:CONCAT(L0,{G0})\|>L0:
MAKEGROB G0;1 5 001000101:CONCAT(L0,{G0})\|>L0:
MAKEGROB G0;1 5 101000101:CONCAT(L0,{G0})\|>L0:
MAKEGROB G0;1 5 000010101:CONCAT(L0,{G0})\|>L0:
MAKEGROB G0;1 5 100010101:CONCAT(L0,{G0})\|>L0:
MAKEGROB G0;1 5 001010101:CONCAT(L0,{G0})\|>L0:
MAKEGROB G0;1 5 101010101:CONCAT(L0,{G0})\|>L0:

ZEROGROB G0;Xmax;Ymax:
REPLACE G0;(1,Ymax);L0(1):
REPLACE G0;(2,Ymax);L0(1):
\->DISPLAY G0:

FOR X=Xmin+2 TO Xmax;
  0\|>R:0\|>I:
  FOR Y=1 TO MIN(.7*X,Ymax) STEP S;
    I+1\|>I:
    R+L1(I)+L2(I)\|>A:
    INT(A/U)\|>R:
    A MOD U\|>A:
    L1(I)\|>L2(I):A\|>L1(I):
    FOR J=1+Ymax-Y TO MAX(2+Ymax-Y-S,0) STEP -5;
      A MOD 32\|>B:
      INT(A/32)\|>A:
      IF B\=/0 THEN
        REPLACE G0;(X,J);L0(B):
      END:
    END:
  END:
  \->DISPLAY G0:
END:
HMS\->(Time)-T\|>T:
ROUND(\->HMS(T)*100,2)\|>T:
{0}\|>L0:{0}\|>L1:{0}\|>L2:
\->GROB G1;T;1:
REPLACE G0;(1,Ymin+8);G1:
\->DISPLAY G0:
FREEZE:

Je divise chaque numéro en groupes de 35 bits. Chaque groupe est dessiné par un boucle de 7 itérations à 5 bits (un GROB par 5 bits).
Temps sur HP40gs : 3'11"
Temps sur émulateur : 7".

[oliverue]

Thank you all for the nice reception!

Gilles59: you're right, in HP UserRPL there's no toBigNum, no toHex, and no image command. These are all ND1 additions.

Until last week I was ignorant of the fact that the HP-49 family added BigNum support and expressions in arrays. It was because of that, that my HP comparison page claimed that this task couldn't be done on other calcs. Boy, was I wrong.

I admire your ingenious creativity to get this to work, in the face of a missing "image" command!

Conversion to hex *strings* and padding is, of course, downright silly. It would be nice if graphic calculators had a command that a permits you to construct an image from a block of binary data, and display it. With a setPixelAt() function, or direct array access, one could then efficiently (and selectively) set pixels and the drawing task would become as small as it ought to be.
I'll soon add binary support to the ND1 image type. (I don't want to sound like a sales person but let me say that ND1 is so open that a "low-level" task like this could also be accomplished by a user--written on the device, with no outside development tools.)

The comp.sys.hp48 newsgroup has some recent not-so-good news about the state of the HPGCC project, which I understand has been the only way to get full ARM performance out of the 50g.

I found this http://sense.net/~egan/hpgcc/ very interesting.

I, too, would be curious to know if a system extension could facilitate the task of constructing a displayable image.

Marcus: missing GROB is a bummer. Sorry. But, then, you have an iPod touch… Check your personal mail.

A+

Oliver

[Gilles59]

Thank you all for the nice reception!

Gilles59: you're right, in HP UserRPL there's no toBigNum, no toHex, and no image command. These are all ND1 additions.

Until last week I was ignorant of the fact that the HP-49 family added BigNum support and expressions in arrays.
A+

Oliver

Hi Oliver

Le projet ND1 m'intéresse mais je n'utilise ni iphone ni ipad ... Quelques remarques et questions :
The ND1 project is interesting. But i own no iphone neither ipad. A few remarks and questions :

1/ Conversion string to hex

C'est possible en RPL/50 avec les commandes S->H et H->S ( remplacer -> par le caractère flèche droite sur la HP)

It's possible in fact:

ex:

"HP" S->H donne "8405"

2/ a command that a permits you to construct an image from a block of binary data, and display it.

Possible aussi Exemple :
"GROB 8 4 AAAAAA" OBJ-> @ To construct :
PICT STO {} PVIEW @ And Display

(ou juste fleche basse si le grob est sur la pile)

« "GROB 130 60 " 1. 390. START "AF0FA" + NEXT OBJ-> »

Il y a aussi ->H qui transforme l'objet dans son codage hexa (avec un en-tête).
#123456789d ->H donne "E4A2051000E416CB000000000000"

Il suffit ensuite de virer l'en-tête.
You only have to delete the header

H-> fait l'inverse

The H-> do the reverse thing. For exemple you can create a graphic object (GROB) directly in hexadecimal (you can code the header also)....

Vous avez aussi les commandes pour trouver l'adresse mémoire d'un objet (-A) et avec PEEK et POKE bidouiller dedans.

You also have commands to find the adresse of an object (->A) and peek or poke inside him


3/ What is the internal structure of BigInt in ND1 ? The internal structure for BigInt in HP50 looks strange for me. 123 is in hexa "3210" ...

***

[Gilles59]

Un exemple vaut mieux qu'un long discours. Concernant la génération directe d'objet graphique :

Code : Tout sélectionner

« 
 "GROB 64 80 "
  -> g
  «         
   #1d DUP
   1. 80. START 
     DUP2 + 
     ROT ->H 11 26 SUB 'g' SWAP STO+
   NEXT
  DROP2
  g OBJ->
  »
»

[/size]

(replacer -> par la flèche qui va bien su HP)

EVAL donne :



Si ->H permettait de convertir les 'bigint' en héxa, comme les 'int', ce progr générerait toute taille de graph avec la ram de la HP comme seule limite

Variante sans variable de 97,5 octets :

Code : Tout sélectionner

« 
 "GROB 64 80 "           
 1 R->B DUP
 1. 80. START 
    DUP2 + 
    ROT ->H 11 26 SUB
    4. ROLL SWAP +
    UNROT 
  NEXT
  DROP2
  OBJ->
»

[/size]

[C.Ret]

Bon, j'ai enfin pu mener à bien l'impression du graphique par découper/coller des copies d'écran du HP28S.

Il a fallu plusieurs heures (un peu plus de 4, je n'étais pas à coté donc je n'ai pas de chronomètrage précis).

Le code utilisé est donné ci-dessous, il utilise trois astuces :
- comme précèdemment, les nombres de Fibanocci sont 'tronçonnés' en octet pour correspondre directement aux codes graphiques binaires à l'aide de la fonction ->LCD (ancètre des GROB des HP48/49/50),
- pour gagner du temps, les blancs en débuts de lignes ne sont pas calculés, l'ancienne version perdait beaucoup trop de temps à calculer des pages entière de zéros. Le tableau (en fait une liste) OFF contient le nombre de 'blancs' en début de chaque ligne graphiques. Ceux-ci seront en quelque sorte ajouter lors de l'impression,
- pour économiser la mémoire, après chaque impression, les codes graphiques de chaque ligne sont effacés en ne gardant que les deux derniers qui permettront de calculer les colones suivantes. Cela évite d'avoir jusqu'à 411 caractères par ligne dont seulement les 137 derniers servent.

Code : Tout sélectionner

«
  1 CHR DUP + {} + 'GRL' STO                                       @ Initialise liste des lignes graphiques
  { 0 } 'OFF' STO                                                  @ Tableau des 'OffSet'
  CLLCD LCD-> 'LCD0' STO                                           @ LCD0, affichage blanc 

  3 411 FOR n                                                                   
      0
      1 GRL SIZE FOR i                                             @ Pour chaque ligne graphique
         'OFF' i GET -> o
            « 'GRL' i DUP2
              GET 
               DUP n o - 2 - DUP SUB NUM 5 ROLL +
              OVER n o - 1 - DUB SUB NUM +                         @ Additionne retenue, rang n-2 et n-1

              256 MOD                                              @ limite à un octet (un caractère graphique)
              LAST / IP 5 ROLLD                                    @ Calcul retenu pour ligne suivante
 
              CHR + PUT
            »
         IF n 137 MOD NOT                                          @ Toutes les 137 colones, impression
         THEN
             i 1 - 4 MOD 1 + -> l
                « IF i 1 == 
                  THEN "------------------------" PR1 DROP END     @ Une ligne de tirets pour marquer le haut du graph
                  LCD-> 
                  LCD0 'GRL' i GET + DUP SIZE DUP l 137 * - 1 +
                  SWAP SUB LCD0 + 1 548 SUB OR ->LCD               @ Affiche les pixels à l'écran 
                  IF l 4 == THEN PRLCD 25 WAIT CLLCD END           @ Lors de la 4ieme ligne, imprime copie d'écran

                  'GRL' i DUP2 GET DUP SIZE DUP 1 - SWAP SUB PUT   @ Retire la partie affichée (pour soulager mémoire)
                  'OFF' i n 2 - PUT                                @ Met à jour l'OffSet
                »
         END
      NEXT
      n 1 DISP 1 WAIT
      IF DUP                                                       @ retenue sur dernière ligne graphique
      THEN 
         CHR 0 CHR SWAP + GRL SWAP + 'GRL' STO                     @ ajout d'une nouvelle ligne
         OFF n 2 - + 'OFF' STO                                     @ met à jour les 'OffSet'
      ELSE
         DROP
      END
      CLLCD
  NEXT
  CLMF
»

[Gilles59]

Bon, j'ai enfin pu mener à bien l'impression du graphique par découper/coller des copie d'écran du HP28S.

Il a fallu plusieurs heures (un peu plus de 4, je n'étais pas à coté donc je n'ai pas de chronomètrage précis).

Le code utilisé est donné ci-dessous, il utilise trois astuces :
- comme précèdemment, les nombres de Fibanocci sont 'tronçonner' en octet pour correspondre directement aux codes graphiques binaires à l'aide de la fonction ->LCD (ancètre des GROB des HP48/49/50),
- pour gagner du temps, les blancs en débuts de lignes ne sont pas calculé, l'ancienne version perdait beaucoup trop de temps à calculer des pages de zéro. Le tableau (en fait une liste) OFF contient le nombre de 'blancs' en début de chaque ligne graphiques. Ceux-ci seront en quelqeu sorte ajouter lors de l'impression,
- pour économiser la mémoire, après chaque impression, les codes graphiques de chaque ligne sont effacés en ne gardant que les deux derniers qui permettront de calculer les colones suivantes. Cela évite d'avoir jusqu'à 411 caractères par ligne dont seulemetn les 137 dernier vont servir.

Bravo... et 4 h c'est bien pour cette machine et cette taille de sortie, j'aurai cru plus. Les astuces sont bien vues ...

[Gilles59]

Bsr,

j'ai essayé de pousser la HP50 a ses limites ( pour la taille du dessin plus que la vitesse et pour du User RPL ) et j'arrive à un graphe de 1600 x 1200 (fibo de 1600 donc)

pour le voir :

GROB Fibo HP50 1600x1200

mais le paysage devient monotone

Je vous mets le prog ci-apres mais à utiliser avec prudence car c'est la premiere fois que j'utilise les peek et poke sur cette machine ! C'est stable mais je me suis fait quelques frayeurs en écrivant le logiciel. En fait je calculais _une fois_ l'adresse de l'objet graphique et l'utilisais pour mes poke... C'est visiblement ce qu'il ne faut pas faire car je soupçonne la 50 de déplacer les objets en mémoire ! D'où jolis plantages

Cette version est complétement paramêtrée et une fenêtre vous demande de choisir la taille du graphique dans une liste.



Voici le source (si vous changez des choses attention aux poke qui peuvent être violents

Code : Tout sélectionner

« 
"Graphique de Fibonacci "
{
{ "      160 x 120" #120d}
{ "      320 x 240" #240d }
{ "      640 x 480" #480d }
{ "      800 x 600" #600d }
{ "      960 x 720" #720d }
{ "     1120 x 840" #840d }
{ "     1440 x1080" #1080d }
{ "     1600 x1200" #1200d }
}
1
CHOOSE
IF 0 == THEN KILL END

TICKS SWAP

DUP #4d * #3d / DUP2 BLANK 
UNROT 
B->R SWAP 
B->R DUP 
60. / 1 -
#0d  
  -> g y x r a
  « 
   #20d 'a' STO    
   {#1d}
   1. r START { #0d } + NEXT
   DUP
   
   y 10 -
   1.SWAP FOR b 
     DUP2 ADD
     1. r FOR i                       @ Gestion des retenues
       DUP i GET DUP   
       #F000000000000000h AND           @ Récup le premier bit du quartet le plus 'faible' 
       IF #1000000000000000h SAME THEN  @ de l'entier de poids faible et vérifie si il est 'levé' => retenue
          #0FFFFFFFFFFFFFFFh AND         @ Effacfer la retenue 
          i SWAP PUTI
          DUP2 GET #1d + PUT             @ Ajouter 1 dans l'entier de poids fort    
        ELSE
          DROP
        END
     NEXT
   
     ROT 
     1. r 1 +
     1. SWAP START
       GETI ->A #10d + #15d PEEK g ->A a + SWAP POKE
       #15d 'a' STO+
     NEXT 
     DROP2
     b 1  DISP
   NEXT
   DROP2
   g
   TICKS ROT - B->R 8192. / 2 RND "Temps " SWAP + "Sec." + MSGBOX
 »
»

[/size]

Parmi les commandes 'intéressantes' ->A qui donne l'adresse d'un objet en mémoire. C'est à partir de cette base que je vais 'poker' directement dans le graphe