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.

L'équipe y mettait en avant ses journées d'été
Les activités proposées sur le stand tournaient autour du robot
Les enseignants visitant le stand était pour leur part bien davantage intéressés par les possibilités de programmation en
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.
A priori nous ne voyons malheureusement que des
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

L-DVT-000146
DVT NOT FOR SALE
Il s'agit donc d'un prototype de niveau
Rappelons les différents niveaux de prototypage par lesquels passe un nouveau produit chez
- 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 !

1) Versions système, boot et diagnostic :
Go to top- 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
mode
alpha
S. Et la surprise, nous apprenons l'utilisation d'un tout nouveau
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
2) Performances générales :
Go to topNous notons en passant que la touche
prgmadopte enfin un comportement que nous avions suggéré il y a quelques années pour les seules
- 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 
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

Sur le stand l'équipe
Mais qu'est-ce que

3) Applications Python et PyAdaptr :
Go to topToutefois, avec une taille toujours aussi énorme de
Et inversement, l'ancienne application
4) Ensembles de nombres :
Go to top- 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 precm(10)
nous précise que cela correspond en base décimale à environ 16 chiffres significatifs.Continuons à creuser les flottants avec la fonction
- 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 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) | ✓ | ✓ | ✓ | ✓ |
- 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
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
5) Liste modules Python :
Go to tophelp("modules")
nous liste exactement la même chose qu'avec le module externe - 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 |
- 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
Que cela n'ait pas été fait pour le module externe
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
6) Exploration module sys :
Go to top- 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
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
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'
Nous n'avons certes pas encore fouillé le code machine, mais vu comme l'implémentation
Même si cet usage est a priori légal sous la licence

7) Exploration module builtins :
Go to topNous 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
>>>
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
get()
et send()
.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
get()
et send()
ont justement été rajoutées récemment dans le langage interprété historique des 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.

On peut effectivement reprocher à l'ensemble de la concurrence actuelle de cloisonner l'application

Contrairement à la concurrence, la

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.8) Exploration autres modules Python :
Go to topPassons 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 |
- 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 top- 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
- 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

- 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
Toutefois notre fonction
mem()
a le défaut d'avoir un résultat qui varie selon le contexte Peut-être qu'une amélioration du protocole de test pour une prochaine fois pourrait être de faire la moyenne d'une série d'appels
mem()
.10) Performances Python :
Go to top- 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 - 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
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 - 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
Conclusion :
Go to top
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
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

