π
<-
Chat plein-écran
[^]

Divers Campagne de dons / financement participatif... avec goodies!

Nouveau messagede Admin » Hier, 00:42

Comme vous le savez peut-être en nous lisant, chez TI-Planet nous avons l'habitude depuis plusieurs années particulièrement, de nous rendre à des salons, conférences, événements… à propos d'
education technology
, notamment pour aller rencontrer des exposants comme TI, Casio, HP, NumWorks…
On peut par exemple citer les news que nous avons écrites à propos de T3, EduSpot, Orme, APMEP, UdPPC etc. ainsi que les nombreux albums photos associés.

En 2019 nous continuons bien sûr cette habitude, surtout qu'il y a beaucoup de nouveautés ces temps-ci, et être présent là où sont révélées les dernières innovations sera assez coûteux à l'association UPECS
(qui gère TI-Planet)
- et en fait, davantage que d'habitude…

En effet, voici le programme chargé que nous avons prévu pour vous :
Lors de ces salons,
critor
sera votre journaliste envoyé spécial et aura l'occasion de vous rapporter des nouvelles exclusives de ce que TI (particulièrement) et d'autres constructeurs y présenteront, comme la TI-Nspire CX II notamment, mais aussi le TI-Python et sûrement davantage encore...

Nous avons calculé le coût global de tout ceci (que l'on tente de minimiser autant que possible, évidemment), donc trains, avions, hôtels, nourriture sur place, entrées, transports en commun, etc. et ça reviendra à environ 1400 euro maximum (respectivement environ 400, 800, 80, et 80).

Cette fois-ci donc, nous aimerions appeler à votre générosité, pour nous aider financièrement à travers ces aventures en ouvrant une petite campagne de dons / financement participatif.
L'association accueille à bras ouverts tout don peu importe le montant !
Et pour vous encourager, nous avons mis en place un système de "goodies/récompenses donateurs" par palier qui vous permettra si vous le souhaitez de récupérer un tas de choses bien sympa tout en nous aidant - nous pensons que c'est un système bénéfique à la fois pour nous et pour vous. Quand vous donnez un montant égal ou supérieur à un palier, vous pouvez choisir de recevoir lesdites "récompenses donateurs" :)

En tout cas, peu importe ce que vous donnez, votre compte TI-Planet rejoindra le groupe des Donateurs !

PayPal - la solution de paiement en ligne la plus simple et la plus sécurisée !
Don par Paypal ou par carte, mais vous pouvez aussi nous contacter si vous préférez autrement (virement...)


A partir de 2€
:
  • compte
    premium
    TI-Planet
    (ce qui en fait donc une sorte de promo spéciale ;-))


A partir de 5€
:
  • compte premium TI-Planet
  • ajout de votre compte TI-Planet au
    groupe spécial
    VIP


A partir de 8€
:
  • compte premium TI-Planet
  • ajout de votre compte TI-Planet au
    groupe spécial
    VIP+
  • mention de votre nom/pseudo en remerciement dans les news des événements associés


A partir de 13,37€
:
  • compte premium TI-Planet
  • votre nom/pseudo en remerciement dans les news des événements associés
  • ajout de votre compte TI-Planet au
    groupe spécial
    VIP++
  • accès aux albums privés contenant les photos relatives aux événements avant utilisation en news


A partir de 16€
:
  • compte premium TI-Planet
  • ajout de votre compte TI-Planet au
    groupe spécial
    VIP++
  • votre nom/pseudo en remerciement dans les news des événements associés
  • accès aux albums privés contenant les photos relatives aux événements avant utilisation en news
  • un sticker TI-Planet spécial VIP


A partir de 25€
:
  • compte premium TI-Planet
  • ajout de votre compte TI-Planet au
    groupe spécial
    VIP++
  • votre nom/pseudo en remerciement dans les news des événements associés
  • accès aux albums privés contenant les photos relatives aux événements avant utilisation en news
  • 2 stickers TI-Planet spécial VIP
  • adaptateur périphériques USB pour calculatrice CE / Nspire CX : mini-usb A/OTG mâle ⇔ USB A femelle


A partir de 50€
:
  • compte premium TI-Planet
  • ajout de votre compte TI-Planet au
    groupe spécial
    VIP++
  • votre nom/pseudo en remerciement dans les news des événements associés
  • accès aux albums privés contenant les photos relatives aux événements avant utilisation en news
  • 2 stickers TI-Planet spécial VIP
  • adaptateur périphériques USB pour calculatrice CE / Nspire CX : mini-usb A/OTG mâle ⇔ USB A femelle
  • T-Shirt TI-Planet spécial VIP


A partir de 80€
:
  • compte premium TI-Planet
  • ajout de votre compte TI-Planet au
    groupe spécial
    VIP++
  • votre nom/pseudo en remerciement dans les news des événements associés
  • accès aux albums privés contenant les photos relatives aux événements avant utilisation en news
  • 2 stickers TI-Planet spécial VIP
  • T-Shirt TI-Planet spécial VIP
  • adaptateur périphériques USB pour calculatrice CE / Nspire CX : mini-usb A/OTG mâle ⇔ USB A femelle
  • au choix :
    • un prototype de clavier TI-Nspire
      (quantité disponible : 3)
    • un mini-clavier USB pour TI-83 Premium CE / TI-84 Plus CE
1024910250Détail des prototypes de claviers TI-Nspire disponibles :


A partir de 99€
:
10253
  • compte premium TI-Planet
  • ajout de votre compte TI-Planet au groupe spécial/exclusif (avec couleur unique)
  • votre nom/pseudo en remerciement dans les news des événements associés
  • accès aux albums privés contenant les photos relatives aux événements avant utilisation en news
  • 2 stickers TI-Planet spécial VIP
  • T-Shirt TI-Planet spécial VIP
  • adaptateur périphériques USB pour calculatrice CE / Nspire CX : mini-usb A/OTG mâle ⇔ USB A femelle
  • au choix :
    • un prototype TI-Nspire CAS avec connecteur J04/JTAG, Nlaunch et la dernière version 3.9.0
      (quantité disponible : 2)
    • un TI-Nspire Connection Cradle
      - adaptateur facilitant la connexion au connecteur J01/Dock de vos bricolages à inventer
      (UART: afficheur/enregistreur/interface bidirectionnelle..., 2ème port USB, batterie externe, diode ou haut-parleur sur les GPIO0/GPIO4/GPIO22, etc...)
Détail des prototypes
TI-Nspire CAS JTAG
disponibles :
  • une
    TI-XXXXXXXXXXX
    , numéro de série
    P1-R2-DVT1-000160
    , référence carte mère
    P1R2_DVT1.2_MB_6422
    , référence carte écran
    P3_LB_DVT1.2_2425
  • une
    TI-Nspire CAS
    , numéro de série
    P1-R2-DVT1.2-197
    , référence carte mère
    P1R2_DVT2_MB_6423
    , référence carte écran
    P1R2/P3_LB_PVT_2430
1025810256102571025510254


Pour les 3 premiers à donner 159€ ou plus
:
  • compte premium TI-Planet
  • ajout de votre compte TI-Planet au
    groupe spécial
    VIP++
  • votre nom/pseudo en remerciement dans les news des événements associés
  • accès aux albums privés contenant les photos relatives aux événements avant utilisation en news
  • 2 stickers TI-Planet spécial VIP
  • T-Shirt TI-Planet spécial VIP
  • adaptateur périphériques USB pour calculatrice CE / Nspire CX : mini-usb A/OTG mâle ⇔ USB A femelle
  • un mini-clavier USB pour TI-83 Premium CE / TI-84 Plus CE
  • une TI-83 Premium CE neuve au choix avec
    boot string
    custom
    (par exemple votre nom/surnom).
    En cadeau, on vous installe tout programme/appli existant souhaité !
10259Détail des
TI-83 Premium CE
disponibles :
  • une
    TI-83 Premium CE
    sous emballage d'exposition A (rentrée 2015 - probablement Boot Code
    5.0.0
    )
  • une
    TI-83 Premium CE
    blanche de timbre à date
    L-0717I
    (révision matérielle
    I
    , Boot Code
    5.1.5
    ) sous emballage d'expédition
  • une
    TI-83 Premium CE
    bleue sous emballage d'exposition D (rentrée 2018 - probablement Boot Code
    5.1.5
    )


Pour les 3 premiers à donner 199€ ou plus

10253
  • compte premium TI-Planet
  • ajout de votre compte TI-Planet au
    groupe spécial
    VIP++
  • votre nom/pseudo en remerciement dans les news des événements associés
  • accès aux albums privés contenant les photos relatives aux événements avant utilisation en news
  • 2 stickers TI-Planet spécial VIP
  • T-Shirt TI-Planet spécial VIP
  • adaptateur périphériques USB pour calculatrice CE / Nspire CX : mini-usb A/OTG mâle ⇔ USB A femelle
  • un TI-Nspire Connection Cradle
    - adaptateur facilitant la connexion au connecteur J01/Dock de vos bricolages à inventer
    (afficheur UART, enregistreur UART, interface UART bidirectionnelle, 2ème port USB, batterie externe, diode ou haut-parleur sur les GPIO0/GPIO4/GPIO22, etc...)
  • une TI-Nspire CX CAS avec licence neuve au choix que l'on personnalise à vos souhaits
    :
    • Ndless qui affiche un remerciement personnalisé à nous communiquer (par exemple “Ndless installed for [NOM]”, de couleur vive au choix)
    • nBoot+ControlX / nLoader selon compatibilité
    • splash de démarrage custom 320x240 à fournir (nBoot+ControlX uniquement)
    • Linux (nBoot+ControlX uniquement)
    • nSonic2MS avec touche secrète + code pin au choix préconfigurés
    • etc.
10260Détail des
TI-Nspire CX CAS
disponibles :
  • une
    TI-Nspire CX CAS
    sous emballage d'exposition D (rentrée 2017 - probablement génération
    CR4+
    , révision matérielle
    W+
    , processeur
    156MHz
    , Boot1
    4.0.1
    , batterie Samsung
    1200mAh
    )
  • deux
    TI-Nspire CX CAS
    de timbre à date
    P-0517AA
    (génération
    CR7
    , révision matérielle
    AA
    , processeur
    156MHz
    , Boot1
    4.0.1
    , batterie Samsung
    1200mAh
    ) sous emballage d'expédition

PayPal - la solution de paiement en ligne la plus simple et la plus sécurisée !
Don par Paypal ou par carte, mais vous pouvez aussi nous contacter si vous préférez autrement (virement...)


Nous analyserons les paliers demandés (leur quantité à dispatcher) d'ici mi-mai afin de faire des commandes groupées et optimiser les frais-de-port ; chaque personne recevant quelque chose sera tenue au courant de la livraison :)

Merci d'avance à tous !
Lien vers le sujet sur le forum: Campagne de dons / financement participatif... avec goodies! (Commentaires: 7)

TI-z80 Correctif TI-Python flottants + complexes sur Trinket M0

Nouveau messagede critor » 14 Fév 2019, 23:32



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
, 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
, featuring
double precision floating-point values
to fix the 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 de ces nombres, ce qui limite leur nombre de chiffres significatifs.

Voici la transcription
Python
d'un algorithme permettant de tester les nombres de bits et de chiffres significatifs utilisables pour les mantisses de flottants.
Ceci en appelant respectivement precm(2) et precm(10) :
Code: Tout sélectionner
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 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.

Vouloir construire un produit pour le lycée scientifique en partant de ça n'était-il pas une erreur ?...
:#roll#:
TODO translate to English. TL;DR: single-precision floating-point sucks, yielding wrong results for a range of reasonable high school level math problems. There's a reason why all other manufacturers ended up using DPFP in the end...

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

Heureusement, devant la gravité de la situation et pour voir si c'était difficile de faire mieux que TI, 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, 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, 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) :)
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, 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) :)

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
:
https://tiplanet.org/forum/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=240032#p240032 . 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.
Lien vers le sujet sur le forum: Correctif TI-Python flottants + complexes sur Trinket M0 (Commentaires: 9)

TI-Nspire Découvre les TI-Nspire CX II à Didacta 2019 Cologne !

Nouveau messagede critor » 14 Fév 2019, 20:52

1018110175Dans un article précédent, nous t'annoncions l'arrivée pour la rentrée 2019 d'une nouvelle génération de calculatrices
TI-Nspire
, les
TI-Nspire CX II
et
TI-Nspire CX II CAS
.

Nous t'en avons par la suite détaillé les nouvelles fonctionnalités. Quant au matériel, a été évoqué un processeur 2,5 fois plus rapide.

La France et l'Europe pour leur part vont bénéficier pour la première fois de déclinaisons spécifiques, les
TI-Nspire CX II-T
et
TI-Nspire CX II-T CAS
.

As-tu raté la première présentation au public aux Pays-Bas ?

Et bien nouvelle chance de découvrir l'avenir de la gamme
TI-Nspire
cette semaine avec l'édition 2019 de
Didacta
, le salon européen de l'éducation, du mardi 19 au samedi 23 février inclus à Cologne/Köln en Allemagne ! :bj:

Texas Instruments
y tiendra en effet un stand et, si les Pays-Bas ont eu droit à la
TI-Nspire CX II
, il nous semblerait impensable que
Didacta
n'y ait pas droit. ;)

Casio
tiendra également un stand, mais nous ignorons si il y aura des nouveautés.

Hewlett Packard
sera présent mais via sa filiale
Aruba
, donc rien à voir avec les calculatrices.

Tu trouveras des entreprises et institutions venant du monde entier, France incluse, mais pas de
NumWorks
.

Lien
:
http://www.didacta-cologne.com/
Lien vers le sujet sur le forum: Découvre les TI-Nspire CX II à Didacta 2019 Cologne ! (Commentaires: 0)

Divers Retour vers 1998 avec le dossier fnac calculatrices

Nouveau messagede critor » 13 Fév 2019, 13:50

Salut à toi !

Aujourd'hui, nous te proposons un voyage dans le temps avec l'édition
1998
du
dossier fnac sélection calculatrices et bloc-notes
que nous t'avons retrouvé. Ce magazine annuel était disponible gratuitement dans les boutiques
fnac
, à l'époque où cette chaîne en avait encore quelque chose à faire des calculatrices graphiques, avec un rayon entier leur étant exclusivement consacré et opposant sur un pied d'égalité les
Casio
,
Texas Instruments
,
Hewlett Packard
et même les légendaires
Sharp
.

Le catalogue présente entre autres un test comparatif des différentes calculatrices graphiques commercialisées par la chaîne, et nos tests
QCC
pour chaque rentrée
en sont justement librement inspirés.

Amusant de lire l'introduction mettant en avant la possibilité de stocker des "anti-sèches" en mémoire, ce ne scandalisait personne à l'époque.




Commençons donc par un petit inventaire de ce que proposait donc la
fnac
autour de 1998.

Nous avons premièrement les calculatrices pour la Troisième et la Seconde.

De 200F à 300F
(soit 40€ à 60€ de nos jours en tenant compte de l'inflation)
, nous avons :
  • la
    Casio fx-6910G
  • la
    TI-80

Puis de 300F à 500F
(soit 60€ à 100€ de nos jours)
nous trouvons :
  • la
    Casio cfx-8930
    , référence qui en fait n'existe pas, probablement plutôt la
    fx-8930GT
  • la
    Sharp EL-9400

Page suivante, de 500F à 800F
(soit 100€ à 160€)
, nous trouvons dabord d'autres calculatrices prévues pour la Troisième et la Seconde :
  • la
    Casio cfx-9930GT
  • la
    Casio cfx-9940GT
  • la
    Casio cfx-9960GT
Notons qu'il s'agit de calculatrices à écran couleur 2 bits
(2²=4 couleurs)
!

Puis, pour la Première et la Terminale, nous avons :
  • la
    HP 38G
  • la
    Sharp EL-9600
    , avec un écran tactile !
  • la
    TI-82
  • la
    TI-83

Dernière page, de 800F à 1200F
(soit 160€ à 240€)
, est proposée la
HP 48G
.

Puis pour les classes préparatoires et les études supérieures :
  • TI-85
  • TI-86

Enfin pour plus de 1700F
(340€)
:
  • HP 48GX
  • TI-92
  • TI-92II



Des informations très préciseuses qui nous permettent nos diverses frises chronologiques conçues avec l'aide de et .

Les chronologies qui vont suivre sont organisées par gammes commerciales. Elles n'indiquent donc pas une parenté technologique entre les différents modèles successifs, mais c'est aussi une façon beaucoup plus simple et donc claire de présenter les choses, car cela expose le raisonnement du constructeur.

Chez
Texas Instruments
nous avions donc de façon cohérente en 1998 :
  • la
    TI-80
    : Modèle bas qui adaptait le système
    z80
    8 bits de la
    TI-81
    à un processeur
    Toshiba
    16 bits propriétaire, éclairant un écran ridicule de 64x48 pixels, et bien évidemment dépourvu de port de communication. Sorti en 1995, le modèle fut arrêté dès 1998. Si il fut certes remplacé par la
    TI-73
    , basée sur la
    TI-83 Plus
    allégée en fonctionnalités, la
    TI-73
    ne fut toutefois pas commercialisée en France ce qui eut pour conséquence d'augmenter nettement le prix de l'entrée de gamme. La
    TI-76.fr
    de 2009 mise en avant pour le lycée professionnel, une
    TI-82 Stats.fr
    elle aussi allégée en fonctionnalités fut le dernier membre de cette gamme commerciale. Il n'y a plus d'équivalent commercial depuis l'annonce de l'arrivée du mode examen en 2015, ce qui a donc à nouveau eu pour conséquence de reculer le prix de l'entrée de gamme.
  • la
    TI-82
    : Sortie en 1993 puis remplacée par la
    TI-82 STATS
    en 2004, il s'agit donc, commercialement parlant, du lointain ancêtre de ta
    TI-82 Advanced
    .
  • la
    TI-83
    : Sortie en 1996 puis rapidement remplacée dès 1999 par la
    TI-83 Plus
    , il s'agit ici du lointain ancêtre de ta
    TI-83 Premium CE
    .
  • les
    TI-85
    et
    TI-86
    : Sortie dès 1992, la
    TI-85
    , deuxième calculatrice graphique de
    Texas Instruments
    , initiait un haut de gamme ciblant les études supérieures et les élèves ingénieurs. Elle fut remplacée en 1997 par la
    TI-86
    , avec beaucoup plus de mémoire et pour la première fois le support officiel du langage assembleur. La
    fnac
    disposait donc encore 1998 de stock pour les deux modèles. Mais coincée à partir de 2001 entre la gamme des
    TI-83
    améliorées
    (
    TI-83 Plus Silver Edition
    ,
    TI-84 Plus
    ...)
    et les versions de poche plus abordables des modèles à moteur de calcul formel
    (
    TI-89
    )
    , la gamme n'était plus justifiée commercialement et fut donc arrêtée.
  • les
    TI-92
    et
    TI-92II
    : Sortie dès 1995, la
    TI-92
    fut la première calculatrice du constructeur à offrir un moteur de calcul formel, emprunté au logiciel
    Derive
    développé par la
    Soft Warehouse
    , rachetée par la suite par
    Texas Instruments
    . Elle avait également l'avantage exclusif d'un grand écran 240x128 pixels, ainsi que d'un clavier à disposition alphabétique
    qwerty
    ! Elle fut rapidement remplacée dès 1996 par la
    TI-92II
    avec davantage de mémoire, et ici donc la
    fnac
    disposait encore de stock pour les deux modèles.
Un défaut de cet éventail, est qu'à part la
TI-80
qui n'est pas concernée, tous les autres modèles utilisent des protocoles de communication différents. Impossible donc d'échanger directement des données entres les
TI-82
,
TI-83
,
TI-85/86
et
TI-92
, il fallait obligatoirement être équipé du même modèle que son partenaire.

Notons que le langage de programmation n'est pas présenté comme de nos jours. Il n'est pas qualifié comme étant proche du
Basic
, mais du
Pascal
, voir même du
Turbo Pascal
pour les
TI-92
. C'est faux dans tous les cas, le langage étant spécifique et ne se ressemblant qu'à lui-même.



Chez
Casio
nous avions donc en 1998 à la
fnac
:
  • la
    Casio fx-6910G
    : Plus connue à l'international sous le nom de
    fx-7400G
    depuis 1996, elle fut renommée
    fx-6910G
    dans sa version distribuée en France, noms de modèles dans tous les cas imbuvables. Elle fut succédée dès 1997 par la
    fx-6910aG
    puis par un modèle portant deux noms, la
    Graph 20 / fx-6910aG
    .
    Noblet
    , la société qui s'occupait à l'époque de la commercialisation des calculatrices
    Casio
    en France, avait en effet eu cette idée très salutaire de nous simplifier les noms de modèles français, mais qui nous complique beaucoup les choses pour établir une chronologie. Il s'agit donc d'un lointain ancêtre de ta
    Graph 25+E
    d'entrée de gamme.
  • la
    Casio fx-8930GT
    : Là encore il s'agit du nom français de l'époque pour la
    fx-9750G
    internationale de 1997. En France, elle fut renommée
    Graph 30
    pour la rentrée 1998, et il s'agit donc de l'ancêtre de ta
    Graph 35+E
    .
  • les
    Casio cfx-9930GT
    ,
    cfx-9940GT
    et
    cfx-9960GT
    : Il s'agit de 3 modèles succédant simultanément dès 1996 à la toute première calculatrice couleur, la
    Casio cfx-9800G
    de 1995. Elles sont plus connues à l'international sous les noms respectifs de
    cfx-9850G
    ,
    cfx-9850G+
    et
    cfx-9950G
    , avec bien évidemment une progression en fonctionnalités et mémoire. La
    cfx-9940GT
    fut remplacée dès 1998 par un modèle à double référence, la
    Graph 60 / cfx-9940GT+
    . La
    cfx-9960GT
    fut quant à elle remplacée en 1998 par la
    Graph 65
    . Dans tous les cas, commercialement parlant avec leur écran couleur, il s'agit des lointains ancêtres de ta
    Graph 90+E
    .
Le langage de programmation est ici bizarrement qualifié pour les
Casio
couleur de proche du
Basic
alors qu'il ressemble énormément à celui de
TI
, à de simples renommages près. Et tout aussi bizarrement, il est qualifié de spécifique pour les
Casio
monochromes qui ont pourtant le même langage, juste dépourvu des instructions concernant la couleur.




Chez
Hewlett Packard
, la frise chronologique se simplifie un petit peu. Nous avions en 1998 :
  • la
    HP 38G
    : Sortie en 1995, il s'agit de l'ancêtre de l'actuelle
    HP 39gII
    .
  • les
    HP 48G
    et
    HP 48GX
    : Sorties en 1993. La
    HP 48G
    fut remplacée en 1998 par la
    HP 48G+
    avec davantage de mémoire. Il s'agit dans les deux cas de versions allégées et donc plus abordables du haut de gamme. La
    HP 48GX
    fut quant à elle remplacée en 1999 par la
    HP 49G
    . Dans les deux cas il s'agit des ancêtres commerciaux de ta
    HP Prime
    .



Et enfin nous avons encore plus simple avec le légendaire
Sharp
:
  • la
    EL-9400
    : Sortie en 1995, il s'agit de la première calculatrice graphique à écran tactile.
  • la
    EL-9600
    : Sortie en 2000, elle remplace le modèle précédent dont elle conserve l'écran tactile.


Nos frises chronologiques nous ont demandé énormément de travail, et ne sont malgré tout sûrement pas parfaitement exactes, la période des années 1990 étant la plus difficile par manque de sources, l'Internet étant bien moins utilisé à l'époque. Et c'est encore plus difficile chez
Casio
avec des noms de modèles différents en France et à l'international pas évidents à recouper, les renommage en
Graph XX
à partir de 1998, des dates de lancement qui peuvent également différer, et avec la délégation de la commercialisation à un prestataire,
Noblet
racheté par
Dexxon
avant de retourner dans le giron de
Casio
en 2008-2009, ce qui éparpille encore davantage les rares sources.

Si tu disposes d'autres documents représentatifs des calculatrices offertes à cette époque et souhaites aider notre travail, n'hésite pas à les partager. :)


Téléchargement
:
archives_voir.php?id=1892203
Lien vers le sujet sur le forum: Retour vers 1998 avec le dossier fnac calculatrices (Commentaires: 14)

TI-z80 Test module TI-Python (version 3.0.0.12)

Nouveau messagede critor » 13 Fév 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
  2. Matériel et spécifications
  3. Première connexion USB : stockage, version, fonctionnement
  4. Liste modules Python
  5. Nombres complexes
  6. Exploration module sys
  7. Nombres entiers courts et longs
  8. Reference design
  9. Exploration module builtins
  10. Exploration module math
  11. Nombres flottants et précision
  12. Exploration autres modules Python
  13. Mémoire de travail
  14. Performances
  15. Connexion USB en mode mise à jour
  16. Dumping et compatibilités
  17. Conclusion



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
    de
    Batangas
    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 qu'il devrait être possible d'avoir des programmes
TI-83 Premium CE
gérant la lecture écriture sur clé USB ! :bj:


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


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



4) Liste modules Python :
Go to top

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

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


Pour comparaison :
Image


D'où le classement suivant :
  1. module externe
    TI-Python
    avec
    8
    modules
  2. + +
    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 pour les élèves Terminales S, STI2D et STL, c'est l'absence du module
cmath
pour les nombres complexes.

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

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


Pour comparaison :
Image


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



6) Exploration module sys :
Go to top

Puisque donc le module
sys
est inclus dans le module externe
TI-Python
, tentons d'en apprendre davantage sur ce dernier en effectuant son exploration à l'aide du script suivant que nous copions dans le dossier racine de l'espace de stockage :
Code: Tout sélectionner
def sstr(obj):
  try:
    s=obj.__name__
  except:
    s=str(obj)
    a=s.find("'")
    b=s.rfind("'")
    if a>=0 and b!=a:
      s=s[a+1:b]
  return s

def isExplorable(obj):
  s=str(obj)
  return s.startswith("<module '") or s.startswith("<class '")

def explmod(pitm,pitmsl=[],reset=True):
  global curline
  if(reset):
    curline=0
    pitmsl=[sstr(pitm)]
  hd="."*(len(pitmsl)-1)
  spath=".".join(pitmsl)
  c=0
  for itms in sorted(dir(pitm)):
    c=c+1
    try:
      itm=eval(spath+"."+itms)
      print(hd+itms+"="+str(itm))
      if isExplorable(itm):
        pitmsl2=pitmsl.copy()
        pitmsl2.append(itms)
        c=c+explmod(itm,pitmsl2,False)
    except:
      print(hd+itms)
  if c>0:
    print(hd+"Total: "+str(c)+" item(s)")
  return c


L'appel explmod(sys) nous produit alors :
TI-Python a écrit:>>> # Shell Reinitialized
>>> from explmod import *
>>> import sys
>>> explmod(sys)
__name__=sys
argv=[]
byteorder=little
exit=<function>
implementation=(name='circuitpython', version=(3, 0, 0))
maxsize=1073741823
modules={}
path=['', '/', '/lib', '.frozen']
platform=TI-Python Adapter
print_exception=<function>
stderr=<io.FileIO 2>
stdin=<io.FileIO 0>
stdout=<io.FileIO 1>
version=3.4.0
version_info=(3, 4, 0)
Total: 15 item(s)
15
>>>


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

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

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

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



7) Nombres entiers courts et longs :
Go to top

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

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

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

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

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

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


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

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


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

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


Pour comparaison :
Image


D'où le classement suivant :
  1. NumWorks
    + + +
    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: Tout sélectionner
def explmod(pitm,pitmsl=[],reset=True):
  global curline
  if(reset):
    curline=0
    pitmsl=[sstr(pitm)]
  hd="."*(len(pitmsl)-1)
  spath=".".join(pitmsl)
  c=0
  for itms in sorted(dir(pitm)):
    c=c+1
    try:
      itm=eval(spath+"."+itms)
      print(hd+itms+"="+str(itm))
      if isExplorable(itm):
        pitmsl2=pitmsl.copy()
        pitmsl2.append(itms)
        c=c+explmod(itm,pitmsl2,False)
    except:
      print(hd+itms)
  if c>0:
    print(hd+"Total: "+str(c)+" item(s)")
  return c


L'appel explmod(builtins) nous produit alors :
Code: Tout sélectionner
>>> # Shell Reinitialized
>>> from explmod import *
>>> import builtins
>>> explmod(builtins)
ArithmeticError=<class 'ArithmeticError'>
AssertionError=<class 'AssertionError'>
AttributeError=<class 'AttributeError'>
BaseException=<class 'BaseException'>
.__init__=<function>
.Total: 1 item(s)
EOFError=<class 'EOFError'>
Ellipsis=Ellipsis
Exception=<class 'Exception'>
GeneratorExit=<class 'GeneratorExit'>
ImportError=<class 'ImportError'>
IndentationError=<class 'IndentationError'>
IndexError=<class 'IndexError'>
KeyError=<class 'KeyError'>
KeyboardInterrupt=<class 'KeyboardInterrupt'>
LookupError=<class 'LookupError'>
MemoryError=<class 'MemoryError'>
NameError=<class 'NameError'>
NotImplementedError=<class 'NotImplementedError'>
OSError=<class 'OSError'>
OverflowError=<class 'OverflowError'>
ReloadException=<class 'ReloadException'>
RuntimeError=<class 'RuntimeError'>
StopIteration=<class 'StopIteration'>
SyntaxError=<class 'SyntaxError'>
SystemExit=<class 'SystemExit'>
TypeError=<class 'TypeError'>
UnicodeError=<class 'UnicodeError'>
ValueError=<class 'ValueError'>
ZeroDivisionError=<class 'ZeroDivisionError'>
__build_class__=<function>
__import__=<function>
__name__=builtins
__repl_print__=<function>
abs=<function>
all=<function>
any=<function>
bin=<function>
bool=<class 'bool'>
bytearray=<class 'bytearray'>
.append=<function>
.extend=<function>
.Total: 2 item(s)
bytes=<class 'bytes'>
.count=<function>
.endswith=<function>
.find=<function>
.format=<function>
.index=<function>
.isalpha=<function>
.isdigit=<function>
.islower=<function>
.isspace=<function>
.isupper=<function>
.join=<function>
.lower=<function>
.lstrip=<function>
.replace=<function>
.rfind=<function>
.rindex=<function>
.rsplit=<function>
.rstrip=<function>
.split=<function>
.startswith=<function>
.strip=<function>
.upper=<function>
.Total: 22 item(s)
callable=<function>
chr=<function>
classmethod=<class 'classmethod'>
dict=<class 'dict'>
.__delitem__=<function>
.__getitem__=<function>
.__setitem__=<function>
.clear=<function>
.copy=<function>
.fromkeys=<bound_method>
.get=<function>
.items=<function>
.keys=<function>
.pop=<function>
.popitem=<function>
.setdefault=<function>
.update=<function>
.values=<function>
.Total: 14 item(s)
dir=<function>
divmod=<function>
enumerate=<class 'enumerate'>
eval=<function>
exec=<function>
filter=<class 'filter'>
float=<class 'float'>
getattr=<function>
globals=<function>
hasattr=<function>
hash=<function>
help=<function>
help=<function>
hex=<function>
id=<function>
input=<function>
input=<function>
int=<class 'int'>
.from_bytes=<bound_method>
.to_bytes=<function>
.Total: 2 item(s)
isinstance=<function>
issubclass=<function>
iter=<function>
len=<function>
list=<class 'list'>
.append=<function>
.clear=<function>
.copy=<function>
.count=<function>
.extend=<function>
.index=<function>
.insert=<function>
.pop=<function>
.remove=<function>
.reverse=<function>
.sort=<function>
.Total: 11 item(s)
locals=<function>
map=<class 'map'>
max=<function>
memoryview=<class 'memoryview'>
min=<function>
next=<function>
object=<class 'object'>
oct=<function>
open=<function>
ord=<function>
pow=<function>
print=<function>
property=<class 'property'>
.deleter=<function>
.getter=<function>
.setter=<function>
.Total: 3 item(s)
range=<class 'range'>
repr=<function>
round=<function>
set=<class 'set'>
.__contains__=<function>
.add=<function>
.clear=<function>
.copy=<function>
.difference=<function>
.difference_update=<function>
.discard=<function>
.intersection=<function>
.intersection_update=<function>
.isdisjoint=<function>
.issubset=<function>
.issuperset=<function>
.pop=<function>
.remove=<function>
.symmetric_difference=<function>
.symmetric_difference_update=<function>
.union=<function>
.update=<function>
.Total: 18 item(s)
setattr=<function>
slice=<class 'slice'>
sorted=<function>
staticmethod=<class 'staticmethod'>
str=<class 'str'>
.count=<function>
.endswith=<function>
.find=<function>
.format=<function>
.index=<function>
.isalpha=<function>
.isdigit=<function>
.islower=<function>
.isspace=<function>
.isupper=<function>
.join=<function>
.lower=<function>
.lstrip=<function>
.replace=<function>
.rfind=<function>
.rindex=<function>
.rsplit=<function>
.rstrip=<function>
.split=<function>
.startswith=<function>
.strip=<function>
.upper=<function>
.Total: 22 item(s)
sum=<function>
super=<class 'super'>
tuple=<class 'tuple'>
.count=<function>
.index=<function>
.Total: 2 item(s)
type=<class 'type'>
zip=<class 'zip'>
Total: 190 item(s)
190
>>>


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

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

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


hex()
id()
input()

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

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

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

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

ValueError<0>

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

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

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


hex()
id()
input()

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

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

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

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

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

ValueError<0>

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

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

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

eval()
exec()

float<0>

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


hex()
id()
input()

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

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

range<0>
repr()

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

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

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

ValueError<0>

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

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


hex()
id()
input()

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

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

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


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

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

round()
set<18>
setattr()
slice<0>
sorted()
staticmethod<0>
str<22>
sum()
super<0>
tuple<2>
type<0>
zip<0>
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: Tout sélectionner
def explmod(pitm,pitmsl=[],reset=True):
  global curline
  if(reset):
    curline=0
    pitmsl=[sstr(pitm)]
  hd="."*(len(pitmsl)-1)
  spath=".".join(pitmsl)
  c=0
  for itms in sorted(dir(pitm)):
    c=c+1
    try:
      itm=eval(spath+"."+itms)
      print(hd+itms+"="+str(itm))
      if isExplorable(itm):
        pitmsl2=pitmsl.copy()
        pitmsl2.append(itms)
        c=c+explmod(itm,pitmsl2,False)
    except:
      print(hd+itms)
  if c>0:
    print(hd+"Total: "+str(c)+" item(s)")
  return c


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


Pour comparaison :
Image


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

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


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

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

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

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



11) Nombres flottants et précision :
Go to top

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

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

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

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


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


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

Pour comparaison :
Image


D'où le classement :
  1. +
    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: Tout sélectionner
    def sumr(n,a,b,d=1):
      s=0
      for k in range(a,b+d,d):
        s+=1/k**n
      return s


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

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

    Mais le pire est à venir, lorsque nous allons enchaîner des calculs différents...

  2. Passons au niveau Première avec les racines d'un polynôme du second degré :
    Code: Tout sélectionner
    from math import *

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


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

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


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

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

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

    Tu penses peut-être qu'il te suffira d'arrondir à l'unité pour ne pas avoir faux en recopiant les affichages de ton module externe
    TI-Python
    ? Et bien non, ne crois pas être à l'abri pour autant...

  3. Passons au niveau Terminale, avec un algorithme de seuil sur une suite convergente :
    Code: Tout sélectionner
    def seuil(d):
      n,u,l,d=0,2.,1,d**2
      while (u-l)**2>=d:
        u,n=1+(1/((1-u)*(n+1))),n+1
        print(n,u)
      return n


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


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


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

    Si tu crois avoir vu le pire avec un millier de différence, attends-toi à être surpris(e)...

  4. Restons sur les suites de Terminale, mais cette fois-ci en spécialité avec une suite récurrente d'ordre 2 :
    Code: Tout sélectionner
    from math import *

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

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


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


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

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


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

    Mais attends, tu n'as pas tout vu, on peut avoir pire qu'un résultat faux : pas de résultat du tout !...

  5. Terminons en redescendant au niveau Première, avec l'approche du nombre dérivé par la limite du taux de variation :
    Code: Tout sélectionner
    def f(x):
      return x*x*x

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

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

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


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


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

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

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

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

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

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

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

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

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



12) Exploration autres modules :
Go to top

Terminons maintenant avec l'exploration des modules
array
,
collections
,
gc
,
random
et
time
à l'aide du script suivant :
Code: Tout sélectionner
def explmod(pitm,pitmsl=[],reset=True):
  global curline
  if(reset):
    curline=0
    pitmsl=[sstr(pitm)]
  hd="."*(len(pitmsl)-1)
  spath=".".join(pitmsl)
  c=0
  for itms in sorted(dir(pitm)):
    c=c+1
    try:
      itm=eval(spath+"."+itms)
      print(hd+itms+"="+str(itm))
      if isExplorable(itm):
        pitmsl2=pitmsl.copy()
        pitmsl2.append(itms)
        c=c+explmod(itm,pitmsl2,False)
    except:
      print(hd+itms)
  if c>0:
    print(hd+"Total: "+str(c)+" item(s)")
  return c


Voici la sortie obtenue :
TI-Python a écrit:>>> # Shell Reinitialized
>>> import array
>>> explmod(array)
__name__=array
array=<class 'array'>
.append=<function>
.extend=<function>
.Total: 2 item(s)
Total: 4 item(s)
4
>>> import collections
>>> explmod(collections)
__name__=collections
namedtuple=<function>
Total: 2 item(s)
2
>>> import gc
>>> explmod(gc)
__name__=gc
collect=<function>
disable=<function>
enable=<function>
isenabled=<function>
mem_alloc=<function>
mem_free=<function>
Total: 7 item(s)
7
>>> import random
>>> explmod(random)
__name__=random
choice=<function>
getrandbits=<function>
randint=<function>
random=<function>
randrange=<function>
seed=<function>
uniform=<function>
Total: 8 item(s)
8
>>> import time
>>> explmod(time)
__name__=time
monotonic=<function>
sleep=<function>
struct_time=<class 'struct_time'>
Total: 4 item(s)
4


Comparaison bilan qui en découle :
Image


D'où le classement final sur les entrées offertes :
  1. 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: Tout sélectionner
def mem():
  try:
    l=[]
    try:
      l+=[0]
      l+=[""]
      l[1]+="x"
      while True:
        try:
          l[1]+=l[1][l[0]:]
        except:
          if l[0]<len(l[1])-1:
            l[0]=len(l[1])-1
          else:
            raise(Exception)
    except:
      print("+",len(l)>1 and len(l[1]))
      return 64+8*len(l)+(len(l) and 24+4*(l[0]>0)+(len(l)>1 and 49+len(l[1])))+mem()
  except:
    return 0


Voici la sortie obtenue :
TI-Python a écrit:>>> # Shell Reinitialized
>>> from mem import *
>>> mem()
+ 8196
+ 4096
+ 2176
+ 1428
+ 512
+ 408
+ 252
+ 80
+ 32
+ 4
+ 4
+ 4
17192
>>>


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

D'où le classement :
  1. 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: Tout sélectionner
try:
  from time import *
except:
  pass

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

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

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

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

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


La ligne d'appel test(9,2) se termine en
23,20s
sur le module externe
TI-Python
.

Une fois le script exécuté à l'identique sur les autres plateformes, voici le classement obtenu :
  1. 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 a écrit:UF2 Bootloader v1.23.0 SFHR
Model: Trinket M0
Board-ID: SAMD21E18A-Trinket-v0


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

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


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


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

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

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



16) Dumping et compatibilités :
Go to top

10213Pas de possibilité donc de récupérer le
firmware
via le mode mise à jour du
boot
, mais 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.

Et pour ceux qui trouvent que 10€ c'est encore trop cher, selon les tests de le
firmware
est également compatible avec les cartes
ST-Link STM32F103
dites
"blue pills"
, facilement trouvables pour moins de 5€ ! :bj:



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érieur à 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:
Lien vers le sujet sur le forum: Test module TI-Python (version 3.0.0.12) (Commentaires: 23)

Casio Découvre la puce ASIC fx-92 Collège 2D !

Nouveau messagede critor » 08 Fév 2019, 23:24

A la rentrée 2007,
Casio
révolutionnait le monde de la calculatrice scientifique pour le collège en sortant sa fantastique
fx-92 Collège 2D
. Issue de la gamme internationale
ES
avec comme entrée de gamme la
fx-82 ES
, ce modèle innovait en offrant la saisie des expressions en écriture naturelle et en intégrant un moteur de calcul exact ! :bj:

C'est ce modèle qui a modelé toutes les calculatrices sorties par la suite dont l'équivalent chez
Texas Instruments
, la
TI-Collège Plus
de la rentrée 2008.

Pour référence :
sortie
génération
entrée de gamme
internationale
modèles
franco-belges
innovations
rentrée
2007
ES
fx-82 ES
fx-92 Collège 2D
  • écran matriciel 96x32 pixels
  • saisie et résultats en écriture naturelle
  • moteur de calcul exact
rentrée
2009
ES Plus
fx-82 ES Plus
fx-92 Collège 2D+
fx-92B Collège 2D+
rentrée
2015
EX/Classwiz
fx-82 EX
fx-92 Spéciale Collège
fx-92B Spéciale Collège
  • écran matriciel 192x64 pixels
  • QR codes pour sauvegarde état machine et consultation manuel
rentrée
2018
EX/Classwiz
fx-82 EX
fx-92+ Spéciale Collège
  • tableur / feuille de calcul
  • langage de programmation orienté tracés à la Logo/Scratch


10246Dès 2010, t'avait déjà fait plein d'expériences avec sa
fx-92 Collège 2D
.

Il avait d'une part lancé l'écran de diagnostic secret de la machine de la façon suivante sur la
fx-92 Collège 2D
ainsi que sur ses successeures :
  • allumer la calculatrice en maintenant les touches
    Seconde/Shift
    et
    7
  • taper
    9
  • passer le test de l'écran en tapant plusieurs fois
    Seconde/Shift
Ce qui nous avait révélé l'usage dans le modèle français d'une version ROM
017
.

10247 était même allé jusqu'à ouvrir sa machine pour le plaisir de tes beaux yeux, nous révélant une carte mère de référence
PWB-GY380-1
.

Mais voilà, que ce soit sur les
Casio Graph
ou
fx-92 Collège
, nos explorations matérielles s'étaient toujours arrêtées là, le coeur chez
Casio
étant toujours dissimulé sur une goutte d'epoxy solidifiée dépourvue de références, et non retirable sans détruire la calculatrice.

10248Et bien aujourd'hui, pour ma 4000ème news sur
TI-Planet
je t'ai réservé de l'exceptionnel, quelque chose que l'on ne voit pas tous les jours...

Nous allons enfin pouvoir t'emmener bien plus loin dans le cœur de la
fx-92 Collège 2D
, car oui quelqu'un a osé aller plus loin en brisant le sceau d'epoxy, nous faisant paraître comme les modestes petits joueurs que nous sommes.

Tout comme quelqu'un d'autre l'avait déjà fait pour
TI-Nspire
, voici ci-contre grâce à
Epop
une photo au microscope de la face cachée de la puce
ASIC
de la
fx-92 Collège 2D
!

Si tu zoomes dans le coin supérieur droit, tu découvriras enfin le grand secret de la
fx-92 Collège 2D
, l'usage d'un coeur
ML610901
de chez le fondeur
OKI
(renommé
LAPIS Semiconductor
depuis 2011)
.

C'est-à-dire selon les spécifications :
  • un processeur 8 bits RISC
    nX-U8/100
    , ce qui est cohérent par rapport aux fichiers
    SimU8.dll
    et
    SimU8engine.dll
    venant avec l'émulateur de
    fx-82 ES
  • un contrôleur d'écran
    96x32
    segments, là encore cohérent avec l'écran 96x32 pixels
  • 96Kio
    de mémoire ROM
  • 3.5Kio
    octets de mémoire RAM

Et juste en-dessous, tu noteras l'inscription
Rom-017
, là encore cohérente avec l'écran de diagnostic.


Source
:
https://commons.wikimedia.org/wiki/File ... ircuit.jpg
Lien vers le sujet sur le forum: Découvre la puce ASIC fx-92 Collège 2D ! (Commentaires: 5)

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

Nouveau messagede critor » 06 Fév 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
Lien vers le sujet sur le forum: Geometry Dash : God Eater, adaptation du niveau démoniaque ! (Commentaires: 0)

NumWorks Firmware NumWorks 10.0.0 bêta; module turtle Python !

Nouveau messagede critor » 03 Fév 2019, 15:02

NumWorks
travaille actuellement sur la prochaine mise à jour
10.0.0
de sa calculatrice. Celle-ci est déjà disponible en version bêta, à condition de la compiler à partir du code source officiel.

Mais cette fois-ci, une version compilée de la
10.0.0 bêta
vient d'être diffusée par dans le contexte de son Python amélioré pour les jeux. Profitons-en donc pour découvrir les nouveautés à venir. ;)

10238D'une part, nous notons des améliorations apportées au moteur de calcul.

Il est désormais capable de renvoyer des résultats exacts lorsque l'on passe un argument complexe aux fonctions de module et d'argument ! :bj:

D'autre part, pour la rentrée 2019, selon le nouveau programme de
Physique-Chimie
de la
Seconde Générale et Technologique
, il faudra programmer des tracés en langage
Python
:
  • mouvement plan d'un objet ponctuel
  • nuage de points
  • vecteurs vitesse et variations

La
NumWorks
est certes le seul modèle à ce jour à disposer d'une implémentation
Python
constructeur
(et donc disponible en mode examen)
permettant de dessiner sur l'écran, à l'aide du module
kandinsky
.

Mais le dernier point évoqué, à savoir représenter des vecteurs, c'est-à-dire une direction, un sens et peut-être même la flèche qu'il y a au bout, n'en reste pas moins un problème trigonométrique bien conséquent, qui ne nous semble pas évident à faire résoudre à un niveau Seconde.
A moins bien sûr de distribuer des fonctions Python précodées par l'enseignant, ce qui n'aura alors pas grand intérêt...

10224Une fois de plus, le constructeur
NumWorks
nous prouve sa grande réactivité en n'attendant pas le dernier moment pour apporter une solution, l'inclusion dans son application
Python
du module
turtle
développé par en novembre 2018.

Tracer maintenant un vecteur en coordonnées relatives et non absolues, même avec la flèche au bout, n'a plus du tout la même complexité ! :bj:
C'est doublement une excellente solution à notre problème, puisque c'est également l'occasion de réinvestir les acquis de collège avec le codage de tracés en langage
Scratch
, mais dans le cadre maintenant d'un langage textuel conformément aux programmes du lycée. :bj:

Y sont disponibles des équivalents pour l'ensemble des fonctions
Scratch
du collège :
10237102361023510234
10233102321023110230


10229De quoi tracer facilement des vecteurs ou même encore plus complexe comme des fleurs ! ;)
Code: Tout sélectionner
from turtle import *
import kandinsky

def forbackward(d):
  forward(d)
  backward(d)
 
def pf(d=1,gd=-1,nervure=False):
  n=9
  pos=position()
  for j in range(2):
    for k in range(n):
      forward(d)
      right(gd*90/n)
    right(gd*90)
  if nervure:
    right(gd*40)
    forbackward(5*d)
    right(-gd*40)

def fleur(npetales=8,nfeuilles=2,ltige=160,kfeuille=1,c=kandinsky.color(255,255,0)):
  d=ltige/(nfeuilles+1)
  color(0,191,0)
  for j in range(nfeuilles):
    forward(d)
    pf(kfeuille,2*(j%2)-1,True)
  forward(d)
  color((c>>11)<<3,((c>>5)%64)<<2,(c%32)<<3)
  for j in range(npetales):
    pf(kfeuille,-1)
    left(360/npetales)

#example
from math import *

def hsv2color(h,s=1,v=1):
  c=v*s
  x=c*(1-abs((h%120)/60-1))
  m=v-c
  k=int(h/60)
  r=255*(m+x*(k==1 or k==4)+c*(k==5 or k==0))
  g=255*(m+c*(k==1 or k==2)+x*(k==3 or k==0))
  b=255*(m+x*(k==2 or k==5)+c*(k==3 or k==4))
  return kandinsky.color(round(r),round(g),round(b))

def horiz(y,col):
  for x in range(320):
    kandinsky.set_pixel(x,y,col)

for j in range(112):
  horiz(111-j,hsv2color(210,0+1*j/111,1))
  horiz(111+j,hsv2color(30,.1+.9*j/111,.7))

sw=320
sh=222
ymax=sh/2
ymin=ymax-sh+1
xmin=-sw/2
xmax=xmin+sw-1
penup()
goto(0,ymin)
setheading(90)
pendown()
fleur(12,9,ymax-ymin+1-26,3,kandinsky.color(255,255,0))

Creusons un petit peu la chose, et explorons ce que renferme ce module à l'aide du script suivant :
Code: Tout sélectionner
#platforms:
#0: MicroPython / TI-Nspire
#1: MicroPython / NumWorks
#2: MicroPython / G90+E
#3: MicroPython / G35+E/USB / G75/85/95
#4: CircuitPython / TI-Python / 83PCE
#5: Xcas / HP Prime
#6: KhiCAS / Graph 90+E
def getplatform():
  id=-1
  try:
    import sys
    try:
      if sys.platform=='nspire':id=0
      if sys.platform=='TI-Python Adapter':id=4
    except:id=3
  except:
    try:
      import kandinsky
      id=1
    except:
      try:
        if chr(256)==chr(0):id=5+(not ("HP" in version()))
      except:
        id=2
  return id
 
platform=getplatform()
#lines shown on screen
plines=[29,12,  7, 9,11,0,0]
#max chars per line
#(error or new line if exceeded)
pcols =[53,99,509,32,32,0,0]

nlines=plines[platform]
ncols=pcols[platform]
curline=0

def mprint(*ls):
  global curline
  st=""
  for s in ls:
    if not(isinstance(s,str)):
      s=str(s)
    st=st+s
  stlines=1+int(len(st)/ncols)
  if curline+stlines>=nlines:
    input("Input to continue:")
    curline=0
  print(st)
  curline+=stlines

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)
      mprint(hd+itms+"="+str(itm))
      if isExplorable(itm):
        pitmsl2=pitmsl.copy()
        pitmsl2.append(itms)
        c=c+explmod(itm,pitmsl2,False)
    except:
      mprint(hd+itms)
  if c>0:
    mprint(hd+"Total: "+str(c)+" item(s)")
  return c

10225102261022710228

38
éléments donc, soit de quoi chambouler notre classement de la richesse des implémentations de
pythonnettes
dès la sortie de cette mise à jour ! :bj:
NumWorks
Casio
Graph 90+E
module externe
TI-Python
pour
TI-83 Premium CE
builtins218188175204190
array444
collections2
cmath121212
gc777
math4141254128
random8888
sys151215
time34
turtle38
spécifique
10
(nsp)
5
(kandinsky)
4
(handshake)
Modules
7
7
3
7
9
Éléments
307
295
208
288
262


D'où le classement suivant :
  1. avec
    7
    modules et
    307
    entrées
  2. NumWorks
    avec
    7
    modules et
    295
    entrées
  3. avec
    7
    modules et
    288
    entrées
  4. module externe
    TI-Python
    pour
    TI-83 Premium CE
    avec
    9
    modules et
    262
    entrées
  5. Casio Graph 90+E
    avec
    3
    modules et
    208
    entrées

Attention le firmware
10.0.0
téléchargeable ci-dessous est donc en version bêta non finale. Des problèmes peuvent apparaître même en dehors des points évoqués; il t'est déconseillé de l'installer si tu as de prochains rendez-vous importants
(DS, examens, concours...)
. :#non#:

Téléchargement
:
firmware
10.0.0 bêta
(installable facilement via webdfu_numworks )
Lien vers le sujet sur le forum: Firmware NumWorks 10.0.0 bêta; module turtle Python ! (Commentaires: 2)

Campagne de dons
Pour nous aider à financer nos déplacements sur les salons/congrès qui vous donnent du contenu exclusif

Vous aurez droit aux avantages VIP et des goodies !
2%
-
Rechercher
-
Sujets à la une
"NumWorks++": Challenge de modification matérielle pour rajouter une puce de mémoire Flash !
Offre TI-Planet/Jarrety pour avoir la TI-83 Premium CE avec son chargeur pour 79,79€ port inclus !
Offre TI-Planet/Jarrety pour avoir la TI-Nspire CX CAS à seulement 130€ TTC port inclus!
Jailbreake ta TI-Nspire avec Ndless et profite des meilleurs jeux et applications !
Transforme ta TI-Nspire CX en console Game Boy Advance!
12345
-
Faire un don / Premium
Pour plus de concours, de lots, de tests, nous aider à payer le serveur et les domaines...

Découvrez les avantages d'un compte donateur !
JoinRejoignez the donors and/or premium!les donateurs et/ou premium !


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