À notre grand regret la formidable calculatrice HP Prime que nous avions plusieurs fois classée première dans nos tests de rentrée QCC, avait cessé d'évoluer depuis maintenant des années :
- la dernière mise à jour 2.1.14433 hélas très mineure remontait à Janvier 2020
- et la dernière mise à jour majeure 2.1.14181 remontait à Novembre 2018
C'était d'autant plus regrettable qu'une application Python était bel et bien en préparation au moins depuis octobre 2019 ; les développeurs avaient bien donc fait la veille institutionnelle, anticipé et prévu de quoi être à l'heure, avant que l'on vienne leur mettre des bâtons dans les roues.
Or comme nous te l'annoncions dans un article précédent, il y a eu un incident concernant la HP Prime aux Pays-Bas. Le calcul exact QPiRac est interdit aux examens à compter de cette session 2021, sauf que comme la HP Prime n'a plus été mise à jour depuis des années son mode examen ne tient bien évidemment pas compte de cette nouvelle règle. L'Institution néerlandaise a exigé une mise à jour d'ici la fin du mois d'avril.


Les développeurs HP Prime t'invitent à participer à un bêta-test public de cette prochaine mise à jour. Ils t'ont sorti la semaine dernière une version 2.1.14541.
Cette mise à jour inclut enfin l'application Python ainsi qu'une titanesque collection d'autres nouveautés ; cela valait le coup d'attendre !

Tes retours sont de préférence à effectuer par courriel à calcbeta@hp.com.
Nous allons prendre le temps de te détailler l'ensemble des nouveautés de cette version, de t'en expliquer l'utilisation avec des exemples, mais également de les tester et te donner notre avis.
N'hésite pas à utiliser le sommaire ci-dessous afin d'accéder directement aux points qui t'intéressent le plus.
La mise à jour 2.1.14541 bêta a donc été compilée le 13 avril 2021. Elle concerne :
- les calculatrices HP Prime G1 et HP Prime G2
- le logiciel HP Prime pour machines Windows 32 bits et Windows 64 bits
- le logiciel de connectivité pour machines Windows 32 bits et Windows 64 bits
Sommaire :
- Moteur de calcul exact QPiRac - Home
- Mode examen et Pays-Bas
- Solveur de lois de probabilités - boîte à outils
- Solveur de triangles
- Solveur d'équations
- Bibliothèque d'unités
- Graphes, fonctions et coordonnées
- Listes et matrices
- Saisie en notation RPN
- USB - HP Prime G2
- Moteur de calcul formel - CAS
- Applications
- Python
- Python : Éditeur et aide en ligne
- Python : Console et clavier
- HPPPL / Python / CAS : Editeur hybride de projets + nouveautés HPPPL
- Python : Implémentation, entiers et performances - import sys
- Python : Nombres flottants et performances - transfert de scripts
- Python : Mémoire tas/heap - import gc
- Python : Mémoire pile/stack
- Python : Modules intégrés standard et propriétaires
- Python : Appels HPPPL - import hpprime
- Python : Clavier et tactile - import hpprime
- Python : Tracé par pixels et performances - import hpprime
- Python : Tracé dans un repère - import hpprime
- Python : Bilan modules
- Conclusion
- Téléchargements
A) Moteur de calcul exact QPiRac - Home
Go to top- le mode numérique avec l'écran de calcul accessible via
⌂Home
et les diverses applications accessibles viaApps
, le tout développé par HP, agrémenté de diverses interfaces graphiques et offrant pléthore de fonctions avec des noms en majuscules - le mode CAS avec l'écran de calculs
CAS
offrant pour sa part un moteur de calcul formel (le moteur GIAC développé pour le logiciel Xcas par Bernard Parisse enseignant-chercheur à l'Université de Grenoble), accompagné ici d'interfaces spécifiques en mode texte et offrant des fonctions avec des noms en minuscules
L'écran ⌂Home cible le calcul numérique. C'est-à-dire qu'il fournit les résultats en écriture décimale, approchés si besoin.


- soit utiliser l'écran de calcul
CAS
avec ce qu'il impliquait, soit interfaces en texte, noms de fonctions différents et en minuscules - soit rester sur l'écran ⌂Home mais y spécifier un appel au moteur CAS sous la forme
CAS.eval(...)
, rapidement lourd si tu devais le faire pour chaque calcul - soit encore sur l'écran ⌂Home spécifier tes calculs au sein d'un appel
QPI(...)
plus rapide à saisir, recherchant alors un résultat exact approchant sous les formes$mathjax$\pm a\sqrt{\frac{b}{c}}$mathjax$(QRac) ou$mathjax$\pm a\sqrt{\frac{b}{c}}\pi$mathjax$(QPi) pas toujours pertinentes - soit encore sur l'écran ⌂Home sélectionner un résultat numérique puis taper
ab/c
, mais cela ne faisait que rechercher une forme$mathjax$\frac{a}{b}$mathjax$proche du résultat en question et ne fournissait qu'encore plus rarement des résultats pertinents




Attention toutefois, actuellement il ne semble pas activé par défaut. Il te faut accéder aux paramètres via
Shift
⌂, et cocher Intelligent Math sur la 2ème page.



Les formes gérées sont un peu plus larges qu'avec la fonction QPI(), elles semblent s'étendre cette fois-ci au QPiRac, c'est-à-dire à tout ce qui appartient aux 2 familles de nombres suivantes :
- QPi : multiples rationnels de π - $mathjax$\pm\frac{a\pi}{b}$mathjax$(pour les angles en radians notamment)
- binômes de rationnels et/ou radicaux - $mathjax$\frac{\pm a\sqrt{b} \pm c\sqrt{d}}{f}$mathjax$(ce qui couvre un large ensemble allant des fractions du collège aux racines de polynômes du 2nd degré au lycée en passant par nombre de valeurs remarquables en trigonométrie)

ab/cgère désormais elle aussi les formes QPi et QRac, activables à l'écran de configuration.

À partir de l'affectation la valeur exacte semble définitivement perdue, ne pouvant être retrouvée automatiquement.
Même problème de moteur de calcul exact ineffectif dans le contexte des objets composés à partir de plusieurs nombres (listes, matrices, nombres complexes...).


En parlant d'affectations nouveauté également, tu as enfin la possibilité d'affecter simultanément plusieurs variables.


Les erreurs de calcul dans ce contexte (résultat proche de zéro au lieu d'un résultat nul, résultat très grand au lieu d'une erreur) se font bien plus rares, mais ne disparaissent pas complètement pour autant.


B) Mode examen et Pays-Bas
Go to top
Aux Pays-Bas les examens de l'enseignement secondaire exigent l'activation du mode examen des calculatrices, mais interdisent de plus certaines fonctionnalités :
- le calcul formel (CAS)
- tout élément logiciel additionnel (ce qui interdit certes les programmes préchargés mais également toute application additionnelle, c'est-à-dire sur certains modèles même les applications officielles préchargées lorsqu'elles ont le tort de ne pas être intégrées au système)
- tout accès à un éditeur de texte (ce qui interdit entre autres l'ouverture de l'éditeur de programmes, et par conséquent toute création de programme pendant l'examen)


- durée suffisante (4 heures)
- contenu mémoire préexistant masqué ou effacé
- et en prime préciser des fonctionnalités à verrouiller via le bouton tactile Configuration en bas d'écran :
- Apps utilisateur
- CAS
- Remarques et programmes
- Nouv. remarques et programmes

Or il n'y avait aucune option relative à cela ; les résultats exacts QPiRac restaient dans tous les cas accessibles en mode examen via la fonction QPI(...).

- Intelligent Math
- a b/c Key options
HP va même très loin pour faire plaisir aux Pays-Bas, jusqu'à présent le mode examen personnalisé n'avait par défaut aucune limitation de fonctionnalités activée.
Et bien désormais gros changement désormais, le a b/c Key options est coché par défaut.

- la mise sous forme exacte via la touche
ab/c
- la mise sous forme exacte via la fonction QPI(...)
Il semble donc que les candidats aux Pays-Bas devront dès cette année cocher quand même 1 limitation supplémentaire à l'écran de configuration des fonctionnalités en mode examen :
- Apps utilisateur
- CAS
- Intelligent Math
- Remarques et programmes
- Nouv. remarques et programmes
- a b/c Key options (coché par défaut)



Lorsque la calculatrice est réglée en Néerlandais, les champs permettant de choisir le type de définition de suite ainsi que le rang initial éventuel passent en premier.


- une nouvelle option permet de désactiver les fonctions CAS d'arithmétique ifactor(), idivis(), igcd() et lcm()
- Do1VStats désactive désormais également les fonctions CAS de médiane, quartile et moyenne
- Stat2Vars désactive désormais également les fonctions de régression du mode CAS
- le même réglage unique désactive désormais les fonctions comb(), perm(), min() et max() aussi bien en mode numérique que CAS
C) Solveur de lois de probabilités - boîte à outils
Go to top
Tu avais une fonction pour chaque type de loi de probabilités, et également une fonction pour chaque type de question à résoudre (densité, cumulatif et inverse). Soit pas moins de 7×3=21 fonctions avec des noms différents et bien sûr des paramètres différents.

🧰te permet désormais d'accéder à un solveur de problèmes de lois de probabilités continues.
Pas moins de 5 lois t'y sont proposées au choix :
- normale
- Student
- χ2
- Fisher
- géométrique

- center pour travailler sur la forme p(...≤X≤...)
- lower tail pour travailler la forme p(X≤...)
- upper tail pour travailler la forme p(X≥...)
- tails pour travailler la forme p(X≤... ∪ X≥...)

- le ou les paramètres de la loi de probabilité concernée
- ainsi que l'information dont tu disposes dans ton problème, soit au choix :
- la valeur de la probabilité
- la ou les bornes de l'intervalle

Simple, intuitif, avec même en prime un diagramme t'illustrant la question travaillée ainsi que sa réponse, bravo HP !

Cela nous semble beaucoup ressembler à la superbe application de probabilités que la NumWorks propose depuis la rentrée 2017, mais ce n'est absolument pas un reproche. Quand c'est génial, pourquoi se gêner ?

D) Solveur de triangles
Go to top
Il te suffisait de saisir 3 informations (longueur d'un côté ou mesure d'un angle) afin d'obtenir les 3 mesures manquantes, peu importe qu'elles concernent des côtés ou des angles !

Cerise sur la gâteau dans cette mise à jour, lors de la résolution tu obtiendras en prime l'aire du triangle.
E) Solveur d'équations
Go to top

Plutôt qu'une erreur, elle te propose dans ce cas de les définir.
F) Bibliothèque d'unités
Go to top
Shift
□/□, les unités relatives aux couples de forces.


G) Graphes, fonctions et coordonnées
Go to top





- de cartésiennes à polaires avec la fonction polar_coordinates()
- de polaires à cartésiennes avec la fonction rectangular_coordinates()
Elle gère non seulement les coordonnées 2D cartésiennes et polaires, mais également en prime les coordonnées 3D cartésiennes, cylindriques et sphériques !
H) Listes et matrices
Go to top

Tu peux maintenant réaliser ces mêmes opérations en appelant les fonctions GET() ou PUT().
Un avantage notamment pour PUT() est que cela permet l'imbrication de son appel au sein d'une autre fonction, ce qui n'était pas possible avec l'opérateur d'affectation.


Tu as maintenant de nouvelles fonctions au comportement légèrement différent et qui peut-être te seront utiles, ListToMat() et MatToList().
I) Saisie en notation RPN
Go to top
- Livre pour la saisie en écriture naturelle comme dans tes livres et énoncés
- Algébrique pour une saisie sur une seule ligne, pouvant nécessiter par rapport à la précédente l'ajout de parenthèses
- RPN, une notation post-fixée dite notation polonaise inverse utilisée par défaut sur les calculatrices HP des années 1980 et 1990, une notation logique très rapide ne nécessitant aucune parenthèse, un bel hommage


J) USB - HP Prime G2
Go to top
USBOpen(vid, pid)
pour connecter le périphérique USBUSBSend({...})
pour envoyer des données au périphériqueUSBReceive()
pour lire des données depuis le périphérique
Pour l'instant les fonctions sont donc basiques, c'est-à-dire qu'elles doivent être utilisées pour programmer des pilotes gérant chacun des périphériques que tu souhaites utiliser.

Un
USBOpen(#0D28h,#0204h)
n'arrive pas à connecter une carte micro:bit v2. Ayant constaté plusieurs erreurs dans l'aide en ligne de cette version bêta, nous avons également tenté USBOpen(#0204h,#0D28h)
sans plus de succès.Nous n'avons pas réussi à retrouver le câble micro-USB direct venant avec la HP Prime, mais nous avons pas moins de 2 connectiques micro-USB qui permettent avec succès de faire détecter la micro:bit v2 à un smartphone OTG, cette dernière se comportant comme une clé USB. Donc ni la connectique ni la micro:bit v2 ne semblent fautifs.
Nous avons également tenté avec une calculatrice Casio Graph 90+E, un clavier USB filaire et pas moins de 3 souris USB filaires. Échec dans tous les cas...

Suspectant un problème d'alimentation nous avons également rechargé la HP Prime G2 à fond, sans changement.
Après, notre HP Prime G2 n'est pas un modèle de production mais un modèle de développement, possiblement non pleinement fonctionnel sur l'USB, ou mal détecté/géré par cette version bêta...
Nous allons tenter d'élargir les tests, et en cas de succès nous ne manquerons pas de t'en reparler.
K) Moteur de calcul formel - CAS
Go to top



L) Applications
Go to top
Petite nouveauté pour le développement d'applications, la fonction Apps() te permet d'obtenir la liste des applications installées sur la calculatrice, avec en premier élément le nom de l'application courante.
Particulièrement pratique pour les applications qui ont besoin de ressources présentes dans d'autres applications, ou dont les fonctionnalités sont réparties entre différentes applications à cause de la limite de taille à 4,5 Mo par application.
DelApp("nom_appli")
te permet également de réinitialiser une application contrairement à ce que son nom indique.1) Python : Éditeur et aide en ligne
Go to top- la vue
Symb
avec l'éditeur de script - la vue
Num
avec la console
Sur HP Prime G1 en application Python, tout appui sur la touche
Symbredémarre immédiatement la calculatrice.


Il est accompagné d'un menu de bas d'écran Tmplt permettant de saisir rapidement différents blocs de commandes Python.


Celui-ci liste les éléments des différents modules disponibles, et va même de façon fort logique jusqu'à lister les sous-éléments lorsqu'il y en a !

Bien dommage par contre que ces menus n'aient apparemment rien prévu pour saisir rapidement une commande incontournable comme import.



Il te suffit dans les menus précédents de sélectionner l'élément mais de ne pas valider, et à la place de taper
Help.
Bref, de gros défauts ou manques d'une part, mais également des avancées inédites hautement intéressantes d'autre part.
2) Python : Console et clavier
Go to top

Numpermet donc d'accéder à la vue de la console. La console à sa première ouverture importe automatiquement l'ensemble des scripts associés à l'application Python.
Par la suite elle te proposera de rafraîchir lors de tes aller-retours entre la console et l'éditeur, certes en Anglais alors que nous avons réglé la machine en Français.
import ...
et non pas from ... import *
.Tu devras donc systématiquement préfixer à la main tous tes appels aux éléments d'un script du nom du script en question.
Sinon, il te faudra saisir toi-même la commande
from ... import *
adéquate.C'est d'autant plus dommage que, rappelons-le, il n'y a apparemment rien au menu permettant de saisir rapidement des commandes import.


Nous avons toujours le menu Cmds en bas d'écran, mais plus le menu Tmplt pour saisir les blocs de commandes.
Cela peut s'expliquer par le fait que la console Python de la HP Prime ne gère pas les saisies sur plusieurs lignes. Peu de solutions Python concurrentes les supportent à ce jour, juste les TI-83 Premium CE, TI-84 Plus CE, TI-Nspire CX II et le programme Ndless micropython pour les TI-Nspire.
La calculatrice n'est pas complètement figée, les menus de bas d'écran continuent à réagir bien que ineffectifs, et la calculatrice peut encore être éteinte et rallumée.
Mais il n'empêche qu'elle n'en reste pas moins inutilisable et que seul le bouton Reset au dos te la décoincera.

Escsur une ligne de saisie vide de la console Python, c'est une des façons de coincer ta calculatrice.

Sur émulateur on remarque quelque chose que ne voit pas sur l'écran de la calculatrice ; on dirait que cela fait disparaître la ligne de saisie.

Numalors que tu es déjà dans la vue console. Sinon, mêmes résultat et conséquences.

Ici cela fait disparaître la barre de titre et la calculatrice sera systématiquement coincée à la validation de la prochaine saisie.
Évite également de taper
Plotou
Viewsi tu es dans la vue console. La vue Plot n'est pas valide dans le contexte de l'application Python et la demande sera donc refusée, mais de même ça efface la barre de titre et ta calculatrice sera coincée à la prochaine saisie.
Peut-être que le refus de basculement vers la vue Plot redirige automatiquement vers la vue Num et nous fait donc retomber sur le cas précédent.
Attention également, il semble n'y avoir aucun moyen d'interrompre un script Python qui pour une raison ou une autre prendrait trop de temps ou ne se terminerait pas.

Maintenir la touche
Onou la touche
Escest sans effet, ta seule porte de sortie sera ici encore le bouton Reset.


- tu ne peux pas remonter dans l'historique avec
↑
comme tu en as peut-être l'habitude, tu devras utiliser l'écran tactile - impossible de faire passer le curseur de texte dans l'historique
- et par conséquent impossible de reprendre une saisie précédente, un résultat ou une partie d'un affichage ; tu ne peux rien sélectionner et donc rien copier-coller


Donc ici aucun raccourci, tu dois tout saisir via les menus tactiles ou bien au clavier alphabétique.
Il serait bien pratique de traduire automatiquement afin de ne pas gêner les utilisateurs HP Prime dans leurs habitudes de saisie :
- π → pi
- √ → sqrt()
- e^() → exp()
- ln() → log()
- log10() → log(,10)
- ...

Par exemple les touches
x²et
x^ysaisissent l'opérateur
^
qui en Python n'est pas l'opérateur de puissance mais celui du ou exclusif binaire.En conséquence des résultats qui ne correspondent pas à ce que tu penses avoir saisi, et peut-être bien embêtants à corriger si il s'agit d'une fonction interne à un de tes scripts.

Maintenir les touches
Onou
Esccomme tu en as peut-être l'habitude est ici sans effet.
Attention donc à bien faire attention à ce que tes scripts et fonctions se terminent, sans quoi le bouton Reset sera ta seule et unique porte de sortie.
De gros bugs qui on espère vont maintenant enfin disparaître, mais également de gros manques au niveau de l'interface utilisateur et là c'est dommage car c'est quand même un point important, conditionnant l'adoption (ou pas) de la solution.
3) Editeur programmes hybride projets HPPPL / Python / CAS et nouveautés HPPPL
Go to top

Déjà de façon évidente nous avons désormais des numéros de lignes affichés. De façon complémentaire le nouveau menu de bas d'écran Plus permet d'aller directement au numéro de ligne de son choix.
Avais-tu tendance à te perdre dans tes lignes de code ? Ce même menu te permet également de définir jusqu'à 10 signets, c'est-à-dire des endroits de ton code où tu pourras alors aller rapidement.
Tu peux également procéder sans menu directement avec les raccourcis clavier :
On
Shiftavec un numéro de 0 à 9 pour placer un signet à la position courante. Pour te rendre ensuite instantanément au signet en question, c'est
Onavec le numéro du signet concerné.
Mais il permettait également de gérer le langage Xcas. Les blocs en langage Xcas étaient à encadrer de balises
#cas
et #end
.La langage Xcas pouvait utiliser 2 syntaxes : la syntaxe historique de Xcas ainsi qu'une syntaxe proche du Python.
Et bien voilà, en plus des 2 langages précédents, tu peux désormais inclure des blocs en Python, à délimiter ici par les balises
#python
et #end
.Oui oui, l'éditeur de programmes historique de la HP Prime gère désormais 3 langages, HPPPL, Xcas et Python. Un même éditeur pour les coder tous, quand sur nombre de solutions concurrentes tu dois te taper un éditeur différent par langage sans aucun mélange possible !
Tu peux alors appeler le bloc Python comme si c'était un script, en spécifiant son nom à une fonction PYTHON(), ainsi que ses paramètres éventuels. Le bloc Python récupère alors les valeurs des paramètres éventuels dans la liste
sys.argv
:- Code: Select all
#PYTHON name
import sys
print("Python says "+sys.argv[0])
#end
Export ppl(a)
Begin
PYTHON(name, a);
End;
Mais tu peux également écrire différemment le bloc Python en question, afin de pouvoir l'appeler comme une fonction, et te passer alors de l'appel à la fonction PYTHON() :
- Code: Select all
#PYTHON EXPORT name(param)
import sys
print("Python says "+sys.argv[0])
#end
Export ppl(a)
Begin
name(a);
End;
La langage HPPPL disposait d'une très large bibliothèque de fonctions de tracé par pixels ou coordonnées. De quoi programmer de superbes interfaces pour tes programmes de sciences ou jeux.
- pour bien positionner les autres éléments graphiques à tracer
- pour donner un fond coloré à certains affichages de texte

Elle retourne en pixels les dimensions du rectangle occupé par l'affichage de la chaîne de caractères fournie selon la taille de police spécifiée (de 1 pour la plus petite à 7 pour la plus grande, ou sinon 0 pour tout simplement la taille courante). De quoi positionner parfaitement tes affichages en un minimum de lignes !

- Code: Select all
Export demo(txt,fcol,bcol)
Begin
X:=0;
Y:=0;
FOR F FROM 1 TO 7 DO
L1:=TEXTSIZE(txt,F);
TEXTOUT_P(txt,G0,X,0,F,fcol,L1[1],bcol);
TEXTOUT_P(txt,G0,0,Y,F,fcol,L1[1],bcol);
Y:=Y+L1[2];
X:=X+L1[1];
END;
WAIT();
End;
En Python les fonctions peuvent être définies avec des valeurs par défaut pour les derniers arguments. Cela évite à l'utilisateur d'avoir à spécifier les derniers arguments lors de son appel de la fonction, pourvu que les valeurs par défaut correspondent bien à un cas fréquent.
Le langage HPPPL ne permet pour sa part pas de définir des fonctions avec des valeurs d'arguments par défaut.

Pratique pour l'utilisateur de ne plus avoir à retenir différents noms de fonction ayant le même rôle mais dans des contextes différents :
- Code: Select all
EXPORT DIST(x1,y1,x2,y2):
RETURN (x2-x1)^2+(y2-y1)^2
END;
EXPORT DIST(x1,y1,z1,x2,y2,z2):
RETURN (x2-x1)^2+(y2-y1)^2+(z2-z1)^2
END;

- Code: Select all
EXPORT POLY2(a,b,c)
BEGIN
LOCAL d,ex;
ex:="("+a+")*x^2"+"+("+b+")*x+"+c;
d:=b^2-4*a*c;
RETURN CONCAT({CAS.expr(ex)},(−b+{1,−1}*√(d))/(2*a));
END;
EXPORT POLY2(a,b)
BEGIN
RETURN POLY2(a,b,0);
END;
EXPORT POLY2(a)
BEGIN
RETURN POLY2(a,0,0);
END;

Dans tous les cas tu as une alternative avec une autre formidable nouveauté, une fonction HPPPL peut désormais être définie pour accepter un nombre variable d'argument !

Il suffit de préfixer le dernier argument de la fonction de points de suspension, et ce dernier recevra la liste de tous les arguments optionnels spécifiés au-delà des éventuels premiers arguments obligatoires.
- Code: Select all
EXPORT POLY22(...l)
BEGIN
LOCAL a,b,c,d,n,ex;
{'a','b','c'}:={1,0,0};
n:=SIZE(l);
IF n>=1 THEN
a:=l[1];
IF n>=2 THEN
b:=l[2];
IF n>=3 THEN
c:=l[3];
END;
END;
END;
ex:="("+a+")*x^2"+"+("+b+")*x+"+c;
d:=b^2-4*a*c;
RETURN CONCAT({CAS.expr(ex)},(−b+{1,−1}*√(d))/(2*a));
END;

Précisons si tu lances un programme via l'interface de l'éditeur, le cas où sa fonction principale prend un nombre variable d'arguments est bien géré.
Toujours pour plus de libertés, pour rester sur les fonctions tu n'as plus besoin dans un programme HPPPL de placer leur déclaration de fonctions avant la première ligne les appelant.
Cela autorise également de nouvelles possibilités, comme des fonctions qui s'appellent mutuellement l'une l'autre :
- Code: Select all
FUNC1(a)
BEGIN
IF a==0 THEN RETURN 1; END;
RETURN FUNC2(a-1);
END;
FUNC2(a)
BEGIN
IF a==0 THEN RETURN 1; END;
RETURN FUNC1(a-1);
END;
Tu peux maintenant déclarer et affecter des variables en tant que constantes, et même les exporter en tant que telles vers l'environnement HPPPL :
- Code: Select all
CONST C1=6;
EXPORT CONST C2=7;



- Code: Select all
EXPORT test2d()
BEGIN
PRINT("");
PRINT("Hello 2D");
PRINT2D(quote(5^2));
PRINT2D('5^2');
PRINT2D('√5');
PRINT2D('√2022/19');
END;
Tu peux également afficher des expressions en écriture naturelle à la position de ton choix sur l'écran grâce aux fonctions TEXTOUT_P() et TEXTOUT(), en précisant le nouveau drapeau "2D" :
TEXTOUT_P('√2022/19', G0, 0, 60, {"2D"});
Par contre il semble y avoir un bug avec cette version bêta, si l'on précise à TEXTOUT_P() une valeur strictement positive pour l'abscisse x, elle n'affiche plus rien...



C'est en fait l'arbre qui cache la forêt ; cela va beaucoup plus loin que ça. L'éditeur de programmes devient désormais un véritable éditeur de projets.
Nouveau menu de bas d'écran Plus qui nous révèle plein de choses. Les fichiers .hpprgm peuvent maintenant comporter plusieurs onglets dont tu définis le nom et le type à la création, et entre lesquels tu peux basculer par la suite. Les types d'onglets proposés sont :
- PPL Program pour donc du code HPPPL comportant éventuellement des blocs en langage Python ou Xcas
- Cas Program pour donc du code Xcas
- Python Program pour du code Python
- Binary asset pour des données brutes
- Jpg image pour une image JPEG
- Png image pour une image PNG

Par exemple pour charger une image Jpg/Png ainsi dans le calque G1, c'est
G1:= Resource("nom_onglet")
.
L'appel de code Python est similaire à ce qui a été vu plus haut avec la commande PYTHON(), peu importe que le code soit maintenant sur un onglet distinct.
Il t'est possible de mettre un programme en lecture seule, le protégeant ainsi contre des modifications accidentelles.
Et accessoirement, il t'est désormais possible de crypter tes programmes/projets dans ce même menu Plus, afin de rendre leur code source illisible. Attention l'opération est définitive, aussi te créera-t-elle une copie cryptée du programme courant, copie que tu pourras donc diffuser tout en conservant l'original modifiable.
4) Python : Implémentation, nombres entiers et performances - import sys
Go to top

Il est donc au menu de bas d'écran Cmds, et on peut noter que le contenu listé semble très exhaustif.


dir(sys)
.sys.platform == 'HP Prime'
sera par exemple une astuce de test bien utile pour tes scripts en ayant besoin d'identifier la plateforme sur laquelle ils tournent, notamment pour tenir compte des dimensions de l'écran ou du comportement de la console Python.Comme on pouvait s'en douter
sys.implementation
nous indique que nous sommes sur un Micropython, en précisant qu'il s'agit d'une version 1.9.4, et implémentant lui-même le Python 3.4.0 comme l'indique sys.version
.Actuellement l'ensemble des solutions concurrentes implémentent Python 3.4.0, et la plupart utilisent Micropython.
Mais peut-être n'y a-t-il pas eu le temps de creuser ce point depuis la version alpha d'octobre 2019 qui intégrait déjà cette version.
- Micropython 1.12.0 : NumWorks
- Micropython 1.11.0 : TI-Nspire CX II
- Micropython 1.9.4 : HP Prime
Casio Graph 90+E / 35+E II - TI-Python 3.1.0.58 : TI-83 Premium CE Edition Python
- Micropython 1.12.0 : NumWorks
- Micropython 1.11.0 : TI-Nspire CX II
- Micropython 1.9.4 : HP Prime
Casio Graph 90+E / 35+E II / fx-CG50 / fx-9750/9860GIII - TI-Python 3.1.0.58 : TI-83 Premium CE Edition Python / TI-84 Plus CE Python Edition
- CircuitPython 3.0.0 : TI-83 Premium CE + TI-Python
- Micropython 1.12.0 : TI-Nspire CX / CX II (Ndless + KhiCAS CX / KhiCAS CX II)
- Micropython 1.12.0 : NumWorks
- Micropython 1.12.0 : NumWorks N0110 (Omega + KhiCAS)
- Micropython 1.11.0 : TI-Nspire CX II
- Micropython 1.9.4 : HP Prime
Casio Graph 90+E / 35+E II / fx-CG50 / fx-9750/9860GIII
Casio Graph 35/75+E / 35+E II / fx-9750GII/GIII / fx-9860G/GII/GIII (appli CasioPython) - Micropython 1.4.6 : TI-Nspire (Ndless + micropython)
- TI-Python 3.1.0.58 : TI-83 Premium CE Edition Python / TI-84 Plus CE Python Edition
- CircuitPython 4.0.0 : TI-83 Premium CE + TI-Python (firmware tiers)
- CircuitPython 3.0.0 : TI-83 Premium CE + TI-Python
Pour information TI-Python est un dérivé de CircuitPython, qui est lui-même un Micropython allégé.

sys.maxsize
pour sa part indique le plus grand entier pouvant être codé nativement sur la plateforme utilisée, avec ici une organisation little endian comme l'indique sys.byteorder
. En pratique sys.maxsize
détermine la taille maximale de nombre de structures telles les listes. Les variables peuvent quand même prendre des valeurs entières absolues supérieures qui sont alors gérées logiciellement en tant qu'entiers longs.Comme la quasi totalité de la concurrence jusqu'à présent, nous avons
sys.maxsize == 2147483647
, soit sys.maxsize == 2**31 -1
, valeur habituelle pour les plateformes 32 bits, 1 bit étant réservé pour le signe.Les seules exceptions sont les TI-Nspire CX II qui pour on ne sait quelle raison ont
sys.maxsize == 32767
soit sys.maxsize == 2**15 -1
, caractéristique des plateformes 16 bits...Quant à
sys.byteorder
, ici aussi la quasi totalité de la concurrence travaille en little endian.À une exception près ici encore mais pas la même, les Casio travaillent en big endian.
Voyons donc les performances du Python dans le contexte des nombres entiers, afin de voir si les performances de la HP Prime sont à la hauteur de la réputation de son formidable matériel. Voici donc un script réalisant un test de primalité :
- Code: Select all
try:from time import monotonic
except:pass
def hastime():
try:
monotonic()
return True
except:return False
def nodivisorin(n,l):
for k in l:
if n//k*k==n:
return False
return True
def isprimep(n):
t=hastime()
s,l,k=0 or t and monotonic(),[3],7
if n==2 or n==5:return True
if int(n)!=n or n//2*2==n or n//5*5==5:
return False
if n<k:return n in l
while k*k<n:
if nodivisorin(k,l):l.append(k)
k+=2+2*((k+2)//5*5==k+2)
r=nodivisorin(n,l)
return (t and monotonic() or 1)-s,r
Malheureusement ici pas de module time, donc nous allons lancer une série de 15
isprimep(10000019)
via une boucle, chronométrer à la main et faire la moyenne.Donc en moyenne pour un appel de
isprimep(10000019)
:- la HP Prime G1 répond en seulement 0,449s, soit déjà légèrement plus vite qu'une TI-Nspire CX II !
- la HP Prime G2 répond plus vite que son ombre, en 0,171s !

- 0,171s : HP Prime G2 (32 bits : Cortex-A7/ARMv7 @528MHz Python)
- 0,449s : HP Prime G1 (32 bits : ARM9/ARMv5 @400MHz Python)
- 0,451s : TI-Nspire CX II (32 bits : ARM9/ARMv5 @396MHz)
- 0,581s : NumWorks N0110 (32 bits : Cortex-M7/ARMv7 @216MHz)
- 1,17s : NumWorks N0100 (32 bits : Cortex-M4/ARMv7 @100MHz)
- 1,58s : Casio Graph 90+E (32 bits : SH4 @117,96MHz)
- 4,39s : Casio Graph 35+E II (32 bits : SH4 @58,98MHz)
- 4,42s : HP Prime G2 (32 bits : Cortex-A7/ARMv7 @528MHz CAS)
- 9s : TI-83 Premium CE Edition Python (8 + 32 bits : eZ80 @48MHz + Cortex-M0+/ARMv6 @48MHz)
- 16,05s : HP Prime G1 (32 bits : ARM9/ARMv5 @400MHz CAS)
- 0,171s : HP Prime G2 (32 bits : Cortex-A7/ARMv7 @528MHz Python)
- 0,449s : HP Prime G1 (32 bits : ARM9/ARMv5 @400MHz Python)
- 0,451s : TI-Nspire CX II (32 bits : ARM9/ARMv5 @396MHz)
- 0,794s : TI-Nspire CX (révisions A-V) (32 bits : ARM9/ARMv5 @132MHz - Ndless + KhiCAS Micropython)
- 0,581s : NumWorks N0110 (32 bits : Cortex-M7/ARMv7 @216MHz)
- 0,715s : NumWorks N0110 (Omega + KhiCAS Micropython)
- 1,17s : NumWorks N0100 (32 bits : Cortex-M4/ARMv7 @100MHz)
- 1,18s : TI-Nspire CX CR4+ (révisions W+) (32 bits : ARM9/ARMv5 @156MHz - Ndless + KhiCAS Micropython)
- 1,58s : Casio Graph 90+E (32 bits : SH4 @117,96MHz)
- 4,39s : Casio Graph 35+E II (32 bits : SH4 @58,98MHz)
- 4,42s : HP Prime G2 (32 bits : Cortex-A7/ARMv7 @528MHz CAS)
- 9s : TI-83 Premium CE Edition Python (8 + 32 bits : eZ80 @48MHz + Cortex-M0+/ARMv6 @48MHz)
- 16,05s : HP Prime G1 (32 bits : ARM9/ARMv5 @400MHz CAS)
- 36,26s : TI-Nspire CX (révisions A-V) (32 bits : ARM9/ARMv5 @132MHz - Ndless + KhiCAS compatibilité Python)
- 42,75s : NumWorks N0110 (Omega + KhiCAS compatibilité Python)
- 53,24s : TI-Nspire CX CR4+ (révisions W+) (32 bits : ARM9/ARMv5 @156MHz - Ndless + KhiCAS compatibilité Python
- 0,171s : HP Prime G2 (32 bits : Cortex-A7/ARMv7 @528MHz Python)
- 0,449s : HP Prime G1 (32 bits : ARM9/ARMv5 @400MHz Python)
- 0,451s : TI-Nspire CX II (32 bits : ARM9/ARMv5 @396MHz)
- 0,511s : TI-Nspire CX (révisions A-V) (32 bits : ARM9/ARMv5
@132MHzoverclocké @222MHz Nover - Ndless + KhiCAS Micropython) - 0,581s : NumWorks N0110 (32 bits : Cortex-M7/ARMv7 @216MHz)
- 0,715s : NumWorks N0110 (Omega + KhiCAS Micropython)
- 0,821s : TI-Nspire CX CR4+ (révisions W+) (32 bits : ARM9/ARMv5
@156MHzoverclocké @216MHz Nover - Ndless + KhiCAS Micropython) - 1,17s : NumWorks N0100 (32 bits : Cortex-M4/ARMv7 @100MHz)
- 1,58s : Casio Graph 90+E (32 bits : SH4 @117,96MHz)
- 4,39s : Casio Graph 35+E II (32 bits : SH4 @58,98MHz)
- 4,42s : HP Prime G2 (32 bits : Cortex-A7/ARMv7 @528MHz CAS)
- 9s : TI-83 Premium CE Edition Python (8 + 32 bits : eZ80 @48MHz + Cortex-M0+/ARMv6 @48MHz)
- 16,05s : HP Prime G1 (32 bits : ARM9/ARMv5 @400MHz CAS)
- 29,20s : TI-Nspire CX (révisions A-V) (32 bits : ARM9/ARMv5
@132MHzoverclocké @222MHz Nover - Ndless + KhiCAS compatibilité Python) - 42,75s : NumWorks N0110 (Omega + KhiCAS compatibilité Python)
- 45,34s : TI-Nspire CX CR4+ (révisions W+) (32 bits : ARM9/ARMv5
@156MHzoverclocké @216MHz Nover - Ndless + KhiCAS compatibilité Python)
- 0,171s : HP Prime G2 (32 bits : Cortex-A7/ARMv7 @528MHz Python)
- 0,449s : HP Prime G1 (32 bits : ARM9/ARMv5 @400MHz Python)
- 0,451s : TI-Nspire CX II (32 bits : ARM9/ARMv5 @396MHz)
- 0,581s : NumWorks N0110 (32 bits : Cortex-M7/ARMv7 @216MHz)
- 1,17s : NumWorks N0100 (32 bits : Cortex-M4/ARMv7 @100MHz)
- 1,58s : Casio Graph 90+E / fx-CG50 (32 bits : SH4 @117,96MHz)
- 4,39s : Casio Graph 35+E II / fx-9750/9860GIII (32 bits : SH4 @58,98MHz)
- 4,42s : HP Prime G2 (32 bits : Cortex-A7/ARMv7 @528MHz CAS)
- 8,1s : TI-83 Premium CE + TI-Python (8 + 32 bits : eZ80 @48MHz + Cortex-M0+/ARMv6 @48MHz)
- 9s : TI-83 Premium CE Edition Python / TI-84 Plus CE Python Edition (8 + 32 bits : eZ80 @48MHz + Cortex-M0+/ARMv6 @48MHz)
- 16,05s : HP Prime G1 (32 bits : ARM9/ARMv5 @400MHz CAS)
- 0,171s : HP Prime G2 (32 bits : Cortex-A7/ARMv7 @528MHz Python)
- 0,307s : TI-Nspire CX II (32 bits : ARM9/ARMv5 @396MHz - Ndless + MicroPython)
- 0,323s : TI-Nspire CX II (32 bits : ARM9/ARMv5 @396MHz - Ndless + KhiCAS Micropython)
- 0,449s : HP Prime G1 (32 bits : ARM9/ARMv5 @400MHz Python)
- 0,451s : TI-Nspire CX II (32 bits : ARM9/ARMv5 @396MHz)
- 0,58s : Casio Graph 35/75+E / 35/75/95 / fx-9750/9860GII (32 bits : SH4 @29,49MHz - CasioPython)
- 0,581s : NumWorks N0110 (32 bits : Cortex-M7/ARMv7 @216MHz)
- 0,59s : Casio Graph 35+E II / fx-9750/9860GIII (32 bits : SH4 @58,98 - CasioPython)
- 0,62s : TI-Nspire CX (révisions A-V) (32 bits : ARM9/ARMv5 @132MHz - Ndless + MicroPython)
- 0,67s : TI-Nspire (32 bits : ARM9/ARMv5 @120MHz - Ndless + MicroPython)
- 0,715s : NumWorks N0110 (Omega + KhiCAS Micropython)
- 0,794s : TI-Nspire CX (révisions A-V) (32 bits : ARM9/ARMv5 @132MHz - Ndless + KhiCAS Micropython)
- 0,99s : TI-Nspire CX CR4+ (révisions W+) (32 bits : ARM9/ARMv5 @156MHz - Ndless + MicroPython)
- 1,17s : NumWorks N0100 (32 bits : Cortex-M4/ARMv7 @100MHz)
- 1,18s : TI-Nspire CX CR4+ (révisions W+) (32 bits : ARM9/ARMv5 @156MHz - Ndless + KhiCAS Micropython)
- 1,58s : Casio Graph 90+E / fx-CG50 (32 bits : SH4 @117,96MHz)
- 4,39s : Casio Graph 35+E II / fx-9750/9860GIII (32 bits : SH4 @58,98MHz)
- 4,42s : HP Prime G2 (32 bits : Cortex-A7/ARMv7 @528MHz CAS)
- 5,24s : Casio Graph 35/75/85/95 / fx-9750/9860GII / fx-9860G (32 bits : SH3 @29,49MHz - CasioPython)
- 8,1s : TI-83 Premium CE + TI-Python (8 + 32 bits : eZ80 @48MHz + Cortex-M0+/ARMv6 @48MHz)
- 9s : TI-83 Premium CE Edition Python / TI-84 Plus CE Python Edition (8 + 32 bits : eZ80 @48MHz + Cortex-M0+/ARMv6 @48MHz)
- 11,26s : TI-83 Premium CE + TI-Python (8 + 32 bits : eZ80 @48MHz + Cortex-M0+/ARMv6 @48MHz CircuitPython)
- 11,62s : TI-Nspire CX II (32 bits : ARM9/ARMv5 @396MHz - Ndless + KhiCAS compatibilité Python)
- 16,05s : HP Prime G1 (32 bits : ARM9/ARMv5 @400MHz CAS)
- 32,76s : Casio Graph 90+E / fx-CG50 (32 bits : SH4 @117,96MHz - KhiCAS)
- 36,26s : TI-Nspire CX (révisions A-V) (32 bits : ARM9/ARMv5 @132MHz - Ndless + KhiCAS compatibilité Python)
- 42,75s : NumWorks N0110 (Omega + KhiCAS compatibilité Python)
- 53,24s : TI-Nspire CX CR4+ (révisions W+) (32 bits : ARM9/ARMv5 @156MHz - Ndless + KhiCAS compatibilité Python)
- 91,71s : Casio Graph 35+E II / fx-9750/9860GIII (32 bits : SH4 @58,98MHz - KhiCAS)
- 102,04s : Casio fx-CG10/20 (32 bits : SH4 @58,98MHz - KhiCAS)
- 0,171s : HP Prime G2 (32 bits : Cortex-A7/ARMv7 @528MHz Python)
- 0,206s : TI-Nspire CX II (32 bits : ARM9/ARMv5
@396MHzoverclocké @468MHz NoverII - Ndless + MicroPython) - 0,263s : TI-Nspire CX II (32 bits : ARM9/ARMv5
@396MHzoverclocké @468MHz NoverII - Ndless + KhiCAS Micropython) - 0,382 : TI-Nspire CX II (32 bits : ARM9/ARMv5
@396MHzoverclocké @468MHz NoverII) - 0,42s : TI-Nspire CX (révisions A-V) (32 bits : ARM9/ARMv5
@132MHzoverclocké @222MHz Nover - Ndless + MicroPython) - 0,449s : HP Prime G1 (32 bits : ARM9/ARMv5 @400MHz Python)
- 0,511s : TI-Nspire CX (révisions A-V) (32 bits : ARM9/ARMv5
@132MHzoverclocké @222MHz Nover - Ndless + KhiCAS Micropython) - 0,57s : TI-Nspire (32 bits : ARM9/ARMv5 overclocké
@120MHz@150MHz Nover - Ndless + MicroPython) - 0,58s : Casio Graph 35/75+E / 35/75/95 / fx-9750/9860GII (32 bits : SH4
@29,49MHzoverclocké @267,78MHz Ftune2 - CasioPython) - 0,581s : NumWorks N0110 (32 bits : Cortex-M7/ARMv7 @216MHz)
- 0,59s : Casio Graph 35+E II / fx-9750/9860GIII (32 bits : SH4
@58,98MHzoverclocké @274,91MHz Ftune3 - CasioPython) - 0,63s : TI-Nspire CX CR4+ (révisions W+) (32 bits : ARM9/ARMv5
@156MHzoverclocké @216MHz Nover - Ndless + MicroPython) - 0,715s : NumWorks N0110 (Omega + KhiCAS Micropython)
- 0,821s : TI-Nspire CX CR4+ (révisions W+) (32 bits : ARM9/ARMv5
@156MHzoverclocké @216MHz Nover - Ndless + KhiCAS Micropython) - 0,86s : Casio Graph 35+E II / fx-9750/9860GIII (32 bits : SH4
@58,98MHzoverclocké @274,91MHz Ftune3) - 1,08s : Casio Graph 90+E / fx-CG50 (32 bits : SH4
@117,96MHzoverclocké @270,77MHz Ptune3) - 1,17s : NumWorks N0100 (32 bits : Cortex-M4/ARMv7 @100MHz)
- 1,688s : Casio Graph 35/75/85/95 / fx-9750/9860GII / fx-9860G (32 bits : SH3
@29,49MHzoverclocké @117,96MHz Ftune - CasioPython) - 4,42s : HP Prime G2 (32 bits : Cortex-A7/ARMv7 @528MHz CAS)
- 8,1s : TI-83 Premium CE + TI-Python (8 + 32 bits : eZ80 @48MHz + Cortex-M0+/ARMv6 @48MHz)
- 9s : TI-83 Premium CE Edition Python / TI-84 Plus CE Python Edition (8 + 32 bits : eZ80 @48MHz + Cortex-M0+/ARMv6 @48MHz)
- 9.964s : TI-Nspire CX II (32 bits : ARM9/ARMv5
@396MHzoverclocké @468MHz NoverII - Ndless + KhiCAS compatibilité Python) - 11,26s : TI-83 Premium CE + TI-Python (8 + 32 bits : eZ80 @48MHz + Cortex-M0+/ARMv6 @48MHz CircuitPython)
- 16,05s : HP Prime G1 (32 bits : ARM9/ARMv5 @400MHz CAS)
- 19,06s : Casio Graph 35+E II / fx-9750/9860GIII (32 bits : SH4
@58,98MHzoverclocké @274,91MHz Ftune3 - KhiCAS) - 22,77s : Casio Graph 90+E / fx-CG50 (32 bits : SH4
@117,96MHzoverclocké @270,77MHz Ptune3 - KhiCAS) - 29,20s : TI-Nspire CX (révisions A-V) (32 bits : ARM9/ARMv5
@132MHzoverclocké @222MHz Nover - Ndless + KhiCAS compatibilité Python) - 30,85s : Casio fx-CG10/20 (32 bits : SH4
@58,98MHzoverclocké @267,78MHz Ptune2 - KhiCAS) - 42,75s : NumWorks N0110 (Omega + KhiCAS compatibilité Python)
- 53,24s : TI-Nspire CX CR4+ (révisions W+) (32 bits : ARM9/ARMv5
@156MHzoverclocké @216MHz Nover - Ndless + KhiCAS compatibilité Python)
5) Python : Nombres flottants et performances - transfert de scripts
Go to topCe type de donnée représente les nombres non entiers sous la forme
- M, un nombre entier relatif dit mantisse
- Emin, nombre entier négatif indique l'exposant minimal pouvant être codé
- E, nombre entier naturel codant l'exposant

#python
et #end
dans un programme HPPPL. Mais nous allons plutôt te montrer cette fois-ci comment envoyer directement un fichier .py à l'application Python, car oui la machine les gère.Pour cela, dans le logiciel de connectivité, il faut rajouter le ou les scripts Python souhaités aux fichiers de l'application Python, via un appel au menu contextuel (clic droit) sur le dossier en question.
- Code: Select all
def precm(b):
k,b=0,float(b)
while 1+b**-k-1>0:
k+=1
return k
def prece():
a=-1
while 2.**a>0:
a*=2
while 2.**a==0:
a+=1
b=1
while str(2.**b)[0:3]!='inf':
b*=2
while str(2.**b)[0:3]=='inf':
b-=1
return [a,b]

precm(2)
nous répond que le moteur travaille en virgule flottante avec des mantisses dont la précision est codée sur 53 bits, permettant environ 16 chiffres significatifs en écriture décimale (precm(10)
), et auxquels il faut bien évidemment rajouter 1 bit de signe.L'appel
prece()
nous indique pour sa part que les valeurs codables pour les exposants dans la formule vont de -1075 à +1023.Il s'agit du standard double précision du Python (64 bits), un bon choix pour le contexte scientifique du lycée, et à ce jour toutes les calculatrices concurrentes disposant d'une véritable implémentation Python répondent la même chose.
Puisque tout-le-monde est à égalité là-dessus, voyons donc les performances du Python dans le contexte des calculs flottants sur HP Prime.
Nous utiliserons pour cela le script suivant, développé et utilisé pour le QCC 2020, petit algorithme de seuil dans le contexte d'une suite récurrente, niveau Première :
- Code: Select all
try:
from time import *
except:
pass
def hastime():
try:
monotonic()
return True
except:
return False
def seuil(d):
timed,n=hastime(),0
start,u=0 or timed and monotonic(),2.
d=d**2
while (u-1)**2>=d:
u=1+1/((1-u)*(n+1))
n=n+1
return [(timed and monotonic() or 1)-start,n,u]
Pas de module time ici, nous allons lancer une série de 15
seuil(0.008)
via une boucle, chronométrer à la main et effectuer la moyenne.Donc en moyenne pour un appel de
seuil(0.008)
:- la HP Prime G1 termine en seulement 0,258s, presque aussi vite qu'une TI-Nspire CX II !
- la HP Prime G2 répond plus vite que tu ne relâches la touche, 0,087s !

À la fois parmi les solutions Python officielles et les solutions Python compatibles avec le mode examen, la HP Prime G2 est clairement la plus puissante que ce soit en calcul entier ou en calcul flottant, et de loin, félicitations !

- 0,087s : HP Prime G2 (32 bits : Cortex-A7/ARMv7 @528MHz Python)
- 0,258s : HP Prime G1 (32 bits : ARM9/ARMv5 @400MHz Python)
- 0,297s : TI-Nspire CX II (32 bits : ARM9/ARMv5 @396MHz)
- 0,376s : HP Prime G2 (32 bits : Cortex-A7/ARMv7 @528MHz CAS)
- 0,498s : NumWorks N0110 (32 bits : Cortex-M7/ARMv7 @216MHz)
- 0,785s : NumWorks N0100 (32 bits : Cortex-M4/ARMv7 @100MHz)
- 1,61s : HP Prime G1 (32 bits : ARM9/ARMv5 @400MHz CAS)
- 3,27s : Casio Graph 90+E (32 bits : SH4 @117,96MHz)
- 3,93s : TI-83 Premium CE Edition Python (8 + 32 bits : eZ80 @48MHz + Cortex-M0+/ARMv6 @48MHz)
- 9,21s : Casio Graph 35+E II (32 bits : SH4 @58,98MHz)
- 0,087s : HP Prime G2 (32 bits : Cortex-A7/ARMv7 @528MHz Python)
- 0,258s : HP Prime G1 (32 bits : ARM9/ARMv5 @400MHz Python)
- 0,297s : TI-Nspire CX II (32 bits : ARM9/ARMv5 @396MHz)
- 0,376s : HP Prime G2 (32 bits : Cortex-A7/ARMv7 @528MHz CAS)
- 0,609s : TI-Nspire CX (révisions A-V) (32 bits : ARM9/ARMv5 @132MHz - Ndless + KhiCAS Micropython)
- 0,498s : NumWorks N0110 (32 bits : Cortex-M7/ARMv7 @216MHz)
- 0,544s : NumWorks N0110 (Omega + KhiCAS Micropython)
- 0,785s : NumWorks N0100 (32 bits : Cortex-M4/ARMv7 @100MHz)
- 0,868s : TI-Nspire CX CR4+ (révisions W+) (32 bits : ARM9/ARMv5 @156MHz - Ndless + KhiCAS Micropython)
- 1,61s : HP Prime G1 (32 bits : ARM9/ARMv5 @400MHz CAS)
- 3,27s : Casio Graph 90+E (32 bits : SH4 @117,96MHz)
- 3,93s : TI-83 Premium CE Edition Python (8 + 32 bits : eZ80 @48MHz + Cortex-M0+/ARMv6 @48MHz)
- 5,45s : TI-Nspire CX (révisions A-V) (32 bits : ARM9/ARMv5 @132MHz - Ndless + KhiCAS compatibilité Python)
- 6,69s : NumWorks N0110 (Omega + KhiCAS compatibilité Python)
- 7,63s : TI-Nspire CX CR4+ (révisions W+) (32 bits : ARM9/ARMv5 @156MHz - Ndless + KhiCAS compatibilité Python
- 9,21s : Casio Graph 35+E II (32 bits : SH4 @58,98MHz)
- 0,087s : HP Prime G2 (32 bits : Cortex-A7/ARMv7 @528MHz Python)
- 0,258s : HP Prime G1 (32 bits : ARM9/ARMv5 @400MHz Python)
- 0,297s : TI-Nspire CX II (32 bits : ARM9/ARMv5 @396MHz)
- 0,376s : HP Prime G2 (32 bits : Cortex-A7/ARMv7 @528MHz CAS)
- 0,396s : TI-Nspire CX (révisions A-V) (32 bits : ARM9/ARMv5
@132MHzoverclocké @222MHz Nover - Ndless + KhiCAS Micropython) - 0,498s : NumWorks N0110 (32 bits : Cortex-M7/ARMv7 @216MHz)
- 0,544s : NumWorks N0110 (Omega + KhiCAS Micropython)
- 0,65s : TI-Nspire CX CR4+ (révisions W+) (32 bits : ARM9/ARMv5
@156MHzoverclocké @216MHz Nover - Ndless + KhiCAS Micropython) - 0,785s : NumWorks N0100 (32 bits : Cortex-M4/ARMv7 @100MHz)
- 1,61s : HP Prime G1 (32 bits : ARM9/ARMv5 @400MHz CAS)
- 3,27s : Casio Graph 90+E (32 bits : SH4 @117,96MHz)
- 3,93s : TI-83 Premium CE Edition Python (8 + 32 bits : eZ80 @48MHz + Cortex-M0+/ARMv6 @48MHz)
- 4,13s : TI-Nspire CX (révisions A-V) (32 bits : ARM9/ARMv5
@132MHzoverclocké @222MHz Nover - Ndless + KhiCAS compatibilité Python) - 6,69s : NumWorks N0110 (Omega + KhiCAS compatibilité Python)
- 7,19s : TI-Nspire CX CR4+ (révisions W+) (32 bits : ARM9/ARMv5
@156MHzoverclocké @216MHz Nover - Ndless + KhiCAS compatibilité Python) - 9,21s : Casio Graph 35+E II (32 bits : SH4 @58,98MHz)
- 0,087s : HP Prime G2 (32 bits : Cortex-A7/ARMv7 @528MHz Python)
- 0,258s : HP Prime G1 (32 bits : ARM9/ARMv5 @400MHz Python)
- 0,297s : TI-Nspire CX II (32 bits : ARM9/ARMv5 @396MHz)
- 0,376s : HP Prime G2 (32 bits : Cortex-A7/ARMv7 @528MHz CAS)
- 0,498s : NumWorks N0110 (32 bits : Cortex-M7/ARMv7 @216MHz)
- 0,785s : NumWorks N0100 (32 bits : Cortex-M4/ARMv7 @100MHz)
- 1,61s : HP Prime G1 (32 bits : ARM9/ARMv5 @400MHz CAS)
- 3,27s : Casio Graph 90+E / fx-CG50 (32 bits : SH4 @117,96MHz)
- 3,73s : TI-83 Premium CE + TI-Python (8 + 32 bits : eZ80 @48MHz + Cortex-M0+/ARMv6 @48MHz)
- 3,93s : TI-83 Premium CE Edition Python / TI-84 Plus CE Python Edition (8 + 32 bits : eZ80 @48MHz + Cortex-M0+/ARMv6 @48MHz)
- 9,21s : Casio Graph 35+E II / fx-9750/9860GIII (32 bits : SH4 @58,98MHz)
- 0,025s : TI-Nspire CX II (32 bits : ARM9/ARMv5 @396MHz - Ndless + KhiCAS Micropython)
- 0,087s : HP Prime G2 (32 bits : Cortex-A7/ARMv7 @528MHz Python)
- 0,232s : TI-Nspire CX II (32 bits : ARM9/ARMv5 @396MHz - Ndless + MicroPython)
- 0,258s : HP Prime G1 (32 bits : ARM9/ARMv5 @400MHz Python)
- 0,297s : TI-Nspire CX II (32 bits : ARM9/ARMv5 @396MHz)
- 0,376s : HP Prime G2 (32 bits : Cortex-A7/ARMv7 @528MHz CAS)
- 0,47s : TI-Nspire (32 bits : ARM9/ARMv5 @120MHz - Ndless + MicroPython)
- 0,48s : TI-Nspire CX (révisions A-V) (32 bits : ARM9/ARMv5 @132MHz - Ndless + MicroPython)
- 0,498s : NumWorks N0110 (32 bits : Cortex-M7/ARMv7 @216MHz)
- 0,544s : NumWorks N0110 (Omega + KhiCAS Micropython)
- 0,609s : TI-Nspire CX (révisions A-V) (32 bits : ARM9/ARMv5 @132MHz - Ndless + KhiCAS Micropython)
- 0,68s : TI-Nspire CX CR4+ (révisions W+) (32 bits : ARM9/ARMv5 @156MHz - Ndless + MicroPython)
- 0,785s : NumWorks N0100 (32 bits : Cortex-M4/ARMv7 @100MHz)
- 0,868s : TI-Nspire CX CR4+ (révisions W+) (32 bits : ARM9/ARMv5 @156MHz - Ndless + KhiCAS Micropython)
- 1,61s : HP Prime G1 (32 bits : ARM9/ARMv5 @400MHz CAS)
- 1,909s : TI-Nspire CX II (32 bits : ARM9/ARMv5 @396MHz - Ndless + KhiCAS compatibilité Python)
- 3,27s : Casio Graph 90+E / fx-CG50 (32 bits : SH4 @117,96MHz)
- 3,73s : TI-83 Premium CE + TI-Python (8 + 32 bits : eZ80 @48MHz + Cortex-M0+/ARMv6 @48MHz)
- 3,9s : Casio Graph 35+E II / fx-9750/9860GIII (32 bits : SH4 @58,98 - CasioPython)
- 3,93s : TI-83 Premium CE Edition Python / TI-84 Plus CE Python Edition (8 + 32 bits : eZ80 @48MHz + Cortex-M0+/ARMv6 @48MHz)
- 4s : Casio Graph 35/75+E / 35/75/95 / fx-9750/9860GII (32 bits : SH4 @29,49MHz - CasioPython)
- 4,4s : TI-83 Premium CE + TI-Python (8 + 32 bits : eZ80 @48MHz + Cortex-M0+/ARMv6 @48MHz CircuitPython)
- 5,29s : Casio Graph 35/75/85/95 / fx-9750/9860GII / fx-9860G (32 bits : SH3 @29,49MHz - CasioPython)
- 5,45s : TI-Nspire CX (révisions A-V) (32 bits : ARM9/ARMv5 @132MHz - Ndless + KhiCAS compatibilité Python)
- 5,48s : Casio Graph 90+E / fx-CG50 (32 bits : SH4 @117,96MHz - KhiCAS)
- 6,69s : NumWorks N0110 (Omega + KhiCAS compatibilité Python)
- 9,21s : Casio Graph 35+E II / fx-9750/9860GIII (32 bits : SH4 @58,98MHz)
- 13,93s : Casio Graph 35+E II / fx-9750/9860GIII (32 bits : SH4 @58,98MHz - KhiCAS)
- 15,05s : Casio fx-CG10/20 (32 bits : SH4 @58,98MHz - KhiCAS)
- 7,63s : TI-Nspire CX CR4+ (révisions W+) (32 bits : ARM9/ARMv5 @156MHz - Ndless + KhiCAS compatibilité Python)
- 0,022s : TI-Nspire CX II (32 bits : ARM9/ARMv5
@396MHzoverclocké @468MHz NoverII - Ndless + KhiCAS Micropython) - 0,087s : HP Prime G2 (32 bits : Cortex-A7/ARMv7 @528MHz Python)
- 0,142s : TI-Nspire CX II (32 bits : ARM9/ARMv5
@396MHzoverclocké @468MHz NoverII - Ndless + MicroPython) - 0,257s : TI-Nspire CX II (32 bits : ARM9/ARMv5
@396MHzoverclocké @468MHz NoverII) - 0,258s : HP Prime G1 (32 bits : ARM9/ARMv5 @400MHz Python)
- 0,27s : TI-Nspire CX (révisions A-V) (32 bits : ARM9/ARMv5
@132MHzoverclocké @222MHz Nover - Ndless + MicroPython) - 0,376s : HP Prime G2 (32 bits : Cortex-A7/ARMv7 @528MHz CAS)
- 0,38s : TI-Nspire (32 bits : ARM9/ARMv5 overclocké
@120MHz@150MHz Nover - Ndless + MicroPython) - 0,396s : TI-Nspire CX (révisions A-V) (32 bits : ARM9/ARMv5
@132MHzoverclocké @222MHz Nover - Ndless + KhiCAS Micropython) - 0,498s : NumWorks N0110 (32 bits : Cortex-M7/ARMv7 @216MHz)
- 0,53s : TI-Nspire CX CR4+ (révisions W+) (32 bits : ARM9/ARMv5
@156MHzoverclocké @216MHz Nover - Ndless + MicroPython) - 0,544s : NumWorks N0110 (Omega + KhiCAS Micropython)
- 0,59s : Casio Graph 35/75+E / 35/75/95 / fx-9750/9860GII (32 bits : SH4
@29,49MHzoverclocké @267,78MHz Ftune2 - CasioPython) - 0,65s : TI-Nspire CX CR4+ (révisions W+) (32 bits : ARM9/ARMv5
@156MHzoverclocké @216MHz Nover - Ndless + KhiCAS Micropython) - 0,785s : NumWorks N0100 (32 bits : Cortex-M4/ARMv7 @100MHz)
- 0,79s : Casio Graph 35+E II / fx-9750/9860GIII (32 bits : SH4
@58,98MHzoverclocké @274,91MHz Ftune3 - CasioPython) - 1,589s : TI-Nspire CX II (32 bits : ARM9/ARMv5
@396MHzoverclocké @468MHz NoverII - Ndless + KhiCAS compatibilité Python) - 1,61s : HP Prime G1 (32 bits : ARM9/ARMv5 @400MHz CAS)
- 1,86s : Casio Graph 35+E II / fx-9750/9860GIII (32 bits : SH4
@58,98MHzoverclocké @274,91MHz Ftune3) - 1,876s : Casio Graph 35/75/85/95 / fx-9750/9860GII / fx-9860G (32 bits : SH3
@29,49MHzoverclocké @117,96MHz Ftune - CasioPython) - 2,15s : Casio Graph 90+E / fx-CG50 (32 bits : SH4
@117,96MHzoverclocké @270,77MHz Ptune3) - 2,96s : Casio Graph 35+E II / fx-9750/9860GIII (32 bits : SH4
@58,98MHzoverclocké @274,91MHz Ftune3 - KhiCAS) - 3,65s : Casio Graph 90+E / fx-CG50 (32 bits : SH4
@117,96MHzoverclocké @270,77MHz Ptune3 - KhiCAS) - 3,718s : Casio fx-CG10/20 (32 bits : SH4
@58,98MHzoverclocké @267,78MHz Ptune2 - KhiCAS) - 3,73s : TI-83 Premium CE + TI-Python (8 + 32 bits : eZ80 @48MHz + Cortex-M0+/ARMv6 @48MHz)
- 3,93s : TI-83 Premium CE Edition Python / TI-84 Plus CE Python Edition (8 + 32 bits : eZ80 @48MHz + Cortex-M0+/ARMv6 @48MHz)
- 4,13s : TI-Nspire CX (révisions A-V) (32 bits : ARM9/ARMv5
@132MHzoverclocké @222MHz Nover - Ndless + KhiCAS compatibilité Python) - 4,4s : TI-83 Premium CE + TI-Python (8 + 32 bits : eZ80 @48MHz + Cortex-M0+/ARMv6 @48MHz CircuitPython)
- 6,69s : NumWorks N0110 (Omega + KhiCAS compatibilité Python)
- 7,19s : TI-Nspire CX CR4+ (révisions W+) (32 bits : ARM9/ARMv5
@156MHzoverclocké @216MHz Nover - Ndless + KhiCAS compatibilité Python)
6) Python : Mémoire tas/heap - import gc
Go to top
Nous avons justement la chance ici de disposer du module gc (garbage collector - ramasse miettes), avec plusieurs fonctions bien utiles :
gc.collect()
pour nettoyer le heap en supprimant les valeurs d'objets Python qui ne sont plus référencéesgc.mem_alloc()
pour connaître la consommation du heap en octetsgc.mem_free()
pour connaître l'espace heap disponible en octets

- Code: Select all
import gc
a, f = gc.mem_alloc(), gc.mem_free()
(a, f, a + f)
Nous disposons donc ici d'un heap d'une capacité impressionnante, parmi les plus grands actuellement, 1,025 Mo aussi bien sur HP Prime G1 que HP Prime G2, de quoi a priori te lancer dans des projets Python très ambitieux !

Plus précisément nous avons ici 1,022 Mo de libres, mais auxquels il faut ajouter la taille consommée par l'importation du module gc.
Toutefois, toutes les calculatrices Python ne disposent pas du module gc. Afin de pouvoir faire des comparaisons équitables, nous allons construire notre propre script de test d'estimation de la capacité heap à partir des informations suivantes sur les tailles des objets Python, du moins sur les plateformes 32 bits que sont à ce jour nos calculatrices :
- pour un entier nul : 24 octets déjà...
- pour un entier court non nul (codable sur 31 bits + 1 bit de signe) : 28 octets
- pour un entier long :
- 28 octets
- + 4 octets pour chaque groupe de 30 bits utilisé par son écriture binaire au-delà des 31 bits précédents
- pour une chaîne :
- 49 octets
- + 1 octet par caractère
- pour une liste :
- 64 octets
- + 8 octets par élément
- + les tailles de chaque élément
Nous récupérerons de plus la plus grand taille d'objet que nous avons réussi à utiliser lors de ce test, on t'explique de suite.


- Code: Select all
def size(o):
t = type(o)
s = t == str and 49 + len(o)
if t == int:
s = 24
while o:
s += 4
o >>= 30
elif t == list:
s = 64 + 8*len(o)
for so in o:
s += size(so)
return s
def mem(v=1):
try:
l=[]
try:
l.append(0)
l.append(0)
l.append("")
l[2] += "x"
l.append(0)
l.append(0)
while 1:
try:
l[2] += l[2][l[1]:]
except:
if l[1] < len(l[2]) - 1:
l[1] = len(l[2]) - 1
else:
raise(Exception)
except:
if v:
print("+", size(l))
try:
l[0] += size(l)
except:
pass
try:
l[3], l[4] = mem(v)
except:
pass
return l[0] + l[3], max(l[0], l[4])
except:
return 0, 0
def testmem():
m1, m2 = 0, 0
while 1:
t1, t2 = mem(0)
if t1 > m1 or t2 > m2:
m1 = max(t1, m1)
m2 = max(t2, m2)
input(str((m1,m2)))
On trouve bien sur HP Prime une capacité heap de 1,025 Mo proche de la mesure précédente, à laquelle bien sûr il faut rajouter la consommation du script que nous estimons à 1,056 Ko.
Nous avons ici en prime une autre valeur de 393,486 Ko, correspondant à la taille du plus gros objet qui a pu être créé au cours du test et donc au plus grand espace libre disponible de façon contiguë dans le heap.
Autant sur HP Prime G1 avec seulement 32 Mio de SDRAM sollicités par bien d'autres choses, on pouvait comprendre de se modérer sur le heap Python...
Mais la HP Prime G2 dispose d'une capacité SDRAM de 256 Mio écrasant littéralement toute concurrence. Nous attendions ici bien mieux que cela, de quoi se lancer dans des projets Python ambitieux...
Mais ne nous avouons pas encore vaincus.
Certes l'application Python ne se lance donc qu'avec 1,025 Mo de heap, mais nous avons vu plus haut qu'il était possible d'exécuter des scripts et fonctions Python depuis l'éditeur de programmes historique grâce à la fonction PYTHON().
Or, il se trouve que cette fonction permet de spécifier la capacité heap à allouer :
PYTHON({nom_python,taille_heap},...)
.Réalisons de quoi saisir et tester des capacités :
- Code: Select all
#python heaptest_python
from gc import mem_alloc,mem_free
a,f=mem_alloc(),mem_free()
print("allocated heap: "+str(f+a))
print("free heap: "+str(f))
#end
Export heaptest_ppl(v)
Begin
PRINT("allocating heap: "+v);
PRINT("");
PYTHON({heaptest_python,v});
End;


Shift
🧰donne une indication.
La HP Prime G1 dispose de 32 Mio de SDRAM, et en gros sur une calculatrice vide ne contenant que le script de test on peut spécifier jusqu'à un peu plus de 16 Mo, au-delà le bloc Python n'est tout simplement pas exécuté. Histoire d'avoir une marge de sécurité puisque cette mémoire libre sera variable, retenons 16 Mo pour la suite.
En pratique la capacité heap reportée par le module gc est légèrement inférieure, dans les 15,6 Mo.


En pratique la capacité heap reportée ici par le module gc est d'environ 252,1 Mo.

- 252,1 Mo : HP Prime G2
- 15,6 Mo : HP Prime G1
- 2,068 Mo : TI-Nspire CX II
- 1,033 Mo : Casio Graph 90+E
- 101,262 Ko : Casio Graph 35+E II
- 33,545 Ko : NumWorks
- 18,354 Ko : TI-83 Premium CE Edition Python
- 252,1 Mo : HP Prime G2
- 15,6 Mo : HP Prime G1
- 2,068 Mo : TI-Nspire CX II
- 1,033 Mo : Casio Graph 90+E / fx-CG50
- 101,262 Ko : Casio Graph 35+E II / fx-9750/9860GIII
- 33,545 Ko : NumWorks
- 20,839 Ko : TI-83 Premium CE + TI-Python
- 18,354 Ko : TI-83 Premium CE Edition Python / TI-84 Plus CE Python Edition
- 252,1 Mo : HP Prime G2
- 15,6 Mo : HP Prime G1
- 4,100 Mo : TI-Nspire CX / CX II (Ndless + KhiCAS CX / KhiCAS CX II)
- 2,068 Mo : TI-Nspire CX II
- 2,050 Mo : TI-Nspire (Ndless + MicroPython)
- 1,033 Mo : Casio Graph 90+E / fx-CG50
- 258,766 Ko : Casio Graph 35/75+E / 35/75/95 / fx-9750/9860GII (SH4 - appli CasioPython)
- 101,262 Ko : Casio Graph 35+E II / fx-9750/9860GIII
- 64,954 Ko : NumWorks (firmware Omega + appli KhiCAS)
- 33,545 Ko : NumWorks
- 32,648 Ko : Casio Graph 35+E II / 35/75/85/95(SH3) / fx-9750/9860GIII / fx-9750/9860GII(SH3) / fx-9860G (appli CasioPython)
- 23,685 Ko : TI-83 Premium CE + TI-Python (firmware tiers)
- 20,839 Ko : TI-83 Premium CE + TI-Python
- 18,354 Ko : TI-83 Premium CE Edition Python / TI-84 Plus CE Python Edition
7) Python : Mémoire pile/stack
Go to topTentons donc de déclencher une consommation massive de stack, afin de pouvoir comparer et voir comment s'en sortent la HP Prime et les autres. Une situation très simple qui peut être grand consommatrice de stack c'est la récursivité, soit les fonctions qui se rappellent elles-mêmes. Prenons le script suivant, issu du QCC 2020 :


- Code: Select all
def compte_r(n):
return n>0 and 1 + compte_r(n-1)
def test(f):
n = 0
try:
while 1:
n = f(n) + 1
except Exception as e:
print(e)
return n
Nous atteignons donc sur HP Prime G1 un maximum de 77 niveaux de récursion avant erreur, et même 99 niveaux sur HP Prime G2.
Mais nous avons vu plus haut qu'il était possible d'appeler un script ou une fonction Python depuis l'environnement HPPPL grâce à la fonction PYTHON(), et que cette dernière permettait de préciser la taille du heap alloué à cet appel. De façon similaire, elle permet également de préciser la taille du stack à utiliser :
PYTHON({nom_python,taille_heap,taille_stack},...)
.Réalisons ici encore de quoi saisir et tester des capacités :
- Code: Select all
#python stacktest_python
def compte_r(n):
return n>0 and 1 + compte_r(n-1)
def test(f):
n = 0
try:
while 1:
n = f(n) + 1
except Exception as e:
print(e)
return n
print(test(compte_r))
#end
Export stacktest_ppl(v)
Begin
PRINT("allocating stack: "+v);
PRINT("");
PYTHON({stacktest_python,#100000h,v});
End;

On peut atteindre 82 niveaux de récursion en passant à 43K de stack.
Mais c'est tout, augmenter davantage le stack ne change plus rien et effectivement on note un changement au niveau de l'exception reportée : on passe d'un "maximum recursion depth exceeded" à un "pystack exhausted".
Ce n'est donc plus le même facteur limitant qui nous bloque, c'est maintenant autre chose qui interrompt la descente récursive.

Mais le changement d'exception se produit alors immédiatement ; on ne peut pas aller au-delà.
D'où le classement des solutions Python niveau stack :
- 202 : TI-Nspire CX II
- 129 : NumWorks
- 99 : HP Prime G2
- 82 : Casio Graph 90+E / 35+E II
- 82 : HP Prime G1
- 28 : TI-83 Premium CE Edition Python
- 202 : TI-Nspire CX II
- 129 : NumWorks
- 99 : HP Prime G2
- 82 : Casio Graph 90+E / 35+E II / fx-CG50 / fx-9750/9860GIII
- 82 : HP Prime G1
- 28 : TI-83 Premium CE Edition Python / TI-84 Plus CE Python Edition
- 20 : TI-83 Premium CE + TI-Python
- 5362 : Casio Graph 35/75+E / 35/75/95 / fx-9750/9860GII (SH4 - appli CasioPython)
- 655 : Casio Graph 35+E II / 35/75/85/95(SH3) / fx-9750/9860GIII / fx-9750/9860GII(SH3) / fx-9860G (appli CasioPython)
- 202 : TI-Nspire CX II
- 155 : TI-Nspire CX / CX II (Ndless + KhiCAS CX / KhiCAS CX II)
- 130 : TI-Nspire (Ndless + MicroPython)
- 129 : NumWorks
- 126 : NumWorks (firmware Omega + appli KhiCAS)
- 99 : HP Prime G2
- 82 : Casio Graph 90+E / 35+E II / fx-CG50 / fx-9750/9860GIII
- 82 : HP Prime G1
- 28 : TI-83 Premium CE Edition Python / TI-84 Plus CE Python Edition
- 20 : TI-83 Premium CE + TI-Python
- 15 : TI-83 Premium CE + TI-Python
8) Python : Modules intégrés standard et propriétaires
Go to top

- builtins
- array
- cmath
- gc
- math
- micropython
- sys
- ucollections
- uerrno
- uhashlib
- uio
- urandom
- ure
- ustruct
- utimeq

help("modules")
; mais non c'est bon, tout semble bien être au menu.Donc pas moins de 15 modules standard intégrés, comparons un peu aux solutions concurrentes :
TI 83PCE + Python | TI 83PCE Python | TI 84+CE Python | TI Nspire CX II | Casio Graph 90+E 35+EII | Num Works | HP Prime | |||||||
builtins array (u)binascii board cmath (u)collections (u)ctypes (u)errno gc (u)hashlib (u)heapq (u)io (u)json linalg math matplotlib .pyplot micropython numpy os (u)random (u)re storage (u)struct sys time (u)timeq turtle (u)zlib TOTAL | ✓ ✓ . . . ✓ . . ✓ . . . . . ✓ . . . . . ✓ . . . ✓ ✓ . . . 8 | ✓ ✓ . . . ✓ . . ✓ . . . . . ✓ . + . . . ✓ . . . ✓ ✓ . + . 8+2 | ✓ ✓ . . . ✓ . . ✓ . . . . . ✓ . + . . . ✓ . . . ✓ ✓ . + . 10 | ✓ ✓ ✓ . ✓ ✓ ✓ ✓ ✓ ✓ ✓ . . . ✓ . + ✓ . . ✓ ✓ . . ✓ ✓ . . . 16+1 | ✓ . . . . . . . . . . . . . ✓ ✓ ✓ . . . ✓ . . . . . . ✓ . 6 | ✓ . . . ✓ . . . . . . . . . ✓ ✓ ✓ ✓ . . ✓ . . . . ✓ . ✓ . 9 | ✓ ✓ . . ✓ ✓ . ✓ ✓ ✓ . ✓ . . ✓ . . ✓ . . ✓ ✓ . ✓ ✓ . ✓ . . 15 | ✓ ✓ . ✓ ✓ ✓ . . ✓ . . . . . ✓ . . ✓ . ✓ ✓ . ✓ . ✓ ✓ . . . 13 | ✓ ✓ . . ✓ . . . ✓ . . . . . ✓ . . ✓ . . . . . . ✓ . . . . 7 | ✓ . ✓ . ✓ ✓ ✓ ✓ ✓ ✓ ✓ ✓ ✓ ✓ ✓ . ✓ ✓ ✓ ✓ ✓ ✓ . ✓ ✓ . . ✓ ✓ 23 | ✓ ✓ . . ✓ . . . ✓ . . . . . ✓ . . ✓ . . ✓ . . . ✓ . . . . 8 | ✓ . . . ✓ . . . . . . . . . ✓ ✓ ✓ ✓ . ✓ ✓ . . . . ✓ . ✓ . 10 | ✓ . ✓ . ✓ ✓ ✓ . ✓ ✓ ✓ ✓ ✓ ✓ ✓ . ✓ ✓ ✓ ✓ ✓ ✓ . ✓ ✓ . ✓ ✓ ✓ 23 |
Légende :
- ✓ module intégré + disponible en mode examen
- ✓ module intégré + interdit en mode examen
- + module propriétaire équivalent + disponible en mode examen
- + module propriétaire équivalent + interdit en mode examen
- . module absent et sans équivalent

- 16 modules : TI-Nspire CX II
- 15 modules : HP Prime
- 9 modules : NumWorks
- 8 modules : TI-83 Premium CE Edition Python
- 6 modules : Casio Graph 90+E / 35+E II
- 17 modules : TI-Nspire CX II
- 15 modules : HP Prime
- 10 modules : TI-83 Premium CE Edition Python / TI-84 Plus CE Python Edition
- 9 modules : NumWorks
- 8 modules : TI-83 Premium CE + TI-Python
- 6 modules : Casio Graph 90+E / 35+E II / fx-CG50 / fx-9750/9860GIII
- 23 modules : TI-Nspire CX / CX II (Ndless + KhiCAS CX / KhiCAS CX II)
NumWorks N0110 (Omega + KhiCAS) - 17 modules : TI-Nspire CX II
- 15 modules : HP Prime
- 13 modules : TI-83 Premium CE + TI-Python (firmware tiers)
- 10 modules : NumWorks (Omega)
TI-83 Premium CE Edition Python / TI-84 Plus CE Python Edition - 9 modules : NumWorks
- 8 modules : Casio Graph 35/75+E / 35+E II / fx-9750GII/GIII / fx-9860G/GII/GIII (appli CasioPython)
TI-83 Premium CE + TI-Python - 7 modules : TI-Nspire (Ndless + micropython)
- 6 modules : Casio Graph 90+E / 35+E II / fx-CG50 / fx-9750/9860GIII
À ces modules standards ou équivalents s'ajoutent usuellement des modules propriétaires destinés à traiter des spécificités matérielles ou logicielles de la calculatrice (détection des touches clavier, de la zone pointée, allumage de pixels sur l'écran, importation/exportation de données, connectivité, ...)
C'est ici le rôle du module unique hpprime que nous allons découvrir maintenant.
9) Python : Appels HPPPL - import hpprime
Go to top

Un
dir(hpprime)
ne révèle rien de plus. Donc pas de cachotteries ici, tout semble bien être montré au menu et c'est déjà pas mal du tout, si bien que nous allons traiter du module hpprime en plusieurs parties.Nous avons donc vu plus haut qu'il était possible d'appeler du Python dans le contexte HPPPL.

C'est l'occasion de profiter du formidable catalogue de fonctions de la HP Prime notamment lorsqu'elles n'ont ici pas d'équivalent intégré en Python, pour effectuer des calculs et mêmes des affectations de variables de l'environnement HPPPL :
hpprime.eval("NORMALD_CDF(2)")
Mais encore mieux que ça, tu peux également évaluer des expressions dans le contexte CAS en imbriquant un appel à la fonction HPPPL CAS.eval(), de quoi bénéficier du moteur de calcul formel CAS en Python :

hpprime.eval('CAS.eval("int(ln(x),x)")')
Pour te donner une idée du formidable niveau d'intégration, on peut comparer à la concurrence sur les critères suivants :
- Python appelable en dehors de son environnement
- Python peut lire/écrire des variables hors de son environnement
- Python peut lire/écrire toute variable hors de son environnement
- Python peut évaluer des expressions hors de son environnement
- Python peut évaluer toute expression hors de son environnement
TI 83PCE + Python | TI 83PCE Python | TI 84+CE Python | TI Nspire CX II | Casio Graph 90+E 35+EII | Num Works | HP Prime | |||||||
1 2 3 4 5 TOTAL | . . . . . 0 | . ✓ . . . 1 | . ✓ . . . 1 | . ✓ ✓ ✓ . 3 | . . . . . 0 | . . . . . 0 | ✓ ✓ ✓ ✓ ✓ 5 | . . . . . 0 | . . . . . 0 | . ✓ ✓ ✓ ✓ 4 | . . . . . 0 | . . . . . 0 | . ✓ ✓ ✓ ✓ 4 |
Sur HP Prime l'intégration du Python a été poussée à un niveau formidable, et de plus de façon bidirectionnelle !

Enfin de quoi faire du Python sur la calculatrice non plus pour faire du Python, mais pour résoudre des problèmes de Mathématiques et de Sciences en interaction avec les autres applications de la calculatrice, bravo !

- 5 points : HP Prime
- 3 points : TI-Nspire CX II
- 1 point : TI-83 Premium CE Edition Python
- 0 point : NumWorks
Casio Graph 90+E / 35+E II
- 5 points : HP Prime
- 3 points : TI-Nspire CX II
- 1 point : TI-83 Premium CE Edition Python / TI-84 Plus CE Python Edition
- 0 point : NumWorks
TI-83 Premium CE + TI-Python
Casio Graph 90+E / 35+E II / fx-CG50 / fx-9750/9860GIII
- 5 points : HP Prime
- 4 points : NumWorks N0110 (Omega + KhiCAS)
TI-Nspire CX / CX II (Ndless + KhiCAS CX / KhiCAS CX II) - 3 points : TI-Nspire CX II
- 1 point : TI-83 Premium CE Edition Python / TI-84 Plus CE Python Edition
- 0 point : NumWorks
TI-Nspire (Ndless + micropython)
Casio Graph 90+E / 35+E II / fx-CG50 / fx-9750/9860GIII
TI-83 Premium CE + TI-Python
Casio Graph 35/75+E / 35+E II / fx-9750GII/GIII / fx-9860G/GII/GIII (appli CasioPython)
10) Python : Clavier et tactile - import hpprime
Go to top

La fonction dédiée
hpprime.keyboard()
cumule vraiment tous les avantages par rapport aux solutions concurrentes :- elle est non bloquante, heureusement
- elle ne te renvoie pas une touche mais l'état global du clavier, c'est-à-dire que tu peux tester en un seul appel des appuis simultanés sur plusieurs touches
- elle permet même de tester les touches
Shift
,ALPHA
etOn
Varsil faudrait faire
hpprime.keyboard() & (1 << 15)
(après correction du mauvais opérateur &&
) car ce serait la 15ème touche clavier en partant du coin en haut à gauche.Nous ne savons pas si c'est l'aide ou l'interpréteur Python qui a tort, mais en pratique cela ne marche pas du tout. Il faut en réalité faire
hpprime.keyboard() & (1 << 54)
pour tester cette même touche.En effet sur cette version bêta les touches en Python ne sont absolument pas numérotées de gauche à droite et de haut en bas. Nous les avons toutes testées une par une, voici une carte corrigée du clavier pour t'aider :
Apps 56 | Symb 57 | ↑ 58 | Help 59 | Esc 60 | |
Plot 62 | ← 63 | → 48 | View 49 | ||
⌂ 61 | Num 51 | ↓ 52 | Menu 53 | CAS 50 | |
Vars 54 | 🧰 55 | □/□ 40 | xtθn 41 | ab/c 42 | ⌫ 43 |
x^y 44 | SIN 45 | COS 46 | TAN 47 | LN 32 | LOG 33 |
x² 34 | +/- 35 | () 36 | , 37 | Enter 38 | |
EEX 39 | 7 24 | 8 25 | 9 26 | ÷ 27 | |
ALPHA 28 | 4 29 | 5 30 | 6 31 | × 16 | |
Shift 17 | 1 18 | 2 19 | 3 20 | - 21 | |
On 22 | 0 23 | . 8 | _ 9 | + 10 |
À tester donc avec
hpprime.keyboard() & (1 << numero_touche)
Évaluons les solutions clavier Python concurrentes selon les critères suivants :
- possible d'identifier la touche pressée
- les touches modificateurs sont identifiables (controle, shift, alpha, 2nde)
- la touche on/off est identifiable
- le test est non bloquant
- possible d'identifier plusieurs touches pressées simultanément
- possible d'identifier plusieurs touches pressées simultanément en un seul appel de la fonction de test
TI 83PCE + Python | TI 83PCE Python | TI 84+CE Python | TI Nspire CX II | Casio Graph 90+E 35+EII | Num Works | HP Prime | |||||||
1 2 3 4 5 6 TOTAL | . . . . . . 0 | ✓ . ✓ . . . 2 | ✓ . ✓ . . . 2 | ✓ . ✓ ✓ . . 3 | . . . . . . 0 | ✓ ✓ ✓ ✓ ✓ . 5 | ✓ ✓ ✓ ✓ ✓ ✓ 6 | . . . . . . 0 | . . . . . . 0 | ✓ . . . . . 1 | . . . . . . 0 | ✓ ✓ ✓ ✓ ✓ . 5 | ✓ ✓ ✓ . . . 3 |

- 6 points : HP Prime
- 5 points : NumWorks
- 3 points : TI-Nspire CX II
- 2 points : TI-83 Premium CE Edition Python
- 0 point : Casio Graph 90+E / 35+E II
- 6 points : HP Prime
- 5 points : NumWorks
- 3 points : TI-Nspire CX II
- 2 points : TI-83 Premium CE Edition Python / TI-84 Plus CE Python Edition
- 0 point : Casio Graph 90+E / 35+E II / fx-CG50 / fx-9750/9860GIII
TI-83 Premium CE + TI-Python
- 6 points : HP Prime
- 5 points : NumWorks
- 3 points : TI-Nspire CX II
NumWorks N0110 (Omega + KhiCAS) - 2 points : TI-83 Premium CE Edition Python / TI-84 Plus CE Python Edition
- 1 point : TI-Nspire CX / CX II (Ndless + KhiCAS CX / KhiCAS CX II)
- 0 point : Casio Graph 90+E / 35+E II / fx-CG50 / fx-9750/9860GIII
Casio Graph 35/75+E / 35+E II / fx-9750GII/GIII / fx-9860G/GII/GIII (appli CasioPython)
TI-Nspire (Ndless + micropython)
TI-83 Premium CE + TI-Python


hpprime.mouse()
.Ici les comparaisons à la concurrence seront rapides puisqu'il n'y a qu'une solution offrant quelque chose de comparable, les TI-Nspire CX II pour leur pavé tactile.

Avec les bons calculs, de quoi donc détecter également en Python les événements tactiles à 2 doigts (zoom notamment), une exclusivité à ce jour !

11) Python : Tracé par pixels et performances - import hpprime
Go to top- kandinsky (NumWorks)
- ti_graphics (TI-83 Premium CE / TI-84 Plus CE)
- ti_draw (TI-Nspire CX II)
- casioplot (Casio Graph 35+E II / 90+E / fx-9750/9860GIII / fx-CG50)
- graphic (NumWorks + KhiCAS - TI-Nspire CX + KhiCAS)
- nsp (TI-Nspire + micropython)


pixon(numero_calque, x, y, couleur)
pour allumer un pixel.numero_calque de 0 à 9 correspond aux variables globales G0 à G9 de l'environnement HPPPL, avec pour rappel :
- G0 : pour un affichage direct sur écran
- G1 à G9 : 9 calques hors écran, permettant non plus du double buffering mais du multiple buffering
Voici le détail des fonctions disponibles dans ce contexte :
blit(numero_calque_1, x, y, numero_calque_2)
pour copier un calque G0 à G9 sur un autre aux coordonnées indiquéesstrblit(numero_calque_1, x, y, largeur, hauteur, numero_calque_2)
, comme le précédent mais permet en prime au passage de redimensionner la copie (agrandissement, réduction, ...)strblit(numero_calque_1, x1, y1, largeur1, hauteur1, numero_calque_2, x2, y2, largeur2, hauteur2)
, comme le précédent mais permet de ne copier qu'une partie du calquedimgrob(numer_calque, largeur, hauteur, couleur)
pour redimensionner les calques G1 à G9 (non valide pour l'écran G0)grobw(numer_calque)
récupérer les dimensions d'un calque G0 à G9
L'écran HP Prime fait 320×240 pixels. Première chose à se demander, est-ce que l'on contrôle tous les pixels de l'écran ? Car vu la concurrence, ce n'est pas garanti.
Nous allons donc tenter de déterminer automatiquement la zone graphique, c'est-à-dire la zone dans laquelle l'utilisateur peut librement allumer des pixels.
Commençons dès maintenant à construire et expliquer devant toi notre protocole de test Python, avec un script universel tournant sur tous les modèles supportant officiellement ou officieusement ce langage.
L'idée générale va être d'effectuer des écritures et lectures de pixels.
Les fonctions de lecture/écriture des pixels différant hélas d'un constructeur à un autre, il nous faut déjà de quoi permettre au script de détecter la plateforme sur laquelle il tourne :
- Code: Select all
def get_pf():
c256 = True
try:
if chr(256)==chr(0):
# Xcas/KhiCAS Python compatibility
if "HP" in version():
return 13 # HP Prime
else:
if not white:
return 12 # Graph 35+E II
elif "Numworks" in version():
return 10 # NumWorks
elif "Nspire" in version():
return 8 # Nspire
else: # Graph 90+E
return 11
except:
c256 = False
try:
import sys
try:
if sys.platform == "nspire":
try: # Nspire Ndless
import graphic
return 7 # KhiCAS Micropython
except: # MicroPython
return 6
elif sys.platform == "TI-Nspire":
return 3 # Nspire CX II
elif sys.platform == "numworks":
return 9 # NumWorks KhiCAS Micropython
elif sys.platform.startswith('TI-Python'):
return 2 # 83P/84+ CE
except: # Graph 35+E/USB / 75/85/95
return 5
except:
pass
if not c256:
return 1 # Graph 90/35+E II
try:
import kandinsky
return 0 # NumWorks
except:
try: # HP Prime
import hpprime
return 4
except:
pass
return -1
Cette pièce de précision te retournera d'un simple
get_pf()
un identifiant couvrant tout l'éventail des solutions Python disponibles à ce jour pour calculatrices, et à interpréter de la façon suivante :- -1: inconnue (ordinateur ?...)
- 0: NumWorks
- 1: Casio Graph 90+E / fx-CG50 ou Graph 35+E II / fx-9750/9860GIII
- 2: TI-83 Premium CE ou TI-84 Plus CE
- 3: HP Prime
- 4: Casio Graph 35+E/USB / 75/85/95 / fx-9750/9860GII / fx-9860G avec CasioPython
- 5: TI-Nspire + MicroPython (nécessite Ndless)
- 6: TI-Nspire + KhiCAS en mode MicroPython (nécessite Ndless)
- 7: TI-Nspire + KhiCAS en mode de compatibilité Python (nécessite Ndless)
- 8: NumWorks + KhiCAS en mode MicroPython (nécessite Omega)
- 9: NumWorks + KhiCAS en mode de compatibilité Python (nécessite Omega)
- 10: Casio Graph 90+E / fx-CG10/20/50 + KhiCAS en mode de compatibilité Python
- 11: Casio Graph 35+E II / fx-9750/9860GIII + KhiCAS en mode de compatibilité Python
- 12: HP Prime en mode CAS
Maintenant que nous connaissons donc la plateforme, reste à récupérer les fonctions d'accès aux pixels.
Nous avons donc vu qu'il n'y avait pas de fonction pour lire un pixel, mais nous avons vu plus haut que le module hpprime nous permettait via sa fonction eval() d'accéder à l'environnement HPPPL complet. Il nous suffit donc de fabriquer la fonction de la façon suivante :
- Code: Select all
def get_pixel(x, y):
return int(hpprime.eval("get_pixel(" + str(x) + "," + str(y) + ")"))
Voici en conséquence de quoi récupérer automatiquement les fonctions de lecture et écriture des pixels sur l'ensemble des plateformes Python :
- Code: Select all
gp_prime = lambda x, y: GETPIX_P(x, y)
sp_prime = lambda x, y, c: PIXON_P(x, y, c)
def get_pixel_functions(pf):
gp, sp = lambda: None, lambda: None
if pf == 0: # NumWorks
import kandinsky
gp, sp = kandinsky.get_pixel, kandinsky.set_pixel
elif pf == 1: # Graph 90/35+E II
import casioplot
gp, sp = casioplot.get_pixel, casioplot.set_pixel
elif pf == 2: # 83P/84+ CE
import ti_graphics
gp, sp = ti_graphics.getPixel, ti_graphics.setPixel
elif pf == 3: # Nspire CX II
pass
elif pf == 4: # HP Prime
import hpprime
def sp(x, y, c):
hpprime.pixon(0, x, y, c)
def gp(x, y):
return int(hpprime.eval("get_pixel(" + str(x) + "," + str(y) + ")"))
elif pf == 6: # Nspire: Ndless MicroPython
from nsp import Texture
canvas = Texture(320, 240, 0)
gp, sp = canvas.getPx, canvas.setPx
elif pf == 7 or pf == 9: # Nspire/NumWorks: KhiCAS-MicroPython
import graphic
gp, sp = graphic.get_pixel, graphic.set_pixel
elif pf == 13: # HP Prime
gp, sp = gp_prime, sp_prime
return gp, sp
Voilà, d'un simple
gp, sp = get_pixel_functions(get_pf())
nous obtenons les fonctions de lecture et écriture des pixels, sur tous les modèles où elles existent.Comment donc faire maintenant pour tester la taille de la zone graphique, rien qu'en lisant / écrivant des pixels ?
Et bien c'est très simple, nous allons procéder comme avec une tortue (langage Scratch ou module Python turtle). Nous allons parcourir l'écran, en diagonale, en tentant de lire et modifier chaque pixel rencontré.
Pour savoir si un pixel est accessible en écriture, nous tenterons d'inverser sa couleur :
- Code: Select all
def invert_color(c):
try:
ci = [0, 0, 0]
for k in range(3):
ci[k] = 255 - c[k]
except:
ci = ~(c&0xffffff) & 0xffffff
return ci
def is_pixel_writable(x, y, bad_pixel):
if is_pixel_readable(x, y, bad_pixel):
c0 = gp(x, y)
sp(x, y, invert_color(c0))
c = gp(x, y)
return c != c0
Pour savoir si un pixel que l'on arrive à lire correspond bien à un pixel visible de l'écran, nous prendrons comme référence la mauvaise valeur de pixel retournée par une lecture clairement hors écran, comme
gp(-2, -2)
.Dans le seul cas où l'on rencontre cette valeur qui peut très bien être justifiée, nous tenterons ici encore de l'inverser.
- Code: Select all
def is_pixel_readable(x, y, bad_pixel):
c = None
try:
c = gp(x, y)
except:
pass
if c != None:
if c == bad_pixel:
sp(x, y, invert_color(c))
c = gp(x, y)
return c != bad_pixel
Voici donc les fonctions principales utilisant tout ça :
- Code: Select all
def scr_test(x0, y0, dx0, dy0, test):
bad_pixel = None
try:
bad_pixel = gp(-2, -2)
except:
pass
x, y, dx, dy = x0, y0, dx0, dy0
while not test(x, y, bad_pixel):
x += dx
y += dy
if test(x, y - dy, bad_pixel): y = y0
elif test(x - dx, y, bad_pixel): x = x0
x0, y0 = x, y
x += dx
y += dy
while(dx or dy):
if not test(x - ((dx == 0) and dx0),y - ((dy == 0) and dy0), bad_pixel):
if test(x - ((dx == 0) and dx0), y - ((dy == 0) and dy0) - dy0, bad_pixel): dy = 0
elif test(x - ((dx == 0) and dx0) - dx0, y - ((dy == 0) and dy0), bad_pixel): dx = 0
else: dx, dy = 0, 0
x += dx
y += dy
return x0, y0, (x - x0) // dx0, (y - y0) // dy0
def scr_size():
xrd0, yrd0, xrd, yrd = scr_test(0, 0, -1, -1, is_pixel_readable)
xra0, yra0, xra, yra = scr_test(1, 1, 1, 1, is_pixel_readable)
xr0, yr0 = xrd0 - xrd + 1, yrd0 - yrd + 1
xr, yr = xra + xrd, yra + yrd
xw0, yw0, xw, yw = scr_test(xr0, yr0, 1, 1, is_pixel_writable)
print("at (" + str(xr0) + "," + str(yr0) + "): " + str(xr) + "x" + str(yr) + " readable pixels")
print("at (" + str(xw0) + "," + str(yw0) + "): " + str(xw) + "x" + str(yw) + " writable pixels")
return xr0, yr0, xr, yr, xw0, yw0, xw, yw

scr_size()
, nous indique alors que nous avons accès à la fois en lecture et écriture à 320×240 pixels à compter du pixel de coordonnées (0, 0)
.
Nous aurions certes pu nous en rendre compte beaucoup plus rapidement, mais l'avantage de cette méthode c'est que nous avons en même temps les résultats des solutions concurrentes.
- 320×240=76800 pixels en écriture : HP Prime
- 384×192=73728 pixels en écriture : Casio Graph 90+E
- 320×222=71040 pixels en écriture : NumWorks
- 318×212=67416 pixels en écriture : TI-Nspire CX II
- 321×210=67410 pixels en écriture sur 321×241=77361 pixels en lecture : TI-83 Premium CE Edition Python
- 128×64=8192 pixels en écriture : Casio Graph 35+E II
- 320×240=76800 pixels en écriture : HP Prime
- 384×192=73728 pixels en écriture : Casio Graph 90+E
- 320×222=71040 pixels en écriture : NumWorks
TI-Nspire CX (Ndless + KhiCAS)
NumWorks N0110 (Omega + KhiCAS) - 318×212=67416 pixels en écriture : TI-Nspire CX II
- 321×210=67410 pixels en écriture sur 321×241=77361 pixels en lecture : TI-83 Premium CE Edition Python
- 128×64=8192 pixels en écriture : Casio Graph 35+E II
- 320×240=76800 pixels en écriture : HP Prime
- 384×192=73728 pixels en écriture : Casio Graph 90+E
- 320×222=71040 pixels en écriture : NumWorks
- 318×212=67416 pixels en écriture : TI-Nspire CX II
- 321×210=67410 pixels en écriture sur 321×241=77361 pixels en lecture : TI-83 Premium CE Edition Python / TI-84 Plus CE Python Edition
- 128×64=8192 pixels en écriture : Casio Graph 35+E II
- 0×0=0 pixels en lecture : TI-83 Premium CE + TI-Python
- 320×240=76800 pixels en écriture : HP Prime
- 384×192=73728 pixels en écriture : Casio Graph 90+E
- 320×222=71040 pixels en écriture : NumWorks
TI-Nspire CX / CX II (Ndless + KhiCAS CX / KhiCAS CX II)
NumWorks N0110 (Omega + KhiCAS) - 318×212=67416 pixels en écriture : TI-Nspire CX II
- 321×210=67410 pixels en écriture sur 321×241=77361 pixels en lecture : TI-83 Premium CE Edition Python / TI-84 Plus CE Python Edition
- 128×64=8192 pixels en écriture : Casio Graph 35+E II
- 0×0=0 pixels en lecture : TI-83 Premium CE + TI-Python
TI-83 Premium CE + TI-Python (firmware tiers)
Casio Graph 35/75+E / 35+E II / fx-9750GII/GIII / fx-9860G/GII/GIII (appli CasioPython)
TI-Nspire (Ndless + micropython)
Maintenant que nous savons quelles coordonnées de pixels indiquer aux fonctions de tracé, intéressons-nous au paramètre de couleur.
Il y a 2 façons de coder les couleurs dans le contexte des pixels en Python :
- soit avec une liste ou un tuple
(r, g, b)
décrivant les valeurs de chaque composante primaire rouge-vert-bleu par un entier sur 8 bits (de 0 à 255) - soit par un nombre entier qui sera directement la valeur fournie au contrôleur écran
Dans la plupart des solutions Python il s'agit de listes ou tuples
(rouge, vert, bleu)
avec chaque valeur codée sur 8 bits et pouvant donc prendre les valeurs entières de 0 à 255.Ce n'est pas ce qui a été retenu sur HP Prime, le paramètre de couleur est un unique nombre entier, reste à connaître les capacités du contrôleur écran.
Les modules graphiques concurrents à avoir fait ce choix de codage de couleur sont peu nombreux :
- graphic (NumWorks + KhiCAS - TI-Nspire CX + KhiCAS)
- nsp (TI-Nspire + micropython)
Pour en savoir davantage, rajoutons aux scripts précédents une fonction pour tester le codage utilisé, par simple vérification du type de retour d'une lecture de pixel. Dans le cas d'un retour de type entier, tentons en passant de détecter le nombre de bits gérés par le contrôleur écran, en écrivant des valeurs de pixels de plus en plus grandes et vérifiant à chaque fois si le pixel concerné a bien pris la valeur en question.
- Code: Select all
def get_color_mode():
c = gp(0, 0)
try:
c[2]
return 0
except:
b, v = 0, 1
dv = 1
x, y = 0, sy0
sp(x, y, v + dv)
while gp(x, y) >= v:
b += 1
v *= 2
sp(x, y, v + dv)
return b

color_mode = get_color_mode()
pourra donc renvoyer par exemple :- 0 : pour un codage des couleurs par des tuples (r,g,b)
- 15 : pour un codage des couleurs sur des entiers de 15 bits
- 16 : pour un codage des couleurs sur des entiers de 16 bits
- 24 : pour un codage des couleurs sur des entiers de 24 bits
- ...

Vérifions cela, pour un script universel prévoyons une fonction de conversion de couleur :
- Code: Select all
def fixcolor(c, bits=16):
try:
if not color_mode:
return c
r, g, b = c[0], c[1], c[2]
except:
if color_mode == bits:
return c
if bits == 16:
br, bg, bb = 5, 6, 5
else:
br, bg, bb = 8, 8, 8
r, g, b = c & (2**br - 1) * 2**(8 - br), c & ((2**bg - 1) * 2**br) // 2**br * 2**(8 - bg), c & ((2**bb - 1) * 2**(br + bg)) // 2**(br + bg) * 2**(8 - bb)
if not color_mode:
return (r, g, b)
else:
if color_mode == 16:
br, bg, bb = 5, 6, 5
else:
br, bg, bb = 8, 8, 8
r, g, b = r // 2**(8 - br), g // 2**(8 - bg) * 2**br, b // 2 **(8 - bb) * 2**(br + bg)
c = r + g - (r & g)
return c + b - (c & b)
Voici des fonctions intermédiaires pour tracer des lignes verticales ou horizontales :
- Code: Select all
def draw_vline(x, y1, y2, c):
for j in range(y2 - y1 + 1):
sp(x, y1 + j, c)
def draw_hline(y, x1, x2, c):
for j in range(x2 - x1 + 1):
sp(x1 + j, y, c)
Et voici enfin de quoi tracer une mire :
- Code: Select all
#o: 0=horizontal, 1=vertical
#s: 0=no_shadow, 1=shadow left/up, -1=shadow right/down
def mire(s=1, o=0, w=sw, h=sh, y0=sy0):
if o:
l1, l2, f, i1, i2 = h, w, draw_hline, y0, 0
else:
l1, l2, f, i1, i2 = w, h, draw_vline, 0, y0
n = 8
for m in range(l1):
v = 255
if s != 0:
v = v * (s*m % l1) // (l1 - 1)
for j in range(n):
f(m + i1, j * l2 // n + i2, (j + 1) * l2 // n - 1 + i2, fixcolor(color8(j, v)))
def color8(j, v):
c = [0, 0, 0]
for b in range(3):
if j & 2**b:
c[b] = v
return c

L'ensemble de la concurrence Python couleur présente des saccades dans le dégradé, qui plus est moins marquées mais 2 fois plus nombreuses dans les teintes tirant sur le vert.
C'est-à-dire que bien que même lorsque le paramètre de couleur spécifié est un tuple de 24 bits, le contrôleur écran ne tient compte que de 16 bits, ne permettant alors que 216=65536 couleurs différentes.
Plus précisément il y a 5 bits pour le rouge, 6 bits pour le vert et 5 bits pour le bleu.
En passant, le bleu étant ci-contre affiché en haut, les bits des plus faibles au plus forts codent donc dans l'ordre les composantes bleu, puis vert, puis rouge.
La concurrence Python monochrome pour sa part n'affiche jusqu'à présent qu'en noir et blanc, le codage couleur utilisé étant alors sur 1 bit.


circle(numero_calque, x, y, rayon, couleur)
pour tracer un cercle (non rempli donc)arc(numero_calque, x, y, rayon, couleur, angle1, angle2)
pour tracer un arc de cercle (avec sur cette version bêta les angles précisés en degrés contrairement à ce qu'indique l'écran d'aide)line(numero_calque, x1, y1, x2, y2, couleur)
pour tracer une lignerect(numero_calque, x1, y1, largeur, hauteur, couleur)
pour tracer un rectangle (non rempli)fillrect(numero_calque, x1, y1, largeur, hauteur, couleur1, couleur 2)
pour tracer un rectangle pleintextout(numero_calque, x, y, texte, couleur)
pour tracer une chaîne de caractères
Intéressons-nous maintenant aux performances. Pour illustrer l'importance d'avoir une bonne bibliothèque graphique ainsi que du double buffering, voici un petit script de démo animant des tracés de lignes.
Il est compatible avec l'interface polycalc.py déjà mise en avant à notre concours de rentrée 2020, et permettant à un script de s'exécuter sur l'ensemble des calculatrices graphiques Python.
- Code: Select all
from polycalc import *
screen_w, screen_h, my_draw_line, my_fill_rect, my_show_screen, test_esc_key = get_infos(("w", "h", "dl", "fr", "sh", "ek"))
def demog(n=64, front_color=(255, 0, 255)):
n_max = 256
n = min(n_max, n)
dx = n_max // n
dy = dx
def get_dir(x, y, d):
if(x >= screen_w - 1 and y <= 0):
d = [0, dy]
elif(x >= screen_w - 1 and y >= screen_h - 1):
d = [-dx, 0]
elif(x <= 0 and y >= screen_h - 1):
d = [0, -dy]
elif(x <= 0 and y <= 0):
d = [dx, 0]
return d
x1, y1 = 0, 0
x2, y2 = screen_w - 1, 0
d1 = [dx, 0]
d2 = [0, dy]
colors = [ tuple([(255 - front_color[j]) * (n - 1 - i) // (n - 1) + front_color[j] for j in range(3)]) for i in range(n)]
l = [[0,0,0,0] for k in range(n)]
my_fill_rect(0, 0, screen_w, screen_h, (255, 255, 255))
while not test_esc_key():
x1 += d1[0]
y1 += d1[1]
x2 += d2[0]
y2 += d2[1]
l.append((x1, y1, x2, y2))
for k in range(n):
c = l[k]
my_draw_line(c[0], c[1], c[2], c[3], colors[k])
l.pop(0)
my_show_screen()
d1 = get_dir(x1, y1, d1)
d2 = get_dir(x2, y2, d2)
Les lignes doivent donc être tracées pixel par pixel par une fonction de remplacement que voici :
- Code: Select all
def poly_draw_line(x1, y1, x2, y2, c):
m, a1, b1, a2, b2 = 0, int(x1), int(y1), int(x2), int(y2)
if (x2 - x1) ** 2 < (y2 - y1) ** 2:
m, a1, a2, b1, b2 = 1, b1, b2, a1, a2
if min(a1, a2) != a1: a1, b1, a2, b2 = a2, b2, a1, b1
for k in range(a2 - a1 + 1):
a, b = a1 + k, int(b1 + (b2 - b1) * k / ((a2 - a1) or 1))
poly_set_pixel((a, b)[m], (b, a)[m] + screen_y0, c)
Cela se paie très cher en performances, l'animation met plus d'un quart d'heure à boucler, 17min50.
Toutefois leur bibliothèque ti_graphics est extrêmement complète ce qui leur permet ici de compenser et même faire mieux que la solution précédente en terme de performances. L'animation boucle en 12min36, comme quoi ça compte.

En conséquence une animation encore bien lente bouclant en 5min14, avec des clignotements inesthétiques.
Les NumWorks peuvent toutefois être améliorées par installation du firmware tiers Omega. Dans ce cas la bibliothèque kandinsky se voit rajoutée une fonction de tracé de lignes, qui change complètement la donne. L'animation ne met plus que 7,28s à boucler.
Sur NumWorks N0110 on peut alors également installer l'application KhiCAS qui dispose de son propre interpréteur Micropython avec sa propre bibliothèque graphics. Mêmes avantages ici. 9,08s.
graphics dispose d'une fonction show_screen() suggérant une possibilité de double buffering, mais cela ne semble pas du tout marcher en pratique.
Sur TI-Nspire CX II on a bien du double buffering ainsi que la très large bibliothèque graphique ti_draw. Seulement 27,8s.
Mais il semble par contre y avoir ici de l'anti-aliasing à l'œuvre, ce qui parasite les nettoyages intermédiaires effectués par ce script.
Si on passe sous KhiCAS ici apparemment on a toujours le double buffering, mais le problème d'anti-aliasing disparaît et c'est même en prime légèrement plus rapide. Plus que 22,6s
Voici enfin la HP Prime G1 de la rentrée 2013. Son excellente bibliothèque graphique hpprime donc couplée à son matériel honorable, nous donnent une animation parfaitement fluide et esthétique, 2,6s !

Avec la HP Prime G2 et son matériel très supérieur de la rentrée 2019, là nous quittons clairement l'attraction terrestre. 0,84s !

Classons donc les solutions graphiques Python concurrentes selon les critères suivants :
- module de tracé par pixels
- fonction de tracé de ligne
- fonctions de tracé de rectangles
- fonctions de tracé de cercles
- fonctions de tracé d'ellipses
- double buffering
- multiple buffering
TI 83PCE + Python | TI 83PCE Python | TI 84+CE Python | TI Nspire CX II | Casio Graph 90+E 35+EII | Num Works | HP Prime | |||||||
1 2 3 4 5 6 7 TOTAL | . . . . . . . 0 | ✓ ✓ ✓ ✓ ✓ . . 5 | ✓ ✓ ✓ ✓ ✓ . . 5 | ✓ ✓ ✓ ✓ ✓ ✓ . 6 | ✓ . . . . ✓ . 2 | ✓ . ✓ . . . . 2 | ✓ ✓ ✓ ✓ . ✓ ✓ 6 | . . . . . . . 0 | ✓ . . . . ✓ ✓ 3 | ✓ ✓ ✓ ✓ ✓ ✓ . 6 | . . . . . . . 0 | ✓ ✓ ✓ . . . . 3 | ✓ ✓ ✓ ✓ ✓ . . 5 |

- 6 points : HP Prime
TI-Nspire CX II - 5 points : TI-83 Premium CE Edition Python
- 2 points : NumWorks
Casio Graph 90+E / 35+E II
- 6 points : HP Prime
TI-Nspire CX II - 5 points : TI-83 Premium CE Edition Python / TI-84 Plus CE Python Edition
- 2 points : NumWorks
Casio Graph 90+E / 35+E II / fx-CG50 / fx-9750/9860GIII - 0 points : TI-83 Premium CE + TI-Python
- 6 points : HP Prime
TI-Nspire CX II
TI-Nspire CX / CX II (Ndless + KhiCAS CX / KhiCAS CX II) - 5 points : TI-83 Premium CE Edition Python / TI-84 Plus CE Python Edition
TI-Nspire CX (Ndless + KhiCAS)
NumWorks N0110 (Omega + KhiCAS) - 3 points : NumWorks (Omega)
TI-Nspire (Ndless + micropython) - 2 points : NumWorks
Casio Graph 90+E / 35+E II / fx-CG50 / fx-9750/9860GIII - 0 point : TI-83 Premium CE + TI-Python
TI-83 Premium CE + TI-Python (firmware tiers)
Casio Graph 35/75+E / 35+E II / fx-9750GII/GIII / fx-9860G/GII/GIII (appli CasioPython)
12) Python : Tracé dans un repère - import hpprime
Go to top
Pour référence, hpprime serait donc a priori l'équivalent chez la concurrence des modules :
- matplotlib.pyplot (NumWorks - Casio Graph 35+E II / 90+E / fx-9750/9860GIII / fx-CG50)
- ti_plotlib (TI-83 Premium CE / TI-84 Plus CE - TI-NSpire CX II - NumWorks + KhiCAS - TI-Nspire CX + KhiCAS)
Il s'agit de l'ensemble des fonctions de tracé vues plus haut mais suffixées d'un _c pour leur version repérée.
Les bornes de la fenêtre se règlent avec
set_cartesian(xmin, ymin, xmax, ymax)
et se récupèrent si besoin avec get_cartesian()
.Toutefois c'est ici encore très préliminaire par rapport à la concurrence, dans le sens où il n'y a pas de fonction pour tracer des diagrammes (nuage de points, histogramme, champs de vecteurs, etc.) comme exigé au lycée français en Physique-Chimie.
Mais on ne peut pas tout avoir, n'est-ce pas ?

13) Python : Bilan modules
Go to topPour comparer la richesse de diverses implémentations Python, on ne peut pas se baser sur le nombre de modules différents offerts. En effet pour les modules propriétaires, certaines implémentations regroupent les fonctionnalités en un minimum de modules, alors que d'autres les répartissent entre de nombreux modules différents.
Tentons une autre approche incluant cette fois-ci les modules propriétaires avec le script suivant, initialement conçu pour notre classement QCC 2020 :
- Code: Select all
from autopfrm import *
pf = get_pf()
sh_inf = shell_infos(pf)
unsafe = ()
if pf == 4: #HP Prime
unsafe = ('count','encode','endswith','find','format','index','islower','lstrip','replace','rfind','rindex','rsplit','rstrip','split','splitlines','startswith','strip','from_bytes','to_bytes','fromkeys','get','pop','setdefault','update','values','sort','__enter__','__exit__','read','readinto','readline','seek','write')
if pf == 5 or pf == 7 or pf == 9: #CasioPython / Nspire+NumWorks KhiCAS MicroPython
unsafe = ('sys.argv', 'sys.path')
if pf >= 0:
curline=0
_p = print
def print(*ls):
global curline
st=""
for s in ls:
if not(isinstance(s,str)):
s=str(s)
st=st+s
stlines=1
if sh_inf[1]:
stlines += sh_inf[2]*int(len(st)/sh_inf[1])
if curline+stlines>=sh_inf[0]:
input("Input to continue:")
curline=0
_p(st)
curline+=stlines
def sstr(obj):
try:
s=obj.__name__
except:
s=str(obj)
a=s.find("'")
b=s.rfind("'")
if a>=0 and b!=a:
s=s[a+1:b]
return s
def isExplorable(obj):
if str(obj).startswith("<module"): return False
l = ()
try: l = dir(obj)
except: pass
return len(l)
def explmodr(pitm, pitm_name_l=[], pitm_str_l=[], pitm_val_l=[], reset=True):
global curline, found
pitm_name=sstr(pitm)
if(reset):
curline=0
found = []
pitm_name_l=[pitm_name]
pitm_str_l=[str(pitm)]
pitm_val_l=[pitm]
hd="."*(len(pitm_name_l)-1)
c = 0
l = sorted(dir(pitm))
for i in range(len(l)):
l[i] = (l[i], getattr(pitm, l[i]), str(l[i]))
try:
if not isinstanceof(pitm, str):
for i in range(len(pitm)):
l.append((pitm_name+'['+str(i)+']',pitm[i],str(pitm[i])))
except: pass
for itm in l:
isFound = itm[0] in found
c += not isFound
isUnsafe = '.'.join(pitm_name_l + [itm[0]]) in unsafe or itm[0] in unsafe
try:
if isUnsafe: raise Exception
print(hd+itm[0]+"="+str(itm[1]))
except:
print(hd+itm[0])
if not isFound:
found.append(itm[0])
if not isUnsafe and isExplorable(itm[1]) and itm[1] not in pitm_val_l and itm[2] not in pitm_str_l:
pitm_name_l2, pitm_val_l2, pitm_str_l2 = pitm_name_l.copy(), pitm_val_l.copy(), pitm_str_l.copy()
pitm_name_l2.append(itm[0])
pitm_val_l2.append(itm[1])
pitm_str_l2.append(itm[2])
c += explmodr(itm[1], pitm_name_l2, pitm_str_l2, pitm_val_l2, False)
return c
def explmod(s):
global found
module = __import__(s)
found = []
return explmodr(module)
Le script compte donc le nombre de fonctions offertes par le module donné ainsi que ses différents éléments, tout en évitant les doublons.
La HP Prime n'est pas en tête cette fois-ci, mais pour une toute première version avec Python son classement n'en est pas moins honorable, bien plus haut que d'autres solutions :
- 1915 fonctions : TI-83 Premium CE Edition Python
- 1017 fonctions : TI-Nspire CX II
- 853 fonctions : HP Prime
- 547 fonctions : NumWorks
- 443 fonctions : Casio Graph 90+E / 35+E II
- 2495 fonctions : TI-83 Premium CE Edition Python / TI-84 Plus CE Python Edition
- 2160 fonctions : TI-Nspire CX II
- 853 fonctions : HP Prime
- 547 fonctions : NumWorks
- 443 fonctions : Casio Graph 90+E / 35+E II / fx-CG50 / fx-9750/9860GIII
- 405 fonctions : TI-83 Premium CE + TI-Python
- 2495 fonctions : TI-83 Premium CE Edition Python / TI-84 Plus CE Python Edition
- 2160 fonctions : TI-Nspire CX II
- 1387 fonctions : NumWorks N0110 (Omega + KhiCAS)
- 1284 fonctions : TI-Nspire CX / CX II (Ndless + KhiCAS CX / KhiCAS CX II)
- 853 fonctions : HP Prime
- 602 fonctions : TI-83 Premium CE + TI-Python (firmware tiers)
- 590 fonctions : NumWorks (Omega)
- 547 fonctions : NumWorks
- 464 fonctions : Casio Graph 35/75+E / 35+E II / fx-9750GII/GIII / fx-9860G/GII/GIII (appli CasioPython)
- 429 fonctions : TI-Nspire (Ndless + micropython)
- 405 fonctions : TI-83 Premium CE + TI-Python
Conclusion
Go to top
Énormément d'idées ont été mises en œuvre depuis deux ans et demi. Bien sûr pour les raisons que l'on sait le temps de développement a clairement manqué, beaucoup de nouveautés souffrant de bugs plus ou moins gênants ou encore de non conformité du comportement avec ce qu'indique l'aide en ligne. Mais c'est justement l'intérêt de cette ouverture des tests de validation au public.
Nous n'en retenons pas moins l'extraordinaire révolution du développement HPPPL !

Nous avons enfin le Python, certes qui arrive un peu tard, avec une interface encore légère et parfois problématique. Mais il ne s'agit pas moins d'une solution :
- déjà très complète du point de vue de la quantité de fonctions intégrées
- tout comme du point de vue de l'adéquation aux programmes scolaires
- et extrêmement performante, anéantissant littéralement toute concurrence sur ce point !
N'oublions pas les incroyables possibilités d'interactions bidirectionnelles entre les différents langages et environnements HPPPL / CAS / Python de la calculatrice, un niveau d'intégration de loin jamais vu jusqu'à présent, du grand Art !

Le tout en parfaite contradiction avec l'esprit du logiciel de Mathématiques et de Sciences intégré de la calculatrice, puisque toutes les autres applications étaient interconnectées. Cela pouvait signifier que le constructeur avait décidé de rajouter le Python au dernier moment, sans prendre le temps de penser à son intégration.
Outre sa puissance et son caractère exhaustif, et même si l'on peut encore reprocher son interface à l'application Python, un point qui a clairement été pensé et travaillé à un niveau totalement inédit, c'est justement indiscutablement l'intégration du Python à l'environnement de la calculatrice et donc dans le processus de résolution de problèmes des élèves.
Si l'on ne devait retenir qu'une seule chose ce serait donc l'intégration du Python HP Prime, clairement un exemple précurseur à suivre !

Rester presque 3 ans sans évolution ne donne pas une bonne image du produit et ébranle la confiance des potentiels acheteurs. 2 ans et demi c'est long, c'est presque toute une scolarité au lycée...

Téléchargements
Go to topSource : https://www.hpmuseum.org/forum/thread-16643.html