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.
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 !
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.
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.
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.
| | 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.
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
| | NumWorks | Casio
Graph 35+E II
Graph 90+E | | 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.
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 :
| | | 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 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 autreimplementation.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.
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 :
| | NumWorks | Casio
Graph 35+E II
Graph 90+E | | 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 !
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 :
| | NumWorks | Casio
Graph 35+E II
Graph 90+E | | 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
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().
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.
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... 
by 
Nous retrouvons tout ce qui fait les grandes qualités de cette collection et même davantage. Une présentation par blocs de couleur claire au premier regard, l'écriture duale des fonctions en Python (captures d'écran) et en langage naturel (algorithme), la représentation intuitive des touches calculatrices à presser, et les QR codes (certes non encore fonctionnels) permettant d'aller chercher les corrections et compléments éventuels. 
