MPO 95 : Balayage des rationnels

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 du membre
Hobiecat
Fonctionne à 9600 bauds
Fonctionne à 9600 bauds
Messages : 3626
Enregistré le : 06 sept. 2011 14:57
Localisation : Normandie

Re: MPO 95 : Balayage des rationnels

Message par Hobiecat »

Bon, j'ai trouvé l'erreur de mon programme : j'ai utilisé ISG comme compteur, donc forcément après U(999), ça coince. :mrgreen:

Mon programme était classique : compteur, calcul et on boucle. L'avantage de la 41 sur la 65 et qu'on peut faire "BEEP" à la fin pour ne pas la regarder pendant plusieurs minutes ! :wink:
Avatar du membre
dprtl
Fonctionne à 1200 bauds
Fonctionne à 1200 bauds
Messages : 463
Enregistré le : 27 janv. 2013 00:26
Localisation : Strasbourg
Contact :

Re: MPO 95 : Balayage des rationnels

Message par dprtl »

En trichant un peu, ce MPO est trop simple en Basic 1000D sur Atari ST (1990), avec le code naïf suivant :

Code : Tout sélectionner

clear timer
input n
u=1
for i=2 to n
  u=1/(2*int(u)+1-u)
next i
print "u(";n;")=";u;" en ";timer;"s"
Résultats :

Image

Pour un usage sur calculette, il n'y aurait pas grand chose à envier au langage Python (1991) qui équipe les modèles récents.
Avatar du membre
Danny
Fonctionne à 2400 bauds
Fonctionne à 2400 bauds
Messages : 1248
Enregistré le : 28 déc. 2013 16:34

Re: MPO 95 : Balayage des rationnels

Message par Danny »

Cool le code sur Atari ST ! 8)
? Apple, Atari, Canon, Casio, ????????????, HP, Psion, Sharp, Tandy... même TI.
Avatar du membre
C.Ret
Fonctionne à 9600 bauds
Fonctionne à 9600 bauds
Messages : 3405
Enregistré le : 31 mai 2008 23:43
Localisation : N 49°22 E 6°10

Re: MPO 95 : Balayage des rationnels

Message par C.Ret »

Danny a écrit : 25 août 2020 20:27Mais j’ai hâte de voir la mega astuce pour aller + vite :geek:
Pas de souci, les HP-65 pourront en profiter sans compromis, vieilles mais pas obsolètes ! (Comme les Terminator T1000)

dprtl a écrit : 25 août 2020 23:07 En trichant un peu, ce MPO est trop simple en Basic 1000D sur Atari ST (1990), avec le code naïf suivant :
Coup de bol qu'il n'y ai pas d'erreur d'arrondi !! :) :) Ah! Non, je confonds, les ATARI ne font pas de vilaines choses.

Bon, d'un autre coté, en 1986 on avait facilement une valeur approchée avec exactement le même code , mais un matériel concurrent:
MPO 95 - C128D 80col. Full iterative Full Wrong U(500) U(5000) Approximations.gif
MPO 95 - C128D 80col. Full iterative Full Wrong U(500) U(5000) Approximations.gif (7.96 Kio) Vu 6724 fois
Bon d'accord il manque quelque part une vraie arithmétique rationnelle, mais c'est presque aussi rapide...
...mais beaucoup plus faux !
C'est de là que viens mon réflexe d'utiliser deux variables pour chaque rationnel, le pauvre BASIC dont je disposais me donnait bien du grain à moudre.

Remarquons au passage que chez les Commodoristes, contrairement aux Ataristes, on remet à zéro le TIMER après la saisie, sinon le programme mesure aussi le temps mis par l'utilisateur pour entrer le nombre !
J'en déduis que dptrl affiche les temps de calculs afin de mesurer la vélocité et la concentration de l'utilisateur. Et que les temps affichés nous indique comme il est prompt à saisir 500 ou 5000 puis presser sur la touche ENTER de son jackintosh
MPO 95 - C128D 80col. Better U(500) U(5000) determination using two variables for rational A B.gif
MPO 95 - C128D 80col. Better U(500) U(5000) determination using two variables for rational A B.gif (8.39 Kio) Vu 6724 fois
Woaw ! Pas d'erreur d'arrondi ?? C'est bizarre sur cette machine :)

Bon, ça n'a pas l'avantage du BASIC sophistiqué, structuré et bien plus utile mathématiquement de l'ATARI, mais ce code fonctionne dès 1977 sur les premiers PET et CBM comme sur les derniers C128.

dprtl a écrit : 25 août 2020 23:07 Pour un usage sur calculette, il n'y aurait pas grand chose à envier au langage Python (1991) qui équipe les modèles récents.
Très juste. Sauf que l'ATARI, comme les PET et CBM ne tienent pas dans une poche (ni un cartable).

gege a écrit : 25 août 2020 00:25 J'aime lire tes super explications.

Je donne donc ci-dessous une meilleure interprétation de mon accélération à l'aide de la séquence Fusc() c'est à dire la suite diatomique de Stern.
Elle permet de calculer chaque terme de la suite de rationnels qui nous intéresse dans cet MPO !

Image

La mnémonisation des termes de cette suite ne semble pas, à priori produire un avantage par rapport à ma mnémonisation directe de la suite U() ou des numérateurs et dénominateurs a(n) et b(n) si l'on veut éviter les arrondis et mauvais calculs (comme ceux sur mon CBM 8 bits).

Mais en fait, si comme l'indique la formule ci-dessus, les séquences a(n), b(n+1) et Fusc(n) sont identiques, ce qui permet un gain de mémoire, mais aussi de simplifier énormément le calcul des U(n) car - et c'est là que c'est presque magique - la séquence Fusc a des propriétés remarquable, issue de la façon dont est construit l'énumération des rationnels sous la forme d'arbres binaires.

Code : Tout sélectionner

U(n) = a_n / b_n = fusc_n / fusc_n+1
 n     0  1  2  3  4  5  6  7  8  9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32
a_n    0  1  1  2  1  3  2  3  1  4  3  5  2  5  3  4  1  5  4  7  3  8  5  7  2  7  5  8  3  7  4  5  1...
b_n+1     1  1  2  1  3  2  3  1  4  3  5  2  5  3  4  1  5  4  7  3  8  5  7  2  7  5  8  3  7  4  5  1...
fusc_n 0  1  1  2  1  3  2  3  1  4  3  5  2  5  3  4  1  5  4  7  3  8  5  7  2  7  5  8  3  7  4  5  1...

pairs     ^  ^  :  ^  !  :  .  ^     !     :     .     ^           !           :           .           ^...
impairs        1+1   1+2   2+1   1+3   3+2   2+3   3+1   1+4   4+3   3+5   5+2   2+5   5+3   3+4   4+1  ...

Il existe donc une définition récurrente des Fusc():
  1. Fusc(0)=0
  2. Fusc(1)=1
  3. Fusc(2n)=Fusc(n) tous les éléments d'indices pairs ont pour valeur celle du premier indice impair.
  4. Fusc(2n+1)=Fusc(n)+Fusc(n+1) tous les éléments d'indices impairs se déduisent (un peu comme une suite de Fibonacci) à partir des valeurs des éléments de part et d'autre du demi-indice.
Le point 3 permet d'avoir bien moins de valeurs à mémoriser.
Par exemple Fusc(1)=Fusc(2)=Fusc(4)=Fusc(8)=Fusc(16)=...=1 d'où l'idée d'utiliser non pas une mnémonisation basée sur un tableau indicé, mais une liste munie d'un dictionnaire, c'est à dire la liste énumérant les indices impairs déjà mémorisés.
Le point 4 permet de déterminer la valeur d'un élément Fusc(i) d'indice impair à l'aide des deux demi-indices FLOOR(i/2) et CEIL(i/2). L'un deux sera d'ailleurs impair et l'autre pair.

En calculant U(1000), on se rend compte qu'il ne faut en fait que 20 appels récursifs et qu'il suffit de mémoriser 10 éléments d'indices impairs. Le calcul ne prend alors que quelques secondes, car cela est bien plus rapide et produit moins d'opérations que les calculs des 999 (ou 998 si l'on commence à i=1) valeurs intermédiaires de U(n) (même si en réalité seuls les B(n) nécessitent un calcul, les A(n) n'étant que la copie du registre B précèdent.
Comme pour la suite de Fibonacci, le seul calcul est une addition ( Fusc(2n+1)=Fusc(n)+Fusc(n+1) ) ce qui ne pose pas trop de souci d'arrondi ou de complication. Donc pas de multiplication, ni valeur entière, ni soustraction etc. => Algorithme très propice à une implémentation en assembleur !

La figure ci-dessous indique la façon dont s'emboite les appels récursifs et se construit au fur et à mesure la mnémonisation:
MPO 95 - Recursive Fusc's Calls U(1000) U(500).gif
MPO 95 - Recursive Fusc's Calls U(1000) U(500).gif (59.33 Kio) Vu 6769 fois
Comme les valeurs Fusc(i) d'indices impairs sont systématiquement mémorisées, les déterminations suivantes se font bien plus rapidement car le système trouve les valeurs directement dans la liste mémorisé.
Ainsi, la première détermination de U(1000) nécessitera 20 appels récursifs qui précalculent les dix valeurs d'indice impair, mais le second se limitera à deux car seules Fusc(1000→500→250→125) et Fusc(1001) seront évaluées.
De même , la détermination de Fusc(500) ne prendra que deux évaluations aux indices 125 et 501 déjà mnémonisé par la détermination de U(1000).

Comme on le voit aussi, il faut une machine qui supporte bien les appels récursifs emboités. En effet, 13 appels s'emboitent pour déterminer Fusc(1000) puis seulement 7 (grâce à la mnémonisation) appels emboités pour Fusc(1001). Les RPL et autres machines CAS récentes sont donc particulièrement adaptées à cette façon de faire.

Le code type d'un système RPL se base sur les 3 programmes suivants et deux listes respectivement FUn qui sert de dictionnaire (liste des indices impairs mémorisés) et FUv (liste des valeurs Fusc() de ces indices).

J'ai ajouté un petit programme qui remet à zéro les deux listes et un compteur nFC qui me sert à évaluer et décomposer le mécanisme. Le compteur est facultatif, mais c'est bien pratique pour analyser les phénomènes mis en jeu.

Code : Tout sélectionner

MPO96:
« → n                                                   // INPUT indice n
  « 'U(x)=a/b'                                          // Mise en forme du résultat 
       2       n          EXSUB                         // Substitue x par n 
          4    n     Fusc EXSUB                         // Substitue a par Fusc(n)
            6  n 1 + Fusc EXSUB                         // Substitue b par Fusc(n+1)
     980 .1 BEEP »                                      // Sonne fin du calcul 

Code : Tout sélectionner

Fusc:                                                                 
« 'nFC' 1 STO+                             // Incrémente compteur d'appels                        (facultatif)
  IF DUP 1 >                               // Fusc(n)=n pour n=0 ou n=1                            (raccourci)
  THEN WHILE DUP 2 MOD NOT                 // **** Boucle de division                         Fusc(n)=Fusc(2n)
       REPEAT 2 /                          //      Divise n par deux tant qu'il est pair  
       END → i                             // i = indice impair
           « FUn i POS                     // **** position p de l'indice i dans le dictionnaire 
             IF DUP                        // SI   position p est connue                (p=0 si i est inconnu)
             THEN 'FUv' SWAP GET           // ALORS  retourne valeur 'FUv(p)' issue de la mnémonisation 
             ELSE DROP                     // SINON 
                  i 2 / FLOOR Fusc         // **** Calcul récurssif Fusc(i)
                  i 2 / CEIL Fusc +        //                                     Fusc(2n+1)=Fusc(n)+Fusc(n+1)
                  DUP FUv + 'FUv' STO      // **** Mnémonisation: ajoute Fusc(i) au début des valeurs FUv 
                    i FUn + 'FUn' STO      //                     ajoute      i  au début du dictionnaire FUn 
             END »
  END »

Code : Tout sélectionner

IniFU:
« 0 { 1 } DUP 'FUn' STO 'FUv' STO 'nFC' STO »       // RAZ liste dictionnaire, tableaux et compteur d'appels
Exemple d'exécution avec U(1000) puis U(500) et avec U(500) après avoir remis tout à zéro (et donc effacer les valeurs précalculées.

Code : Tout sélectionner

IniFU                                              // Remet à zéro mnémonisation et compteur
1000 MPO96 →                     'U(1000)=11/39'   // Délai 5"8 secondes 
nFC        →                                  20   // (CF. diagramme) 13 appels emboités Fusc(1000)
                                                   //  et 7 pour Fusc(1001)
FUn        → { 1001 501 251 125 63 31 15 7 3 1 }
FUv        → {   39  28  17  11  6  5  4 3 2 1 }
500 MPO96  →                      'U(500)=11/28'   // Délai <1" seconde
nFC        →                                  22   // soit uniquement les 2 appels Fusc(500→250→125) et Fusc(501)    
FUn        → { 1001 501 251 125 63 31 15 7 3 1 }
FUv        → {   39  28  17  11  6  5  4 3 2 1 }

Code : Tout sélectionner

IniFU	                                           // Remet à zéro compteur et mnémonisation
500 MPO96  →                      'U(500)=11/28'   // Délai 5"4 secondes
nFC        →                                  18   //
FUn        →      { 501 251 125 63 31 15 7 3 1 }   // (CF. diagramme) 13 appels emboités Fusc(500) et 5 pour Fusc(501)
FUv        →      {  28  17  11  6  5  4 3 2 1 }   //    

Code : Tout sélectionner

IniFU                                               // Remet à zéro mnémonisation et compteur
1000 MPO96 →                      'U(1000)=11/39'   // Délai 5"8 secondes 
500 MPO96  →                       'U(500)=11/28'   // Délai <1" seconde
5000 MPO96 →                     'U(5000)=43/162'   // Délai 8"1 secondes
nFC        →                                   46   // 20 pour U(1000) 2 pour U(500) donc 24 pour U(5000)
FUn        →{ 5001 2501 1251 625 313 157 79 39 19
              9 5 1001 501 251 125 63 31 15 7 3 1 } // 21 indices impairs mnémonisés
FUv        → { 162  119   76  43  33  23 13 10  7  
              4 3   39  28  17  11  6  5  4 3 2 1 } // 21 valeurs mnémonisés

Code : Tout sélectionner

IniFU                                               // Remet à zéro mnémonisation et compteur
5000 MPO96 →                     'U(5000)=43/162'   // Délai 6"3 secondes
nFC        →                                   26   // 26 appels récursifs
FUn        →{ 5001 2501 1251 625 313 157 79 39 19
                                          9 5 3 1 } // 13 indices impairs mnémonisés
FUv        → { 162  119   76  43  33  23 13 10  7  
                                          4 3 2 1 } // 13 valeurs mnémonisés
Voilà, une façon de faire. Qui pourrait donner lieu à des codes sans mnémonisation, tous les calculs des Fusc() se faisant de façon récursive jusqu'à l'indice 0 ou 1. Cela augmenterai quelque peu les appels emboités par un facteur variant entre 2 et 3. Ce qui est toujours bien mieux que de calculer toutes les itérations de 1 à n.

Mais, il existe une méthode encore plus sioux, où même pour U(5000), il ne faut que 12 itérations (ou appels).
Méthode facile à programmer, même sur une HP-65 ! :twisted: :twisted:
Modifié en dernier par C.Ret le 26 août 2020 19:52, modifié 3 fois.
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.
Avatar du membre
dprtl
Fonctionne à 1200 bauds
Fonctionne à 1200 bauds
Messages : 463
Enregistré le : 27 janv. 2013 00:26
Localisation : Strasbourg
Contact :

Re: MPO 95 : Balayage des rationnels

Message par dprtl »

C.Ret a écrit : 26 août 2020 14:59 Remarquons au passage que chez les Commodoristes, contrairement aux Ataristes, on remet à zéro le TIMER après la saisie, sinon le programme mesure aussi le temps mis par l'utilisateur pour entrer le nombre !
J'en déduis que dprl affiche les temps de calculs afin de mesurer la vélocité et la concentration de l'utilisateur. Et que les temps affichés nous indique comme il est prompt à saisir 500 ou 5000 puis presser sur la touche ENTER de son jackintosh
Même dans 7 lignes de code il peut y avoir une bêtise. Bien vu ! :oops:
Avatar du membre
C.Ret
Fonctionne à 9600 bauds
Fonctionne à 9600 bauds
Messages : 3405
Enregistré le : 31 mai 2008 23:43
Localisation : N 49°22 E 6°10

Re: MPO 95 : Balayage des rationnels

Message par C.Ret »

dprtl a écrit : 26 août 2020 15:52Même dans 7 lignes de code il peut y avoir une bêtise. Bien vu ! :oops:
Je n'ai aucun mérite, je l'ai fais des milliers de fois. Et souvent sans m'en rendre compte. En général, lors des essais le temps pour enter les valeurs tests est identique d'un essai à l'autre.

c'était juste histoire de trouver un truc à dire , parce que, .. il faut bien un peu perpétuer la tradition et dénigré systématiquement la marque concurrente chez qui est aller le fondateur ... Donc, dénigré même s'il n'y a rien, bien au contraire (on peut le dire maintenant) qu'ATARI c'était mieux que Commodore - chut! )
Modifié en dernier par C.Ret le 26 août 2020 18:59, modifié 1 fois.
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.
Avatar du membre
dprtl
Fonctionne à 1200 bauds
Fonctionne à 1200 bauds
Messages : 463
Enregistré le : 27 janv. 2013 00:26
Localisation : Strasbourg
Contact :

Re: MPO 95 : Balayage des rationnels

Message par dprtl »

Le Basic 1000D pourrait sans doute être ré-assemblé, au moins en partie, sur n'importe quelle machine 68K : Amiga, TI-92, TI-89 ? Cela dit, même sur un ST ou TT, avec le code source et la documentation que l'auteur a laissé, ça reste difficile (pour un non-spécialiste de l'ASM). Je reste émerveillé par tout ce qui a été casé dans cet interpréteur de 122 Ko. Pour comparaison, le binaire de base de Python 3.8 pèse 5,3 Mo. C'est peu pour une machine récente, mais il faudrait 8 disquettes double densité.
Avatar du membre
Danny
Fonctionne à 2400 bauds
Fonctionne à 2400 bauds
Messages : 1248
Enregistré le : 28 déc. 2013 16:34

Re: MPO 95 : Balayage des rationnels

Message par Danny »

C.Ret a écrit : 26 août 2020 14:59[...]
Voilà, une façon de faire. Qui pourrait donner lieu à des codes sans mnémonisation, tous les calculs des Fusc() se faisant de façon récursive jusqu'à l'indice 0 ou 1. Cela augmenterai quelque peu les appels emboités par un facteur variant entre 2 et 3. Ce qui est toujours bien mieux que de calculer toutes les itérations de 1 à n.
J’ai envie de dire Fusc me !! 8O
C.Ret a écrit : 26 août 2020 16:04Je n'ai aucun mérite, je l'ai fais des milliers de fois. Et souvent sans m'en rendre compte. En général, lors des essais le temps pourentre les valeurs tests est identique d'un essai à l'autre.
C’est pas faux, si le développeur est aussi le testeur il risque d’aller trop vite et de ne pas se rendre compte du souci :geek:
? Apple, Atari, Canon, Casio, ????????????, HP, Psion, Sharp, Tandy... même TI.
Avatar du membre
C.Ret
Fonctionne à 9600 bauds
Fonctionne à 9600 bauds
Messages : 3405
Enregistré le : 31 mai 2008 23:43
Localisation : N 49°22 E 6°10

Re: MPO 95 : Balayage des rationnels

Message par C.Ret »

Danny a écrit : 26 août 2020 18:08J’ai envie de dire Fusc me !! 8O
D'après ma documentation, la séquence Fusc() aurait été nommée ainsi en 1976 à cause de l'aspect intelligible de sa représentation graphique par Edsger W. Dijkstra en personne !
"the fusc function, named according to the obfuscating appearance of the sequence of values "

Image
Fusc (0 à 4096)

Fusc étant donc l'abréviation de "obfuscating appearance", mais connaissant le personnage , FUSC EVERY (math) BODIES est bien dans le ton et l'esprit facétieux des universitaires de l'époque ! Puisque la découverte de cette séquence et ses propriétés a révolutionné et remis en question pas mal de travaux scientifiques de cette époque surtout en théorie des nombres. Elle ouvre la porte à de nouvelles technologies des mathématiques appliquées et techniques industrielles du numérique.
EWD570 and EWD578.
Le document EWD578 est aussi un des premiers à signaler une autre propriété de cette séquence et qui concerne son RUN-lenght-encoding (ou codage par plage binaire) qui est une des deux (l'autre concerne les fractions continues) puissantes clefs de la méthode vraiment rapide du calcul des U(n).
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.
Avatar du membre
C.Ret
Fonctionne à 9600 bauds
Fonctionne à 9600 bauds
Messages : 3405
Enregistré le : 31 mai 2008 23:43
Localisation : N 49°22 E 6°10

Re: MPO 95 : Balayage des rationnels

Message par C.Ret »

Ah! tant que j'avais mon HP-28S sous la main (et qui lui reste des piles), j'ai essayé de faire sans mnémonisation.

L'HP-28S a l'avantage de savoir calculer un déterminant.
Le plus dure est de lui faire construire une matrice trigonale, le code suivant peut être raccourci, mais c'est pour le moment la façon la plus rapide de construire la matrice trigonale ad'hoc.

Je trouve maintenant U(500)=11/28 en 7"8 et U(5000)= 43/162 en 6"9
Ces deux temps sont indépendant des calculs déjà effectués, il n'y a plus de mnémonisation, c'est une méthode directe dont le temps de calcul pour U(n) ne dépend que de n.
Et oui, le calcul pour U(5000) est plus rapide que celui pour U(500) ! C'est dingue !

Comme pour la méthode avec mnémonisation j'utilise la relation U(n)=Fusc(n)/Fusc(n+1). vous trouverez donc ci-dessous le même code MPO95.
J'ai juste changé la façon de calculer Fusc(n) : plus de récurrence, plus de séquence de Stern, ... que du direct.

Code : Tout sélectionner

MPO95:
« → n                                              // INPUT indice n
  « 'U(x)=a/b'                                     // Mise en forme du résultat 
       2       n          EXSUB                    // Substitue x par n 
          4    n     FUSC EXSUB                    // Substitue a par Fusc(n)
            6  n 1 + FUSC EXSUB                    // Substitue b par Fusc(n+1)
     980 .1 BEEP »                                 // Sonne fin du calcul 

Code : Tout sélectionner

FUSC:   // Calcule Fusc(n) via déterminant matrice trigonale issue décomposition puissances binaires L de n
« → n « {} n DUP LOG 2 LOG / IP 0 FOR i 2 i ^
          IF DUP2 >= THEN - SWAP i + SWAP ELSE DROP END 
        -1 STEP DROP DUP SIZE 1 - 1 MAX → L d
          « d IDN DUP  ARRY→ DROP d SQ ROLL  { d d } →ARRY
            OVER ARRY→ DROP d SQ ROLLD { d d } →ARRY + + 1 1 d FOR i
              1 L i GETI ROT ROT GET - + PUTI d +
            NEXT DROP DET » » »
Evidemment, en lisant ce code RPL (que je ne commente pas volontairement comme ça il reste codé , le RPL est naturellement impossible à relire (parfois même pour l'auteur du programme), hé hé hé - c'est exactement comme l'huile noire qui protège le code de mon PC-1211).
Mais certains auront compris que l'on peut faire encore mieux. En effet, j'effectue toujours deux déterminations, une pour n et l'autre pour n+1. Ce qui fait qu'il y a aussi deux décompositions alors qu'une peut suffire, même sans utiliser de fraction continue car l'HP-28S sait manipuler des matrices, toutes sortes de matrices.

Une nouvelle version, plus efficace va donc rapidement apparaitre qui utilise les fractions G=[[1 0][1 1]] et D=[[1 1][0 1]] :)
Modifié en dernier par C.Ret le 05 déc. 2021 09:40, modifié 1 fois.
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.
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: MPO 95 : Balayage des rationnels

Message par gege »

Bonjour,
Ce code RPL explique bien pourquoi après pas mal d'utilisation j'ai laissé tomber définitivement.
Ce truc est illisible.
Or on n'écrit JAMAIS un programme, on ne fait que CORRIGER une page blanche… :)
G.E.
Avatar du membre
Danny
Fonctionne à 2400 bauds
Fonctionne à 2400 bauds
Messages : 1248
Enregistré le : 28 déc. 2013 16:34

Re: MPO 95 : Balayage des rationnels

Message par Danny »

Bon en même temps, le code RPL de C.Ret mériterait un peu + d’indentation et de formatage pour être + lisible :geek: :P
? Apple, Atari, Canon, Casio, ????????????, HP, Psion, Sharp, Tandy... même TI.
Avatar du membre
C.Ret
Fonctionne à 9600 bauds
Fonctionne à 9600 bauds
Messages : 3405
Enregistré le : 31 mai 2008 23:43
Localisation : N 49°22 E 6°10

Re: MPO 95 : Balayage des rationnels

Message par C.Ret »

gege a écrit : 28 août 2020 11:39...Ce truc est illisible....
Oui, et là c'est un peu fait exprès pour laisser aux plus ardus des explorateurs de code le plaisir de débroussailler tout ça !
Danny a écrit : 28 août 2020 14:58 Bon en même temps, le code RPL de C.Ret mériterait un peu plus d’indentation et de formatage pour être plus lisible :geek: :P


C'est vrai, à l'heure où le Python fait rage, publier un code volontairement mal indenté, c'est pas gentil :( du tout.

Maintenant, je ne suis pas sûr que même avec l'indentation la + rigoureuse, ce truc soit vraiment + lisible:
La preuve :
MPO 95 - HP-28S Coloured and Indented R P L code for FUSC using DET.gif
MPO 95 - HP-28S Coloured and Indented R P L code for FUSC using DET.gif (38.74 Kio) Vu 6666 fois
Aïe , j'aurais pas dû ! Surtout avec les codes couleur qui, si vous êtes attentif, divulguent quelques détails en + .

Maintenant, je ne suis pas fâché de publier quelque chose de propre, parce que dans trois semaines j'aurais plus vite fait de tout refaire que de chercher à modifier ça.

Mais, même si ce code est plus direct et plus court que les versions précédentes pour mon HP-28S, il n'est pas , et de loin le plus performant ! Si vous voulez tirer parti de la puissance du calcul matriciel de votre système RPL, je vous conseille ce truc là, qui est + court + rapide +simple +efficace:

Et plus facile à présenter bien indenté:
MPO 95 - HP-28S Fast Fancy Matrix based direct U_n.gif
MPO 95 - HP-28S Fast Fancy Matrix based direct U_n.gif (24.62 Kio) Vu 6659 fois
En moins de deux secondes et dix centièmes 500 U affiche [[ 11 28 ]]
et il ne faut pas plus de 32 centièmes de plus pour que 5000 U affiche [[ 43 162 ]]

J'obtiens U( 20200828 )=[[ 6451 / 14045 ]] en 4"21 (contre 15"80 avec la mnémonisation et 35"68 avec le calcul par déterminant )

Les lecteurs les plus attentifs de ce fil auront certainement remarqué qu'il y a pas mal de point commun avec ce dernier code et celui utilisant le déterminant (en plus des mêmes codes couleur). Je leur ferai remarqué que ce sont justement aussi les points communs avec le premier code que j'ai posté sur ce fil pour mon PC-1211. Même si cela ne se voit pas bien à cause de l'huile noire.

Mais ce n'est pas fini, je n'ai pas utilisé encore l'astuce concernant les fractions continues !

P.S.: J'aime bien la structure très symétrique de ce dernier code, mais ce n'est pas le plus court; Il y a moyen de bien le raccourcir. Je vous laisse essayer. N'hésiter pas à nous proposer une version plus courte !
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.
Avatar du membre
Danny
Fonctionne à 2400 bauds
Fonctionne à 2400 bauds
Messages : 1248
Enregistré le : 28 déc. 2013 16:34

Re: MPO 95 : Balayage des rationnels

Message par Danny »

Moi je quitte définitivement le forum 8O

Image



:mrgreen:
? Apple, Atari, Canon, Casio, ????????????, HP, Psion, Sharp, Tandy... même TI.
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: MPO 95 : Balayage des rationnels

Message par gege »

Bonjour,
WOOOWW
Il semble que nous ayons ouvert la boîte de Pandore et que C.ret soit irrémédiablement passé en mode berzerk.
J'espère qu'il n'a pas mon adresse.
Sinon, on aimerait une chtite explication du pourquoi du comment mais un petit peu moins mongue (Monsieur Cadbury) ?
Bravo
G.E.
Répondre

Retourner vers « Tous les Pockets »