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.
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.
- 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
- 1er allumage : écran et versions
- Mémoires et persistance données
- Fonctionnalités hors applications
- Applications intégrées
- Application Python82
- Python82 : Implémentation, entiers et performances - import sys
- Python82 : Nombres flottants et performances
- Python82 : Mémoire tas/heap - import gc
- Python82 : Mémoire pile/stack
- Python82 : Modules intégrés
- Python82 : Modules additionnels PYMP
- Python82 : Codes CSI et "programmation Python en couleur" ?
- Python82 : Test touches clavier via sys.stdin ?
- Python82 : Bilan modules
- Mode examen
- Matériel
- Conclusion et concurrence
A) Emballage, ouverture et contenu
Go to topOn 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.
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 topEn 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) 1er allumage : écran et versions
Go to topAu 1er 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'à 216 = 65536 couleurs différentes (codage RGB-565).
Pour plus d'informations allons à l'écran à propos via
2nde
+
1.
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- 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
+
2.
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.
- 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 topDans 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 topComme 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çablesmode
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 topUn 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).
- 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.- 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
@132MHzoverclocké @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
@156MHzoverclocké @216MHz Nover - Ndless + KhiCAS Micropython) - 1,17s : NumWorks N0100 (32 bits : Cortex-M4/ARMv7 @100MHz)
- 1,58s : Casio Graph 90+E (32 bits : SH4 @117,96MHz)
- 4,39s : Casio Graph 35+E II (32 bits : SH4 @58,98MHz)
- 4,42s : HP Prime G2 (32 bits : Cortex-A7/ARMv7 @528MHz CAS)
- 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
@132MHzoverclocké @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
@156MHzoverclocké @216MHz Nover - Ndless + KhiCAS compatibilité Python)
- 0,171s : HP Prime G2 (32 bits : Cortex-A7/ARMv7 @528MHz Python)
- 0,449s : HP Prime G1 (32 bits : ARM9/ARMv5 @400MHz Python)
- 0,451s : TI-Nspire CX II (32 bits : ARM9/ARMv5 @396MHz)
- 0,581s : NumWorks N0110 (32 bits : Cortex-M7/ARMv7 @216MHz)
- 1,17s : NumWorks N0100 (32 bits : Cortex-M4/ARMv7 @100MHz)
- 1,58s : Casio Graph 90+E / fx-CG50 (32 bits : SH4 @117,96MHz)
- 4,39s : Casio Graph 35+E II / fx-9750/9860GIII (32 bits : SH4 @58,98MHz)
- 4,42s : HP Prime G2 (32 bits : Cortex-A7/ARMv7 @528MHz CAS)
- 8,1s : TI-83 Premium CE + TI-Python (8 + 32 bits : eZ80 @48MHz + Cortex-M0+/ARMv6 @48MHz)
- 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
@396MHzoverclocké @468MHz NoverII - Ndless + MicroPython) - 0,263s : TI-Nspire CX II (32 bits : ARM9/ARMv5
@396MHzoverclocké @468MHz NoverII - Ndless + KhiCAS Micropython) - 0,382 : TI-Nspire CX II (32 bits : ARM9/ARMv5
@396MHzoverclocké @468MHz NoverII) - 0,42s : TI-Nspire CX (révisions A-V) (32 bits : ARM9/ARMv5
@132MHzoverclocké @222MHz Nover - Ndless + MicroPython) - 0,449s : HP Prime G1 (32 bits : ARM9/ARMv5 @400MHz Python)
- 0,511s : TI-Nspire CX (révisions A-V) (32 bits : ARM9/ARMv5
@132MHzoverclocké @222MHz Nover - Ndless + KhiCAS Micropython) - 0,57s : TI-Nspire (32 bits : ARM9/ARMv5 overclocké
@120MHz@150MHz Nover - Ndless + MicroPython) - 0,58s : Casio Graph 35/75+E / 35/75/95 / fx-9750/9860GII (32 bits : SH4
@29,49MHzoverclocké @267,78MHz Ftune2 - CasioPython) - 0,581s : NumWorks N0110 (32 bits : Cortex-M7/ARMv7 @216MHz)
- 0,59s : Casio Graph 35+E II / fx-9750/9860GIII (32 bits : SH4
@58,98MHzoverclocké @274,91MHz Ftune3 - CasioPython) - 0,63s : TI-Nspire CX CR4+ (révisions W+) (32 bits : ARM9/ARMv5
@156MHzoverclocké @216MHz Nover - Ndless + MicroPython) - 0,715s : NumWorks N0110 (Delta / Omega + KhiCAS Micropython)
- 0,821s : TI-Nspire CX CR4+ (révisions W+) (32 bits : ARM9/ARMv5
@156MHzoverclocké @216MHz Nover - Ndless + KhiCAS Micropython) - 0,86s : Casio Graph 35+E II / fx-9750/9860GIII (32 bits : SH4
@58,98MHzoverclocké @274,91MHz Ftune3) - 1,08s : Casio Graph 90+E / fx-CG50 (32 bits : SH4
@117,96MHzoverclocké @270,77MHz Ptune3) - 1,17s : NumWorks N0100 (32 bits : Cortex-M4/ARMv7 @100MHz)
- 1,688s : Casio Graph 35/75/85/95 / fx-9750/9860GII / fx-9860G (32 bits : SH3
@29,49MHzoverclocké @117,96MHz Ftune - CasioPython) - 4,42s : HP Prime G2 (32 bits : Cortex-A7/ARMv7 @528MHz CAS)
- 8,1s : TI-83 Premium CE + TI-Python (8 + 32 bits : eZ80 @48MHz + Cortex-M0+/ARMv6 @48MHz)
- 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
@396MHzoverclocké @468MHz NoverII - Ndless + KhiCAS compatibilité Python) - 11,26s : TI-83 Premium CE + TI-Python (8 + 32 bits : eZ80 @48MHz + Cortex-M0+/ARMv6 @48MHz CircuitPython)
- 16,05s : HP Prime G1 (32 bits : ARM9/ARMv5 @400MHz CAS)
- 19,06s : Casio Graph 35+E II / fx-9750/9860GIII (32 bits : SH4
@58,98MHzoverclocké @274,91MHz Ftune3 - KhiCAS) - 22,77s : Casio Graph 90+E / fx-CG50 (32 bits : SH4
@117,96MHzoverclocké @270,77MHz Ptune3 - KhiCAS) - 29,20s : TI-Nspire CX (révisions A-V) (32 bits : ARM9/ARMv5
@132MHzoverclocké @222MHz Nover - Ndless + KhiCAS compatibilité Python) - 30,85s : Casio fx-CG10/20 (32 bits : SH4
@58,98MHzoverclocké @267,78MHz Ptune2 - KhiCAS) - 42,75s : NumWorks N0110 (Delta / Omega + KhiCAS compatibilité Python)
- 53,24s : TI-Nspire CX CR4+ (révisions W+) (32 bits : ARM9/ARMv5
@156MHzoverclocké @216MHz Nover - Ndless + KhiCAS compatibilité Python)
G2) Python82 : Nombres flottants et performances
Go to topCe type de donnée représente les nombres non entiers sous la forme
- M, un nombre entier relatif dit mantisse
- Emin, nombre entier négatif indique l'exposant minimal pouvant être codé
- E, nombre entier naturel codant l'exposant
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.
- 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
@132MHzoverclocké @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
@156MHzoverclocké @216MHz Nover - Ndless + KhiCAS Micropython) - 0,785s : NumWorks N0100 (32 bits : Cortex-M4/ARMv7 @100MHz)
- 1,61s : HP Prime G1 (32 bits : ARM9/ARMv5 @400MHz CAS)
- 3,27s : Casio Graph 90+E (32 bits : SH4 @117,96MHz)
- 3,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
@132MHzoverclocké @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
@156MHzoverclocké @216MHz Nover - Ndless + KhiCAS compatibilité Python) - 9,21s : Casio Graph 35+E II (32 bits : SH4 @58,98MHz)
- 0,087s : HP Prime G2 (32 bits : Cortex-A7/ARMv7 @528MHz Python)
- 0,258s : HP Prime G1 (32 bits : ARM9/ARMv5 @400MHz Python)
- 0,297s : TI-Nspire CX II (32 bits : ARM9/ARMv5 @396MHz)
- 0,376s : HP Prime G2 (32 bits : Cortex-A7/ARMv7 @528MHz CAS)
- 0,498s : NumWorks N0110 (32 bits : Cortex-M7/ARMv7 @216MHz)
- 0,785s : NumWorks N0100 (32 bits : Cortex-M4/ARMv7 @100MHz)
- 1,61s : HP Prime G1 (32 bits : ARM9/ARMv5 @400MHz CAS)
- 3,27s : Casio Graph 90+E / fx-CG50 (32 bits : SH4 @117,96MHz)
- 3,73s : TI-83 Premium CE + TI-Python (8 + 32 bits : eZ80 @48MHz + Cortex-M0+/ARMv6 @48MHz)
- 3,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
@396MHzoverclocké @468MHz NoverII - Ndless + KhiCAS Micropython) - 0,087s : HP Prime G2 (32 bits : Cortex-A7/ARMv7 @528MHz Python)
- 0,142s : TI-Nspire CX II (32 bits : ARM9/ARMv5
@396MHzoverclocké @468MHz NoverII - Ndless + MicroPython) - 0,257s : TI-Nspire CX II (32 bits : ARM9/ARMv5
@396MHzoverclocké @468MHz NoverII) - 0,258s : HP Prime G1 (32 bits : ARM9/ARMv5 @400MHz Python)
- 0,27s : TI-Nspire CX (révisions A-V) (32 bits : ARM9/ARMv5
@132MHzoverclocké @222MHz Nover - Ndless + MicroPython) - 0,376s : HP Prime G2 (32 bits : Cortex-A7/ARMv7 @528MHz CAS)
- 0,38s : TI-Nspire (32 bits : ARM9/ARMv5 overclocké
@120MHz@150MHz Nover - Ndless + MicroPython) - 0,396s : TI-Nspire CX (révisions A-V) (32 bits : ARM9/ARMv5
@132MHzoverclocké @222MHz Nover - Ndless + KhiCAS Micropython) - 0,498s : NumWorks N0110 (32 bits : Cortex-M7/ARMv7 @216MHz)
- 0,53s : TI-Nspire CX CR4+ (révisions W+) (32 bits : ARM9/ARMv5
@156MHzoverclocké @216MHz Nover - Ndless + MicroPython) - 0,544s : NumWorks N0110 (Delta / Omega + KhiCAS Micropython)
- 0,59s : Casio Graph 35/75+E / 35/75/95 / fx-9750/9860GII (32 bits : SH4
@29,49MHzoverclocké @267,78MHz Ftune2 - CasioPython) - 0,65s : TI-Nspire CX CR4+ (révisions W+) (32 bits : ARM9/ARMv5
@156MHzoverclocké @216MHz Nover - Ndless + KhiCAS Micropython) - 0,785s : NumWorks N0100 (32 bits : Cortex-M4/ARMv7 @100MHz)
- 0,79s : Casio Graph 35+E II / fx-9750/9860GIII (32 bits : SH4
@58,98MHzoverclocké @274,91MHz Ftune3 - CasioPython) - 1,589s : TI-Nspire CX II (32 bits : ARM9/ARMv5
@396MHzoverclocké @468MHz NoverII - Ndless + KhiCAS compatibilité Python) - 1,61s : HP Prime G1 (32 bits : ARM9/ARMv5 @400MHz CAS)
- 1,86s : Casio Graph 35+E II / fx-9750/9860GIII (32 bits : SH4
@58,98MHzoverclocké @274,91MHz Ftune3) - 1,876s : Casio Graph 35/75/85/95 / fx-9750/9860GII / fx-9860G (32 bits : SH3
@29,49MHzoverclocké @117,96MHz Ftune - CasioPython) - 2,15s : Casio Graph 90+E / fx-CG50 (32 bits : SH4
@117,96MHzoverclocké @270,77MHz Ptune3) - 2,96s : Casio Graph 35+E II / fx-9750/9860GIII (32 bits : SH4
@58,98MHzoverclocké @274,91MHz Ftune3 - KhiCAS) - 3,65s : Casio Graph 90+E / fx-CG50 (32 bits : SH4
@117,96MHzoverclocké @270,77MHz Ptune3 - KhiCAS) - 3,718s : Casio fx-CG10/20 (32 bits : SH4
@58,98MHzoverclocké @267,78MHz Ptune2 - KhiCAS) - 3,73s : TI-83 Premium CE + TI-Python (8 + 32 bits : eZ80 @48MHz + Cortex-M0+/ARMv6 @48MHz)
- 3,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
@132MHzoverclocké @222MHz Nover - Ndless + KhiCAS compatibilité Python) - 4,4s : TI-83 Premium CE + TI-Python (8 + 32 bits : eZ80 @48MHz + Cortex-M0+/ARMv6 @48MHz CircuitPython)
- 6,69s : NumWorks N0110 (Delta / Omega + KhiCAS compatibilité Python)
- 7,19s : TI-Nspire CX CR4+ (révisions W+) (32 bits : ARM9/ARMv5
@156MHzoverclocké @216MHz Nover - Ndless + KhiCAS compatibilité Python)
G3) Python82 : Mémoire tas/heap - import gc
Go to top- 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éesgc.mem_alloc()
pour connaître la consommation du heap en octetsgc.mem_free()
pour connaître l'espace heap disponible en octets
- Code: Select all
import gc
a, f = gc.mem_alloc(), gc.mem_free()
(a, f, a + f)
Nous 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 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.
- 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 topTentons 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.- 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
- 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- 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
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 | |||||||
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 | ✓ ✓ . . . ✓ . . ✓ . . . . . ✓ . + . . . ✓ . . . ✓ ✓ . + . 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
- 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- 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.
G7) Python82 : Codes CSI et "programmation Python en couleur" ?
Go to topLa 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 1er 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 topHistoriquement, 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
2ndeet
alpha:
f(x) | fenêtre | zoom | trace | graphe |
2nde | mode | suppr | ← \x1b[D \x1b[H | ↑ \x1b[A |
alpha | X,T,θ,n X x | stats | ↓ \x1b[B | → \x1b[C \x1b[F |
math a A | matrice b B | prgm c C | var | annul [2K |
◄► d D | trig pi e E | résol f F | □/□ g G | ^ ** h H |
x² **2 sqrt() [1D i I | , , E j J | ( ( { k K | ) ) } l L | / / e m M |
log log(,10) [4D 10**() [1D n N | 7 7 o O | 8 8 p P | 9 9 q Q | × * [ r R |
ln log() [1D exp() [1D s S | 4 4 t T | 5 5 u U | 6 6 v V | - - ] w W |
sto→ = \\ x X | 1 1 y Y | 2 2 z Z | 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()
.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 topPour comparer la richesse de diverses implémentations Python, on ne peut pas se baser sur le nombre de modules différents offerts. En effet pour les modules propriétaires, certaines implémentations regroupent les fonctionnalités en un minimum de modules, alors que d'autres les répartissent entre de nombreux modules différents.
Tentons une autre approche incluant cette fois-ci les modules propriétaires avec le script suivant, explorant les modules pour en déterminer le nombre d'éléments :
- 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
- 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 topannul
entrerenfoncé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.
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...
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 topJusqu'à 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 topLa 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 :
Téléchargement : OS TI-82 Advanced Edition Python 5.6.3
Lien : Comparaison de l'entrée de gamme rentrée 2021