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 : 7099
Inscription : 31 janv. 2008 15:24
Localisation : Banlieue Paârisienne
Contact :

Idée de programme : dessin de nombres

Message par gege » 25 déc. 2010 19:42

Bonjour,

Comme on a tous reçu plein de cadeaux sans intérêt (cravates, vins fins, bouquins sur le tricot en apnée, montres / bijoux, voyages de 15 jours à Tahiti, voiture de luxe...) et qu'il faut faire semblant de lire leur satané bouquin (ou autre), je vous propose de glisser entre les pages une petite caltos et de faire un joli dessin.
Le thème est vaguement mathématique, mais tout ce qu'il faut connaître c'est l'addition :D

En fait regardez -> cette page <- où je suis arrivé en lisant le forum du HP Museum.
Pour résumer, il faut dessiner avec des pixels la représentation en binaire des nombres de bernouilli, un par ligne.

Rappel sur les nombres de Bernouilli : B1=1, B2=1 et ensuite pour obtenir le prochain ou fait la somme des deux qui le précèdent.
Donc B3=2, B4=3, B5=5... vous avez compris.

Pour vous motiver, le gars qui a pondu la page ci-dessus dit que son programme est le seul qui puisse faire ça... bwaahahaaa
Vous valez mieux que ça, non ???
A bientôt
G.E.

Avatar de l’utilisateur
C.Ret
Fonctionne à 2400 bauds
Fonctionne à 2400 bauds
Messages : 2391
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 » 25 déc. 2010 22:39

Bon Noël à Tous,

Moi aussi j'ai eut du vin en cadeau cette année. Mais je n'ai pas ouvert ces bouteilles. Pas encore.

Je suis surpris, le Nombre de Bernouilli que je connaissait sont plutôts ceux de la série de rationels :
B(n)= Image

La suite de nombres se définissant à partir de al somme des deux précèdents, je pense me souvenir qu'elle correspond à ce que l'on appelle la suite de Fibonacci :
Image



Maintenant, je suis d'accord sur un point, pas besoin de Wolfram ou de Mathematica pour réaliser cette représentation en Pixels Binaires. Représentation qui ressemble étrangement à une fractale d'ailleurs.

Et éteindre/allumer ou noircir ces pixels doit effectivement être à la porté de tout dispositif d'impression à matrice ou d'afficheur LCD.

Et c'est pas parce que les registres mémoire d'une calculatrice se limitent à 12 chiffres, qu'elle ne peut pas calculer
F(400)=176023680645013966468226945392411250770384383304492191886725992896575345044216019675.

Lui faudra simplement utiliser 8 de ses registres à 12 chiffres pour calculer et afficher cela.

Par ailleurs, log(F400)/log(2) ~= 276.535...
Il faudra donc pas moins de 277 bits pour représenter ce nombre en binaire.

A raison d'un maximum de 39 bits par registre à 12 chiffres de notre calculatrice, la même calculatrice n'aura donc toujours besoin que de ses 8 registres pour représenter binairement ce nombre et pouvoir l'afficher ou l'imprimer.


Le plus difficile dans tout cela est de choisir la calculette en question et éventuellement son imprimante.
SHARP PC-1211 + CE-121 + CE-122. | VIC 20 Commodore 128D + Printer P-803 + SD2iec. | TI-57 LCD | HP-28S + HP82240A | TI-74 BasiCalc | HP-41C + (2 memory + stat + IR) | HP-15C | HP Prime Color Touchscreen Graphing Calculator| TI-92 II | CASIO fx-602p + FA-1 | HP-71B 64K+JPC-ROM+HPIL+card reader . Sommaire des M.P.O..

pascal_meheut
Fonctionne à 1200 bauds
Fonctionne à 1200 bauds
Messages : 307
Inscription : 25 sept. 2008 06:40

Re: Idée de programme : dessin de nombres

Message par pascal_meheut » 26 déc. 2010 08:22

Ca ne serait pas plutôt les nombres de Fibonacci ?

http://fr.wikipedia.org/wiki/Suite_de_Fibonacci
Pas mal de HP de la 55 à la 48, 97.... Casio 702p, 890P, AI-1000 et PB-2000C, WP34s dont j'écris les émulateurs et la version iOS
Je cherche les modules Pascal et Prolog pour la PB-2000C

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

Re: Idée de programme : dessin de nombres

Message par gege » 26 déc. 2010 11:24

Oh la la, vous avez raison, j'ai oublié d'allumer le cerveau.
Dont acte, il s'agit bien de Fibonacci.
C.ret, une des formules des nombres de Bernoulli serait plutôt :
Image
(merci Wikipedia)

Je tape mon programme et on en parle.
A+
G.E.

Avatar de l’utilisateur
C.Ret
Fonctionne à 2400 bauds
Fonctionne à 2400 bauds
Messages : 2391
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 » 26 déc. 2010 17:58

Merci pour cette formule de Bernouilli qui est la bienvenue car elle explique bien purquoi il s'agit de nombres rationels.

Pour commencer simplement, je présenterais un premier bout de code , pour HP28S (mais utilisant uniquement du RPL simple et compatible à toute la famille des HP28 à HP50).

Ce premier programme permet de calculer sans arrondi les nombre de Fibanocci pour n allant de 2 à 59 :

Code : Tout sélectionner

« -> n
     « 0               //  F0  soit   F(n-1) pour n=1
       1               //  F1  soit   F(n)   pour n=2
                            
       2 n START       //  Calcul des F(n) pour n>1 par iteration

          DUP ROT +    //  F(n+1) <-- F(n-1) + F(n)

       NEXT

       SWAP DROP       //  efface F(n-1) pour ne laiser que le résultat F(n)
     »
»
'FIB' STO
Usage: prend n dans la pile et le remplace par F(n).


En RPL c'est assez simple, il suffit dans la boucle de calcul de laisser les nombres F(n-1) et F(n) et de calculer F(n+1) en faisant disparaitre F(n-1) de la pile.
Cette version ne fonctionne pas pour n=0 mais peu importe, on cherche à aller vers les grand n.

Avec ce programme, LAST retourne l'élément F(n-1), ce qui peut être utile pour implémenter le calcul des éléments suivant sans reprendre l'itération depuis le début.

Inconvénient, à partir de n=60, les 12 chiffres de mon HP28S ne sont plus suffisants pour représenter F(n) complètement (manque les derniers chiffres !).


Donc l'avantage principal que je trouve à cet algorithme est qu'il permet facilement d'obtenir F(n) avec tous les chiffres par une très simple modification:

Code : Tout sélectionner

« -> n
     « [0 0 0 0 0 0 0 0]    //  F0  soit   F(n-1) pour n=1
       [0 0 0 0 0 0 0 1]    //  F1  soit   F(n)   pour n=2
                            
       2 n START            //  Calcul des F(n) pour n>1 par iteration

          DUP ROT +         //  F(n+1) <-- F(n-1) + F(n)
          ACarry            //  Reporte les retenues
       NEXT

       SWAP DROP            //  efface F(n-1) pour ne laiser que le résultat F(n)
     »
»
'AFIB' STO
Usage: prend n dans la pile et le remplace par le vecteur [ F(n) ] composé de huit éléments donnant tout les chiffres de F(n).
L'algorithme est fondamentalement le même, on obtient les F(n) par itérations en maintenant les termes F(n-1) et F(n) dans la pile.
Le HP28 permet d'additioner les vecteurs membre à membre pour peu qu'ils soient de la même dimension.

Seule ombre au tableau, cette adition ne tient pas compte du dépassement de capacité de chaque élément. C'est à dire qu'il faut 'manuellement' veiller à ce que le résultat de chaque somme ne dépasse pas la capacité maximale des 12 chiffres.

C'est le rôle de ACarry, qui dès qu'un des élèments du vecteur F(n) dépasse 1E11, l'arrondi et reporte le surplus dans le membre de gauche en tant qu'unité.
C'est en fait tout simplement le principe de la retenue que nous utilisons pour toute opération posée sur le papier.

Code : Tout sélectionner

« 0 SWAP                    // Initialise la retenue à zéro
  8 1 FOR i                 // Parcours le vecteur de droite à gauche
       i DUP2                 
       GET                    // Elément i de F(n)
       4 ROLL +               // Ajoute la retenue précèdante (ou zéro à défaut)
       1E11 MOD               // Arrondi à 1E11
       LAST / IP              // Calcul la retenue suivante
       4 ROLLD                // Replace la retenue dans la pile
       PUT                    // Replace l'élément arrondi à sa position dans le vecteur F(n)
  -1 STEP
  IF SWAP THEN ERROR END   // Si dernière retenue non nulle, alors erreur de dépassement
»
'ACarry' STO
Usage : Transforme le vecteur [ x8 x7 x6 x5 x4 x3 x2 x1] en vecteur [ e8 e7 e6 e5 e4 e3 e2 e1] dont tous les éléments sont des entiers de 11 chiffres au maximum.

Ex: [0 0 0 0 0 0 23 123456789012] ---> [0 0 0 0 0 0 24 23456789012]



C'est avec ce code, qu'en quelques minutes, on arrive à afficher toutes les décimales de F(400):
400 AFIB returns [ 1760236 80645013966 46822694539 24112507703 84383304492 19188672599 28965753450 44216019675]
Image
By c__ret at 2011-01-03

Voilà qui est fort interessant mais qui ne répond pas entièrement à la question, qui sous-entendait une réponse en binaire et graphique.

Ce qui sera l'occasion d'un prochain post.
Dernière édition par C.Ret le 03 janv. 2011 16:22, édité 1 fois.
SHARP PC-1211 + CE-121 + CE-122. | VIC 20 Commodore 128D + Printer P-803 + SD2iec. | TI-57 LCD | HP-28S + HP82240A | TI-74 BasiCalc | HP-41C + (2 memory + stat + IR) | HP-15C | HP Prime Color Touchscreen Graphing Calculator| TI-92 II | CASIO fx-602p + FA-1 | HP-71B 64K+JPC-ROM+HPIL+card reader . Sommaire des M.P.O..

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

Re: Idée de programme : dessin de nombres

Message par gege » 26 déc. 2010 19:12

Bien joué,
ce qui est déprimant avec les machines récentes c'est que le premier programme marcherait en précision illimitée et tu n'aurais jamais à écrire le second...
Maintenant après réflexion il me semble qu'il serait malin de saucissonner les nombres de Fibonacci non en segments coupés à des puissances de 10, mais des puissances de 2. Non ?
G.E.

Avatar de l’utilisateur
C.Ret
Fonctionne à 2400 bauds
Fonctionne à 2400 bauds
Messages : 2391
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 » 26 déc. 2010 20:21

Le saucissonnage binaire est une bonne idée.
J'avais dans un premier temps pensé à utiliser les fonction de conversion R->B (réel vers binaire).

Mais, en observant mon dernier programme travailler, je me rends compte qu'il passe plus de temps à vérifer les retenues qu'à faire les additions.

Par ailleurs, le graph binaire, tel que présenté dans la page en référence, montre que les représentations binaires de tous les nombres de n=1 à 400 sont représentés.

Enfin, la représentation binaire sur la HP28S peut être accélérée en utilisant les propriétés des fonctions d'affichage ->LCD ( ou LCD-> ) qui justement utilise un code binaire pour allumer/éteindre les pixels.

Donc, ...
l'idée initale est modifiée et consistera à 'saucissonner' de façon à pouvoir dessiner par ->LCD au fur et à mesure du calcul de la suite F(n) pour n=1 à ...
SHARP PC-1211 + CE-121 + CE-122. | VIC 20 Commodore 128D + Printer P-803 + SD2iec. | TI-57 LCD | HP-28S + HP82240A | TI-74 BasiCalc | HP-41C + (2 memory + stat + IR) | HP-15C | HP Prime Color Touchscreen Graphing Calculator| TI-92 II | CASIO fx-602p + FA-1 | HP-71B 64K+JPC-ROM+HPIL+card reader . Sommaire des M.P.O..

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

Re: Idée de programme : dessin de nombres

Message par Gilles59 » 26 déc. 2010 21:29

gege a écrit :Bonjour,

Comme on a tous reçu plein de cadeaux sans intérêt (cravates, vins fins, bouquins sur le tricot en apnée, montres / bijoux, voyages de 15 jours à Tahiti, voiture de luxe...) et qu'il faut faire semblant de lire leur satané bouquin (ou autre), je vous propose de glisser entre les pages une petite caltos et de faire un joli dessin.
Le thème est vaguement mathématique, mais tout ce qu'il faut connaître c'est l'addition :D
(...)
G.E.
;) Bonsoir à tous !
Première étape sur la HP50 en repompant carrément le prog de c.ret qui fonctionne tel quel en précision illimité sur HP50.
FIB(400) donne le nombre qui va bien avec tous les chiffres.

Pour transformer l'entier en binaire, rien de plus simple, il suffit d'ajouter la séquence :
->STR "#" SWAP + "d" + BIN OBJ->
à la fin

Code : Tout sélectionner

« -> n
     « 0               
       1               
       2 n START       
          DUP ROT +    
       NEXT
       SWAP DROP       
     »
->STR "#" SWAP + "d" + BIN OBJ->
»
'FIB' STO
Reste à transformer en graphique ce qui à priori doit tenir quelques lignes de code... je teste et reviens ;)
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
C.Ret
Fonctionne à 2400 bauds
Fonctionne à 2400 bauds
Messages : 2391
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 » 26 déc. 2010 22:39

Voilà justement la calculatrice typique d'aujourd'hui :
- calcul sur nombre quasi infini de chiffre à l'aide des opérateurs courrant etsans avoir à programmer quoique ce soit,
- représentation graphique possible du binaire facile à réaliser et à transférer.

Ce n'est pas le cas de la HP28S.
En particulier, son affichage limité à 32x137 pixels va m'obliger à 'saucissonner' et 'copier/coller' plusieurs écran (et/ou leur impressions) pour obtenir le graph binaire recherché.

En effet pour chaque ligne du graph, il faut prévoir les 277 bits nécessaires à représenter F(400)
Il y aura donc 400 ligne (une ligne par F(n) avec n allant de 1 à 400).

En plus, le "codage binaire" de l'affichage LCD-> se fait dans l'autre sens. SI je ne veux pas perdre l'avantage de cette astuce, il faut donc que je trace le graphique transposé : les F(n) binaires seront tracé sur chaque colone.

Il me faudra donc horizontalement trois écrans (chaque écran fait 137 pixels)
Ecran A : n=0 à 136 Ecran B: n=137 à 273 Ecran C: n=274 à 411
Et verticalement, les 32 pixels permettent la capture de 4 octets ( 4x8 bits)
Il faudra donc pas moins de 9 écrans de 32 pixels superposés pour représenter le graphisme envisagé !

Soit un total de 9 x 3 = 27 captures d'écran !
Tout cela juste pour afficher/imprimer un bitmap de 411x288 pixels.

Je ne suis pas loin d'abondonner le projet sur une HP-28S (surtout que ce très cher Gille59) va faire cela en une vingtaines d'instruction sur son HP50 (et en prime un transfert USB de quelques secondes pour obtenir une copie de son BitMpa sur son PC et donc très vite sur ce forum).

Heureusement que l'impression peut être programmée, il suffiera alors de rassembler trois bandes de papier.

J'attends de voir si d'autre(s) mordu(s) de retro-programming saurons relever le défit et imprimer ce graphisme - comme cela avait été fait pour les Flocons de Khor et les autres fractales.
SHARP PC-1211 + CE-121 + CE-122. | VIC 20 Commodore 128D + Printer P-803 + SD2iec. | TI-57 LCD | HP-28S + HP82240A | TI-74 BasiCalc | HP-41C + (2 memory + stat + IR) | HP-15C | HP Prime Color Touchscreen Graphing Calculator| TI-92 II | CASIO fx-602p + FA-1 | HP-71B 64K+JPC-ROM+HPIL+card reader . Sommaire des M.P.O..

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

Re: Idée de programme : dessin de nombres

Message par Gilles59 » 27 déc. 2010 00:34

C.Ret a écrit :Voilà justement la calculatrice typique d'aujourd'hui :
- calcul sur nombre quasi infini de chiffre à l'aide des opérateurs courrant etsans avoir à programmer quoique ce soit,
- représentation graphique possible du binaire facile à réaliser et à transférer..
Je me suis avancé un peu vite ! En fait je bute sur un problème : un entier en "précision infini" trop long ne peut pas se convertir pas en binaire ou hexa limités à 64 bits. Bref mon programme ne fonctionne pas pour FIB >93

je vais faire autrement mais un plus plus long (générer dans une chaine alpha la représentation hexadécimale de l'entier précision infinie

Gege où est le source du prg dans le lien que tu as donné ? je ne le vois pas.

PS : bon c'est même encore plus compliqué que ce que je dis ci dessus...si je ne veux pas dessiner point par point, il faut passer de "entier infini" -> binaire ( mais géré à la mimine sur la HP50 car les entiers "normaux" sont limités à 64 bits) -> hexa (à la mimine encore). A la fin on génère le graph avec la commande GROB. Ca devient relativement lourd mais en USER RPL je ne vois pas comment faire autrement (sauf a dessiner point par point bien sur mais çà impose de toute façon une conversion entier infini -> binaire)

Pour info, voilà comment je convertissait un entier "infini" en binaire :

Code : Tout sélectionner

« -> n
   « IF n 2 <= THEN
       1
     ELSE   
       0 1                                        
       2 n START       
         DUP ROT +    
        NEXT
        SWAP DROP       
      END
    » 
     DUP BIN
     ->STR "#" SWAP + "d" + OBJ-> 
»
'FIB' STO
Mais limité à 64 bits :(
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
C.Ret
Fonctionne à 2400 bauds
Fonctionne à 2400 bauds
Messages : 2391
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 » 27 déc. 2010 01:16

La HP28S a la même limitation sur 64 bits pour les entiers binaires/ocatals/hexadecimal


Une méthode serait de 'saucissonner' F(n) dans une liste en le découpant tous les 64 bits.


Donc, même pour une HP50, mon programme style ACarry peut être utile.



Concernant l'avancemetn sur HP28S, je 'saucisonne' encore plus fort, en fait octet par octet afin de profiter d'une "ruse" pour dessiner plus vite sur l'écran LCD la représentation binaire (et donc l'imprimer).


Mais :




Représenter F(400) nécessite 277 bits c'est à dire 35 octets, 9 écrans de quatre ligne (une ligne fait un octet)

L'idée est d'utiliser deux vecteurs de 35 octets (en fait 35 éléments compris entre 0 et 255)

On ne fait qu'une fois la boucle de 1 à 411.
A chaque pas, on calcule la F(n) à partir des deux précèdents.

Pour chaque éléments, on tient compte les éventuelles retenues et on en reporte une si nécessaire.

En même temps, on ajoute l'octet à afficher/imprier dans l'une des 35 lignes graphiques.

Les données sont donc :
les vecteurs F(n-1) et F(n) de 36 éléments FA FB
la liste des 36 lignes graphiques sous forme de chaine de caractère au format compatible ->LCD
GROB


Pour éviter de surcharger la mémoire de cette pauvre HP28S, les 35 lignes graphiques seront affichées 4 par 4 (un écran) au fur et à mesure de l'avancement

du calcul dès que leur logneur fera 137 caractères (pour les 137 pixels d'une ligne graphique).

Code : Tout sélectionner

« 1 36 START "" NEXT 36 ->LIST 'GROB' STO     // création de la liste GROB                    
  {36} 0 CON                                  // création de F(0):[ 0 0 0 ... 0 0 0]
  DUP 36 1 PUT                                // création de F(1):[ 0 0 0 ... 0 0 1]

  1 411 FOR n                                 // boucle principale n1 à 411

      DUP ROT +                               // calcul de F(n) brute (élément > octet)      
      ""                                      // prépare prochaine page graphique
      0                                       // initialisation retenue
      ROT                                                                               
                                                                                        
      36 1 FOR i                              // parcours des éléments/ligne de F(n)    
           i DUP2                                                                       
           GET                                // récupère élément i de F(n)             
           4 ROLL +                           // ajoute éventuelle retenue précèdente   
           256 MOD                            // limite à un octet                      
           LAST / IP                          // calcule retenue                       
           4 ROLLD                            // replace la retenue suivante           
                                                                                       
           'GROB' i DUP2                      
           GET                                // récupère ligne graphique i
           4 PICK CHR +                       // ajoute octet de la colone n
               
           8 ROLL OVER +                      // Ajoute line graphique à prochain écran
           IF                
               i 1 - 4 MOD NOT                // toutes les 4 lignes 
           THEN  

              IF n 137 MOD NOT                // et toutes les 137 colones
              THEN
                 ->LCD
                 IF 1 FS?                        // Si flag levé imprime hardcopy écran
                 THEN  PRLCD 
                     IF i 36 == THEN CR CR END   // saute quelque lignes pour faciliter découpage
                 END
                 DROP "" DUP                     // remet à zéro ligne graphique
              END
              DROP ""                         // remet à zéro écran graphique
           END
           8 ROLLD                            // prépare prochain écran graphique 

           PUT                                // met à jour ligne graphique dans le GROB

           PUT                                // met à jour valeur de l'octet dans vecteur F(n)
      -1 STEP
      IF SWAP THEN ERROR END
      SWAP DROP
  NEXT
»
'DRWBINFIB'
La génération du graphique est en cours.
Et sa copie va parvenir après découper/coller du ruban d'impression et scan.
SHARP PC-1211 + CE-121 + CE-122. | VIC 20 Commodore 128D + Printer P-803 + SD2iec. | TI-57 LCD | HP-28S + HP82240A | TI-74 BasiCalc | HP-41C + (2 memory + stat + IR) | HP-15C | HP Prime Color Touchscreen Graphing Calculator| TI-92 II | CASIO fx-602p + FA-1 | HP-71B 64K+JPC-ROM+HPIL+card reader . Sommaire des M.P.O..

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

Re: Idée de programme : dessin de nombres

Message par gege » 27 déc. 2010 01:52

Gilles59 a écrit :Gege où est le source du prg dans le lien que tu as donné ? je ne le vois pas.
Moi non plus.

Eh bien ça phosphore dur, bravo !
Mes vacances sont finies, je vais me coucher... :|
Salut
G.E.

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

Re: Idée de programme : dessin de nombres

Message par Gilles59 » 27 déc. 2010 02:54

bon me voila relevé ma fille est malade :(
heuresement je ne bosse pas demain

Le site http://naivedesign.com/ND1/Specs.html est intéressant mais le site ne semble pas fini et ils disent aussi quelques bétises.
La HP50 calcule sans soucis 1000! par exemple et avec 2568 chiffres. Idem sur les expressions symbolique dans les matrices possibles en 50g

M'enfin ca semble un beau boulot. Dommage que ca ne tourne que sur iphone/ipad si j'ai tout saisi

J'ai trouvé le code là (pour la partie dessin) : http://naivedesign.com/ND1/Dissecting_FibTriangle.html

Dans l'idée c'est exactement ce que je voulais faire sur la HP50, mais il faut écrire "toHex" et aussi "Pad" (compléter une chaine jusque une longueur donnée par un caractère)

Sauf erreur de ma part, il n'y a pas non plus de fonction "image" sur la 50 mais on peut ruser avec GROB pour faire la même chose (générer un chaine alpha puis OBJ->). Grob a une syntaxe curieuse sur 48 & co. puisque "postfixée" : GROB largeur hauteur suite_code_hexadecimaux. Mais on peut construire l'objet par programme en générant une chaine "GROB ....." puis OBJ->
Je ne sais pas si ca marche sur la 28S mais ca simplifierait je crois. Je ne connais pas de moyen d'entrer en User RPL un "objet binaire" de taille illimitée sur la pile, sans doute pour çà qu'une fonction type IMAGE n'existe pas

Je vois aussi que le programme ne s'embéte pas pour être au pixel pret en largeur. je vais suivre çà, çà simplifie bien

Reste que les images de ce site laisse voir ce que serait une HP51G avec une meilleure résolution et écran couleur.

A+
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+

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

Re: Idée de programme : dessin de nombres

Message par Gilles59 » 27 déc. 2010 03:21

Avant de retourner au lit, je vous laisse méditer sur çà :

Code : Tout sélectionner

«  [[0 1][1 1]] SWAP ^ { 2 1 } GET  » 'Fibo' STO 
Ca marche... même avec 400 Fibo lol ( et 1 et 2 aussi !)

PS : J'y suis pour rien, trouvé là : http://thedailyreviewer.com/hardware/vi ... -116209602
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
Marsupilami
Fonctionne à 300 bauds
Fonctionne à 300 bauds
Messages : 262
Inscription : 16 oct. 2008 01:03
Localisation : Jamais très loin d'un Atari 800 XL
Contact :

Re: Idée de programme : dessin de nombres

Message par Marsupilami » 27 déc. 2010 11:35

Salut les gars, je vois que tout le monde n'a pas asser mal au crane après les fêtes de noel :)
Continuez ca m'épate et puis j'adore les fractales, le résultat ressemble fort à une IFS ;)
https://www.atarinside.com : Atari 800 XL - Référence Atari France/UK/Benelux/Allemagne - Photos HD de cartes mères 800XL - Atari 800 XL revue de presse.

Répondre

Revenir vers « Tous les Pockets »