Test TI-83 Premium CE Edition Python (proto. DVT), Orme 2019

→ **MyCalcs** profile · by **critor** » 08 May 2019, 13:56

Ce jeudi 25 avril, nous étions à Marseille pour les rencontres de l'Orme 2019. Elles se déroulaient cette année dans le cadre exceptionnel du Palais du Pharo.

Le formidable panorama visible du site s'étendant du Nord-Ouest à l'Est nous présentait entre autres la digue du Large, le phare de Sainte-Marie/Joliette, le MuCEM, la cathédrale de Sainte-Marie-Majeure, la tour du fanal, le fort Saint-Jean, la tour du Roi René, le Vieux-Port et le fort Ganteaume.

Quelle aubaine pour les stands qui étaient situés dans la galerie orientale, comme celui de Casio. L'équipe y présentait ses gammes de vidéoprojecteurs et de calculatrices, insistant dans ce dernier cas sur ses modèles programmables : les fx-92+ Spéciale Collège (à la Scratch), Graph 90+E (Python) et Graph 35+E II (Python). Toutefois la Graph 35+E II présente sur le stand était munie de la version système 3.00 que nous t'avons déjà testée et n'incluait donc pas encore l'application Python. Donc rien de plus à ajouter pour le moment. Rappelons que la mise à jour 3.10 gratuite permettant de rajouter cette application devrait sortir le Mercredi 22 Mai.

Et merci pour les nouveaux goodies qui nous permettront de te gâter, dont un sac Casio grand format ainsi qu'une balle anti-stress Casio en forme de globe terrestre.

Rendons-nous maintenant sur le stand de Texas Instruments.

L'équipe y mettait en avant ses journées d'été TI-Python, et distribuait une sélection d'extraits du nouveau livret d'activités pour les TI-83 Premium CE à la rentrée 2019, Algorithme et programmation en Python, Maths 2^nde par Jean-Baptiste Civet et Boris Hanuš, points que nous avons déjà abordés.

Merci donc en passant pour les goodies qui nous permettront de te gâter bientôt, dont outre cette sélection d'extraits un nouveau porte-documents Texas Instruments.

Les activités proposées sur le stand tournaient autour du robot TI-Innovator Rover piloté par une TI-83 Premium CE. Au menu tracer de polygones et park assist, qui ont pas mal intéressé les classes de primaire ayant fait le déplacement :

Bon, passons maintenant aux calculatrices présentes sur le stand. Il y avait une TI-Nspire CX II-T CAS, munie de la même version 5.0.0.1509 non finale étant venue d'origine avec nos échantillons, ainsi qu'une TI-82 Advanced sans rien de nouveau non plus.

Les enseignants visitant le stand était pour leur part bien davantage intéressés par les possibilités de programmation en Python et donc par les TI-83 Premium CE, aussi explorons maintenant ce point.

Rappelons que les actuels possesseurs de TI-83 Premium CE peuvent rajouter la possibilité d'exécuter des scripts Python en faisant l'acquisition d'un module externe TI-Python.
Ce module externe est basé matériellement sur une pyboard (carte de développement Python) Adafruit Trinket M0 munie d'un processeur 32-bits Cortex/ARMv7 @48MHz cette fois-ci correctement dimensionné, et logiciellement sur l'implémentation CircuitPython qui va avec.

Mais pour la rentrée 2019, Texas Instruments sort un nouvelle TI-83 Premium CE Edition Python qui à la différence sera nativement capable d'exécuter des scripts Python, sans aucun besoin de module externe donc.
Une belle énigme matérielle. Qu'est-ce qui va faire que cette fois-ci ce sera possible ? Ils ont juste mis la même pyboard dans le boîtier, ou bien sont-ils allés plus loin dans l'intégration ?

Nous espérions trouver un début de réponse aujourd'hui.

A priori nous ne voyons malheureusement que des TI-83 Premium CE qui ont l'air normales.

Il y en avait toutefois une belle collection avec de quoi tester quelques combinaisons intéressantes, puisque plusieurs d'entre elles étaient munies de versions non finales :

OS 5.3.5.10 + appli PyAdaptr 5.3.5.10 avec le firmware TI-Python 3.0.0.15
OS 5.3.5.17 + appli PyAdaptr 5.3.5.17 avec le firmware TI-Python 3.0.0.20

Nous avons pu constater que l'application PyAdaptr reprogrammait systématiquement le firmware du module externe TI-Python si il différait de la version qu'elle intégrait, et ce sans tenir compte du fait que cette version soit plus récente ou plus ancienne. Une protection conçue pour interdire l'utilisation de firmwares tiers, et heureusement déjouée depuis.

Et puis, parmi toutes les TI-83 Premium CE du stand, nous finissons par tomber sur la nouvelle la nouvelle TI-83 Premium CE Edition Python qui tentait de se cacher dans la masse, la coquine.

Elle n'est clairement pas finale puisque continuant à utiliser le boîtier actuel. De face on dirait en effet une TI-83 Premium CE normale, mais au dos on trouve un sticker TI-83 Premium CE Edition Python. A l'emplacement du numéro de série nous notons :

L-DVT-000146
DVT NOT FOR SALE

Il s'agit donc d'un prototype de niveau DVT, ici assemblé dans la même usine de code L qui assemble les TI-83 Premium CE et TI-84 Plus CE depuis leur sortie en 2015, Kinpo Electronics aux Philippines. Visiblement, on peut estimer le nombre de ces prototypes TI-83 Premium CE Edition Python DVT actuellement entre les mains de Texas Instruments et des différents partenaires contribuant à la conception à plusieurs centaines.
Rappelons les différents niveaux de prototypage par lesquels passe un nouveau produit chez TI :

PROTO (Prototype)
EVT (Engineering Validation Tests)
DVT (Design Validation Tests)
PVT (Production Validation Tests)
MP (Mass Production)

Habituellement chez TI, les prototypes DVT ont un matériel et un logiciel déjà très proches de ceux du modèle de production, les quelques différences visibles pouvant encore concerner le boîtier.

Maintenant que nous avons malgré tout trouvé ce qu'il nous fallait, c'est donc parti pour le test !

Sommaire :Go to top

Versions système, boot et diagnostic
Performances générales
Applications Python et PyAdaptr
Ensembles de nombres
Liste modules Python
Exploration module sys
Exploration module builtins
Exploration autres modules Python
Mémoires de travail Python
Performances Python
Conclusion

1) Versions système, boot et diagnostic :

Go to top

Ce prototype TI-83 Premium CE Edition Python DVT est doté de la future version système 5.3.6. Plus précisément, son écran A propos nous apprend :

que logiciellement, le nom de modèle est toujours TI-83 Premium CE
que le numéro de version complet du système est 5.3.6.0009; il s'agit donc seulement de la 9^ème recompilation de la version 5.3.6
que l'identifiant du modèle est toujours 13 (en hexadécimal), ce qui suggère donc une compatibilité avec les anciennes TI-83 Premium CE

Effectivement, nous arrivons à y exécuter des applications et programmes assembleur conçus pour les anciennes TI-83 Premium CE.

Accédons à l'écran de lancement du menu de diagnostic, avec la combinaison secrète

mode

alpha

. Et la surprise, nous apprenons l'utilisation d'un tout nouveau boot code, ce qui suggère habituellement des changements matériels ou sécuritaires majeurs. Notons de plus que son développement semble être fortement lié aux nouvelles fonctionnalités du système, puisqu'il porte le même numéro de version : 5.3.6.0009.

Si nous lançons maintenant le menu de diagnostic, l'écran d'information qu'il commence par afficher comporte quelques ajouts notables :

une mention Python en bleu en haut à droite, sans doute non affichée si l'on transfère l'OS 5.3.6 sur un ancien modèle
une mention POB: 3.00, peut-être pour Python On Board. La pyboard intégrée d'une façon ou d'une autre, ferait donc tourner un firmware en version 3.00, comparable donc aux firmwares pour le module externe TI-Python.

Ce n'est pas tout car avant d'arriver au menu, nous nous voyons présenter un écran supplémentaire, traitant apparemment de la protection contre l'écriture des secteurs de la mémoire Flash. Peut-être est-ce significatif de changements autour de la mémoire Flash, ou peut-être est-ce juste spécifique à ce prototype dont la mémoire Flash n'est peut-être pas autant verrouillée que cette d'un modèle de production, afin notamment de pouvoir reprogrammer le boot code qui semble évoluer parallèlement au système.

2) Performances générales :

Go to top

Ce qui se dégage au premier abord par rapport aux anciennes TI-83 Premium CE, c'est une inhabituelle impression de puissance. Tentons de vérifier cela en traduisant le script Python suivant dans le langage interprété historique des TI-83 Premium CE et modèles concurrents.

Nous notons en passant que la touche

prgm

adopte enfin un comportement que nous avions suggéré il y a quelques années pour les seules TI-83 Premium CE françaises (et donc pas les TI-84 Plus CE internationales). Au lieu d'accéder directement à la liste des programmes TI-Basic, l'utilisateur doit désormais dabord préciser le langage qu'il souhaite utiliser, TI-Basic ou Python, ce qui dans ce dernier cas lance l'application Python associée.

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]

Effectivement c'est extraordinaire, l'appel seuil(0.02) s'exécute en seulement 16,24s sur la nouvelle TI-83 Premium CE Edition Python, contre 31,27s sur les anciennes TI-83 Premium CE !

Voici le classement parmi les calculatrices graphiques ou programmables conformes 2020 :

0,0625s : HP Prime G2 (32 bits : Cortex/ARMv7 @528MHz)
0,127s : NumWorks (32 bits : Cortex/ARMv7 @100MHz)
0,371s : HP Prime G1 (32 bits : ARM9/ARMv5 @400MHz)
1,45s : TI-Nspire CX II (32 bits : ARM9/ARMv5 @396MHz)
1,64s : TI-Nspire (32 bits : ARM9/ARMv5 @120MHz)
2,89s : TI-Nspire CX révisions W+/CR4+ (ARM9/ARMv5 @156MHz)
3,02s : TI-Nspire CX révisions A-V (ARM9/ARMv5 @132MHz)
7,92s : Casio Graph 90+E (32 bits : SH4 @118MHz)
13,36s : Casio Graph 35+E II (32 bits : SH4 @59MHz)
15,98s : Casio Graph 35/75+E (32 bits : SH4 @29,5MHz)
16,24s : TI-83 Premium CE Edition Python : ?
18,89s : Casio Graph 25+E : (32 bits : SH4 @29,5MHz)
31.27s : TI-83 Premium CE / TI-84 Plus CE-T (8 bits : eZ80 @48MHz)
41.71s : TI-82 Advanced / TI-84 Plus T (8 bits : z80 @15MHz)
97,72s : Casio fx-CP400+E : (32 bits : SH4 @118MHz)
107.29s : Casio fx-92+ Spéciale Collège (8 bits : nX-U8/100 >1,5MHz - spécifications ancien modèle fx-92 Collège 2D+, non confirmées sur le nouveau)
>292s : Lexibook GC3000FR (non programmable, estimation la plus favorable relativement aux performances en tracer de graphes des autres modèles monochromes d'entrée de gamme et de leur largeur en pixels de zone graphique)

Des performances de calcul apparemment multipliées par deux pour la nouvelle TI-83 Premium CE Edition Python, ce n'est pas rien, ce qui permet enfin de combler en grande partie le défaut de performances qu'il y avait par rapport aux Casio Graph monochromes !

Sur le stand l'équipe Texas Instruments nous a dit que cette amélioration des performances venait de l'utilisation d'un nouveau processeur. Sauf que le processeur eZ80 des anciennes TI-83 Premium CE est censé tourner à 48MHz, et un doublement de la fréquence n'est pas envisageable puisque le maximum parmi les processeurs eZ80 commercialisés est de 50MHz. A moins que Texas Instruments ait fait de l'overclocking mais nous en doutons fortement, ce n'est pas trop le genre de la maison...

Mais qu'est-ce que Texas Instruments a donc bien pu fabriquer pour obtenir un tel résultat ?...

3) Applications Python et PyAdaptr :

Go to top

Sur la nouvelle TI-83 Premium CE Edition Python l'application qui permet d'accéder aux fonctionnalités Python ne s'appelle plus PyAdaptr, mais justement Python. Elle aussi en version 5.3.6.0009, elle ne précise plus de version firmware pour une éventuelle pyboard intégrée.

Toutefois, avec une taille toujours aussi énorme de 329,125Ko, il semble clair que comme PyAdaptr, la nouvelle application Python continue à embarquer un firmware pour une pyboard qui serait donc intégrée quelque part.

Puisque nous avons largement de quoi faire quelques échanges sur le stand, nous remarquons que la nouvelle application Python refuse de démarrer sur les anciennes TI-83 Premium CE en version 5.3.5.

Et inversement, l'ancienne application PyAdaptr refuse également de démarrer sur la nouvelle TI-83 Premium CE Edition Python.

4) Ensembles de nombres :

Go to top

Commençons par tester les nombres flottants qui, rappelons-le, sont représentés en mémoire sous la forme

$mathjax$\pm M\times 2^{E-E_{min}}$mathjax$

avec

$mathjax$M\in [1;2[$mathjax$

. Prenons la fonction Python suivante :

Code: Select all: def precm(b): k,b=0,float(b) while 1+b**-k-1>0: k+=1 return k

L'appel precm(2) nous apprend que la mantisse M des nombres flottants peut avoir jusqu'à 53 bits, et l'appel precm(10) nous précise que cela correspond en base décimale à environ 16 chiffres significatifs.

Continuons à creuser les flottants avec la fonction Python suivante :

Code: Select all: def prece(): a=-1 while 2.**a>0: a*=2 while 2.**a==0: a+=1 b=1 while str(2.**b)[0:3]!='inf': b*=2 while str(2.**b)[0:3]=='inf': b-=1 return [a,b]

L'appel prece() nous indique que les bits restants permettent à l'exposant des nombres flottants de prendre des valeurs allant de -1074 à +1023.

Passons maintenant aux nombres entiers. Avec sys.maxsize==2**31-1, les nombres entiers représentables nativement dans le contexte matériel de la machine sont donc codés sur 32 bits, dont 1 bit de signe. Comme il est de plus apparemment possible de dépasser sys.maxsize, le support des entiers longs a donc été activité.

Jusqu'à présent c'est le minimum attendu pour toute implémentation qui se veut sérieuse dans un contexte scientifique, et c'est le cas à ce jour de toutes les solutions concurrentes sur calculatrice.

Les nombres complexes quant à eux ne sont visiblement pas gérés puisque l'évaluation de 1j renvoie une erreur.

	MicroPython TI-Nspire	NumWorks	Casio Graph 35+E II Graph 90+E	CasioPython Graph 35+E II Graph 35+E/USB Graph 75/85/95	TI-83 Premium CE Edition Python TI-83 Premium CE + TI-Python	firmware tiers TI-Python / TI-83 Premium CE
nombres complexes	✓	✓	✓	✓		✓
module cmath (fonctions complexes)	✓	✓		✓		✓

D'où le classement suivant pour les seuls nombres complexes :

NumWorks + Casio Graph 35+E II / 35+E/USB / 75/85/95 / fx-9750GII / fx-9860G/GII (application CasioPython) + TI-Nspire (application MicroPython) + module externe TI-Python pour TI-83 Premium CE (firmware tiers) avec nombres et fonctions complexes
Casio Graph 35+E II / 90+E / fx-CG50 avec nombres complexes
TI-83 Premium CE Edition Python + module externe TI-Python pour TI-83 Premium CE

Contrairement à l'ensemble de la concurrence, l'absence totale de gestion des nombres complexes est fort regrettable pour les élèves de Terminale S/STI2D/STL.

On peut certes objecter que peu d'entre eux devraient utiliser le Python pour l'algorithmique au BAC 2019, puisque ce n'est qu'à la rentrée 2017 que ce langage est devenu obligatoire en Seconde.

Toutefois cet argument n'est plus recevable pour le BAC 2020, et il est donc fort dommage que la TI-83 Premium CE Edition Python ne soit apparemment pas prête.

5) Liste modules Python :

Go to top

Nous venons donc de voir que la nouvelle TI-83 Premium CE Edition Python ne disposait pas du module cmath. En fait l'appel help("modules") nous liste exactement la même chose qu'avec le module externe TI-Python pour les anciennes TI-83 Premium CE; l'implémentation semble donc a priori ne pas avoir été améliorée entre temps :

collections
random
array
gc
sys
builtins
math
time

	MicroPython TI-Nspire	NumWorks	Casio Graph 35+E II Graph 90+E	CasioPython Graph 35+E II Graph 35+E/USB Graph 75/85/95	TI-83 Premium CE Edition Python TI-Python / TI-83 Premium CE	firmware tiers TI-Python / TI-83 Premium CE
builtins array collections cmath gc math micropython os random sys time turtle	✓ ✓ ✓ ✓ ✓ ✓ ✓	✓ ✓ ✓ ✓ ✓ ✓ ✓	✓ ✓ ✓	✓ ✓ ✓ ✓ ✓ ✓ ✓ ✓	✓ ✓ ✓ ✓ ✓ ✓ ✓ ✓ ✓	✓ ✓ ✓ ✓ ✓ ✓ ✓ ✓ ✓ ✓ ✓
spécifique	nsp	kandinsky				board storage
Total	8	8	3	8	8	13

D'où le classement suivant en terme d'éventail de modules :

13 modules : module externe TI-Python pour TI-83 Premium CE (firmware tiers)
8 modules : TI-83 Premium CE Edition Python + NumWorks + Casio Graph 35+E II / 35+E/USB / 75/85/95 / fx-9750GII / fx-9860G/GII + TI-Nspire (application MicroPython) + module externe TI-Python pour TI-83 Premium CE
3 modules : Casio Graph 35+E II / 90+E / fx-CG50

L'absence d'un module graphique se fait de plus en plus pesante.

Que cela n'ait pas été fait pour le module externe TI-Python peut se comprendre si le but était juste de dépanner temporairement les candidats aux examens 2019 et 2020.

Que cela n'ait toujours pas été fait pour le modèle accompagnant les nouveaux programmes de rentrée 2019 est plus regrettable. Notamment le nouveau programme de Physique-Chimie en Seconde, où les enseignants devront donc promouvoir et peut-être durablement adopter des alternatives à la TI-83 Premium CE Edition Python.

6) Exploration module sys :

Go to top

Puisque nous avons la chance de disposer du module sys, explorons-le à la recherche d'informations sur l'implémentation Python. Pour cela, utilisons le script Python suivant :

Code: Select all: 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): s=str(obj) return s.startswith("<module '") or s.startswith("<class '") def explmod(pitm,pitmsl=[],reset=True): global curline if(reset): curline=0 pitmsl=[sstr(pitm)] hd="."*(len(pitmsl)-1) spath=".".join(pitmsl) c=0 for itms in sorted(dir(pitm)): c=c+1 try: itm=eval(spath+"."+itms) print(hd+itms+"="+str(itm)) if isExplorable(itm): pitmsl2=pitmsl.copy() pitmsl2.append(itms) c=c+explmod(itm,pitmsl2,False) except: print(hd+itms) if c>0: print(hd+"Total: "+str(c)+" item(s)") return c

Voici la sortie de l'appel explmod(sys) :

Code: Select all: >>> # Shell Reinitialized >>> from explmod import * >>> import sys >>> explmod(sys) __name__=sys argv=[] byteorder=little exit=<function> implementation=(name='tipython', version=(3, 0, 0)) maxsize=2147483647 modules={'EXPLMOD': <module 'EXPLMOD' from 'EXPLMOD.py'} path=['', '/', '/lib', '.frozen'] platform=TI-Python print_exception=<function> stderr=<io.FileIO 2> stdin=<io.FileIO 0> stdout=<io.FileIO 1> version=3.4.0 version_info=(3, 4, 0) Total: 15 item(s) 15 >>>

Confontons cela aux modèles concurrents disposant du module sys :

	MicroPython TI-Nspire	CasioPython Graph 35+E II Graph 35+E/USB Graph 75/85/95	TI-Python / TI-83 Premium CE	TI-83 Premium CE Edition Python	firmware tiers TI-Python / TI-83 Premium CE
__name__ argv[] byteorder exc_info() exit() getsizeof()	'sys' ✓ 'little' ✓ ✓	'sys' ✓ 'big' ✓ ✓	'sys' ✓ 'little' ✓	'sys' ✓ 'little' ✓	'sys' ✓ 'little' ✓
implementation	.name='micropython' .version=(1,4,6)	.name='micropython' .version=(1,9,4)	.name='circuitpython' .version=(3,0,0)	.name='tipython' .version=(3,0,0)	.name='circuitpython' .version=(4,0,0)
maxsize modules path platform print_exception() stderr stdin stdout version version_info Total	2147483647 ✓ 'nspire' ✓ <io.TextIOWrapper 2> <io.TextIOWrapper 0> <io.TextIOWrapper 1> '3.4.0' (3,4,0) 15	2147483647 ✓ ✓ ✓ '3.4.0' (3,4,0) 12	2147483647 ✓ ✓ 'TI-Python Adapter' ✓ <io.FileIO 2> <io.FileIO 0> <io.FileIO 1> '3.4.0' (3,4,0) 15	2147483647 ✓ ✓ 'TI-Python' ✓ <io.FileIO 2> <io.FileIO 0> <io.FileIO 1> '3.4.0' (3,4,0) 15	2147483647 ✓ ✓ 'TI-Python Adapter' ✓ <io.FileIO 2> <io.FileIO 0> <io.FileIO 1> '3.4.0' (3,4,0) 15

Comparons particulièrement avec l'implémentation du module externe TI-Python pour les anciennes TI-83 Premium CE, puisque nous avons vu que celle de la nouvelle TI-83 Premium CE Edition Python semblait être basée dessus. Nous notons deux changements :

platform=='TI-Python' au lieu de platform=='TI-Python Adapter', point important à préciser pour les scripts Python proposant des interfaces et se voulant multi-plateformes, le comportement de la console Python variant d'un modèle à un autre
implementation.name=='tipython' au lieu de implementation.name=='circuitpython'

Ce dernier changement est surprenant. Cela voudrait-il dire que l'implémentation Python n'est plus basée sur le CircuitPython de l'Adafruit Trinket M0 ? Ou que Texas Instruments y a apporté des changements tellement importants que l'implémentation ne peut plus être considérée comme étant encore du CircuitPython ?

Nous n'avons certes pas encore fouillé le code machine, mais vu comme l'implémentation Python de la nouvelle TI-83 Premium CE Edition Python semble calquée sur celle du module externe TI-Python pour les anciennes TI-83 Premium CE nous doutons fortement que CircuitPython n'ait plus rien à voir dans l'histoire.

Même si cet usage est a priori légal sous la licence MIT de CircuitPython, il nous semblerait moralement très discutable de supprimer ainsi a posteriori la seule référence visible au projet autour duquel lequel Texas Instruments a construit, et donc à la communauté de développement Adafruit/CircuitPython ayant fourni (gratuitement) l'essentiel du code côté Python. Cela s'ajoute au fait que, bien qu'ayant réutilisé une implémentation Python au code libre, le code de l'implémentation modifiée/améliorée par Texas Instruments dans le contexte de l'utilisation sur TI-83 Premium CE ne soit ni libre ni même ouvert. En effet, cela signifie qu'après avoir profité de la communauté de développement CircuitPython/Adafruit, le constructeur ne contribuerait donc rien en retour.

7) Exploration module builtins :

Go to top

Munis du même script ci-dessus, explorons maintenant le module builtins.

Nous obtenons la sortie suivante :

Code: Select all: >>> # Shell Reinitialized >>> from explmod import * >>> import builtins >>> explmod(builtins) ArithmeticError=<class 'ArithmeticError'> AssertionError=<class 'AssertionError'> AttributeError=<class 'AttributeError'> BaseException=<class 'BaseException'> .__init__=<function> .Total: 1 item(s) EOFError=<class 'EOFError'> Ellipsis=Ellipsis Exception=<class 'Exception'> GeneratorExit=<class 'GeneratorExit'> ImportError=<class 'ImportError'> IndentationError=<class 'IndentationError'> IndexError=<class 'IndexError'> KeyError=<class 'KeyError'> KeyboardInterrupt=<class 'KeyboardInterrupt'> LookupError=<class 'LookupError'> MemoryError=<class 'MemoryError'> NameError=<class 'NameError'> NotImplementedError=<class 'NotImplementedError'> OSError=<class 'OSError'> OverflowError=<class 'OverflowError'> ReloadException=<class 'ReloadException'> RuntimeError=<class 'RuntimeError'> StopIteration=<class 'StopIteration'> SyntaxError=<class 'SyntaxError'> SystemExit=<class 'SystemExit'> TypeError=<class 'TypeError'> UnicodeError=<class 'UnicodeError'> ValueError=<class 'ValueError'> ZeroDivisionError=<class 'ZeroDivisionError'> __build_class__=<function> __import__=<function> __name__=builtins __repl_print__=<function> abs=<function> all=<function> any=<function> bin=<function> bool=<class 'bool'> bytearray=<class 'bytearray'> .append=<function> .extend=<function> .Total: 2 item(s) bytes=<class 'bytes'> .count=<function> .endswith=<function> .find=<function> .format=<function> .index=<function> .isalpha=<function> .isdigit=<function> .islower=<function> .isspace=<function> .isupper=<function> .join=<function> .lower=<function> .lstrip=<function> .replace=<function> .rfind=<function> .rindex=<function> .rsplit=<function> .rstrip=<function> .split=<function> .startswith=<function> .strip=<function> .upper=<function> .Total: 22 item(s) callable=<function> chr=<function> classmethod=<class 'classmethod'> dict=<class 'dict'> .__delitem__=<function> .__getitem__=<function> .__setitem__=<function> .clear=<function> .copy=<function> .fromkeys=<bound_method> .get=<function> .items=<function> .keys=<function> .pop=<function> .popitem=<function> .setdefault=<function> .update=<function> .values=<function> .Total: 14 item(s) dir=<function> divmod=<function> enumerate=<class 'enumerate'> eval=<function> exec=<function> filter=<class 'filter'> float=<class 'float'> get=<function> getattr=<function> globals=<function> hasattr=<function> hash=<function> help=<function> help=<function> hex=<function> id=<function> input=<function> input=<function> int=<class 'int'> .from_bytes=<bound_method> .to_bytes=<function> .Total: 2 item(s) isinstance=<function> issubclass=<function> iter=<function> len=<function> list=<class 'list'> .append=<function> .clear=<function> .copy=<function> .count=<function> .extend=<function> .index=<function> .insert=<function> .pop=<function> .remove=<function> .reverse=<function> .sort=<function> .Total: 11 item(s) locals=<function> map=<class 'map'> max=<function> memoryview=<class 'memoryview'> min=<function> next=<function> object=<class 'object'> oct=<function> open=<function> ord=<function> pow=<function> print=<function> property=<class 'property'> .deleter=<function> .getter=<function> .setter=<function> .Total: 3 item(s) range=<class 'range'> repr=<function> round=<function> send=<function> set=<class 'set'> .__contains__=<function> .add=<function> .clear=<function> .copy=<function> .difference=<function> .difference_update=<function> .discard=<function> .intersection=<function> .intersection_update=<function> .isdisjoint=<function> .issubset=<function> .issuperset=<function> .pop=<function> .remove=<function> .symmetric_difference=<function> .symmetric_difference_update=<function> .union=<function> .update=<function> .Total: 18 item(s) setattr=<function> slice=<class 'slice'> sorted=<function> staticmethod=<class 'staticmethod'> str=<class 'str'> .count=<function> .endswith=<function> .find=<function> .format=<function> .index=<function> .isalpha=<function> .isdigit=<function> .islower=<function> .isspace=<function> .isupper=<function> .join=<function> .lower=<function> .lstrip=<function> .replace=<function> .rfind=<function> .rindex=<function> .rsplit=<function> .rstrip=<function> .split=<function> .startswith=<function> .strip=<function> .upper=<function> .Total: 22 item(s) sum=<function> super=<class 'super'> tuple=<class 'tuple'> .count=<function> .index=<function> .Total: 2 item(s) type=<class 'type'> zip=<class 'zip'> Total: 192 item(s) 192 >>>

Grosse suprise, contrairement à l'implémentation du module externe TI-Python pour les anciennes TI-83 Premium CE, le module builtins n'a pas 190 mais 192 éléments ici sur la nouvelle TI-83 Premium CE Edition Python.

Il y a donc eu deux ajouts, faisons une petite comparaison afin de déterminer de quoi il s'agit :

	MicroPython TI-Nspire	NumWorks	Casio Graph 35+E II Graph 90+E	CasioPython Graph 35+E II Graph 35+E/USB Graph 75/85/95	TI-Python / TI-83 Premium CE	TI-83 Premium CE Edition Python	firmware tiers TI-Python / TI-83 Premium CE
ArithmeticError<> AssertionError<> AttributeError<> BaseException<> EOFError<> Ellipsis=Ellipsis Exception<> GeneratorExit<> ImportError<> IndentationError<> IndexError<> KeyError<> KeyboardInterrupt<> LookupError<> MemoryError<> NameError<> NotImplemented NotImplementedError<> OSError<> OverflowError<> ReloadException<> RuntimeError<> StopIteration<> SyntaxError<> SystemExit<> TypeError<> UnicodeError<> ValueError<> ViperTypeError<> ZeroDivisionError<> __build_class__() __import__() __name__ __repl_print__() abs() all() any() bin() bool<> bytearray<> bytes<> callable() chr() classmethod<> compile() complex<> dict<> dir() divmod() enumerate<> eval() exec() filter<> float<> frozenset<> get() getattr() globals() hasattr() hash() help() help() hex() id() input() input() int<> isinstance() issubclass() iter() len() list<11> locals() map<> max() memoryview<> min() next() object<> oct() open() ord() pow() print() property<> range<> repr() reversed<> round() send() set<> setattr() slice<> sorted() staticmethod<> str<> sum() super<> tuple<> type<> zip<> Total	0 0 0 1 0 'Ellipsis' 0 0 0 0 0 0 0 0 0 0 'NotImplemented' 0 0 0 0 0 0 0 0 0 0 0 0 ✓ ✓ ✓ ✓ ✓ ✓ ✓ 0 2 26 ✓ ✓ 0 ✓ 0 14 ✓ ✓ 0 ✓ ✓ 0 0 18 ✓ ✓ ✓ ✓ ✓ ✓ ✓ 2 ✓ ✓ ✓ ✓ 11 ✓ 0 ✓ 0 ✓ ✓ 2 ✓ ✓ ✓ ✓ ✓ 3 0 ✓ 0 ✓ 18 ✓ ✓ 0 26 ✓ 0 2 0 0 218	0 0 0 0 0 'Ellipsis' 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 ✓ ✓ 'builtins' ✓ ✓ ✓ ✓ ✓ 0 22 ✓ ✓ 0 0 14 ✓ ✓ 0 ✓ ✓ 0 0 9 ✓ ✓ ✓ ✓ ✓ ✓ ✓ 2 ✓ ✓ ✓ ✓ 11 ✓ 0 ✓ ✓ ✓ 0 ✓ ✓ ✓ ✓ ✓ 0 ✓ 0 ✓ 18 ✓ 0 ✓ 0 22 ✓ 0 2 0 0 188	0 0 0 0 0 'Ellipsis' 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 ✓ ✓ 'builtins' ✓ ✓ ✓ ✓ ✓ 0 22 ✓ ✓ 0 0 14 ✓ ✓ ✓ ✓ 0 ✓ ✓ ✓ ✓ ✓ ✓ ✓ 2 ✓ ✓ ✓ ✓ 11 ✓ 0 ✓ ✓ ✓ 0 ✓ ✓ ✓ ✓ ✓ 0 ✓ ✓ 18 ✓ 0 ✓ 0 22 ✓ 0 2 0 0 175	0 0 0 0 0 'Ellipsis' 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 ✓ ✓ 'builtins' ✓ ✓ ✓ ✓ ✓ 0 2 26 ✓ ✓ 0 0 14 ✓ ✓ 0 ✓ ✓ 0 0 9 ✓ ✓ ✓ ✓ ✓ ✓ ✓ 2 ✓ ✓ ✓ ✓ 11 ✓ 0 ✓ 0 ✓ ✓ 0 ✓ ✓ ✓ ✓ ✓ 3 0 ✓ 0 ✓ 18 ✓ 0 ✓ 0 26 ✓ 0 2 0 0 204	0 0 0 1 0 'Ellipsis' 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 ✓ ✓ 'builtins' ✓ ✓ ✓ ✓ ✓ 0 2 22 ✓ ✓ 0 14 ✓ ✓ 0 ✓ ✓ 0 0 ✓ ✓ ✓ ✓ ✓ ✓ ✓ ✓ ✓ ✓ 2 ✓ ✓ ✓ ✓ 11 ✓ 0 ✓ 0 ✓ ✓ 0 ✓ ✓ ✓ ✓ ✓ 3 0 ✓ ✓ 18 ✓ 0 ✓ 0 22 ✓ 0 2 0 0 190	0 0 0 1 0 'Ellipsis' 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 ✓ ✓ 'builtins' ✓ ✓ ✓ ✓ ✓ 0 2 22 ✓ ✓ 0 14 ✓ ✓ 0 ✓ ✓ 0 0 ✓ ✓ ✓ ✓ ✓ ✓ ✓ ✓ ✓ ✓ ✓ 2 ✓ ✓ ✓ ✓ 11 ✓ 0 ✓ 0 ✓ ✓ 0 ✓ ✓ ✓ ✓ ✓ 3 0 ✓ ✓ ✓ 18 ✓ 0 ✓ 0 22 ✓ 0 2 0 0 192	0 0 0 0 0 'Ellipsis' 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 ✓ ✓ 'builtins' ✓ ✓ ✓ ✓ ✓ 0 2 23 ✓ ✓ 0 0 14 ✓ ✓ 0 ✓ ✓ 0 0 ✓ ✓ ✓ ✓ ✓ ✓ ✓ ✓ 2 ✓ ✓ ✓ ✓ 11 ✓ 0 ✓ 0 ✓ ✓ 0 ✓ ✓ ✓ ✓ ✓ 3 0 ✓ 0 ✓ 18 ✓ 0 ✓ 0 23 ✓ 0 2 0 0 191

Par rapport à l'implémentation du module externe TI-Python pour les anciennes TI-83 Premium CE, le module builtins de la nouvelle TI-83 Premium CE Edition Python rajoute donc les fonctions get() et send().

Possiblement étrange puisque ce ne sont pas des fonctions Python standard.

Peut-être penses-tu, vu la signification de ces mots, qu'il s'agit d'un simple moyen d'importer/exporter des variables entre l'application Python et le système de la calculatrice ?...

Si l'on remonte dans le temps, des fonctions get() et send() ont justement été rajoutées récemment dans le langage interprété historique des TI-83 Premium CE, TI-84 Plus CE et TI-Nspire CX, à l'occasion de la sortie de l'interface TI-Innovator Hub pour la rentrée 2017.

D'où une hypothèse alternative, il semblerait donc que Texas Instruments a l'intention de se démarquer de la concurrence et de proposer très prochainement en Python la possibilité de lire des capteurs et contrôler des actionneurs, soit de coder en lien avec le monde réel conformément aux dernières évolutions des programmes du collège qui commencent à assaisonner les nouveaux programmes du lycée.

Cela impliquerait par extension la possibilité de piloter le robot TI-Innovator Rover sorti pour la rentrée 2018, là encore en parfaite adéquation avec les dernières évolutions des programmes !

Cette dernière hypothèse nous semblerait bien plus probable, cohérente à la fois dans le contexte des dernières évolutions de l'entreprise et du lycée français.

Dans les deux cas c'est génial.

On peut effectivement reprocher à l'ensemble de la concurrence actuelle de cloisonner l'application Python dans son coin. Impossible d'y importer ou d'en exporter des valeurs et donc par extension d'interagir avec les autres applications de la calculatrice, l'application Python ne peut donc servir à rien d'autre qu'à faire du Python, ce qui limite fortement les possibilités de résolution de problèmes concrets posés en Mathématiques ou Physique-Chimie.

Contrairement à la concurrence, la TI-83 Premium CE Edition Python sous ces deux hypothèses serait la première calculatrice où l'application Python pourra enfin interagir au-delà de sa bulle, une révolution !

Peut-être même que ça marche déjà, mais comme nous n'avons remarqué la présence des fonctions get() et send() sur nos photos qu'a posteriori, nous ne les avons donc pas testées sur place.

Si c'est bien notre hypothèse alternative qui est la bonne, aussi génial que ce soit sur le plan pédagogique et technique, on peut toutefois se demander si cela n'arrive pas ou trop tôt ou trop tard. En effet, les enseignants concernés ont déjà dû trouver des solutions pour le codage en lien avec le monde réel et la robotique depuis la rentrée 2016. Pas sûr qu'ils soient nombreux maintenant à basculer sur la solution TI-Innovator même si compatible Python, solution qui est loin d'être la plus abordable, et qui de plus aura la contrainte de nécessiter un groupe classe entièrement ou presque entièrement équipée en TI-83 Premium CE Edition Python.

8) Exploration autres modules Python :

Go to top

Le même script ci-dessus nous permet d'explorer les divers autres modules Python de la nouvelle TI-83 Premium CE Edition Python, mais là nous ne notons pas de différence par rapport à l'implémentation du module externe TI-Python pour les anciennes TI-83 Premium CE.

Passons donc au bilan tous modules confondus :

	MicroPython TI-Nspire	NumWorks	Casio Graph 35+E II Graph 90+E	CasioPython Graph 35+E II Graph 35+E/USB Graph 75/85/95	TI-Python / TI-83 Premium CE	TI-83 Premium CE Edition Python	firmware tiers TI-Python / TI-83 Premium CE
builtins array collections cmath gc math micropython os random sys time turtle	218 4 12 7 41 3 15	188 12 41 6 8 3 38	175 25 8	204 4 12 7 41 6 8 12	190 4 2 7 28 8 15 4	192 4 2 7 28 8 15 4	191 4 2 12 7 41 6 15 8 15 10
spécifique	10(nsp)	5(kandinsky)					22(board) 21(storage)
Total	310	301	208	294	258	260	354

D'où le classement suivant en terme de richesse des modules Python :

354 éléments : module externe TI-Python pour TI-83 Premium CE (firmware tiers)
310 éléments : TI-Nspire (application MicroPython)
301 éléments : NumWorks
294 éléments : Casio Graph 35+E II / 35+E/USB / 75/85/95 / fx-9750GII / fx-9860G/GII (application CasioPython)
260 éléments : TI-83 Premium CE Edition Python
258 éléments : module externe TI-Python pour TI-83 Premium CE
208 éléments : Casio Graph 35+E II / 90+E / fx-CG50

9) Mémoire de travail Python :

Go to top

La mémoire de travail en Python va accueillir :

les définitions globales (variables, fonctions, classes) issues des scripts importés
les arguments d'appel de la ou des fonctions en cours d'exécution
les définitions locales effectuées par la ou les fonctions en cours d'exécution

La taille de la mémoire de travail conditionne donc jusqu'où il sera possible d'aller en Python, nombre d'appels récursifs par exemple.

Voici quelques tailles occupées en mémoire par des variables Python :

64 octets pour une liste vide
8 octets par élément de liste supplémentaire
24 octets pour un entier nul
28 octets pour un entier court non nul
49 octets pour une chaîne vide
1 octet par caractère de chaîne supplémentaire

En se basant sur ces tailles, le script suivant permet d'estimer la capacité de la mémoire de travail en allouant plusieurs blocs de mémoire jusqu'à épuisement :

Code: Select all: def mem(): try: l=[] try: l+=[0] l+=[""] l[1]+="x" while True: try: l[1]+=l[1][l[0]:] except: if l[0]<len(l[1])-1: l[0]=len(l[1])-1 else: raise(Exception) except: print("+",len(l)>1 and len(l[1])) return 64+8*len(l)+(len(l) and 24+4*(l[0]>0)+(len(l)>1 and 49+len(l[1])))+mem() except: return 0

Voici la sortie obtenue par l'appel mem() :

TI-83 Premium CE Edition Python wrote:>>> from mem import *
>>> mem()
+ 8209
+ 3070
+ 2048
+ 1279
+ 639
+ 397
+ 158
16899
>>>

Le script arrive donc à allouer en mémoire de travail de la TI-83 Premium CE Edition Python jusqu'à 16,899 Ko.

D'où le classement par capacité de mémoire de travail :

2,046 Mo : TI-Nspire (application MicroPython)
1,027 Mo : Casio Graph 90+E / fx-CG50
255,07 Ko : Casio Graph 35+E / 35+USB/75/95 SH4 / fx-9750/9860GII SH4 (application CasioPython)
95,549 Ko : Casio Graph 35+E II
28,625 Ko : Casio Graph 35+E II / 35+USB/75/85/95 SH3 / fx-9750GII SH3 / fx-9860G/GII SH3 (application CasioPython)
19,842 Ko : module externe TI-Python pour TI-83 Premium CE (firmware tiers)
17,192 Ko : module externe TI-Python pour TI-83 Premium CE
16,899 Ko : TI-83 Premium CE Edition Python
13,658 Ko : calculatrice NumWorks
5,946 Ko : logiciel web NumWorks

La nouvelle TI-83 Premium CE Edition Python offrirait donc a priori légèrement moins de mémoire de travail Python que le module externe TI-Python pour les anciennes TI-83 Premium CE. Et c'est certes possible vu que nous avons vu plus haut qu'il y avait eu des ajouts dans le module par défault builtins.

Toutefois notre fonction mem() a le défaut d'avoir un résultat qui varie selon le contexte Python courant. Les variations ne sont certes pas énormes, mais ici avec seulement 1,7% de moins sur une unique mesure sur la nouvelle TI-83 Premium CE Edition Python par rapport au module externe TI-Python pour les anciennes TI-83 Premium CE, il pourrait très bien s'agir d'une erreur.

Peut-être qu'une amélioration du protocole de test pour une prochaine fois pourrait être de faire la moyenne d'une série d'appels mem().

10) Performances Python :

Go to top

Enfin, terminons en voyant les performances. Commençons dans le cadre des nombres entiers avec le script suivant :

Code: Select all: try: from time import * except: pass def hastime(): try: monotonic() return True except: return False def genseed(ndigits): nmax,s,k=5*10**(ndigits-1),0,1 while s<nmax: s+=k k*=2 return s def genarr(ndigits): sd,arr=genseed(ndigits),[] for k in range(1,ndigits): for j in range(ndigits): t=sd%10**k arr.extend([t,-t,10**k-t,t-10**k]) sd=sd//10+(sd%10)*10**(ndigits-1) arr.extend([sd,-sd]) return arr def sortarr(arr,sdiff): segs=[0,len(arr)-1] while len(segs): iref=segs[0] for k in range(segs[0],segs[1]+1): if sdiff*(arr[k]-arr[iref])>0: t=arr[iref] arr[iref]=arr[k] arr[k]=arr[iref+1] arr[iref+1]=t iref+=1 if iref>=segs[0]+2: segs.extend([segs[0],iref-1]) if iref<=segs[1]-2: segs.extend([iref+1,segs[1]]) segs.pop(0) segs.pop(0) return arr def test(l,n): timed=hastime() start,stop,sdiff,arr=0 or timed and monotonic(),1,-1,[] arr.extend(genarr(l)) for k in range(n): arr.extend(sortarr(arr,sdiff)) sdiff=-sdiff stop=timed and monotonic() or 1 return stop-start,len(arr),arr[0],arr[len(arr)//2-1],arr[len(arr)//2],arr[len(arr)-1]

La ligne d'appel test(9,2) se termine en 26,60s sur la nouvelle TI-83 Premium CE Edition Python, contre 23,20s pour le module externe TI-Python sur les anciennes TI-83 Premium CE.

D'où le classement suivant pour les performances en calcul entier :

1,41s : TI-Nspire (application MicroPython) (32 bits : ARM9/ARMv5 @120MHz)
1,56s : TI-Nspire CM / CX révisions A-V (application MicroPython) (32 bits : ARM9/ARMv5 @132MHz)
2,40s : TI-Nspire CX révisions W+/CR4+ (application MicroPython) (32 bits : ARM9/ARMv5 @156MHz)
3,74s : NumWorks (32 bits : Cortex/ARMv7 @100MHz)
4,75s : Casio Graph 90+E / fx-CG50 (32 bits : SH4 @118MHz)
8,81s : HP Prime G2 (32 bits : Cortex/ARMv7 @528MHz)
9,56s : Casio Graph 35+E/75+E / 35+USB/75/95 SH4 / fx-9750/9860GII SH4 (application CasioPython) (32 bits : SH4 @29,5MHz)
10,19s : Casio Graph 35+E II (application CasioPython) (32 bits : SH4 @59MHz)
12,99s : Casio Graph 35+USB/75/85/95 SH3 / fx-9750GII SH3 / fx-9860G/GII SH3 (application CasioPython) (32 bits : SH3 @29,5MHz)
14,93s : Casio Graph 35+E II (32 bits : SH4 @59MHz)
20,73s : HP Prime G1 (32 bits : ARM9/ARMv5 @400MHz)
23,20s : module externe TI-Python pour TI-83 Premium CE (32 bits : Cortex/ARMv7 @48MHz)
26,60s : TI-83 Premium CE Edition Python (?)
33,48s : module externe TI-Python pour TI-83 Premium CE (firmware tiers) (32 bits : Cortex/ARMv7 @48MHz)
60,71s : application KhiCAS sur Casio Graph 90+E / fx-CG50 (32 bits : SH4 @118MHz)
116,93s : application KhiCAS sur Casio fx-CG10/20 (32 bits : SH4 @59MHz)

Là bizarrement, par rapport au module externe pour les anciennes TI-83 Premium CE, nous notons un recul des performances pour la nouvelle TI-83 Premium CE Edition Python. Avec des durées d'exécution cette fois-ci peu variables et plus de 10% d'écart, il est peu probable qu'il s'agisse d'une erreur de mesure.

Passons maintenant aux nombres flottants avec le script suivant :

Code: Select all: try: from time import * except: pass def hastime(): try: monotonic() return True except: return False def seuil(d): timed=hastime() start,stop,n,u,l,d=0 or timed and monotonic(),1,0,2.,1,d**2 while (u-l)**2>=d: u,n=1+(1/((1-u)*(n+1))),n+1 stop=timed and monotonic() or 1 return [stop-start,n,u]

La ligne d'appel seuil(0.005) se termine en 10,38s sur la nouvelle TI-83 Premium CE Edition Python, contre 9,68s pour le module externe TI-Python sur les anciennes TI-83 Premium CE.

D'où le classement suivant dans le contexte des calculs en virgule flottante :

0,962s : HP Prime G2 (32 bits : Cortex/ARMv7 @528MHz)
1,08s : TI-Nspire CM / CX CR3- (application MicroPython) (32 bits : ARM9/ARMv5 @132MHz)
1,29s : TI-Nspire (application MicroPython) (32 bits : ARM9/ARMv5 @120MHz)
1,61s : TI-Nspire CX CR4+ (application MicroPython) (32 bits : ARM9/ARMv5 @156MHz)
2,036s : NumWorks (32 bits : Cortex/ARMv7 @100MHz)
3,068s : HP Prime G1 (32 bits : ARM9/ARMv5 @400MHz)
8,94s : Casio Graph 90+E / fx-CG50 (32 bits : SH4 @118MHz)
9,68s : module externe TI-Python pour TI-83 Premium CE (32 bits : Cortex/ARMv7 @48MHz)
10,38s : TI-83 Premium CE Edition Python (?)
10,68s : Casio Graph 35+E II (application CasioPython) (32 bits : SH4 @59MHz)
11,26s : Casio 35+E/75+E / 35+USB/75/95 SH4 / fx-9750/9860GII SH4 (application CasioPython) (32 bits : SH4 @29,5MHz)
11,46s : module externe TI-Python pour TI-83 Premium CE (firmware tiers) (32 bits : Cortex/ARMv7 @48MHz)
13,87s : Casio Graph 35+USB/75/85/95 SH3 / fx-9750GII SH3 / fx-9860G/GII SH3 (application CasioPython) (32 bits : SH3 @29,5MHz)
19,98s : application KhiCAS sur Casio Graph 90+E / fx-CG50 (32 bits : SH4 @118MHz)
25,19s : Casio Graph 35+E II (32 bits : SH4 @59MHz)
35,55s : application KhiCAS sur Casio fx-CG10/20 (32 bits : SH4 @59MHz)

Dans des proportions similaires, on confirme donc un léger recul des performances sur la TI-83 Premium CE Edition Python par rapport à ce que le module externe TI-Python pour les anciennes TI-83 Premium CE permettait d'espérer.

Conclusion :

Go to top

La TI-83 Premium CE Edition Python est à ce jour une véritable énigme technologique.

Le minimum aurait été d'intégrer une pyboard similaire à celle utilisée pour le module externe TI-Python dans le boîtier.

Mais alors, pourquoi est-elle à la fois beaucoup plus rapide dans le contexte de l'environnement historique, et dans le contexte Python légèrement plus lente que le module externe TI-Python ?
On peut avancer l'hypothèse de deux processeurs eZ80 8 bits pour l'environnement historique et ARM 32 bits pour le Python, mais pourtant le processeur eZ80 sauf erreur ne peut pas être accéléré...

Peut-être qu'alors il s'agit d'une nouvelle puce ASIC avec un unique processeur ARM 32 bits ? Dans ce cas, puisque nous arrivons toujours à y exécuter des applications et programmes assembleur conçus pour les anciennes TI-83 Premium CE, il y aurait une couche d'émulation eZ80, qui pourrait effectivement être plus rapide que le matériel d'origine.

Mais aussi, nous avons cru voir à l'écran de diagnostics que la mémoire Flash avait été touchée. Peut-être que des temps de latence différents expliquent cette accélération dans le contexte historique.
Mais pourquoi la Flash a-t-elle été touchée ? Etait-ce pour la mutualiser en y rajoutant un firmware comparable à celui du module externe TI-Python ? Auquel cas pourrait-il s'agir d'une Flash interne à une nouvelle puce ASIC comme c'était le cas avec le module externe TI-Python ?

Il semble que Texas Instruments ne se soit ici pas contenté du minimum, et ait fait un bel effort niveau processeur/ASIC pour que la nouvelle TI-83 Premium CE Edition Python puisse rester dans la course un bon moment, et s'adapter à d'éventuelles futures évolutions des programmes scolaires.

Nous avons donc hâte de pouvoir découvrir ce que la nouvelle TI-83 Premium CE Edition Python a dans le ventre, et en attendant tu peux voter pour ton explication préférée sur la page de commentaires.

Vivement cette première calculatrice où l'application Python pourra servir à autre chose qu'à simplement afaire du Python; nous avons notamment hâte de pouvoir piloter le robot TI-Innovator Rover depuis nos scripts Python.

A bientôt...

→ **MyCalcs** profile · by **zardam** » 08 May 2019, 18:22

En tout cas, il y a le petit carré vert dans la barre de statut qui donne l'état de la connexion avec le module externe.

Y avait-il l'étape d'upload des scripts vers le module ? (L'écran qui affiche "Veuillez patienter...", la liste des scripts et ensuite "Configuration terminée.")

→ **MyCalcs** profile · by **critor** » 08 May 2019, 18:26

Oui, y'a toujours.

Visible partiellement ici :

→ **MyCalcs** profile · by **parisse** » 08 May 2019, 18:38

J'avais deja trouve que realiser un module externe pour le marche existant etait cher, mais si en plus ce n'est pas le meme type de solution en interne, ca serait vraiment tres cher... Comment la memoire est-elle geree s'il y a bien 2 processeurs ? Peut-on avoir une memoire partagee et dans ce cas y-a-t-il des delais d'attente?

→ **MyCalcs** profile · by **Lionel Debroux** » 08 May 2019, 19:43

A mon avis, ils ont intégré un ATSAMD21 au PCB de la 83PCE EP, et on a deux chips bien distincts, chacun avec sa RAM et sa Flash propres, comme avec le TI-Python Adapter.

→ **MyCalcs** profile · by **Elouan147** » 10 May 2019, 15:11

Ma prof a tellement hâte de la sortie de cette calculatrice: elle m'en avait déjà parlé cet été!

→ **MyCalcs** profile · by **critor** » 10 May 2019, 15:27

Ah, ta prof a de bons contacts alors vu que nous avons appris son arrivée seulement en Mars 2019.

→ **MyCalcs** profile · by **Azerpogba** » 10 May 2019, 18:53

Et la c'est le bug

→ **MyCalcs** profile · by **OulanB** » 14 May 2019, 11:59

Ils ont du intégrer la flash eZ80 dans l'asic, donc les wait states sont plus bas et hop, vitesse en langage historique plus rapide (de mémoire l'eZ80 à 48 MHz "semble" fonctionner à 15 MHz avec les wait states avec la 83PCE actuelle ...)

→ **MyCalcs** profile · by **critor** » 14 May 2019, 12:55

Effectivement, cela se tient.

Merci à toi.

Par contre, ça repose la question de pourquoi ils auraient fait ça. Un lien peut-être matériel avec le Python ?
Parce que TI n'améliore habituellement pas les performances sans besoin.