by 
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 2nde 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.
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)
Maintenant que nous avons malgré tout trouvé ce qu'il nous fallait, c'est donc parti pour le test !
Sommaire :Go to top
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
S. 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
prgmadopte 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 topCommençons par tester les nombres flottants qui, rappelons-le, sont représentés en mémoire sous la forme
L'appel
Continuons à creuser les flottants avec la fonction Python suivante :
L'appel
Passons maintenant aux nombres entiers. Avec
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
$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.NumWorks | Casio Graph 35+E II Graph 90+E | TI-83 Premium CE Edition Python TI-83 Premium CE + TI-Python | ||||
| 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.
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 | ||
| 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.
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 topPuisque 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 :
Voici la sortie de l'appel
Confontons cela aux modèles concurrents disposant du module sys :
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 :
- 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 | ||
| __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 deplatform=='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 autreimplementation.name=='tipython'au lieu deimplementation.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.
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 topMunis du même script ci-dessus, explorons maintenant le module builtins.
Nous obtenons la sortie suivante :
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 :
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
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
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.
Peut-être même que ça marche déjà, mais comme nous n'avons remarqué la présence des fonctions
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 | ||
| 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 !
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 topLe 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 :
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 | ||
| 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 topLa mémoire de travail en Python va accueillir :
Voici quelques tailles occupées en mémoire par des variables Python :
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 :
Voici la sortie obtenue par l'appel
Le script arrive donc à allouer en mémoire de travail de la TI-83 Premium CE Edition Python jusqu'à 16,899 Ko.
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
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
- 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
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 topEnfin, terminons en voyant les performances. Commençons dans le cadre des nombres entiers avec le script suivant :
La ligne d'appel
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 :
La ligne d'appel
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.
- 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 topLa 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...
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...
