π
<-
Chat plein-écran
[^]

Test module TI-Python (version 3.0.0.12)

:32ti73: :32ti73e: :32ti73e2: :32ti76f: :32ti80: :32ti81: :32ti82: :32ti85: :32ti86: :32ti82s: :32ti82sf: :32ti82sfn: :32ti83: :32ti83p: :32ti83pb: :32ti83pr: :32ti83pfr: :32ti83pse: :32ti84p: :32ti84pse: :32ti84ppse: :32ti84pfr: :32ti84pcse: :32ti83pfrusb: :32ti82p: :32ti82a: :32ti84pce: :32ti83pce:

Test module TI-Python (version 3.0.0.12)

Message non lude critor » 13 Fév 2019, 00:35

Edit update: TI a corrigé le problème des flottants dans sa nouvelle version :)
Edit update: TI fixed the floating point issue in the new version :)


10251Depuis trois mois, nous n'avons hélas pas réussi à avoir d'échantillon du module externe TI-Python, ce qui a considérablement compliqué le travail de préparation à chaque fois que nous t'avons fait un article à son sujet.
Aussi l'avons-nous commandé et bien évidemment au prix public, dès le premier jour de sa disponibilité chez Jarrety.
Toutefois, comble de malchance, après deux semaines nous ne l'avons toujours pas reçu.

Aussi, nos plus grands remerciements à nos premiers membres à l'avoir reçu, samourai3745 et zardam, qui n'ont pas hésité à se donner la peine de nous partager informations, photos, archives et même le firmware (microgiciel) en privé.

Plan B, le test du module externe TI-Python a donc été réalisé à partir d'une carte Adafruit Trinket M0 reprogrammée avec le firmware du module externe TI-Python.

Précisons également que nous ne disposons pas non plus des mise à jour et application TI-83 Premium CE compatibles avec ce module, et que ce dernier est donc piloté pour nos tests à partir non pas d'une calculatrice mais d'un ordinateur. Tout ce qui peut donc concerner les qualités ou défauts de l'interface sur TI-83 Premium CE ne sera donc pas abordé ici.

Par ailleurs, la sortie officielle au moins côté logiciel est prévu pour mi-mars, et donc le firmware pourrait être différent d'ici là...

Ces péripéties expliquent également la publication assez tardive de ce test, retard pour lequel nous vous prions de bien vouloir nous excuser.



Sommaire :



1) Premier coup d'oeil :

Go to top

1023910240Les premiers modules externes TI-Python pour TI-83 Premium CE viennent donc d'être livrés par Jarrety. Se présentant sous forme d'une petite brique, ils disposent d'un port USB mini B permettant la connexion directe à la calculatrice, à l'aide du câble USB mini-AUSB mini-B venant avec cette dernière et initialement destiné à l'échange de données entre deux calculatrices.

10242Au dos nous notons le timbre à date L-1118 qui témoigne des date et lieu d'assemblage :
  • en novembre 2018
  • dans l'usine de code L, c'est-à-dire l'usine Kinpo Electronics aux Philippines, ce que confirme la mention "FABRIQUÉ AUX PHILIPPINES"



2) Matériel et spécifications :

Go to top

1021310214Une fois la brique de plastique descellée, on en extrait une simple carte de référence FP17-10-1, pouvant suggérer que TI a finalement été bien plus réactif qu'il n'y paraissait en préparant sa solution Python dès 2017.

La carte s'articule autour d'une unique puce ATSAMD21 de chez Atmel, embarquant :
  • un processeur Cortex-M0+ (ARMv6, Thumb) cadencé à 48 MHz
  • une mémoire Flash de 256 Kio
  • une mémoire SRAM de 32 Kio

Une petite recherche au sujet de cette puce nous apprend son utilisation dans la console de jeux portable française, éducative et rétro Gamebuino META, ou encore pour les cartes de développement Arduino M0 et Zero.

Mais de façon encore plus intéressante, c’est également la puce utilisée dans les PyBoards (cartes de développement Python) Trinket M0 et Feather M0 de chez AdaFruit. :o
Outre une possible compatibilité des firmwares, cela voudra peut-être dire que la base du code logiciel est commune. Auquel cas l’implémentation Python serait du CircuitPython, un dérivé du MicroPython choisi par les constructeurs Casio et NumWorks.



3) Première connexion USB : stockage, version, fonctionnement :

Go to top

Pour les tests qui vont suivre, connectons donc le module externe TI-Python non pas à la calculatrice puisque nous ne disposons pas encore des mise à jour et application nécessaires, mais à l'ordinateur.

Le module externe TI-Python y est détecté avec :
  • le nom TI-Python Adapter
  • un identifiant vendeur 0451 qui est bien celui de Texas Instruments
  • un identifiant produit E020

Mais cela énumère alors non pas un mais plusieurs périphériques supplémentaires, dont :
  • un périphérique de stockage de masse qui, comme une clé USB, offre un espace de stockage nommé Python CE de 58,5 Kio de capacité, et avec 55,5 Kio libres
  • un port série virtuel

Il suffit donc de copier les scripts Python à exécuter sur l'espace de stockage.
C'est donc probablement ce que fait l'application PyAdaptr non publiée à ce jour :
  • copier le script courant lorsque l'on en demande l'exécution
  • copier l'ensemble des scripts de la calculatrice lorsque l'on appelle directement la console Python

Nous notons dans le dossier racine de l'espace de stockage un fichier boot_out.txt de contenu "TI-Python Adapter v3.0.0.12".
Il y a donc un petit peu de travail avec au moins 6 recompilations depuis la version 3.0.0.0006 présentée le 21 octobre 2018 aux journées APMEP à Bordeaux.
Nous avions fait à l'époque un bilan bienveillant et globalement positif de cette version, déplorant certes un gros défaut remonté entre temps en bonne position, mais louant l'énorme travail apparemment accompli, et espérant donc qu'il allait continuer...
A priori, seulement 6 recompilations par rapport à ce qu'il restait à faire ou corriger n'est pas très bon signe, mais nous allons voir.

Nous ignorons ce qui se passe lorsque l'espace libre du module externe TI-Python est épuisé.
Nous ignorons aussi ce que donne cet espace de stockage externe dans le cadre du mode examen.

Par contre, cela implique donc qu'il devrait être possible d'avoir des programmes TI-83 Premium CE gérant la lecture écriture sur clé USB ! :bj:


Le port série virtuel quant à lui nous offre une console Python, et permet donc l'exécution des scripts :
TI-Python a écrit:>>> # Shell Reinitialized
>>> help()
To list built-in modules please do `help("modules")`.
>>>


Notons que l'exécution d'un print(...) ne rend pas automatiquement la main, il faut valider chaque ligne affichée avec le caractère ASCII de contrôle de code 6 (ACK, obtenable au clavier sur la console en faisant
ctrl
F
)
. On peut support qu'il s'agit d'une sorte d'accusé réception dans le contexte de l'affichage déporté de la sortie du print(...) sur la calculatrice TI-83 Premium CE.



4) Liste modules Python :

Go to top

Comme nous y sommes invités, tapons donc help("modules") afin d'avoir la liste de tous les modules Python intégrés :
TI-Python a écrit:>>> # Shell Reinitialized
>>> help()
To list built-in modules please do `help("modules")`.
>>> help("modules")
__main__ collections random
array gc sys
builtins math time
Plus any modules on the filesystem
>>>

__main__ étant le script courant qui ne compte pas, nous avons donc 8 modules intégrés :
  • array
  • builtins
  • collections
  • gc
  • math
  • random
  • sys
  • time
Une implémentation remarquable par sa bibliothèque de modules standard ! :bj:


Pour comparaison :
Image


D'où le classement suivant :
  1. module externe TI-Python avec 8 modules
  2. Casio Graph 35+E/USB 75/85/95 + TI-Nspire + NumWorks (version 10.0.0) avec 7 modules
  3. NumWorks (version 9.2.0) avec 6 modules
  4. Casio Graph 90+E avec 4 modules

En terme d'éventail de modules, le module externe TI-Python pointe donc parmi les meilleures implémentations Python pour calculatrice ! :bj:

Toutefois, l'absence d'un module graphique pour le nouveau programme de Physique-Chimie en Seconde à la rentrée 2019 est préoccupante.



5) Nombres complexes :

Go to top

Un autre grand regret cette fois-ci pour les élèves Terminales S, STI2D et STL, c'est l'absence du module cmath pour les nombres complexes.

Mais même si donc les fonctions complexes (module, argument...) ne sont pas incluses, cela ne veut pas forcément dire que le type nombre complexe n'est pas géré.
Testons :
TI-Python a écrit:>>> # Shell Reinitialized
>>> 1j
Traceback (most recent call last):
File "<stdin>", line 1
SyntaxError: complex values not supported
>>>

Et non, mauvaise nouvelle donc, il n'y a rien sur les nombres complexes. Le module externe TI-Python n'est donc pas au point pour les élèves de Terminale S/STI2D/STL passant leurs épreuves cette année.


Pour comparaison :
Image


D'où le classement suivant :
  1. NumWorks + TI-Nspire + Casio Graph 35+E/USB 75/85/95 avec calculs et fonctions complexes
  2. Casio Graph 90+E avec calculs complexes
  3. module externe TI-Python



6) Exploration module sys :

Go to top

Puisque donc le module sys est inclus dans le module externe TI-Python, tentons d'en apprendre davantage sur ce dernier en effectuant son exploration à l'aide du script suivant que nous copions dans le dossier racine de l'espace de stockage :
Code: Tout sélectionner
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


L'appel explmod(sys) nous produit alors :
TI-Python a écrit:>>> # Shell Reinitialized
>>> from explmod import *
>>> import sys
>>> explmod(sys)
__name__=sys
argv=[]
byteorder=little
exit=<function>
implementation=(name='circuitpython', version=(3, 0, 0))
maxsize=1073741823
modules={}
path=['', '/', '/lib', '.frozen']
platform=TI-Python Adapter
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
>>>


Comme promis, nous en apprenons davantage sur le module externe TI-Python, notamment que contrairement aux autres calculatrices il n'utilise pas MicroPython mais CircuitPython, une implémentation légère en fait dérivée de MicroPython et justement développée par Adafruit pour ses PyBoards.

Niveau implémentation il s'agit apparemment d'un CircuitPython 3.0.0 implémentant du Python 3.4.0.

Notons le sys.platform=='TI-Python Adapter' qui permettra donc à un script de savoir si il tourne sur le module externe TI-Python.

Notons également que lorsque l'on demande au module externe TI-Python d'importer un script, il le recherche apparemment dans l'ordre :
  • dans le dossier courant
  • dans le dossier racine /
  • dans le dossier /lib
  • dans .frozen



7) Nombres entiers courts et longs :

Go to top

L'exploration du module sys nous apprend donc que sys.maxsize==1073741823.

Cette constante indique la borne supérieure pour les valeurs d'entiers courts. Notons que les entiers courts sont représentables nativement dans le langage machine de la plateforme faisant tourner l'implémentation Python.

Les entiers courts peuvent donc ici prendre des valeurs de -230=-1073741824 à 230-1=+1073741823.

Ce qui veut dire que les entiers courts sont ici codés sur 31 bits :
  • 1 bit pour le signe
  • 30 bits pour le nombre non signé

C'est moins que le standard Python qui est de 32 bits (dont 31 bits pour la valeur absolue) sur les plateformes à processeur 32 bits.

Voilà pourquoi nous qualifions plus haut CircuitPython d'implémentation légère, il s'agit donc d'un de ses divers allègements. A priori ici il ne nous semble pas bien pénalisant.


Mais si nous parlons d'entiers courts, c'est qu'il existe des entiers longs. En Python, si une valeur sort de l'intervalle des entiers courts, elle est automatiquement convertie en entier long. Il n'y a alors plus aucune limite, mais à la différence dans ce cas ces valeurs ne seront plus représentables nativement en langage machine.

Ce comportement n'est toutefois valide qu'à condition que le support des entiers longs ait été activé à la compilation. Vérifions cela :
TI-Python a écrit:>>> # Shell Reinitialized
>>> import sys
>>> sys.maxsize+1
Traceback (most recent call last):
File "<stdin>", line 1, in <module>
OverflowError: small int overflow
>>>


Et bien non, il va donc nous falloir retenir que le module externe TI-Python a donc des entiers courts bridés sur 31 bits, et ne gère pas les entiers longs.

Mais puisque cela ne concerne que le contexte des nombres entiers, ce n'est à notre avis pas bien gênant au lycée.


Pour comparaison :
Image


D'où le classement suivant :
  1. NumWorks + TI-Nspire + Casio Graph 35+E/USB 75/85/95 + Casio Graph 90+E avec entiers courts sur 32 bits et entiers longs
  2. module externe TI-Python avec entiers courts sur 31 bits



8) Reference design :

Go to top

Entre la puce Atmel ATSAMD21 et le CircuitPython comme vient de le révéler le module sys cela fait beaucoup de coincidences, beaucoup trop.

Pour nous il est désormais clair que Texas Instruments n'a conçu ni le matériel ni le firmware, et a simplement adapté de l'existant de chez Adafruit.

Le reference design est donc très probablement la Trinket M0 ou la Feather M0.

Les changements apportés incluent entre autres:
  • pour le matériel :
    • remplacement du connecteur USB micro par de l'USB mini
    • retrait de la diode RVB (si Trinket M0)
    • retrait de l'oscillateur à cristal de quartz 32.768 KHz (si Feather M0)
    • retrait du connecteur batterie LiPo (si Feather M0)
    • retrait de la Flash SPI (si Feather M0)
    • probablement divers ajustements pour garantir le bon fonctionnement de l'USB dans le contexte spécifique d'utilisation, c'est-à-dire :
      • alimenté par la calculatrice (variations de voltage)
      • dans un contexte scolaire (nombreux changements de salle et sorties de bâtiment quotidiens et donc variations de température)
  • pour le logiciel :
    • couche de communication bidirectionnelle avec l'application PyAdaptr de la calculatrice



9) Exploration fonctions builtins :

Go to top

Voyons maintenant l'éventail des capacités du module en explorant les fonctions builtins à l'aide du script suivant :
Code: Tout sélectionner
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


L'appel explmod(builtins) nous produit alors :
Code: Tout sélectionner
>>> # 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'>
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>
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: 190 item(s)
190
>>>


Pour comparaison :
NumWorks
Casio
Graph 90+E
module externe
TI-Python
ArithmeticError<0>
AssertionError<0>
AttributeError<0>
BaseException<1>
EOFError<0>
Ellipsis=Ellipsis
Exception<0>
GeneratorExit<0>
ImportError<0>
IndentationError<0>
IndexError<0>
KeyError<0>
KeyboardInterrupt<0>
LookupError<0>
MemoryError<0>
NameError<0>
NotImplemented=NotImplemented
NotImplementedError<0>
OSError<0>
OverflowError<0>

RuntimeError<0>
StopIteration<0>
SyntaxError<0>
SystemExit<0>
TypeError<0>
UnicodeError<0>
ValueError<0>
ViperTypeError<0>
ZeroDivisionError<0>
__build_class__()
__import__()

__repl_print__()
abs()
all()
any()
bin()
bool<0>
bytearray<2>
bytes<26>
callable()
chr()
classmethod<0>
compile()
complex<0>
dict<14>
dir()
divmod()
enumerate<0>
eval()
exec()
filter<0>
float<0>
frozenset<18>
getattr()
globals()
hasattr()
hash()


hex()
id()
input()

int<2>
isinstance()
issubclass()
iter()
len()
list<11>
locals()
map<0>
max()
memoryview<0>
min()
next()
object<2>
oct()
open()
ord()
pow()
print()
property<3>
range<0>
repr()
reversed<0>
round()
set<18>
setattr()

sorted()
staticmethod<0>
str<26>
sum()
super<0>
tuple<2>
type<0>
zip<0>
ArithmeticError<0>
AssertionError<0>
AttributeError<0>
BaseException<0>
EOFError<0>
Ellipsis=Ellipsis
Exception<0>
GeneratorExit<0>
ImportError<0>
IndentationError<0>
IndexError<0>
KeyError<0>
KeyboardInterrupt<0>
LookupError<0>
MemoryError<0>
NameError<0>

NotImplementedError<0>
OSError<0>
OverflowError<0>

RuntimeError<0>
StopIteration<0>
SyntaxError<0>
SystemExit<0>
TypeError<0>

ValueError<0>

ZeroDivisionError<0>
__build_class__()
__import__()
__name__=builtins
__repl_print__()
abs()
all()
any()
bin()
bool<0>

bytes<22>
callable()
chr()
classmethod<0>

complex<0>
dict<14>
dir()
divmod()
enumerate<0>
eval()
exec()
filter<0>
float<0>
frozenset<9>
getattr()
globals()
hasattr()
hash()


hex()
id()
input()

int<2>
isinstance()
issubclass()
iter()
len()
list<11>
locals()
map<0>
max()

min()
next()
object<0>
oct()
open()
ord()
pow()
print()

range<0>
repr()
reversed<0>
round()
set<18>
setattr()
slice<0>
sorted()
staticmethod<0>
str<22>
sum()
super<0>
tuple<2>
type<0>
zip<0>
ArithmeticError<0>
AssertionError<0>
AttributeError<0>
BaseException<0>
EOFError<0>
Ellipsis=Ellipsis
Exception<0>
GeneratorExit<0>
ImportError<0>
IndentationError<0>
IndexError<0>
KeyError<0>
KeyboardInterrupt<0>
LookupError<0>
MemoryError<0>
NameError<0>

NotImplementedError<0>
OSError<0>
OverflowError<0>

RuntimeError<0>
StopIteration<0>
SyntaxError<0>
SystemExit<0>
TypeError<0>

ValueError<0>

ZeroDivisionError<0>
__build_class__()
__import__()
__name__=builtins
__repl_print__()
abs()
all()
any()
bin()
bool<0>

bytes<22>
callable()
chr()
classmethod<0>

complex<0>
dict<14>
dir()
divmod()

eval()
exec()

float<0>

getattr()
globals()
hasattr()
hash()


hex()
id()
input()

int<2>
isinstance()
issubclass()
iter()
len()
list<11>
locals()
map<0>
max()

min()
next()
object<0>
oct()
open()
ord()
pow()
print()

range<0>
repr()

round()
set<18>
setattr()
slice<0>
sorted()
staticmethod<0>
str<22>
sum()
super<0>
tuple<2>
type<0>
zip<0>
ArithmeticError<0>
AssertionError<0>
AttributeError<0>
BaseException<0>
EOFError<0>
Ellipsis=Ellipsis
Exception<0>
GeneratorExit<0>
ImportError<0>
IndentationError<0>
IndexError<0>
KeyError<0>
KeyboardInterrupt<0>
LookupError<0>
MemoryError<0>
NameError<0>

NotImplementedError<0>
OSError<0>
OverflowError<0>

RuntimeError<0>
StopIteration<0>
SyntaxError<0>
SystemExit<0>
TypeError<0>

ValueError<0>

ZeroDivisionError<0>
__build_class__()
__import__()
__name__=builtins
__repl_print__()
abs()
all()
any()
bin()
bool<0>
bytearray<2>
bytes<26>
callable()
chr()
classmethod<0>

complex<0>
dict<14>
dir()
divmod()
enumerate<0>
eval()
exec()
filter<0>
float<0>
frozenset<9>
getattr()
globals()
hasattr()
hash()


hex()
id()
input()

int<2>
isinstance()
issubclass()
iter()
len()
list<11>
locals()
map<0>
max()
memoryview<0>
min()
next()
object<0>
oct()
open()
ord()
pow()
print()
property<3>
range<0>
repr()
reversed<0>
round()
set<18>
setattr()
slice<0>
sorted()
staticmethod<0>
str<26>
sum()
super<0>
tuple<2>
type<0>
zip<0>
ArithmeticError<0>
AssertionError<0>
AttributeError<0>
BaseException<1>
EOFError<0>
Ellipsis=Ellipsis
Exception<0>
GeneratorExit<0>
ImportError<0>
IndentationError<0>
IndexError<0>
KeyError<0>
KeyboardInterrupt<0>
LookupError<0>
MemoryError<0>
NameError<0>

NotImplementedError<0>
OSError<0>
OverflowError<0>
ReloadException<0>
RuntimeError<0>
StopIteration<0>
SyntaxError<0>
SystemExit<0>
TypeError<0>
UnicodeError<0>
ValueError<0>

ZeroDivisionError<0>
__build_class__()
__import__()
__name__=builtins
__repl_print__()
abs()
all()
any()
bin()
bool<0>
bytearray<2>
bytes<22>
callable()
chr()
classmethod<0>


dict<14>
dir()
divmod()
enumerate<0>
eval()
exec()
filter<0>
float<0>

getattr()
globals()
hasattr()
hash()
help()
help()
hex()
id()
input()
input()
int<2>
isinstance()
issubclass()
iter()
len()
list<11>
locals()
map<0>
max()
memoryview<0>
min()
next()
object<0>
oct()
open()
ord()
pow()
print()
property<3>
range<0>
repr()

round()
set<18>
setattr()
slice<0>
sorted()
staticmethod<0>
str<22>
sum()
super<0>
tuple<2>
type<0>
zip<0>
218188175204190


D'où le classement suivant :
  1. TI-Nspire avec 218 entrées
  2. Casio Graph 35+E/USB 75/85/95 avec 204 entrées
  3. module externe TI-Python avec 190 entrées
  4. NumWorks avec 188 entrées
  5. Casio Graph 90+E avec 175 entrées
Le module externe TI-Python se classe donc ici honorablement, avec en builtins 93% de ce qu'offrent les Casio Graph 35/75/85/95, ou encore 87% de ce qu'offrent les TI-Nspire ! :bj:



10) Exploration module math :

Go to top

Sachant qu'ici nous avons un produit censé cibler le lycée, explorons les capacités offertes par le module math à l'aide du script suivant :
Code: Tout sélectionner
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


L'appel explmod(math) nous produit alors :
TI-Python a écrit:>>> # Shell Reinitialized
>>> from explmod import *
>>> import math
>>> explmod(math)
__name__=math
acos=<function>
asin=<function>
atan=<function>
atan2=<function>
ceil=<function>
copysign=<function>
cos=<function>
degrees=<function>
e=2.71828
exp=<function>
fabs=<function>
floor=<function>
fmod=<function>
frexp=<function>
isfinite=<function>
isinf=<function>
isnan=<function>
ldexp=<function>
log=<function>
modf=<function>
pi=3.14159
pow=<function>
radians=<function>
sin=<function>
sqrt=<function>
tan=<function>
trunc=<function>
Total: 28 item(s)
28
>>>


Pour comparaison :
Image


Comme avec la Casio Graph 90+E, nous remarquons que Texas Instruments nous a effectué une sélection, et a retiré ce qui a été jugé inutile au lycée. Fonctions hyperboliques et raccourcis d'exponentielles et logarithmes notamment.

Notons toutefois que cette sélection est un peu plus riche que sur Casio Graph 90+E, avec entre autres les fonctions relatives à l'infini et les conversions d'angles entre radians et degrés.


D'où le classement suivant :
  1. Casio Graph 35+E/USB 75/85/95 + TI-Nspire + NumWorks avec 41 entrées
  2. module externe TI-Python avec 28 entrées
  3. Casio Graph 90+E avec 23 entrées

Par contre, ce qui est très perturbant c'est qu'apparemment math.pi==3.14159 sur le module externe TI-Python, et non pas math.pi=3.141592653589793 comme sur toutes les solutions concurrentes.

Pareil avec math.e==2.71828 au lieu de math.e==2.718281828459045.

Un problème avec la précision des décimales ? Parce que ce n'est pas possible, elle serait inférieur à ce qu'offre une calculatrice 4 opérations du primaire...



11) Nombres flottants et précision :

Go to top

Creusons donc le problème du math.pi==3.14159. Les nombres décimaux sont en fait calculés en virgule flottante, soit sous la forme
$mathjax$\pm M\times 2^{E-E_{min}}$mathjax$
avec
$mathjax$M\in [1;2[$mathjax$
, mais avec des codages différents selon que l'on travail en 32 bits ou 64 bits, dits en simple et double précision.

En Python voici les répartitions usuelles des codages :
  • simple précision / 32 bits :
    • 1 bit pour le signe de la mantisse M
    • 23 bits pour la valeur absolue de la mantisse M (qui en fait peut prendre des valeurs sur 24 bits, puisque le 1 systématique de la partie entière n'est pas stocké)
    • 8 bits pour l'exposant E
  • double précision / 64 bits :
    • 1 bit pour le signe de la mantisse M
    • 52 bits pour la valeur absolue de la mantisse M (qui en fait peut prendre des valeurs sur 53 bits)
    • 11 bits pour l'exposant E

Testons donc la précision des mantisses et exposants sur le module externe TI-Python à l'aide du script suivant :
Code: Tout sélectionner
def precm(b):
  k,b=0,float(b)
  while 1+b**-k-1>0:
    k+=1
  return k

def prece():
  k=0
  while 2.**-k>0:
    k+=1
  em=-k+1
  k=0
  while str(2.**(em+2**k))[0:3]!='inf':
    k+=1
  return k


Voici la sortie obtenue :
TI-Python a écrit:>>> # Shell Reinitialized
>>> from prec import *
>>> precm(2)
22
>>> precm(10)
7
>>> prece()
9


Le module externe TI-Python est donc capable de représenter des nombres flottants
$mathjax$\pm M\times 2^{E-E_{min}}$mathjax$
avec :
  • des valeurs absolues de mantisses M sur 22 bits (soit environ 7 chiffres significatifs)
  • des exposants E sur 9 bits

Pour comparaison :
Image


D'où le classement :
  1. TI-Nspire + NumWorks + Casio Graph 90+E + Casio Graph 35/75/85/95 avec 53+12 bits
  2. HP Prime avec 48+12 bits
  3. Casio Graph 90+E avec KhiCAS avec 45+12 bits
  4. module externe TI-Python avec 22+9 bits

C'est donc pire que le standard flottants en simple précision, puisqu'au lieu de 24 bits codés sur 23 bits, nous avons donc sur le module externe TI-Python 22 bits codés sur 21 bits, soit environ 7 chiffres significatifs.

Et déjà, le standard 24/23 bits est considéré comme n'étant jamais suffisant, à partir du moment où il y a besoin de calculs décimaux.

Une catastrophe, si ça reste en l'état !


Pourquoi ? Nous n'allons sûrement rien apprendre à un constructeur de calculatrices, mais comme toute représentation en virgule flottante tu vas avoir facilement des erreurs de calcul qui vont se propager sur le dernier chiffre significatif, puis l'avant-dernier et ainsi de suite. Mais ici avec seulement dans les 7 chiffres significatifs, ces erreurs vont donc facilement atteindre des chiffres recopiables sur ta copie !

Quelques exemples :
  1. Simple algorithme de somme :
    Code: Tout sélectionner
    def sumr(n,a,b,d=1):
      s=0
      for k in range(a,b+d,d):
        s+=1/k**n
      return s


    L'appel sumr(-0.1,195,1,-1) fournit la sortie suivante sur le module externe TI-Python :
    TI-Python a écrit:>>> # Shell Reinitialized
    >>> from sumr import *
    >>> sumr(-0.1,195,1,-1)
    300.788
    >>>

    Or, la bonne approximation au millième près n'est pas 300,788 mais 300,792 comme le dit unanimement la concurrence !
    Image

    Mais le pire est à venir, lorsque nous allons enchaîner des calculs différents...
  2. Passons au niveau Première avec les racines d'un polynôme du second degré :
    Code: Tout sélectionner
    from math import *

    def roots(a,b,c):
      d=b*b-4*a*c
      print("delta=b^2-4ac="+str(delta))
      if d<0:
        print("delta<0")
        print("pas de racine reelle")
        return
      else:
        w=sqrt(d)
        x1=(-b+w)/(2*a)
        if d==0:
          print("delta=0")
          print("1 racine double")
          print("x=-b/(2a)="+str(x1))
          return x1
        else:
          x2=(-b-w)/(2*a)
          print("delta>0")
          formule="racine(delta)"
          print("2 racines")
          print("x1=(-b+"+formule+")/(2a)="+str(x1))
          print("x2=(-b-"+formule+")/(2a)="+str(x2))
          return x1,x2


    L'appel roots(1281.421,2562.8424,1281.421) fournit la sortie suivante sur le module externe TI-Python :
    TI-Python a écrit:>>> # Shell Reinitialized
    >>> from roots import *
    >>> roots(1281.421,2562.8424,1281.421)
    delta=b^2-4ac=0.0
    delta=0
    1 racine double
    x=-b/(2a)=-1.0
    -1.0
    >>>

    Les conséquences ici vont bien au-delà d'une erreur de calcul pardonnable, puisque tout le raisonnement est faux. Il n'y a pas une racine double mais 2 racines distinctes, car en fait le discriminant n'est pas nul, loin de là ! Le discriminant vaut un peu plus de 2 comme l'indique unanimement la concurrence !
    Image


    Même la TI-83 Premium CE dit pareil avec son moteur de calcul historique !

    Le pire, c'est donc qu'utiliser le module externe TI-Python censé améliorer ta TI-83 Premium CE en dégrade en fait les capacités de calcul !

    Et note bien qu'ici, les deux racines sont pourtant suffisamment distinctes, la différence étant bien loin de concerner les seuls deux derniers chiffres significatifs.

    Tu penses peut-être qu'il te suffira d'arrondir à l'unité pour ne pas avoir faux en recopiant les affichages de ton module externe TI-Python ? Et bien non, ne crois pas être à l'abri pour autant...
  3. Passons au niveau Terminale, avec un algorithme de seuil sur une suite convergente :
    Code: Tout sélectionner
    def seuil(d):
      n,u,l,d=0,2.,1,d**2
      while (u-l)**2>=d:
        u,n=1+(1/((1-u)*(n+1))),n+1
        print(n,u)
      return n


    Avec la ligne d'appel seuil(0.01), demandons au module externe TI-Python à partir de quel rang nous seront à moins d'un centième de la limite de la suite, ici 1 :
    TI-Python a écrit:>>> # Shell Reinitialized
    >>> from seuil import *
    >>> seuil(0.01)
    [...]
    5842 1.01001
    5843 0.982895
    5844 1.01
    5845 0.982897
    5846 1.01
    5847 0.9829
    5848 1.01
    5848
    >>>


    Sauf que ce n'est pas à partir du rang n=5848 que les termes de la suite rentrent dans l'intervalle [0,99;1,01]. Cette valeur est complètement délirante, puisque c'est en fait à partir du rang n=6366 comme le crie unaniment la concurrence :
    Image


    Si si, même la TI-83 Premium CE est d'accord et même doublement !

    Si tu crois avoir vu le pire avec un millier de différence, attends-toi à être surpris(e)...
  4. Restons sur les suites de Terminale, mais cette fois-ci en spécialité avec une suite récurrente d'ordre 2 :
    Code: Tout sélectionner
    from math import *

    def u(n):
      k=0
      uc=1
      un=1-sqrt(2)
      for k in range(n):
        t=2*un+uc
        uc=un
        un=t
      return uc

    def table(u,n):
      for i in range(n):
        print(i,u(i))


    Avec la ligne d'appel table(u,23), nous obtenons sur le module externe TI-Python :
    TI-Python a écrit:>>> # Shell Reinitialized
    >>> from suite2 import *
    >>> table(u,23)
    0 1
    1 -0.414213
    2 0.171574
    3 -0.0710659
    4 0.0294418
    5 -0.0121822
    6 0.00507736
    7 -0.00202751
    8 0.00102234
    9 1.71661e-05
    10 0.00105667
    11 0.00213051
    12 0.00531769
    13 0.0127659
    14 0.0308495
    15 0.0744648
    16 0.179779
    17 0.434023
    18 1.04782
    19 2.52967
    20 6.10717
    21 14.744
    22 35.5952


    De quoi conjecturer une suite croissante divergeant vers +∞ ?...

    Et bien non, perdu, cette suite converge vers 0 comme la concurrence te le dira :
    Image


    Même la TI-83 Premium CE abonde dans le même sens :

    Mais attends, tu n'as pas tout vu, on peut avoir pire qu'un résultat faux : pas de résultat du tout !...
  5. Terminons en redescendant au niveau Première, avec l'approche du nombre dérivé par la limite du taux de variation :
    Code: Tout sélectionner
    def f(x):
      return x*x*x

    def ta1(f,x,h):
      return (f(x+h)-f(x))/h

    def ta2(f,x,h):
      return (f(x+2*h)-2*f(x+h)+f(x))/h/h

    def table(f,x,n):
      for k in range(n):
        h=10**-k
        print(h,ta1(f,x,h),ta2(f,x,h))


    Tapons table(f,1,7) pour approcher sur le module externe TI-Python les dérivées première et seconde de la fonction d'expression
    $mathjax$f(x)=x^3$mathjax$
    en x=1 :
    TI-Python a écrit:>>> # Shell Reinitialized>>> from table import *
    >>> table(f,1,7)
    1 7.0 12.0
    0.1 3.30999 6.60005
    0.01 3.02997 6.07967
    0.001 3.00264 5.72205
    0.0001 2.98977 143.051
    1e-05 3.00407 0.0
    1e-06 2.86102 0.0
    >>>


    Et bien c'est pire que d'habitude... l'affichage est tout simplement inexploitable, aucune conjecture n'est possible.

    En fait, la dérivée seconde se met à délirer dès la 4ème itération pour devenir aberrante dès la 5ème. La dérivée première sort quant à elle définitivement des clous à la 7ème itération.

    Les valeurs que l'ensemble de la concurrence permettent de conjecturer sont f'(1)=3 et f''(1)=6 :
    Image

Précisons que ces problèmes peuvent également être déclenchés avec une précision de flottants sur 53 bits.

Mais voilà avec seulement 22 bits soit 7 chiffres significatifs, sur le module externe TI-Python ils se déclenchent beaucoup plus tôt dans les itérations ou récursions.

Comme de plus tu n'as donc que 7 chiffres significatifs, les erreurs vont très rapidement altérer la partie utile du résultat, celle que tu as l'habitude de recopier. Avec des conséquences désagréables lors d'une évaluation, notamment si tu omets la justification.

Et ça encore, c'est quand le résultat n'est pas totalement aberrant ou inexploitable...

Le comble étant que toute la concurrence, la TI-83 Premium CE, les calculatrices scientifique du collège et même les calculatrices 4 opérations du primaire n'ont pas ce défaut !

Bref, nous espérons que Texas Instruments remédie à cette situation problématique d'ici la sortie officielle en mi-mars...



12) Exploration autres modules :

Go to top

Terminons maintenant avec l'exploration des modules array, collections, gc, random et time à l'aide du script suivant :
Code: Tout sélectionner
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 obtenue :
TI-Python a écrit:>>> # Shell Reinitialized
>>> import array
>>> explmod(array)
__name__=array
array=<class 'array'>
.append=<function>
.extend=<function>
.Total: 2 item(s)
Total: 4 item(s)
4
>>> import collections
>>> explmod(collections)
__name__=collections
namedtuple=<function>
Total: 2 item(s)
2
>>> import gc
>>> explmod(gc)
__name__=gc
collect=<function>
disable=<function>
enable=<function>
isenabled=<function>
mem_alloc=<function>
mem_free=<function>
Total: 7 item(s)
7
>>> import random
>>> explmod(random)
__name__=random
choice=<function>
getrandbits=<function>
randint=<function>
random=<function>
randrange=<function>
seed=<function>
uniform=<function>
Total: 8 item(s)
8
>>> import time
>>> explmod(time)
__name__=time
monotonic=<function>
sleep=<function>
struct_time=<class 'struct_time'>
Total: 4 item(s)
4


Comparaison bilan qui en découle :
Image


D'où le classement final sur les entrées offertes :
  1. TI-Nspire avec 307 entrées
  2. NumWorks (version 10.0.0) avec 295 entrées
  3. Casio Graph 35+E/USB 75/85/95 avec 288 entrées
  4. module externe TI-Python avec 258 entrées
  5. NumWorks (version 9.2.0) avec 257 entrées
  6. Casio Graph 90+E avec 206 entrées



13) Mémoire de travail :

Go to top

La mémoire de travail en Python va accueillir :
  • les définitions globales (variables, fonctions, classes) issues des scripts importés
  • les arguments d'appel de la ou des fonctions en cours d'exécution
  • les définitions locales effectuées par la ou les fonctions en cours d'exécution
La taille de la mémoire de travail conditionne donc jusqu'où il sera possible d'aller en Python, nombre d'appels récursifs par exemple.

Voici quelques tailles occupées en mémoire par des variables Python :
  • 64 octets pour une liste vide
  • 8 octets par élément de liste supplémentaire
  • 24 octets pour un entier nul
  • 28 octets pour un entier court non nul
  • 49 octets pour une chaîne vide
  • 1 octet par caractère de chaîne supplémentaire

En se basant sur ces tailles, le script suivant permet d'estimer la capacité de la mémoire de travail en allouant plusieurs blocs de mémoire :
Code: Tout sélectionner
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 :
TI-Python a écrit:>>> # Shell Reinitialized
>>> from mem import *
>>> mem()
+ 8196
+ 4096
+ 2176
+ 1428
+ 512
+ 408
+ 252
+ 80
+ 32
+ 4
+ 4
+ 4
17192
>>>


L'on dispose donc sur le module externe TI-Python d'une mémoire de travail de 17,192Ko, ce qui est bien cohérent avec la capacité SRAM de 32Kio vue plus haut.
Cette mémoire de travail comporte donc entre autres ici des blocs continus de 8Kio et 4Kio pour les plus importants.

D'où le classement :
  1. TI-Nspire avec 2,046Mo
  2. Casio Graph 90+E avec 1,027Mo
  3. Casio Graph 35+E/75+E / 35+USB/75/95 SH4 avec 255,07Ko
  4. Casio Graph 35+USB/75/85/95 SH3 avec 30,147Ko
  5. module externe TI-Python avec 17,192Ko
  6. calculatrice NumWorks avec 13,658Ko
  7. logiciel web NumWorks avec 5,946Ko

17K pour le module externe TI-Python c'est donc un petit peu mieux que la NumWorks qui a bien des difficultés avec les fonctions récursives, mais cela reste encore bien faible.



14) Performances :

Go to top

Voyons maintenant les performances relatives du module externe TI-Python.

Afin d'être équitable, le script de test ne doit pas utiliser de nombre flottants. Contentons-nous donc d'un script travaillant sur des entiers, et ne nécessitant pas d'entiers longs :
Code: Tout sélectionner
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 23,20s sur le module externe TI-Python.

Une fois le script exécuté à l'identique sur les autres plateformes, voici le classement obtenu :
  1. TI-Nspire en 1,41s
  2. TI-Nspire CX CR3- en 1,56s
  3. TI-Nspire CX CR4+ en 2,40s
  4. NumWorks en 3,74s
  5. Casio Graph 90+E en 4,75s
  6. HP Prime G2 en 8,81s
  7. Casio Graph 35+E/75+E / 35+USB/75/95 SH4 en 9,78s
  8. HP Prime G1 en 20,73s
  9. module externe TI-Python en 23,20s
  10. Casio Graph 90+E avec KhiCAS en 60,71s

Notons toutefois que les HP Prime et KhiCAS ne disposent pas d'une véritable implémentation Python, mais d'une couche de traduction vers leur langage de programmation historique. Aussi, vouloir comparer les performances n'est peut-être pas très pertinent.

Si nous retirons donc les HP Prime et KhiCAS, le module externe TI-Python arrive alors de loin à la dernière place, un peu plus de 2 fois plus lent que les Casio Graph 35/75/95.



15) Connexion USB en mode mise à jour :

Go to top

Sur l'Adafruit Trinket M0, enchaîner rapidement deux pressions sur le bouton reset redémarre la carte en mode mise à jour.

Nous avons alors dans ce cas accès un espace de stockage de 4 Mo dénommé TRINKETBOOT.

Nous y trouvons un fichier CURRENT.UF2 de 512 Kio qui est en fait une copie du firmware actuellement installé au format UF2. Le firmware peut donc être facilement sauvegardé, et mis à jour par simple copie d'un nouveau fichier UF2.

Nous trouvons également un fichier INFO_UF2.TXT de contenu :
Adafruit Trinket M0 a écrit:UF2 Bootloader v1.23.0 SFHR
Model: Trinket M0
Board-ID: SAMD21E18A-Trinket-v0


Notre Adafruit Trinket M0 démarre donc sur un boot en version 1.23.0 SFHR.

10242Or un bouton reset est toujours présent sur le module externe TI-Python, et selon zardam qui a testé pour nous ce mode de démarrage spécial est toujours présent ! :bj:


Le contenu du fichier INFO_UF2.TXT est légèrement différent :
TI-Python a écrit:UF2 Bootloader v1.0.3U SFRO
Model: TI-Python Adapter
Board-ID: TI Python Adapter


Nous ignorons pourquoi, mais Texas Instruments s'est donc donné la peine de se développer une toute nouvelle version du boot puisque inconnue de Google, la 1.0.3 SFRO.

Et en fait nous ne tardons pas à découvrir une des choses qui ont été changées, le fichier CURRENT.UF2 bien que toujours présent et de bonne taille, ne contient rien d'intéressant.

Nous ignorons si cette fonctionnalité a été cassé involontairement, ou si Texas Instruments ne l'a pas fait exprès pour mettre des bâtons dans les roues à ceux qui voudraient récupérer le firmware, ce qui ne nous étonnerait absolument pas de la part de ce constructeur.



16) Dumping et compatibilités :

Go to top

10213Pas de possibilité donc de récupérer le firmware via le mode mise à jour du boot, mais zardam a trouvé une interface SWD sur les points de test TP7 (SWDCLK) et TP8 (SWDIO). C'est ainsi qu'il a pu copier le firmware et nous le passer, rendant ainsi ce test possible.

10251Le firmware du module externe TI-Python fonctionne donc parfaitement selon nos tests sur la carte Adafruit Trinket M0 (sa diode RVB devenant alors inutilisable), ainsi que sur la carte Arduino M0 selon les tests de zardam.

Il est probable que le firmware fonctionne également sur les cartes Adafruit Feather M0 et Arduino Zero car munies de la même puce Atmel ATSAMD21.

Des alternatives donc intéressantes si jamais la disponibilité du module externe TI-Python venait à faire défaut un jour !

De plus, certaines de ces cartes sont à la différence facilement trouvables pour moins de 10€ !

Enfin, les dimensions de la carte Adafruit Trinket M0 sont nettement inférieures à celles de la carte du module externe TI-Python, ce qui la rend beaucoup plus intéressante pour tenter de la faire rentrer dans une calculatrice TI-Premium CE, et avoir ainsi un module interne et donc parfaitement autorisé aux examens en France. :bj:

Précisons toutefois que, ne disposant pas des mise à jour et application nécessaires, nous n'avons pas pu tester sur calculatrice.

Il n'est pas garanti que l'application PyAdaptr acceptera de fonctionner avec un firmware tournant sur une carte non officielle.



Conclusion :

Go to top

Lors de notre premier contact avec le module externe TI-Python en octobre dernier, nous avions été très impressionnés. Nous le sommes sans doute moins aujourd'hui, après avoir donc découvert que le logiciel et le matériel avaient été repris de chez Adafruit. L'essentiel du travail visible effectué par Texas Instruments ne concernerait donc plus que l'application PyAdaptr et la future mise à jour 5.3.5 qui va avec, éléments qui ne font pas partie de ce test.

Pour la faible capacité de stockage (58,5 Kio même si il y a pire chez la concurrence), elle sera à re-tester dans le contexte d'une vraie calculatrice chargée avec plus de 60K de scripts Python, ainsi qu'en mode examen.

Pour le reste nous pouvons excuser l'absence de gestion des entiers longs, la faible mémoire de travail (17Ko) ou encore les faibles performances...

Nous pouvons même excuser l'absence de gestion des nombres complexes puisque les élèves étant en Terminale S/STI2D/STL cette année ont donc eu droit à l'ancien programme de Seconde qui n'imposait pas encore un enseignement exclusivement en langage Python.

Nous pouvons également excuser l'absence d'un module graphique, puisqu'il ne sera nécessaire avant la rentrée 2019 pour le nouveau programme de Physique-Chimie en Seconde.

Edit update: TI a corrigé le problème des flottants dans sa nouvelle version :)
Edit update: TI fixed the floating point issue in the new version :)


Mais nous ne pouvons pas passer l'éponge sur l'absence de gestion des nombres flottants en double précision.
En l'état actuel sur donc cette version 3.0.0.12 la précision en calcul décimal du module externe TI-Python est inférieure à ce qu'offre une calculatrice basique 4 opérations de primaire. Comme vu plus haut nombre d'activités numériques au programme de Mathématiques du lycée pourront conduire à des résultats faux, aberrants ou même totalement inexploitables, et ce avec une probabilité bien supérieure par rapport aux solutions concurrentes !

Or, si le module externe TI-Python n'est pour l'instant pas utilisable en Physique-Chimie à la rentrée 2019, le minimum serait quand même qu'il soit sereinement utilisable en Mathématiques.
Si il peut être fort intéressant d'évoquer en classe la représentation interne des nombres décimaux pour expliquer pourquoi le module externe TI-Python a faux, les conséquences lors d'une évaluation écrite seront moins drôles, particulièrement pour les réponses qui ne seront pas accompagnées d'une justification et c'est (hélas) régulièrement le cas en algorithmique au BAC.

Adafruit ne va sûrement pas corriger cela ni accepter de contribution à son code en ce sens, because it's not a bug it's a feature. CircuitPython est volontairement une version très allégée de MicroPython afin de pouvoir tourner sur des cartes de développement peu puissantes, ce qui permet accessoirement à Adafruit de vendre d'autres cartes aux capacités de calcul améliorées (cartes Express notamment).

Ce serait donc à Texas Instruments de corriger, et tout espoir n'est pas encore perdu puisqu'une mise à jour du module externe TI-Python peut encore sortir à l'occasion de la future publication des application PyAdaptr et mise à jour 5.3.5 pour TI-83 Premium CE prévue pour mi-mars 2019.
En effet, nous avons signalé ce défaut en très bonne position en novembre 2018, et le module externe TI-Python ici testé a justement été assemblé en novembre 2018. Il ne pouvait donc pas encore disposer des améliorations que nous avons indiquées comme souhaitables, ou essentielles dans le cas qui nous intéresse ici.

Peut-être que le choix de partir sur une implémentation CircuitPython était dès le départ une erreur, celle-ci nous semblant plutôt orientée pour une découverte du Python auprès d'un jeune public voir pour des projets technologiques, et certainement pas pour le contexte scientifique du lycée.

Mais le constructeur Texas Instruments va-t-il donc se donner la peine de corriger CircuitPython alors qu'il donne au contraire l'impression d'avoir rogné au maximum les coûts du module externe TI-Python (pour pouvoir en offrir 70000 aux enseignants), en reprenant les matériel et firmware ouverts d'Adafruit ? Un changement aussi profond dans le coeur de l'interpréteur Python impliquera d'autres coûts, puisque comme il ne sera pas accepté par Adafruit il faudra le réappliquer et retester à chaque mise à jour de CircuitPython !
Nous ignorons la réponse mais le découvrirons bientôt, et la négative serait inexcusable.

Il n'en reste pas moins que le module externe TI-Python nous est fort sympathique. L'idée de pouvoir enfin exécuter du code Python sur TI-83 Premium CE ça nous fait quelque chose, et à part de réinvestir dans une autre calculatrice il n'y a de toutes façons aucune autre alternative à ce jour.

Surtout, l'implémentation Python de ce module a le bel avantage ne pas être aseptisée contrairement à certaines implémentations officielles sorties pour des calculatrices concurrentes. Nous avons en effet les modules array, collections, gc, time et même sys... un vrai Python cette fois-ci quoi ! :bj:
Image
Avatar de l’utilisateur
critorAdmin
Niveau 19: CU (Créateur Universel)
Niveau 19: CU (Créateur Universel)
Prochain niv.: 41.4%
 
Messages: 41455
Images: 14353
Inscription: 25 Oct 2008, 00:00
Localisation: Montpellier
Genre: Homme
Calculatrice(s):
MyCalcs profile
YouTube: critor3000
Twitter/X: critor2000
GitHub: critor

Re: Test module TI-Python (version 3.0.0.12)

Message non lude Noury » 13 Fév 2019, 01:12

Quel boulot !
Franchement, bravo.
Et puis au passage, j'aurai appris des choses sur les entiers long en Python 3 ;)
Avatar de l’utilisateur
NouryVIP++
Niveau 11: LV (Légende Vivante)
Niveau 11: LV (Légende Vivante)
Prochain niv.: 52.5%
 
Messages: 287
Inscription: 07 Sep 2018, 09:19
Localisation: Sceaux, France 92
Genre: Homme
Calculatrice(s):
MyCalcs profile

Re: Test module TI-Python (version 3.0.0.12)

Message non lude Hayleia » 13 Fév 2019, 06:54

Une petite recherche au sujet de cette puce nous apprend son utilisation dans la console de jeux portable française, éducative et rétro Gamebuino META, ou encore pour les cartes de développement Arduino M0 et Zero.

Ou comme modchip pour la Nintendo Switch :troll:
Ce qui va bien dans le sens de ceci
Enfin, les dimensions de la carte Adafruit Trinket M0 sont nettement inférieures à celles de la carte du module externe TI-Python, ce qui la rend beaucoup plus intéressante pour tenter de la faire rentrer dans une calculatrice TI-Premium CE, et avoir ainsi un module interne et donc parfaitement autorisé aux examens en France

mais du coup, il faudrait que les fichiers du module soient disponibles...

Image
ImageImageImage
Pokemon Topaze (Axe) discussion and download links here
(19:29:36) noelnadal: plus sérieusemen​t, j'ai très peu de problèmes
(22:45:44) Clifward: J'aime rire du malheur des autres :troll:

(2017.11.18 - 17:07:12) Fireworks: Hayleia !!!!!
(2017.11.18 - 17:07:19) TI-Bot: Fireworks has been logged out (Kicked).
(2017.11.18 - 17:07:22) TI-Bot: Ban of user Fireworks revoked.
(2017.11.18 - 17:07:25) TI-Bot: Fireworks logs into the Chat.
(2017.11.18 - 17:07:28) Fireworks: <3
(2017.11.18 - 17:07:31) Fireworks: 208
Avatar de l’utilisateur
HayleiaGénéreux
Niveau 17: GM (Grand Maître des calculatrices)
Niveau 17: GM (Grand Maître des calculatrices)
Prochain niv.: 43.8%
 
Messages: 2509
Images: 2
Inscription: 30 Aoû 2011, 08:22
Genre: Non spécifié
Calculatrice(s):
MyCalcs profile
Classe: Templar

Re: Test module TI-Python (version 3.0.0.12)

Message non lude Lionel Debroux » 13 Fév 2019, 08:22

En effet, quel boulot de ta part, comme toujours pour ce genre de tests :)

Entre les flottants double précision, cmath, les fonctions spéciales de math et des fonctions graphiques, il manque quand même pas mal de choses utiles dans ce firmware. C'est techniquement faisable de les ajouter, et même facile... mais le fait que la partie firmware de la Flash, entre le bootloader et la partition FAT, soit presque pleine compliquera sérieusement les choses.
Bien sûr, l'utilisation de DPFP va encore baisser les performances...
Membre de la TI-Chess Team.
Co-mainteneur de GCC4TI (documentation en ligne de GCC4TI), TIEmu et TILP.
Avatar de l’utilisateur
Lionel DebrouxSuper Modo
Niveau 14: CI (Calculateur de l'Infini)
Niveau 14: CI (Calculateur de l'Infini)
Prochain niv.: 11.2%
 
Messages: 6858
Inscription: 23 Déc 2009, 00:00
Localisation: France
Genre: Homme
Calculatrice(s):
MyCalcs profile
Classe: -
GitHub: debrouxl

Re: Test module TI-Python (version 3.0.0.12)

Message non lude critor » 13 Fév 2019, 08:28

Merci @nbenm et @Lionel. :)

Hayleia a écrit:
Enfin, les dimensions de la carte Adafruit Trinket M0 sont nettement inférieures à celles de la carte du module externe TI-Python, ce qui la rend beaucoup plus intéressante pour tenter de la faire rentrer dans une calculatrice TI-Premium CE, et avoir ainsi un module interne et donc parfaitement autorisé aux examens en France

mais du coup, il faudrait que les fichiers du module soient disponibles...

Pour l'émulation TI-83 Premium CE aussi, il faut les fichiers.
Image
Avatar de l’utilisateur
critorAdmin
Niveau 19: CU (Créateur Universel)
Niveau 19: CU (Créateur Universel)
Prochain niv.: 41.4%
 
Messages: 41455
Images: 14353
Inscription: 25 Oct 2008, 00:00
Localisation: Montpellier
Genre: Homme
Calculatrice(s):
MyCalcs profile
YouTube: critor3000
Twitter/X: critor2000
GitHub: critor

Re: Test module TI-Python (version 3.0.0.12)

Message non lude Hayleia » 13 Fév 2019, 08:32

critor a écrit:Pour l'émulation TI-83 Premium CE aussi, il faut les fichiers.

Euh, oui, mais je ne vois pas pourquoi parler d'émulation de PCE dans un contexte où on parle de mettre un Trinket M0 dans une PCE physique.

Image
ImageImageImage
Pokemon Topaze (Axe) discussion and download links here
(19:29:36) noelnadal: plus sérieusemen​t, j'ai très peu de problèmes
(22:45:44) Clifward: J'aime rire du malheur des autres :troll:

(2017.11.18 - 17:07:12) Fireworks: Hayleia !!!!!
(2017.11.18 - 17:07:19) TI-Bot: Fireworks has been logged out (Kicked).
(2017.11.18 - 17:07:22) TI-Bot: Ban of user Fireworks revoked.
(2017.11.18 - 17:07:25) TI-Bot: Fireworks logs into the Chat.
(2017.11.18 - 17:07:28) Fireworks: <3
(2017.11.18 - 17:07:31) Fireworks: 208
Avatar de l’utilisateur
HayleiaGénéreux
Niveau 17: GM (Grand Maître des calculatrices)
Niveau 17: GM (Grand Maître des calculatrices)
Prochain niv.: 43.8%
 
Messages: 2509
Images: 2
Inscription: 30 Aoû 2011, 08:22
Genre: Non spécifié
Calculatrice(s):
MyCalcs profile
Classe: Templar

Re: Test module TI-Python (version 3.0.0.12)

Message non lude Lionel Debroux » 13 Fév 2019, 08:37

Peut-être l'émulation d'une 83PCE trafiquée à laquelle on aurait intégré le TI-Python Adapter / Trinket M0 / un matériel compatible compatible dans le boîtier de la calculatrice ?
Même sans pouvoir dumper directement, et diffuser officiellement, le firmware TI-Python Adapter, vu que c'est une base FLOSS CircuitPython, il est facile de produire, puis de diffuser des binaires, une fois qu'ils ont été un peu testés.
Membre de la TI-Chess Team.
Co-mainteneur de GCC4TI (documentation en ligne de GCC4TI), TIEmu et TILP.
Avatar de l’utilisateur
Lionel DebrouxSuper Modo
Niveau 14: CI (Calculateur de l'Infini)
Niveau 14: CI (Calculateur de l'Infini)
Prochain niv.: 11.2%
 
Messages: 6858
Inscription: 23 Déc 2009, 00:00
Localisation: France
Genre: Homme
Calculatrice(s):
MyCalcs profile
Classe: -
GitHub: debrouxl

Re: Test module TI-Python (version 3.0.0.12)

Message non lude Azerpogba » 13 Fév 2019, 08:46

Bien joué pour avoir trouvé tout ça !! :p
Image
Avatar de l’utilisateur
AzerpogbaAmbianceur
Niveau 13: CU (Calculateur Universel)
Niveau 13: CU (Calculateur Universel)
Prochain niv.: 60%
 
Messages: 397
Images: 16
Inscription: 04 Déc 2018, 19:40
Genre: Homme
Calculatrice(s):
MyCalcs profile
Classe: Etude sup

Re: Test module TI-Python (version 3.0.0.12)

Message non lude critor » 13 Fév 2019, 09:00

Hayleia a écrit:
critor a écrit:Pour l'émulation TI-83 Premium CE aussi, il faut les fichiers.

Euh, oui, mais je ne vois pas pourquoi parler d'émulation de PCE dans un contexte où on parle de mettre un Trinket M0 dans une PCE physique.


Même problème d'apparente indisponibilité du fichier en public, et pourtant en pratique ça semble ne rien empêcher. ;)
Image
Avatar de l’utilisateur
critorAdmin
Niveau 19: CU (Créateur Universel)
Niveau 19: CU (Créateur Universel)
Prochain niv.: 41.4%
 
Messages: 41455
Images: 14353
Inscription: 25 Oct 2008, 00:00
Localisation: Montpellier
Genre: Homme
Calculatrice(s):
MyCalcs profile
YouTube: critor3000
Twitter/X: critor2000
GitHub: critor

Re: Test module TI-Python (version 3.0.0.12)

Message non lude parisse » 13 Fév 2019, 13:25

@critor: chapeau!
@ti: pas chapeau!!! Pas de double precision, pas d'entiers longs, pas de complexes, tres peu de flash, ca fait quand meme beaucoup de defauts!
Mais finalement, c'est peut-etre une bonne nouvelle, ca va relancer la concurrence sur le segment des couleurs a 80 euros environ.
Avatar de l’utilisateur
parisseVIP++
Niveau 12: CP (Calculatrice sur Pattes)
Niveau 12: CP (Calculatrice sur Pattes)
Prochain niv.: 77.1%
 
Messages: 3497
Inscription: 13 Déc 2013, 16:35
Genre: Non spécifié
Calculatrice(s):
MyCalcs profile

Suivante

Retourner vers News TI-z80 (TI-73, 76, 80, 81, 82, 83, 84, 85, 86)

Qui est en ligne

Utilisateurs parcourant ce forum: Aucun utilisateur enregistré et 45 invités

-
Rechercher
-
Social TI-Planet
-
Sujets à la une
Comparaisons des meilleurs prix pour acheter sa calculatrice !
Aidez la communauté à documenter les révisions matérielles en listant vos calculatrices graphiques !
Phi NumWorks jailbreak
123
-
Faire un don / Premium
Pour plus de concours, de lots, de tests, nous aider à payer le serveur et les domaines...
Faire un don
Découvrez les avantages d'un compte donateur !
JoinRejoignez the donors and/or premium!les donateurs et/ou premium !


Partenaires et pub
Notre partenaire Jarrety Calculatrices à acheter chez Calcuso
-
Stats.
861 utilisateurs:
>837 invités
>18 membres
>6 robots
Record simultané (sur 6 mois):
6892 utilisateurs (le 07/06/2017)
-
Autres sites intéressants
Texas Instruments Education
Global | France
 (English / Français)
Banque de programmes TI
ticalc.org
 (English)
La communauté TI-82
tout82.free.fr
 (Français)