Hewlett Packard
en 2019-2020, les 2 seuls développeurs qu'il restait pour la HP Prime
, Cyrille de Brébisson
et Tim Wessman
, avaient été réaffectés à d'autres missions. À 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 hélas très mineure remontait à Janvier 2020
- et la dernière mise à jour majeure remontait à Novembre 2018
Python
en tant que langage de programmation universel, commun à l'ensemble des matières scientifiques. 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.Pour ce mois d'Avril
Hewlett Packard
a donc autorisé Cyrille
et Tim
à travailler sur la HP Prime
. Plusieurs versions ont été diffusées dans le cadre d'un bêta-test public, et les plus réussies ont fait l'objet d'un test complet chez nous :- 13 avril 2021 :
- 16 avril 2021 : 2.1.14549(régression du modeCAS: menu des fonctionsCASinutilisable)
- 22 avril 2021 : 2.1.14558(régression surHP Prime G1: bloque la calculatrice)
- 26 avril 2021 : 2.1.14563(régression de l'appliPython: les opérations/fonctions construisant des chaînes retournent des chaînes vides)
- 27 avril 2021 :
- 28 avril 2021 : 2.1.14575
L'
La dernière version bêta
Cette mise à jour
et , ainsi que les applications pour et ne sont à ce jour pas concernées par la mise à jour. 
Puisqu'il s'agit donc d'une sortie officielle, nous allons traiter ensemble de l'intégralité des nouveautés et améliorations, aussi bien par rapport à la version bêta précédente que par rapport à la dernière mise à jour de . Pour chaque point nous prendrons à la fois le temps de te donner notre avis, et de t'expliquer l'utilisation à l'aide de premiers exemples simples. N'hésite pas à utiliser le sommaire ci-dessous afin d'accéder directement aux points qui t'intéressent le plus.
Mais avant ça, hélas, quelques avertissements d'importance :
Nous ignorons si il s'agit d'une erreur ou bien d'un choix délibéré dans l'urgence de la situation, mais les logiciels
Cela a des conséquences non annoncées et non négligeables ; les logiciels cesseront définitivement de fonctionner
Or, nous ne sommes pas sûrs que les épreuves d'examens soient alors terminées partout dans le monde, certains candidats pourraient bien avoir une très mauvaise surprise le
Si tu choisis d'installer ces versions des logiciels, tu devras donc impérativement d'ici le
Ceci étant dit, c'est maintenant parti pour la collection de formidables bonnes nouvelles !
ultimatum
de l'Institution néerlandaise expirait donc ce vendredi 30 avril
à minuit, et le grand jour est donc arrivé pour tous les amoureux de la HP Prime
et des calculatrices Hewlett Packard
en général.La dernière version bêta
2.1.14575
a fait l'objet d'une publication à l'identique sur le serveur de mise à jour jeudi 29 avril
au soir. Et le 30 avril
au soir soit avant l'expiration de l'ultimatum, les alertes de mise à jour ont été déclenchées signant donc, avec le début de la diffusion à grande échelle, la sortie officielle de cette version.Cette mise à jour
2.1.14575
concerne donc :- les calculatrices HP Prime G1etHP Prime G2
- le logiciel d'émulation HP Primepour machinesWindows 32 bitsetWindows 64 bits
- le logiciel de connectivité HP Primepour machinesWindows 32 bitsetWindows 64 bits
Mac
Linux
Android
iOS
Puisqu'il s'agit donc d'une sortie officielle, nous allons traiter ensemble de l'intégralité des nouveautés et améliorations, aussi bien par rapport à la version bêta précédente
2.1.14567
janvier 2020
Mais avant ça, hélas, quelques avertissements d'importance :
Nous ignorons si il s'agit d'une erreur ou bien d'un choix délibéré dans l'urgence de la situation, mais les logiciels 2.1.14575
sont marqués en tant que version bêta.Cela a des conséquences non annoncées et non négligeables ; les logiciels cesseront définitivement de fonctionner
60 jours
après leur date de compilation, ce qui du 28 avril 2021
nous amène donc au 28 juin 2021
.
Or, nous ne sommes pas sûrs que les épreuves d'examens soient alors terminées partout dans le monde, certains candidats pourraient bien avoir une très mauvaise surprise le
28 juin
...Si tu choisis d'installer ces versions des logiciels, tu devras donc impérativement d'ici le
28 juin
au plus tard :- les mettre à jour vers une version plus récente si disponible d'ici-là
- sinon, les désinstaller, pour ensuite pouvoir installer la dernière version inférieure non-bêta, la de2.1.14425, liens de téléchargements en fin d'articlejanvier 2020
Attention, pour sa part le logiciel de connectivité en version
Cela concerne les programmes et applications
En pleine période d'examens nous te déconseillons donc très fortement l'installation de cette version du logiciel de connectivité.
Note que tu peux parfaitement mettre à jour ta calculatrice et bénéficier de toutes les formidables nouveautés qui vont suivre à partir du logiciel de connectivité en version de , liens en fin d'article.
2.1.14575
casse la compatibilité avec la version initiale des formats de fichiers HP Prime
suivants :- .hpprgm(programmes)
- hpappdir.hpappprgm(scripts d'applications)
Cela concerne les programmes et applications
HP Prime
publiés chez nous il y a quelques années, ainsi que l'intégralité des images et documents .pdf
convertis en applications HP Prime
chez nous.En pleine période d'examens nous te déconseillons donc très fortement l'installation de cette version du logiciel de connectivité.
Note que tu peux parfaitement mettre à jour ta calculatrice et bénéficier de toutes les formidables nouveautés qui vont suivre à partir du logiciel de connectivité en version
2.1.14425
janvier 2020
Ceci étant dit, c'est maintenant parti pour la collection de formidables bonnes nouvelles !
Sommaire :
- Application Python et programmation
A) Moteur de calcul exact QPiRac - Home
Go to topLa
L'écran
Si tu souhaitais obtenir des résultats exacts, plusieurs possibilités s'offraient à toi :
La mise sous forme exacte via la touche
L'appui sur
Notons un petit changement de forme très agréable concernant
Avec cette formidable mise à jour plus besoin de t'embêter avec les diverses gymnastique précédentes, nouveauté historique, après des années cette mise à jour nous rajoute enfin un moteur de calcul exact sur l'écran de calcul 
Attention toutefois, actuellement il ne semble pas activé par défaut. Il te faut accéder aux paramètres via
Une fois ceci fait tu obtiens enfin par défaut des résultats exacts à chaque fois que possible, la plupart du temps plus besoin de réaliser des manipulations spécifiques pour cela !
Les formes gérées sont beaucoup plus larges qu'avec la touche
Accessoirement si tu préfères obtenir des résultats en écriture décimale puis éventuellement les mettre en écriture exacte, la touche
Par contre, on remarque que le moteur de calcul exact
À 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
En passant grande nouveauté que tu viens peut-être de remarquer sur les captures d'écran, le menu de bas d'écran te permet enfin de sauvegarder et recharger des états de l'écran de calcul
En parlant d'affectations nouveauté également, tu as enfin la possibilité d'affecter simultanément plusieurs variables.
Pour rester sur le calcul, la justesse des calculs par des fonctions trigonométriques en radians a été améliorée.
Dans ce contexte, cela vise à faire disparaître les :
Ces améliorations ne se limitent d'ailleurs pas à la trigonométrie et sont bien plus générales que cela.
HP Prime
est un agrégat de 2 mondes :- le mode numérique avec l'écran de calcul accessible via
⌂Home
et les diverses applications accessibles viaApps
, le tout développé parHP, agrémenté de diverses interfaces graphiques et offrant pléthore de fonctions avec des noms en majuscules - le mode CASavec l'écran de calculs
CAS
offrant pour sa part un moteur de calcul formel(le moteur, accompagné ici d'interfaces spécifiques en mode texte et offrant des fonctions avec des noms en minusculesGIACdéveloppé pour le logicielXcasparBernard Parisseenseignant-chercheur à l'Université de Grenoble)
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.
Si tu souhaitais obtenir des résultats exacts, plusieurs possibilités s'offraient à toi :- 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 ⌂Homemais y spécifier un appel au moteurCASsous la forme
CAS.eval(...), rapidement lourd si tu devais le faire pour chaque calcul - soit encore sur l'écran ⌂Homespé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$(ouQRac)$mathjax$\pm a\sqrt{\frac{b}{c}}\pi$mathjax$(pas toujours pertinentesQPi)
- soit encore sur l'écran ⌂Homesé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
La mise sous forme exacte via la touche ab/ccommettait parfois des erreurs impressionnantes, comme ci-contre de pas moins de 10 milliards sur e24. Normal puisque l'on sortait de l'intervalle de fiabilité de l'algorithme approchant le résultat par une fraction.
L'appui sur
ab/cévite maintenant de traiter les nombres trop grands.
Notons un petit changement de forme très agréable concernant QPI()
. La forme recherchée n'est plus $mathjax$a\sqrt{\frac{b}{c}}$mathjax$
mais $mathjax$a\frac{\sqrt{b}}{c}$mathjax$
, ce qui évite maintenant les racines carrées au dénominateur.
Avec cette formidable mise à jour plus besoin de t'embêter avec les diverses gymnastique précédentes, nouveauté historique, après des années cette mise à jour nous rajoute enfin un moteur de calcul exact sur l'écran de calcul ⌂Home
, comme la plupart des modèles concurrents, enfin ! 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.
Une fois ceci fait tu obtiens enfin par défaut des résultats exacts à chaque fois que possible, la plupart du temps plus besoin de réaliser des manipulations spécifiques pour cela ! Les formes gérées sont beaucoup plus larges qu'avec la touche
ab/cet même 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)
Intelligent Math
c'est comme si une fonction QPI(...)
plus évoluée était automatiquement appliquée à chacun de tes résultats.
Accessoirement si tu préfères obtenir des résultats en écriture décimale puis éventuellement les mettre en écriture exacte, la touche ab/cgère désormais elle aussi les formes
QPi
et QRac
, activables à l'écran de configuration.
Par contre, on remarque que le moteur de calcul exact QPiRac
ne semble pas fonctionner si le résultat calculé est directement affecté à une variable.À 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 passant grande nouveauté que tu viens peut-être de remarquer sur les captures d'écran, le menu de bas d'écran te permet enfin de sauvegarder et recharger des états de l'écran de calcul ⌂Home
. Très pratique pour travailler en parallèle les problèmes des différents cours de sciences du jour.En parlant d'affectations nouveauté également, tu as enfin la possibilité d'affecter simultanément plusieurs variables.
Pour rester sur le calcul, la justesse des calculs par des fonctions trigonométriques en radians a été améliorée.Dans ce contexte, cela vise à faire disparaître les :
- résultats proches de zéro alors qu'ils auraient dû être nuls (notamment avec des angles en radians)
- résultats très grands alors qu'ils auraient dû déclencher une erreur de dépassement
$mathjax$tan\left(\frac{3\pi}{2}\right)=+\infty$mathjax$
? Erreur qu'elle ne commet pourtant pas avec $mathjax$tan\left(\frac{\pi}{2}\right)$mathjax$
...
Ces améliorations ne se limitent d'ailleurs pas à la trigonométrie et sont bien plus générales que cela.B) Moteur de calcul formel - CAS
Go to top
Dans le mode CAS
, nous bénéficions de toute une collection d'améliorations du moteur de calcul, soit l'ensemble des améliorations apportées entre temps au moteur GIAC
de Xcas
.
De nouveaux avertissements accompagnent certains résultats.C) Graphes, fonctions et coordonnées
Go to top
Passons aux fonctions. En mode réel, les graphes de fonctions dont les expressions utilisent des puissances fractionnaires sont maintenant tracés au complet.
Il devient maintenant possible d'intégrer une fonction dérivée.
Tu pouvais jusqu'à présent convertir des coordonnées :- de cartésiennes à polaires avec la fonction polar_coordinates()
- de polaires à cartésiennes avec la fonction rectangular_coordinates()
CoordinateConvert()
permettant de convertir des coordonnées de façon cette fois-ci unifiée.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 même sphériques !
D) Bibliothèque d'unités
Go to top
Nouveauté dans la bibliothèques d'unités physiques accessible via Shift
□/□, les unités relatives aux couples de forces.
En mode CAS
, nous bénéficions de meilleures simplifications d'unités.E) Listes et matrices
Go to top
Tu pouvais déjà récupérer et modifier un élément de liste ou matrice en appelant le nom de cette dernière avec son numéro (attention, commençant à 1 et non à 0 comme en
.Python
)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 pouvais déjà convertir des listes en matrices et vice-versa, grâce aux fonctions list2mat()
et mat2list()
.Tu as maintenant de nouvelles fonctions au comportement légèrement différent et qui peut-être te conviendront mieux,
ListToMat()
et MatToList()
.F) Saisie en notation RPN
Go to top
La HP Prime
te permet plusieurs formes de saisie de tes expressions :- Livrepour la saisie en écriture naturelle comme dans tes livres et énoncés
- Algébriquepour une saisie sur une seule ligne, pouvant nécessiter l'ajout de parenthèses par rapport à la précédente pour une même expression à saisir
- RPN, une notation post-fixée dite notation polonaise inverse utilisée par défaut sur les calculatricesHPdes années 1980 et 1990, une notation logique très rapide ne nécessitant aucune parenthèse, un bel hommage
Si la notation RPN
fonctionnait à l'écran de calculs, elle causait quelques problèmes lorsque l'on saisissait des formes erronées dans le tableur, les boîtes de dialogue, ainsi que l'éditeur de données statistiques. C'est maintenant corrigé.G) Assistant de résolution de lois de probabilités - boîte à outils
Go to top
Résoudre un problème de loi de probabilités jusqu'à présent, c'était complexe (et pas que sur
.HP Prime
)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.
Et bien autre grande nouveauté, la boîte à outils 🧰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
Tu dois ensuite choisir le type de question :- centerpour travailler sur la formep(...≤X≤...)
- lower tailpour travailler la formep(X≤...)
- upper tailpour travailler la formep(X≥...)
- tailspour travailler la formep(X≤... ∪ X≥...)
Il te faut ensuite saisir :- 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
Résoudre
pour l'obtenir automatiquement ! 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
Casio
Mais ce n'est absolument pas un reproche. Quand c'est génial, pourquoi se gêner ?
On peut justement déjà comparer le nombre de lois disponibles :
HP Prime | NumWorks | Casio | |
| binomiale géométrique hypergéométrique Poisson Discrètes exponentielle Fisher normale Student uniforme χ² Continues TOTAL | . ✓ . . 1 . ✓ ✓ ✓ . ✓ 4 5 | ✓ ✓ . ✓ 3 ✓ ✓ ✓ ✓ ✓ ✓ 6 9 | ✓ ✓ ✓ ✓ 4 . ✓ ✓ ✓ . ✓ 4 8 |
Si la HP Prime
propose moins de lois, notons par contre que son interface permet bien davantage de choses que celle de la NumWorks
(par rapport à
.Casio
nous ne savons pas encore)En effet, pour l'ensemble des lois proposées, la
HP Prime
permet de résoudre les questions de probabilité inverse dans le cadre d'une forme p(...≤X≤...)
, là où la NumWorks
Mais surtout autre exclusivité à ce jour, l'option cochable
Linked
en bas d'écran te permet de préciser pour ce genre de forme si tu souhaites obtenir les 2 bornes d'un intervalle centré, ou bien seulement l'une des deux bornes, déterminée alors dans ce cas par rapport à la valeur que tu as précisée pour l'autre.H) Assistant de résolution de polynômes - boîte à outils CAS
Go to top
Pour résoudre tes équations polynomiales, plus besoin de saisir un appel de la fonction solve()
avec l'ensemble de ses paramètres. Nous avons maintenant un assistant de résolution de polynômes, accessible via l'onglet CAS
de la boîte à outils.Il suffit de saisir les coefficients, et on obtient alors automatiquement les racines accompagnées d'une représentation graphique sur un intervalle jugé pertinente.
Un bel ajout, cela va bien évidemment dans la bonne direction. Nous pouvons toutefois regretter peut-être des erreurs de jeunesse :- une interface de saisie encore rudimentaire, réclamant les coefficients sous la forme d'un vecteur, ne simplifiant pas vraiment la chose sur ce point par rapport à la saisie habituelle de l'appel à solve()
- l'affichage de l'expression du polynôme avec :
- des signes
- des parenthèses oubliées avec un affichage faux, notamment en cas de coefficients complexes
- un oubli d'affichage du terme de degré zéro, si celui-ci vaut +1 ou -1
+inutiles - l'absence de résultats en écriture exacte bien que l'option Intelligent Mathsoit activée, ce qui reste ici hélas un gros manque par rapport à la concurrence
I) Assistant de résolution de triangles - application Solveur Triangle
Go to top
Dans le même style, tu disposais déjà d'une très belle application permettant de résoudre les problèmes de géométrie autour du triangle.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.
J) Assistant de résolution d'équations - application Résoudre
Go to top
L'application de résolution d'équations autorise maintenant la saisie d'équations comportant des variables non encore définies.Plutôt qu'une erreur, elle te propose dans ce cas de les définir.
K) Test χ² GOF - application Inférence
Go to top
Dans l'application Inférence
, le test χ² GOF te permet maintenant d'imposer le nombre de degrés de libertés.Ce nouveau paramètre est utilisable aussi bien sur l'interface de l'application que lors d'un appel direct à sa fonction
CHI2GOF()
.L) Développement applications
Go to top
La HP Prime
te permet de développer et rajouter des applications. Ces applications tierces sont écrites dans les mêmes langages que les programmes, mais sont rajoutées sur l'écran d'accueil et alors directement lançables.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.M) Fréquence rafraîchissement écran - HP Prime G2
Go to topHP Prime G2
.D'origine, la
HP Prime G2
rafraîchit son écran à une fréquence de 55 Hz
.Désormais, grâce aux nouveaux raccourcis
On
Shift
+et
On
Shift
-, tu peux monter cette fréquence par pas de
10 Hz
jusqu'à 125 Hz
.Une fréquence plus élevée ralentit très légèrement la machine, mais te permet alors des changements d'écrans/menus visuellement plus instantanés et agréables, et notamment des animations bien plus fluides :
N) Périphériques USB OTG - HP Prime G2
Go to top
HP Prime G2
et absolument révolutionnaire ! Il t'est maintenant possible de connecter des périphériques
USB
et de communiquer avec. Tu as pour cela à ta disposition les fonctions suivantes :USBOpen(vid, pid)pour établir une connexion avec le périphériqueUSBcorrespondantUSBSend({...})pour envoyer des données au périphériqueUSBReceive()pour lire des données depuis le périphériqueUSBOpen()qui permet maintenant de lister les identifiantsvid/piddu ou des appareilsUSBbranchés sur ta calculatrice, fort pratique pour écarter une erreur d'identifiant en cas d'échec de la connexion
HP Prime
, peut-être enfin un pas vers la possibilité de transférer des données entre deux calculatrices.Cela ouvre la voie vers bien d'autres possibilités ; clavier
USB
, souris optique USB
, clé USB
: STEM
offertes par exemple par une carte BBC micro:bit
! Toutefois pour l'instant les fonctions sont basiques. C'est-à-dire que les périphériques ainsi connectés ne sont pas fonctionnels en l'état ; les souris ne font rien et les touches clavier pas mieux. C'est-à-dire que ces fonctions doivent être utilisées pour programmer des pilotes ciblant chacun des types de périphériques que tu souhaites utiliser.
Précisons de plus que la détection de périphériques via un appel
USBOpen()
n'est pas très fiable. Nous n'avons réussi à détecter que 2 souris sur 3... 1 clé USB
sur 10... Et si cela a marché avec la carte BBC micro:bit v1
, cela n'a pas été le cas avec une carte BBC micro:bit v2
.Peut-être y a-t-il des différences de consommation électrique entre ces périphériques gênant la détection au-delà d'un certain seuil, mais si c'est ça la limite serait bien basse par rapport à ce que l'on observe sur les modèles
Texas Instruments
O) Application Tableur - HP Prime G2
Go to top
L'application
Si tu choisissais d'aller directement à une cellule via le menu
Tableur
souffrait d'un petit bug
, mais bizarrement il ne se déclenchait que sur HP Prime G2
.Si tu choisissais d'aller directement à une cellule via le menu
Aller
en bas d'écran et validais une saisie d'adresse vide, la calculatrice redémarrait immédiatement.C'est maintenant corrigé.
Mode examen - Pays-Bas
Go to top
Comme nous te l'avions expliqué cette mise à jour sort en urgence pour les examens aux Pays-Bas.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)
Pour activer correctement le mode examen, les candidats devaient choisir de personnaliser sa configuration et tout remplir correctement :- 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 Configurationen bas d'écran :
- Apps utilisateur
- CAS
- Remarques et programmes
- Nouv. remarques et programmes
Nouveauté à compter de cette session 2021, en dehors des quotients de nombres entiers le reste des résultats exacts QPiRac
sont désormais également interdits aux examens des Pays-Bas.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(...)
.
Le nouveau mode examen de cette version résout le problème en rajoutant 2 limitations de fonctionnalités relatives au calcul exact à l'écran de configuration du mode examen :- 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.
a b/c Key options
désactive à la fois :- la mise sous forme exacte via la touche
ab/c
- la mise sous forme exacte via la fonction QPI(...)
QPiRac
rajouté à l'écran ⌂Home
.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)
Autre changement pour faire plaisir aux Pays-Bas dans l'application Suites
.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.
Le mode examen gagne des façons de désactiver seulement certaines fonctions CAS
:- une nouvelle option permet de désactiver les fonctions CASd'arithmétiqueifactor(),idivis(),igcd()etlcm()
- Do1VStatsdésactive désormais également les fonctionsCASde médiane, quartile et moyenne
- Stat2Varsdésactive désormais également les fonctions de régression du modeCAS
- le même réglage unique désactive désormais les fonctions comb(),perm(),min()etmax()aussi bien en mode numérique queCAS
CAS
.Mode examen - France
Go to topDans les pays comme la France où ce sont les candidats qui activent le mode examen, la
La bouton
Grande nouveauté avec cette version, lorsque activé, l'écran de statut du mode examen présente enfin un
Finies les manipulations compliquées ou impossibles pour le surveillant, une simple pression sur ce bouton tactile suffira !
HP Prime
était bien embêtante. En effet, pour ceux qui arrivaient à leur épreuve avec un mode examen déjà activé (et donc potentiellement une mémoire non vide)
, il n'y avait pas de moyen simple de réinitialiser le mode examen.La bouton
reset
n'efface pas les données, et à moins de disposer sur place d'un ordinateur ou autre hôte USB
avec la bonne connectique sous la main pour désactiver puis réactiver le mode examen, la seule solution était d'aller tout effacer dans le menu mémoire.
Grande nouveauté avec cette version, lorsque activé, l'écran de statut du mode examen présente enfin un Restart
en menu de bas d'écran.Finies les manipulations compliquées ou impossibles pour le surveillant, une simple pression sur ce bouton tactile suffira !
1) Python : Éditeur et aide en ligne
Go to topDans l'application
L'éditeur en soi est assez rudimentaire. Il ne bénéficie ni de coloration syntaxique, ni d'autocomplétion.
L'éditeur offre par défaut un système d'indentation automatique, bizarrement nommé
En fait au retour à la ligne avec
L'éditeur s'accompagne d'un menu de bas d'écran
Toutefois quelque chose de remarquablement bien conçu, c'est le menu
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 !
Les menus des modules s'accompagnent bien sûr chacun de l'essentielle commande d'importation.
Autre fonctionnalité absolument remarquable, tu disposes d'une formidable aide en ligne qui t'explique de façon exhaustive le fonctionnement et l'utilisation de chaque élément
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
Bref, de gros manques d'une part, mais également des avancées inédites hautement intéressantes d'autre part.
Python
, il y a 2 vues :- la vue
Symb
avec l'éditeur de script - la vue
Num
avec la console
L'éditeur en soi est assez rudimentaire. Il ne bénéficie ni de coloration syntaxique, ni d'autocomplétion.
L'éditeur offre par défaut un système d'indentation automatique, bizarrement nommé Tiret
dans le menu, mais à ce jour fort peu pratique pour du code Python
.En fait au retour à la ligne avec
Enterinsère un retrait qui ne fait qu'aligner le code avec celui de la ligne précédente.
L'éditeur s'accompagne d'un menu de bas d'écran
Tmplt
permettant de saisir rapidement différents blocs de commandes Python
.
Toutefois quelque chose de remarquablement bien conçu, c'est le menu Cmds
.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 !
Les menus des modules s'accompagnent bien sûr chacun de l'essentielle commande d'importation.
Autre fonctionnalité absolument remarquable, tu disposes d'une formidable aide en ligne qui t'explique de façon exhaustive le fonctionnement et l'utilisation de chaque élément Python
! 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 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
La touche 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.
Attention toutefois, contrairement à toute la concurrence ces importations automatiques utilisent la commande
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
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.
Tu saisis donc sur la ligne en bas d'écran, et tu as l'historique défilable des sorties au-dessus.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
TI-Nspire
Ligne de saisie et historique sont donc ici deux zones graphiques bien distinctes. Il n'empêche que tu peux quand même réutiliser tout ou partie d'une saisie ou d'un affichage précédent, il te suffit de cliquer dans l'historique pour en sélectionner une ligne, passer alors de ligne en ligne avec les flèches, et copier la ligne de ton choix vers le champ de saisie à l'aide du menu de bas d'écran.La touche
Onpermet d'interrompre instantanément un script
Python
qui pour une raison ou une autre prendrait trop de temps ou ne se terminerait pas.
Concernant la fonction input()
, la saisie est effectuée sur la ligne dédiée. On peut toutefois regretter l'absence de retour à la ligne dans l'historique de la console.
L'ensemble des touches avec fonctions et symboles mathématiques au clavier est soigneusement adapté à l'environnement Python
, les saisies usuellement en langage HPPPL
étant ici automatiquement transcrites en langage Python
.
On peut toutefois regretter quelques fonctions qui, si saisies via leurs touches clavier associées, ne positionnent pas correctement le curseur de texte, ne le plaçant pas entre les parenthèses mais après.
Pour la racine n-ième avec Shift
x^y, c'est même pire. La fonction n'existant pas en
Python
, cette combinaison saisit une puissance. Non seulement le curseur de texte souffre du même mauvais positionnement, mais en prime les parenthèses sont mal placées, ne faisant alors pas calculer de racine n-ième.
Le travail de transcription automatique ne s'arrête d'ailleurs pas au clavier. Par exemple, l'interface de saisie de nombres en base hexadécimale, octale ou binaire reste accessible en Python
via son raccourci Shift
-. Bien que continuant d'afficher les nombres au format
HPPPL
, ces derniers sont automatiquement traduits en syntaxe Python
pour la saisie une fois validés. 
On peut trouver par contre quelques défauts de transcription à condition de se rendre dans des menus ou interfaces :- La plupart des opérateurs de comparaison et de logique accessibles via
Shift
6
sont saisis correctement dans le contextePython. Font exception :- le non logique NOT, bizarrement remplacé dans le contextePythonpar!ce qui n'est pas correct enPython; il faut remplacer parnot
- le ou exclusif xor, à remplacer par^dans le contextePython
- la fonction EQ()à remplacer par==enPythonou bien à supprimer si ça fait doublon
- le non logique
- Les constantes mathématiques sont saisies correctement en Pythonvia les touches clavier, mais pas via le menu des constantes accessible via
Shift
□/□
.
Il n'empêche, un accomplissement qui reste remarquable en terme de quantité et de rapidité !
3) HPPPL / Python / CAS : Editeur programmes hybride projets HPPPL / Python / CAS et nouveautés HPPPL
Go to top
L'éditeur de programmes subit avec cette version une formidable révolution.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é.
Venons-en à la révolution. L'éditeur de programmes gérait par défaut le langage
Mais il permettait également de gérer le langage
Le langage
Et bien voilà, en plus des 2 langages précédents, tu peux désormais inclure des blocs en
Oui oui, l'éditeur de programmes historique de la
Tu peux alors appeler le bloc
Mais tu peux également écrire différemment le bloc
HPPPL
(HP Prime Programming Language)
.Mais il permettait également de gérer le langage
Xcas
. Les blocs en langage Xcas
étaient à encadrer de balises #cas et #end.Le 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.Un petit manque, c'était dans le cadre du tracé de chaînes de caractères avec par exemple la fonction
TEXTOUT_P()
. Il n'y avait en effet pas de moyen simple de connaître l'espace occupé par le texte affiché (largeur et hauteur)
, ce qui pouvait être embêtant :- pour bien positionner les autres éléments graphiques à tracer
- pour donner un fond coloré à certains affichages de texte
Voici donc enfin la solution pour programmer encore plus facilement tes interfaces graphiques, la fonction TEXTSIZE(texte,taille_police)
.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.
Par contre, une nouveauté dans cette mise à jour, il est maintenant possible de définir plusieurs fonctions partageant le même nom.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;
Et surtout, cela permet de simuler des valeurs d'arguments par défaut. Il suffit de définir plusieurs fois le même nom de fonction avec des nombres d'arguments qui diffèrent, et c'est au code d'agir en conséquence :- 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;
Peut-être que cela te choque de pouvoir ainsi définir plusieurs fois et différemment le même nom de fonction... ou pas.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;
Pour le moment il y a un maximum de 16 arguments au total, qu'ils soient obligatoires ou optionnels.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;
Les affichages non graphiques de tes programmes via la fonction PRINT()
étaient pour leur part redirigés vers une sorte de console ici appelée terminal. Et bien grande nouveauté, il y a désormais une nouvelle fonction PRINT2D()
pour afficher dans le terminal des lignes en écriture naturelle.
En pratique pour que la fonction PRINT2D()
fonctionne correctement, il est nécessaire de bloquer l'évaluation/simplification des expressions que tu lui passes. C'est possible en les entourant d'un appel de fonction quote()
, ou encore en les mettant entre guillemets simples.- 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"});
Autre point, on pouvait inclure la caractère tabulation '\t'
dans les chaînes de caractères, mais les fonctions d'affichage (PRINT, PRINT2D, TEXTOUT, TEXTOUT_P)
le remplaçaient par un rectangle peu esthétique.C'est maintenant amélioré, ces mêmes fonctions remplacent à l'affichage le caractère tabulation par un espace.
Autre nouveauté, il t'est maintenant possible de déclencher via la fonction READLINE()
une saisie qui sera réalisée directement dans le terminal. L'utilisateur bénéficiera ainsi lors de sa saisie de tout ce qui aura pu y être affiché auparavant.
Nous avons donc vu plus haut qu'il était possible d'inclure des blocs de code Python
dans tes programmes HPPPL
.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 Programpour donc du codeHPPPLcomportant éventuellement des blocs en langagePythonouXcas
- Cas Programpour donc du codeXcas
- Python Programpour du codePython
- Binary assetpour des données brutes
- Jpg imagepour une imageJPEG
- Png imagepour une imagePNG
Données brutes et images peuvent ensuite être lues / écrites via la fonction Resource(nom_onglet)
.Par exemple pour charger une image
Jpg/Png
ainsi dans le calque G1
, c'est G1:= Resource("nom_onglet").
L'éditeur de programme du logiciel de connectivité reproduit les mêmes nouveautés.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
Un module Python
très intéressant à explorer pour commencer à apprendre à se connaître, c'est le module standard sys
.Il est donc au menu de bas d'écran
Cmds
, et on peut noter que le contenu listé semble très exhaustif.
Histoire d'être sûr de ne rien rater, on peut obtenir la liste intégrale des différents éléments qu'il permet d'appeler via un simple 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
.Bon,
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.9.4
sur HP Prime
ce n'est certes pas une antiquité, mais nous sommes en 2021 et les mises à jour sorties en 2020-2021 pour solutions concurrentes sont déjà passées à plus récent.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 PrimeCasio 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 PrimeCasio 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
- Micropython 1.12.0:NumWorks
- Micropython 1.12.0:NumWorks N0110
- Micropython 1.11.0:TI-Nspire CX II
- Micropython 1.9.4:HP PrimeCasio Graph 90+E / 35+E II / fx-CG50 / fx-9750/9860GIIICasio 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
- 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
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 G1répond en seulement0,449s, soit déjà légèrement plus vite qu'une!TI-Nspire CX II
- la HP Prime G2répond plus vite que son ombre, en0,171s!
Fantastique, les
HP Prime
mènent la course, et la HP Prime G2
écrase littéralement toute concurrence, bravo ! - 0,171s:HP Prime G2(32 bits : Cortex-A7/ARMv7 @528MHzPython)
- 0,449s:HP Prime G1(32 bits : ARM9/ARMv5 @400MHzPython)
- 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 @528MHzCAS)
- 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 @400MHzCAS)
- 0,171s:HP Prime G2(32 bits : Cortex-A7/ARMv7 @528MHzPython)
- 0,449s:HP Prime G1(32 bits : ARM9/ARMv5 @400MHzPython)
- 0,451s:TI-Nspire CX II(32 bits : ARM9/ARMv5 @396MHz)
- 0,794s:TI-Nspire CX(révisions A-V)
- 0,581s:NumWorks N0110(32 bits : Cortex-M7/ARMv7 @216MHz)
- 0,715s:NumWorks N0110
- 1,17s:NumWorks N0100(32 bits : Cortex-M4/ARMv7 @100MHz)
- 1,18s:TI-Nspire CX CR4+(révisions W+)
- 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 @528MHzCAS)
- 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 @400MHzCAS)
- 36,26s:TI-Nspire CX(révisions A-V)
- 42,75s:NumWorks N0110
- 53,24s:TI-Nspire CX CR4+(révisions W+)
- 0,171s:HP Prime G2(32 bits : Cortex-A7/ARMv7 @528MHzPython)
- 0,449s:HP Prime G1(32 bits : ARM9/ARMv5 @400MHzPython)
- 0,451s:TI-Nspire CX II(32 bits : ARM9/ARMv5 @396MHz)
- 0,511s:TI-Nspire CX(révisions A-V)
- 0,581s:NumWorks N0110(32 bits : Cortex-M7/ARMv7 @216MHz)
- 0,715s:NumWorks N0110
- 0,821s:TI-Nspire CX CR4+(révisions W+)
- 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 @528MHzCAS)
- 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 @400MHzCAS)
- 29,20s:TI-Nspire CX(révisions A-V)
- 42,75s:NumWorks N0110
- 45,34s:TI-Nspire CX CR4+(révisions W+)
- 0,171s:HP Prime G2(32 bits : Cortex-A7/ARMv7 @528MHzPython)
- 0,449s:HP Prime G1(32 bits : ARM9/ARMv5 @400MHzPython)
- 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 @528MHzCAS)
- 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 @400MHzCAS)
- 0,171s:HP Prime G2(32 bits : Cortex-A7/ARMv7 @528MHzPython)
- 0,307s:TI-Nspire CX II
- 0,323s:TI-Nspire CX II
- 0,449s:HP Prime G1(32 bits : ARM9/ARMv5 @400MHzPython)
- 0,451s:TI-Nspire CX II(32 bits : ARM9/ARMv5 @396MHz)
- 0,581s:NumWorks N0110(32 bits : Cortex-M7/ARMv7 @216MHz)
- 0,62s:TI-Nspire CX(révisions A-V)
- 0,67s:TI-Nspire
- 0,715s:NumWorks N0110
- 0,794s:TI-Nspire CX(révisions A-V)
- 0,99s:TI-Nspire CX CR4+(révisions W+)
- 1,17s:NumWorks N0100(32 bits : Cortex-M4/ARMv7 @100MHz)
- 1,18s:TI-Nspire CX CR4+(révisions W+)
- 1,58s:Casio Graph 90+E / fx-CG50(32 bits : SH4 @117,96MHz)
- 3,04s:Casio Graph 35+E II / fx-9750/9860GIII(32 bits : SH4 @58,98- CasioPython)
- 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 @528MHzCAS)
- 4,89s:Casio Graph 35/75+E / 35/75/95 / fx-9750/9860GII(32 bits : SH4 @29,49MHz- CasioPython)
- 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
- 11,62s:TI-Nspire CX II
- 16,05s:HP Prime G1(32 bits : ARM9/ARMv5 @400MHzCAS)
- 32,76s:Casio Graph 90+E / fx-CG50(32 bits : SH4 @117,96MHz- KhiCAS)
- 36,26s:TI-Nspire CX(révisions A-V)
- 42,75s:NumWorks N0110
- 53,24s:TI-Nspire CX CR4+(révisions W+)
- 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 @528MHzPython)
- 0,206s:TI-Nspire CX II
- 0,263s:TI-Nspire CX II
- 0,382:TI-Nspire CX II
- 0,42s:TI-Nspire CX(révisions A-V)
- 0,449s:HP Prime G1(32 bits : ARM9/ARMv5 @400MHzPython)
- 0,511s:TI-Nspire CX(révisions A-V)
- 0,57s:TI-Nspire
- 0,58s:Casio Graph 35/75+E / 35/75/95 / fx-9750/9860GII
- 0,581s:NumWorks N0110(32 bits : Cortex-M7/ARMv7 @216MHz)
- 0,59s:Casio Graph 35+E II / fx-9750/9860GIII
- 0,63s:TI-Nspire CX CR4+(révisions W+)
- 0,715s:NumWorks N0110
- 0,821s:TI-Nspire CX CR4+(révisions W+)
- 0,86s:Casio Graph 35+E II / fx-9750/9860GIII
- 1,08s:Casio Graph 90+E / fx-CG50
- 1,17s:NumWorks N0100(32 bits : Cortex-M4/ARMv7 @100MHz)
- 1,688s:Casio Graph 35/75/85/95 / fx-9750/9860GII / fx-9860G
- 4,42s:HP Prime G2(32 bits : Cortex-A7/ARMv7 @528MHzCAS)
- 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
- 11,26s:TI-83 Premium CE+TI-Python
- 16,05s:HP Prime G1(32 bits : ARM9/ARMv5 @400MHzCAS)
- 19,06s:Casio Graph 35+E II / fx-9750/9860GIII
- 22,77s:Casio Graph 90+E / fx-CG50
- 29,20s:TI-Nspire CX(révisions A-V)
- 30,85s:Casio fx-CG10/20
- 42,75s:NumWorks N0110
- 53,24s:TI-Nspire CX CR4+(révisions W+)
5) Python : Nombres flottants et performances - transfert de scripts
Go to topPoursuivons l'étude du moteur de calcul numérique du
Ce type de donnée représente les nombres non entiers sous la forme
Nous pourrions bien sûr saisir à la main le script ci-dessous, le transférer comme déjà vu entre balises
Pour cela, dans le logiciel de connectivité, il faut rajouter le ou les scripts
L'appel
L'appel
Il s'agit du standard double précision du
Puisque tout-le-monde est à égalité là-dessus, voyons donc les performances du
Nous utiliserons pour cela le script suivant, développé et utilisé pour le , petit algorithme de seuil dans le contexte d'une suite récurrente, niveau Première :
Pas de module
Donc en moyenne pour un appel de
Micropython
en question, avec cette fois-ci les nombres en virgule flottante dits flottants.Ce type de donnée représente les nombres non entiers sous la forme
$mathjax$M\times 2^{E-E_{min}}$mathjax$
, avec :- 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
Nous pourrions bien sûr saisir à la main le script ci-dessous, le transférer comme déjà vu entre balises #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]
L'appel 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 (
, et auxquels il faut bien évidemment rajouter 1 bit de signe.precm(10))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.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 , 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 G1termine en seulement0,258s, presque aussi vite qu'une!TI-Nspire CX II
- la HP Prime G2répond plus vite que tu ne relâches la touche,0,087s!
Les
À la fois parmi les solutions
HP Prime
sont vraiment extraordinaires en calcul flottant Python
et la HP Prime G2
écrase même toute concurrence de sa toute puissance, même en dopant cette dernière à l'overclocking
! À 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 @528MHzPython)
- 0,258s:HP Prime G1(32 bits : ARM9/ARMv5 @400MHzPython)
- 0,297s:TI-Nspire CX II(32 bits : ARM9/ARMv5 @396MHz)
- 0,376s:HP Prime G2(32 bits : Cortex-A7/ARMv7 @528MHzCAS)
- 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 @400MHzCAS)
- 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 @528MHzPython)
- 0,258s:HP Prime G1(32 bits : ARM9/ARMv5 @400MHzPython)
- 0,297s:TI-Nspire CX II(32 bits : ARM9/ARMv5 @396MHz)
- 0,376s:HP Prime G2(32 bits : Cortex-A7/ARMv7 @528MHzCAS)
- 0,609s:TI-Nspire CX(révisions A-V)
- 0,498s:NumWorks N0110(32 bits : Cortex-M7/ARMv7 @216MHz)
- 0,544s:NumWorks N0110
- 0,785s:NumWorks N0100(32 bits : Cortex-M4/ARMv7 @100MHz)
- 0,868s:TI-Nspire CX CR4+(révisions W+)
- 1,61s:HP Prime G1(32 bits : ARM9/ARMv5 @400MHzCAS)
- 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)
- 6,69s:NumWorks N0110
- 7,63s:TI-Nspire CX CR4+(révisions W+)
- 9,21s:Casio Graph 35+E II(32 bits : SH4 @58,98MHz)
- 0,087s:HP Prime G2(32 bits : Cortex-A7/ARMv7 @528MHzPython)
- 0,258s:HP Prime G1(32 bits : ARM9/ARMv5 @400MHzPython)
- 0,297s:TI-Nspire CX II(32 bits : ARM9/ARMv5 @396MHz)
- 0,376s:HP Prime G2(32 bits : Cortex-A7/ARMv7 @528MHzCAS)
- 0,396s:TI-Nspire CX(révisions A-V)
- 0,498s:NumWorks N0110(32 bits : Cortex-M7/ARMv7 @216MHz)
- 0,544s:NumWorks N0110
- 0,65s:TI-Nspire CX CR4+(révisions W+)
- 0,785s:NumWorks N0100(32 bits : Cortex-M4/ARMv7 @100MHz)
- 1,61s:HP Prime G1(32 bits : ARM9/ARMv5 @400MHzCAS)
- 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)
- 6,69s:NumWorks N0110
- 7,19s:TI-Nspire CX CR4+(révisions W+)
- 9,21s:Casio Graph 35+E II(32 bits : SH4 @58,98MHz)
- 0,087s:HP Prime G2(32 bits : Cortex-A7/ARMv7 @528MHzPython)
- 0,258s:HP Prime G1(32 bits : ARM9/ARMv5 @400MHzPython)
- 0,297s:TI-Nspire CX II(32 bits : ARM9/ARMv5 @396MHz)
- 0,376s:HP Prime G2(32 bits : Cortex-A7/ARMv7 @528MHzCAS)
- 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 @400MHzCAS)
- 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
- 0,087s:HP Prime G2(32 bits : Cortex-A7/ARMv7 @528MHzPython)
- 0,232s:TI-Nspire CX II
- 0,258s:HP Prime G1(32 bits : ARM9/ARMv5 @400MHzPython)
- 0,297s:TI-Nspire CX II(32 bits : ARM9/ARMv5 @396MHz)
- 0,376s:HP Prime G2(32 bits : Cortex-A7/ARMv7 @528MHzCAS)
- 0,47s:TI-Nspire
- 0,48s:TI-Nspire CX(révisions A-V)
- 0,498s:NumWorks N0110(32 bits : Cortex-M7/ARMv7 @216MHz)
- 0,544s:NumWorks N0110
- 0,609s:TI-Nspire CX(révisions A-V)
- 0,68s:TI-Nspire CX CR4+(révisions W+)
- 0,785s:NumWorks N0100(32 bits : Cortex-M4/ARMv7 @100MHz)
- 0,868s:TI-Nspire CX CR4+(révisions W+)
- 1,61s:HP Prime G1(32 bits : ARM9/ARMv5 @400MHzCAS)
- 1,909s:TI-Nspire CX II
- 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
- 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)
- 5,48s:Casio Graph 90+E / fx-CG50(32 bits : SH4 @117,96MHz- KhiCAS)
- 6,69s:NumWorks N0110
- 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)
- 7,63s:TI-Nspire CX CR4+(révisions W+)
- 15,05s:Casio fx-CG10/20(32 bits : SH4 @58,98MHz- KhiCAS)
- 0,022s:TI-Nspire CX II
- 0,087s:HP Prime G2(32 bits : Cortex-A7/ARMv7 @528MHzPython)
- 0,142s:TI-Nspire CX II
- 0,257s:TI-Nspire CX II
- 0,258s:HP Prime G1(32 bits : ARM9/ARMv5 @400MHzPython)
- 0,27s:TI-Nspire CX(révisions A-V)
- 0,376s:HP Prime G2(32 bits : Cortex-A7/ARMv7 @528MHzCAS)
- 0,38s:TI-Nspire
- 0,396s:TI-Nspire CX(révisions A-V)
- 0,498s:NumWorks N0110(32 bits : Cortex-M7/ARMv7 @216MHz)
- 0,53s:TI-Nspire CX CR4+(révisions W+)
- 0,544s:NumWorks N0110
- 0,59s:Casio Graph 35/75+E / 35/75/95 / fx-9750/9860GII
- 0,65s:TI-Nspire CX CR4+(révisions W+)
- 0,785s:NumWorks N0100(32 bits : Cortex-M4/ARMv7 @100MHz)
- 0,79s:Casio Graph 35+E II / fx-9750/9860GIII
- 1,589s:TI-Nspire CX II
- 1,61s:HP Prime G1(32 bits : ARM9/ARMv5 @400MHzCAS)
- 1,86s:Casio Graph 35+E II / fx-9750/9860GIII
- 1,876s:Casio Graph 35/75/85/95 / fx-9750/9860GII / fx-9860G
- 2,15s:Casio Graph 90+E / fx-CG50
- 2,96s:Casio Graph 35+E II / fx-9750/9860GIII
- 3,65s:Casio Graph 90+E / fx-CG50
- 3,718s:Casio fx-CG10/20
- 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)
- 4,4s:TI-83 Premium CE+TI-Python
- 6,69s:NumWorks N0110
- 7,19s:TI-Nspire CX CR4+(révisions W+)
6) Python : Mémoire tas/heap - import gc
Go to top
Les interpréteurs MicroPython
ou similaires qui tournent sur calculatrices font appel à différents types de mémoires. Le tas (heap)
stocke, à l'exécution, le contenu des objets Python
créés. Il limite donc la taille globale utilisée pour les données de ces différents objets.Nous avons justement la chance ici de disposer du module
gc
(garbage collector - ramasse miettes)
, avec plusieurs fonctions bien utiles :gc.collect()pour nettoyer leheapen supprimant les valeurs d'objetsPythonqui ne sont plus référencéesgc.mem_alloc()pour connaître la consommation duheapen octetsgc.mem_free()pour connaître l'espaceheapdisponible en octets
Exécutons donc le petit script suivant afin d'enfin découvrir la tant attendue taille de heap
Python
HP Prime
:- 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 : 24octets déjà...
- pour un entier court non nul (codable sur 31 bits + 1 bit de signe):28octets
- pour un entier long :
- 28octets
- + 4octets pour chaque groupe de 30 bits utilisé par son écriture binaire au-delà des 31 bits précédents
- pour une chaîne :
- 49octets
- + 1octet par caractère
- pour une liste :
- 64octets
- + 8octets par élément
- + les tailles de chaque élément
heap
avec plusieurs objets que nous allons faire grandir chacun son tour jusqu'à déclenchement d'une erreur, et retourner la capacité maximale que nous avons réussi à consommer.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.
Voici donc le script, issu du QCC 2020
:- 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
heap
.Pour le moment, dans le contexte de la
Autant sur
Mais la
HP Prime
la capacité heap
Python
serait bien décevante.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;
La capacité heap
maximale que l'on peut allouer dépend de la mémoire RAM
disponible, sur laquelle l'écran mémoire accessible via 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
.
La HP Prime G2
dispose pour sa part de 256 Mio
de SDRAM
. De même sur une calculatrice vide ne contenant que le script de test, on peut spécifier jusqu'à 258 Mo et quelques, restons-en à 258 Mo
(non non pas d'erreur ça rentre, puisque 256 Mio ≈ 268,5 Mo)
.En pratique la capacité
heap
reportée ici par le module gc
est d'environ 252,1 Mo
.
Encore plus simple que nous n'avions pas remarqué la dernière fois, l'application Python
dispose de réglages accessibles via Shift
Plot.
On peut y spécifier le
heap
, avec le gros avantage d'avoir ici sur le même écran une indication de la mémoire disponible.Voilà qui change complètement la façon de voir les choses, les capacités
heap
Python
des HP Prime
sont littéralement en orbite et rendent toute concurrence insignifiante ! - 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,582 Ko:NumWorks
- 18,354 Ko:TI-83 Premium CE Edition Python
- 252,1 Mo:HP Prime G2
- 15,6 Mo:HP Prime G1
- 4,100 Mo:TI-Nspire CX
- 2,068 Mo:TI-Nspire CX II
- 1,033 Mo:Casio Graph 90+E
- 101,262 Ko:Casio Graph 35+E II
- 98,928 Ko:NumWorks(firmware Omega)
- 64,954 Ko:NumWorks N0110
- 33,582 Ko:NumWorks
- 25,235 Ko:NumWorks N0110(firmware Delta)
- 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,582 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
- 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
- 98,928 Ko:NumWorks(firmware Omega)
- 64,954 Ko:NumWorks N0110(firmware Omega + appli KhiCAS)
- 33,582 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)
- 25,235 Ko:NumWorks N0110(firmware Delta)
- 23,685 Ko:TI-83 Premium CE + TI-Python
- 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 topLes interpréteurs
Tentons donc de déclencher une consommation massive de
Nous atteignons donc sur
Mais nous avons vu plus haut qu'il était possible d'appeler un script ou une fonction
Réalisons ici encore de quoi saisir et tester des capacités :
Sur
On peut atteindre
Mais c'est tout, augmenter davantage le
Ce n'est donc plus le même facteur limitant qui nous bloque, c'est maintenant autre chose qui interrompt la descente récursive.
Sur
Mais le changement d'exception se produit alors immédiatement ; on ne peut pas aller au-delà.
Encore plus simple que nous n'avions pas remarqué la dernière fois, l'application
On peut y spécifier le
D'où le classement des solutions
MicroPython
ou similaires qui tournent sur calculatrices font appel à différents types de mémoires. La pile (stack)
référence, à l'exécution, les objets Python
créés. Sa capacité limite donc le nombre d'objets Python
pouvant coexister simultanément en mémoire.Tentons 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;
Sur HP Prime G1
nous atteignons la limite initiale de 77 en allouant 40K de stack
.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.
Sur HP Prime G2
il suffit de 26K de stack
pour atteindre la limite de 99.Mais le changement d'exception se produit alors immédiatement ; on ne peut pas aller au-delà.
Encore plus simple que nous n'avions pas remarqué la dernière fois, l'application Python
dispose de réglages accessibles via Shift
Plot.
On peut y spécifier le
stack
à utiliser pour l'application. Et apparemment c'est la par défaut de 40 Ko
qui nous donne donc 77
récursions sur HP Prime G1
et 99
sur HP Prime G2
.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
- 130:TI-Nspire(Ndless + MicroPython)
- 129:NumWorks
- 126: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
- 15:TI-83 Premium CE + TI-Python
8) Python : Modules intégrés standard et propriétaires
Go to top
L'application Python
de la HP Prime
dispose selon les menus d'une formidable collection de modules importables standard ou équivalents :- builtins
- array
- cmath
- gc
- linalg, un module destiné à remplacer le standardnumpy.linalg
- math
- matplotl, un module destiné à remplacer le module standard de tracé dans un repère,matplotlib.pyplot
- micropython
- sys
- ucollections
- uerrno
- uhashlib
- uio
- urandom
- ure
- ustruct
- utimeq
Histoire d'être sûr de ne rien rater on peut également appeler help("modules") ; mais non c'est bon, tout semble bien être au menu.Donc pas moins de 17 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 | ✓ ✓ . . ✓ ✓ . ✓ ✓ ✓ . ✓ . + ✓ . + ✓ . . ✓ ✓ . ✓ ✓ . ✓ . . 17 | ✓ ✓ . ✓ ✓ ✓ . . ✓ . . . . . ✓ . . ✓ . ✓ ✓ . ✓ . ✓ ✓ . . . 13 | ✓ ✓ . . ✓ . . . ✓ . . . . . ✓ . . ✓ . . . . . . ✓ . . . . 7 | ✓ . ✓ . ✓ ✓ ✓ ✓ ✓ ✓ ✓ ✓ ✓ + ✓ . ✓ ✓ ✓ ✓ ✓ ✓ . ✓ ✓ . . ✓ ✓ 23 | ✓ ✓ . . ✓ . . . ✓ . . . . . ✓ . . ✓ . . ✓ . . . ✓ . . . . 8 | ✓ . . . ✓ . . . . . . . . . ✓ ✓ ✓ ✓ . ✓ ✓ . . . . ✓ . ✓ . 10 | ✓ . ✓ . ✓ ✓ ✓ . ✓ ✓ ✓ ✓ ✓ + ✓ . ✓ ✓ ✓ ✓ ✓ ✓ . ✓ ✓ . ✓ ✓ ✓ 23 |
Légende:
La
HP Prime
compte donc parmi les solutions Python
offrant la plus large collection de modules standard ! - 17modules :HP Prime
- 16modules :TI-Nspire CX II
- 9modules :NumWorks
- 8modules :TI-83 Premium CE Edition Python
- 6modules :Casio Graph 90+E / 35+E II
- 17modules :HP PrimeTI-Nspire CX II
- 10modules :TI-83 Premium CE Edition Python / TI-84 Plus CE Python Edition
- 9modules :NumWorks
- 8modules :TI-83 Premium CE + TI-Python
- 6modules :Casio Graph 90+E / 35+E II / fx-CG50 / fx-9750/9860GIII
- 23modules :TI-Nspire CX / CX IINumWorks N0110
- 17modules :HP PrimeTI-Nspire CX II
- 13modules :TI-83 Premium CE + TI-Python
- 10modules :NumWorksTI-83 Premium CE Edition Python / TI-84 Plus CE Python Edition
- 9modules :NumWorks
- 8modules :Casio Graph 35/75+E / 35+E II / fx-9750GII/GIII / fx-9860G/GII/GIII(appli CasioPython)TI-83 Premium CE + TI-Python
- 7modules :TI-Nspire(Ndless + micropython)
- 6modules :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é, ...)
Pour cela nous avons le module unique
hpprime
que nous allons découvrir ou redécouvrir de suite.D'autres modules spécifiques sont également disponibles en provenance du développement de
Xcas
:- aritpour faire de l'arithmétique
- graphic, un module de tracé par pixels
- caspour appeler le moteurCAS
9) Python : Appels HPPPL / CAS - import hpprime + import cas
Go to top
Le module hpprime
est donc un module Python
propriétaire dédié à la HP Prime
.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
.
Et bien l'inverse est également possible grâce à la fonction eval("...")
. La fonction eval()
permet d'évaluer l'expression fournie dans le contexte HPPPL
et d'en retourner le résultat.
C'est maintenant 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)")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)")')
Mais c'est un peu long et donc pénible à saisir, non ?Et bien justement, nous avons le module
cas
qui permet d'appeler directement le moteur CAS
grâce aux fonctions caseval("...")
, xcas("...")
et eval_expr("...")
:- Code: Select all
cas.caseval("int(ln(x),x)")
cas.xcas("int(ln(x),x)")
cas.eval_expr("int(ln(x),x)")
Pas de différence entre ces 3 fonctions, tu as donc le choix selon tes habitudes.
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 |
On pouvait reprocher aux solutions
Sur
Enfin de quoi faire du
Python
concurrentes leur absence d'intégration, le Python
tournant en vase clos dans son coin sans interaction avec le reste de l'environnement mathématique de la calculatrice, ou avec très peu d'interactions.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 ! - 5points :HP Prime
- 3points :TI-Nspire CX II
- 1point :TI-83 Premium CE Edition Python
- 0point :NumWorksCasio Graph 90+E / 35+E II
- 5points :HP Prime
- 3points :TI-Nspire CX II
- 1point :TI-83 Premium CE Edition Python / TI-84 Plus CE Python Edition
- 0point :NumWorksTI-83 Premium CE + TI-PythonCasio Graph 90+E / 35+E II / fx-CG50 / fx-9750/9860GIII
- 5points :HP Prime
- 4points :NumWorks N0110TI-Nspire CX / CX II
- 3points :TI-Nspire CX II
- 1point :TI-83 Premium CE Edition Python / TI-84 Plus CE Python Edition
- 0point :NumWorksTI-Nspire(Ndless + micropython)Casio Graph 90+E / 35+E II / fx-CG50 / fx-9750/9860GIIITI-83 Premium CE + TI-PythonCasio 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
Le module hpprime
contient également de quoi permettre à tes scripts de tester les appuis sur les touches du clavier.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 des touches silencieuses : les modificateurs
Shift
etALPHA
(elle ne permet toutefois pas d'identifier la toucheOn
, l'arrêt du script étant immédiat et prioritaire)
Varsil faut faire
hpprime.keyboard() & (1 << 15) car ce serait la 15ème touche clavier en partant du coin en haut à gauche.L'opérateur
&& affiché à l'écran d'aide en question étant une erreur.Afin de t'aider, voici donc la carte clavier en ce sens :
Apps 0 | Symb 1 | ↑ 2 | Help 3 | Esc 4 | |
Plot 6 | ← 7 | → 8 | View 9 | ||
⌂ 5 | Num 11 | ↓ 12 | Menu 13 | CAS 10 | |
Vars 14 | 🧰 15 | □/□ 16 | xtθn 17 | ab/c 18 | ⌫ 19 |
x^y 20 | SIN 21 | COS 22 | TAN 23 | LN 24 | LOG 25 |
x² 26 | +/- 27 | () 28 | , 29 | Enter 30 | |
EEX 31 | 7 32 | 8 33 | 9 34 | ÷ 35 | |
ALPHA 36 | 4 37 | 5 38 | 6 39 | × 40 | |
Shift 41 | 1 42 | 2 43 | 3 44 | - 45 | |
On 46 | 0 47 | . 48 | _ 49 | + 50 | |
À 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/offest 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 | ✓ ✓ . ✓ ✓ ✓ 5 | . . . . . . 0 | . . . . . . 0 | ✓ . . . . . 1 | . . . . . . 0 | ✓ ✓ ✓ ✓ ✓ . 5 | ✓ ✓ ✓ . . . 3 |
La
HP Prime
t'offre clairement la meilleure solution Python
de gestion du clavier, de quoi en adapter intégralement le comportement pour des interfaces et jeux intuitifs et réactifs ! - 5points :HP PrimeNumWorks
- 3points :TI-Nspire CX II
- 2points :TI-83 Premium CE Edition Python
- 0point :Casio Graph 90+E / 35+E II
- 5points :HP PrimeNumWorks
- 3points :TI-Nspire CX II
- 2points :TI-83 Premium CE Edition Python / TI-84 Plus CE Python Edition
- 0point :Casio Graph 90+E / 35+E II / fx-CG50 / fx-9750/9860GIIITI-83 Premium CE + TI-Python
- 5points :HP PrimeNumWorks
- 3points :TI-Nspire CX IINumWorks N0110
- 2points :TI-83 Premium CE Edition Python / TI-84 Plus CE Python Edition
- 1point :TI-Nspire CX / CX II
- 0point :Casio Graph 90+E / 35+E II / fx-CG50 / fx-9750/9860GIIICasio 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
Le module cas
offre lui aussi une fonction get_key()
, mais nous n'allons pas être bien longs à son sujet cette fois-ci. En effet elle ne semble pas fonctionnelle à ce jour ; elle renvoie immédiatement 0, indépendamment du nombre de touches que tu peux presser ou pas.
Mais le clavier n'est pas la seule entrée. La HP Prime
dispose également d'un écran tactile, et ce dernier est lui aussi géré en Python
, grâce à la fonction 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.Mais ici encore énorme avantage à la 
Avec les bons calculs, de quoi donc détecter également en
HP Prime
qui te retourne les coordonnées de non pas 1 pointeur mais 2 pointeurs ! 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 + import graphic
Go to topLe module
Nous y trouvons notamment la fonction
Voici le détail des fonctions disponibles dans ce contexte :
L'écran
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
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 :
Cette pièce de précision te retournera d'un simple
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
Voici en conséquence de quoi récupérer automatiquement les fonctions de lecture et écriture des pixels sur l'ensemble des plateformes
Voilà, d'un simple
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
Pour savoir si un pixel est accessible en écriture, nous tenterons d'inverser sa couleur :
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
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.
Voici donc les fonctions principales utilisant tout ça :
L'appel
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.
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
Dans la plupart des solutions
Ce n'est pas ce qui a été retenu sur
Les modules graphiques concurrents à avoir fait ce choix de codage de couleur sont peu nombreux :
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.
Un appel
Vérifions cela, pour un script universel prévoyons une fonction de conversion de couleur :
Voici des fonctions intermédiaires pour tracer des lignes verticales ou horizontales :
Et voici enfin de quoi tracer une mire :
L'ensemble de la concurrence
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
Poursuivons maintenant notre exploration des fonctions de tracé par pixels du module
Avec cette version nous disposons donc également d'un deuxième module de tracée par pixels,
La présence de fonctions
En terme de primitives graphiques, cette bibliothèque semble a priori comparable :
Intéressons-nous maintenant aux performances. Pour illustrer l'importance d'avoir une bonne bibliothèque graphique ainsi que du
Il est compatible avec l'interface
Commençons par les et compatibles. Ici nous avons du est rudimentaire, ne fournissant rien d'autre que de quoi allumer un pixel.
Les lignes doivent donc être tracées pixel par pixel par une fonction de remplacement que voici :
Cela se paie très cher en performances, l'animation met plus d'un quart d'heure à boucler,.
Les n'ont pour leur part pas de
Toutefois leur bibliothèque 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 , comme quoi ça compte.
Les extrêmement pauvre, presque autant que celle de . Tout ce que a en plus, c'est de quoi tracer des rectangles ce qui ne nous aidera pas ici.
En conséquence une animation encore bien lente bouclant en, avec des clignotements inesthétiques.
Les peuvent toutefois être améliorées par installation du . Dans ce cas la bibliothèque se voit rajoutée une fonction de tracé de lignes, qui change complètement la donne. L'animation ne met plus que à boucler.
Sur on peut alors également installer l'application qui dispose de son propre interpréteur . Mêmes avantages ici. .
dispose d'une fonction
Sur on a bien du . Seulement .
Mais il semble par contre y avoir ici de l'
Si on passe sous ici apparemment on a toujours le
Voici enfin la !
Avec la
On peut également modifier le script de test pour appeler sur
Les performances sont alors nettement supérieures, la
Et la
Mais comme il n'y a ici pas de
Classons donc les solutions graphiques
hpprime
comprend également des fonctions de tracé par pixels. Pour référence, c'est donc l'équivalent chez la concurrence des modules :- 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)
Nous y trouvons notamment la fonction 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 dudouble bufferingmais dumultiple buffering
Voici le détail des fonctions disponibles dans ce contexte :
blit(numero_calque_1, x, y, numero_calque_2)pour copier un calqueG0àG9sur 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 calquesG1àG9(non valide pour l'écranG0)grobw(numer_calque)récupérer les dimensions d'un calqueG0àG9
hpprime
ne semble pas fournir de quoi lire la valeur d'un pixel.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:ouCasio Graph 90+E / fx-CG50Graph 35+E II / fx-9750/9860GIII
- 2:ouTI-83 Premium CETI-84 Plus CE
- 3:HP Prime
- 4:avecCasio Graph 35+E/USB / 75/85/95 / fx-9750/9860GII / fx-9860G
- 5:+TI-Nspire(nécessiteNdless)
- 6:+ en modeTI-NspireMicroPython(nécessiteNdless)
- 7:+ en mode de compatibilitéTI-NspirePython(nécessiteNdless)
- 8:+ en modeNumWorksMicroPython
- 9:+ en mode de compatibilitéNumWorksPython
- 10:+ en mode de compatibilitéCasio Graph 90+E / fx-CG10/20/50Python
- 11:+ en mode de compatibilitéCasio Graph 35+E II / fx-9750/9860GIIIPython
- 12:en modeHP PrimeCAS
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
. Nous allons parcourir l'écran, en diagonale, en tentant de lire et modifier chaque pixel rencontré.Scratch
ou module Python turtle
)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
L'appel 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).C'est-à-dire qu'en
Python
sur HP Prime
nous avons le privilège de contrôler intégralement l'écran ! 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=76800pixels en écriture :HP Prime
- 384×192=73728pixels en écriture :Casio Graph 90+E
- 320×222=71040pixels en écriture :NumWorks
- 318×212=67416pixels en écriture :TI-Nspire CX II
- 321×210=67410pixels en écriture sur321×241=77361pixels en lecture :TI-83 Premium CE Edition Python
- 128×64=8192pixels en écriture :Casio Graph 35+E II
- 320×240=76800pixels en écriture :HP Prime
- 384×192=73728pixels en écriture :Casio Graph 90+E
- 320×222=71040pixels en écriture :NumWorksTI-Nspire CXNumWorks N0110
- 318×212=67416pixels en écriture :TI-Nspire CX II
- 321×210=67410pixels en écriture sur321×241=77361pixels en lecture :TI-83 Premium CE Edition Python
- 128×64=8192pixels en écriture :Casio Graph 35+E II
- 320×240=76800pixels en écriture :HP Prime
- 384×192=73728pixels en écriture :Casio Graph 90+E
- 320×222=71040pixels en écriture :NumWorks
- 318×212=67416pixels en écriture :TI-Nspire CX II
- 321×210=67410pixels en écriture sur321×241=77361pixels en lecture :TI-83 Premium CE Edition Python / TI-84 Plus CE Python Edition
- 128×64=8192pixels en écriture :Casio Graph 35+E II
- 0×0=0pixels en lecture :TI-83 Premium CE + TI-Python
- 320×240=76800pixels en écriture :HP Prime
- 384×192=73728pixels en écriture :Casio Graph 90+E
- 320×222=71040pixels en écriture :NumWorksTI-Nspire CX / CX IINumWorks N0110
- 318×212=67416pixels en écriture :TI-Nspire CX II
- 321×210=67410pixels en écriture sur321×241=77361pixels en lecture :TI-83 Premium CE Edition Python / TI-84 Plus CE Python Edition
- 128×64=8192pixels en écriture :Casio Graph 35+E II
- 0×0=0pixels en lecture :TI-83 Premium CE + TI-PythonTI-83 Premium CE + TI-PythonCasio 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
Un appel 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
- ...
HP Prime
on envoie donc directement au contrôleur écran une valeur codée sur 24 bits, ce qui en théorie permet 224=16777216 couleurs différentes ! 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
Effectivement l'affichage des scripts
Python
est fabuleux, un dégradé jusqu'au noir dans chaque teinte ne présentant aucune saccade.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.
Poursuivons maintenant notre exploration des fonctions de tracé par pixels du module hpprime
. Nous avons donc également un bel éventail de fonctions de tracé :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 les angles en degrésline(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 remplir un rectangletextout(numero_calque, x, y, texte, couleur)pour écrire une chaîne de caractères
Avec cette version nous disposons donc également d'un deuxième module de tracée par pixels, graphic
, issu pour sa part du développement de Xcas
.La présence de fonctions
show()
et show_screen()
suggère un fonctionnement en double buffering
, mais en pratique non : les affichages sont immédiats, et l'appel à ces fonctions semble inutile.
En terme de primitives graphiques, cette bibliothèque semble a priori comparable :clear_screen(couleur)pour remplir l'écran de la couleur indiquéedraw_arc(x, y, rayon_x, rayon_y, angle1, angle2, couleur)pour tracer un arc d'ellipse(angles en degrés)draw_circle(x, y, rayon, couleur)pour tracer un arc de cercledraw_filled_arc(x, y, rayon_x, rayon_y, angle1, angle2, couleur)pour remplir un secteur d'ellipse(angles en degrés)draw_filled_circle(x, y, rayon, couleur)pour remplir un cercledraw_filled_polygon([[x1, y1], [x2, y2], ..., [xn, yn]], couleur)pour remplir un polygonedraw_filled_rectangle(x, y, largeur, hauteur, couleur)oufill_rectangle(x, y, largeur, hauteur, couleur)pour remplir un rectangledraw_line(x1, y1, x2, y2, couleur)pour tracer une lignedraw_pixel(x, y, couleur)ouset_pixel(x, y, couleur)pour allumer un pixeldraw_polygon([[x1, y1], [x2, y2], ..., [xn, yn]], couleur)pour tracer un polygonedraw_rectangle(x, y, largeur, hauteur, couleur)pour tracer un rectangledraw_string(x, y, texte, couleur1, couleur2)pour écrire une chaîne de caractères
Tu as même une fonction
À y regarder,, avec la gestion des ellipses et les nombreuses possibilités de remplissage ne nécessitant ici qu'un unique appel de fonction !
get_pixel(x, y) pour remplacer les appels à rallonge int(hpprime.eval("get_pixel(" + str(x) + "," + str(y) + ")")) vus plus haut.À y regarder,
graphic
est une bibliothèque graphique beaucoup plus étendue que hpprime
C'est vraiment juste dommage pour le
double buffering
non fonctionnel.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)
Attention, pour des raisons de limitation de durée sur la plateforme
gfycat
, les deux prochaines vidéos sont accélérées d'un facteur de 1,26
dans leur version intégrée, et 20
si jouées de façon indépendante.Casio Graph 90+E
double buffering
mais la bibliothèque de tracé casioplot
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
TI-83 Premium CE Edition Python
double buffering
. Cela déclenche ici des clignotements intempestifs, les états intermédiaires de l'animation avec les effacements de lignes devenant visibles. Le matériel est également très inférieur.Toutefois leur bibliothèque
ti_graphics
12min36
Dans sa version intégrée la prochaine vidéo est à vitesse réelle. Si ouverte de façon indépendante, elle sera accélérée d'un facteur de
8
.NumWorks N0110
et compatibles n'ont pas non plus de double buffering
, et souffrent d'une bibliothèque graphique kandinsky
Casio
kandinsky
En conséquence une animation encore bien lente bouclant en
5min14
À compter de maintenant toutes les vidéos sont à vitesse réelle, aussi bien dans leur version intégrée que si ouvertes indépendamment.
NumWorks
firmware
tiers Omega
kandinsky
7,28s
NumWorks N0110
KhiCAS
Micropython
avec sa propre bibliothèque graphics
9,08s
graphic
show_screen()
suggérant une possibilité de double buffering
, mais cela ne semble pas du tout marcher en pratique.TI-Nspire CX II
double buffering
ainsi que la très large bibliothèque graphique ti_draw
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.KhiCAS
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
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
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
! HP Prime
non plus la bibliothèque hpprime
, mais la bibliothèque graphic
.Les performances sont alors nettement supérieures, la
HP Prime G1
ne met plus que 1,32s
.HP Prime G2
seulement 0,48s
.Mais comme il n'y a ici pas de
double buffering
l'animation n'est pas jouée de façon propre, et graphic
n'est donc à ce jour pas forcément un meilleur choix que hpprime
en tant que module de tracé par pixels.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 | ✓ ✓ ✓ ✓ ✓ ✓ ✓ 7 | . . . . . . . 0 | ✓ . . . . ✓ ✓ 3 | ✓ ✓ ✓ ✓ ✓ ✓ . 6 | . . . . . . . 0 | ✓ ✓ ✓ . . . . 3 | ✓ ✓ ✓ ✓ ✓ . . 5 |
La 
HP Prime
cumule ici encore tous les avantages : une bibliothèque graphique ambitieuse tournant sur un matériel correctement dimensionné. De formidables possibilités de tracés par pixels en conséquence avec des projets qui pourront aller bien au-delà de notre très modeste animation ! - 7points :HP Prime
- 6points :TI-Nspire CX II
- 5points :TI-83 Premium CE Edition Python
- 2points :NumWorksCasio Graph 90+E / 35+E II
- 7points :HP Prime
- 6points :TI-Nspire CX II
- 5points :TI-83 Premium CE Edition Python / TI-84 Plus CE Python Edition
- 2points :NumWorksCasio Graph 90+E / 35+E II / fx-CG50 / fx-9750/9860GIII
- 0points :TI-83 Premium CE + TI-Python
- 7points :HP Prime
- 6points :TI-Nspire CX IITI-Nspire CX / CX II
- 5points :TI-83 Premium CE Edition Python / TI-84 Plus CE Python EditionTI-Nspire CXNumWorks N0110
- 3points :NumWorks(Omega)TI-Nspire(Ndless + micropython)
- 2points :NumWorksCasio Graph 90+E / 35+E II / fx-CG50 / fx-9750/9860GIII
- 0point :TI-83 Premium CE + TI-PythonTI-83 Premium CE + TI-PythonCasio 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 + import matplotl
Go to top
Le module hpprime
fournit également des fonctions de tracé dans un repère. 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().
Pour le moment c'est assez 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.On pourrait penser pour cela faire appel au module
matplotl
apporté par Xcas
...Mais en pratique nous n'arrivons à ce jour pas à obtenir le moindre tracé avec ce module, bien que n'oubliant pas d'appeler sa fonction
show()
et la commande pour geler l'écran hpprime.eval("wait()").13) Python : Bilan modules
Go to topNous avons donc comparé plus haut l'offre de modules
Pour comparer la richesse de diverses implémentations
Tentons une autre approche incluant cette fois-ci les modules propriétaires avec le script suivant, initialement conçu pour notre classement
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
Python
standard.Pour 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 première entrée son classement n'en est pas moins honorable, et devrait progresser si le développement se poursuit à la même vitesse :- 1915fonctions :TI-83 Premium CE Edition Python
- 1065fonctions :HP Prime
- 1017fonctions :TI-Nspire CX II
- 547fonctions :NumWorks
- 443fonctions :Casio Graph 90+E / 35+E II
- 2495fonctions :TI-83 Premium CE Edition Python / TI-84 Plus CE Python Edition
- 2160fonctions :TI-Nspire CX II
- 1065fonctions :HP Prime
- 547fonctions :NumWorks
- 443fonctions :Casio Graph 90+E / 35+E II / fx-CG50 / fx-9750/9860GIII
- 405fonctions :TI-83 Premium CE + TI-Python
- 2495fonctions :TI-83 Premium CE Edition Python / TI-84 Plus CE Python Edition
- 2160fonctions :TI-Nspire CX II
- 1387fonctions :NumWorks N0110
- 1284fonctions :TI-Nspire CX / CX II
- 1065fonctions :HP Prime
- 602fonctions :TI-83 Premium CE + TI-Python
- 590fonctions :NumWorks(Omega)
- 547fonctions :NumWorks
- 464fonctions :Casio Graph 35/75+E / 35+E II / fx-9750GII/GIII / fx-9860G/GII/GIII(appli CasioPython)
- 429fonctions :TI-Nspire(Ndless + micropython)
- 405fonctions :TI-83 Premium CE + TI-Python
Conclusion
Go to topClairement une mise à jour
Énormément d'idées ont été mises en œuvre depuis deux ans et demi.
La solution
Notons l'extraordinaire révolution du développement
N'oublions pas les incroyables possibilités d'interactions bidirectionnelles entre les différents langages et environnements
Outre sa puissance et son caractère exhaustif, et même si l'on peut encore reprocher son interface à l'application
Si l'on ne devait retenir qu'une seule chose ce serait donc l'intégration du
HP Prime
colossale et historique, la plus importante mise à jour logicielle dans toute l'histoire de la calculatrice HP Prime
, merci Cyrille
et Tim
! Énormément d'idées ont été mises en œuvre depuis deux ans et demi.
La solution
Python
est :- 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 !
Python
novatrices et exclusives à ce jour ! Notons l'extraordinaire révolution du développement
HPPPL
, ainsi que l'ouverture aux périphériques USB
, avec peut-être bientôt la programmation et le pilotage de cartes BBC micro:bit
ou autres depuis ta HP Prime G2
! 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 ! On pouvait jusqu'à présent reprocher de façon générale à la concurrence son manque d'intégration du
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
. L'application Python
arrivait comme un cheveu sur la soupe, tournant totalement dans son coin avec très peu d'interactions possibles avec le reste de l'environnement mathématique de la calculatrice quand ce n'était pas totalement impossible.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 ! Maintenant que la crise avec les institutions néerlandaises est passée, espérons que
Cette mise à jour bien que formidable n'est pas dénuée de défauts, et bénéficie selon nous d'une finition nettement inférieure à celle des mises à jour précédentes : davantage de
C'est un peu normal puisqu'il s'agit comme nous avons vu dès le début, d'une version bêta que seul le calendrier extrêmement contraint a imposé en tant que version de production. Il serait inacceptable que les utilisateurs aient de nouveau à attendre 3 ans pour la finition.
Hewlett Packard
ne va pas se dépêcher de mettre à nouveau le développement de la HP Prime
au point mort. Cette mise à jour bien que formidable n'est pas dénuée de défauts, et bénéficie selon nous d'une finition nettement inférieure à celle des mises à jour précédentes : davantage de
bugs
connus non encore corrigés, ou de nouvelles fonctionnalités non encore pleinement fonctionnelles.C'est un peu normal puisqu'il s'agit comme nous avons vu dès le début, d'une version bêta que seul le calendrier extrêmement contraint a imposé en tant que version de production. Il serait inacceptable que les utilisateurs aient de nouveau à attendre 3 ans pour la finition.
Téléchargements
Go to top- mise à jour pour HP Prime 2.1.14575
- logiciel de connectivité HP Prime:
- 2.1.14425pour(pleinement fonctionnel + sans expiration)
- 2.1.14575pour(défectueux + expire le28 juin 2021)
- logiciel/appli d'émulation HP Prime:
- 2.1.14575pour(expire le28 juin 2021)
- 2.1.14425pour(sans expiration)
- appli gratuite 2.1.14346pour
- appli complète 2.1.14346pour
- 2.1.14288pour
Source
:
