Programmer en RPL

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
Gilles59
Fonctionne à 2400 bauds
Fonctionne à 2400 bauds
Messages : 1602
Enregistré le : 27 oct. 2010 20:46

Re: Programmer en RPL

Message par Gilles59 »

kweeky a écrit :
gege a écrit :OK, intéressant mais comme tu le soulignes le Logo ne se limite pas à la tortue, mais propose la définition de procédures avec paramètres, des structures de contrôle etc...
Ca ne me semble pas du tout (du tout) évident, il faut faire tout un interpréteur.
C'est vrai que ce sont les structures complexes et les définitions de procédure qui vont être gênantes. Car si c'est juste pour faire une tortue graphique, la définition de quelques mots suffit, ce qui permet de créer son programme LOGO directement en RPL (cf. fil sur les fractales). Il y a quand même un air de parenté entre le LOGO et le RPL par la facilité de définir de nouveaux mots qu'on pourra utiliser comme les instructions internes de la machine dans un programme. Ce qu'on peut faire aussi dans le FORTH (et là la parenté est accentuée par l'usage d'une pile).

Bon courage à Gilles, en tout cas...
Je cherche un endroit qui décrit plus précisément la syntaxe du Logo. Le truc un peu génant c'est que dans certains cas je vois par exemple SOMME [ x y] dans d'autres SOMME x y ou encore SOMME :x :y Idem pour les "template iteration" "porperty list" décrite tres sommairement.

Code : Tout sélectionner

Logo provides several common control structures.

        * ifelse test [ do_if_true list ] [do_if_false list]

There are iteration commands

        * while condition [instruction list]
        * until condition [instruction list ]
        * repeat number [instruction list]

Recursion is Logo's preferred processing paradigm.
Ca ca me plait bien ;) Le test ifelse est tres proche du test ifte de RPL. En logique de pile çà devient :

{ instruction list } condition TantQue
etc.

Apres j'ai deux grands choix :
- soit un traducteur (interpréteur) de Logo classique en RPL. (c'est complexe)
- Soit une variante de Logo fonctionnant en RPN (c'est facile - les langages sont tres proches même si ils semblent tres différents à premiere vue).

J'aperçois que j'ai inversé TourneDroite et TourneGauche dans le prg!
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+ CM14 et MM12 / Alice 32
Avatar du membre
C.Ret
Fonctionne à 9600 bauds
Fonctionne à 9600 bauds
Messages : 3404
Enregistré le : 31 mai 2008 23:43
Localisation : N 49°22 E 6°10

Re: Programmer en RPL

Message par C.Ret »

J'encourage fortement la seconde solution. Quitte à avoir comme pour la Tortue, une Polish Inverted Turtle.

Car, c'est comme le Lisp, mis à part la convention et la syntaxe légale, rien n'interdit de chainer 'à l'envers' et donc de retrouver l'opérateur en fin de liste :

{ + 2 3 } retourn 5 en Lisp

En inversant l'ordre de chainage de la liste : on obtient qulque chose de fort similaire à du RPL/RPN :
<< 3 2 + >> (notez que je n'ai pas écrit << 3 2 +>> !)

Ce qui fait que
* REPETE nombre [jeu d'instructions]
pourrait s'écrire
<< jeu d'instruction >> num REPETE
et correspndre à

Code : Tout sélectionner

« -> PrgLst n 
  « 1 n START
         PrgLst EVAL
    NEXT
  »
»
Reste à trouver une syntaxe convenable pour introduire les variables.

En Logo les variables ne sont pas définies paravance et peuvent être utilisée à tout moment :
Par exemple:

Code : Tout sélectionner

SOMME 5 4 :A 
Mémorise 5 dans A.
La syntaxe abrégée utilisant les ":" est embettante pour notre implémentation en RPL.
Je préfére l'utilisation d'une primitive logo:

Code : Tout sélectionner

MEMORISE SOMME 5 4 'A
En Reverse Notation Logo (RNL) , cela devrait ressembler à :
4 5 SOMME 'A' MEMORISE qui ressemble fort à << 4 5 + 'A' STO >>

Je suis plus très sûr que le RPL et le Logo renversant soit tout à fait deux languages distincts !
SHARP PC-1211 PC-1360 EL-5150 PC-E500 | Commodore C=128D | Texas Instruments Ti-57LCD Ti-74BASICalc Ti-92II Ti-58c Ti-95PROCalc Ti-30XPROMathPrint | Hewlett-Packard HP-28S HP-41C HP-15C HP-Prime HP-71B | CASIO fx-602p | NUMWORKS | Graphoplex Rietz Neperlog | PockEmul | Sommaire des M.P.O. | Ma...dov'il sapone.
Gilles59
Fonctionne à 2400 bauds
Fonctionne à 2400 bauds
Messages : 1602
Enregistré le : 27 oct. 2010 20:46

Re: Programmer en RPL

Message par Gilles59 »

C.Ret a écrit :J'encourage fortement la seconde solution. Quitte à avoir comme pour la Tortue, une Polish Inverted Turtle.

Car, c'est comme le Lisp, mis à part la convention et la syntaxe légale, rien n'interdit de chainer 'à l'envers' et donc de retrouver l'opérateur en fin de liste :

{ + 2 3 } retourn 5 en Lisp

En inversant l'ordre de chainage de la liste : on obtient qulque chose de fort similaire à du RPL/RPN :
<< 3 2 + >> (notez que je n'ai pas écrit << 3 2 +>> !)

Ce qui fait que
* REPETE nombre [jeu d'instructions]
pourrait s'écrire
<< jeu d'instruction >> num REPETE
....
Pas le temps d'avancer sur çà mais je vais rester sur une base RPL et utiliser les mécanismes d'édition du RPL. La contrainte que cela impose c'est que je ne pourrai pas utiliser certains mots clés type := mais pas tres génant.

Dans les LOGO français, MEMORISE que tu proposes ci dessus est en fait DONNE (avec l"image d'une boite qui s'appelle 'A' à laquelle on donne 9. L'idée c'est _met dans_...

Pas trouvé les instructions de traitement de liste du LOGO mais avec tout ce qui existe en RPL (les HEAD, TAIL, DOLIST DOSUB et j'en passe) , je ne vois pas trop où çà bloquera.

Code : Tout sélectionner

-1-

POUR CARRE :LG
   REPETE 4 [AV :LG TD 90]
FIN

serait par exemple :

-2-

<< 'LG' DONNE
   << LG AV 90 TD>> 4 répéte
>> 'CARRE' Pour
L'idée c'est POUR ( nom du mot, contenu)... Même si j'y trouve peu d'intérêt traduire -1- en -2- ne semble pas insurmontable.Je finalise -1- et on verra

Je vais me baser sur ce site :
http://certis.enpc.fr/~keriven/Info/Pro ... elLogo.pdf

Dommage que le chapitre consacré au liste en Logo est... vide.

A noter :

Code : Tout sélectionner

POUR Khor :L
  SI :L < 5 [AV :L ]
      [ Khor :L / 3 TG 60
        Khor :L / 3 TD 120
        Khor :L / 3 TG 60
       Khor :L / 3 ]
FIN
VE
Repete 3 [ Khor 90 TD 120 ]
CT
Pour les listes en Logo, trouvé ceci : http://fr.wikibooks.org/wiki/Programmation_Logo/Listes
Quasiment tout est natif ou facile en RPL. Mais cet article ne détaille pas assez les commandes Logo et il semble y avoir de subtiles différences
Une liste peut comporter zéro élément, ou un seul élément, ou plusieurs éléments. Un élément d'une liste peut être un mot OU UNE LISTE.
OK...Comme en RPL. Si ce n'est qu'un élément de liste peut aussi être un tableau, vecteur, image, un programme etc..
Exemples de listes :
à zéro élément (liste vide) : []
à un élément : [abc] ou : [ [1 2 3] ] ou même : [[Jean Dupont [place du marché] [46200 Souillac]]]
à plusieurs éléments : [x y z] ou : [Jean Dupont [place du marché] [46200 Souillac]]
Idem en RPL en mettant { } à la place de [ ] (les crochets sont réservées aux tableaux/matrices sur la hp)
Fonctions portant sur les listes :
Les fonctions COMPTE, PREMIER, DERNIER, SAUFPREMIER et SAUFDERNIER opèrent de la même manière sur une liste que sur un mot.

COMPTE, PREMIER, DERNIER, SAUFPREMIER et SAUFDERNIER

Code : Tout sélectionner

Idem en RPL

COMPTE :

{ Rouge vert bleu } SIZE 
->
3

PREMIER :

{Rouge vert bleu} HEAD
->
'Rouge'

DERNIER :

{Rouge vert bleu} DUP SIZE GET

ou

{Rouge vert bleu}  REVLIST HEAD   @ Le dernier élément d'une liste est le premier de la liste inversée
->
'bleu'

SAUFPREMIER :

{Rouge vert bleu} TAIL
{vert bleu}

SAUFDERNIER :

{Rouge vert bleu} OBJ-> 1 - ->LIST SWAP DROP

ou 

{Rouge vert bleu} REVLIST TAIL REVLIST
->
{Rouge vert}

Trois autres fonctions opèrent seulement sur des listes :
LISTE :élément1 :élément2 renvoie une liste composée des DEUX éléments, :élément1 et :élément2

Exemple :
ECRIS LISTE "Logo [un langage ultra puissant] Le programme affichera [Logo [un langage ultra puissant]]
LISTE

Code : Tout sélectionner

'Logo' {un langage ultra puissant} 2 ->LIST
->
{Logo{un langage ultra puissant}}
METSPREMIER :élément :liste renvoie la liste :liste augmentée de :élément en première position

Exemple : ECRIS METSPREMIER [Le langage Logo] [va plus loin que les petits dessins] Le programme affichera [[Le langage Logo] va plus loin que les petits dessins]
METSPREMIER

Code : Tout sélectionner

{Le langage Logo} {va plus loin que les petits dessins} SWAP 1 ->LIST SWAP +
->
{{Le langage Logo} va plus loin que les petits dessins}

A noter que si on fait juste :

{Le langage Logo} {va plus loin que les petits dessins} +
->
{Le langage Logo va plus loin que les petits dessins} 

Idem

{ 1 2 3 } { 4 5 6 } +
->
{ 1 2 3 4 5 6}

Alors que Logo donnerait si je comprends bien :

METSPREMIER [1 2 3] [4 5 6]
->
[ [1 2 3] 4 5 6]
METSDERNIER :élément :liste renvoie la liste :liste augmentée de :élément en dernière position

Exemple : ECRIS METSDERNIER 8 [1 1 2 3 5] Le programme affichera [1 1 2 3 5 8]
METSDERNIER
8 { 1 1 2 3 5 } SWAP +
->
{1 1 2 3 5 8}

Si on veut que çà marche exactement comme le Logo, il faudrait plutot faire

8 { 1 1 2 3 5 } SWAP 1 ->LIST +

pour que {8} { 1 1 2 3 5} METSDERNIER
->
{1 1 2 3 5 {8}} et non pas {1 1 2 3 5 8}

Je trouve le LOGO un peu plus logique pour le coup.A moins qu'une commande autre que + m'ait échappé en RPL ?
Je pense qu'il y a encore d'autres commandes LOGO plus puissante sur les listes ...
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+ CM14 et MM12 / Alice 32
Gilles59
Fonctionne à 2400 bauds
Fonctionne à 2400 bauds
Messages : 1602
Enregistré le : 27 oct. 2010 20:46

Re: Programmer en RPL

Message par Gilles59 »

Créé de nouveaux mots mais en fait passé plus de temps avec les exemples donnés sur http://certis.enpc.fr/~keriven/Info/Pro ... elLogo.pdf et autres idées.

Quelques, ex avec le code généralement en haut à gauche du dessin ( ECRIS )

Image

Code : Tout sélectionner

«
  -> cote ang
   « cote Av ang Td cote 2 + ang Spi1  »
» 'Spi1' Pour 
Image

Code : Tout sélectionner

«
  -> dist ang inc
  « dist Av ang Td
    dist ang inc + inc Spi2 
  »
»
'Spi2' Pour
Image

Image

Image

Image

Image

Image

Code : Tout sélectionner

« « 2 Av 2 Td » 45 Repete » 'QCercle' Pour
« « QCercle 90 Td » 2 Repete » 'Petale' Pour
« « Petale 36 Td » 10 Repete » 'Fleur' Pour
« Fleur 130 Re Petale 70 Re » 'Plante' Pour
Voir page 20 du manuel la version LOGO

Image

etc.

Pour la traduction LOGO -> RPLogo s j'y vais, l'idée est de se baser sur des listes genre :

{ mot clé { nbre paramêtre attendu , marqueur fin } ...}

ex : { POUR { 1 FIN } REPETE { 2 Null } AV { 1 Null } }
puis le 'lire' le prog en entrée et générer (récursivement bien sur) le prog RPLogo
Modifié en dernier par Gilles59 le 05 déc. 2010 11:43, modifié 1 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+ CM14 et MM12 / Alice 32
Avatar du membre
gege
Fonctionne à 14400 bauds
Fonctionne à 14400 bauds
Messages : 7141
Enregistré le : 31 janv. 2008 14:24
Localisation : Banlieue Paârisienne
Contact :

Re: Programmer en RPL

Message par gege »

Joli, mon préféré est l'Arbre 2, superbe.
Peux-tu publier le code ?
A+
G.E.
Gilles59
Fonctionne à 2400 bauds
Fonctionne à 2400 bauds
Messages : 1602
Enregistré le : 27 oct. 2010 20:46

Re: Programmer en RPL

Message par Gilles59 »

gege a écrit :Joli, mon préféré est l'Arbre 2, superbe.
Peux-tu publier le code ?
A+
G.E.
Bonjour, voilà :

Code : Tout sélectionner

« -> l g 
  « g 0 >
    «  l Av 45 Td 
        l 1.5 / g 1 - Arbre2
        90 Tg
        l 1.5 / g 1 - Arbre2
        45 Td
        l Re
    »
    Si
  »
»
 'Arbre2' Pour
 
Init 
(0, -200) FPos 
150 11 Arbre2
l = L minuscule et pas 1 :O

En Logo 'normal' :

Code : Tout sélectionner

POUR arbre :L :G
 SI :G=0 
   [ ]
   [ AV :L TD 45
     arbre :L/1.5 :G-1
     TG 90
     arbre :L/1.5 :G-1
     TD 45
     REC :L 
   ]
FIN

VE
arbre 150 11
Pour Spi1 et Spi2 il faut interrompre le prog avec "ON" car pas de sortie prévue pour la récursion (j'ai repris les sources des prog logo du lien qui sont comme çà.... )

Et pour boucler la boucle avec le flocon de Koch, ex repris "tel quel" du Logo

Code : Tout sélectionner

POUR Khor :L
SI :L < 5 [AV :L ]
  [ Khor :L / 3 TG 60
   Khor :L / 3 TD 120
   Khor :L / 3 TG 60
   Khor :L / 3 ]
FIN

VE
Repete 3 [ Khor 90 TD 120 ]
CT

Code : Tout sélectionner

« -> l
  « l 5 <  
    « l Av »       
    « l 3 / Khor 60 Tg
      l 3 / Khor 120 Td
      l 3 / Khor 60 Tg
      l 3 / Khor
    »  
    SSi
  »
»
'Khor' Pour

« 300 Khor 120 Td » 3 Repete 
SSi = Si Sinon (IFTE).

L'idée de sortir de la récursion qd la tortue avance moins de n pixels (ici 5) est bien vue...
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+ CM14 et MM12 / Alice 32
Avatar du membre
gege
Fonctionne à 14400 bauds
Fonctionne à 14400 bauds
Messages : 7141
Enregistré le : 31 janv. 2008 14:24
Localisation : Banlieue Paârisienne
Contact :

Re: Programmer en RPL

Message par gege »

Ah ben oui j'aurais dû m'en douter !!
Le programme est "évident" -- c'est souvent ce qu'on se dit quand on lit la solution d'un problème.
M'enfin c'est déjà bien que je comprenne :oops:
Je tape ça sur la Casio 85.
A bientôt,
G.E.
Gilles59
Fonctionne à 2400 bauds
Fonctionne à 2400 bauds
Messages : 1602
Enregistré le : 27 oct. 2010 20:46

Re: Programmer en RPL

Message par Gilles59 »

Je dois faire ma V1 d' ISOLA sur Casio FX602P. Comme ca risque d'être chaud pour que ca tienne dans la Casio, je ne veux pas me planter sur la tech de jeu. Bref j'utilise la HP50 pour tester les idée et j'ai découvert une commande sympa...

Soit une matrice 8x6 qui correspond au plateau de jeu par ex, et une fonction genre ValCase(x,y) qui attribue une valeur à une case en fonction des cases adjacentes (enfoncées ou pas)

Code : Tout sélectionner

6 8 
  « 
  -> i j 
    « i j ValCase 
    » 
  » LCXM 
génère une matrice 6x8 avec dans chaque case i j la valeur générée par la fonction ValCase

ex :

Code : Tout sélectionner

 6 8 
 « -> i j 
   « i j * » 
 » LCXM 
LCXM comme Ligne Colonne Xfonction Matrice (?)

Image
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+ CM14 et MM12 / Alice 32
Gilles59
Fonctionne à 2400 bauds
Fonctionne à 2400 bauds
Messages : 1602
Enregistré le : 27 oct. 2010 20:46

Re: Programmer en RPL

Message par Gilles59 »

Trouvé sur le net des "tutoriels" vidéos vraiment excellents de "rolinychupetin" sur l'utilisation de HP50G

Il y a une vingtaine de vidéos et vraiment c'est progressif (pas trouvé cependant comment les voir dans l'ordre). C'est en anglais mais tres clair. Y'a en pour tous les niveaux, 2 exemples :

Initiation notation RPN :
http://www.youtube.com/watch?v=716wE5El ... re=related

Résolution de systèmes d'equations complexes (vraiment bien fait !)
http://www.youtube.com/user/rolinychupe ... bAtwNfCW9Q

plein d'autres 'leçons' toutes aussi bien faite, par ex :
http://www.youtube.com/user/rolinychupe ... 802L29JyQE
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+ CM14 et MM12 / Alice 32
Gilles59
Fonctionne à 2400 bauds
Fonctionne à 2400 bauds
Messages : 1602
Enregistré le : 27 oct. 2010 20:46

A PROPOS DU TRAITEMENT DE LISTES

Message par Gilles59 »

La signification de RPL n'est pas très claire. Une des explication donnée par HP est "ROM-based procedural language". Mais d'après le principal concepteur de ce langage (Bill Wickes) ce nom qui ne devait pas être public est en fait l'acronyme de Reverse Polish Lisp.

Si le coté RP est clair ( 2 3 + ) , on peut se demander où se cache le coté LISP. Je connais mal le LISP et me suis remis récemment au RPL, aussi n'hésitez pas à compléter ou corriger ce que je vais dire. Je voudrai ci-après détailler ce que permet le traitement de listes dans les dernières versions du RPL (HP50 v 2.09) et montrer leur souplesse et leur puissance.

Je pense que la gestion de listes en RPL a commencé dès la HP28 est s'est progressivement développée.

Qu'est ce qu'une liste en RPL ?

Il faut déjà savoir que le RPL fonctionne avec une pile (stack). Cette pile est polymorphe dans le sens où on met dedans toutes sortes d'objets. Le RPL connait une trentaine de type d'objets qui peuvent être par exemple des entiers binaire, des entiers longs, des réels, des complexes, des matrices, des objets graphiques (GROB), des objets algébriques, des binaires etc.

Un des objets important que l'on peut déposer sur la pile en RPL est une liste. Une liste a ceci de particulier que c'est un méta-objet : tout simplement un objet qui peut contenir d'autres objets (y compris des listes).

par exemple, la liste des chiffres en RPL se définit comme suit :

Code : Tout sélectionner

Liste des chiffres
{ 0 1 2 3 4 5 6 7 8 9 }

Une liste de couleurs :

{ "vert" "rouge" "bleu" }

Une liste mixant plusieurs type d'objets :

{ 0 "Vert" 3.14  'a.x²+b.x+c=0' { "une liste dans une liste} << DUP *>> [[01][10]]}

Cette liste est composée d'un entier, d'un réél, d'un objet algébrique, d'une liste, d'un programme, une matrice 2x2. En ce sens on peut dire qu'une liste en RPL est une collection ordonnée d'objets. Pas de limitation de taille, hors la mémoire disponible
Pour créer une liste en RPL, il suffit de mettre les objets que l'on souhaite entre deux accolades. Bien évident, comme tout objet RPL, une liste peut être sauvegardée avec la commande STO, ou avec via la structure ad hoc pour créer des variables locales dans un programme.

Pour mémoire, il faut aussi bien comprendre qu'en RPL il n'y a aucune différence entre des données et des programmes. Ce ne sont jamais que des objets qu'on manipule.

Code : Tout sélectionner

{ 0 1 2 3 4 5 6 7 8 9 } 'Chiffres' STO
stocke dans 'Chiffres' la liste de tous les chiffres de 0 à 9

Pour rappeler cette liste il suffit de taper
'Chiffres' RCL

ou plus simplement

Chiffre
(sans apostrophe)
En mode intéractif sur les HP28/28/.../50 il suffit tout simplement de cliquer sur la touche correspondante du "menu"

Autre point intéressant, on peut tout à fait "évaluer" une liste. Evaluer une liste consiste en fait à l'exécuter comme si c'était un programme.

Code : Tout sélectionner

{ "pomme" 25 } EVAL
place  "pomme" et 25 au 2 premiers niveauxde la pile

{ DUP * } EVAL
mets au carré le nombre présent au sommet de la pile

5 { DUP * } EVAL
place 25 au premier niveau de la pile
(Comment créer et modifier des listes ....A suivre...)
Modifié en dernier par Gilles59 le 17 janv. 2011 22:10, modifié 1 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+ CM14 et MM12 / Alice 32
Gilles59
Fonctionne à 2400 bauds
Fonctionne à 2400 bauds
Messages : 1602
Enregistré le : 27 oct. 2010 20:46

Listes -2-

Message par Gilles59 »

2/ Ajouter un élément à une liste

On peut ajouter un élément à une liste tout simplement avec la commande +

Code : Tout sélectionner

{ 0 1 2 } 3 +   =>  { 0 1 2 3 }
A noter que 'opérateur '+' appliqué aux listes n'est pas commutatif. Ex

Code : Tout sélectionner

{ 0 1 2 } 3 +  => { 0 1 2 3 }
mais
3 { 0 1 2 } + => { 3 0 1 2  }
{} est la liste vide

"ROUGE" {} + => {"ROUGE"}

Le programme suivant génére la liste des 10 chiffres de 0 à 9 :

Code : Tout sélectionner

<<
    {} 
    0 9 FOR i 
      +
    NEXT
>>
On peut aussi créer une liste à partir de n éléments de la pile

Code : Tout sélectionner

"Rouge" "Vert" "Bleu" 3 ->LIST
crée une liste de 3 éléments {"Rouge" "Vert" "Bleu"}

3/ Que puis-je faire avec une liste

Et bien... tout ou presque si j'ose dire.
Il faut déjà savoir qu'en RPL la plupart (tous ?) les opérateurs 'unaires' s'appliquent aux listes (sous réserves que le type de l'objet de la liste est cohérent)

ex

Code : Tout sélectionner

{ 0 1 2 3 4 } SQ -> { 0 1 4 9 16}   @ SQ carré
{ 0 1 2 3 4 } 3 ^ => { 0 1 8 27 64 }

Bien évidemment l'opération appliquée à la liste doit être cohérente

{ 1 2 "trois" 4 } SQ => Bad argument type
En effet "trois" au carré n'a pas de sens !

Code : Tout sélectionner

Si on a stocké 'Chiffres' comme définit en haut et en mode exact :

Chiffres 2 / => { 0 1/2 1 3/2 2 5/2 3 7/2 4 9/2}
Quasiment tout peut s'appliquer à une liste (SIN COS LOG 1/x etc etc.)

Mais comment fait-on pour une addition puisque l'instruction + permet d'ajouter un élément à la liste ?
Et bien il y la commande ADD

Code : Tout sélectionner

{ 1 2 3 } 1 ADD => {2 3 4}
De mon point de vue il aurait été plus logique de faire l'inverse et d'utiliser ADD pour l'ajout d'un élément et conserver la cohérence de "+".
Je n'ai pas cherché plus loin mais je suppose que ce choix a été fait pour conserver un compatibilité ascendante. Bon il suffit de le savoir d'autant plus que ADD fonctionne aussi avec des entiers, réel etc.

Couleur " foncé " ADD => { "rouge foncé" "vert foncé" " bleu foncé" }

NB : Comme pour +, STO+ n'est pas commutatif pour les listes. Suivant l'ordre des opérandes les nouveaux élément seront ajoutés en début ou en fin de liste

Code : Tout sélectionner

Supposons qu'on veuille stocker 10 dans les mots 'A' 'B' 'C' 'D', il suffit de faire :

10 { 'A' 'B' 'C' 'D' } STO
Les listes permettent aussi la plupart du temps un traitement parallèle. Il faut dans ce cas que les deux listes à traiter aient le même nombre d'items :

Code : Tout sélectionner

{ 1 2 3 4 } {'A' 'B' 'C' 'D'} STO 
stocke 1 dans A, 2 dans B etc.

{ 2 3 4 5 } { 5 4 3 2 } *
=> { 10 12 12 10 }

Manipuler des listes (... a suivre ...)
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+ CM14 et MM12 / Alice 32
Gilles59
Fonctionne à 2400 bauds
Fonctionne à 2400 bauds
Messages : 1602
Enregistré le : 27 oct. 2010 20:46

RPL & Liste

Message par Gilles59 »

Je continue l'exploration un peu décousue de ce qu'on faire avec des listes en RPL...

Compter le nombre d'éléments

{ a b c } SIZE
>=> 3

{ { a b c } { 7 8 9 } } SIZE
>=> 2
En effet c'est une liste composée de 2 listes. On verra ensuite comment compter le nombre d'éléments récursivement.

Le premier élément de la liste

{ 1 2 3 } HEAD
>=>
1

Tout sauf le premier

{ a b c } TAIL
>=>
{ b c }

Classer une liste

{ "Gamma" "Alpha" "Beta" } SORT
>=>
{"Alpha" "Beta" "Gamme" }

Les premiers seront les derniers

{ 5 4 33 2 1 } REVLIST
>=>
{ 1 2 33 4 5 }

De là, facile de trier en ordre inverse

{ ma liste dans le désordre } SORT REVLIST
>=>
{ ma liste le désordre dans }

Il existe bien sur la possibilité de récupérer le niéme élement d'une liste (GET), de remplacer le nieme élément d'une liste (PUT), de rechercher la position d'un élément dans une liste (POS) etc.

Mais venons en maintenant à de plus intéressantes et originales commandes ....
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+ CM14 et MM12 / Alice 32
Avatar du membre
badaze
Fonctionne à 14400 bauds
Fonctionne à 14400 bauds
Messages : 8384
Enregistré le : 12 févr. 2007 18:36
Localisation : Pas très loin de Lyon
Contact :

Re: Programmer en RPL

Message par badaze »

Très bien.
Tout est bon dans le pocket.
Moi j'aime tout.... Casio, HP, Sharp, TI et les autres sauf que les TI semblent ne pas m'aimer :(
http://www.emmella.fr
Mes Casio - HP - Sharp - TI
Homme invisible.
Avatar du membre
zpalm
Fonctionne à 9600 bauds
Fonctionne à 9600 bauds
Messages : 2919
Enregistré le : 03 mai 2008 15:33
Localisation : Grenoble

Re: Programmer en RPL

Message par zpalm »

Merci pour cette présentation du RPL, c'est très clair!
Avatar du membre
C.Ret
Fonctionne à 9600 bauds
Fonctionne à 9600 bauds
Messages : 3404
Enregistré le : 31 mai 2008 23:43
Localisation : N 49°22 E 6°10

Re: Programmer en RPL

Message par C.Ret »

Oui, très bien, mais toutes ces spécificités des listes n'existent pas sur la HP28S.

Faire des listes de listes, pas de problème cela se passe comme décrit ci-dessus sur HP28.
La fonction SIZE renvoie bien les mêmes valeurs.
{ A B C} SIZE retourne 3.
{ { 1 2 3 } { X Y } } SIZE retourne 2.

Par contre , l'EVALuation d'une liste retourne la même liste non modifiée :
Ainsi: { "Pomme" 25 } EVAL renvoie simplement { "Pomme" 25 }

Pour mimer le comportement des H4x/HP50, il faut utiliser la séquence
{ "Pomme" 25 } LIST-> DROP
En effet, l'instruction LIST-> (qui je crois a disparue de l'arsenal des instructions des HP4x/HP50 où seule OBJ-> est présent) retourne les éléments de la liste dans la pile (un élément par niveau de pile) et au niveau 1: le nombre d'éléments.
Ainsi { "Pomme" 25} LIST-> met "Pomme" au niveau 3:, 25 au niveau 2: et 2 au niveau 1:
Le DROP est nécessaire pour faire disparaitre ce dernier 2 (qui indique en fait le nombre d'éléments).

Les instuctions HEAD et TAIL doivent être programmées, elles n'existent pas d'origine sur les HP28C/S.
On peut par exemple utiliser les codes suivants:

Code : Tout sélectionner

« 1 GET »                « 2 OVER SIZE SUB »
‘HEAD’ STO               ‘TAIL’ STO
Notons d’ailleurs que HEAD renvoi un Atom (c'est-à-dire un élément d’une liste), alors que TAIL renvoi une liste.


Quand à la fonction SORT, elle doit aussi être créée par l’utilisateur. Mais, il y a une ambiguité quand à la façon de trier, car les éléments des listes ne sont pas tous nécessairement des valeurs numériques, il peut s’agir de nombre, de symboles, de chaine de caractère, d’autres listes, etc...

Alors qu’elle est la relation d’ordre qui doit être utilisée ?
Ma question est, comment SORT évalue-t-il les atoms d’une Liste ? Comment fait SORT pour classer par exemple 25 et "Pomme" ?


Quand à REVLIST, c’est assez drôle à programmer :

Code : Tout sélectionner

« LIST-> -> n
  « IF n 1 >
    THEN
      2 n FOR i
           i ROLL
      NEXT
    END
    n ->LIST
  »
»
‘REVLIST’ STO 
[/code]

Il existe également le moyen de récupérer ou de placer le n-ième élément d’une liste (GET et PUT), de trouver la position d’un élément (très utile car retourne 0 si l’élément n’est pas dans la liste), mais il y a aussi SUB qui permet d’extraire une partie d’une liste :
{ A B C D E F } 2 4 SUB renvoie { B C D }

Mais il y a aussi GETI et PUTI, très utiles dans une boucle DO...UNTIL...END car ces instructions permettent de pointer automatiquement sur l’élément suivant de la liste.


L’opérateur + a le même rôle et permet de concaténer les listes, ou une liste avec un atom :
{ A B C D } { 1 2 3 4 5 6 } + renvoi { A B C D 1 2 3 4 5 6 }
123456 { A B C D } + renvoi { 123456 A B C D }
{ A B C D } 123456 + renvoi { A B C D E F 123456 }


Mais là s’arrête la similitude avec les HP RPL perfectionnées, les HP28S ne permettent aucune ‘vectorialisation’ des opérandes :
{ 1 2 3 4 } SQ
{ 1 2 3 4 } 3 ^
{ 1 2 3 4 } 3 /
{ 1 2 3 4 } 3 *
Etc.
--->Provoquent tous une erreur ‘Bad Argument Type’ (type d’argument incorrect)

De même, les instructions STO+, STO*, etc ne fonctionnent pas pour les listes entières.

Par contre, l’adressage indirect fonctionne très bien en notation algébrique :
Supposons que l’on ait la liste ‘L’ suivante :
{ 10 20 30 40 50 "Lapin" } ‘L’ STO

On peut obtenir ses élément par indexation :
‘L(3)’ EVAL renvoi 30 et ‘L(6)’ EVAL renvoi "Lapin".

On peut également utiliser STO :
400 ‘L(2)’ STO remplace le second élément de la liste L par 400.
Nous avons alors L qui contient { 10 400 30 40 50 "Lapin" }

On peut ainsi rapidement construire des listes par récursivité ou par pointeurs :
’L(4)’ ‘L(5)’ STO va modifier la liste L en { 10 400 30 40 ‘L(4)’ "Lapin" }
Alors ‘L’ 5 GET EVAL et ‘L’ 4 GET EVAL pointe tous deux sur le même atom, ici 40.

Les deux séquences suivantes sont équivalentes :
L ‘L(3)’ STO
‘L’ 3 L PUT
Elles modifient toutes les deux la liste mémorisée en L en y dupliquant le contenu :
La variable L contient alors { 10 400 { 10 400 30 40 ‘L(4)’ "Lapin" } 40 ‘L(4)’ "Lapin" }

Notons enfin, que le HP28C/S ne fait pas la distinction entre un nom de variable (un label) et la référence formelle ou algébrique à cette variable.

Ainsi, dans une liste les variables ne sont jamais entre guillemets simples : sur HP28S, il est impossible de produire la liste { ‘A’ ‘B’ ‘C’ ‘D’ } qui est immédiatement représenté et interprétée comme la liste { A B C D }.

Il ya encore une ou deux subtilités concernant des listes pouvant contenir des instructions ou des fonctions. Ainsi que l’évaluation de liste donc les deux premiers (au plus) éléments sont des variables locale (dans une procédure donc). Dans ce cas, la liste servant d’argument à PUT, GET, P->R et R->P est évaluée en substituant les variables locale par leur valeur en cours d’exécution.

C’est, il me semble assez différent du comportement des listes du HP50.
SHARP PC-1211 PC-1360 EL-5150 PC-E500 | Commodore C=128D | Texas Instruments Ti-57LCD Ti-74BASICalc Ti-92II Ti-58c Ti-95PROCalc Ti-30XPROMathPrint | Hewlett-Packard HP-28S HP-41C HP-15C HP-Prime HP-71B | CASIO fx-602p | NUMWORKS | Graphoplex Rietz Neperlog | PockEmul | Sommaire des M.P.O. | Ma...dov'il sapone.
Répondre

Retourner vers « Tous les Pockets »