[critor]

Quelle Calculatrice programmable Choisir 2020
(index des épisodes)

Episode 5 - Unités et conversions

Nous n'en avions pas refait depuis 2017, mais cette année il y a du nouveau. Traitons donc des possibilités de conversion d'unités de nos calculatrices.

Si jamais tu avais opté pour un modèle dépourvu d'un convertisseur d'unités, tu pouvais jusqu'à présent télécharger gratuitement des programmes rajoutant cette fonctionnalité.
Hélas, c'est désormais impossible à cause du mode examen à diode qui sera mis en place pour la première fois de façon nationale à l'occasion des épreuves d'examen 2020-2021, un mode qui désactive tout ce que tu auras rajouté.

Il est donc important pour toi cette année de choisir d'origine un modèle pourvu de cette fonctionnalité, ce que nous allons t'indiquer pour l'ensemble des modèles conformes ou se disant conformes 2021.
De plus il existe certains modèles où le mode examen désactive certaines fonctionnalités officielles, dont le convertisseur d'unités pourtant préchargé à l'achat de la calculatrice, un véritable piège que nous allons par la même occasion désamorcer.

Déjà, commençons par dénoncer les modèles dépourvus à l'achat d'un convertisseur d'unités, et sans aucune solution à ce jour :

• l'Esquisse GCEXFR, à fuir comme la peste
• la Lexibook GC3000FR, entre la peste et le choléra...
• la Casio Graph 25+E
• la Casio Graph 25+E II
• la TI-82 Advanced, qui visiblement n'est pas aussi avancée que ça...
• et la Casio fx-CP400+E, si si, bizarrement le seul modèle haut de gamme à en être incapable alors que le milieu de gamme du même constructeur le fait très bien

A noter qu'il n'existe bien à ce jour aucune solution pour TI-82 Advanced, officielle ou non.
Certes, il existe une application TI-83/84 Plus officielle SciTools incluant un convertisseur d'unités...
Certes, il est possible d'installer sur TI-82 Advanced des applications TI-83/84 Plus et d'y conserver l'accès en mode examen...
Mais les applications installées via cette méthode doivent faire moins de 16 Kio et SciTools est hélas beaucoup trop gros.

Sur les TI-83 Premium CE et TI-83 Premium CE Edition Python, les conversions d'unités sont apportées par l'application SciTools (outils scientifiques), venant préchargée dans les calculatrices neuves.
Si jamais cette application a été effacée, il suffit juste de la retélécharger et réinstaller gratuitement.

11 catégories clairement nommées en français te donnent accès à 106 unités différentes, dont :

• 61 unités simples
• 25 unités munies d'un préfixe SI
• 20 unités composées

Ce convertisseur a toutefois le gros défaut de ne pas être intégré à l'écran de calculs. Il dispose d'une simple ligne de saisie spécifique n'autorisant même pas l'écriture naturelle, tu auras l'impression d'un véritable retour en arrière et l'inconfort d'une saisie ne réagissant pas comme les autres.
De plus impossible également d'appliquer la conversion d'unité à un calcul, il te faudra donc recopier le résultat à convertir à la main en passant par une feuille de brouillon, la calculatrice ne comportant pas de fonctionnalité de copier-coller.

Précisons également que tu es limité(e) aux seules unités listées et pas une de plus. Impossible d'utiliser une unité munie d'un préfixe SI autre que ceux avec lesquels elle est listée au menu ; rien que ci-contre tu remarqueras donc l'absence des hectomètre (hm), décamètre (dam) et décimètre (dm).

Toutefois 13 préfixes SI sont listés dans une catégorie à part, une astuce permettant de transposer tes conversions d'unités simples lorsque les bons préfixes ne lui sont pas associés.

Le menu de bas d'écran "EXPT" (exporter) permettra de récupérer la valeur à l'écran de calculs.

Bref un convertisseur d'unités très limité, tout juste digne d'un programme amateur.

Attention au piège, particulièrement pour les candidats dans les lycées français à l'étranger.

D'autres modèles Texas Instruments incluent également l'application SciTools, mais le mode examen une fois activé en interdira l'accès :

• TI-84 Plus T
• TI-84 Plus CE-T
• TI-84 Plus CE-T Python Edition

Sur les calculatrices Casio Graph 35+E, Casio Graph 35+E II et Casio Graph 75+E, on accède au menu de conversion via le menu de bas d'écran CONV disponible sous

OPTN

.

Ici, le convertisseur a le gros avantage d'être intégré à l'écran de calculs, c'est-à-dire que tu bénéficies de tous les avantages de ce dernier :

• saisie en écriture naturelle
• conversion directement sur un calcul en cours de saisie
• récupération facile d'un résultat précédent pour conversion sans besoin de passer par une feuille de brouillon
• ...

Par contre le listage certes intuitif des 11 catégories en menu de bas d'écran utilise des abréviations, et l'on peut regretter qu'elles ne soient pas traduites, restant en anglais contrairement au reste du système ce qui n'arrange pas la chose.

Y sont disponibles également 106 unités, mais réparties de la façon suivante :

• 67 unités simples
• 16 unités munies d'un préfixe SI
• 23 unités composées

Les possibilités sont les mêmes que pour la solution précédente, tu ne peux convertir que les unités listées, impossible de préfixer ou combiner pour obtenir une unité non présente au menu.

Par contre, tous ces modèles disposent d'un mode d'affichage dit ingénieur (ENG) permettant de convertir vers les préfixes SI.

Attention au piège, sur la Graph 90+E la conversion d'unités est liée à l'application additionnelle officielle préchargée Conv.

Et comme toute application additionnelle, elle est désactivée en mode examen.

Les TI-Nspire CX CAS en version 4.5.0 ou supérieure ainsi que les TI-Nspire CX II CAS offrent 152 unités accessibles à travers pas moins de 26 catégories différentes via :

• 86 unités simples
• 37 unités munies d'un préfixe SI
• 29 unités composées

Notons à chaque fois une légende en français décrivant clairement l'unité en question.

Mais cela va beaucoup plus loin que ça. En effet les unités font partie intégrante du calcul et peuvent être combinées à l'infini via de simples opérations et même stockées avec les valeurs dans les variables. De quoi comprendre véritablement la logique des unités et franchir naturellement le pas des formules et équations aux dimensions en Physique-Chimie !

Remarquons de plus ici la bonne intégration avec le moteur de calcul formel, permettant même de découvrir le calcul justifiant le résultat !

On apprécie de plus ici les transformations automatiques d'unités composées et unités préfixées lorsque la calculatrice pense avoir trouvé une forme plus pertinente.

Par contre toujours pas possible ici de préfixer des unités comme on veut, d'autant plus regrettable que nombre d'unités préfixées usuelles manquent ici encore au menu.

L'intégration est tellement poussée qu'il est possible de faire appel à des unités dans des matrices, vecteurs, listes ou même programmes !

Petit regret toutefois, unités et constantes physiques utilisent à la saisie le même préfixe. Quelle idée alors que cela n'a strictement rien à voir... Plusieurs unités n'adoptent en conséquence pas la bonne notation car sinon elles s'écriraient comme la constante de même nom :

• le gramme qui se saisit _gm et non _g réservé à l'accélération de la pesanteur terrestre
• l'heure qui se saisit _hr et non _h réservé à la constante de Planck

C'est peu, certes, mais ça touche des unités suffisamment communes pour avoir de graves conséquences.

Globalement une solution haut de gamme extrêmement poussé, tu en as pour ton argent !

La TI-Nspire CAS TouchPad offre les mêmes fonctionnalités à partir d'un éventail plus restreint de 120 unités au menu :

• 85 unités simples
• 32 unités munies d'un préfixe SI
• 3 unités composées

Sur les simples TI-Nspire TouchPad et TI-Nspire monochromes, pas de convertisseur d'unités.

Toutefois tu peux obtenir ces dernières capacités en leur installant le système TI-Nspire CAS.

Les TI-Nspire CX en version 4.5.0, TI-Nspire CX II-T et TI-Nspire CX II offrent quant à elles 116 unités à travers 11 catégories :

• 68 unités simples
• 19 unités munies d'un préfixe SI
• 29 unités composées

Ici par contre, pas de possibilité de combiner des unités. Si c'est pas au menu, c'est foutu...

Pour les seules TI-Nspire CX (pas TI-Nspire CX II), de façon similaire aux TI-Nspire monochromes il est en théorie possible de leur installer le système TI-Nspire CX CAS pour bénéficier de l'intégralité des fonctionnalités relatives aux unités.
Il suffit pour cela d'installer nBoot + ControlX si compatible, ou à défaut nLoader.

Toutefois en pratique l'ajout de ces outils nécessite de commencer par installer Ndless. Or la plupart des TI-Nspire CX que tu trouveras seront préchargées avec une version 4.5.1 ou supérieure que Ndless ne gère toujours pas.

Cette transformation qui n'est plus réalisable que par une minorité ne sera donc pas comptabilisée.

Sur HP Prime, on accède au menu des unités via

Shift

Units

, avec 178 unités sous 18 catégories.

• 125 unités simples
• 9 unités munies d'un préfixe SI
• 44 unités composées

Pour la description de chaque unité, il suffit de taper

Help

.

Une solution très similaire à la précédente, les unités font partie intégrante du calcul ce qui ouvre des possibilités bien plus larges que ce que laisse apparaître le menu, dont la fabrication d'unités composées non listées.

Pour les unités composées présentes au menu notons leur affichage en écriture naturelle, un avantage exclusif jusqu'à présent !

Mais aussi tu peux ici librement préfixer toutes tes unités à l'aide de 20 préfixes SI génériques !

Ici toutefois, on ne bénéficie pas du moteur de calcul formel.

Aucune transformation automatique non plus, même face à des combinaisons peu pertinentes.

L'utilisation d'unités dans des listes ou programmes est parfaitement possible.

Le stockage d'unités dans des variables ainsi que l'utilisation dans du calcul matriciel ou vectoriel également, mais attention uniquement dans le contexte CAS.

Ici encore une excellente solution !

Grande nouveauté de cette rentrée 2021, la NumWorks gère les unités, fonctionnalité introduite avec la version 13.1.

21 catégories nous présentent donc :

• 33 unités simples
• 42 unités munies d'un préfixe SI

Cela peut paraître peu a priori face aux solutions précédentes, mais c'est sans compter qu'ici encore les unités font partie intégrante du calcul pour de formidables possibilités, dont la composition libre d'unités à l'infini !

Les menus ne présentent certes pas chaque unité avec tous les préfixes SI possibles.
Toutefois il sera ici encore possible de préfixer librement des unités à la saisie, de pico pour 10^-12 à Tera pour 10¹².
Petit avertissement par contre, contrairement à la solution précédente ici cela ne fonctionne bizarrement pas avec toutes les unités. Admettons, mais le problème est surtout qu'il n'y a aucun moyen de le savoir à l'avance, un défaut d'intuitivité...

Ici hélas, pas de possibilité d'utiliser les unités dans du calcul de listes, vectoriel ou matriciel.

Impossible également de les utiliser dans les programmes, un gros défaut de cette machine étant que sa seule application de programmation disponible, l'appli Python, tourne totalement en vase clos sans aucune interaction en entrée ou sortie avec le reste des variables ou fonctionnalités du système.

Par contre, la solution NumWorks bénéficie de plusieurs avantages à ce jour exclusifs :

• utilisation automatique du préfixe SI le plus pertinent pour les résultats avec unités selon leur valeur
• ou même changement automatique pour une unité plus pertinente selon la valeur

Et ce n'est pas tout, la NumWorks est aussi la seule solution où tu n'auras la plupart du temps pas besoin de demander une conversion d'unités.

En effet, gros avantage d'interface, il te suffira tout simplement de sélectionner ton résultat avec unités dans l'historique de calcul pour obtenir automatiquement d'une simple touche sa conversion dans une ou plusieurs autres unités pertinentes selon la calculatrice !

Ici encore donc une solution haut de gamme dont l'utilisation permet de véritablement comprendre ce qu'est une unité, mais à la différence des précédentes au prix du milieu de gamme !

A noter que l'installation du firmware tiers Omega permet de bénéficier d'un jeu d'unités un peu plus élargi, et ce même en mode examen :

• 43 unités simples
• 42 unités munies d'un préfixe SI

Résumé des données, avec :

• en bas les fonctionnalités officielles présentes à l'achat et persistant en mode examen
• en haut l'ensemble des possibilités avec améliorations et/ou hors mode examen

[critor]

Quelle Calculatrice programmable Choisir 2020
(index des épisodes)

Episode 6 - Constantes physiques

Cette année il y a du nouveau au niveau des bibliothèques de constantes physiques ; voyons donc ce qu'offrent les calculatrices graphiques conformes ou se disant conformes 2021.

Si jamais tu avais opté pour un modèle dépourvu d'une telle bibliothèque, tu pouvais jusqu'à présent télécharger gratuitement des programmes en rajoutant.
Hélas, c'est désormais impossible à cause du mode examen à diode qui sera mis en place pour la première fois de façon nationale à l'occasion des épreuves d'examen 2020-2021, un mode qui désactive tout ce que tu auras rajouté.

Il ne faut donc pas te tromper dans ton achat cette année, particulièrement si tu envisages une coloration sciences expérimentales de ton orientation.

Déjà, commençons par dénoncer les modèles dépourvus à l'achat d'une bibliothèque de constantes physiques, et sans aucune solution à ce jour :

• l'Esquisse GCEXFR
• la Lexibook GC3000FR
• la Casio Graph 25+E
• la Casio Graph 25+E II

Sur les TI-83 Premium CE et TI-83 Premium CE Edition Python, la bibliothèque de constantes physiques est apportée par l'application SciTools (outils scientifiques), venant préchargée dans les calculatrices neuves.
Si jamais cette application a été effacée, il suffit juste de la retélécharger et réinstaller gratuitement.

15 constantes physiques y sont disponibles, avec pour chacune : description, symbole et unité !
Les symboles toutefois ne sont pas toujours standard.

Le menu de bas d'écran

EXPT

permettra d'exporter la valeur numérique intégrale vers la ligne de saisie de l'écran de calculs.
Les constantes ont ainsi le défaut de ne pas pouvoir être appelées automatiquement depuis un calcul ou un programme.

On peut ainsi déplorer l'impossibilité pour un programme de récupérer automatiquement une valeur de constante.

Bref il n'y a donc ici pas beaucoup de constantes ; mais la quantité ne fait pas tout.
Pour cette rentrée 2020, l'application bénéficie d'une mise à jour 5.5 avec des corrections de valeurs de certaines constantes.

Tentons donc d'évaluer la précision de cette bibliothèque. Nous allons nous baser pour cela sur les valeurs de 8 constantes communes à toutes les solutions que nous allons te présenter :

• e : charge élémentaire
• G : constante de gravitation universelle
• h : constante de Planck
• k : constante de Boltzmann
• m_e : masse de l'électron
• m_p : masse du proton
• N_A : nombre d'Avogadro
• R : constante universelle des gaz parfaits

Nous prendrons comme référence les valeurs officielles du CODATA (Comité de données pour la science et la technologie), dont la dernière mise à jour date de 2018 : CODATA 2018.

Voici un petit script Python auquel il suffira de fournir les chiffres significatifs des constantes de la calculatrice pour obtenir les écarts relatifs de chacune ainsi que l'écart relatif moyen :

Code: Select all

from math import log

def mean(l):
  return sum(l)/len(l)

def error_r(name, val):
  data = (
    ['c',  299792458, 0],
    ['e',  1602176634, -19],
    ['G',  667430, -11],
    ['g',  980665, 0],
    ['h',  662607015, -34],
    ['k',  1380649, -23],
    ['me', 91093837015, -31],
    ['mn', 167492749804, -27],
    ['mp', 167262192369, -27],
    ['NA', 602214076, 23],
    ['R',  8314462618, 0],
    ['u',  166053906660, -27],
  )
  for vref in data:
    if vref[0] == name:
      break
  if vref[0] == name:
    while int(log(val, 10)) < int(log(vref[1] , 10)):
      val *= 10
    while int(log(val, 10)) > int(log(vref[1] , 10)):
      vref[1] *= 10
    return abs(val - vref[1]) / vref[1]

def error_m(l):
  lerr = []
  for v in l:
    err = error_r(v[0], v[1])
    lerr.append(err)
    print(v[0], err)
  return mean(lerr)

Recopions donc les valeurs fournies par la calculatrice dans notre appel, avec l'ancienne puis la nouvelle version :

Code: Select all

error_m([
  ['e',  1602176565],
  ['G',  667384],
  ['h',  662606957],
  ['k',  13806488],
  ['me', 910938291],
  ['mp', 1672621777],
  ['NA', 602214129],
  ['R',  83144621],
])

Code: Select all

error_m([
  ['e',  1602176634],
  ['G',  66743],
  ['h',  662607015],
  ['k',  1380649],
  ['me', 91093837015],
  ['mp', 167262192369],
  ['NA', 602214076],
  ['R',  8314462618],
])

C'est extraordinaire, quel formidable travail de veille scientifique chez Texas Instruments.
L'écart relatif moyen passe de 0,000869% avec la version précédente de l'application à 0% cette année ; c'est-à-dire que toutes les constantes testées sont exactes !

Plus précisément la mise à jour nous fait passer des valeurs CODATA 2010 aux valeurs CODATA 2018.
Texas Instruments avait donc pris pas mal de retard mais s'est finalement bien rattrapé.

Candidats scolarisés hors de France, attention.

La TI-84 Plus CE-T distribuée dans le reste des pays européens interdira l'accès à l'application SciTools une fois passée en mode examen !

Même problème pour la TI-84 Plus T monochrome.

Accessoirement ce modèle n'a jamais bénéficié de la moindre mise à jour depuis sa sortie pour la rentrée 2016. Les valeurs utilisées sont donc plus anciennes, avec ici un écart relatif moyen de 0,00247% :

Code: Select all

error_m([
  ['e',  1602176462],
  ['G',  6673],
  ['h',  662606876],
  ['k',  13806503],
  ['me', 910938188],
  ['mp', 167262158],
  ['NA', 602214199],
  ['R',  8314472],
])

Il s'agit en fait de valeurs beaucoup plus anciennes correspondant à la base de données CODATA 1998.
C'est-à-dire que Texas Instruments semble n'avoir jamais mis à jour les données de l'application SciTools pour TI-82/83/84+ depuis le lancement de cette gamme avec la TI-83 Plus en 1999, et avoir utilisé la même application pour la TI-84 Plus T en 2016 sans aucun rafraîchissement du contenu.

La TI-82 Advanced monochrome ne dispose hélas pas de l'application SciTools.
Il est certes possible d'installer des applications TI-82/83/84 Plus et même d'y conserver l'accès en mode examen...
Mais les applications installées via cette méthode doivent faire moins de 16 Kio et SciTools est hélas beaucoup trop gros.

Par contre, on peut installer l'application Omnicalc qui inclut une petite bibliothèque de 13 constantes, et aura le gros avantage de rester disponible en mode examen.

Ici on récupère les valeurs de constantes en résultat, et elles ont ainsi le gros avantage de pouvoir être directement appelées depuis un programme.
Par contre pas d'unités ni de description, et les symboles se permettent diverses fantaisies.

Cette application a été mise à jour pour la dernière fois en 2004, donc les valeurs seront ici bien plus obsolètes.
Notons que comme les valeurs étant récupérées en résultat, tous leurs chiffres significatifs ne sont pas forcément affichés.
Voici un petit programme TI-Basic afin d'extraire tous les chiffres significatifs du dernier résultat :

Code: Select all

abs(Rep→X
" →Chn1
"0123456789→Chn0
While partDéc(X
  10X→X
End
While X≥10
  X/10→X
End
While X
  ent(X→I
  10partDéc(X→X
  Chn1+sousch(Chn0,I+1,1→Chn1
End
Chn1

Mais en fait non, les constantes sont tellement peu précises ici qu'il n'y a pas de chiffre significatif masqué.

Ici l'erreur relative moyenne est ainsi de 0,00396% :

Code: Select all

print(error_m([
  ['e',  160217733],
  ['G',  667259],
  ['h',  66260755],
  ['k',  1380658],
  ['me', 91093897],
  ['mp', 16726231],
  ['NA', 60221367],
  ['R',  831451],
]))

En fait, c'est encore pire que ce que l'on pensait, les valeurs correspondent à la banque CODATA 1986...

La Casio Graph 90+E dispose d'une application officielle préchargée Physium qui apporte une bibliothèque de constantes.

Attention, cette application sera inaccessible en mode examen.

Pas moins de 39 constantes sont ici disponibles avec leurs symboles et, sur demande, descriptions et unités.

Un gros avantage par contre ici, est que l'on peut modifier les constantes pour s'adapter par exemple à la valeur fournie par un énoncé, et les réinitialiser automatiquement pas la suite.

Pas de possibilité d'appel automatique depuis un programme, par contre l'interface permet de stocker directement la valeur sélectionnée dans une variable de la calculatrice.

Voici de quoi extraire l'ensemble des chiffres significatifs des variables en question :

Code: Select all

?→X
Abs X→X
""→Str 1
"0123456789"→Str 10
While Frac X
  10X→X
WhileEnd
While X≥10
  X÷10→X
End
While X
  Int X→I
  10Frac X→X
  StrJoin(Str 1,StrMid(Str 10,I+1,1))→Str 1
WhileEnd
Locate 1,1,Str 1

Une fois l'ensemble des chiffres significatifs récupérés, nous trouvons ici 0,000422% d'erreur relative moyenne :

Code: Select all

error_m([
  ['e',  16021766208],
  ['G',  667408],
  ['h',  662607004],
  ['k',  138064852],
  ['me', 910938356],
  ['mp', 1672621898],
  ['NA', 6022140857],
  ['R',  83144598],
])

Il s'agit ici des valeurs CODATA 2014.

Physium est tout autant disponible pour Casio fx-CP400+E, avec les mêmes valeurs CODATA et quasiment les mêmes capacités.

Seule et unique chose que nous ne trouvons pas ici, la possibilité de modifier les constantes.

Ici encore, plus rien en mode examen.

Physium est également disponible pour les Casio Graph 35+E II et Graph 75+E monochrome avec exactement les mêmes capacités.

Toujours aussi interdite en mode examen.

L'application passe cette année à la nouvelle version 1.13, première mise à jour concernant la Graph 75+E depuis 2014 !

Le changement est que les constantes basculent sur les nouvelles valeurs qu'utilisaient déjà les versions couleur pour Graph 90+E et fx-CP400+E depuis des années, passant l'erreur relative moyenne de 0,000869% à 0,000422% :

Code: Select all

error_m([
  ['e',  1602176565],
  ['G',  667384],
  ['h',  662606957],
  ['k',  13806488],
  ['me', 910938291],
  ['mp', 1672621777],
  ['NA', 602214129],
  ['R',  83144621],
])

Code: Select all

error_m([
  ['e',  16021766208],
  ['G',  667408],
  ['h',  662607004],
  ['k',  138064852],
  ['me', 910938356],
  ['mp', 1672621898],
  ['NA', 6022140857],
  ['R',  83144598],
])

Nous passons donc ici des valeurs CODATA 2010 aux valeurs CODATA 2014.

Pour les anciennes Casio Graph 35+E il est possible de leur installer le système Graph 75+E pour ensuite leur rajouter l'application Physium.

Toutefois elle restera tout autant inaccessible en mode examen.

Les TI-Nspire CX II CAS, ainsi que les TI-Nspire CX CAS si mise à jour en version 4.5 ou supérieure t'offriront 24 constantes, toutes accompagnées de leurs descriptions et unités.
Leur nommage par contre n'est pas toujours très heureux par rapport à leur symbole, les constantes ayant le défaut d'utiliser le même préfixe que les unités.

Voici de quoi extraire l'ensemble des chiffres significatifs :

Code: Select all

Define fullnbr(x)=
Func
  Local s,i
  s:=""
  x:=abs(x)
  While fPart(x)≠0
    x:=10*x
  EndWhile
  While x≥10
    x:=((x)/(10))
  EndWhile
  While x≠0
    i:=int(x)
    x:=10*fPart(x)
    s:=s&mid(string(i),1,1)
  EndWhile
  Return s
EndFunc

Nous avons ici affaire aux données CODATA 2014.

Les données de nos constantes une fois extraites en intégralité nous donnent une erreur relative moyenne de 0,000422% :

Code: Select all

error_m([
  ['e',  16021766208],
  ['G',  667408],
  ['h',  662607004],
  ['k',  138064852],
  ['me', 910938356],
  ['mp', 1672621898],
  ['NA', 6022140857],
  ['R',  83144598],
])

Les simples TI-Nspire CX II-T, TI-Nspire CX II et TI-Nspire CX si mise à jour en version 4.5 ou supérieure offriront la même bibliothèque de constantes, mais sans les unités.

La TI-Nspire CAS TouchPad quant à elle reprend l'intégralité des fonctionnalités, mais avec le jeu de données beaucoup plus ancien du CODATA 2010, pour une erreur relative moyenne de 0,000869% :

Code: Select all

error_m([
  ['e',  1602176565],
  ['G',  667384],
  ['h',  662606957],
  ['k',  13806488],
  ['me', 910938291],
  ['mp', 1672621777],
  ['NA', 602214129],
  ['R',  83144621],
])

Sur les simples TI-Nspire TouchPad et TI-Nspire, pas de bibliothèque de constantes physiques.

Tu peux toutefois leur rajouter une bibliothèque de constantes complète en installant le logiciel KhiCAS, permettant d'obtenir en prime les unités.

Pour les simples TI-Nspire CX il est en théorie également possible de leur installer un logiciel KhiCAS même un peu plus étendu.
Toutefois en pratique l'ajout de ces outils nécessite de commencer par installer Ndless. Or la plupart des TI-Nspire CX que tu trouveras seront préchargées avec une version 4.5.1 ou supérieure que Ndless ne gère toujours pas.

KhiCAS t'offre ici une bibliothèque de 27 constantes.

Les valeurs semblent toutefois être très anciennes, remontant au CODATA 1986 pour presque toutes celles que nous avons choisi de tester ici. Seule exception parmi notre sélection, la constante G qui correspond bizarrement au CODATA 2014.

Ce qui nous donne donc ici une erreur relative moyenne intermédiaire de 0,000606%.

Code: Select all

error_m([
  ['e',  160217733],
  ['G',  667408],
  ['h',  66260755],
  ['k',  1380658],
  ['me', 91093897],
  ['mp', 16726231],
  ['NA', 60221367],
  ['R',  831451],
])

Hélas tout ceci sera indisponible en mode examen.

Tu peux toutefois obtenir la bibliothèque officielle et ce même en mode examen sur tes TI-Nspire TouchPad et TI-Nspire, en installant directement le système TI-Nspire CAS

Pour les simples TI-Nspire CX, de façon similaire il est en théorie possible de leur installer le système TI-Nspire CX CAS et donc d'accompagner les constantes d'unités.
Il suffit pour cela d'installer nBoot + ControlX si compatible, ou à défaut nLoader.
Toutefois en pratique l'ajout de ces outils nécessite ici encore de commencer par installer Ndless. Or comme la plupart des TI-Nspire CX que tu trouveras seront préchargées avec une version 4.5.1 ou supérieure...

Sur NumWorks au commencement il n'y a rien. Toutefois tu peux installer très facilement le firmware tiers Omega. Omega reprend le firmware officiel tout en y faisant quelques ajouts, dont justement une bibliothèque de constantes physiques.

Nous excluons ici les constantes relatives aux atomes que nous compterons à part avec les applis de classification périodique des éléments, ce qui nous donne quand même un nombre formidable de 82 constantes ici, toutes avec description et unités.

Ici les valeurs sont copiées directement sur la ligne de saisie, ce qui interdit hélas tout accès automatique depuis un programme.

Quelques bizarreries également, les valeurs effectivement saisies ne correspondent pas toujours à celles des menus. Par exemple, la constante R des gaz parfaits perd son 4 final...

Les valeurs ne sont pas uniformes ici, semblant provenir de plusieurs sources et pas directement des banques CODATA officielles. Par exemple :

• les constantes de Planck (h), de Boltzmann (k) et nombre d'Avogadro (N_A) proviennent du CODATA 2018
• la constante de gravitation universelle (G) et la charge élémentaire (e) semblent être des troncatures des valeurs du CODATA 2014
• la masse de l'électron (m_e) semble être une troncature de la valeur du CODATA 2018
• la masse du proton (m_p) semble être un arrondi de la valeur du CODATA 1973
• la constante des gaz parfaits (R) semblerait correspondre à la valeur du CODATA 2018, mais bizarrement avec des chiffres en plus cette fois-ci...

Tout ceci se ressent bien évidemment dans notre mesure de la pertinence des valeurs, avec ici 0,000765% d'erreur relative moyenne :

Code: Select all

error_m([
  ['e',  160217662],
  ['G',  6674],
  ['h',  662607015],
  ['k',  1380649],
  ['me', 9109383],
  ['mp', 1672649],
  ['NA', 602214076],
  ['R',  83144626181532],
])

Précisons qu'Omega te permet à son tour d'installer l'application KhiCAS, avec les mêmes 27 constantes et capacités que pour l'édition TI-Nspire.

Mais grosse différence ici, KhiCAS restera disponible en mode examen !

Enfin terminons avec la HP Prime. On y accède aux constantes via le menu Const affiché par

Shift

Units

.
Décocher

Valeur

permet d'obtenir les unités, et quant à la description on la récupère avec la touche

Help

.
En excluant les constantes mathématiques, nous obtenons ici un total de 21 constantes physiques !

Il s'agit des valeurs du CODATA 2014, avec donc 0,000422% d'erreur relative moyenne :

Code: Select all

error_m([
  ['e',  16021766208],
  ['G',  667408],
  ['h',  662607004],
  ['k',  138064852],
  ['me', 910938356],
  ['mp', 1672621898],
  ['NA', 6022140857],
  ['R',  83144598],
])

Précisons de plus que si tu bascules ta calculatrice en mode calcul formel avec la touche

CAS

, tu auras accès aux 27 constantes de KhiCAS déjà couvertes plus haut dans le contexte des TI-Nspire et NumWorks. Avec ici le gros avantage de pouvoir les appeler automatiquement depuis un programme.

Résumé des données, avec :

• en bas les fonctionnalités officielles présentes à l'achat et persistant en mode examen
• en haut l'ensemble des possibilités avec améliorations et/ou hors mode examen

[critor]

Quelle Calculatrice programmable Choisir 2020
(index des épisodes)

Episode 7 - Définitions écrans et zones graphiques

Plus tôt cette année nous avons donc traité des tailles des écrans des calculatrices graphiques affichant une conformité pour les examens 2021, l'un des éléments matériels les plus importants. Mais la taille ne fait pas tout, reste à voir la définition en pixels ainsi que nombre d'autres caractéristiques que nous allons méticuleusement tester en Python comme jamais auparavant. Prépare-toi à découvrir nombre de secrets...

Nous allons donc te donner ici entre autres les caractéristiques et définitions des écrans.

Mais la définition elle non plus ne fait pas tout, car il faut également voir quelle est la zone graphique par rapport à ça, c'est-à-dire la zone dans laquelle l'utilisateur peut librement allumer des pixels.
L'accès en écriture à cette zone graphique se fait notamment via le grapheur de fonctions, ainsi que via des scripts ou programmes.
Sur nombre de modèles dont le système a été développé avant l'ère du Python, le langage de programmation historique utilise la même zone graphique que le grapheur de fonctions. Par contre, l'application Python sortie depuis pour nombre de ces modèles ne reprend pas toujours exactement la même zone graphique...

Nous effectuerons donc jusqu'à 2 tests par modèle :

• un test de la zone graphique en utilisant soit le grapheur de fonctions soit un programme en langage historique
• un test de la zone graphique en Python

Commençons dès maintenant à construire et expliquer devant toi notre protocole de test Python, avec un script universel tournant sur tous les modèles supportant officiellement ou officieusement ce langage. Nous adapterons si besoin dans d'autres langages pour les modèles ne comprenant pas encore le langage Python.

Les fonctions de lecture/écriture des pixels différant hélas d'un constructeur à un autre, il nous faut déjà de quoi permettre au script de détecter la plateforme sur laquelle il tourne :

Code: Select all

def get_pf():
  c256 = True
  try:
    if chr(256)==chr(0):
      if "HP" in version():
        return 12
      else:
        if not white:
          return 11
        elif "Numworks" in version():
          return 9
        elif "Nspire" in version():
          return 7
        else:
          return 10
  except:
    c256 = False
  try:
    import sys
    try:
      if sys.platform == "nspire":
        try:
          import graphic
          return 6
        except:
          return 5
      elif sys.platform == "numworks":
        return 8
      elif sys.platform.startswith('TI-Python'):
        return 2
    except:
      return 4
  except:
    pass
  if not c256:
    return 1
  try:
    import kandinsky
    return 0
  except:
    try:
      import hpprime
      return 3
    except:
      pass
  return -1

Cette pièce d'horlogerie te retournera d'un simple get_pf() un identifiant couvrant tout l'éventail des solutions Python disponibles à ce jour pour calculatrices, et à interpréter de la façon suivante :

• -1: inconnue (ordinateur ?...)
• 0: NumWorks
• 1: Casio Graph 90+E ou Graph 35+E II
• 2: TI-83 Premium CE ou TI-84 Plus CE
• 3: HP Prime (version alpha)
• 4: Casio Graph 35+E/USB ou Graph 75/85/95 avec CasioPython
• 5: TI-Nspire + MicroPython (nécessite Ndless)
• 6: TI-Nspire + KhiCAS en mode MicroPython (nécessite Ndless)
• 7: TI-Nspire + KhiCAS en mode de compatibilité Python (nécessite Ndless)
• 8: NumWorks + KhiCAS en mode MicroPython (nécessite Omega)
• 9: NumWorks + KhiCAS en mode de compatibilité Python (nécessite Omega)
• 10: Casio Graph 90+E + KhiCAS en mode de compatibilité Python
• 11: Casio Graph 35+E II + KhiCAS en mode de compatibilité Python
• 12: HP Prime en mode CAS

Maintenant que nous connaissons donc la plateforme, reste à récupérer les fonctions d'accès aux pixels :

Code: Select all

gp_prime = lambda x, y: GETPIX_P(x, y)
sp_prime = lambda x, y, c: PIXON_P(x, y, c)

def get_pixel_functions(pf):
  gp, sp = lambda: None, lambda: None
  if pf == 0:
    import kandinsky
    gp, sp = kandinsky.get_pixel, kandinsky.set_pixel
  elif pf == 1:
    import casioplot
    gp, sp = casioplot.get_pixel, casioplot.set_pixel
  elif pf == 2:
    import ti_graphics
    gp, sp = ti_graphics.getPixel, ti_graphics.setPixel
  elif pf == 3:
    import hpprime
    sp = hpprime.pixon
  elif pf == 5:
    from nsp import Texture
    canvas = Texture(320, 240, 0)
    gp, sp = canvas.getPx, canvas.setPx
  elif pf == 6 or pf == 8:
    import graphic
    gp, sp = graphic.get_pixel, graphic.set_pixel
  elif pf == 12:
    gp, sp = gp_prime, sp_prime
  return gp, sp

Voilà, d'un simple gp, sp = get_pixel_functions(get_pf()) nous obtenons les fonctions de lecture et écriture des pixels, sur tous les modèles où elles existent !

Comment donc faire maintenant pour tester la taille de la zone graphique, rien qu'en lisant / écrivant des pixels ?
Et bien c'est très simple, tu ne vas pas être dépaysé(e).
Nous allons procéder comme avec une tortue (langage Scratch ou module Python turtle).
Nous allons parcourir l'écran, en diagonale, en tentant de lire et modifier chaque pixel rencontré.

Pour savoir si un pixel est accessible en écriture, nous tenterons d'inverser sa couleur :

Code: Select all

def invert_color(c):
  try:
    ci = [0, 0, 0]
    for k in range(3):
      ci[k] = 255 - c[k]
  except:
    ci = ~(c&0xffffff) & 0xffffff
  return ci

def is_pixel_writable(x, y, bad_pixel):
  if is_pixel_readable(x, y, bad_pixel):
    c0 = gp(x, y)
    sp(x, y, invert_color(c0))
    c = gp(x, y)
    return c != c0

Pour savoir si un pixel que l'on arrive à lire correspond bien à un pixel visible de l'écran, nous prendrons comme référence la mauvaise valeur de pixel retournée par une lecture clairement hors écran, coordonnées (-2, -2).
Dans le seul cas où l'on rencontre cette valeur qui peut très bien être justifiée, nous tenterons ici encore de l'inverser.

Code: Select all

def is_pixel_readable(x, y, bad_pixel):
  c = None
  try:
    c = gp(x, y)
  except:
    pass
  if c != None:
    if c == bad_pixel:
      sp(x, y, invert_color(c))
      c = gp(x, y)
  return c != bad_pixel

Voici donc les fonctions principales utilisant tout ça :

Code: Select all

def scr_test(x0, y0, dx0, dy0, test):
  bad_pixel = None
  try:
    bad_pixel = gp(-2, -2)
  except:
    pass
  x, y, dx, dy = x0, y0, dx0, dy0
  while not test(x, y, bad_pixel):
    x += dx
    y += dy
  if test(x, y - dy, bad_pixel): y = y0
  elif test(x - dx, y, bad_pixel): x = x0
  x0, y0 = x, y
  x += dx
  y += dy
  while(dx or dy):
    if not test(x - ((dx == 0) and dx0),y - ((dy == 0) and dy0), bad_pixel):
      if test(x - ((dx == 0) and dx0), y - ((dy == 0) and dy0) - dy0, bad_pixel): dy = 0
      elif test(x - ((dx == 0) and dx0) - dx0, y - ((dy == 0) and dy0), bad_pixel): dx = 0
      else: dx, dy = 0, 0
    x += dx
    y += dy
  return x0, y0, (x - x0) // dx0, (y - y0) // dy0

def scr_size():
  xrd0, yrd0, xrd, yrd = scr_test(0, 0, -1, -1, is_pixel_readable)
  xra0, yra0, xra, yra = scr_test(1, 1, 1, 1, is_pixel_readable)
  xr0, yr0 = xrd0 - xrd + 1, yrd0 - yrd + 1
  xr, yr = xra + xrd, yra + yrd
  xw0, yw0, xw, yw = scr_test(xr0, yr0, 1, 1, is_pixel_writable)
  print("at (" + str(xr0) + "," + str(yr0) + "): " + str(xr) + "x" + str(yr) + " readable pixels")
  print("at (" + str(xw0) + "," + str(yw0) + "): " + str(xw) + "x" + str(yw) + " writable pixels")
  return xr0, yr0, xr, yr, xw0, yw0, xw, yw

Il suffit donc d'appeler scr_size(), et tu vas vite comprendre avec notre premier exemple.

Prenons donc pour commencer les TI-83 Premium CE et TI-84 Plus CE, disposant d'un écran couleur 320×240= 76800 pixels.

On peut obtenir la taille de la zone graphique accessible au grapheur ainsi qu'aux programmes grâce à un tout petit calcul effectué par le programme ci-dessous à partir des bornes de la fenêtre graphique :

Code: Select all

(Xmax-Xmin)/ΔX+1→W
(Ymax-Ymin)/ΔY+1→H
{W,H

Nous bénéficions donc pour nos graphiques et programmes d'une zone de 265×165= 43725 pixels, une zone extrêmement décevante ne permettant d'exploiter que 56,93% de la définition de l'écran.
Ce n'est pas pour rien que les plus grands créateurs de jeux programmaient en langage machine dit assembleur...

Passons maintenant dans l'application Python, qui n'offre les fonctions de pixels que sur TI-83 Premium CE Edition Python et TI-84 Plus CE-T Python Edition. Texas Instruments y a enfin corrigé ce gros défaut. Après donc parcours de l'écran en diagonale par notre tortue virtuelle, cette dernière nous reporte :

• 321×241= 77361 pixels pouvant être lus à partir des coordonnées (-1, -1)
• 321×210= 67410 pixels pouvant être écrits à partir des coordonnées (-1, 30)

Si le fonctionnement est simple, plusieurs bizarreries dans le résultat sont toutefois à traiter ici.

Déjà sur les deux zones différentes qui nous sont retournées :

• la première signifie que l'on peut lire l'intégralité des pixels de l'écran
• la deuxième ne retient donc plus que les pixels pouvant être modifiés, ici situés en-dessous de la barre d'état de 30 pixels de hauteur, et c'est celle-ci qui correspond à la zone graphique, la seule zone où la tortue a réussi à tracer son chemin comme tu vois ci-contre

Ensuite, selon notre tortue nous aurions donc un écran de 321×241 pixels, soit plus que les 320×240 pixels précédemment annoncés, avec :

• une ligne de pixels d'ordonnée -1 pouvant être lus
• une colonne de pixels d'abscisse -1 pouvant être lus, et également écrits à partir de l'ordonnée 30 marque le début de la zone graphique précédente

Or une tentative d'écriture donc sur cette dernière colonne ne donne visiblement rien à l'écran.

Soit il y a un bug dans notre code expliquant ce résultat différent de la réalité, et tu verras bien ci-dessous si la même anomalie est présente sur d'autres modèles ou pas avec exactement le même code.

Soit la chose vient de Texas Instruments. Nous aurions donc un écran de 320×240 pixels, mais avec en mémoire un buffer associé de 321×241 pixels. Ou bien c'est un bug, ou bien il y a une raison technique que nous ignorons à ce jour pour disposer en mémoire d'1 ligne et d'1 colonne supplémentaires de pixels sans aucune existence physique.

Pour notre classement, nous retiendrons donc ici une zone graphique correspondant à la réalité, c'est-à-dire de 320×210= 67200 pixels, soit 87,50% de la définition de l'écran, c'est déjà bien mieux qu'avec le langage historique !

Passons aux TI-82 Advanced et TI-84 Plus T, qui t'offrent un écran monochrome de 96×64= 6144 pixels, un écran utilisant de plus des cristaux liquides noirs fort bien contrastés.

Voici le même programme pour calculer la taille de la zone graphique accessible au grapheur ainsi qu'aux programmes :

Code: Select all

(Xmax-Xmin)/PasX+1→W
(Ymax-Ymin)/PasY+1→H
{W,H

Nous contrôlons donc 95×63= 5985 pixels, soit 97,41% de l'écran.

Voici maintenant venir la Casio Graph 90+E, avec son superbe écran couleur de 396×224= 88704 pixels.

Pour la zone graphique historique, petit problème de détection, nous n'avons pas de variable nous donnant le pas vertical (écart entre 2 pixels sur l'axe des ordonnées). Toutefois il nous suffit de choisir la fenêtre graphique par défaut qui a l'avantage de donner un repère orthonormal, et ensuite il suffit donc de calculer avec le pas horizontal :

Code: Select all

(Xmax-Xmin)÷Xdot+1→W
(Ymax-Ymin)÷Xdot+1→H
{W,H

Via les graphes et les programmes, nous avons donc accès à une zone de 379×187= 70873 soit 79,90% des pixels de l'écran.

Mais voyons maintenant ce que cela donne dans l'application Python.

Et c'est extraordinaire, Casio ici aussi a fait un effort, ce sont pas moins de 384×192= 73728 pixels qui sont contrôlables en Python, soit 83,12% de l'écran !

Notons que tu as également la possibilité d'installer l'application KhiCAS, une adaptation pour ta calculatrice du logiciel de mathématiques intégré Xcas par Bernard Parisse, enseignant-chercheur à l'Université de Grenoble.

L'environnement est également programmable avec une syntaxe proche du Python. Pas de fonctions pour contrôler individuellement les pixels ici, mais par contre nous y disposons d'une tortue dont on peut spécifier les déplacements en pixels. Tentons de tracer un rectangle le plus grand possible à l'aide du code suivant :

Code: Select all

def scrtest(w, h):
  efface
  leve_crayon
  tourne_gauche 180
  avance w // 3
  tourne_gauche 90
  avance h // 2
  baisse_crayon
  for k in range(2):
    tourne_gauche 90
    avance w
    tourne_gauche 90
    avance h

C'est l'appel scrtest(383, 191) qui nous permet de rentrer le plus grand rectangle possible dans l'écran. Comme les paramètres concernent ici des déplacements de la tortue cela correspond à une zone graphique de 384×192= 73728, soit exactement comme avec l'application Python officielle.

Casio Graph 25+E II, ancienne Graph 25+E, Graph 35+E II, ancienne Graph 35+E et Graph 75+E utilisent des écrans de 128×64= 8192 pixels.

Casio Graph 25+E II, Graph 35+E II et Graph 35+E partagent le même écran aux cristaux liquides noirs agréablement contrastés.

Comme vu en épisode 1, le superbe écran de la Graph 75+E a l'avantage d'être sensiblement plus grand.
Il bénéficie en prime d'un éclairage optionnel.

L'ancienne Graph 25+E à la différence bénéficie d'un écran nettement plus petit.
Précisons surtout que l'écran utilise des cristaux liquides bleus qui donnent un assez mauvais contraste, nuisant beaucoup à la lisibilité.

En appliquant le même programme de test que sur Graph 90+E, nous obtenons une zone graphique historique utilisable de 127×63= 8001 pixels soit 97,67%.

Passons maintenant à l'application Python, ce qui ne concerne que la Graph 35+E II.

Ici c'est fantastique, nous contrôlons apparemment 100% de l'écran, soit 128×64= 8192 pixels.

La Graph 35+E II te permet en prime d'installer l'application KhiCAS, adaptation dédiée du logiciel de mathématiques intégré Xcas par Bernard Parisse, un environnement programmable avec une syntaxe proche du Python.

Très similaire à celle pour Graph 90+E on peut donc tester ce qu'elle offre de la même façon. C'est l'appel scrtest(127, 63) qui nous permet d'inscrire le plus grand rectangle dans l'écran, ce qui correspond donc ici encore à 128×64= 8192 pixels.

La Casio fx-92+ Spéciale Collège intègre un contrôleur écran gérant 192×64= 12288 pixels.
En réalité son écran est hybride, avec :

• une zone matricielle de 192×63= 12096 pixels
• 20 drapeaux indicatifs en haut d'écran, assimilables à des pixels mais aux formes non élémentaires

Nous sommes finalement sur un fantastique écran monochrome de 192×63+20= 12116 pixels.

La calculatrice est programmable dans un langage orienté tracé, avec des déplacements spécifiés en pixels. Nous pouvons donc ici encore tenter de dessiner un rectangle le plus grand possible.

Code: Select all

?→A
?→B
Stylo relevé
Tourner de ↺ 180 degrés
Avancer de Ent(A÷2pixels
Tourner de ↺ 90 degrés
Avancer de Ent(B÷2pixels
Stylo écrit
Répéter 2
  Tourner de ↺ 90 degrés
  Avancer de A pixels
  Tourner de ↺ 90 degrés
  Avancer de B pixels
⤴

C'est en saisissant 191 et 46 que l'on arrive à tracer le plus grand rectangle, ce qui correspond donc à une zone graphique contrôlable de 192×47= 9024 pixels, soit 74,48%.

Les TI-Nspire, qu'elles soient à écran couleur ou monochrome, nous offrent toutes 320×240= 76800 pixels.

Pour déterminer la zone graphique utile, on peut utiliser un script Lua dimensionné en pleine page :

Code: Select all

function on.paint(gc)
  w = platform.window
  s = tostring(w.width()) .. "x" .. tostring(w.height())
  gc:drawString(s, 0, 0)

Les scripts Lua contrôlent donc jusqu'à 318×212= 67416 pixels soit 87,78%.

A compter de la version système 5.0 avec les TI-Nspire CX II, le langage de programmation orienté fonctions historique s'enrichit de commandes graphiques dessinant dans une zone cette fois-ci non redimensionnable, mais qui fait elle aussi 318×212= 67416 pixels.

Nous ne disposons toujours pas de préversion de la future mise à jour TI-Nspire CX II avec Python, mais nous supposons que ce sera à nouveau la même zone graphique : 318×212= 67416 pixels.

Sur les TI-Nspire monochromes, ainsi que les anciennes TI-Nspire CX si non encore mises à jour en version 4.5.1 ou supérieure, il est possible d'y installer Ndless puis ensuite MicroPython.
On y contrôle alors 100% de l'écran, soit 320×240= 76800 pixels.

Sur les anciennes TI-Nspire CX, Ndless permet également l'installation d'une version de KhiCAS intégrant une version étendue de ce même interpréteur Python.
Notre script universel de test détecte ici un peu moins, 320×222= 71040 pixels pouvant à la fois être lus et écrits.

La NumWorks t'apporte un écran de 320×240= 76800 pixels.

Pour les graphes nous n'avons pas trouvé de moyen automatique de mesurer la fenêtre graphique. Alors tant pis comptons les pixels à la main, ci-contre 320×156= 49920 pixels.

L'application Python quant à elle te permet de contrôler 320×222= 71040 pixels.

Si tu installes le firmware tiers Omega, tu peux ensuite installer une application KhiCAS intégrant son propre interpréteur MicroPython. Mais pas de changement, ici encore c'est 320×222= 71040 pixels.

La HP Prime t'offre un écran de 320×240= 76800 pixels.

Le mode CAS y disposant d'une compatibilité syntaxique Python, il est possible d'y exécuter directement notre script de test.

La compatibilité est très loin d'être automatique, il y a nombre de contraintes à respecter dans l'écriture, mais notre script a été conçu dès le départ en en tenant compte. Si tu y vois des blocs pas très optimisés, c'est pour ça.

320×240= 76800 pixels sont donc à disposition pour tes programmes, soit 100% !

Pas possible de tester de la même façon l'application Python de la version alpha publiée par erreur en octobre 2019. En effet son module prime y transcrit bien la fonction graphique historique pixon() pour écrire des pixels, mais pas encore la fonction getpix() pour les lire.

Toutefois jusqu'à présent tous les constructeurs ont proposé dans leur Python officiel une zone graphique identique ou plus étendue que celle de leurs graphiques et programmes en langage historique, c'est probablement ici encore 320×240= 76800, ce que l'on confirme en allumant quelques pixels aux frontières de l'écran.

La Casio fx-CP400+E inclut niveau définition de loin le meilleur écran tous modèles confondus, 320×528= 168960 pixels.

Niveau zone graphique utile maintenant, c'est compliqué.

En orientation portrait nous avons par défaut 309×185= 57165 pixels.

Si tu te donnes la peine de redimensionner la fenêtre graphique en pleine page, ce seront 309×401= 123909 pixels.

Tu peux également utiliser ta calculatrice en orientation paysage. Mais pas d'accéléromètre ici et donc rien d'automatique, c'est un bouton tactile physique à côté de l'écran qui est à utiliser à chaque fois que tu éprouves le besoin de changer l'orientation, un peu comme sur la console portable Lynx d'Atari.

Par défaut tu disposes dans ce sens d'une zone graphique de 517×81= 41877 pixels, une zone que nous trouvons bien trop écrasée et donc peu adaptée à étudier autre chose que des fonctions trigonométriques.

Si tu redimensionnes en pleine page, tu peux étendre la chose à 517×193= 99781 pixels :

Bref, que retenir de tout ça pour confrontation à la concurrence ?

Déjà on peut préciser qu'il est impossible d'exécuter des programmes en orientation paysage, donc autant prendre l'orientation portrait commune.
Optons donc pour les 309×401= 123909 pixels, soit 73,33%.

Enfin, si Maman revient des courses de rentrée avec une Esquisse GCEXFR ou Lexibook GC3000FR, tu auras sans doute à t'interroger sur le sens caché de ce message d'une extrême violence.

Le packaging est mensonger, te présentant via un sticker un écran à cristaux liquides noirs, qui se transforme une fois allumé en cristaux liquides bleus fort mal contrastés et ainsi désagréables à lire, et contrairement à tous les modèles précédents aucune fonctionnalité n'a été prévue pour en régler le contraste !

L'écran n'est pas matriciel mais hybride. Tellement dur à lire que pour mieux t'en détailler l'intégralité des capacités nous t'avons fait un petit montage ci-contre.
Nous avons donc :

• une zone matricielle dédiée aux graphiques de 47×32= 1504 pixels en bas à gauche soit un timbre poste, littéralement...
• une zone matricielle complémentaire de pixels 40×8= 320 pixels en bas à droite, qui par juxtaposition permet la saisie de tes calculs et l'affichage de leurs résultats sur 87 pixels de largeur
• 2 afficheurs numériques à 7 segments dédiés à l'affichage des exposants de 10 pour les résultats en notation scientifique
• 19 autres drapeaux de formes diverses

Il s'agit donc d'un écran assimilable à du 47×32+40×8+2×7+19= 1857 pixels.

Que contrôle-t-on dans tout ça ? Déjà pas grand chose car la machine n'est pas programmable malgré la présence trompeuse d'une touche

PROG

au clavier, une inadéquation manifeste aux programmes scolaires, et encore ce n'est même pas le pire de ses défauts de ce point de vue...

Bref pour tester la zone graphique (in)utile, il ne nous reste plus que les graphiques. Par défaut nous avons donc un repère orthonormal, avec un pas de 0.2 entre deux pixels horizontaux ou verticaux.
Récupérons les bornes de la fenêtre, une par une car la technologie archaïque qu'il semble y avoir sous le capot est incapable d'afficher simultanément plusieurs nombres à l'écran :

Allons-y pour les calculs :

• $mathjax$\frac{\left(4.6-\left(-4.6\right)\right)}{0.2}+1=\frac{\left(4.6+4.6\right)}{0.2}+1\\
  \phantom{\frac{\left(4.6-\left(-4.6\right)\right)}{0.2}+1}=\frac{9.2}{0.2}+1\\
  \phantom{\frac{\left(4.6-\left(-4.6\right)\right)}{0.2}+1}=46+1\\
  \phantom{\frac{\left(4.6-\left(-4.6\right)\right)}{0.2}+1}=47$mathjax$
• $mathjax$\frac{\left(3-\left(-3\right)\right)}{0.2}+1=\frac{\left(3+3\right)}{0.2}+1\\
  \phantom{\frac{\left(3-\left(-3\right)\right)}{0.2}+1}=\frac{6}{0.2}+1\\
  \phantom{\frac{\left(3-\left(-3\right)\right)}{0.2}+1}=30+1\\
  \phantom{\frac{\left(3-\left(-3\right)\right)}{0.2}+1}=31$mathjax$

Zone graphique utilisable donc de 47×31= 1457 pixels.
Oui, la zone matricielle correspondant sur l'écran faisant 32 pixels de hauteur, il y a donc physiquement et bêtement une ligne de 47 pixels qui ne s'allument jamais...

Ce qui nous permet en passant de dénoncer un autre mensonge de l'emballage et du manuel, si tu comptes bien la sinusoïde donnée en exemple y est en effet tracée sur une zone graphique 48×32= 1536 pixels, soit une surestimation de plus de 5%... Forcément avec ça, la sinusoïde réellement obtenue est loin d'être aussi belle que celle de l'emballage...

Comment peut-on avoir un packaging aussi mensonger, aussi trompeur, sans le faire exprès ?... Ce ne sont plus des astuces marketing là, c'est de l'arnaque pure et simple, les marques concernées regorgent visiblement de grands talents dans ce domaine... des pratiques irrespectueuses du consommateur et dans tous les cas indignes de notre pays, un crime contre la jeunesse, contre l'éducation et donc contre l'avenir, et par conséquent contre l'humanité !

Résumé donc des capacités des différents écrans, avec :

• en bas les capacités officielles de la machine en mode examen
• en haut les possibilités hors mode examen

Crédits images : bande dessinée

[critor]

Quelle Calculatrice programmable Choisir 2020
(index des épisodes)

Episode 8 - Classification périodique des éléments

Outre pour répondre aux questions de cours de Seconde, la classification périodique des éléments est un formidable outil de référence salvateur dans nombre de situations une fois que l'on a compris la périodicité des propriétés chimiques. Un doute sur la formule du fluorure de béryllium ? Sur la charge de l'ion phosphore ? Un simple coup d’œil à la classification, une simple addition/soustraction selon la règle de l'octet, et ton problème sera résolu !

Nombre de calculatrices graphiques t'offrent une application de classification périodique des éléments chimiques, et nous avons quelques nouveautés à te présenter cette année.
Attention toutefois, l'application en question ne reste pas toujours disponible en mode examen, ça dépend du modèle, et nous te le préciserons à chaque fois.

Nous ignorons certes encore l'esprit de l'épreuve de Physique-Chimie du BAC 2021 faute de sujet zéro disponible, mais rappelons que l'épreuve en question avait nettement changé d'orientation à partir de 2013.
Jusqu'en 2012 il y avait pas mal de Mathématiques appliquées essentiellement de niveau Première ; il s'agissait d'évaluer des raisonnements calculatoires conséquents (dérivation, primitives, coordonnées, vecteurs...) et où le sujet fournissait donc l'ensemble des données nécessaires afin que tous les candidats puissent entamer la démarche.
Depuis 2013 le lien entre ces deux disciplines scientifiques a été coupé dans les programmes ; il s'agit de plus en plus d'études de documents laissant le candidat prendre des initiatives, notamment lors de questions de synthèses de documents.
Si l'on reste sur ce genre d'épreuve, faire appel de façon pertinente à des connaissances non fournies dans le sujet comme celles issues de la classification périodique des éléments pourra être fortement valorisé.

Déjà, commençons par énoncer les modèles dépourvus d'une telle application, et sans aucune solution à ce jour :

• l'Esquisse GCEXFR
• la Lexibook GC3000FR
• la Casio Graph 25+E
• la Casio Graph 25+E II

La TI-83 Premium CE dispose d'une application Periodic préchargée et restant accessible en mode examen, offrant une superbe classification périodique des éléments en couleurs avec les 118 éléments chimiques découverts à ce jour, chacun accompagné de 16 propriétés.

Il est possible de rechercher un élément par numéro, nom ou symbole.

Si jamais cette application a été effacée, il suffit juste de la retélécharger et réinstaller gratuitement.

Les différentes propriétés numériques de l'ensemble des éléments chimiques peuvent être exportées vers des listes qui pourront ensuite être affichées sous forme de diagrammes, ou traitées par des programmes ou scripts Python.

L'application t'offre de plus en option une vue étendue intégrant de façon logique les lanthanides et actinides (bloc f) au tableau.

La dernière mise à jour 5.5 disponible pour cette rentrée rafraîchit ou complète les données des derniers éléments chimiques découverts avec entre autres leurs noms finaux, beau travail de veille scientifique du constructeur.

Candidats scolarisés hors de France, attention.

La TI-84 Plus CE-T distribuée dans le reste des pays européens interdira l'accès à l'application Periodic une fois passée en mode examen !

Plutôt que d'acheter dans tes magasins locaux, tu auras donc grand intérêt à acheter le modèle français en ligne ou via une commande groupée de ton enseignant ou établissement.

La TI-82 Advanced offre une édition monochrome de cette même application restant disponible en mode examen. Cette application est ici intégrée et non effaçable.

Mais attention ce modèle n'a jamais bénéficié de la moindre mise à jour depuis sa sortie pour la rentrée 2015, et intègre en fait à l'identique l'application Periodic des TI-82+/83+/84+ mise à jour pour la dernière fois pour la rentrée 1999... En conséquence l'application n'est ici pas du tout à jour, ne connaissant que 109 éléments chimiques.

Candidats scolarisés hors de France, attention.

La TI-84 Plus T reprend cette même application monochrome, mais ici à nouveau t'y interdira l'accès une fois passée en mode examen.

L'application est ici effaçable. Pour la remettre si besoin, il te faudra réinstaller le système d'exploitation au complet.

La formidable Casio Graph 90+E vient préchargée avec l'extraordinaire application Physium, exploitant avec pertinence et talent son écran couleur. Les 118 éléments chimiques sont même ici joliment illustrés.

Il est possible de rechercher un élément non seulement par numéro, nom ou symbole, mais également par masse molaire.

Il est même possible de modifier les masses molaires des éléments chimiques et de les réinitialiser, que ce soit pour mettre à jour les valeurs ou pour utiliser temporairement la valeur fournie dans un énoncé.

En cas d'effacement l'application peut-être retéléchargée et réinstallée totalement gratuitement.

Les données des différents éléments sont ici encore exportables, soit de façon individuelle vers une variable à partir de l'élément, soit de façon globale vers une feuille de calcul pouvant être ouverte avec l'application Tableur intégrée et dont tu feras ensuite tout ce que tu voudras.

Hélas, l'accès à cette superbe application te sera interdit en mode examen.

Sur Casio fx-CP400+E nous retrouvons une application Physium très similaire à celle de la Graph 90+E, mais adaptée au grand écran de la machine.

Par contre ici, pas d'exportation globale des données.

De plus les données ne sont pas tout-à-fait à jour, plusieurs des derniers éléments chimiques utilisant encore leur dénomination systématique temporaire.
Et pas de possibilité ici de modifier les valeurs.

Sur les Casio Graph 35+E II et Graph 75+E, nous avons une édition monochrome de l'application Physium, très similaire à celle de la Graph 90+E mais sans les illustrations à la différence. La dernière mise à jour 1.13 en rafraîchit de plus les données, avec les noms définitifs des derniers éléments.

Ici aucune possibilité d'exporter les données ni même de rechercher un élément.

L'ancienne Graph 35+E peut également en bénéficier après avoir été reprogrammée avec le système Graph 75+E, mais cela ne changera rien pour le mode examen.

Sur NumWorks il est possible d'installer le firmware tiers Omega, qui intègre directement une application Atome qui restera même disponible en mode examen.

Pas besoin d'exporter ici, les masses molaires sont directement disponibles dans la boîte à outils accessible depuis toute application, listables au choix par numéro atomique ou par nom de l'élément.

Sur les TI-Nspire il est possible d'installer le classeur MultiPeriodic.

De grandes qualités graphiques ainsi que sur le nombre de propriétés disponibles.

Toutefois, on peut regretter ici l'absence de possibilité de rechercher un élément, ou encore d'exporter les données.

Et bien évidemment, ce classeur sera inaccessible en mode examen.

Sur HP Prime il est possible d'installer l'application Eléments.

Ici encore de grandes qualités graphiques mais on regrettera l'absence apparente de travail sur l'intégration à l'écosystème de la calculatrice ainsi que dans la démarche de résolution d'un problème : aucun moyen prévu pour rechercher un élément ou exporter les données.

Et ici encore, tristement, plus rien de tout ça en mode examen.

Résumé des données, avec :

• en bas les fonctionnalités officielles présentes à l'achat et persistant en mode examen
• en haut l'ensemble des possibilités hors mode examen et/ou en installant les éléments mentionnés précédemment

[critor]

Quelle Calculatrice programmable Choisir 2020
(index des épisodes)

Episode 9 - Ecrans et profondeurs

L'écran est décidément un élément incontournable de ta calculatrice graphique. Après avoir couvert dans des épisodes précédents ses dimensions, définition et zone graphique, nous allons aujourd'hui traiter de sa profondeur, c'est-à-dire du nombre de couleurs différentes qu'il peut afficher.

Commençons par enfoncer les portes ouvertes, avec les modèles dont le contrôleur écran ne gère que 1 bit de profondeur, ne permettant donc que 2¹= 2 couleurs différentes.

D'une part, voici les modèles à cristaux liquides bleus, affichant donc en bleu et blanc :

• Esquisse GCEXFR
• Lexibook GC3000FR
• Casio Graph 25+E

Et voici les modèles à cristaux liquides noirs, affichant en noir et blanc :

• Casio Graph 25+E II
• Casio Graph 35+E
• Casio Graph 35+E II
• Casio Graph 75+E
• TI-82 Advanced
• TI-84 Plus T
• Casio fx-92+ Spéciale Collège

Passons maintenant aux choses sérieuses ; nous allons te présenter notre protocole de test.

Notre idée est donc d'afficher une mire avec des dégradés des composantes primaires rouge-vert-bleu, afin de déterminer le nombre de bits utilisés par chacune.

Histoire d'avoir un script de test aussi universel que possible, commençons par ressortir nos fonctions Python magiques que nous t'avons déjà présentées :

• get_pf() pour récupérer un code identifiant la plateforme détectée
• get_pixel_functions(pf) pour récupérer les fonctions de lecture/écriture des pixels correspondant à la plateforme en question

Code: Select all

# detects calculator Python platform
def get_pf():
  c256 = True
  try:
    if chr(256)==chr(0):
      # Xcas/KhiCAS Python compatibility
      if "HP" in version():
        return 13 # HP Prime
      else:
        if not white:
          return 12 # Graph 35+E II
        elif "Numworks" in version():
          return 10 # NumWorks
        elif "Nspire" in version():
          return 8 # Nspire
        else: # Graph 90+E
          return 11
  except:
    c256 = False
  try:
    import sys
    try:
      if sys.platform == "nspire":
        try: # Nspire Ndless
          import graphic
          return 7 # KhiCAS Micropython
        except: # MicroPython
          return 6
      elif sys.platform == "TI-Nspire":
        return 3 # Nspire CX II
      elif sys.platform == "numworks":
        return 9 # NumWorks KhiCAS Micropython
      elif sys.platform.startswith('TI-Python'):
        return 2 # 83P/84+ CE
    except: # Graph 35+E/USB / 75/85/95
      return 5
  except:
    pass
  if not c256:
    return 1 # Graph 90/35+E II
  try:
    import kandinsky
    return 0 # NumWorks
  except:
    try: # HP Prime
      import hpprime
      return 4
    except:
      pass
  return -1

#return get_pixel and set_pixel functions for the platform
gp_prime = lambda x, y: GETPIX_P(x, y)
sp_prime = lambda x, y, c: PIXON_P(x, y, c)
def get_pixel_functions(pf):
  gp, sp = lambda: None, lambda: None
  if pf == 0: # NumWorks
    import kandinsky
    gp, sp = kandinsky.get_pixel, kandinsky.set_pixel
  elif pf == 1: # Graph 90/35+E II
    import casioplot
    gp, sp = casioplot.get_pixel, casioplot.set_pixel
  elif pf == 2: # 83P/84+ CE
    import ti_graphics
    gp, sp = ti_graphics.getPixel, ti_graphics.setPixel
  elif pf == 3: # Nspire CX II
    pass
  elif pf == 4: # HP Prime
    import hpprime
    sp = hpprime.pixon
  elif pf == 6: # Nspire: Ndless MicroPython
    from nsp import Texture
    canvas = Texture(320, 240, 0)
    gp, sp = canvas.getPx, canvas.setPx
  elif pf == 7 or pf == 9: # Nspire/NumWorks: KhiCAS-MicroPython
    import graphic
    gp, sp = graphic.get_pixel, graphic.set_pixel
  elif pf == 13: # HP Prime
    gp, sp = gp_prime, sp_prime
  return gp, sp

Voici de quoi récupérer tout ça :

Code: Select all

gp, sp = get_pixel_functions(pf)
sw, sh, sy0 = scr_infos(pf)

Maintenant que nous connaissons les positions et tailles des zones graphiques contrôlables par les scripts Python, faisons une fonction permettant de les récupérer rapidement cette fois-ci sans avoir à tester l'écran :

Code: Select all

#returns platform screen infos : width, height, color_mode/bits
def scr_infos(pf):
  #                                              uPy       uPy
  #                G352                CPy  uPy  KhiCAS--------------------->  CAS
  #           NW   G90  CE   CX2  HP   GXX  NS   NS   NS   NW   NW   G90  G352 HP
  l_vlines = (222, 192, 210, 212, 240, 064, 240, 222, 222, 222, 222, 192, 064, 240)
  l_vcols  = (320, 384, 320, 318, 320, 128, 320, 320, 320, 320, 320, 384, 128, 320)
  l_y0     = (000, 000, 030, 000, 000, 000, 000, 000, 000, 000, 000, 000, 000, 000)
  l_modes  = (000, 000, 000, 016, 032, 000, 016, 000, 016, 000, 016, 016, 001, 032)
  return l_vcols[pf], l_vlines[pf], l_y0[pf], l_modes[pf]

Il y a 2 façons de coder les couleurs dans le contexte des pixels en Python :

• soit avec un tuple (r,g,b) décrivant les valeurs de chaque composante primaire rouge-vert-bleu par un entier de 0 à 255
• soit par un nombre entier qui sera directement la valeur fournie au contrôleur écran

Prévoyons une fonction pour tester le codage utilisé, par simple vérification du type de retour d'une lecture de pixel.
Dans le cas d'un retour de type entier, tentons de plus en passant de détecter le nombre de bits gérés par le contrôleur écran, en écrivant des valeurs de pixels de plus en plus grandes et vérifiant à chaque fois si le pixel concerné a bien pris la valeur en question.

Code: Select all

#0: (R,G,B) >0: RGB-bits
def get_color_mode():
  c = gp(0, 0)
  try:
    c[2]
    return 0
  except:
    b, v = 0, 1
    x, y = 0, sy0
    sp(x, y, v)
    while gp(x, y) == v:
      b += 1
      v *= 2
      sp(x, y, v)
    return b

Un appel color_mode = get_color_mode() pourra donc renvoyer par exemple :

• 0 : pour un codage des couleurs par des tuples (r,g,b)
• 15 : pour un codage des couleurs sur des entiers de 15 bits
• 16 : pour un codage des couleurs sur des entiers de 16 bits
• 24 : pour un codage des couleurs sur des entiers de 24 bits
• ...

Pour notre script universel il faudra bien choisir un codage plutôt qu'un autre, alors prévoyons une fonction de conversion :

Code: Select all

def fixcolor(c, bits=16):
  try:
    if not color_mode:
      return c
    r, g, b = c[0], c[1], c[2]
  except:
    if color_mode == bits:
      return c
    if bits == 16:
      br, bg, bb = 5, 6, 5
    else:
      br, bg, bb = 8, 8, 8
    r, g, b = c & (2**br - 1) * 2**(8 - br), c & ((2**bg - 1) * 2**br) // 2**br * 2**(8 - bg), c & ((2**bb - 1) * 2**(br + bg)) // 2**(br + bg) * 2**(8 - bb)
  if not color_mode:
    return (r, g, b)
  else:
    if color_mode == 16:
      br, bg, bb = 5, 6, 5
    else:
      br, bg, bb = 8, 8, 8
    r, g, b = r // 2**(8 - br), g // 2**(8 - bg) * 2**br, b // 2 **(8 - bb) * 2**(br + bg)
    c = r + g - (r & g)
    return c + b - (c & b)

Voici de quoi tracer des lignes verticales et horizontales :

Code: Select all

def draw_vline(x, y1, y2, c):
  for j in range(y2 - y1 + 1):
    sp(x, y1 + j, c)

def draw_hline(y, x1, x2, c):
  for j in range(x2 - x1 + 1):
    sp(x1 + j, y, c)

Et voici enfin notre code de tracé de la mire :

Code: Select all

#o: 0=horizontal, 1=vertical
#s: 0=no_shadow, 1=shadow left/up, -1=shadow right/down
def mire(s=1, o=0, w=sw, h=sh, y0=sy0):
  if o:
    l1, l2, f, i1, i2 = h, w, draw_hline, y0, 0
  else:
    l1, l2, f, i1, i2 = w, h, draw_vline, 0, y0
  n = 8
  for m in range(l1):
    v = 255
    if s != 0:
      v =  v * (s*m % l1) // (l1 - 1)
    for j in range(n):
      f(m + i1, j * l2 // n + i2, (j + 1) * l2 // n - 1 + i2, fixcolor(color8(j, v)))

def color8(j, v):
  c = [0, 0, 0]
  for b in range(3):
    if j & 2**b:
      c[b] = v
  return c

Tu vas vite comprendre tout ça avec notre premier exemple.

Commençons donc par les TI-83 Premium CE Edition Python et TI-84 Plus CE-T Python Edition que nous allons tester en Python.
Nous considérerons que c'est pareil sur les anciennes TI-83 Premium CE et TI-84 Plus CE.

Cela ne t'apprendra sans doute rien mais histoire de vérifier que ça marche, d'après get_color_mode() sur TI-83 Premium CE Edition Python et TI-84 Plus CE Python Edition les couleurs de pixels sont codées en Python par des tuples (r,g,b).

On peut noter ci-contre que le vert ainsi que les couleurs composées de vert (cyan, jaune et blanc) ont un dégradé beaucoup moins saccadé, beaucoup plus fluide. En effet si tu regardes bien elles utilisent 2 fois plus de teintes intermédiaires, très exactement 64 teintes contre 32 pour les autres :

• canal rouge sur 5 bits pour 2⁵= 32 teintes
• canal vert sur 6 bits pour 2⁶= 64 teintes
• canal bleu sur 5 bits pour 2⁵= 32 teintes

Total donc 16 bits pour 2¹⁶= 65536 couleurs affichables, et un contrôleur écran fonctionnant donc au format RGB 565.

Voici maintenant la Casio Graph 90+E et son superbe écran.

Ici encore les paramètres de couleur sont passés sous forme de tuples (r,g,b).

Même constat ici, nous notons 2 fois plus de teintes intermédiaires pour les dégradés de vert et de couleurs incluant du vert :

• canal rouge sur 5 bits pour 2⁵= 32 teintes
• canal vert sur 6 bits pour 2⁶= 64 teintes
• canal bleu sur 5 bits pour 2⁵= 32 teintes

Total donc 16 bits pour 2¹⁶= 65536 couleurs affichables, et un contrôleur écran fonctionnant donc au format RGB 565.

Arrive maintenant la NumWorks.

Avec l'application Python officielle, les paramètres de couleur prennent toujours la forme de tuples (r,g,b).

Encore pareil, 2 fois plus de teintes intermédiaires dans le vert :

• canal rouge sur 5 bits pour 2⁵= 32 teintes
• canal vert sur 6 bits pour 2⁶= 64 teintes
• canal bleu sur 5 bits pour 2⁵= 32 teintes

Total donc 16 bits pour 2¹⁶= 65536 couleurs affichables, et un contrôleur écran fonctionnant donc au format RGB 565.

Tu peux installer le firmware tiers Omega et ensuite, si tu disposes du dernier modèle NumWorks N0110, l'application KhiCAS, une adaptation pour ta calculatrice du logiciel intégré de Mathématiques Xcas par Bernard Parisse, enseignant-chercheur à l'université de Grenoble, et programmable grâce à son interpréteur MicroPython intégré.

Pas de raison que la mire soit différente, mais précisons tout de même au passage que cette édition de KhiCAS fonctionne elle aussi avec des tuples (r,g,b).

Passons donc aux TI-Nspire. Nous disposons d'une préversion de la prochaine mise à jour 5.2 rajoutant Python aux TI-Nspire CX II, mais hélas nous n'avons pas à ce jour l'autorisation de te faire de nouvelles révélations à son sujet.

Donc tant pis, adaptons notre script de mire dans le langage orienté fonction historique de la machine.
Et nous considérerons que c'est pareil sur les anciennes TI-Nspire CX.

Code: Select all

Define mire(s,o,w,h)=
Prgm
  Local l1,l2,f,c,j,m,n,v
  If o≠0 Then
    l1:=h
    l2:=w
    Define f(y,x1,x2,c)=Prgm
      SetColor c[1],c[2],c[3]
      DrawLine x1,y,x2,y
    EndPrgm
  Else
    l1:=w
    l2:=h
    Define f(x,y1,y2,c)=Prgm
      SetColor c[1],c[2],c[3]
      DrawLine x,y1,x,y2
    EndPrgm
  EndIf
  n:=8
  For m,0,l1-1
    v:=int(255*when(s=0,1,((mod(s*m,l1))/(l1-1))))
    For j,0,n-1
      f(m,((j*l2)/(n)),(((j+1)*l2)/(n))-1,color8(j,v))
      EndFor
  EndFor
EndPrgm

Define color8(j,v)=
Func
  Local l,k
  l:=newList(3)
  For k,1,dim(l)
    If mod(int(((j)/(2^(k-1)))),2)≠0 Then
      l[k]:=v
    EndIf
  EndFor
  Return l
EndFunc

Toujours 2 fois plus de teintes intermédiaires tirant sur le vert :

• canal rouge sur 5 bits pour 2⁵= 32 teintes
• canal vert sur 6 bits pour 2⁶= 64 teintes
• canal bleu sur 5 bits pour 2⁵= 32 teintes

Total donc 16 bits pour 2¹⁶= 65536 couleurs affichables, et un contrôleur écran fonctionnant donc au format RGB 565.

Sur les anciennes TI-Nspire CX et TI-Nspire monochromes soit donc avant la version 5.0, le langage interprété ne dispose hélas pas des fonctions de tracé.

Adaptons donc notre mire dans le langage de script Lua :

Code: Select all

o = false
s = 1

function on.charIn(c)
  print(c)
  olds, oldo = s, o
  if c == "−" or c == "-" then
    s = -1
  elseif c == "+" then
    s = 1
  elseif c == "0" then
    s = 0
  elseif c == "*" or c == "/" then
    o = not o
  end
  if s ~= olds or o ~= oldo then
    platform.window.invalidate()
  end
end

function on.resize(w, h)
  platform.window.invalidate()
end

function color8(j, v)
  l={0, 0, 0}
  for k = 1, #l do
    if math.floor(j / 2^(k - 1)) % 2 ~= 0 then
      l[k] = v
    end
  end
  return l
end

function on.paint(gc)
  pw = platform.window
  w, h = pw.width(), pw.height()
  if o then
    l1, l2 = h, w
    function f(gc, y, x1, x2, c)
      gc:setColorRGB(c[1], c[2], c[3])
      gc:drawRect(x1, y, x2, y)
    end
  else
    l1, l2 = w, h
    function f(gc, x, y1, y2, c)
      gc:setColorRGB(c[1], c[2], c[3])
      gc:drawRect(x, y1, x, y2)
    end
  end
  n = 8
  for m = 0, l1 - 1 do
    v = 255
    if s ~=0 then
      v = v * (s * m % l1) / (l1 - 1)
    end
    for j = 0, n - 1 do
      f(gc, m, j * l2 / n, (j + 1)*l2/n - 1, color8(j, v))
    end
  end
end

Sur les TI-Nspire monochromes nous avons donc 4 bits pour 2⁴= 16 niveaux de gris.

Cela ne changera rien au résultat, mais précisons que sur les anciennes TI-Nspire monochromes et TI-Nspire CX si munie d'une version 4.5.0 ou inférieure, tu peux installer Ndless puis MicroPython. Dans ce cas les paramètres de couleur ne sont pas des tuples, mais des entiers sur 16 bits. Heureusement que nous avions prévu notre fonction de conversion automatique.

Sur les anciennes TI-Nspire CX, il est de plus possible dans ce cas d'installer la version de KhiCAS en cours de développement, avec son propre interpréteur MicroPython intégré.

Ici on retrouve la spécification des couleurs sous forme de tuples (r,g,b).

Sur Casio fx-CP400+E nous ne pouvons hélas pas te programmer de mire.
En effet dans le langage interprété historique de la machine et seul langage qui nous est accessible, le paramètre de couleur des fonctions graphiques ne peut prendre que 7 valeurs différentes.

Alors plan B, générons et enregistrons notre mire sous forme d'image, et convertissons-la en image .c2p pour la calculatrice à l'aide de notre convertisseur en ligne.

Toujours le même résultat avec 2 fois plus de teintes intermédiaires dans les tons de vert :

• canal rouge sur 5 bits pour 2⁵= 32 teintes
• canal vert sur 6 bits pour 2⁶= 64 teintes
• canal bleu sur 5 bits pour 2⁵= 32 teintes

Total donc 16 bits pour 2¹⁶= 65536 couleurs affichables, et un contrôleur écran fonctionnant donc au format RGB 565.

On peut remarquer un petit bug d'affichage dans le dégradé de bleu, comme si la teinte la plus claire avait été marquée en tant que couleur transparente.

Mais ce n'est pas un bug lié à notre convertisseur, nous obtenons exactement le même défaut en utilisant le logiciel de conversion officiel de Casio. Le problème se situe donc ou dans le format, ou dans la calculatrice...

Et enfin nous arrive la HP Prime. Une version alpha très préliminaire incluant une application Python a été diffusée en octobre 2019.

Toutefois hélas, son module graphique n'offre de fonction que pour écrire les pixels, pas pour les lire. Impossible donc ici d'y détecter automatiquement le format de couleur.

Revenons donc sur une version plus stable, et passons la calculatrice en mode CAS afin d'y exploiter la compatibilité syntaxique Python.
Grosse surprise, les paramètres de couleur sont ici détectés comme étant des entiers codés sur 24 bits !

Ici c'est ainsi fantastique, des dégradés extrêmement fluides et ce peu importe la teinte !

• canal rouge sur 8 bits pour 2⁸= 256 teintes
• canal vert sur 8 bits pour 2⁸= 256 teintes
• canal bleu sur 8 bits pour 2⁸= 256 teintes

Total donc 24 bits pour 2²⁴= 16777216 couleurs affichables, et un contrôleur écran fonctionnant donc au format RGB 888 !

Résumé donc des données collectées jusqu'à présent sur les écrans, avec :

• en bas les capacités officielles de la machine en mode examen
• en haut les possibilités hors mode examen