π
<-
Chat plein-écran
[^]

Correctif TI-Python flottants + complexes sur Trinket M0

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

Correctif TI-Python flottants + complexes sur Trinket M0

Unread 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èlesbitschiffres
significatifs
Graph 90+E / fx-CG50 (Python)
Graph 35/75/85/95 USB / fx-9750GII/9860G (CasioPython)
NumWorks (Python)
TI-Nspire[ (MicroPython)
5316
HP Prime (CAS)4815
Graph 90+E / fx-CG10/20/50 (KhiCAS)
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:

modelsbitssignificant digits
Graph 90+E / fx-CG50 (Python)
Graph 35/75/85/95 USB / fx-9750GII/9860G (CasioPython)
NumWorks (Python)
TI-Nspire[ (MicroPython)
5316
HP Prime (CAS)4815
Graph 90+E / fx-CG10/20/50 (KhiCAS)
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), Lionel Debroux 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), Lionel Debroux 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.
Image
User avatar
critorAdmin
Niveau 19: CU (Créateur Universel)
Niveau 19: CU (Créateur Universel)
Level up: 42.4%
 
Posts: 41498
Images: 14640
Joined: 25 Oct 2008, 00:00
Location: Montpellier
Gender: Male
Calculator(s):
MyCalcs profile
YouTube: critor3000
Twitter: critor2000
GitHub: critor

Re: Correctif TI-Python flottants + complexes sur Trinket M0

Unread postby Adriweb » 16 Feb 2019, 04:38

Même si on a été plusieurs a le dire sur le topic source, c'est indubitablement du bon travail, félicitations :)
Reste à voir en effet ce que l'on aura dans la version finale/officielle lors de la sortie mis-mars...

En tout cas, que TI rendre open-source ses modifs du firmware (ou au moins documente le protocole de communication) serait une bon avantage pour que la communauté puisse proposer des améliorations/modifications etc. pouvant potentiellement prendre le dessus sur la concurrence :P
Image

MyCalcs: Help the community's calculator documentations by filling out your calculators info!
MyCalcs: Aidez la communauté à documenter les calculatrices en donnant des infos sur vos calculatrices !
Inspired-Lua.org: All about TI-Nspire Lua programming (tutorials, wiki/docs...)
User avatar
AdriwebAdmin
Niveau 16: CC2 (Commandeur des Calculatrices)
Niveau 16: CC2 (Commandeur des Calculatrices)
Level up: 80.2%
 
Posts: 14616
Images: 1218
Joined: 01 Jun 2007, 00:00
Location: France
Gender: Male
Calculator(s):
MyCalcs profile
Twitter: adriweb
GitHub: adriweb

Re: Correctif TI-Python flottants + complexes sur Trinket M0

Unread postby parisse » 16 Feb 2019, 07:27

Prendre le dessus sur la concurrence, ca parait illusoire vu la quantite de memoire disponible: Lionel a ete oblige de virer les entiers longs, pour quelques kilo-octets. Ca limite sacrement l'interet pour l'arithmetique, a deconseiller aux lyceens qui veulent faire des maths, mieux vaut acheter une des calculatrices concurrentes.
User avatar
parisseVIP++
Niveau 12: CP (Calculatrice sur Pattes)
Niveau 12: CP (Calculatrice sur Pattes)
Level up: 78%
 
Posts: 3511
Joined: 13 Dec 2013, 16:35
Gender: Not specified
Calculator(s):
MyCalcs profile

Re: Correctif TI-Python flottants + complexes sur Trinket M0

Unread postby Adriweb » 16 Feb 2019, 08:01

Ah mais justement - si le protocole de communication est documenté, rien n'empêche de faire tourner circuitpython (voire micropython) sur un chip/board muni de davantage de mémoire et puissance, pour faire tourner des modules plus conséquents.
Mais c'est sûr que ca ne sera jamais autant pratique que s'il n'y avait rien a rajouter d'externe à la calculatrice, mais bon, pour ça, va falloir attendre un nouveau modèle chez les TI milieu-de-gamme :P
Image

MyCalcs: Help the community's calculator documentations by filling out your calculators info!
MyCalcs: Aidez la communauté à documenter les calculatrices en donnant des infos sur vos calculatrices !
Inspired-Lua.org: All about TI-Nspire Lua programming (tutorials, wiki/docs...)
User avatar
AdriwebAdmin
Niveau 16: CC2 (Commandeur des Calculatrices)
Niveau 16: CC2 (Commandeur des Calculatrices)
Level up: 80.2%
 
Posts: 14616
Images: 1218
Joined: 01 Jun 2007, 00:00
Location: France
Gender: Male
Calculator(s):
MyCalcs profile
Twitter: adriweb
GitHub: adriweb

Re: Correctif TI-Python flottants + complexes sur Trinket M0

Unread postby Lionel Debroux » 16 Feb 2019, 08:43

Lionel a ete oblige de virer les entiers longs, pour quelques kilo-octets

En fait, sur les Trinket M0 et certainement la plupart des autres boards à base d'ATSAMD21, par défaut, les entiers longs ne sont pas activés. Mais le reste des remarques reste vrai. Là, sachant que j'ai mis math, cmath et les fonctions spéciales de math, le tout prenant beaucoup de place au-dessus du code DPFP qui est plus gros que le code SPFP, je ne vois pas comment gagner ~6 KB pour une implémentation des entiers long basée sur mpz...

C'est facile d'activer les entiers longs si on vire précisément les modules os, io et storage absents des builds de TI:
Code: Select all
diff --git a/ports/atmel-samd/boards/trinket_m0/mpconfigboard.mk b/ports/atmel-samd/boards/trinket_m0/mpconfigboard.mk
index 763ccec7c..84492c51b 100644
--- a/ports/atmel-samd/boards/trinket_m0/mpconfigboard.mk
+++ b/ports/atmel-samd/boards/trinket_m0/mpconfigboard.mk
@@ -5,7 +5,7 @@ USB_PRODUCT = "Unofficial TI-Python Adapter"
USB_MANUFACTURER = "Texas Instruments Incorporated"

INTERNAL_FLASH_FILESYSTEM = 1
-LONGINT_IMPL = NONE
+LONGINT_IMPL = LONGLONG

CHIP_VARIANT = SAMD21E18A
CHIP_FAMILY = samd21
diff --git a/ports/atmel-samd/mpconfigport.h b/ports/atmel-samd/mpconfigport.h
index c08b232bf..aba98c61f 100644
--- a/ports/atmel-samd/mpconfigport.h
+++ b/ports/atmel-samd/mpconfigport.h
@@ -166,7 +166,7 @@ typedef long mp_off_t;
#define MICROPY_PY_BUILTINS_NOTIMPLEMENTED          (0)
#define MICROPY_PY_COLLECTIONS_ORDEREDDICT          (0)
#define MICROPY_PY_FUNCTION_ATTRS                   (0)
-#define MICROPY_PY_IO                               (1)
+#define MICROPY_PY_IO                               (0)
#define MICROPY_PY_REVERSE_SPECIAL_METHODS          (0)
#define MICROPY_PY_SYS_EXC_INFO                     (0)
#define MICROPY_PY_UERRNO_LIST \
@@ -211,6 +211,7 @@ typedef long mp_off_t;

#ifdef LONGINT_IMPL_LONGLONG
#define MICROPY_LONGINT_IMPL (MICROPY_LONGINT_IMPL_LONGLONG)
+#define MP_SSIZE_MAX (0x7fffffff)
#endif

// extra built in modules to add to the list of known ones
@@ -352,7 +353,7 @@ extern const struct _mp_obj_module_t pixelbuf_module;

#else
     #define MICROPY_PY_BUILTINS_STR_CENTER (1)
-    #define MICROPY_PY_BUILTINS_STR_PARTITION (1)
+    #define MICROPY_PY_BUILTINS_STR_PARTITION (0)
     #define MICROPY_PY_BUILTINS_FROZENSET (0)
     #define MICROPY_PY_BUILTINS_STR_SPLITLINES (1)
     #define MICROPY_PY_BUILTINS_REVERSED (1)
@@ -426,9 +427,7 @@ extern const struct _mp_obj_module_t pixelbuf_module;

#else
#define MICROPY_PORT_BUILTIN_MODULES \
-    { MP_OBJ_NEW_QSTR(MP_QSTR_os), (mp_obj_t)&os_module }, \
     { MP_OBJ_NEW_QSTR(MP_QSTR_random), (mp_obj_t)&random_module }, \
-    { MP_OBJ_NEW_QSTR(MP_QSTR_storage), (mp_obj_t)&storage_module }, \
     { MP_OBJ_NEW_QSTR(MP_QSTR_time), (mp_obj_t)&time_module }, \
     EXTRA_BUILTIN_MODULES
#endif


Code: Select all
LINK build-trinket_m0/firmware.elf

284 bytes free in flash out of 188416 bytes ( 184.0 kb ).
26644 bytes free in ram for stack out of 32768 bytes ( 32.0 kb ).

Create build-trinket_m0/firmware.bin
Create build-trinket_m0/firmware.uf2
Converting to uf2, output size: 376320, start address: 0x2000
Wrote 376320 bytes to build-trinket_m0/firmware.uf2.

(avec MICROPY_PY_BUILTINS_STR_PARTITION = 1, il y a -4 octets de place disponible !)
mais dans tous les cas, c'est nul de devoir faire ça parce que le matériel est sous-dimensionné.

rien n'empêche de faire tourner circuitpython (voire micropython) sur un chip/board muni de davantage de mémoire et puissance, pour faire tourner des modules plus conséquents.

Voilà, par exemple des boards à base d'ATSAMD51 beaucoup plus puissant, sur lesquelles beaucoup plus de modules sont activés par défaut. Cependant, on doit pouvoir trouver des SoC intermédiaires, s'il y en a qui sont gérés par CircuitPython. Le simple doublement des quantités de mémoire à 64 KB de RAM et 512 KB de Flash permettrait de faire sauter les limitations gênantes pour un usage d'enseignement en collège-lycée.

C'est fou cette manie de choisir des composants offrant juste la moitié de la quantité d'un des deux types de mémoire qu'il faudrait... c'est vrai notamment pour les TI-eZ80 actuelles (512 KB à 1 MB de RAM, 8 MB de Flash, et les deux avec beaucoup moins de waitstates, ne seraient pas du luxe, même si ça ne résoudrait pas le problème de la toolchain eZ80 !), pour les Prime G1 et leurs 32 MB de RAM deux ans après la sortie des Nspire CX équipées de 64 MB, pour les machines NumWorks parce qu'ils ne pouvaient pas se permettre le surcoût à l'époque.
Membre de la TI-Chess Team.
Co-mainteneur de GCC4TI (documentation en ligne de GCC4TI), TIEmu et TILP.
User avatar
Lionel DebrouxSuper Modo
Niveau 14: CI (Calculateur de l'Infini)
Niveau 14: CI (Calculateur de l'Infini)
Level up: 11.2%
 
Posts: 6859
Joined: 23 Dec 2009, 00:00
Location: France
Gender: Male
Calculator(s):
MyCalcs profile
Class: -
GitHub: debrouxl

Re: Correctif TI-Python flottants + complexes sur Trinket M0

Unread postby parisse » 16 Feb 2019, 18:43

Adriweb wrote:Ah mais justement - si le protocole de communication est documenté, rien n'empêche de faire tourner circuitpython (voire micropython) sur un chip/board muni de davantage de mémoire et puissance, pour faire tourner des modules plus conséquents.
Mais c'est sûr que ca ne sera jamais autant pratique que s'il n'y avait rien a rajouter d'externe à la calculatrice, mais bon, pour ça, va falloir attendre un nouveau modèle chez les TI milieu-de-gamme :P

Je ne suis pas sur d'avoir bien compris. Si on utilise le materiel vendu par TI, on ne peut pas avoir plus de memoire, si? Ca n'empeche evidemment pas quelques passiones de faire mieux, mais la quasi-totalite des lyceens vont se trainer un module Python externe sous-developpe.
Ca serait d'ailleurs interessant de voir le %age de lyceens qui vont convertir leur casio 35 en 75 pour installer CasioPython dessus.
User avatar
parisseVIP++
Niveau 12: CP (Calculatrice sur Pattes)
Niveau 12: CP (Calculatrice sur Pattes)
Level up: 78%
 
Posts: 3511
Joined: 13 Dec 2013, 16:35
Gender: Not specified
Calculator(s):
MyCalcs profile

Re: Correctif TI-Python flottants + complexes sur Trinket M0

Unread postby Lionel Debroux » 17 Feb 2019, 00:11

De grosses modifs, allant plutôt dans le sens de l'amélioration, ont été apportées au processus de build de CircuitPython. J'ai donc rebasé mes modifs dessus, il y a maintenant un peu moins de hacks.
Les nouveaux binaires fonctionneront peut-être un peu moins bien que la précédente version ? Merci de vos tests, je linkerai ce post dans le premier post si mes binaires fonctionnent suffisamment bien ;)

Changelog par rapport à la version précédente 691440f89d94b96cc0271001a2e75fc659463f89 :
* rebase sur CircuitPython HEAD;
* désactivation d'io: c'est le dernier module que j'avais ajouté, il n'est pas très utile et son petit KB m'empêchait de réaliser l'...
* ... activation de l'implémentation LONGLONG des entiers longs, en laissant 512 octets de marge :)
* création d'une autre version qui ne dispose pas des fonctions spéciales de math (expm1, a?{cos,sin,tan}h, log2, log10, erf, erfc, lgamma, tgamma) mais dispose de meilleurs entiers longs, avec l'implémentation MPZ. Là, il y a presque 4 KB de marge.

Notes:
* étape 1: désactiver expm1, log2, log10, erfc et lgamma, qui sont les moins utiles du groupe des fonctions spéciales, donne un binaire 1 KB au-delà de la limite. log2 et log10 ne coûtent pas grand chose;
* étape 2: si en plus de désactiver ces fonctions, on désactive le module "storage", on n'est plus que 200 octets au-delà de la limite, un peu plus d'un pour mille...
* étape 3: il faut désactiver également le module "os" et enlever une référence à l'OS pour passer 1+ KB en-dessous de la limite. Mais sans trafiquer le code, on ne peut pas activer "storage" sans "os".

Diffs et binaires joints, comme d'habitude.
Attachments
circuitpython_trinketm0_dpfp_nospecialmath_mpzlongint_20190216_2320_debrouxl.tar.bz2
Version sans les fonctions de maths spéciales et de meilleurs entiers longs
(277.13 KiB) Downloaded 207 times
circuitpython_trinketm0_dpfp_specialmath_longlonglongint_20190216_2319_debrouxl.tar.bz2
Version avec les fonctions de maths spéciales et des entiers un peu plus longs
(291.38 KiB) Downloaded 208 times
Membre de la TI-Chess Team.
Co-mainteneur de GCC4TI (documentation en ligne de GCC4TI), TIEmu et TILP.
User avatar
Lionel DebrouxSuper Modo
Niveau 14: CI (Calculateur de l'Infini)
Niveau 14: CI (Calculateur de l'Infini)
Level up: 11.2%
 
Posts: 6859
Joined: 23 Dec 2009, 00:00
Location: France
Gender: Male
Calculator(s):
MyCalcs profile
Class: -
GitHub: debrouxl

Re: Correctif TI-Python flottants + complexes sur Trinket M0

Unread postby Adriweb » 17 Feb 2019, 03:54

Pas mal :)

Est-il possible de prendre uniquement "a?{cos,sin,tan}h, log2, log10" parmi les fonctions spéciales? C'est a la limite ce qui serait le moins rare parmi ce qui peut se faire, il me semble.
Et si ça rentre pas, enlever les variantes hyperboliques de trigo ?
Image

MyCalcs: Help the community's calculator documentations by filling out your calculators info!
MyCalcs: Aidez la communauté à documenter les calculatrices en donnant des infos sur vos calculatrices !
Inspired-Lua.org: All about TI-Nspire Lua programming (tutorials, wiki/docs...)
User avatar
AdriwebAdmin
Niveau 16: CC2 (Commandeur des Calculatrices)
Niveau 16: CC2 (Commandeur des Calculatrices)
Level up: 80.2%
 
Posts: 14616
Images: 1218
Joined: 01 Jun 2007, 00:00
Location: France
Gender: Male
Calculator(s):
MyCalcs profile
Twitter: adriweb
GitHub: adriweb

Re: Correctif TI-Python flottants + complexes sur Trinket M0

Unread postby Lionel Debroux » 17 Feb 2019, 10:15

Avant de dormir, en dégradant le seeding des nombres aléatoires (shared-module/random::yasmarang(): suppression de l'appel à common_hal_os_urandom()), j'avais réussi à obtenir un build avec les entiers longs mpz et toutes les fonctions de maths spéciales, qui laissait exactement 0 octets de place libre en Flash :)
Mais évidemment, un tel build passera au-delà de la limite au moindre changement, donc sans autres changements, cette technique n'est pas réellement utilisable...

En jouant à activer / désactiver individuellement les fonctions de maths spéciales, on voit qu'activer erfc() coûte 560 octets, ce qui est normal quand on regarde l'implémentation de la fonction de calcul erfc(): pour atteindre une meilleure précision, il y a un deuxième jeu de fonctions et coefficients flottants, plus gros que celui utilisé par erf(). J'ai donc changé l'implémentation d'erfc() par un simple "return 1. - erf(x)", qui ne coûte que 40 octets, parce que j'ai du mal à me convaincre qu'en lycée, pour l'enseignement des probas, on ait besoin de plus de précision que ça.

Quand on restaure la génération des nombres aléatoires (~150 octets), et qu'on fait le changement d'implémentation d'erfc() précédemment décrit, on obtient:
* version cmath + toutes fonctions spéciales + LONGLONG longint + os + storage:
Code: Select all
LINK build-trinket_m0/firmware.elf

1056 bytes free in flash out of 188416 bytes ( 184.0 kb ).
26652 bytes free in ram for stack out of 32768 bytes ( 32.0 kb ).

Create build-trinket_m0/firmware.bin
Create build-trinket_m0/firmware.uf2
Converting to uf2, output size: 374784, start address: 0x2000
Wrote 374784 bytes to build-trinket_m0/firmware.uf2.


* version cmath + toutes fonctions spéciales + MPZ longint, mais pas io, storage et os:
Code: Select all
LINK build-trinket_m0/firmware.elf

392 bytes free in flash out of 188416 bytes ( 184.0 kb ).
26760 bytes free in ram for stack out of 32768 bytes ( 32.0 kb ).

Create build-trinket_m0/firmware.bin
Create build-trinket_m0/firmware.uf2
Converting to uf2, output size: 376320, start address: 0x2000
Wrote 376320 bytes to build-trinket_m0/firmware.uf2.


La marge est assez faible - un peu plus de 2 pour mille - mais cette deuxième version est assez proche de ce que TI pourrait fournir s'ils voulaient s'en donner la peine.
Attachments
circuitpython_trinketm0_dpfp_mpzlongint_20190217_0937_debrouxl.tar.bz2
Version avec entiers longs longs, mais pas io, os et storage
(271.31 KiB) Downloaded 196 times
circuitpython_trinketm0_dpfp_longlonglongint_20190217_0935_debrouxl.tar.bz2
Version avec entiers longs moyens, os, storage
(282.05 KiB) Downloaded 229 times
Membre de la TI-Chess Team.
Co-mainteneur de GCC4TI (documentation en ligne de GCC4TI), TIEmu et TILP.
User avatar
Lionel DebrouxSuper Modo
Niveau 14: CI (Calculateur de l'Infini)
Niveau 14: CI (Calculateur de l'Infini)
Level up: 11.2%
 
Posts: 6859
Joined: 23 Dec 2009, 00:00
Location: France
Gender: Male
Calculator(s):
MyCalcs profile
Class: -
GitHub: debrouxl

Re: Correctif TI-Python flottants + complexes sur Trinket M0

Unread postby Adriweb » 17 Feb 2019, 17:06

Les 2 bootent et ont l'air de fonctionner comme prévu, mais il va falloir me dire quoi tester :D

longlong:
Adafruit CircuitPython 4.0.0-beta.2-78-g4a78aa3a5 on 2019-02-17; Adafruit Trinket M0 with samd21e18
>>> 2+2
4
>>> 2.0+2.0
4.0
>>> 123456789*123456789
15241578750190521
>>>
>>> help("modules")
__main__ collections os time
array gc random
builtins math storage
cmath micropython sys
Plus any modules on the filesystem


mpz:
Adafruit CircuitPython 4.0.0-beta.2-79-g4b5b8b66c on 2019-02-17; Adafruit Trinket M0 with samd21e18
>>> help("modules")
__main__ cmath math sys
array collections micropython time
builtins gc random
Plus any modules on the filesystem
>>> 2+2
4
>>> 2.0+2.0
4.0
>>> 123456789*123456789
15241578750190521
>>> 12345678910*12345678910
152415787748818788100
>>> 123456789101*123456789101
15241578775128792388201
>>> 12345678910111*12345678910111
152415787751559528818032321
>>> 1234567891011123*1234567891011123
1524157877515652078303309721129
Image

MyCalcs: Help the community's calculator documentations by filling out your calculators info!
MyCalcs: Aidez la communauté à documenter les calculatrices en donnant des infos sur vos calculatrices !
Inspired-Lua.org: All about TI-Nspire Lua programming (tutorials, wiki/docs...)
User avatar
AdriwebAdmin
Niveau 16: CC2 (Commandeur des Calculatrices)
Niveau 16: CC2 (Commandeur des Calculatrices)
Level up: 80.2%
 
Posts: 14616
Images: 1218
Joined: 01 Jun 2007, 00:00
Location: France
Gender: Male
Calculator(s):
MyCalcs profile
Twitter: adriweb
GitHub: adriweb

Next

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

Who is online

Users browsing this forum: No registered users and 110 guests

-
Search
-
Social TI-Planet
-
Featured topics
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
-
Donations / Premium
For more contests, prizes, reviews, helping us pay the server and domains...
Donate
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 Calculatrices à acheter chez Calcuso
-
Stats.
1069 utilisateurs:
>1006 invités
>58 membres
>5 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)