Ma calculette ne peut pas gérer de liste de plus de 10000 éléments
J'utilise beaucoup les listes depuis quelques temps et donc j'ai testé que :
une liste peut contenir des listes de 9999 éléments
je suis monté jusque 6 listes de plus de 9000 éléments
théoriquement on devrait pouvoir créer une liste de 9999 listes de 9999 éléments (pas testé )
C.Ret a écrit :
Le gain de temps doit provenir de l'utilisation des variables globales et de la fonction FP() dont l'appel doit être plus rapide que les fonctions CAS odd ou even (entre-temps je les ai trouvées, ainsi que le catalogue de toutes les fonctions de ma machine )
Le passage de l'environnement Home au CAS qui se fait chaque fois que l'on utilise une fonction CAS dans un programme non CAS prend du temps, du coup utiliser FP est plus rapide que odd ou even.
C.Ret a écrit :
Par ailleurs si quelqu'un connaît un moyen de supprimer un terme d'une suite sans utiliser DIFFERENCE, et qu'il peut nous l'expliquer, je lui en serai fort reconnaissant.
Je ne connais pas de fonction sur la Prime qui le fasse directement, mais si on veut supprimer l'élément n d'une liste , on peut utiliser la fonction suivante :
Pour effacer un des éléments d'une liste il n'y a donc pas d'astuce simple, comme y mettre un élément vide ou un truc du genre.
Je garde donc mon idée d'utiliser DIFFERENCE qui me permet de réaliser l'opération sans aucun test.
C.Ret a écrit :Je garde donc mon idée d'utiliser DIFFERENCE qui me permet de réaliser l'opération sans aucun test.
oui, mais ce n'est pas le plus rapide. Ci-dessous j'ai codé les 2 versions de la fonction de suppression d'un élément d'une liste:
Suppress0: ce que tu utilises dans ton programme avec DIFFERENCE
Suppress1: ma proposition avec CONCAT
Le programme TestSup(n) créé une liste de n éléments, puis appelle n fois chaque fonction Suppressx pour supprimer successivement chaque élément. Il retourne le temps total de l’opération pour chaque fonction Suppressx.
A essayer avec TestSup(9000) sur l’émulateur et TestSup(2000) sur la calculatrice.
EXPORT Suppress0(list,n)
BEGIN
−1▶list(n);DIFFERENCE(list,−1);
END;
EXPORT Suppress1(list,n)
BEGIN
LOCAL m:=SIZE(list);
CONCAT(IFTE(n=1,{},list({1,n-1})),IFTE(n=m,{},list({n+1,m})));
END;
te0(n)
BEGIN
FOR I FROM 1 TO n DO Suppress0(L0,I); END;
END;
te1(n)
BEGIN
FOR I FROM 1 TO n DO Suppress1(L0,I); END;
END;
EXPORT TestSup(n)
BEGIN
local t0, t1;
L0:=MAKELIST(I,I,1,n);
t0:=TEVAL(te0(n));
t1:=TEVAL(te1(n));
RETURN {t0,t1};
END;
C.Ret a écrit :
Par ailleurs si quelqu'un connaît un moyen de supprimer un terme d'une suite sans utiliser DIFFERENCE, et qu'il peut nous l'expliquer, je lui en serai fort reconnaissant.
En fait il y a une bien une fonction pour ça, c'est la fonction suppress du CAS: suppress(list,n) supprime dans une liste l’élément d’indice n, et non comme c'est indiqué de manière erronée dans le guide de l'utilisateur: "supprime la première occurrence de l'élément dans la liste".
Par contre comme c'est une fonction CAS c'est beaucoup plus lent que les solutions discutées précédemment....
#cas
syr(n):=
BEGIN
IP(n)▶n▶m;0▶f;TICKS▶t;
WHILE n>1 DO 1+f▶f; IF even(n) THEN n/2▶n ELSE 3*n+1▶n; MAX(m,n)▶m; END; END;
return {f,m,(TICKS-t)*.001_(s)};
END;
#end
Bonjour,
Excellent !
Ton idée des valeurs clefs est un bon exemple du dilemne de l'optimisation sur caltos : l'algorithme simpliste est beaucoup plus court, donc passe comparativement beaucoup plus de temps dans les primitives du langage qui sont en langage machine, alors que la version intelligente rame dans les dédales de l'interpréteur.
Pour gagner il faut une méthode qui prenne un raccourci radical dans le nombre d'instructions...
G.E.
#cas
syr(n):=
BEGIN
IP(n)▶n▶m;0▶f;TICKS▶t;
WHILE n>1 DO
IF odd(n) THEN
3*n+1▶n; MAX(m,n)▶m; 1+f▶f;
END;
n/2▶n+1; 1+f▶f;
END;
return {f,m,(TICKS-t)*.001_(s)};
END;
#end
EDIT: je viens de tester sur ma Prime et je ne retrouve pas le gain de performance observé sur l'émulateur
Assembly language routine for the PB-1000 series for large numbers up to 16 digits in BCD format.
Most of the instructions are not supported by the built-in assembler of the PB-1000.
Xerxes a écrit :Assembly language routine for the PB-1000 series for large numbers up to 16 digits in BCD format.
Most of the instructions are not supported by the built-in assembler of the PB-1000.
Very impressive demonstration ! One day, will you publish some "educational content" about all your discoveries on the Casio PB-1000 ? About the HD61700 product line, assembly langage, and tools ? Wikipedia content is still very poor, and a lot of links, in the vintage Casio calculators sphere, tend to become broken.
merci for your kind words. The HD61700 is a highly interesting CPU with a very nice and special instruction set. Unfortunately the
PB-1000 assembler contains a subset of these instructios only. What I miss particularly, are the instructions for LCD access and
the multi byte commands, that allows to handle up to 64 bit in 8 bit steps at once. Something similar is also available on the SHARP
CPUs, but by far not that consequent. This concept allows interesting solutions in some cases and a significant speed gain too.
I've send all my discoveries regarding the HD61700 to Piotr, for having his excellent PB-1000/PB-2000C emulator, as accurate as
possible. You will find all about the PB-1000 on his site. Some HD61700 tools are available here.
Please notice, that I use different mnemonics for the undocumented instructions. I think the ones in the documentations are the
creaton of some Japanese while reverse engineering. The ones I use, are the original mnemonics that CASIO used to develop
the HD61700 based pockets.