π
<-
Chat plein-écran
[^]

News 2019
August (10)
July (3)
June (4)
May (11)
April (7)
March (19)
January (14)

News 2018
August (5)
July (1)
June (9)
May (10)
April (2)
March (14)
January (12)

News 2017
August (10)
July (14)
June (14)
May (11)
April (9)
March (12)
January (11)

News 2016
October (10)
August (8)
July (4)
June (8)
May (14)
April (9)
March (13)
January (11)

News 2015
October (15)
August (11)
July (4)
June (7)
May (12)
April (6)
March (11)

News 2014
August (2)
July (4)
June (2)
May (5)
April (4)
March (5)

News 2013
August (6)
July (6)
June (8)
May (14)
April (24)
March (16)
January (10)

News 2012
October (11)
August (6)
July (7)
June (8)
May (16)
April (16)
March (6)

News 2011
August (4)
July (4)
June (11)
May (5)
April (2)
March (6)

News 2010
July (1)
June (1)
May (2)
April (1)

News 2009
August (2)
April (1)

Omnicalc, pour des possibilités TI-82 Advanced étendues !

New postby critor » 02 Feb 2019, 18:25

10185La
TI-82 Advanced
est techniquement une
TI-84 Plus
, mais a été bridée pour empêcher l'ajout d'applications.

Toutefois dans un article précédent, nous t'annoncions enfin la possibilité d'installer les applications
TI-82+/83+/84+
de ton choix sur ta
TI-82 Advanced
, grâce au formidable travail de . :bj:

Dans un article précédent, nous traitions de l'ajout de la superbe application
Symbolic
, et pour qu'elle fonctionne correctement tu avais besoin de l'application
Omnicalc
.

Il existe toutefois de grandes différences internes entre la version système
5.0.0.0028
du
20 janvier 2015
pour
TI-82 Advanced
et la dernière version
2.55MP
du
19 octobre 2010
pour
TI-84 Plus
.

Si bien que les applications
TI-84 Plus
ne fonctionnent pas toujours correctement ou entièrement sur
TI-82 Advanced
.

C'est notamment le cas de celles qui ont à voir avec le fonctionnement du système ou de l'écran de calcul, et
Omnicalc
tout comme
Symbolic
fait justement partie de ces dernières.

Voyons donc aujourd'hui quelles fonctionnalités de
Omnicalc
sont utilisables sur
TI-82 Advanced
.

Une fois l'application
Omnicalc
lancée
(et installée)
, tu disposes dans son menu de configuration de plusieurs options destinées à modifier le comportement de l'écran de calcul et du système.

10186Plusieurs options ne sont pas fonctionnelles : :'(
  • Parentheses Assistant
    , censé faire clignoter la parenthèse ouvrante correspondant lorsque l'on ferme une parenthèse lors d'une saisie sur l'écran de calcul, et qui ici non seulement ne marche pas mais en plus bloque la saisie des parenthèses fermantes !
  • Entries Menu
    , censé afficher sur
    2nde
    entrée
    un menu permettant de choisir parmi les saisies précédentes, et qui ici affiche bien un menu mais propose n'importe quoi dedans et finit par planter !
  • RAM Recovery
    , censé sauvegarder la mémoire à chaque extinction de la calculatrice, pour pouvoir la restaurer immédiatement après un plantage. Ne fait rien de mal, mais en pratique la commande de restauration traitée plus bas semble inutilisable.
  • Virtual Calculators
    , censé permettre de basculer entre et utiliser deux états mémoire différents de la calculatrice, avec le raccourci
    on
    mode
    . Tu as donc deux calculatrices dans une seule, de quoi mettre les choses pour les maths dans l'une et les choses pour les sciences dans l'autre. Ne fait rien de mal, en pratique le raccourci ne marche tout simplement pas.


Mais d'autres marchent encore à la perfection : :bj:
  • Memory Protection
    , bloque empêche ton prof/surveillant/voisin d'effacer tes données. Bloque aussi bien l'effacement des variables que le menu de réinitialisation.
  • Base Conversions
    , permet de convertir les résultats à l'écran de calcul de la base décimale
    (10)
    vers n'importe quelle autre base de 2 à 36. La base de destination se choisit via le raccourci
    on
    log
    et est à saisir sur 2 chiffres
    (donc 02 pour le binaire par exemple)
    .
  • Lowercase Letters
    , permet de saisir des lettres minuscules via le raccourci
    alpha
    alpha
    .


10187
En deuxième page c'est encore mieux, tout marche : :bj:
  • Thousands Separators
    , rajoute des séparateurs de milliers aux résultats dans l'écran de calcul.
  • Quick APPS
    , permet de lister les applications plus rapidement, l'affichage du menu avec nos 12 applications étant maintenant instantané au lieu de prendre une fraction de seconde.
    Mais il y a un autre avantage beaucoup plus important. Si tu as rajouté des applications sur ta
    TI-82 Advanced
    , dans le menu
    apps
    si tu tapes
    pour aller en fin de liste, tu as pu remarqué un bug de décalage entre l'affichage de l'application sélectionnée, et l'application effectivement lancée à la validation. Sans doute que TI a tenu compte du nombre d'application préchargées quelque part...
    Une fois l'option
    Quick APPS
    activée, plus de problème ! :bj:
  • Hide Finance app
    , lorsque l'option
    Quick APPS
    est activée, permet de masquer l'application intégrée
    Finance
    du menu
    apps
    , application qui ne sert pas à grand monde dans le contexte du lycée.


Mais ce n'est pas tout car avec le raccourci
prgm
prgm
, on a accès à de toutes nouvelles fonctions.
Dans l'onglet
MISC
, les fonctions suivantes ne marchent pas : :(
  • Les fonctions de communication linkGet( et linkSend( ne marchent pas, renvoyant systématiquement -1 pour indiquer une erreur. Elles sont destinées à écrire/lire un octet sur le port de communication de la calculatrice, très probablement non pas le port mini-USB mais le port série mini-Jack 2.5 qui n'existe plus sur
    TI-82 Advanced
    .
  • La fonction RestoreMem( destinée à restaurer la mémoire après un plantage. C'est la seule fonction qui selon sa documentation ne prend pas de paramètre. Mais lors de la saisie sur
    TI-82 Advanced
    elle se transforme en réel(32,, qui donne une erreur de syntaxe si validé sans paramètre, et une erreur de donnée si on rajoute un nombre.


Par contre, la fonction Rom>Dec(, permet de convertir un nombre écrit en chiffres romains, est fonctionnelle ! :bj:


Dans l'onglet
MATH
, absolument tout est fonctionnel ! :bj:
  • La fonction !n( pour la fonction sous-factorielle.
  • La fonction baseInput( qui complète la fonctionnalité vue plus haut, en permettant cette fois-ci de convertir en base décimale une saisie effectuée dans n'importe quelle base 2 à 36.
  • La fonction const( qui permet de rappeler les valeurs de plusieurs constantes physiques :
    • NA, pour le nombre d'Avogadro
      (sans unité)
    • K, pour la constante de Boltzman
      $mathjax$\left(J\cdot K^{-1}\right)$mathjax$
    • CC
    • EC, pour la charge élémentaire
      (C)
    • RC, pour la constante universelle des gaz parfaits
      $mathjax$\left(J\cdot mol^{-1}\cdot K^{-1}\right)$mathjax$
    • GC, pour la constante gravitationnelle
      $mathjax$\left(N\cdot m^2\cdot kg^{-2}\right)$mathjax$
    • G, pour l'accélération de la pesanteur à la surface de la Terre
      $mathjax$\left(m\cdot s^{-2}\right)$mathjax$
    • ME, pour la masse de l'électron
      (kg)
    • MP, pour la masse du proton
      (kg)
    • MN, pour la masse du neutron
      (kg)
    • H, pour la constante de Planck
      (J∙s)
    • C, pour la vitesse de la lumière dans le vide
      $mathjax$m\cdot s^{-1}$mathjax$
    • U, pour l'unité de masse atomique unifiée
      (kg)
  • La fonction factor( pour décomposer un nombre en facteurs premiers.
  • La fonction gamma(.
  • La fonction mod( pour calculer le reste d'une division euclidienne.
    Certes, la fonction remainder( existe déjà à cette fin dans ta
    TI-82 Advanced
    , mais ici à la différence la fonction marchera même avec les nombres décimaux et les grands nombres ! :bj:
  • La fonction simp√( pour simplifier les racines carrées.

Enfin dans l'onglet
PRGM
, nous avons les fonctions suivantes qui marchent : :bj:
  • La fonction sprite( pour afficher non pas une variable image en entier, mais un rectangle découpé dans une des variables images de la calculatrice, fort pratique pour programmer des jeux.
  • La fonction ExecAsm( pour exécuter directement du code machine.

Et puis, il reste cette fonction play(, censée jouer des partitions de musique sur un haut parleur à brancher sur le port mini-Jack 2.5 de la calculatrice, partitions à retranscrire dans une chaîne de caractères au format suivant :
  • P... : joue un silence
    (1, 2, 4, 8, 16, 32, 64)
  • A-G : joue les notes la, si, do, ré, mi, fa , sol
  • + : augmente la hauteur de la note précédente d'un demi-ton
    (dièse)
  • - : baisse la hauteur de la note précédente d'un demi-ton
    (bémol)
  • . : augmente la durée de la note ou pause précédente de moitié
  • T... : règle le tempo
    (32-255, par défaut 120)
  • L... : règle la longueur des notes suivantes
    (1, 2, 4, 8, 16, 32, 64, par défaut 4)
  • O... : règle l'octave
    (0-6, par défaut 2)
  • < : baisse d'un octave
  • > : augmente d'un octave
  • MN : les prochaines notes se termineront par un silence faisant 1/8 de leur durée
  • MS : les prochaines notes se termineront par un silence faisant 1/4 de leur durée
  • ML : les prochaines notes se termineront sans silence

Or, le port mini-Jack 2.5 est inexistant sur
TI-82 Advanced
. Mais ce n'est pas parce que ça ne peut pas marcher que ça ne fait rien...

Nous avions déjà vu que c'était en fait la diode examen qui avait pris la place du port mini-Jack 2.5 sur
TI-82 Advanced
. Alors à ton avis, ça fait quoi ? ;)

Réponse ci-dessous :

10212Et oui, pas de musique, mais à la place ça allume la diode examen ! :o

Mais ne t'embête pas à chercher la partition de la mélodie du mode examen, car cela n'a aucun intérêt pour frauder en 2020.

Certes, TI s'est bien embêté à interdire les applis et l'assembleur sur
TI-82 Advanced
, très probablement pour empêcher ce genre de chose.
Mais ils ont régulièrement tendance à être extrêmes dans leurs protections, et à embêter à bloquer des choses inutilement.

En effet, si tu fais clignoter ta diode avec en mettant par exemple la bonne commande play( dans une boucle, oui tu pourras faire croire que tu es en mode examen alors que tes données n'ont pas été effacées.

Mais, tant que ta calculatrice exécutera la boucle, elle sera inutilisable car n'acceptant aucune entrée. Il faudra bien à un moment où à un autre que tu interrompes la boucle pour pouvoir te servir de ta calculatrice. A ce moment-là la diode cessera de clignoter et les surveillants le verront. :#non#:

Maintenant étendue avec
Omnicalc
, ta
TI-82
mérite enfin d'être qualifiée de
Advanced
! :bj:

Téléchargements
:
Liens
:


Oiram CE : relève le défi du Big Bang !

New postby critor » 02 Feb 2019, 22:13

7698Ce week-end te lance un défi avec
Big Bang
, son monde perso pour pour
Oiram CE
, le moteur de jeu
Mario-like
pour ta
TI-83 Premium CE
. :)

Seulement 4 niveaux, mais c'est du concentré si tu regardes bien ! :bat:


Seras-tu le ou la première à les terminer ? ;)


Pour fonctionner correctement,
Oiram CE
a besoin des bibliothèques C téléchargeables ci-dessous. Mais rien de bien compliqué, il suffit juste de les transférer.


Téléchargements
:
Link to topic: Oiram CE : relève le défi du Big Bang ! (Comments: 14)

Tuto saisie minuscules facile et universel, même 82 Advanced

New postby critor » 03 Feb 2019, 12:29

Par défaut, ta
TI-82/83/84
ne te permet de saisir du texte qu'en majuscules.

Il existe toutefois des programmes assembleur ou applications permettant d'activer la saisie en lettres minuscules en tapant
alpha
alpha
.

On peut citer entre autres :
  • le programme assembleur pour
    TI-83 Premium CE
    /
    TI-84 Plus CE
  • l'application pour
    TI-82+/83+/84+

Sauf que, initialement, les
TI-82 Advanced
et
TI-84 Plus T
interdisaient d'exécuter des programmes assembleur ou de rajouter des applications.

Toutefois grâce au formidable travail de nous t'annoncions enfin dans un article précédent la possibilité d'installer les applications
TI-82+/83+/84+
de ton choix sur ta
TI-82 Advanced
, et donc par extension d'exécuter des programmes assembleur grâce aux applications de shell.

Mais voilà, à ce jour la
TI-84 Plus T
reste fermée à ces possibilités.

Et peut-être trouves-tu aussi que la manipulation pour installer l'application
OmniCalc
sur ta
TI-82 Advanced
est trop compliquée...

10223Mais heureusement, il existe une autre possibilité pour saisir du texte en minuscules sur ta calculatrice, possibilité qui est valable pour toutes les
TI-82+/83+/84+
, y compris les dernières
TI-82 Advanced
ou
TI-84 Plus T
.

Il te suffit simplement de faire appel en cours de saisie au catalogue avec
2nde
0
, puis de valider l'entrée
Caractères
que tu trouveras vers le début.
Attention, cette entrée n'est disponible que si ta calculatrice est réglée dans une autre langue que l'Anglais. :#non#:


A l'écran auquel tu accèdes alors, la combinaison
alpha
alpha
activera bien la saisie des minuscules ! :bj:

Cette méthode universelle vient justement de faire l'objet d'un tutoriel par . :)


Liens
:


Téléchargements
:

  • (pour
    TI-83 Premium CE
    et
    TI-84 Plus CE
    )
  • (pour
    TI-82 Plus
    ,
    TI-83 Plus
    ,
    TI-84 Pocket.fr
    et
    TI-84 Plus
    monochromes
    sauf
    TI-84 Plus T
    )
  • (pour
    TI-82 Advanced
    )

Geometry Dash : God Eater, adaptation du niveau démoniaque !

New postby critor » 06 Feb 2019, 16:15

Ta
TI-83 Premium CE
bénéficie d'une superbe adaptation de
Geometry Dash
par aidé d'Anonyme0. :bj:

D'origine, le jeu inclut des adaptations de trois des 21 niveaux accompagnant la version complète du jeu mobile :
  • Stereo Madness
    (niveau 1 - easy)
  • Polargeist
    (niveau 3 - normal)
  • Dry Out
    (niveau 4 - normal)

Mais il est de plus possible de créer et charger tes propres niveaux. :bj:
La conception se passe sur ordinateur avec le logiciel
Tiled
où il suffira d'utiliser le
tileset
de
Geometry Dash
, puis d'en exporter une version
.csv
avant de la convertir en ligne.

10245Après avoir adapté le niveau 7
(Jumper)
, est de retour pour s'attaquer encore à un niveau difficile mais cette fois-ci non officiel et pas des moindres, le légendaire
God Eater
.

Considéré comme étant parmi les niveaux les plus difficiles existant pour
Geometry Dash
, l'adaptation de la première partie de
God Eater
devrait bien pouvoir t'occuper jusqu'aux vacances... et peut-être même au-delà ! :bat:

Pour le rajouter il n'y a rien de plus facile, il te suffira simplement d'envoyer le fichier du niveau sur ta calculatrice et il deviendra automatiquement sélectionnable à l'écran d'accueil de
Geometry Dash
.


Téléchargements
:


Liens
:


Source
:
viewtopic.php?f=12&t=19211&start=160#p238699

Test module TI-Python (version 3.0.0.12)

New postby critor » 13 Feb 2019, 00:35

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, et , 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-A
USB 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 , ou encore pour les cartes de développement
Arduino
et .

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 wrote:>>> # 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 wrote:>>> # 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. + +
    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 wrote:>>> # 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
    + + 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: 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


L'appel explmod(sys) nous produit alors :
TI-Python wrote:>>> # 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 wrote:>>> # 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
    + + +
    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 ou la .

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: Select all
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: 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'>
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>
218
188
175
204
190


D'où le classement suivant :
  1. avec
    218
    entrées
  2. 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: Select all
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 wrote:>>> # 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. + +
    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: Select all
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 wrote:>>> # 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. +
    NumWorks
    +
    Casio Graph 90+E
    + 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: Select all
    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 wrote:>>> # 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: Select all
    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 wrote:>>> # 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: Select all
    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 wrote:>>> # 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: Select all
    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 wrote:>>> # 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: Select all
    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 wrote:>>> # 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: Select all
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 wrote:>>> # 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. avec
    307
    entrées
  2. NumWorks
    (version 10.0.0)
    avec
    295
    entrées
  3. 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: Select all
def mem():
  try:
    l=[]
    try:
      l+=[0]
      l+=[""]
      l[1]+="x"
      while True:
        try:
          l[1]+=l[1][l[0]:]
        except:
          if l[0]<len(l[1])-1:
            l[0]=len(l[1])-1
          else:
            raise(Exception)
    except:
      print("+",len(l)>1 and len(l[1]))
      return 64+8*len(l)+(len(l) and 24+4*(l[0]>0)+(len(l)>1 and 49+len(l[1])))+mem()
  except:
    return 0


Voici la sortie obtenue :
TI-Python wrote:>>> # 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. avec
    2,046Mo
  2. Casio Graph 90+E
    avec
    1,027Mo
  3. avec
    255,07Ko
  4. 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: Select all
try:
  from time import *
except:
  pass

def hastime():
  try:
    monotonic()
    return True
  except:
    return False

def genseed(ndigits):
  nmax,s,k=5*10**(ndigits-1),0,1
  while s<nmax:
    s+=k
    k*=2
  return s

def genarr(ndigits):
  sd,arr=genseed(ndigits),[]
  for k in range(1,ndigits):
    for j in range(ndigits):
      t=sd%10**k
      arr.extend([t,-t,10**k-t,t-10**k])
      sd=sd//10+(sd%10)*10**(ndigits-1)
  arr.extend([sd,-sd])
  return arr

def sortarr(arr,sdiff):
  segs=[0,len(arr)-1]
  while len(segs):
    iref=segs[0]
    for k in range(segs[0],segs[1]+1):
      if sdiff*(arr[k]-arr[iref])>0:
        t=arr[iref]
        arr[iref]=arr[k]
        arr[k]=arr[iref+1]
        arr[iref+1]=t
        iref+=1
    if iref>=segs[0]+2:
      segs.extend([segs[0],iref-1])
    if iref<=segs[1]-2:
      segs.extend([iref+1,segs[1]])
    segs.pop(0)
    segs.pop(0)
  return arr

def test(l,n):
  timed=hastime()
  start,stop,sdiff,arr=0 or timed and monotonic(),1,-1,[]
  arr.extend(genarr(l))
  for k in range(n):
    arr.extend(sortarr(arr,sdiff))
    sdiff=-sdiff
  stop=timed and monotonic() or 1
  return stop-start,len(arr),arr[0],arr[len(arr)//2-1],arr[len(arr)//2],arr[len(arr)-1]


La ligne d'appel test(9,2) se termine en
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. en
    1,41s
  2. en
    1,56s
  3. en
    2,40s
  4. NumWorks
    en
    3,74s
  5. Casio Graph 90+E
    en
    4,75s
  6. HP Prime G2
    en
    8,81s
  7. 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 wrote: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 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 wrote: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 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 .

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.

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:
Link to topic: Test module TI-Python (version 3.0.0.12) (Comments: 23)

Correctif TI-Python flottants + complexes sur Trinket M0

New postby critor » 14 Feb 2019, 23:32



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 :)


En résumé: il y a maintenant une paire de firmwares non officiels pour le TI-Python Adapter associé aux TI-83 Premium CE, qui
corrigent les plus gros défauts de la première version du firmware officiel
(le rapprochant des solutions concurrentes), en fournissant la
gestion des nombres flottants double précision
pour corriger les horribles problèmes de précision, et l'ajout des
gestion des nombres complexes, des fonctions spéciales de maths (dont trigo hyperbolique), et des entiers (plus) longs
. Binaires et code source liés en bas de ce post.
TL;DR: there's now a couple third-party firmware images for the TI-Python Adapter associated to the TI-83 Premium CE, which
fix the main drawbacks of the first version of the official firmware
(making it closer to competitor offerings), featuring
double precision floating-point values
to fix severe accuracy issues, as well as the addition of
complex math functions, special math functions (including hyperbolic trig), and long(er) integers
. Binaries and source code linked at the bottom of this post.


10251
Suite à la livraison des premiers modules externes
TI-Python
par
Jarrety
pour
améliorer
ta
TI-83 Premium CE
, dans notre test dédié nous venons de voir que le matériel et le
firmware
reprenaient ceux d'une carte
Python
(PyBoards)
développée par
Adafruit
. Probablement la
Trinket M0
ou la
Feather M0
. D'où la possibilité d'interchanger les
firmwares
entre ces différents appareils.

L'implémentation
Python
sur le module TI-Python est donc celle développée tout spécialement par
Adafruit
pour ces cartes, un
CircuitPython
en version
3.0.0
. C'est un fork de
MicroPython
comportant d'importants changements dans le code, certains visant probablement un peu plus de légèreté pour tourner un peu mieux sur des cartes vraiment peu puissantes.
After the first external
TI-Python
modules
improving
your
TI-83 Premium CE
were delivered by
Jarrety
, in our detailed test, we showed that the hardware and the
firmware
were taken from a
Python
board
(PyBoards)
developed by
Adafruit
, probably the
Trinket M0
or the
Feather M0
, hence the ability to interchange firmware between these boards and the TI-Python Adapter.

The TI-Python Adapter's
Python
implementation is the one tailor-made by
AdaFruit
for their boards,
CircuitPython
, version
3.0.0
. This
MicroPython
fork contains widespread code changes, some of which probably aim at slightly reducing the footprint for running better on really underpowered hardware.


Et justement, parmi les allègements il y en a un qui est particulièrement problématique dans le contexte du lycée scientifique, c'est la précision des nombres flottants.
Les nombres non entiers, qu'ils soient décimaux ou réels, sont représentés en
Python
en virgule flottante, soit au format
$mathjax$\pm M\times 2^{E-E_{min}}$mathjax$
avec
$mathjax$M\in [1;2[$mathjax$
.

Or, toutes les calculatrices n'accordent pas le même nombre de bits pour coder la mantisse M et l'exposant E de ces nombres, ce qui limite leur nombre de chiffres significatifs.

Voici la transcription
Python
d'un algorithme permettant de calculer les nombres de bits et de chiffres significatifs utilisables pour les mantisses de flottants, ceci en appelant respectivement precm(2) et precm(10) :
Code: Select all
def precm(b):
  k,b=0,float(b)
  while 1+b**-k-1>0:
    k+=1
  return k


Précisons que selon les modèles, le test devra être réalisé deux fois, car bien souvent l'environnement
Python
utilisera un moteur de calcul spécifique totalement déconnecté du reste de la calculatrice.

Voici le petit classement de différents appareils scolaires en termes de précision binaire et décimale qui en découle, du meilleur au pire :

modèles
bits
chiffres
significatifs
Graph 90+E / fx-CG50
(Python)

Graph 35/75/85/95 USB / fx-9750GII/9860G
NumWorks
(Python)

TI-Nspire[
5316
HP Prime
(CAS)
4815
Graph 90+E / fx-CG10/20/50
NumWorks
(hors Python)

TI-82/85/86/89/92 / Voyage 200
TI-Nspire
(hors MicroPython)
4514
TI-814113
fx-92 Collège 2D / Spéciale Collège / fx-ES/EX
Graph 90+E / fx-CG50
(hors Python et KhiCAS)

Graph 35/75/85/95 USB / fx-9750GII/9860G
(hors CasioPython)

fx-CG10/20
(hors KhiCAS)

Sharp EL-9900/9950
TI-73/76.fr/83/84 / 82 Stats/Plus/Advanced
4013
HP Prime
(hors CAS)
3812
Lexibook GC3000FR3511
TI-Primaire Plus3411
TI-Collège Plus / 30/34/36 MultiView3210
fx-CP400/CG500 / Classpad3110
module externe TI-Python227


Pour référence, 53 bits correspondent à ce qui est appelé la double précision dans le contexte du
Python
, et 24 bits à la simple précision.


Comme tu peux le voir, les premiers modules externes
TI-Python
à avoir été livrés ont un très grave défaut, avec une précision en virgule flottante nettement inférieure à celle de la
TI-83 Premium CE
, et dégraderont donc ses capacités de calcul ! :(
Cette précision est même inférieure à celle qu'offre l'étron intergalactique
Lexibook GC3000FR
, et même pire encore à celles qui ont été jugées nécessaires pour les
TI/Casio
scientifiques de collège ou pour les
TI/Casio
de primaire... et également inférieure à celle des flottants
Python
simple précision normaux ! :'(

Par conséquent, avec des résultats intermédiaires et finaux bridés sur 7 chiffres significatifs, nombre d'activités numériques au programme du lycée scientifique - notamment lorsqu'il y a enchaînement de différents calculs
(polynômes du second degré, suites récurrentes, nombre dérivé, matrices, itérations de boucles, fonctions récursives...)
conduiront à des résultats faux, aberrants ou même totalement inexploitables, beaucoup plus facilement sur le module externe
TI-Python
que sur les solutions concurrentes ! :mj:
Dans le test dédié précédemment évoqué, nous avons mentionné des exemples de résultats faux.

De la part d'
Adafruit
, cette utilisation des flottants simple précision vient d'un allègement volontaire de
MicroPython
, afin de minimiser la consommation de ressources sur ses cartes
Trinket/Feather M0
, qui ont des caractéristiques matérielles très faibles.
Adafruit
semble ne pas avoir pensé ses cartes pour le contexte scientifique du lycée, mais davantage pour servir dans des projets techniques ou encore comme jouet d'éveil au
Python
pour les écoliers/collégiens.

Même si cette base matérielle et logicielle semble être une bonne solution pour minimiser les coûts de production, vouloir construire un produit pour le lycée scientifique en partant de ça n'était-il pas une erreur ?...
:#roll#:
And precisely, one of the changes which aim at producing more lightweight builds is especially harmful for science-oriented high school teaching purposes, is the prevision of floating-point numbers.
Non-integer numbers, be them decimal or real, are represented as floating-point values in
Python
, that is in the
$mathjax$\pm M\times 2^{E-E_{min}}$mathjax$
format, with
$mathjax$M\in [1;2[$mathjax$
.

As a matter of fact, calculators use different bit counts for encoding the mantissa M and the exponent E, which caps the number of significant figures.

Here is the
Python
translation of an algorithm computing the number of bits and the number of significant digits usable for floating-point number mantissas, by calling respectively precm(2) and precm(10):
Code: Select all
def precm(b):
  k,b=0,float(b)
  while 1+b**-k-1>0:
    k+=1
  return k


On some models, this test needs to be performed twice, as the
Python
environment often uses a specific computations engine, completely disconnected from the rest of the calculator's operation.

Here is the rundown of school calculators in terms of binary / decimal accuracy, from best to worst:

models
bits
significant digits
Graph 90+E / fx-CG50
(Python)

Graph 35/75/85/95 USB / fx-9750GII/9860G
NumWorks
(Python)

TI-Nspire[
5316
HP Prime
(CAS)
4815
Graph 90+E / fx-CG10/20/50
NumWorks
(outside Python)

TI-82/85/86/89/92 / Voyage 200
TI-Nspire
(outside MicroPython)
4514
TI-814113
fx-92 Collège 2D / Spéciale Collège / fx-ES/EX
Graph 90+E / fx-CG50
(outside Python and KhiCAS)

Graph 35/75/85/95 USB / fx-9750GII/9860G
(outside CasioPython)

fx-CG10/20
(outside KhiCAS)

Sharp EL-9900/9950
TI-73/76.fr/83/84 / 82 Stats/Plus/Advanced
4013
HP Prime
(hors CAS)
3812
Lexibook GC3000FR3511
TI-Primaire Plus3411
TI-Collège Plus / 30/34/36 MultiView3210
fx-CP400/CG500 / Classpad3110
TI-Python Adapter227


For reference, 53 bits correspond to what is termed double precision in the context of
Python
, and 24 bits correspond to simple precision.


As you can see, the first external
TI-Python Adapter
modules delivered to customers are thoroughly crippled by floating-point precision much lower than that of the
TI-83 Premium CE
, and therefore lower its computation abilities very much ! :(
This precision is even lower than that of the
Lexibook GC3000FR
intergalactic PoS
, or even worse, lower than the ones deemed necessary for the
TI/Casio
scientific calculators aimed at primary and secondary calculators... and lower than that of normal
Python
single precision floating-point values ! :'(

Therefore, with intermediate and final results truncated to 7 significant digits, many numerical activities used in scientific high school level math classes - especially when chaining / iterating multiple computations
(quadratic polynomials, recurrent sequences, derived number, matrices, loop iterations, recursive functions...)
simply produce wrong, stupid or even completely unusable results, much more easily on the
TI-Python Adapter
than on competitors' solutions ! :mj:
In the aforementioned detailed test, we listed multiple instances of wrong results.

As far as
Adafruit
is concerned, using single precision floating-point values stems from a voluntary reduction of
MicroPython
, in order to reduce the foorprint on their
Trinket/Feather M0
boards, whose hardware characteristics are very weak.
Adafruit
doesn't seem to have designed boards for the purpose of targeting scientific high schools, they probably target technical projects or baby
Python
activity steps for pupils younger than high schoolers.

Even if such hardware and software seem to be a good method to reduce production costs, maybe trying to use them as a starting point for building a product targeting scientific high school teaching purposes was a mistake, huh ?
:#roll#:

Heureusement, devant la gravité de la situation et pour voir si c'était difficile de faire mieux que TI (une forme de défi personnel), vient de passer du temps
(une heure pour la première version qui compile mais ne produit pas les résultats attendus, quelques heures supplémentaires pour la première version qui calcule correctement, bien davantage pour les modifications ultérieures et le partage en deux versions qui ont des caractéristiques un peu différentes suivant les opérations qu'on souhaite réaliser)
à rajouter le support des nombres flottants en double précision à un
firmware
pour
Trinket M0
, en repartant du code de CircuitPython disponible publiquement (dans une version plus récente que celle utilisée par TI) ! :bj:
Fortunately, given how dire the situation is and in order to see whether doing better than what TI did is hard (some form of a personal challenge), spent some time
(an hour for the first version which built correctly but didn't yield the expected results, several additional hours for the first version which computes correctly, much more for later modifications and the split into two versions with slightly different contents targeting different operation sets)
adding support for double-precision floating-point numbers to a
firmware
targeting the
Trinket M0
, by restarting from the CircuitPython code (in a version newer than the one used by TI) ! :bj:

Notons que les nombres flottants simple précision ne sont pas le seul gros défaut du module externe
TI-Python
tel qu'on le voit actuellement, et que les firmwares produits par Lionel comble justement d'autres manques fonctionnels (dont ne souffrent pas la plupart des solutions concurrentes), en particulier :
  • la gestion des nombres complexes
    (Terminales S/STI2D/STL)
    : le module
    cmath
    et donc les fonctions complexes qu'il fournit :bj:
  • les fonctions mathématiques spéciales, notamment de trigonométrie hyperbolique, présentes sur certaines autres implémentations de Python sur calculatrice mais pas dans le firmware 3.0.0.12 du TI-Python Adapter.
  • les entiers longs, un peu plus longs (64 bits) dans une version et vraiment plus longs dans l'autre - présents dans toutes les autres implémentations de Python sur calculatrice

Une des versions du firmware fournit également d'autres modules :
os
et
storage
(
io
a fait une courte apparition, il a été enlevé pour des raisons de place) :)

A moins que quelqu'un trouve une idée pour gagner des kilo-octets supplémentaires sans réduire la fonctionnalité, il n'y a pas de marge de manoeuvre pour faire évoluer le produit ultérieurement - une nouvelle fois, contrairement à la plupart des solutions Python calculatrice concurrentes.
Note that single precision floating-point values aren't the only significant issue with the
TI-Python Adapter
as it currently stands, and that the firmware images produced by Lionel plug in other holes in functionality (which most competing solutions do not have), especially:
  • complex math functionality
  • special math functions
  • long integers
One of the firmware's flavors offers other additional modules:
os
and
storage
(
io
made a quick appearance, it was removed for space reasons) :)

Unless someone has an idea to save multiple additional KBs of Flash memory without reducing functionality, there's no spare room left in the Flash memory to provide later product improvements to consumers - again, unlike most competing Python solutions for calculators.

Par contre, nous avions testé sur le stand de
TI
à l'UdPPC en octobre dernier, et la
TI-83 Premium CE
munie de l'OS
5.3.5
et de l'application
PyAdaptr
refusait de fonctionner avec la carte
Adafruit Trinket M0
munie de son
firmware
d'origine.

C'est donc au code
firmware
modifié par
Texas Instruments
qu'il faudrait apporter ces mêmes modifications, mais malheureusement à la différence ce code n'est pas public à notre connaissance.

A défaut donc d'une réouverture du code que
Texas Instruments
a repris en le fermant, les modifications en question sont tenues gracieusement à la disposition de la communauté et du constructeur. Espérons...
However, we had made some tests on
TI
's space at the UdPPC show in October 2018, and the
TI-83 Premium CE
equipped with the
5.3.5
OS version and the
PyAdaptr
FlashApp refused to communicate with an
Adafruit Trinket M0
running its factory default
firmware
.

These modifications should therefore be applied direclty into
Texas Instruments
's modified
firmware
, but unfortunately, its code isn't published anywhere, as far as we can tell. These modifications are provided to the community and the manufacturer, let's hope that TI integrates them, and even opens up their source code, why not...

Source de l'information
:
viewtopic.php?f=41&t=22242&start=80#p239474 et posts suivants.
Binaires prêts à l'emploi
:
dernière version actuelle à viewtopic.php?f=41&t=22328&p=240032#p240032 . D'une manière générale, en pièces jointes des posts de ce topic, et auparavant, de viewtopic.php?f=41&t=22242&start=80#p239474 .
Code source
:
avec les binaires, sous forme de diff, et https://github.com/debrouxl/circuitpython .
Texte de la news: critor (le gros du texte), Lionel (quelques parties, la traduction anglaise).
Information source
:
viewtopic.php?f=41&t=22242&start=80#p239474 and subsequent posts.
Readily usable binaries
:
latest version at viewtopic.php?f=41&t=22328&p=240287#p240287 . In general, binaries are posted as attachments in this topic, and earlier, at viewtopic.php?f=41&t=22242&start=80#p239474 and subsequent posts.
Source code
:
alongside the binaries in diff form, and https://github.com/debrouxl/circuitpython .
News writing credits: critor (the bulk of the text), Lionel (select parts, the English translation.

-
Search
-
Featured topics
Omega, le fork étendant les capacités de ta NumWorks, même en mode examen !
Comparaisons des meilleurs prix pour acheter sa calculatrice !
Concours TI-Planet-Casio de rentrée 2019. 3 défis pour plus d'une 15aine de calculatrices graphiques et nombre de goodies sortant de l'ordinaire ! :D
123
-
Donations / Premium
For more contests, prizes, reviews, helping us pay the server and domains...

Discover the the advantages of a donor account !
JoinRejoignez the donors and/or premium!les donateurs et/ou premium !


Partner and ad
Notre partenaire Jarrety 
-
Stats.
468 utilisateurs:
>421 invités
>41 membres
>6 robots
Record simultané (sur 6 mois):
6892 utilisateurs (le 07/06/2017)
-
Other interesting websites
Texas Instruments Education
Global | France
 (English / Français)
Banque de programmes TI
ticalc.org
 (English)
La communauté TI-82
tout82.free.fr
 (Français)