Test-découverte TI-82 Advanced Edition Python - rentrée 2021

→ **MyCalcs** profile · by **critor** » 27 Jun 2021, 06:20

La réforme du lycée n'a pas que des avantages, loin de là. Elle a notamment un effet très pervers qui ne semble pas avoir été bien anticipé. Les élèves rentrant en Seconde ne sont plus sûrs de poursuivre l'étude de matières scientifiques en Première avec les 3 spécialités désormais à la carte, et la même incertitude se retrouve lors du passage en Terminale avec l'abandon d'une des 3 spécialités.

Or, les calculatrices graphiques couleur programmables en Python coûtaient jusqu'à présent au minimum dans les 80€, cette combinaison de capacités ne concernant que les modèles de milieu de gamme et haut de gamme. Acheter une calculatrice graphique dans les 80€ pour peut-être l'utiliser juste une année dans le pire des cas, les familles se montrent de plus en plus frileuses et préfèrent bien souvent remettre cet investissement à plus tard.

Résultat au lieu d'avoir pu bénéficier comme avant d'une prise en main progressive tout le long de l'année de Seconde, l'élève obtient sa calculatrice en Première ou en Terminale soit à la veille des épreuves écrites du BAC et se voit ainsi réduit à devoir la prendre en main rapidement au dernier moment (rappelons que les épreuves scientifiques du BAC c'est désormais très tôt dans l'année scolaire, de janvier à mars et ce aussi bien en Première qu'en Terminale). Ce sont parfois des enseignants qui n'osent même plus demander l'achat d'une calculatrice graphique en Seconde à cause des prix pratiqués. Bien évidemment tout ceci impacte négativement la maîtrise de la calculatrice graphique, seul outil numérique autorisé aux épreuves scientifiques du BAC, et donc forcément d'une façon ou d'une autre les résultats.

Mais heureusement le constructeur Texas Instruments se propose de fournir une réponse à cette problématique pour cette rentrée 2021 avec son nouveau modèle TI-82 Advanced Edition Python.

Un modèle trouvable à des prix absolument formidablement bas : moins de 60€ chez les bonnes boutiques (voir les prix ici, sans oublier les prix en achats groupés encore plus bas chez Calcuso par exemple, ou Jarrety ou TSP).

Maintenant bien sûr, le prix ne fait pas tout. Nous avons la chance de disposer aujourd'hui d'un échantillon dans le cadre de l'offre de test lancée le mois dernier par le constructeur.

Nous allons donc le tester devant toi. Nous nous attendions a priori à ce que la TI-82 Advanced Edition Python de rentrée 2021 soit une version allégée de la TI-83 Premium CE Edition Python de rentrée 2019, mais reste à savoir jusqu'à quel point. Car pour permettre et justifier une telle baisse de prix, il doit y avoir des différences matérielles et même logicielles. Donc pour faire simple, nous déroulerons ce test en comparant ces deux modèles.

En conclusion, nous évoquerons le positionnement de ce modèle par rapport à la concurrence.

Pour référence, dans ce test nous évoquerons d'autres modèles Texas Instruments :

TI-82 Advanced (rentrée 2015)
TI-83 Premium CE (rentrée 2015)
TI-83 Premium CE Edition Python (rentrée 2019)

Sommaire :

Emballage, ouverture et contenu
Boîtier et mesures
1^er allumage : écran et versions
Mémoires et persistance données
Fonctionnalités hors applications
Applications intégrées
Application Python82
Mode examen
Matériel
Conclusion et concurrence

A) Emballage, ouverture et contenu

Go to top

Il n'y a pas que Casio qui passe aux emballages carton écologiques pour cette rentrée 2021, Texas Instruments également avec la TI-82 Advanced Edition Python.

On pourrait certes se demander si ce ne serait pas juste un emballage exceptionnel réalisé pour expédition aux enseignants inscrits à l'offre de test.

Mais la finition de l'emballage nous permet ici d'exclure toute réalisation à la va-vite. Notons en effet les visuels colorés et soignés même si chacun est libre de son appréciation, mais surtout de façon indiscutable le code barre qui est bel et bien présent pour un passage en caisse :

Enfin fini donc les emballages historiques à coque blister rigide très difficiles à ouvrir proprement, quasiment impossibles à réutiliser une fois ouverts, pénibles et encombrants à ranger, et n'ayant donc dans la plupart des cas que la poubelle comme seule destination possible après ouverture !

Les TI-Collège Plus et TI-83 Premium CE Edition Python devraient elles aussi bénéficier de nouveaux emballages similaires pour la rentrée 2021. La TI-82 Advanced également, cet ancien modèle restant en effet produit et commercialisé. La TI-82 Advanced Edition Python n'est donc pas son successeur, mais bel et bien une toute nouvelle référence.

Mais la disparition de la coque blister avec le passage au carton intégral ne constitue pas le seul avantage écologique du nouvel emballage. Il est aussi de dimensions bien plus restreintes, ce qui permet d'optimiser également le transport ainsi que le stockage. En effet l'emballage blister de la TI-82 Advanced d'apparence similaire sortie pour la rentrée 2015 occupait en surface 27,2 × 19,2 cm². Selon notre pied à coulisse numérique, le nouvel emballage ne fait plus ici que 20,2 × 11,2 cm², soit une réduction absolument fantastique de plus de 55% !

Tu te rends compte ? Formidable, l'emballage de la TI-82 Advanced Edition Python prend moins de place qu'une TI-92 !

Quant à l'épaisseur, elle est maintenant de 4,92 cm.

Ne te faisons pas languir plus longtemps ; ouvrons la boîte. Le contenu de l'emballage comprend :

la calculatrice, très soigneusement protégée dans une pochette de papier bulle
le guide de prise en main en Français
4 piles AAA maxell
le câble USB mini-B ↔ USB A pour connexion à un ordinateur
le câble USB mini-B ↔ USB mini-A pour connexion à une autre calculatrice Texas Instruments
un numéro de licence pour une utilisation de 3 ans du logiciel d'émulation TI-SmartView CE dans sa déclinaison TI-83 Premium CE Edition Python, suffisant donc pour une scolarité au lycée

Ce numéro de licence inclus à ne surtout pas jeter/égarer donc, est une autre formidable nouveauté Texas Instruments de cette rentrée 2021, réservé jusqu'à présent aux seuls achats de modèles enseignants. Désormais tous les élèves pourront donc également en profiter, et notons qu'il concernera également les TI-83 Premium CE Edition Python vendues sous le nouvel emballage carton.

Sont également incluses ici 2 feuilles volantes à destination des enseignants bénéficiaires dans le cadre de cet offre de test :

L'une d'elles présente les caractéristiques de la TI-82 Advanced Edition Python, indique une disponibilité d'ici la rentrée 2021 et annonce très fièrement "La calculatrice pour initier tous les élèves de Seconde à la programmation Python en couleur" ; nous allons voir cela.
L'autre réexplique les conditions de l'offre : il ne s'agit pas d'un don/cadeau, mais d'un prêt à durée indéterminée. L'échantillon reste la propriété de Texas Instruments et doit être retourné sur demande du constructeur.

En effet nous avons régulièrement constaté non sans amertume ces dernières années, qu'à chaque fois que Texas Instruments lançait une offre de test de ce genre, ou bien proposait des calculatrices à tarif spécial enseignants, nombre d'entre elles se retrouvaient systématiquement à la revente en ligne dans les jours et semaines suivant, et bien évidemment à plein tarif à la différence.

La dernière offre de test a concerné le lancement de la TI-83 Premium CE pour la rentrée 2015, et fut hélas concernée par ces écarts. À l'époque les échantillons venaient avec une étiquette les identifiant en tant que tels, mais il suffisait bêtement de la décoller.

Des comportements très regrettables et surtout nuisant à l'ensemble du corps enseignant, remettant en effet les offres en question, conduisant à la raréfaction dans le cas des offres de test (la précédente remontant donc à 6 ans...), ainsi qu'à des tarifs enseignants de moins en moins intéressants.

B) Boîtier et mesures

Go to top

Restons un tout petit moment sur la problématique des enseignants qui se dépêchent de revendre leurs échantillons. Cette fois-ci Texas Instruments s'est montré beaucoup plus malin.

En effet les échantillons de TI-82 Advanced Edition Python distribués ici sont clairement identifiées sur leur tranche latérale gauche par une inscription "TI PROPERTY-NOT FOR SALE". Une inscription qui ici est littéralement gravée dans le boîtier de la calculatrice ; elle est donc là pour toujours, félicitations TI !

Dans sa forme, la gravure nous fait penser à la façon de faire de Calcuso, le distributeur proposant à l'achat la personnalisation de ta calculatrice graphique par gravure laser d'un message au choix, pour un supplément de 3,95€. Mais en réalité non, la gravure a directement été effectuée en aval de la chaîne d'assemblage en usine.

La TI-82 Advanced de rentrée 2015 utilisait un boîtier dérivé de celui de la TI-84 Plus, modèle lancé en 2004.

La TI-82 Advanced Edition Python utilise toujours un boîtier de type TI-84 Plus, mais avec des différences au niveau du cadre de l'écran, ce dernier étant en effet maintenant couleur. Plus précisément pour sa face avant, la TI-82 Advanced Edition Python réutilise et modifie très légèrement le boîtier de la TI-84 Plus C Silver Edition, modèle couleur lancé pour la rentrée 2013.

Bien évidemment parmi les quelques modifications apportées au boîtier original, on retrouve celles déjà effectuées sur la tranche supérieure pour la TI-82 Advanced de 2015, le port série historique étant en effet remplacé par une diode examen.

Bref, il faut donc s'attendre aux mêmes dimensions. De façon générale nous préférons faire les mesures nous-mêmes plutôt que de recopier bêtement celles des constructeurs comme d'autres sites. Surtout que les constructeurs ne communiquent pas leurs protocoles de mesures, que ces derniers peuvent varier d'un constructeur à un autre (surtout que chacun a tendance à choisir le protocole qui arrange la mesure dans le sens souhaité), ce qui rend alors toute comparaison non pertinente.

Nous écartons donc notre pied à coulisse numérique jusqu'à ce que la calculatrice puisse le traverser sans accrochage selon chacune de ses 3 dimensions. Sans surprise c'est donc pareil que tous les autres modèles à boîtier de type TI-84 Plus :

avec couvercle : 19,26 × 8,93 × 2,70 cm³
sans couvercle : 19,04 × 8,51 × 2,36 cm³

Pour le poids de la TI-82 Advanced Edition Python, nous réalisons également 2 mesures :

avec piles et couvercle : 272 g (contre 275 g pour la TI-82 Advanced)
avec piles mais sans couvercle : 232 g (contre 236 g pour la TI-82 Advanced)

Quelques grammes de moins de façon systématique dans les deux cas, il semble que TI ait enlevé quelque chose...

Comme nous l'avons vu la TI-82 Advanced Edition Python n'utilise pas de batterie rechargeable mais des piles AAA (ce qui n'est absolument pas une mauvaise nouvelle, nos tests montrant que l'autonomie offerte par des piles AAA de marque est nettement supérieure à celle permise par les batteries rechargeables flambant neuves, autonomie qui de plus se dégrade avec le temps).

Pour la face arrière de façon évidente, ce n'est pas le boîtier TI-84 Plus C Silver Editition de 2013 qui est utilisé (modèle à batterie), mais le bon vieux boîtier TI-84 Plus de 2004 comme pour la TI-82 Advanced.

Nous notons au passage gravé au dos à droite du numéro de série le timbre à date L-0521, indiquant un assemblage :

dans l'usine de code L (Kinpo Electronics aux Philippines)
en Mai 2021

Nous te disions donc plus haut que Texas Instruments avait retiré quelque chose, et nous trouvons de suite de quoi il s'agit en ouvrant le compartiment d'alimentation.

Comme la TI-84 Plus de 2004, la TI-82 Advanced de 2015 continuait à utiliser une pile bouton dite de sauvegarde, destinée à préserver le contenu de la mémoire RAM lors d'une rupture de l'alimentation (pendant un changement de piles, en cas de piles à plat, etc.).

Sur la TI-82 Advanced Edition Python l'emplacement de la pile de sauvegarde est toujours présent mais dépourvu de son cache et la pile en question est manquante. Inutile d'en rajouter une, car même les contacts sont absents au fond de l'emplacement.

Est-ce à des fins d'économie afin de nous proposer le prix le plus bas possible ? Et dans ce cas comment les données mémoire sont-elles préservées ?... Nous verrons cela plus loin.

En tous cas avoir réutilisé la coque TI-84 Plus arrière à l'identique et donc conservé un emplacement vide qui ne sert à rien ne nous fait pas bonne impression. Cela nous rappelle les habitudes de certaines contrefaçons chinoises de calculatrices de marque, cela donne l'impression d'une conception à la va-vite, du moins pour la coque arrière...

C) 1^er allumage : écran et versions

Go to top

Assez tourné autour du pot, il est grand temps de donner vie à la TI-82 Advanced Edition Python et de faire connaissance.

Au 1^er allumage la machine affiche comme nom de modèle TI-82 Adv Edition Python et indique qu'elle fait actuellement tourner un système d'exploitation en version 5.6.3.0017.

Le fichier .8yu permettant l'installation du système 5.6.3.0017 sur TI-82 Advanced Edition Python vient d'ailleurs tout juste d'être publié aujourd'hui sur le site de Texas Instruments, et nous pouvons noter que ce système a été compilé le 29 Avril 2021.

Nous reconnaissons la même interface que sur TI-83 Premium CE Edition Python, ce qui confirme la parenté technique entre ces deux modèles, cette dernière étant pour sa part à ce jour en version 5.6.1.

Nous avons donc affaire à un écran 320 × 240 pixels 16 bits, c'est-à-dire pouvant afficher jusqu'à 2¹⁶ = 65536 couleurs différentes (codage RGB-565).

Pour plus d'informations allons à l'écran à propos via

2nde

.

Nous y découvrons ici le code/identifiant produit de la TI-82 Advanced Edition Python, soit 15 en hexadécimal (contre 13 pour les TI-83 Premium CE et 0B pour la TI-82 Advanced).

En effet les différentes calculatrices Texas Instruments et leurs périphériques associés lorsque munis de la technologie Flash (mémoire persistante réinscriptible permettant la mise à jour du système d'exploitation), s'identifient avec un code/identifiant produit hexadécimal. C'est une des protections empêchant d'installer du code sur un modèle auquel il ne convient pas.

Voici donc en conséquence mise à jour notre liste des valeurs connues :

01 : TI-92 Plus + TI-CBL
02 : TI-73
03 : TI-89
04 : TI-83 Plus / TI-83 Plus.fr / TI-82 Plus
05 : TI-CBL2
06 : Vernier LabPro
07 : TI-Presenter
08 : TI-Voyage 200
09 : TI-89 Titanium
0A : TI-83 Plus.fr USB / TI-84 Plus / TI-84 Plus Silver Edition / TI-84 Pocket.fr / TI-84 Plus Pocket SE + TI-CBR
0B : TI-82 Advanced + TI-CBR2
0C : TI-Nspire CAS / TI-Nspire CAS TouchPad / TI-Nspire CAS+ / TI-Nspire+ / TI-Phoenix 1
0D : TI-Nspire Lab Cradle / TI-Nspire DataTracker + TI-Nspire ViewScreen
0E : TI-Nspire / TI-Nspire TouchPad
0F : TI-Nspire CX CAS / TI-Nspire CX-C CAS / TI-Nspire CX CAS Chinese Edition / TI-84 Plus C Silver Edition
10 : TI-Nspire CX / TI-Nspire CX-C / TI-Nspire CX Chinese Edition
11 : TI-Nspire CM-C CAS / TI-Nspire CM CAS Chinese Edition
12 : TI-Nspire CM-C / TI-Nspire CM Chinese Edition
13 : TI-83 Premium CE / TI-83 Premium CE Edition Python / TI-84 Plus CE / TI-84 Plus CE Python / TI-84 Plus CE-T / TI-84 Plus CE-T Python Edition
15 : TI-82 Advanced Edition Python
1B : TI-84 Plus T
1C : TI-Nspire CX II CAS / TI-Nspire CX II-T CAS / TI-Nspire CX II-C CAS
1D : TI-Nspire CX II
1E : TI-Nspire CX II-T

Bizarre en passant que la valeur 14 ait apparemment été sautée. Aurions-nous raté un autre nouveau modèle en préparation ?...

Accédons maintenant au mode d'auto-diagnostic de la machine en tapant

mode

alpha

ln

.

Un premier écran nous confirme l'utilisation d'un système d'exploitation système en version 5.6.3.0017, mais nous précise également que ce dernier s'amorce sur un Boot en version 5.6.3.0010.

L'écran suivant nous indique en prime la version du firmware Python utilisé, 3.20, contre 3.10 à ce jour sur TI-83 Premium CE Edition Python.

D) Mémoires et persistance données

Go to top

Historiquement les calculatrices Texas Instruments utilisaient deux types de mémoire :

la RAM, mémoire de travail volatile (c'est-à-dire devant être alimentée pour conserver son contenu)
la ROM, mémoire persistante mais non modifiable, contenant notamment le système d'exploitation

.

Introduite par Texas Instruments en 1998 avec les TI-73 et TI-89 puis 1999 avec les TI-83 Plus et TI-92 Plus, la mémoire Flash remplaçait la ROM.

Tout en étant persistante sans alimentation comme de la ROM, la mémoire Flash a le gros avantage d'être réinscriptible. Cela permet la mise à jour du système d'exploitation, mais également la mise à disposition d'une partie de l'espace inutilisé pour l'utilisateur en tant que mémoire de stockage (appelée mémoire d'archive chez Texas Instruments), permettant le stockage sécurisé de données mais également l'installation d'applications.

Après, ces deux mémoires ne sont pas symétriques :

depuis la mise à jour 5.3.0 pour TI-83 Premium CE les programmes TI-Basic peuvent être exécutés indifféremment qu'ils soient en RAM ou en Flash, mais ils ne peuvent être modifiés que si ils sont stockés en RAM
certains types de variables comme les applications, ainsi que sur TI-83 Premium CE les images, ne peuvent être stockées qu'en mémoire Flash
les scripts Python sur TI-83 Premium CE si stockés en Flash n'étaient non seulement pas modifiables, mais de plus ne pouvaient même pas être lancés, ce qui incitait fortement à les laisser en permanence en mémoire RAM

Consultons donc les capacités disponibles sur TI-82 Advanced Edition Python grâce au gestionnaire de mémoire, accessible via

2nde

.

Nous avons donc dans les 152K de mémoire RAM libre pour l'utilisateur, et 1835K disponibles en Flash en tant que mémoire de stockage.

Notons qu'une réinitialisation de la mémoire de la calculatrice ne libère pas davantage d'espace en Flash, comme si il n'y avait pas d'applications à effacer ; nous approfondirons ce point plus loin.

Traitons maintenant comme promis du cas de la persistance des données, puisque la disparition de la pile de sauvegarde plus haut nous a inquiétés.

Les TI-83 Premium CE sont elles aussi dépourvues d'une pile de sauvegarde, mais la différence c'est qu'elles utilisent une batterie. Or, comme avec des piles, tu n'attends normalement pas que la calculatrice ne s'allume plus avant de réagir (la charge de batterie étant en permanence indiquée à l'écran, et des messages d'alerte apparaissant de plus lorsqu'elle tombe sous un niveau critique). Et avec une batterie aucun besoin de la déconnecter, il suffit de brancher la calculatrice en USB pour la recharger.

Ici avec la TI-82 Advanced Edition Python, en cas d'alimentation faible il te faudra donc remplacer les piles. Calculatrice éteinte, avec des variables à la fois présentes en mémoire RAM et Flash, tentons de déconnecter et reconnecter très rapidement une seule pile de la TI-82 Advanced Edition Python, de l'ordre d'une demi-seconde. Soit une rupture d'alimentation franchement très raisonnable (tout-le-monde ne remplaçant pas les 4 piles une par une avec les neuves sous la main). Effectuons ce test plusieurs fois de suite. Et bien malgré ces conditions de tests extrêmement favorables, les résultats sont très inquiétants :

dans tous les cas (à moins d'une rupture d'alimentation beaucoup plus courte), la calculatrice redémarre (reset), puisque montrant l'écran de revalidation du système d'exploitation
dans presque une moitié des cas (à la suite), le contenu Flash était conservé, mais le contenu RAM était intégralement perdu
dans presque une moitié des cas (à la suite), le contenu Flash était conservé, et le contenu RAM également
dans quelques cas, le contenu RAM était perdu, mais le contenu Flash également, du jamais vu !
dans quelques cas, la calculatrice était inutilisable (ne voulant pas se rallumer, ou bien étant bloquée à l'allumage sur un message d'erreur de mémoire sans que la moindre touche ne permette de le fermer) et nous avons donc dû à nouveau retirer une pile, plus longuement

Comme nous le craignions plus haut, nous notons malheureusement un problème bien préoccupant de persistance des données sur TI-82 Advanced Edition Python, mais l'absence de la pile de sauvegarde n'explique pas tout.

En effet Texas Instruments a donc retiré la pile de sauvegarde ainsi que son circuit, peut-être pour économiser sur les coûts de production. Mais les résultats des tests étant divers, il semble que le constructeur l'ait remplacée par un autre système, logiciel, permettant la conservation ou récupération des données en cas de rupture d'alimentation.

Nous ne pouvons hélas que constater que ce nouveau système n'est de toute évidence absolument pas fiable à ce jour. Le jour où tu changeras les piles de ta TI-82 Advanced Edition Python, il te faudra absolument penser à déplacer l'intégralité de tes variables en mémoire Flash, et encore sans garantie comme nous avons vu. Sans cela, tu as de gros risques de perdre l'intégralité du contenu RAM (voir pire), et donc entre autres l'intégralité de tes scripts Python si comme sur TI-83 Premium ils doivent être stockés en RAM pour être utilisables, ce que nous verrons plus loin !

C'est très embêtant, et clairement selon nous un gros défaut. Espérons que ce sera corrigé par une mise à jour logicielle d'ici à ce que les premiers utilisateurs aient besoin de remplacer leurs piles...

E) Fonctionnalités hors applications

Go to top

Alors, quelles fonctionnalités la TI-82 Advanced Edition Python offre-t-elle ?

Dans un premier temps concentrons-nous sur les fonctionnalités directement intégrées au système d'exploitation, c'est-à-dire ne nécessitant pas le lancement d'une application via

2nde

résol

.

Et bien c'est extrêmement simple et formidable à la fois. La quasi-totalité des fonctionnalités hors applications donc de la TI-83 Premium Edition Python sont disponibles sur TI-82 Advanced Edition Python !

Nous disposons donc de presque toutes les améliorations apportées sur TI-83 Premium CE depuis la rentrée 2015 et pas sur le modèle inférieur TI-82 Advanced.

On peut citer le calcul exact QPiRac, mais également les suites récurrentes directement définissables aux rangs n+1 et n+2, la définition de fonctions par morceaux en écriture naturelle, ou encore le calcul par défaut des quartiles à la française.

Pour faire court, qu'est-ce que la TI-82 Advanced Edition Python ne fait pas ?

C'est très simple, elle ne permet pas de contrôler des périphériques dans le cadre de projets STEM (TI-Innovator, BBC micro:bit, ...).

Les fonctions nécessaires Send() et Get() ne sont pas au catalogue et ne peuvent donc pas être saisies au clavier.

Si l'on tente de les utiliser malgré tout, par exemple en transférant un programme comportant déjà ces appels dans son code TI-Basic, elles ne fonctionnent pas et renvoient une erreur Invalide.

Même erreur en passant si l'on tente de même avec la fonction Asm(), la gestion des programmes en langage machine déjà supprimée à compter de la version 5.5.1 de la TI-83 Premium CE Edition Python ne revient pas davantage sur TI-82 Advanced Edition Python.

F) Applications intégrées

Go to top

Passons donc maintenant aux fonctionnalités dont l'accès nécessite de lancer une application.

Comme dit plus haut, Texas Instruments introduisait donc en 1998 un véritable gestionnaire d'applications. Initialement, tu pouvais librement à tout moment installer en Flash des applications à télécharger sur le site de Texas Instruments, les mettre à jour ou les supprimer, et c'est toujours le cas aujourd'hui sur TI-83 Premium CE.

Toutefois les TI-82 Advanced et TI-84 Plus T des rentrées 2015 et 2016 bridaient lourdement le fonctionnement du gestionnaire d'applications. Tu n'avais plus la possibilité de rajouter ou mettre à jour librement des applications, ces dernières étant désormais intégrées au système d'exploitation. La seule façon de rajouter ou mettre à jour des applications était donc de mettre à jour le système d'exploitation de la calculatrice, à condition que des mises à jour existent. Or Texas Instruments n'a jamais publié de mise à jour pour ces modèles depuis leur sortie.

Nous nous rendons vite compte que c'est ce dernier fonctionnement bridé que Texas Instruments a retenu pour sa TI-82 Advanced Edition Python, les menus de la calculatrice ne listant de même plus le type Application, TI-Connect CE ne les listant pas davantage et refusant même d'en installer.

Découvrons donc la sélection ainsi définitive d'applications que Texas Instruments t'a faite pour ta TI-82 Advanced Edition Python.

Les applications sont en fait à aller chercher sous 2 menus différents :

```
2nde
```
```
résol
```
pour les applications lançables
```
mode
```
pour les applications de langues

Pour les applications de langues et bien cela va être rapide, la TI-82 Advanced Edition Python ne gère que 2 langues : le Français et l'Anglais.

Pour les applications lançables, nous avons une très petite sélection des applications couleur déjà disponibles pour TI-83 Premium CE Edition Python :

Fonct financ…
CelSheet 5.0.0.0017 (tableur / feuille de calculs)
Inequalz 5.1.0.0110 (représentation graphique d'inéquations)
PlySmlt2 5.5.0.0038 (résolution de systèmes d'équations linéaires et équations polynomiales)
Prob Sim 5.1.0.0110 (simulateur d'expériences aléatoires)
Python82 5.6.3.0017 (éditeur et interpréteur Python)
Transfrm 5.3.1.0034 (représentation graphique de fonctions à paramètres)

Pour mieux te rendre compte de ce que cela implique, voici une comparaison des applications disponibles selon les modèles :

Description	TI-82 Advanced (5.0.0.0028)	TI-82 Advanced Edition Python (5.6.3.0017)	TI-83 Premium CE Edition Python (5.6.1.0012)
fonctions financières	Finance	Fonct financ…	Fonct financ…
feuille de calculs / tableur	CSheetFr (1.10)	CelSheet (5.1.1.0017)	CelSheet (5.1.0.0110)
résolution systèmes/polynômes	PlySmlt2 (2.00)	PlySmlt2 (5.5.0.0038)	PlySmlt2 (5.5.0.0038)
simulation expériences aléatoires	Prob Sim (1.1)	Prob Sim (5.1.0.0110)	Prob Sim (5.1.0.0110)
graphes inégalités	Inequalz (2.40)	Inequalz (5.1.0.0110)	Inequalz (5.1.0.0110)
fonctions à paramètres		Transfrm (5.3.1.0034)	Transfrm (5.3.1.0034)
Python		Python82 (5.6.3.0017)	Python (5.5.2.0044)
géométrie dynamique			CabriJr (5.0.0.0089)
courbes coniques			Conics (5.1.0.0110)
classification périodique éléments	Period (1.0)		Periodic (5.5.0.0038)
unités + constantes + vecteurs 2D			SciTools (5.5.0.0038)
acquisition mesures physiques			EasyData (5.3.6.0018)
connectivité projets STEM			Hub (5.4.0.0034)
télécommande pour émulateur			SmartPad (5.3.0.0042)
langue française	Français (2.40)	Français (5.6.3.0017)	Français (5.6.0.0020)
langue allemande			Deutsch (5.6.0.0020)
langue espagnole			Español (5.6.0.0020)
langue néerlandaise			Nederlan (5.6.0.0020)
langue portugaise			Portug (5.6.0.0020)
langue suédoise			Svenska (5.6.0.0020)
Total	7	8	20

La TI-82 Advanced Edition Python intègre donc 8 applications, contre seulement 7 sur l'ancien modèle TI-82 Advanced :

on perd l'application Period de tableau périodique des éléments
pour gagner à la place l'application Transfrm traitant des fonctions à paramètres, et l'application Python82 sur laquelle nous allons revenir

Précisons en passant qu'il n'y a pas ici l'application CabriJr, et donc à ce jour aucune possibilité d'installer arTIfiCE pour rajouter la gestion des programmes en langage machine dits "assembleur" (ASM).

Il semble y avoir eu une volonté d'exclure toute fonctionnalité relative aux sciences expérimentations (Physique-Chimie, projets STEM) alors qu'il s'agit pourtant encore d'enseignements obligatoires en Seconde, c'est assez surprenant a priori mais nous reviendrons là-dessus en conclusion.

Concernant l'absence des applications de connectivité STEM, selon nos tests la TI-82 Advanced Edition Python semble de toutes façons incapable d'alimenter le moindre périphérique USB.

Nous notons que les applications sont en version 5, c'est-à-dire que contrairement à la TI-82 Advanced, l'on bénéficie de toutes les nouveautés et améliorations qui leur ont été apportées dans le cadre du développement de la TI-83 Premium CE Edition Python.

On peut noter toutefois quelques différences de versions :

Français est en version 5.6.3.0017 sur TI-82 Advanced Edition Python, alors qu'en version 5.6.0.0020 sur TI-83 Premium CE Edition Python - mais c'est ici normal puisque certains menus du système d'exploitation sont différents comme nous avons vu
CelSheet qui est en version 5.1.1.0017 alors que la dernière version disponible pour TI-83 Premium CE Edition Python est la 5.1.0.0110

En fait, après analyse du fichier de mise à jour du système d'exploitation .8yu, nous nous rendons compte que même lorsqu'il y a le même numéro de version, le code machine des applications intégrées à la TI-82 Advanced Edition Python n'est pas identique à celui des applications équivalentes sur TI-83 Premium CE Edition Python. Nous ignorons a priori ce qui peut bien justifier ça, alors que nous avons jusqu'ici supposé les deux modèles comme similaires et compatibles...

G1) Python82 : Implémentation, entiers et performances - import sys

Go to top

Si l'application dédiée à la programmation en Python s'appelle donc ici Python82 et non Python comme sur TI-83 Premium CE Edition Python. C'est donc qu'il doit y avoir des différences... Nous allons nous montrer particulièrement attentifs ici.

Un module Python très intéressant à explorer pour commencer à faire connaissance, c'est le module standard sys.

Il n'est pas au menu mais bel et bien disponible, et on peut obtenir la liste intégrale des différents éléments qu'il permet d'appeler via un simple dir(sys).

sys.platform == 'TI-Python' 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, même si ici cela ne permettra pas de distinguer les TI-82 Advanced Edition Python et TI-83 Premium CE Edition Python.

Comme on pouvait s'en douter sys.implementation nous indique que nous sommes sur un interpréteur TI-Python (un dérivé de CircuitPython, qui est lui-même un MicroPython allégé), en précisant qu'il s'agit d'une version 3.2.0.71, et implémentant lui-même le Python 3.4.0 comme l'indique sys.version.

Bref, cela semble être a priori la même solution Python que sur TI-83 Premium CE Edition Python, à une différence de version près (TI-Python 3.2.0.71, au lieu de TI-Python 3.1.0.58).

en exam
officiel en exam
tiers hors exam
officiel hors exam
tiers

Micropython 1.12.0 : NumWorks
Micropython 1.11.0 : TI-Nspire CX II
Micropython 1.9.4 : HP Prime
Casio Graph 90+E / 35+E II
TI-Python 3.2.0.71 : TI-82 Advanced Edition Python
TI-Python 3.1.0.58 : TI-83 Premium CE Edition Python

Micropython 1.12.0 : TI-Nspire CX (Ndless + KhiCAS)
Micropython 1.12.0 : NumWorks
Micropython 1.12.0 : NumWorks N0110 (Delta / Omega + KhiCAS)
Micropython 1.11.0 : TI-Nspire CX II
Micropython 1.9.4 : HP Prime
Casio Graph 90+E / 35+E II
TI-Python 3.2.0.71 : TI-82 Advanced Edition Python
TI-Python 3.1.0.58 : TI-83 Premium CE Edition Python

Micropython 1.12.0 : NumWorks
Micropython 1.11.0 : TI-Nspire CX II
Micropython 1.9.4 : HP Prime
Casio Graph 90+E / 35+E II / fx-CG50 / fx-9750/9860GIII
TI-Python 3.2.0.71 : TI-82 Advanced Edition Python
TI-Python 3.1.0.58 : TI-83 Premium CE Edition Python / TI-84 Plus CE Python Edition
CircuitPython 3.0.0 : TI-83 Premium CE + TI-Python

Micropython 1.12.0 : TI-Nspire CX / CX II (Ndless + KhiCAS CX / KhiCAS CX II)
Micropython 1.12.0 : NumWorks
Micropython 1.12.0 : NumWorks N0110 (Delta / Omega + KhiCAS)
Micropython 1.11.0 : TI-Nspire CX II
Micropython 1.9.4 : HP Prime
Casio Graph 90+E / 35+E II / fx-CG50 / fx-9750/9860GIII
Casio Graph 35/75+E / 35+E II / fx-9750GII/GIII / fx-9860G/GII/GIII (appli CasioPython)
Micropython 1.4.6 : TI-Nspire (Ndless + micropython)
TI-Python 3.2.0.71 : TI-82 Advanced Edition Python
TI-Python 3.1.0.58 : TI-83 Premium CE Edition Python / TI-84 Plus CE Python Edition
CircuitPython 4.0.0 : TI-83 Premium CE + TI-Python (firmware tiers)
CircuitPython 3.0.0 : TI-83 Premium CE + TI-Python

Malgré le numéro de version supérieur, nous doutons toutefois fortement que ce soit des améliorations que l'appli Python82 de la TI-82 Advanced Edition Python apporte par rapport à l'appli Python de la TI-83 Premium CE Edition Python. Poursuivons les tests, nous allons bien finir par réussir à avoir le fin mot de l'histoire...

sys.maxsize pour sa part indique le plus grand entier pouvant être codé nativement sur la plateforme utilisée, avec ici une organisation little endian comme l'indique sys.byteorder. En pratique sys.maxsize détermine la taille maximale de nombre de structures telles les listes. Les variables peuvent quand même prendre des valeurs entières absolues supérieures qui sont alors gérées logiciellement en tant qu'entiers longs.

Comme la quasi totalité de la concurrence jusqu'à présent, nous avons sys.maxsize == 2147483647, soit sys.maxsize == 2**31 -1, valeur habituelle pour les plateformes 32 bits, 1 bit étant réservé pour le signe.

Les seules exceptions sont les TI-Nspire CX II qui pour on ne sait quelle raison ont sys.maxsize == 32767 soit sys.maxsize == 2**15 -1, caractéristique des plateformes 16 bits...

Quant à sys.byteorder, ici aussi la quasi totalité de la concurrence travaille en little endian.

À une exception près ici encore mais pas la même, les Casio travaillent en big endian.

Voyons donc les performances du Python dans le contexte des nombres entiers, afin de voir si les performances de la TI-82 Advanced Edition Python égalent celles de la TI-83 Premium CE Edition Python ou pas. 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

Sur le calcul entier en Python, elle semble être très légèrement moins performante que la TI-83 Premium CE Edition Python.
En effet pour un appel de isprimep(10000019), la TI-82 Advanced Edition Python met dans les 9,22s, là où la TI-83 Premium CE Edition Python mettait dans les 8,91s.

en exam
officiel en exam
tiers en exam
tiers + overclock hors exam
officiel hors exam
tiers hors exam
tiers + overclock

0,171s : HP Prime G2 (32 bits : Cortex-A7/ARMv7 @528MHz Python)
0,449s : HP Prime G1 (32 bits : ARM9/ARMv5 @400MHz Python)
0,451s : TI-Nspire CX II (32 bits : ARM9/ARMv5 @396MHz)
0,581s : NumWorks N0110 (32 bits : Cortex-M7/ARMv7 @216MHz)
1,17s : NumWorks N0100 (32 bits : Cortex-M4/ARMv7 @100MHz)
1,58s : Casio Graph 90+E (32 bits : SH4 @117,96MHz)
4,39s : Casio Graph 35+E II (32 bits : SH4 @58,98MHz)
4,42s : HP Prime G2 (32 bits : Cortex-A7/ARMv7 @528MHz CAS)
8,91s : TI-83 Premium CE Edition Python (8 + 32 bits : eZ80 @48MHz + Cortex-M0+/ARMv6 @48MHz)
9,22s : TI-82 Advanced Edition Python
16,05s : HP Prime G1 (32 bits : ARM9/ARMv5 @400MHz CAS)

0,171s : HP Prime G2 (32 bits : Cortex-A7/ARMv7 @528MHz Python)
0,449s : HP Prime G1 (32 bits : ARM9/ARMv5 @400MHz Python)
0,451s : TI-Nspire CX II (32 bits : ARM9/ARMv5 @396MHz)
0,794s : TI-Nspire CX (révisions A-V) (32 bits : ARM9/ARMv5 @132MHz - Ndless + KhiCAS Micropython)
0,581s : NumWorks N0110 (32 bits : Cortex-M7/ARMv7 @216MHz)
0,715s : NumWorks N0110 (Delta / Omega + KhiCAS Micropython)
1,17s : NumWorks N0100 (32 bits : Cortex-M4/ARMv7 @100MHz)
1,18s : TI-Nspire CX CR4+ (révisions W+) (32 bits : ARM9/ARMv5 @156MHz - Ndless + KhiCAS Micropython)
1,58s : Casio Graph 90+E (32 bits : SH4 @117,96MHz)
4,39s : Casio Graph 35+E II (32 bits : SH4 @58,98MHz)
4,42s : HP Prime G2 (32 bits : Cortex-A7/ARMv7 @528MHz CAS)
8,91s : TI-83 Premium CE Edition Python (8 + 32 bits : eZ80 @48MHz + Cortex-M0+/ARMv6 @48MHz)
9,22s : TI-82 Advanced Edition Python
16,05s : HP Prime G1 (32 bits : ARM9/ARMv5 @400MHz CAS)
36,26s : TI-Nspire CX (révisions A-V) (32 bits : ARM9/ARMv5 @132MHz - Ndless + KhiCAS compatibilité Python)
42,75s : NumWorks N0110 (Delta / Omega + KhiCAS compatibilité Python)
53,24s : TI-Nspire CX CR4+ (révisions W+) (32 bits : ARM9/ARMv5 @156MHz - Ndless + KhiCAS compatibilité Python

0,171s : HP Prime G2 (32 bits : Cortex-A7/ARMv7 @528MHz Python)
0,449s : HP Prime G1 (32 bits : ARM9/ARMv5 @400MHz Python)
0,451s : TI-Nspire CX II (32 bits : ARM9/ARMv5 @396MHz)
0,511s : TI-Nspire CX (révisions A-V) (32 bits : ARM9/ARMv5 ~~@132MHz~~ overclocké @222MHz Nover - Ndless + KhiCAS Micropython)
0,581s : NumWorks N0110 (32 bits : Cortex-M7/ARMv7 @216MHz)
0,715s : NumWorks N0110 (Delta / Omega + KhiCAS Micropython)
0,821s : TI-Nspire CX CR4+ (révisions W+) (32 bits : ARM9/ARMv5 ~~@156MHz~~ overclocké @216MHz Nover - Ndless + KhiCAS Micropython)
1,17s : NumWorks N0100 (32 bits : Cortex-M4/ARMv7 @100MHz)
1,58s : Casio Graph 90+E (32 bits : SH4 @117,96MHz)
4,39s : Casio Graph 35+E II (32 bits : SH4 @58,98MHz)
4,42s : HP Prime G2 (32 bits : Cortex-A7/ARMv7 @528MHz CAS)
8,91s : TI-83 Premium CE Edition Python (8 + 32 bits : eZ80 @48MHz + Cortex-M0+/ARMv6 @48MHz)
9,22s : TI-82 Advanced Edition Python
16,05s : HP Prime G1 (32 bits : ARM9/ARMv5 @400MHz CAS)
29,20s : TI-Nspire CX (révisions A-V) (32 bits : ARM9/ARMv5 ~~@132MHz~~ overclocké @222MHz Nover - Ndless + KhiCAS compatibilité Python)
42,75s : NumWorks N0110 (Delta / Omega + KhiCAS compatibilité Python)
45,34s : TI-Nspire CX CR4+ (révisions W+) (32 bits : ARM9/ARMv5 ~~@156MHz~~ overclocké @216MHz Nover - Ndless + KhiCAS compatibilité Python)

0,171s : HP Prime G2 (32 bits : Cortex-A7/ARMv7 @528MHz Python)
0,449s : HP Prime G1 (32 bits : ARM9/ARMv5 @400MHz Python)
0,451s : TI-Nspire CX II (32 bits : ARM9/ARMv5 @396MHz)
0,581s : NumWorks N0110 (32 bits : Cortex-M7/ARMv7 @216MHz)
1,17s : NumWorks N0100 (32 bits : Cortex-M4/ARMv7 @100MHz)
1,58s : Casio Graph 90+E / fx-CG50 (32 bits : SH4 @117,96MHz)
4,39s : Casio Graph 35+E II / fx-9750/9860GIII (32 bits : SH4 @58,98MHz)
4,42s : HP Prime G2 (32 bits : Cortex-A7/ARMv7 @528MHz CAS)
8,1s : TI-83 Premium CE + TI-Python (8 + 32 bits : eZ80 @48MHz + Cortex-M0+/ARMv6 @48MHz)
8,91s : TI-83 Premium CE Edition Python / TI-84 Plus CE Python Edition (8 + 32 bits : eZ80 @48MHz + Cortex-M0+/ARMv6 @48MHz)
9,22s : TI-82 Advanced Edition Python
16,05s : HP Prime G1 (32 bits : ARM9/ARMv5 @400MHz CAS)

0,171s : HP Prime G2 (32 bits : Cortex-A7/ARMv7 @528MHz Python)
0,307s : TI-Nspire CX II (32 bits : ARM9/ARMv5 @396MHz - Ndless + MicroPython)
0,323s : TI-Nspire CX II (32 bits : ARM9/ARMv5 @396MHz - Ndless + KhiCAS Micropython)
0,449s : HP Prime G1 (32 bits : ARM9/ARMv5 @400MHz Python)
0,451s : TI-Nspire CX II (32 bits : ARM9/ARMv5 @396MHz)
0,581s : NumWorks N0110 (32 bits : Cortex-M7/ARMv7 @216MHz)
0,62s : TI-Nspire CX (révisions A-V) (32 bits : ARM9/ARMv5 @132MHz - Ndless + MicroPython)
0,67s : TI-Nspire (32 bits : ARM9/ARMv5 @120MHz - Ndless + MicroPython)
0,715s : NumWorks N0110 (Delta / Omega + KhiCAS Micropython)
0,794s : TI-Nspire CX (révisions A-V) (32 bits : ARM9/ARMv5 @132MHz - Ndless + KhiCAS Micropython)
0,99s : TI-Nspire CX CR4+ (révisions W+) (32 bits : ARM9/ARMv5 @156MHz - Ndless + MicroPython)
1,17s : NumWorks N0100 (32 bits : Cortex-M4/ARMv7 @100MHz)
1,18s : TI-Nspire CX CR4+ (révisions W+) (32 bits : ARM9/ARMv5 @156MHz - Ndless + KhiCAS Micropython)
1,58s : Casio Graph 90+E / fx-CG50 (32 bits : SH4 @117,96MHz)
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 @528MHz CAS)
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)
8,91s : TI-83 Premium CE Edition Python / TI-84 Plus CE Python Edition (8 + 32 bits : eZ80 @48MHz + Cortex-M0+/ARMv6 @48MHz)
9,22s : TI-82 Advanced Edition Python
11,26s : TI-83 Premium CE + TI-Python (8 + 32 bits : eZ80 @48MHz + Cortex-M0+/ARMv6 @48MHz CircuitPython)
11,62s : TI-Nspire CX II (32 bits : ARM9/ARMv5 @396MHz - Ndless + KhiCAS compatibilité Python)
16,05s : HP Prime G1 (32 bits : ARM9/ARMv5 @400MHz CAS)
32,76s : Casio Graph 90+E / fx-CG50 (32 bits : SH4 @117,96MHz - KhiCAS)
36,26s : TI-Nspire CX (révisions A-V) (32 bits : ARM9/ARMv5 @132MHz - Ndless + KhiCAS compatibilité Python)
42,75s : NumWorks N0110 (Delta / Omega + KhiCAS compatibilité Python)
53,24s : TI-Nspire CX CR4+ (révisions W+) (32 bits : ARM9/ARMv5 @156MHz - Ndless + KhiCAS compatibilité Python)
91,71s : Casio Graph 35+E II / fx-9750/9860GIII (32 bits : SH4 @58,98MHz - KhiCAS)
102,04s : Casio fx-CG10/20 (32 bits : SH4 @58,98MHz - KhiCAS)

0,171s : HP Prime G2 (32 bits : Cortex-A7/ARMv7 @528MHz Python)
0,206s : TI-Nspire CX II (32 bits : ARM9/ARMv5 ~~@396MHz~~ overclocké @468MHz NoverII - Ndless + MicroPython)
0,263s : TI-Nspire CX II (32 bits : ARM9/ARMv5 ~~@396MHz~~ overclocké @468MHz NoverII - Ndless + KhiCAS Micropython)
0,382 : TI-Nspire CX II (32 bits : ARM9/ARMv5 ~~@396MHz~~ overclocké @468MHz NoverII)
0,42s : TI-Nspire CX (révisions A-V) (32 bits : ARM9/ARMv5 ~~@132MHz~~ overclocké @222MHz Nover - Ndless + MicroPython)
0,449s : HP Prime G1 (32 bits : ARM9/ARMv5 @400MHz Python)
0,511s : TI-Nspire CX (révisions A-V) (32 bits : ARM9/ARMv5 ~~@132MHz~~ overclocké @222MHz Nover - Ndless + KhiCAS Micropython)
0,57s : TI-Nspire (32 bits : ARM9/ARMv5 overclocké ~~@120MHz~~ @150MHz Nover - Ndless + MicroPython)
0,58s : Casio Graph 35/75+E / 35/75/95 / fx-9750/9860GII (32 bits : SH4 ~~@29,49MHz~~ overclocké @267,78MHz Ftune2 - CasioPython)
0,581s : NumWorks N0110 (32 bits : Cortex-M7/ARMv7 @216MHz)
0,59s : Casio Graph 35+E II / fx-9750/9860GIII (32 bits : SH4 ~~@58,98MHz~~ overclocké @274,91MHz Ftune3 - CasioPython)
0,63s : TI-Nspire CX CR4+ (révisions W+) (32 bits : ARM9/ARMv5 ~~@156MHz~~ overclocké @216MHz Nover - Ndless + MicroPython)
0,715s : NumWorks N0110 (Delta / Omega + KhiCAS Micropython)
0,821s : TI-Nspire CX CR4+ (révisions W+) (32 bits : ARM9/ARMv5 ~~@156MHz~~ overclocké @216MHz Nover - Ndless + KhiCAS Micropython)
0,86s : Casio Graph 35+E II / fx-9750/9860GIII (32 bits : SH4 ~~@58,98MHz~~ overclocké @274,91MHz Ftune3)
1,08s : Casio Graph 90+E / fx-CG50 (32 bits : SH4 ~~@117,96MHz~~ overclocké @270,77MHz Ptune3)
1,17s : NumWorks N0100 (32 bits : Cortex-M4/ARMv7 @100MHz)
1,688s : Casio Graph 35/75/85/95 / fx-9750/9860GII / fx-9860G (32 bits : SH3 ~~@29,49MHz~~ overclocké @117,96MHz Ftune - CasioPython)
4,42s : HP Prime G2 (32 bits : Cortex-A7/ARMv7 @528MHz CAS)
8,1s : TI-83 Premium CE + TI-Python (8 + 32 bits : eZ80 @48MHz + Cortex-M0+/ARMv6 @48MHz)
8,91s : TI-83 Premium CE Edition Python / TI-84 Plus CE Python Edition (8 + 32 bits : eZ80 @48MHz + Cortex-M0+/ARMv6 @48MHz)
9,22s : TI-82 Advanced Edition Python
9.964s : TI-Nspire CX II (32 bits : ARM9/ARMv5 ~~@396MHz~~ overclocké @468MHz NoverII - Ndless + KhiCAS compatibilité Python)
11,26s : TI-83 Premium CE + TI-Python (8 + 32 bits : eZ80 @48MHz + Cortex-M0+/ARMv6 @48MHz CircuitPython)
16,05s : HP Prime G1 (32 bits : ARM9/ARMv5 @400MHz CAS)
19,06s : Casio Graph 35+E II / fx-9750/9860GIII (32 bits : SH4 ~~@58,98MHz~~ overclocké @274,91MHz Ftune3 - KhiCAS)
22,77s : Casio Graph 90+E / fx-CG50 (32 bits : SH4 ~~@117,96MHz~~ overclocké @270,77MHz Ptune3 - KhiCAS)
29,20s : TI-Nspire CX (révisions A-V) (32 bits : ARM9/ARMv5 ~~@132MHz~~ overclocké @222MHz Nover - Ndless + KhiCAS compatibilité Python)
30,85s : Casio fx-CG10/20 (32 bits : SH4 ~~@58,98MHz~~ overclocké @267,78MHz Ptune2 - KhiCAS)
42,75s : NumWorks N0110 (Delta / Omega + KhiCAS compatibilité Python)
53,24s : TI-Nspire CX CR4+ (révisions W+) (32 bits : ARM9/ARMv5 ~~@156MHz~~ overclocké @216MHz Nover - Ndless + KhiCAS compatibilité Python)

G2) Python82 : Nombres flottants et performances

Go to top

Poursuivons l'étude du moteur de calcul numérique du 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
E_min, nombre entier négatif indique l'exposant minimal pouvant être codé
E, nombre entier naturel codant l'exposant

Explorons donc ce codage à l'aide des fonctions suivantes :

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]

Pas de surprise ici, 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 (precm(10)), et auxquels il faut bien évidemment rajouter 1 bit de signe.
L'appel prece() nous indique quant à lui 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.

Égalité donc là-dessus, voyons donc plutôt les performances du Python dans le contexte des calculs flottants, et vérifions si elles confirment ou pas la très légère baisse en performances notée plus haut.

Nous utiliserons pour cela le script suivant, 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]

Donc pour un appel de seuil(0.008) la TI-82 Advanced Edition Python met en moyenne dans les 4,01s, contre 3,99s pour la TI-83 Premium CE Edition Python.

Cela semble donc confirmer un recul général des performances en Python, bien que très léger et apparemment encore plus dans le cadre du calcul flottant.

en exam
officiel en exam
tiers en exam
tiers + overclock hors exam
officiel hors exam
tiers hors exam
tiers + overclock

0,087s : HP Prime G2 (32 bits : Cortex-A7/ARMv7 @528MHz Python)
0,258s : HP Prime G1 (32 bits : ARM9/ARMv5 @400MHz Python)
0,297s : TI-Nspire CX II (32 bits : ARM9/ARMv5 @396MHz)
0,376s : HP Prime G2 (32 bits : Cortex-A7/ARMv7 @528MHz CAS)
0,498s : NumWorks N0110 (32 bits : Cortex-M7/ARMv7 @216MHz)
0,785s : NumWorks N0100 (32 bits : Cortex-M4/ARMv7 @100MHz)
1,61s : HP Prime G1 (32 bits : ARM9/ARMv5 @400MHz CAS)
3,27s : Casio Graph 90+E (32 bits : SH4 @117,96MHz)
3,99s : TI-83 Premium CE Edition Python (8 + 32 bits : eZ80 @48MHz + Cortex-M0+/ARMv6 @48MHz)
4,01s : TI-82 Advanced Edition Python
9,21s : Casio Graph 35+E II (32 bits : SH4 @58,98MHz)

0,087s : HP Prime G2 (32 bits : Cortex-A7/ARMv7 @528MHz Python)
0,258s : HP Prime G1 (32 bits : ARM9/ARMv5 @400MHz Python)
0,297s : TI-Nspire CX II (32 bits : ARM9/ARMv5 @396MHz)
0,376s : HP Prime G2 (32 bits : Cortex-A7/ARMv7 @528MHz CAS)
0,609s : TI-Nspire CX (révisions A-V) (32 bits : ARM9/ARMv5 @132MHz - Ndless + KhiCAS Micropython)
0,498s : NumWorks N0110 (32 bits : Cortex-M7/ARMv7 @216MHz)
0,544s : NumWorks N0110 (Delta / Omega + KhiCAS Micropython)
0,785s : NumWorks N0100 (32 bits : Cortex-M4/ARMv7 @100MHz)
0,868s : TI-Nspire CX CR4+ (révisions W+) (32 bits : ARM9/ARMv5 @156MHz - Ndless + KhiCAS Micropython)
1,61s : HP Prime G1 (32 bits : ARM9/ARMv5 @400MHz CAS)
3,27s : Casio Graph 90+E (32 bits : SH4 @117,96MHz)
3,99s : TI-83 Premium CE Edition Python (8 + 32 bits : eZ80 @48MHz + Cortex-M0+/ARMv6 @48MHz)
4,01s : TI-82 Advanced Edition Python
5,45s : TI-Nspire CX (révisions A-V) (32 bits : ARM9/ARMv5 @132MHz - Ndless + KhiCAS compatibilité Python)
6,69s : NumWorks N0110 (Delta / Omega + KhiCAS compatibilité Python)
7,63s : TI-Nspire CX CR4+ (révisions W+) (32 bits : ARM9/ARMv5 @156MHz - Ndless + KhiCAS compatibilité Python
9,21s : Casio Graph 35+E II (32 bits : SH4 @58,98MHz)

0,087s : HP Prime G2 (32 bits : Cortex-A7/ARMv7 @528MHz Python)
0,258s : HP Prime G1 (32 bits : ARM9/ARMv5 @400MHz Python)
0,297s : TI-Nspire CX II (32 bits : ARM9/ARMv5 @396MHz)
0,376s : HP Prime G2 (32 bits : Cortex-A7/ARMv7 @528MHz CAS)
0,396s : TI-Nspire CX (révisions A-V) (32 bits : ARM9/ARMv5 ~~@132MHz~~ overclocké @222MHz Nover - Ndless + KhiCAS Micropython)
0,498s : NumWorks N0110 (32 bits : Cortex-M7/ARMv7 @216MHz)
0,544s : NumWorks N0110 (Delta / Omega + KhiCAS Micropython)
0,65s : TI-Nspire CX CR4+ (révisions W+) (32 bits : ARM9/ARMv5 ~~@156MHz~~ overclocké @216MHz Nover - Ndless + KhiCAS Micropython)
0,785s : NumWorks N0100 (32 bits : Cortex-M4/ARMv7 @100MHz)
1,61s : HP Prime G1 (32 bits : ARM9/ARMv5 @400MHz CAS)
3,27s : Casio Graph 90+E (32 bits : SH4 @117,96MHz)
3,99s : TI-83 Premium CE Edition Python (8 + 32 bits : eZ80 @48MHz + Cortex-M0+/ARMv6 @48MHz)
4,01s : TI-82 Advanced Edition Python
4,13s : TI-Nspire CX (révisions A-V) (32 bits : ARM9/ARMv5 ~~@132MHz~~ overclocké @222MHz Nover - Ndless + KhiCAS compatibilité Python)
6,69s : NumWorks N0110 (Delta / Omega + KhiCAS compatibilité Python)
7,19s : TI-Nspire CX CR4+ (révisions W+) (32 bits : ARM9/ARMv5 ~~@156MHz~~ overclocké @216MHz Nover - Ndless + KhiCAS compatibilité Python)
9,21s : Casio Graph 35+E II (32 bits : SH4 @58,98MHz)

0,087s : HP Prime G2 (32 bits : Cortex-A7/ARMv7 @528MHz Python)
0,258s : HP Prime G1 (32 bits : ARM9/ARMv5 @400MHz Python)
0,297s : TI-Nspire CX II (32 bits : ARM9/ARMv5 @396MHz)
0,376s : HP Prime G2 (32 bits : Cortex-A7/ARMv7 @528MHz CAS)
0,498s : NumWorks N0110 (32 bits : Cortex-M7/ARMv7 @216MHz)
0,785s : NumWorks N0100 (32 bits : Cortex-M4/ARMv7 @100MHz)
1,61s : HP Prime G1 (32 bits : ARM9/ARMv5 @400MHz CAS)
3,27s : Casio Graph 90+E / fx-CG50 (32 bits : SH4 @117,96MHz)
3,73s : TI-83 Premium CE + TI-Python (8 + 32 bits : eZ80 @48MHz + Cortex-M0+/ARMv6 @48MHz)
3,99s : TI-83 Premium CE Edition Python / TI-84 Plus CE Python Edition (8 + 32 bits : eZ80 @48MHz + Cortex-M0+/ARMv6 @48MHz)
4,01s : TI-82 Advanced Edition Python
9,21s : Casio Graph 35+E II / fx-9750/9860GIII (32 bits : SH4 @58,98MHz)

0,025s : TI-Nspire CX II (32 bits : ARM9/ARMv5 @396MHz - Ndless + KhiCAS Micropython)
0,087s : HP Prime G2 (32 bits : Cortex-A7/ARMv7 @528MHz Python)
0,232s : TI-Nspire CX II (32 bits : ARM9/ARMv5 @396MHz - Ndless + MicroPython)
0,258s : HP Prime G1 (32 bits : ARM9/ARMv5 @400MHz Python)
0,297s : TI-Nspire CX II (32 bits : ARM9/ARMv5 @396MHz)
0,376s : HP Prime G2 (32 bits : Cortex-A7/ARMv7 @528MHz CAS)
0,47s : TI-Nspire (32 bits : ARM9/ARMv5 @120MHz - Ndless + MicroPython)
0,48s : TI-Nspire CX (révisions A-V) (32 bits : ARM9/ARMv5 @132MHz - Ndless + MicroPython)
0,498s : NumWorks N0110 (32 bits : Cortex-M7/ARMv7 @216MHz)
0,544s : NumWorks N0110 (Delta / Omega + KhiCAS Micropython)
0,609s : TI-Nspire CX (révisions A-V) (32 bits : ARM9/ARMv5 @132MHz - Ndless + KhiCAS Micropython)
0,68s : TI-Nspire CX CR4+ (révisions W+) (32 bits : ARM9/ARMv5 @156MHz - Ndless + MicroPython)
0,785s : NumWorks N0100 (32 bits : Cortex-M4/ARMv7 @100MHz)
0,868s : TI-Nspire CX CR4+ (révisions W+) (32 bits : ARM9/ARMv5 @156MHz - Ndless + KhiCAS Micropython)
1,61s : HP Prime G1 (32 bits : ARM9/ARMv5 @400MHz CAS)
1,909s : TI-Nspire CX II (32 bits : ARM9/ARMv5 @396MHz - Ndless + KhiCAS compatibilité Python)
3,27s : Casio Graph 90+E / fx-CG50 (32 bits : SH4 @117,96MHz)
3,73s : TI-83 Premium CE + TI-Python (8 + 32 bits : eZ80 @48MHz + Cortex-M0+/ARMv6 @48MHz)
3,9s : Casio Graph 35+E II / fx-9750/9860GIII (32 bits : SH4 @58,98 - CasioPython)
3,99s : 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,01s : TI-82 Advanced Edition Python
4,4s : TI-83 Premium CE + TI-Python (8 + 32 bits : eZ80 @48MHz + Cortex-M0+/ARMv6 @48MHz CircuitPython)
5,29s : Casio Graph 35/75/85/95 / fx-9750/9860GII / fx-9860G (32 bits : SH3 @29,49MHz - CasioPython)
5,45s : TI-Nspire CX (révisions A-V) (32 bits : ARM9/ARMv5 @132MHz - Ndless + KhiCAS compatibilité Python)
5,48s : Casio Graph 90+E / fx-CG50 (32 bits : SH4 @117,96MHz - KhiCAS)
6,69s : NumWorks N0110 (Delta / Omega + KhiCAS compatibilité Python)
9,21s : Casio Graph 35+E II / fx-9750/9860GIII (32 bits : SH4 @58,98MHz)
13,93s : Casio Graph 35+E II / fx-9750/9860GIII (32 bits : SH4 @58,98MHz - KhiCAS)
7,63s : TI-Nspire CX CR4+ (révisions W+) (32 bits : ARM9/ARMv5 @156MHz - Ndless + KhiCAS compatibilité Python)
15,05s : Casio fx-CG10/20 (32 bits : SH4 @58,98MHz - KhiCAS)

0,022s : TI-Nspire CX II (32 bits : ARM9/ARMv5 ~~@396MHz~~ overclocké @468MHz NoverII - Ndless + KhiCAS Micropython)
0,087s : HP Prime G2 (32 bits : Cortex-A7/ARMv7 @528MHz Python)
0,142s : TI-Nspire CX II (32 bits : ARM9/ARMv5 ~~@396MHz~~ overclocké @468MHz NoverII - Ndless + MicroPython)
0,257s : TI-Nspire CX II (32 bits : ARM9/ARMv5 ~~@396MHz~~ overclocké @468MHz NoverII)
0,258s : HP Prime G1 (32 bits : ARM9/ARMv5 @400MHz Python)
0,27s : TI-Nspire CX (révisions A-V) (32 bits : ARM9/ARMv5 ~~@132MHz~~ overclocké @222MHz Nover - Ndless + MicroPython)
0,376s : HP Prime G2 (32 bits : Cortex-A7/ARMv7 @528MHz CAS)
0,38s : TI-Nspire (32 bits : ARM9/ARMv5 overclocké ~~@120MHz~~ @150MHz Nover - Ndless + MicroPython)
0,396s : TI-Nspire CX (révisions A-V) (32 bits : ARM9/ARMv5 ~~@132MHz~~ overclocké @222MHz Nover - Ndless + KhiCAS Micropython)
0,498s : NumWorks N0110 (32 bits : Cortex-M7/ARMv7 @216MHz)
0,53s : TI-Nspire CX CR4+ (révisions W+) (32 bits : ARM9/ARMv5 ~~@156MHz~~ overclocké @216MHz Nover - Ndless + MicroPython)
0,544s : NumWorks N0110 (Delta / Omega + KhiCAS Micropython)
0,59s : Casio Graph 35/75+E / 35/75/95 / fx-9750/9860GII (32 bits : SH4 ~~@29,49MHz~~ overclocké @267,78MHz Ftune2 - CasioPython)
0,65s : TI-Nspire CX CR4+ (révisions W+) (32 bits : ARM9/ARMv5 ~~@156MHz~~ overclocké @216MHz Nover - Ndless + KhiCAS Micropython)
0,785s : NumWorks N0100 (32 bits : Cortex-M4/ARMv7 @100MHz)
0,79s : Casio Graph 35+E II / fx-9750/9860GIII (32 bits : SH4 ~~@58,98MHz~~ overclocké @274,91MHz Ftune3 - CasioPython)
1,589s : TI-Nspire CX II (32 bits : ARM9/ARMv5 ~~@396MHz~~ overclocké @468MHz NoverII - Ndless + KhiCAS compatibilité Python)
1,61s : HP Prime G1 (32 bits : ARM9/ARMv5 @400MHz CAS)
1,86s : Casio Graph 35+E II / fx-9750/9860GIII (32 bits : SH4 ~~@58,98MHz~~ overclocké @274,91MHz Ftune3)
1,876s : Casio Graph 35/75/85/95 / fx-9750/9860GII / fx-9860G (32 bits : SH3 ~~@29,49MHz~~ overclocké @117,96MHz Ftune - CasioPython)
2,15s : Casio Graph 90+E / fx-CG50 (32 bits : SH4 ~~@117,96MHz~~ overclocké @270,77MHz Ptune3)
2,96s : Casio Graph 35+E II / fx-9750/9860GIII (32 bits : SH4 ~~@58,98MHz~~ overclocké @274,91MHz Ftune3 - KhiCAS)
3,65s : Casio Graph 90+E / fx-CG50 (32 bits : SH4 ~~@117,96MHz~~ overclocké @270,77MHz Ptune3 - KhiCAS)
3,718s : Casio fx-CG10/20 (32 bits : SH4 ~~@58,98MHz~~ overclocké @267,78MHz Ptune2 - KhiCAS)
3,73s : TI-83 Premium CE + TI-Python (8 + 32 bits : eZ80 @48MHz + Cortex-M0+/ARMv6 @48MHz)
3,99s : TI-83 Premium CE Edition Python / TI-84 Plus CE Python Edition (8 + 32 bits : eZ80 @48MHz + Cortex-M0+/ARMv6 @48MHz)
4,01s : TI-82 Advanced Edition Python
4,13s : TI-Nspire CX (révisions A-V) (32 bits : ARM9/ARMv5 ~~@132MHz~~ overclocké @222MHz Nover - Ndless + KhiCAS compatibilité Python)
4,4s : TI-83 Premium CE + TI-Python (8 + 32 bits : eZ80 @48MHz + Cortex-M0+/ARMv6 @48MHz CircuitPython)
6,69s : NumWorks N0110 (Delta / Omega + KhiCAS compatibilité Python)
7,19s : TI-Nspire CX CR4+ (révisions W+) (32 bits : ARM9/ARMv5 ~~@156MHz~~ overclocké @216MHz Nover - Ndless + KhiCAS compatibilité Python)

G3) Python82 : 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 :

La mémoire de stockage comme son nom l'indique stocke physiquement tes scripts Python. Nous confirmons en passant comme évoqué plus haut que comme sur TI-83 Premium CE Edition Python, tes scripts Python doivent être mis dans la mémoire RAM pour être utilisables, ce qui confirme hélas le problème de perte de données vu plus haut.
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.
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.

Sur calculatrices, c'est très souvent le heap qui est le facteur limitant lors de la conception de projets.

Nous avons justement la chance ici de disposer du module gc (garbage collector - ramasse miettes), avec plusieurs fonctions bien utiles :

gc.collect() pour nettoyer le heap en supprimant les valeurs d'objets Python qui ne sont plus référencées
gc.mem_alloc() pour connaître la consommation du heap en octets
gc.mem_free() pour connaître l'espace heap disponible en octets

Exécutons donc le petit script suivant afin de découvrir la taille de heap Python de la TI-82 Advanced Edition Python, et comparons au passage avec la TI-83 Premium CE Edition Python :

Code: Select all: import gc a, f = gc.mem_alloc(), gc.mem_free() (a, f, a + f)

Nous avons donc la même capacité heap de 19,968 Ko aussi bien sur TI-82 Advanced Edition Python que sur TI-83 Premium CE Edition Python, ces machines utilisant probablement le même matériel comme nous verrons plus loin.

Par contre, un avantage apparemment d'avoir moins de modules Python intégrés, c'est qu'à vide nous avons ici 19,328 Ko de heap effectivement disponibles, alors que c'est à peine plus de 17 Ko sur TI-83 Premium CE Edition Python.

Toutefois, toutes les calculatrices Python ne disposent pas du module gc. Afin de pouvoir faire des comparaisons équitables, construisons notre propre script de test d'estimation de la capacité heap à partir des informations suivantes sur les tailles des objets Python, du moins sur les plateformes 32 bits que sont à ce jour nos calculatrices :

pour un entier nul : 24 octets déjà...
pour un entier court non nul (codable sur 31 bits + 1 bit de signe) : 28 octets
pour un entier long :
- 28 octets
- + 4 octets pour chaque groupe de 30 bits utilisé par son écriture binaire au-delà des 31 bits précédents
pour une chaîne :
- 49 octets
- + 1 octet par caractère
pour une liste :
- 64 octets
- + 8 octets par élément
- + les tailles de chaque élément

Nous allons donc tenter de remplir le 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 un script en ce sens :

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 maintenant sur TI-82 Advanced Edition Python une capacité heap utilisable de 19,705 Ko un peu supérieure à la mesure précédente, à laquelle bien sûr il faut rajouter la consommation du script... donc en gros c'est quasiment la totalité de la capacité heap qui est utilisable ici.
Nous avons ici en prime une autre valeur de 8,444 Ko, correspondant à la taille du plus gros objet qui a pu être créé au cours du test et donc au plus grand espace libre disponible de façon contiguë dans le heap.

en exam
officiel en exam
tiers hors exam
officiel hors exam
tiers

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
19,968 Ko : TI-82 Advanced Edition Python
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 (Ndless + KhiCAS)
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 (firmware Delta / Omega + appli KhiCAS)
33,582 Ko : NumWorks
25,235 Ko : NumWorks N0110 (firmware Delta)
19,968 Ko : TI-82 Advanced Edition Python
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
19,968 Ko : TI-82 Advanced Edition Python
18,354 Ko : TI-83 Premium CE Edition Python / TI-84 Plus CE Python Edition

252,1 Mo : HP Prime G2
15,6 Mo : HP Prime G1
4,100 Mo : TI-Nspire CX / CX II (Ndless + KhiCAS CX / KhiCAS CX II)
2,068 Mo : TI-Nspire CX II
2,050 Mo : TI-Nspire (Ndless + MicroPython)
1,033 Mo : Casio Graph 90+E / fx-CG50
258,766 Ko : Casio Graph 35/75+E / 35/75/95 / fx-9750/9860GII (SH4 - appli CasioPython)
101,262 Ko : Casio Graph 35+E II / fx-9750/9860GIII
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 (firmware tiers)
20,839 Ko : TI-83 Premium CE + TI-Python
19,968 Ko : TI-82 Advanced Edition Python
18,354 Ko : TI-83 Premium CE Edition Python / TI-84 Plus CE Python Edition

G4) Python82 : Mémoire pile/stack

Go to top

Passons donc maintenant à la pile (stack).

Tentons donc de déclencher une consommation massive de stack, afin de pouvoir comparer ici encore TI-82 Advanced Edition Python et TI-83 Premium CE Edition Python. Une situation très simple qui peut être grande consommatrice de stack c'est la récursivité, soit les fonctions qui se rappellent elles-mêmes. En ce sens, prenons le script suivant :

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

L'appel test(compte_r) atteint donc 28 niveaux de récursion avant erreur, aussi bien sur TI-82 Advanced Edition Python que TI-83 Premium CE Edition Python.

en exam
officiel en exam
tiers hors exam
officiel hors exam
tiers

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-82 Advanced Edition Python / TI-83 Premium CE Edition Python

202 : TI-Nspire CX II
155 : TI-Nspire CX (Ndless + KhiCAS)
129 : NumWorks
126 : NumWorks (firmware Delta / Omega + appli KhiCAS)
99 : HP Prime G2
82 : Casio Graph 90+E / 35+E II
82 : HP Prime G1
28 : TI-82 Advanced Edition Python / 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-82 Advanced Edition Python / TI-83 Premium CE Edition Python / TI-84 Plus CE Python Edition
20 : TI-83 Premium CE + TI-Python

5362 : Casio Graph 35/75+E / 35/75/95 / fx-9750/9860GII (SH4 - appli CasioPython)
655 : Casio Graph 35+E II / 35/75/85/95(SH3) / fx-9750/9860GIII / fx-9750/9860GII(SH3) / fx-9860G (appli CasioPython)
202 : TI-Nspire CX II
155 : TI-Nspire CX / CX II (Ndless + KhiCAS CX / KhiCAS CX II)
130 : TI-Nspire (Ndless + MicroPython)
129 : NumWorks
126 : NumWorks (firmware Delta / Omega + appli KhiCAS)
99 : HP Prime G2
82 : Casio Graph 90+E / 35+E II / fx-CG50 / fx-9750/9860GIII
82 : HP Prime G1
28 : TI-82 Advanced Edition Python / 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

G5) Python82 : Modules intégrés

Go to top

Passons maintenant enfin aux modules Python disponibles sur TI-82 Advanced Edition Python. Au menu nous ne trouvons que des modules standard :

math
random
time

Histoire d'être sûr de ne rien rater on peut également appeler help("modules"). Ce qui nous permet de rajouter quelques autres modules mais toujours standard :

builtins
array
collections
gc
sys

Par rapport à la TI-83 Premium CE Edition Python on dirait que tous les modules propriétaires de Texas Instruments ont été supprimés, notamment :

ti_graphics, module de tracé par pixels
ti_plotlib, module de tracé dans un repère
ti_hub, module de connectivité pour les projets STEM
ti_system, module qui permettait à la fois de :
- afficher du texte à la ligne de son choix
- attendre l'appui sur la touche
```
annul
```
- tester les appuis sur les touches clavier
- exporter des listes Python en tant que variables accessibles par les autres applications de la calculatrice
- importer des listes créées par les autres applications de la calculatrice en tant que listes Python

Toutes ces possibilités seraient donc exclues sur TI-82 Advanced Edition Python.

TI
82A
Python

TI
83PCE
+
Python

TI
83PCE
Python

TI
84+CE
Python

TI
Nspire
CX II

Casio
Graph
90+E
35+EII

Num
Works

HP
Prime

TI
83PCE
+
Python
tiers

TI-
Nspire
Ndless
μPython

TI-
Nspire
CX
Ndless
χCAS

Casio
Graph
35/75+E
35+EII
CasioPython

Num
Works
Ω Δ

Num
Works
Ω Δ
χCAS

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 :
✓ module intégré + disponible en mode examen
✓ module intégré + interdit en mode examen
+ module propriétaire équivalent + disponible en mode examen
+ module propriétaire équivalent + interdit en mode examen
. module absent et sans équivalent

en exam
officiel en exam
tiers hors exam
officiel hors exam
tiers

17 modules standard : HP Prime
16 modules standard : TI-Nspire CX II
9 modules standard : NumWorks
8 modules standard : TI-82 Advanced Edition Python / TI-83 Premium CE Edition Python
6 modules standard : Casio Graph 90+E / 35+E II

23 modules standard : TI-Nspire CX (Ndless + KhiCAS)
NumWorks N0110 (Delta / Omega + KhiCAS)
17 modules standard : HP Prime
16 modules standard : TI-Nspire CX II
10 modules standard : NumWorks (Delta / Omega)
9 modules standard : NumWorks
8 modules standard : TI-82 Advanced Edition Python / TI-83 Premium CE Edition Python
6 modules standard : Casio Graph 90+E / 35+E II

17 modules standard : HP Prime
TI-Nspire CX II
10 modules standard : TI-83 Premium CE Edition Python / TI-84 Plus CE Python Edition
9 modules standard : NumWorks
8 modules standard : TI-82 Advanced Edition Python / TI-83 Premium CE + TI-Python
6 modules standard : Casio Graph 90+E / 35+E II / fx-CG50 / fx-9750/9860GIII

23 modules standard : TI-Nspire CX / CX II (Ndless + KhiCAS CX / KhiCAS CX II)
NumWorks N0110 (Delta / Omega + KhiCAS)
17 modules standard : HP Prime
TI-Nspire CX II
13 modules standard : TI-83 Premium CE + TI-Python (firmware tiers)
10 modules standard : NumWorks (Delta / Omega)
TI-83 Premium CE Edition Python / TI-84 Plus CE Python Edition
9 modules standard : NumWorks
8 modules standard : Casio Graph 35/75+E / 35+E II / fx-9750GII/GIII / fx-9860G/GII/GIII (appli CasioPython)
TI-82 Advanced Edition Python / TI-83 Premium CE + TI-Python
7 modules standard : TI-Nspire (Ndless + micropython)
6 modules standard : Casio Graph 90+E / 35+E II / fx-CG50 / fx-9750/9860GIII

G6) Python82 : Modules additionnels PYMP

Go to top

Notons que la TI-83 Premium CE Edition Python supportait l'installation de modules additionnels, format propriétaire PYMP non documenté à ce jour. Sont disponibles :

des modules de tracé faisant appel à ti_graphics (ce_turtl, ce_box, ce_chart, ce_quivr)
des modules de connectivité faisant appel à ti_hub (microbit, ...)

Ces modules ont l'avantage de pouvoir être installés en mémoire d'archive, mais contrairement aux modules intégrés sont inacessibles en mode examen.

Donc nous avons testé, bonne nouvelle, les modules additionnels PYMP sont bien reconnus par l'application Python82 de la TI-82 Advanced Edition Python.

Toutefois à ce jour cela ne sert strictement à rien. Ces modules ont tous besoin soit de ti_graphics soit de ti_hub, modules ici manquants, et à ce jour il n'est pas possible de générer ses propres modules additionnels PYMP sans passer par Texas Instruments.

G7) Python82 : Codes CSI et "programmation Python en couleur" ?

Go to top

Bref comme nous venons de le voir aucun module de tracé sur TI-82 Advanced Edition Python. Il est donc impossible de commander l'allumage du moindre pixel.

La mention "La calculatrice pour initier tous les élèves de Seconde à la programmation Python en couleur" ne serait-elle pas alors un peu beaucoup exagérée, non ?

La seule chose qui pourrait ressembler à de la "programmation Python couleur", c'est la possibilité d'afficher du texte en couleur dans la console Python sur TI-83 Premium CE Edition Python, grâce aux codes CSI.

Bonne nouvelle, cela a été conservé sur TI-82 Advanced Edition Python :

Code: Select all: def color_str(s, cf, cb=7): return "\x1B[" + str(cf) + ";" + str(cb) + "m" + s n = 16 s = "" for cb in range(n): for cf in range(n): s += color_str("X", cf, cb) if cb % 2: s += "\n" print(s)

Mais franchement, cela nous étonnerait beaucoup que Texas Instruments ait fait référence à cela...

Non en fait, à bien y repenser, la mention "La calculatrice pour initier tous les élèves de Seconde à la programmation Python en couleur" doit être littéralement à prendre au 1^er degré dans sa forme la plus simple.

Nous ne l'avions clairement pas comprise comme cela au départ, mais elle met sans doute en avant ni plus ni moins que la simple possibilité de saisir et visualiser son code dans un éditeur gérant la coloration syntaxique.

Un argument marketing donc, probablement destiné à envoyer une pique à sa concurrente directe, la Casio Graph 35+E II trouvable à des prix similaires, mais qui à la différence dispose d'un écran monochrome.

Edit 2022: d'après les pages de TI qui semblent désormais clarifier cet aspect, c'est en effet bien la possibilité d'avoir l'éditeur en couleurs qui est mise en avant

G8) Python82 : Test touches clavier via sys.stdin ?

Go to top

Donc pas de module ti_system ici sur TI-82 Advanced Edition Python, et donc en théorie pas de moyen de tester les appuis de touches clavier si tu souhaites coder des interfaces ou même jeux en Python.

Historiquement, nous avions vu sur TI-83 Premium CE Edition Python que les appuis de touches clavier écrivaient dans le flux sys.stdin. Voici ce que ça donne, y compris avec les modificateurs

2nde

et

alpha

:

f(x)	fenêtre	zoom	trace	graphe
2nde	mode	suppr	← `\x1b[D` `\x1b[H`	↑ `\x1b[A`
alpha	X,T,θ,n `Xx`	stats	↓ `\x1b[B`	→ `\x1b[C` `\x1b[F`
math `aA`	matrice `bB`	prgm `cC`	var	annul `[2K`
◄► `dD`	trig `pieE`	résol `fF`	□/□ `gG`	^ `**hH`
x² `**2` `sqrt() [1D` `iI`	, `,` `E` `jJ`	( `(` `{` `kK`	) `)` `}` `lL`	/ `/` `e` `mM`
log `log(,10) [4D` `10**() [1D` `nN`	7 `7` `oO`	8 `8` `pP`	9 `9` `qQ`	× `*` `[` `rR`
ln `log() [1D` `exp() [1D` `sS`	4 `4` `tT`	5 `5` `uU`	6 `6` `vV`	- `-` `]` `wW`
sto→ `=` `\\` `xX`	1 `1` `yY`	2 `2` `zZ`	3 `3` `@`	+ `+` `'` `"`
on	0 `0`	. `.:`	(-) `-_?`	entrée `\x1b[F`

Il suffisait donc en théorie de lire la sortie du flux sys.stdin pour identifier les touches ou combinaisons de touches pressées. En pratique c'était toutefois plus complexe, la lecture étant bloquante, aucun module permettant de la reconfigurer en non-bloquante n'étant inclus, et la méthode .isatty() permettant de savoir si il y a des données à lire n'étant pas incluse elle non plus.

CaptainLuigi était arrivé malgré tout à du code qui commençait à être utilisable :

Code: Select all: from sys import * def getkey(): s = stdin.read(1) if s == "\x1B": s = stdin.read(3) return s

Et puis à compter de la mise à jour 5.5 cette possibilité n'avait plus été utilisée, puisque nous avions en remplacement l'appel officiel ti_system.wait_key().

Nous nous rendons compte hélas aujourd'hui que Texas Instruments semble avoir bloqué ce comportement à partir de la mise à jour 5.5 des TI-83 Premium CE Edition Python : les appuis de touches semblent ne plus rien écrire dans sys.stdin. Et malheureusement, c'est pareil sur la version 5.6.3 de la TI-82 Advanced Edition Python.

Bref jusqu'à preuve du contraire non, aucune possibilité de tester les appuis de touches clavier si tu souhaites coder des interfaces ou même jeux en Python sur ta TI-82 Advanced Edition Python.

G9) Python82 : Bilan modules

Go to top

Nous avons donc comparé plus haut l'offre de modules 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, explorant les modules pour en déterminer le nombre d'éléments :

explmod.py autopfrm.py

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)

Code: Select all: # detects calculator Python platform 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 #return get_pixel and set_pixel functions for the platform 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 sp = hpprime.pixon 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 #returns platform screen infos : width, height, color_mode/bits def scr_infos(pf): # uPy uPy # G352 CPy uPy KhiCAS---------------------> CAS # NW G90 CE CX2 HP GXX NS NS NS NW NW G90 G352 HP l_vlines = (222, 192, 210, 212, 240, 064, 240, 222, 222, 222, 222, 192, 064, 240) l_vcols = (320, 384, 320, 318, 320, 128, 320, 320, 320, 320, 320, 384, 128, 320) l_y0 = (000, 000, 030, 000, 000, 000, 000, 000, 000, 000, 000, 000, 000, 000) l_modes = (000, 000, 000, 016, 032, 000, 016, 000, 016, 000, 016, 016, 001, 032) return l_vcols[pf], l_vlines[pf], l_y0[pf], l_modes[pf] #returns platform shell infos : visible lines, visible columns, if larger strings are displayed on several lines or not def shell_infos(pf): #NW small: [00] 12.5x30 -> 16 x 42 #HP small: [03] 11.5x39 -> 15.5 x 45 [12] 14 x39 -> 18.5 x 45 #HP big : [03] 11.5x39 -> 09 x 35 [12] 14 x39 -> 11 x 35 # uPy uPy # G352 CPy uPy KhiCAS---------------> CAS # NW G90 CE CX2 HP GXX NS NS NS NW NW G90 G352HP l_vlines = (12, 07, 11, 11, 12, 09, 29, 11, 11, 11, 11, 09, 07, 14) l_vcols = (30, 21, 32, 00, 39, 32, 53, 32, 32, 29, 29, 30, 19, 39) b_vcr = 0b1111100 if pf >= 0: return l_vlines[pf], l_vcols[pf], b_vcr // 2**pf % 2 else: return max(l_vlines), max(l_vcols), 1

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.

Il semble ne trouver aucune différence sur les modules (tous standard) communs aux TI-82 Advanced Edition Python et TI-83 Premium CE Edition Python.

Nous totalisons 406 éléments utilisables, répartis de la façon suivante :

builtins : 153
array : 26
collections : 24
gc : 29
math : 50
random : 30
sys : 68
time : 26

Et oui... Texas Instruments a enlevé tellement de choses, que finalement avec seulement 406 éléments, la TI-82 Advanced Edition Python réussit ici l'exploit, à pas grand chose certes, de rafler la dernière place.

en exam
officiel en exam
tiers hors exam
officiel hors exam
tiers

1915 fonctions : TI-83 Premium CE Edition Python
1065 fonctions : HP Prime
1017 fonctions : TI-Nspire CX II
548 fonctions : NumWorks
443 fonctions : Casio Graph 90+E / 35+E II
406 fonctions : TI-82 Advanced Edition Python

1915 fonctions : TI-83 Premium CE Edition Python
1387 fonctions : NumWorks N0110 (Omega + KhiCAS)
1284 fonctions : TI-Nspire CX (Ndless + KhiCAS)
1065 fonctions : HP Prime
1017 fonctions : TI-Nspire CX II
590 fonctions : NumWorks (Omega)
548 fonctions : NumWorks
443 fonctions : Casio Graph 90+E / 35+E II
406 fonctions : TI-82 Advanced Edition Python

2495 fonctions : TI-83 Premium CE Edition Python / TI-84 Plus CE Python Edition
2160 fonctions : TI-Nspire CX II
1065 fonctions : HP Prime
548 fonctions : NumWorks
443 fonctions : Casio Graph 90+E / 35+E II / fx-CG50 / fx-9750/9860GIII
406 fonctions : TI-82 Advanced Edition Python
405 fonctions : TI-83 Premium CE + TI-Python

2495 fonctions : TI-83 Premium CE Edition Python / TI-84 Plus CE Python Edition
2160 fonctions : TI-Nspire CX II
1387 fonctions : NumWorks N0110 (Delta / Omega + KhiCAS)
1284 fonctions : TI-Nspire CX / CX II (Ndless + KhiCAS CX / KhiCAS CX II)
1065 fonctions : HP Prime
602 fonctions : TI-83 Premium CE + TI-Python (firmware tiers)
590 fonctions : NumWorks (Omega)
548 fonctions : NumWorks
464 fonctions : Casio Graph 35/75+E / 35+E II / fx-9750GII/GIII / fx-9860G/GII/GIII (appli CasioPython)
429 fonctions : TI-Nspire (Ndless + micropython)
406 fonctions : TI-82 Advanced Edition Python
405 fonctions : TI-83 Premium CE + TI-Python

H) Mode examen

Go to top

Comme sur TI-83 Premium CE Edition Python, le mode examen de la TI-82 Advanced Edition Python s'active en allumant la calculatrice avec les touches

annul

entrer

enfoncées.

Depuis la mise à jour 5.3.1 des TI-83 Premium CE, l'activation du mode examen revalidait toutes les applications présentes en mémoire.

Chaque revalidation d'application nécessitait le calcul d'une signature électronique 2048 bits, puis la comparaison avec la signature présente en fin d'application, générée par Texas Instruments via une clé privée et impossible à falsifier à ce jour.

Ce processus garantit que l'application n'a pas été altérée afin de générer un comportement frauduleux en mode examen, et toute application échouant au test est effacée au passage.

Le problème, c'est que le calcul de signature électronique 2048 bits est gourmand, et à effectuer donc 19 fois sur les TI-83 Premium CE (ou 20 fois si l'application tierce Cesium est installée, l'application Finance ne comptant pas).

De façon absolument monstrueuse, l'activation prenait :

dans les 1min30s sur les anciennes TI-83 Premium CE
plus que dans les 30s sur TI-83 Premium CE Edition Python, suite à un changement de technologie Flash (série)

Des délais dans tous les cas très hautement problématiques en début d'épreuve, à un moment où tout-le-monde est stressé.

Mais ici sur TI-82 Advanced Edition Python nous n'avons que 7 applications à valider, ce qui proportionnellement ne devrait plus prendre qu'une bonne 10aine de secondes...

Et bien non même pas, le mode examen s'active en à peine 5s seulement !

Bravo, enfin quelque chose de raisonnable !

Les applications TI-82 Advanced Edition Python sont censées ne jamais bouger. Texas Instruments se serait-il donc montré malin en tenant compte de ce contexte ?

Et bien il semble que oui. Selon notre analyse du fichier de mise à jour du système d'exploitation .8yu, il n'y a pas 7 signatures à vérifier mais 1 seule, présente à la fin de la dernière application, et signant probablement de façon globale l'ensemble des 7 applications.

I) Matériel

Go to top

Voici ci-contre pour référence la carte mère de la TI-83 Premium CE Edition Python.

Jusqu'à quel point la TI-82 Advanced Edition Python lui ressemble-t-elle ou en diffère-t-elle ? Regardons enfin ce que ce nouveau modèle a dans le ventre.

La TI-82 Advanced Edition Python utilise donc une carte de référence SG82C-10-1.

Nous y retrouvons sans surprise les mêmes circuits intégrés essentiels de la TI-83 Premium CE Edition Python :

puce ASIC JB-007-01, intégrant entre autres le processeur historique eZ80 et ses 256 Kio de RAM
puce Flash NOR série 25Q32JVSIQ de chez Winbond, d'une capacité de 4 Mio
microcontrôleur ATSAMD21E18A-U de chez Atmel dédiée à l'application Python82, intégrant entre autres le coprocesseur ARM Cortex-M0+ cadencé à 48 MHz ainsi que 256 Kio de mémoire Flash

Nous nous attendions à une organisation de carte légèrement différente, le port USB étant à déplacer de la tranche latérale à la tranche supérieure. Mais finalement nous notons des cartes très différentes.

Pour concevoir la TI-82 Advanced Edition Python à partir de la TI-83 Premium CE Edition Python nous soupçonnons donc une modification massive du circuit de la carte à des fins de réduction des coûts de fabrication, moins de composants semblant présents à sa surface.

Effectivement nous pouvons déjà citer comme simplifications évidentes :

la suppression du circuit VBUS d'alimentation USB des périphériques comme testé plus haut
la suppression du circuit de recharge de la batterie puisque nous avons ici des piles

Conclusion

Go to top

La TI-82 Advanced Edition Python est donc une version très allégée de la TI-83 Premium CE Edition Python. Ses points forts sont son écran couleur, ainsi que ses capacités mathématiques largement suffisantes en Seconde et permettant même d'accompagner une orientation en spécialité Mathématiques en Première et Terminale.

La TI-82 Advanced Edition Python n'offre toutefois que bien peu de possibilités d'exploration à un esprit scientifique/curieux/geek (pas de gestion des programmes en langage machine, pas de modules de tracé en Python).

Toutes les fonctionnalités relatives aux sciences expérimentales (Physique-Chimie, projets STEM) usuellement apportées par des applications dont certaines pourtant présentes sur l'ancienne TI-82 Advanced, semblent ici avoir été méticuleusement exclues, alors que l'enseignement de Physique-Chimie est encore obligatoire en Seconde. Texas Instruments semble avoir voulu concevoir exprès une calculatrice pour le seul enseignement de Mathématiques. Il faut bien préserver une raison d'acheter la TI-83 Premium CE Edition Python plus chère, sans doute.

En fait, nous avons l'impression que Texas Instruments cherche à reproduire le schéma de son succès du début des années 2000, où la TI-82 Stats d'entrée de gamme était numéro 1 des ventes au lycées, avant de finir par être détrônée en 2011 par la Casio Graph 35+USB, modèle également d'entrée de gamme sorti à la rentrée 2009 et qui innovait en intégrant directement un moteur de calcul exact. La TI-82 Stats était une machine pas chère et extrêmement limitée par rapport au reste de la gamme de l'époque (27K de mémoire, aucune gestion des applications et donc aucune fonctionnalité intégrée de Physique-Chimie ou STEM). Et de même ceux qui voulaient davantage que cela avaient donc le choix des modèles TI-83 Plus ou TI-84 Plus plus chers.

La TI-82 Advanced Edition Python nous semble en conséquence convenir aux publics suivants :

les élèves de Seconde qui savent déjà qu'ils n'ont pas pour projet de poursuivre avec des spécialités Mathématiques ou scientifiques en Première (et malheureusement les possibilités d'exploration bien limitées de cette machine ne risquent pas de les faire changer d'avis)
les élèves qui ont l'intention de poursuivre avec une spécialité Mathématiques en Première mais sans spécialité Physique-Chimie (ce qui ne doit pas être souvent le cas...)

Aux tarifs formidables que nous avons annoncés plus haut, nous nous attendons à ce que la TI-82 Advanced Edition Python couleur rencontre un succès phénoménal et recrute bien au-delà de ces groupes, finissant par détrôner la Casio Graph 35+E II monochrome en tant que numéro 1 des ventes au lycée.

Sans doute pas dans l'immédiat pour la rentrée 2021 certes, changer les habitudes prend du temps, et faut-il également que tout-le-monde soit au courant de la sortie de la TI-82 Advanced Edition Python, modèle qui justement nous sort bien tard par rapport à la rentrée 2021 (habituellement les nouveaux produits sont annoncés et disponibles au Printemps). Mais plutôt donc d'ici la rentrée 2022 si Casio ne réagit pas d'ici-là.

L'ennui est donc que nombre d'élèves à profil scientifique risquent de participer aux achats groupés de TI-82 Advanced Edition Python à la rentrée lorsqu'ils vont voir le prix et l'écran couleur. Et comme il sera bien sûr hors de question de racheter une autre calculatrice en Première, ils se retrouveront à suivre une spécialicté Physique-Chimie avec une calculatrice non optimale et bridée de sorte à n'être pas améliorable.

Nous sommes donc assez mitigés :

d'un côté, si cela permet effectivement un meilleur taux d'équipement des élèves dès la Seconde, taux qui avait commencé à chuter dans le cadre de la réforme du lycée, tant mieux
mais d'un autre côté, pour les profils scientifiques nous regrettons la probable vampirisation de la formidable TI-83 Premium CE Edition Python par une TI-82 Advanced Edition Python inadaptée et bridée de sorte à le rester

Enfin, parlons concurrence. La TI-82 Advanced Edition Python est une calculatrice qui casse complètement les codes :

le prix est d'entrée de gamme
l'écran et les fonctionnalités mathématiques sont de milieu de gamme
les fonctionnalités de sciences expérimentales sont totalement inexistantes (même la Casio Graph 25+E II bas de gamme fait mieux avec son convertisseur d'unités intégré)

Dans l'entrée de gamme, la TI-82 Advanced Edition Python nous est ainsi extrêmement difficile à classer de façon unique et indiscutable. De façon générale elle n'est ni davantage capable ni moins capable que d'autres modèles d'entrée de gamme : nous pouvons à la fois te dire qu'elle est meilleure que la Casio Graph 35+E II et paradoxalement pire que la Casio Graph 25+E II ; tout est question de contexte et de point de vue.

Afin de te fournir malgré tout un bilan correct et te permettre de mieux pouvoir te repérer dans la jungle de l'entrée de gamme désormais complètement bouleversée par l'arrivée de la TI-82 Advanced Edition Python, nous t'avons conçu tout le long de la réalisation de cet article un comparateur dynamique dédié à l'entrée de gamme de cette rentrée 2021. Tu vas donc pouvoir décider toi-même si la TI-82 Advanced Edition Python est le meilleur choix pour toi ou pas :

Comparateur de calculatrices

Téléchargement : OS TI-82 Advanced Edition Python 5.6.3
Lien : Comparaison de l'entrée de gamme rentrée 2021

Nous avons aussi publié une vidéo (contenu mise-à-jour 2022) d'unboxing et découverte de la calculatrice :

→ **MyCalcs** profile · by **Lionel Debroux** » 27 Jun 2021, 09:03

Très gros travail de test et de rédaction, comme d'habitude: bravo

Cette 82AEP est donc objectivement une amélioration non négligeable par rapport à la 82A, mais garde cette philosophie de limitations artificielles pour en faire un modèle bas de gamme et la distinguer du milieu de gamme représenté par la 83PCEEP. Les pauvres doivent avoir moins de chances de s'élever et de s'intéresser aux matières scientifiques, parce que ça doit être comme ça que les choses doivent aller pour le maintien d'une société organisée par et pour les riches.

→ **MyCalcs** profile · by **critor** » 27 Jun 2021, 10:41

Merci pour ta lecture et ton retour.

→ **MyCalcs** profile · by **critor** » 27 Jun 2021, 11:00

Donc moi j'ai l'OS TI-82 Advanced Edition Python qui tourne sur une ancienne TI-83 Premium CE (déverrouillée avec BootSwap).
(à ce jour à ma connaissance, ce n'est pas possible sur TI-83 Premium CE Edition Python, BootSwap n'est pas compatible)

Aucun intérêt pour l'utilisateur final d'installer ainsi un OS bridé, c'est juste pour pouvoir tester plus profondément l'OS TI-82 Advanced Edition Python.

Cela me permet notamment d'injecter ce que je veux en Flash avant l'installation de l'OS (CabriJr, Cesium, etc.

).

Donc bonne nouvelle, je confirme que l'ASM peut toujours être réactivé sur l'OS TI-82 Advanced Edition Python via arTIfiCE, dans le cas où l'OS tourne sur TI-83 Premium CE.

Mais pour l'OS TI-82 Advanced Edition Python tournant sur TI-82 Advanced Edition Python, il va falloir trouver une nouvelle méthode d'activation, puisque nous n'avons pas l'application CabriJr nécessaire.

Par contre j'ai également une mauvaise nouvelle. L'installateur de Cesium ne marche pas sur l'OS TI-82 Advanced Edition Python 5.6.3. La faille utilisée semble avoir été corrigée.
Donc Cesium ne sera très probablement plus installable lors de la prochaine mise à jour 5.6.3+ des TI-83 Premium CE et TI-84 Plus CE. Préparez-vous...

→ **MyCalcs** profile · by **parisse** » 27 Jun 2021, 13:55

Le modele 14 manquant est interessant : on peut imaginer un successeur a la ti83 par exemple a la rentree 2022. Auquel cas, certaines restrictions de cette 82 par rapport a la 83 actuelle n'auraient plus de raison d'etre a la rentree 2022 et pourraient etre alors allegees par une mise a jour a ce moment-la.
Tout depend evidemment de l'accueil qui sera fait a cette calculatrice, aux reactions des enseignants vis a vis de ces restrictions, et de ce que fera la concurrence d'ici-la, en particulier Casio va-t-il nous sortir un modele 35 couleur? Tant qu'on y est dans les hypotheses, il faudrait alors une differenciation avec la 90 : il y a deja la taille memoire et donc des addins installable en flash, il pourrait y avoir a une alimentation par batterie. Et Numworks ...?

→ **MyCalcs** profile · by **TheMachine02** » 27 Jun 2021, 14:14

Non c'est normal que installateur ne fonctionne pas. Ça fait quelques versions d'OS que la faille doit être tunée spécifiquement pour chaque version d'OS. Donc ça sera mis à jour, je suis pas inquiet

→ **MyCalcs** profile · by **Shadow** » 27 Jun 2021, 14:19

Nan mais c'est impossible : Ti veut vraiment nous bloquer le passage
On ne peut pas décomposer l'ASM et prendre seulement la partie nous servant à lancer les jeux ?

→ **MyCalcs** profile · by **critor** » 27 Jun 2021, 14:44

TheMachine02 wrote:Non c'est normal que installateur ne fonctionne pas. Ça fait quelques versions d'OS que la faille doit être tunée spécifiquement pour chaque version d'OS. Donc ça sera mis à jour, je suis pas inquiet

Il n'y a pas que Cesium. CERMASTR utilise la même faille, il me semble sans besoin de tuning cette fois-ci, et ne marche pas non plus.

→ **MyCalcs** profile · by **TheMachine02** » 27 Jun 2021, 14:44

Oui c'est le même exploit

→ **MyCalcs** profile · by **critor** » 27 Jun 2021, 14:48

parisse wrote:Le modele 14 manquant est interessant : on peut imaginer un successeur a la ti83 par exemple a la rentree 2022.

Personnellement, j'avais pensé à une TI-84 Plus T Python Edition pour les Pays-Bas, en remplacement de l'ancienne TI-84 Plus T monochrome qui n'est plus autorisée aux examens à compter de la session 2023 :
viewtopic.php?t=24242&p=255897