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.
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
(
et Python
)Graph 35+E II
(
. Toutefois la Python
)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.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. 
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.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 :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
Ce module externe est basé matériellement sur une
Mais pour la rentrée 2019,
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
Nous espérions trouver un début de réponse aujourd'hui.
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+ appliPyAdaptr 5.3.5.10avec lefirmwareTI-Python 3.0.0.15
- OS 5.3.5.17+ appliPyAdaptr 5.3.5.17avec lefirmwareTI-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. 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)
TI
, les prototypes DVT
ont un matériel et un logiciel déjà très proches de ceux du modèle de production, les quelques différences visibles pouvant encore concerner le boîtier.Maintenant que nous avons malgré tout trouvé ce qu'il nous fallait, c'est donc parti pour le test !
Sommaire :
Go to top1) Versions système, boot et diagnostic :
Go to topTI-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 version5.3.6
- que l'identifiant du modèle est toujours 13 (en hexadécimal), ce qui suggère donc une compatibilité avec les anciennesTI-83 Premium CE
Effectivement, nous arrivons à y exécuter des applications et programmes assembleur conçus pour les anciennes
TI-83 Premium CE
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 Pythonen bleu en haut à droite, sans doute non affichée si l'on transfère l'OS5.3.6sur un ancien modèle
- une mention POB: 3.00, peut-être pour. LaPython On Boardpyboardintégrée d'une façon ou d'une autre, ferait donc tourner unfirmwareen version3.00, comparable donc auxfirmwarespour le module externe.TI-Python
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 topTI-83 Premium CE
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
. Au lieu d'accéder directement à la liste des programmes TI-84 Plus CE
internationales)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]
seuil(0.02) s'exécute en seulement 16,24s
sur la nouvelle TI-83 Premium CE Edition Python
, contre 31,27s
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
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
48MHz
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 topTI-83 Premium CE Edition Python
l'application qui permet d'accéder aux fonctionnalités Python
ne s'appelle plus PyAdaptr
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
Python
continue à embarquer un firmware
pour une pyboard
qui serait donc intégrée quelque part.Python
refuse de démarrer sur les anciennes TI-83 Premium CE
5.3.5
Et inversement, l'ancienne application
PyAdaptr
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
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
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
.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.
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+TI-Nspire+ module externe TI-Python pour TI-83 Premium CE avec nombres et fonctions complexes
- Casio Graph 35+E II / 90+E / fx-CG50avec nombres complexes
- TI-83 Premium CE Edition Python+ module externeTI-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
On peut certes objecter que peu d'entre eux devraient utiliser le
Toutefois cet argument n'est plus recevable pour le BAC 2020, et il est donc fort dommage que la
Terminale S/STI2D/STL
.On peut certes objecter que peu d'entre eux devraient utiliser le
Python
pour l'algorithmique au BAC 2019, puisque ce n'est qu'à la rentrée 2017 que ce langage est devenu obligatoire en Seconde.Toutefois cet argument n'est plus recevable pour le BAC 2020, et il est donc fort dommage que la
TI-83 Premium CE Edition Python
ne soit apparemment pas prête.5) Liste modules Python :
Go to topTI-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
TI-83 Premium CE
- collections
- random
- array
- gc
- sys
- builtins
- math
- time
MicroPython TI-Nspire | 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 :
- 13modules : module externeTI-Python pour TI-83 Premium CE
- +8modules :TI-83 Premium CE Edition PythonNumWorks+Casio Graph 35+E II / 35+E/USB / 75/85/95 / fx-9750GII / fx-9860G/GII+TI-Nspire+ module externeTI-Python pour TI-83 Premium CE
- 3modules :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 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
Que cela n'ait pas été fait pour le module externe
TI-Python
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
Voici la sortie de l'appel
Confontons cela aux modèles concurrents disposant du module
Comparons particulièrement avec l'implémentation du module externe pour les anciennes , puisque nous avons vu que celle de la nouvelle
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
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 | 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
TI-83 Premium CE
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 scriptsPythonproposant des interfaces et se voulant multi-plateformes, le comportement de la consolePythonvariant 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
Nous n'avons certes pas encore fouillé le code machine, mais vu comme l'implémentation pour les anciennes nous doutons fortement que
Même si cet usage est a priori légal sous la licence
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
TI-83 Premium CE
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
Nous obtenons la sortie suivante :
Grosse suprise, contrairement à l'implémentation du module externe pour les anciennes , le module mais
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 pour les anciennes , le module
Possiblement étrange puisque ce ne sont pas des fonctions
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
Si l'on remonte dans le temps, des fonctions
D'où une hypothèse alternative, il semblerait donc que
Cela impliquerait par extension la possibilité de piloter le robot
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
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
>>>
TI-Python
TI-83 Premium CE
builtins
n'a pas 190
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 | 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
TI-83 Premium CE
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
Contrairement à la concurrence, la
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 pour les anciennes .
Passons donc au bilan tous modules confondus :
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
TI-83 Premium CE
Passons donc au bilan tous modules confondus :
MicroPython TI-Nspire | 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 externeTI-Python pour TI-83 Premium CE
- 310éléments :TI-Nspire
- 301éléments :NumWorks
- 294éléments :Casio Graph 35+E II / 35+E/USB / 75/85/95 / fx-9750GII / fx-9860G/GII
- 260éléments :TI-83 Premium CE Edition Python
- 258éléments : module externeTI-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
Voici quelques tailles occupées en mémoire par des variables
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
La nouvelle pour les anciennes . 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
Toutefois notre fonction pour les anciennes , 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
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
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
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
- 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
- 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
- 19,842 Ko: module externeTI-Python pour TI-83 Premium CE
- 17,192 Ko: module externeTI-Python pour TI-83 Premium CE
- 16,899 Ko:TI-83 Premium CE Edition Python
- 13,658 Ko: calculatriceNumWorks
- 5,946 Ko: logiciel webNumWorks
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
TI-83 Premium CE
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
TI-83 Premium CE
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 pour le module externe sur les anciennes .
Là bizarrement, par rapport au module externe pour les anciennes, nous notons un recul des performances pour la nouvelle
Passons maintenant aux nombres flottants avec le script suivant :
La ligne d'appel pour le module externe sur les anciennes .
Dans des proportions similaires, on confirme donc un léger recul des performances sur la pour les anciennes 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]
test(9,2) se termine en 26,60s
sur la nouvelle TI-83 Premium CE Edition Python
, contre 23,20s
TI-Python
TI-83 Premium CE
D'où le classement suivant pour les performances en calcul entier :
- 1,41s:TI-Nspire(32 bits : ARM9/ARMv5 @120MHz)
- 1,56s:TI-Nspire CM / CX révisions A-V(32 bits : ARM9/ARMv5 @132MHz)
- 2,40s:TI-Nspire CX révisions W+/CR4+(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(32 bits : SH4 @29,5MHz)
- 10,19s:Casio Graph 35+E II(32 bits : SH4 @59MHz)
- 12,99s:Casio Graph 35+USB/75/85/95 SH3 / fx-9750GII SH3 / fx-9860G/GII SH3(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 externeTI-Python pour TI-83 Premium CE(32 bits : Cortex/ARMv7 @48MHz)
- 26,60s:TI-83 Premium CE Edition Python(?)
- 33,48s: module externeTI-Python pour TI-83 Premium CE(32 bits : Cortex/ARMv7 @48MHz)
- 60,71s: application KhiCAS surCasio Graph 90+E / fx-CG50(32 bits : SH4 @118MHz)
- 116,93s: application KhiCAS surCasio fx-CG10/20(32 bits : SH4 @59MHz)
Là bizarrement, par rapport au module externe pour les anciennes
TI-83 Premium CE
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
TI-Python
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-(32 bits : ARM9/ARMv5 @132MHz)
- 1,29s:TI-Nspire(32 bits : ARM9/ARMv5 @120MHz)
- 1,61s:TI-Nspire CX CR4+(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 externeTI-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(32 bits : SH4 @59MHz)
- 11,26s:Casio 35+E/75+E / 35+USB/75/95 SH4 / fx-9750/9860GII SH4(32 bits : SH4 @29,5MHz)
- 11,46s: module externeTI-Python pour TI-83 Premium CE(32 bits : Cortex/ARMv7 @48MHz)
- 13,87s:Casio Graph 35+USB/75/85/95 SH3 / fx-9750GII SH3 / fx-9860G/GII SH3(32 bits : SH3 @29,5MHz)
- 19,98s: application KhiCAS surCasio Graph 90+E / fx-CG50(32 bits : SH4 @118MHz)
- 25,19s:Casio Graph 35+E II(32 bits : SH4 @59MHz)
- 35,55s: application KhiCAS surCasio 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
TI-83 Premium CE
Conclusion :
Go to topLa
Le minimum aurait été d'intégrer une
Mais alors, pourquoi est-elle à la fois beaucoup plus rapide dans le contexte de l'environnement historique, et dans le contexte
On peut avancer l'hypothèse de deux processeurs
Peut-être qu'alors il s'agit d'une nouvelle puce, il y aurait une couche d'émulation
Mais aussi, nous avons cru voir à l'écran de diagnostics que la mémoire
Mais pourquoi la
Il semble que
Nous avons donc hâte de pouvoir découvrir ce que la nouvelle
Vivement cette première calculatrice où l'application
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
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...
