Forum

Gilles59

Hello ! tu en as une ?

Je suis d'accord avec toi. J'irai jetter un oeil à la fnac pour la voir de visu ! et surtout l'écran

Gilles59

Dans le prog précécent si on change 'Exquis' comme çà :

Code : Tout sélectionner

«
   { 'Sujet' 'Verbe' 'Sujet' " qui" 'Verbe' 'Complément' }
   « EVAL » DOSUBS 
   « + » STREAM MSGBOX
» 
'Exquis' STO

Ca donne des truc assez drôles genre :

"Claire occupe un mamouth laineux qui épluche sa leçon"
"Le microbe exécute la sardine qui exploite son chat"
" Un alien charge mon tres cher ami qui programme sur son perchoir"
"Une orange mange une hyène qui grille sur une planche"
"Maman ours aperçois Raphael qui manque d'inspiration dans son bocal"

Code : Tout sélectionner

{ 'Sujet' "," 'Complément' "," 'Verbe' 'Sujet' " qui" 'Verbe' 'Complément' }

->

Mon hamster, sur sa planche, lessive une hyène qui opère une marmotte
La mère Noel, dans sa niche, codifie l'arbre qui enferme les moutons
Mon amie, son ami, s'assis sur mon très cher ami qui joue dans sa litière
L'entrepreneur, à la ferme, nettoie la guenon qui rigole dans une marmitte
Tarzan et Jane, une bande de voyous, sacrifie le rhinocéros qui miaule sur ta chaise

Par contre ca parle jamais de lapin, je vais changer çà !

Il y a des trucs peu cohérents dans les compléments que j'ai repris tels quels. Pour avoir des phrases toujours correctes syntaxiquement il faudrait différencier divers type de complément (de lieu ou autre etc.). Là tout est mélangé

Gilles59

Ci après une version simple des cadavres exquis identique à celle en Delphi de Matt 261
http://www.delphifr.com/codes/GENERATEU ... 37310.aspx

C'est une version très basique ( pas de gestion des accords singulier/ puriel...)

Je décline le prog, je le lance et première sortie :

"Ces dames envie sur moi"

LOL pas fait expres je vous jure ... Mais je sais que :

"Claire écrase son Mammouth"
"Tu chantes dans le pot de peinture"
"Mon prof navigue sa leçon"
"Elle étonne de la paille"

je ne suis pas sur que la version Delphi soit plus claire que celle-ci (je vous accorde que la version Delphi comme tous les langages qui gèrent l'IHM windows est composée à 80% de son code des pb de fenêtres, boutons etc, mais le coeur du progr me semble bien moins clair et 'naturel' qu'ici)

La version ici pourrait aussi être bien simplifié, mais j'ai choisis cette structure pour aller plus loin ensuite (adjectifs, accord du genre, et pluriel singulier)

Vais voir pour une version plus sophistiquée.

"

Code : Tout sélectionner

%%HP: T(0)A(D)F(.);
@===================================================================
@  Cadavres exquis HP48G/49/50. D'après : 
@  http://www.delphifr.com/codes/GENERATEUR-CADAVRES-EXQUIS_37310.aspx
@  de Matt 261
@===================================================================
«
   { 'Sujet' 'Verbe' 'Complément' }
   « EVAL » DOSUBS 
   « + » STREAM MSGBOX
» 
'Exquis' STO

@====================================================================
@ Sujet / Entrée : Rien    Sortie : STRING (le sujet de la phrase)
@--------------------------------------------------------------------
« Voca HEAD DUP SIZE RAND * 1 + IP GET » 'Sujet' STO

@====================================================================
@ Verbe / Entrée : Rien    Sortie : STRING (le verbe de la phrase)
@--------------------------------------------------------------------
« Voca 2. GET DUP SIZE RAND * 1 + IP GET »'Verbe' STO

@====================================================================
@ Complément / Entrée : Rien    Sortie : STRING (le complément de la phrase)
@--------------------------------------------------------------------
« Voca 3. GET DUP SIZE RAND * 1 + IP GET » 'Complément' STO

@====================================================================
@ Voca / Vocabulaire. Copier-Coller de  la version DELPHI de Matt 261 +qqes corrections
@--------------------------------------------------------------------

{ 
 {
  " Anne"" Ce bouricot"" Ces dames"" Cet acteur"" Claire"" Des libellules"" Elle"" Elles"" Francky"" Il"" Ils"" Je"" John"" La bergère"
  " La calèche du roi"" La coccinelle"" La concierge"" La fontaine"" La guenon"" La mandarine"" La mère Noël"" La mygale"" La pomme"
  " La présidence"" La princesse"" La sardine"" La télévision"" La voiture"" L'arbre"" L'arrosoir"" L'artiste"" Le bouquetin"" Le bovidé"
  " Le bureau"" Le calif"" Le capitaine"" Le chien"" Le détective"" Le directeur"" Le docteur"" Le footballeur"" Le gamin"" Le grand dadet"
  " Le microbe"" Le ministre"" Le monde"" Le monsieur"" Le père Noël"" Le poupon"" Le président"" Le rhinocéros"" Le skieur"" Le voleur"
  " L'entrepreneur"" Les colportateurs"" Les jouets"" Leurs asperges"" Leurs bisons"" Lui"" Ma grand-mère"" Maman"" Maman Ours"" Marc"
  " matt261"" Mes bettraves"" Mes parents"" Mes plantes"" Mickey"" Minousme"" Mon amie"" Mon bébé"" Mon chirurgien"" Mon dragon"" Mon frère"
  " Mon hamster"" Mon passager"" Mon prof"" Mon sandwitch"" Mon très cher ami"" Nicolas"" Notre jument"" Nous"" On"" Papa"" Paul et moi"
  " Raphaël"" Ratus"" Sa proie"" Son carburateur"" Son fantôme"" Son lapinou"" St Nicolas"" Ta chèvre"" Tarzan et Jeanne"" Thomas et Lu"
  " Toi et moi"" Ton frère"" Toto"" Tu"" Un alien"" Un chacal"" Un dinosaure"" Un mamouth laineux"" Un merland"" Un scientifique"" Une hyène"
  " Une marmotte"" Une orange"" Vous"
 }
 {
  " dors"" rigole"" part"" s'esclaffe"" regarde"" apercois"" mange"" s'enouie"" délire"" manque d'inspiration"" s'assied sur"" efface"
  " programme"" configure"" endors"" supprime"" feuillette"" exécute"" satisfait"" tape"" maltraite"" joue"" nage avec"" tombe"" parie"
  " se trempe"" s'énerve"" déchire"" tombe"" casse"" engueule"" parle"" bavarde"" s'ennuie"" s'active"" écrase"" examine"" surfe"" exploite"
  " découvre"" hénni"" bêle"" miaule"" aboit"" meugle"" patauge"" scie"" apprend"" aime"" envie"" ajoute"" ingurgite"" absorbe"" pialle"
  " croasse"" sors"" entre"" croise"" calcule"" demande"" cloue"" apprend"" décape"" chante"" grille"" épluche"" prend"" récite"" abandonne"
  " dévie"" nettoie"" enferme"" coupe"" campe"" caracole"" captive"" chancèle"" change"" écrase"" charge"" opère"" colore"" commence"
  " compense"" interview"" téléphone"" installe"" occupe"" atténue"" intègre"" interpelle"" jalouse"" jubile"" joint"" caquette"" sabote"
  " laisse"" lessive"" rénove"" repli"" déguste"" extermine"" hante"" commande"" navigue"" abbat"" abdique"" aborde"" abrite"" abrutit"
  " incommode"" codifie"" cogne"" compare"" complimente"" conçoit"" débarbouille"" achète"" décapite"" descend"" monte"" éternue"" sacrifie"
  " génère"" excite"" éberlue"" poste son message"" tchatte"" consulte"" classe"" étonne "
 }
 {
  " avec son chat."" avec du chocolat."" au magasin."" sur son ordinateur."" devant la télé."" assis sur son fauteil."" en mangeant du pop-corn"
  " avec une brosse à dents."" en se mouchant."" en écoutant de la musique."" à la piscine."" à la montagne."" en caressant son chat."" sur son ordinateur."
  " avec mamie."" dans le jardin."" avec son ami."" sur moi."" dans sa maison."" dans sa niche."" sur son perchoir."" à la mer."" dans son bocal."
  " dans sa voiture."" sur sa branche."" dans une marmitte."" en jouant du piano."" dans la prairie."" dans son lit."" en sirotant un cognac."" dans le four."
  " sur une chaise."" sur sa planche."" sur son clavier."" dans le pot de peinture."" sur le tapi."" tout à l'heure."" avec son Mammouth."
  " à l'école."" avec une vache à lait"" dans sa grotte."" dans la rue."" avec une marmotte."" avec un dinosaure."" avec un alien."" dans la chocolaterie."
  " en mangeant des nouilles."" derrière son écran."" sous sa mangeoire."" en prenant un bain de soleil."" en apprenant sa leçon."" dans sa litière."" avec le prisonnier."
  " sur les arbres."" six pieds sous terre."" une chanson."" en buvant sa tasse de thé."" à l'école."" dans leur igloo."" à la ferme."" son poulain."
  " les moutons."" un panneau."" de l'argent."" de la paille."" un verre d'eau."" sur DelphiFr."" au clair de la Lune."" avec ses amis."
  " au restaurant."" dans la fromagerie."" une bande de voyoux."" sur Internet."" dans un grand verre d'eau."" avec beaucoup de miel."
 }
   
}
'Voca' STO

[/size]

Gilles59

Marcus von Cube a écrit :
C.Ret a écrit :
Gilles59 a écrit :ou encore

<< -> a b c
<< 'a*b*c' EVAL>>
>>
'Mult3' STO
ou encore

<< -> a b c
'a*b*c'
>>
'Mult3' STO

Si je ne me trompe pas.

Tu as raison, l'EVAL ne sert à rien à cet endroit

Gilles59

Le dernier échange me fait penser à la différence de façon de pensée (enfin pour moi) si je dev un truc en RPL.

Penant l'exemple de "cadavres exquis" voir : http://fr.wikipedia.org/wiki/Cadavre_exquis

. Le principe de ce jeu était que chacun des participants écrive à tour de rôle une partie d'une phrase, dans l'ordre sujet-verbe-complément, sans savoir ce que le précédent a écrit.

Soit { 'sujet' 'verbe' 'complément' }

Voilà déjà le coeur du prog RPL, le reste est tuyauterie

Gilles59

C.Ret a écrit :
En effet, en lisant du code RPL, rien n'indique combien d'arguments sont pris de la pile et combien y sont déposé.
Il manque réellement quelque part un environnement de programmation et de déboggage qui mettrait l'utilisation de la pile et le eu qui s'y déroule en évidence.
Et le nombre d'argument n'est qu'une partie du problème, car rien n'indique non plus quel type d'objets le code peut traiter, etc.

Je comprends que vu de l'extérieur, hors quelque exepmle simples, le RPL apparaisse obscur et très peu clair. Car c'est bien ce qu'il est; efficace et astucieux à manipuler nombre, objets divers etc., mais isotérique et abscon, ne donnant à la lecture du code aucun indice au lecteur sur son fonctionnement ou son domaine de fonctionnement.

Je suis assez d'accord. On peut clarifier le code si besoin. S'obliger à prendre les éléments depuis la pile sous formes de variables locales et/ou utiliser la fonction en mode algébrique.

1/ Plusieurs façon de créer le même prg :

<< * * >> 'Mult3' STO

<< -> a b c
<< a b c * * >>
>>
'Mult3' STO

ou encore

<< -> a b c
<< 'a*b*c' EVAL>>
>>
'Mult3' STO

et plusieurs façons de l'utiliser (même créé sous la forme * * )

5 3 7 Mult3

ou

'Mult3(5,3,7)' EVAL

Concernant ce qui doit être sur la pile en entrée et ce qui y est en sortie, ca peut etre mis en commentaires en reprenant la logique de la doc HP.

Mais amha, le gros intérêt du RPL est son utilisation en mode intéractif. Juste avec l'exemple précédent en mode intéractif, 5 résulte probablement d'un premier calcul . Idem pour 3 et 7... Bref je calcule 5,il est sur la pile, je peux faire 2 ou 20 min de calcul pour trouver 3 puis 7... et en cliquant sur Mult3 j'ai ce que je veux sans bidouiller de variables ou de ANS() ou de parenthèses inutiles et autre temps perdu. En temps réel, je sais ce que je fais et je visualise la pile. Par contre en mode programmer il est vrai que la relecture est plus complexe car je ne vois pas la pile comme en mode interactif. D'ailleurs quand je joue sur la pile (les ROT UNROT et autre ROLL) en programmant sur PC, j'utilise souvent la HP en // pour simuler ce que çà donne

Concernant le déboguage et l'usage de la pile, le mode debug est bien fait je trouve avec commandes SST qui permettent une exécution pas à pas en voyant ce qui se passe sur la pile, les commandes HALT etc. Je me demande aussi si HPUserEdit ne permet pas de bien voir ce qui se passe sur la pile car elle apparait dans l'environnement de dev mais je ne sais pas l'utiliser et l'aide est en espagnol

Bon on peut en tout cas facilement écrire du code et choisir "Emulateur -> Debugguer" qui lance le prog dans l'émulateur et permet d'avancer commande par commande avec SST en visualisant la pile.

Pour m'y retrouver dans la pile, style j'y dépose un objet que j'utiliserai bien plus tard, il m'arrive aussi d'indenter le source.

Et puis comme le forth, il me semble que la philosophie RPL est plutot de découper un progr en petits mots-programmes. Ce qui important c'est ce qu'il y a sur la pile en entrée et ce qu'on y trouve en sortie, et donc de pouvoir utiliser cette brique pour dev ce qu'on cherche à faire. Si il s'agit d'optimiser cette brique alors là oui, c'est un peu plus compliqué. Mais en général quand une brique suffisamment générique marche, elle marche on ne la modifie plus.. L'inconvénient est que ca pénalise la vitesse d'exécution. Mais de toute façon si la vitesse d'exécution est primordiale, le User RPL n'est pas le bon cheval.

Gilles59

Jamais testé RPL/2 encore.

Bon dans le genre " je complique inutilement les choses...). Nul besoin de DOLIST pour créer une nouvelle liste contenant la plus grande valeur à chaque position de 2 listes :

{ 2 7 4 9 1 3 }
{ 3 6 7 1 4 7 }
MAX

>=>

{ 3 7 7 9 4 7}

Idem { 2.4 5.2 6.3} IP
>=> { 2 5 6 }

idem pour MIN, FP (partie fractionnaire) etc etc.

Gilles59

J'ai regardé un peu plus hier soir dans la doc les notions de traitement parallèle de liste.

Y est expliqué les cas où on peut faire directement une opération parallélisée et les cas où on doit employer DOLIST.

De mémoire (et non exhaustif), on est obligé d'utiliser DOLIST dans les cas suivants

- Commande qui fonctionne sur un nombre variable d'argument (par exemple ->LIST)
- Commande qui fonctionne par défaut sur la liste (par exemple { 1 2 3 } STR-> donne "{1 2 3} " et pas {"1" "2" "3"} Idem pour SAME qui va vérifer l'égalité globale des 2 listes et pas l'égalité élément par élément
- Commande dont un des arguments est déjà une liste
- Utilisation de structure de programme de "branchement" (CASE , FOR , IF) (mais remarquez que la forme IFT fonctionne)
- ...

Bref il y a beaucoup de cas qui obligent l'utilisation de DOLIST

Pour en savoir plus: http://www.hpcalc.org/search.php?query=AUR+edition+2

Annexe F-1

La commande DOSUB est effectivement vraiment intéressante aussi

Gilles59

c.ret,je répondrai plus en détail demain...

Mais la plupart des choses que tu décris fonctionne _déjà_ en HP50

{ 12 13 14 } { 7 8 9 } MOD renvoie{ 5 5 5 }
{ 1 2 3 4 } { 5 6 7 8} R->C renvoie la bonne liste

SUM est en fait SLIST (Sigma LIST)
PROD est PiLIST (symbole Pi)

Note que STREAM permet de traiter toute liste par binome { 1 2 3 4 } << * >> STREAM donne 24 comme PiList

Pour ADD, je pense qu'HP a été bloqué a cause de la compatibilité ascendante. Autrement dit + aurait du être ADD et inversement,mais comme ils ont fait le choix que + servait à ajouter un élément dans une liste dès les 28 et 48 impossible de revenir en arriere.

"TRUC " 2 ADD
>=>
"TRUC 2"

2 "TRUC" ADD
>=>
"2 TRUC"

Dès qu'il n'agit pas sur une liste ADD fonctionne comme +

Il y a un chap sur le traitement "Parallel processing" dans le manuel avancé (AUR téléchargeable sur le site HP ou HPCALC je pense)... En gros tout ce qui est possible (logique) fonctionne. Par exemple : (0,0) {(1,1) (3,2)} LINE fonctionne et trace 2 lignes partant de (0,0).Pas testé mais je suppose que {(0,0) (3,3)} {(1,1) (3,2)} LINE aussi comme l'exemple de STO que je donnais avant : 0 {A B C} STO met 0 dans A B et C. Mais { 1 2 3} { A B C } STO mais 1 dans A, 2 dans B et 3 dans C

En fait le RPL fonctionne très souvent comme tu dis souhaiter qu'il fonctionne (ou comme je crois comprendre ce que tu dis

Je vois ca de plus pres ce WE

Extrait du manuel avancé sur + et ADD et le pourquoi :

Group 4: ADD and +
* On HP 48S and HP 48SX calculators, the + command has been used to append lists or to append elements to
lists. Thus { 1 2 3 } 4 + returns { 1 2 3 4 }. With the advent of parallel processing in the HP 48G
series, the ADD command was created to perform parallel addition instead of +.
This has several ramifications:
* To add two lists in parallel, you must do one of the following:
* Use ADD from the !´%LIST% menu.
* Create a custom menu containing the ADD command.
* Assign the ADD command to a user-defined key.
* User programs must be written using ADD instead of + if the program is to be able to perform direct parallel
processing, or written with + and applied to their arguments by using DOLIST. For example, programs such as «
→x 'x+2' » will produce list concatenation when x is a list rather than parallel addition, unless rewritten as «
→ x 'x ADD 2' »
* Algebraic expressions capable of calculating with variables containing lists (including those intended to become
user-defined functions) cannot be created in RPN syntax since using ADD to add two symbolic arguments
concatenates the arguments with + rather than with ADD. For example, 'X' DUP 2 ^ SWAP 4 * ADD
'F(X)' SWAP = produces 'F(X)=X^2+4*X' rather than 'F(X)=X^2 ADD 4*X'.

J'ai peut etre mis des DOLIST inutile au dessus.je vérifiérai.

Pour mieux comprendre

{ 0 1 2 3 4 5 6 7 8 9 } ISPRIME?

>=>

{ 0 0 1 1 0 1 0 1 0 0 }

Par contre si je veux extraire une sous-liste des nombres premiers de cette liste, je ne vois pas comment faire sans DOLIST. Ca se ferait comment en LISP ? ( PS en RPL je peux certes créer une commande genre PREMIER? qui fonctionnera comme je veux mais il y aura un DOLIST dedans)

PS : j'ai trouvé un moyen sans DOLIST :

{ 0 1 2 3 4 5 6 7 8 9 } DUP ISPRIME? SWAP IFT

>=> { 2 3 5 7 }

{ 0 1 2 3 4 5 6 7 8 9 } 1 ADD
>=>

{ 1 2 3 4 5 6 7 8 9 10 }

Gilles59

charognard a écrit :Juste pour l'exemple
Ne serait il pas possible de prendre des canards ?

Oui on peut ! Suffiit d'appliquer çà à la liste :

« DUP SIZE 4 - "canard" REPL » MAP

On peut aussi canarder (premier groupe) le lapin. Par contre je ne suis pas sur que lapiner le canard soit français

Pour revenir à MAP, cette commande balaie tous les items de la liste en incluant les sous listes.

Gilles59

Continuons d'explorer la commande DOLIST, une des commandes de traitement de listes en RPL, avec quelques exemples.

La commande DOLIST existe depuis la HP49, mais doit pouvoir être créée en RPL sur les28 et 48 (bon exercice)... Quelques exemples :

Soit deux listes de chiffres, on veut une liste avec la plus forte valeur pour chaque position dans la liste :

Code : Tout sélectionner

{ 2 7 4 9 1 3 }
{ 3 6 7 1 4 7 }
2 << MAX>> DOLIST

>=>

{ 3 7 7 9 4 7}

DOLIST applique le programme entre << et >> élément par élément sur le nombre de liste précisé. Les éléments des listes sont placés sur la pile, traités et une nouvelle liste est créé si le programme dépose des résultats au bon niveau de pile.

Imaginons qu'on veuille depuis une liste de nombres obtenir la liste des nombres premiers qui la compose :

Code : Tout sélectionner

{ 0 1 2 3 4 5 6 7 8 9 }
1 << DUP ISPRIME? NOT { DROP } IFT >> DOLIST 

>=>

{ 2 3 5 7 }

Comment compter le nombre de nombre premier d'une liste ?

Code : Tout sélectionner

0 { 0 1 2 3 4 5 6 7 8 9 }
1 << ISPRIME? { 1 + } IFT >> DOLIST 

>=>

4

Conjugaison au présent des verbes du 1 groupe :

Code : Tout sélectionner


«
 { "je" "tu" "il" "nous" "vous" "ils"}
 { 
   "PRESENT"      { "e"   "es" "e"  "ons"   "ez" "ent"}
   "IMPARFAIT"    { "ais" "ais" "ait" "ions" "iez" "aient"}
   "FUTUR"        { "erai" "eras" "era" "erons" "erez" "eront"}
   "CONDITIONNEL" { "erais" "erais" "erait" "erions" "eriez" "eraient"}
 }
  -> Verbe Pronom Conj
  «
    DO
      Conj HEAD " de " + Verbe + 
      Pronom
      Conj TAIL DUP TAIL 'Conj' STO 
      HEAD 
      2 «  SWAP " " + Verbe  DUP SIZE 2 - 1 SWAP SUB +  SWAP +  » DOLIST
    UNTIL Conj {} SAME END
  »
  8. ->LIST
»
'Grp1' STO

Code : Tout sélectionner

Exemple d'utilisation :

{ "chanter" "danser" "programmer" "chasser" }
1 « Grp1 » DOLIST

>=>

Code : Tout sélectionner

{ { "PRESENT de chanter" { "je chante" "tu chantes" "il chante" "nous chantons" "vous chantez" "ils chantent" } "IMPARFAIT de chanter" { "je chantais" "tu chantais" "il chantait" "nous chantions" "vous chantiez" "ils chantaient" }
"FUTUR de chanter" { "je chanterai" "tu chanteras" "il chantera" "nous chanterons" "vous chanterez" "ils chanteront" } "CONDITIONNEL de chanter" { "je
chanterais" "tu chanterais" "il chanterait" "nous chanterions" "vous chanteriez" "ils chanteraient" } } 
 "PRESENT de danser" { "je danse" "tu danses" "il danse" "nous dansons" "vous dansez" "ils dansent" } "IMPARFAIT de danser" { "je dansais" "tu dansais" "il dansait" "nous dansions" "vous dansiez" "ils dansaient" } "FUTUR de danser" { "je danserai" "tu danseras" "il dansera" "nous danserons" "vous danserez" "ils danseront" } "CONDITIONNEL de danser" {"je danserais" "tu danserais" "il danserait" "nous danserions" "vous danseriez" "ils danseraient" } }
{ "PRESENT de programmer" { "je programme" "tu programmes" "il programme" "nous programmons" "vous programmez" "ils programment" }
"IMPARFAIT de programmer" { "je programmais" "tu programmais" "il programmait" "nous programmions" "vous programmiez" "ils programmaient" }
"FUTUR de programmer" { "je programmerai" "tu programmeras" "il programmera" "nous programmerons" "vous programmerez" "ils programmeront" } "CONDITIONNEL de programmer" { "je programmerais" "tu programmerais" "il programmerait" "nous programmerions" "vous programmeriez" "ils programmeraient" } } 
{ "PRESENT de chasser" { "je chasse" "tu chasses" "il chasse" "nous chassons" "vous chassez" "ils chassent" } "IMPARFAIT de chasser" { "je chassais" "tu chassais" "il chassait" "nous chassions" "vous chassiez" "ils chassaient" } "FUTUR de chasser" { "je chasserai" "tu chasseras" "il chassera" "nous chasserons" "vous chasserez" "ils chasseront" } "CONDITIONNEL de chasser" { "je chasserais" "tu chasserais" "il chasserait" "nous chasserions" "vous chasseriez" "ils chasseraient" } } }

[/size]

Nous verrons la prochaine fois la commande MAP.
Par exemple si on applique à la liste précédente çà :

Code : Tout sélectionner

REVLIST HEAD «" le lapin" + » MAP

>=>

Code : Tout sélectionner

{ 
"PRESENT de chasser le lapin" 
 { "je chasse le lapin" "tu chasses le lapin" "il chasse le lapin" "nous chassons le lapin" "vous chassez le lapin" "ils chassent le lapin" } 

"IMPARFAIT de chasser le lapin" 
{ "je chassais le lapin" "tu chassais le lapin" "il chassait le lapin" "nous chassions le lapin" "vous chassiez le lapin" "ils chassaient le lapin" }

"FUTUR de chasser le lapin" 
{"je chasserai le lapin" "tu chasseras le lapin" "il chassera le lapin" "nous chasserons le lapin" "vous chasserez le lapin" "ils  chasseront le lapin" }

"CONDITIONNEL de chasser le lapin" 
{ "je chasserais le lapin" "tu chasserais le lapin" "il chasserait le lapin" "nous chasserions le lapin" "vous chasseriez le lapin" "ils chasseraient le lapin" } 
}

[/size]

Bon vous pouvez aussi chasser les lièvres bien sur

Gilles59

Super ! Merci pour ces infos...

La calcu idéale pour moi ? Une HP51 avec un meilleur écran (320x200), un code réécrit en full ARM (suppression de la couche d'émulation SATURN), et une évolution RPL3. J'ajoute plus de compacité et plus d'autonomie
...
Mais je n'y crois pas trop car elle serait commercialement trop proche de la 50 et le marché ne justifie certainement pas l'investissement et que le seul but des multinationale est de payer des dividendes aux actionnaires. Je me réjouis déjà que la 50 qui corrige les défauts des 49 soit sorti et n'espere plus grand chose dans le genre pour l'avenir

Gilles59

Bonjour c.ret !

Suis bluffé par le 400 ‘L(2)’ STO

Je n'avais même pas pensé que c'était possible mais à la réflexion c'est très naturel. Ca marche aussi sur HP50... Idem pour tous tes exemples d'ailleurs. Je pense que HP a été tres vigilant sur la compatibilité ascendante.

OBJ-> Fonctionne comme LIST-> (qui existe toujours pour compatibilité). La différence est que OBJ-> est plus puissant et s'applique à tout les objets :

Par exemple

'A+B' OBJ->
>=donne sur la pile =>
A B 2 +

La logique est :
Appliquer la fonction +
à 2 arguments
second argument B
premier argument A

'SIN(45)' OBJ->
SIN 1 45

'SIN(A+B)' OBJ->
SIN 1 'A+B'

OBJ-> ne transforme en RPN que la premiere fonction trouvée. Il faut procéder récursivement pour tout transformer

Il y a un exemple de prog dans le AUR (Advanced users reference guide) qui traduit toute expression algébrique en équivalent RPN

OBJ-> permet aussi de transforme une chaine alpha en 'code symbolique' :
"Nom" OBJ->
'Nom'

Ce qui peut etre pratique parfois par exemple pour lancer un prog dont le nom est une chaine alpha

Concernant SORT
Essayer de trier une liste non homogène provoque un "SORT erreur : type d'argument incorrect" (j'ai passé ma 50 en français)
Il faut "homogénéiser" la liste avant (en transformant tout en alpha par ex) t :

{ 3 4 2 "3" } 1 «->STR» DOLIST SORT

DOLIST, j'y reviendrai, permet d'appliquer un programme à tous les éléments d'une ou plusieurs liste. Dans le cas ci dessus le programme transforme tous les objets d'une liste en chaine alpha. A noter que { 1 2 3 } ->STR donne "{ 1 2 3 }" alors que { 1 2 3 } 1 <<->STR>> DOLIST donne {"1" "2" "3" }

PS :

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 }.

Idem en 50

PPS

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.

Je ne comprends pas bien. As tu un ex ? Tout ce que tu expliques avant fonctionne pareil sur une 48/49/50

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 ....

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 ...)

Forum

1590 résultats trouvés

Re: La FX-CG10/CG20

Re: Programmer en RPL

Re: Programmer en RPL

Re: Programmer en RPL

Re: Programmer en RPL

Re: Programmer en RPL

Re: Programmer en RPL

Re: Programmer en RPL

Re: Programmer en RPL

Re: Programmer en RPL

Re: Programmer en RPL

Re: HP-71B: le chainon manquant entre RPN et RPL [long]

Re: Programmer en RPL

RPL & Liste

Listes -2-