TI-Planet | Programmes, Tutoriaux, Forum sur les calculatrices TI

de **critor** » 22 Aoû 2020, 17:22

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

de **critor** » 20 Aoû 2020, 13:27

L'année dernière, Texas Instruments avait accompagné les enseignants dans la prise en main de la nouvelle TI-83 Premium CE Edition Python dans le cadre de ses journées d'été TI-Python.
Une formation de 2 jours organisée la semaine d'avant la rentrée dans pas moins de 7 villes de France métropolitaine, et qui avait bénéficié d'un succès phénoménal, la calculatrice étant en prime fournie et offerte aux participants accompagnée de ses supports de formation et d'activités !

L'épidémie étant passée par là entre temps, il n'est hélas pas possible d'organiser le même genre d'événement cette année.

Toutefois ne t'inquiète pas, Texas Instruments ne te laisse pas tomber pour autant, et a prévu en remplacement quelque chose de différent pour cette rentrée 2020, les Journées d’été T³.

Cet événement organisé cette année en ligne, sera l'occasion de se former en Python dans le contexte de nouveaux produits compatibles de la marque ainsi que des nouveaux programmes du lycée général et technique et même du lycée professionnel !

Ton formateur Jérôme Lenoir, professeur en Mathématiques - Sciences Physiques au lycée professionnel Henri Senez dans l'académie de Lille, abordera les nouveautés de la dernière mise à jour 5.5.2 pour TI-83 Premium CE Edition Python :

jeudi 27 août 17h45-19h00 : installation de la mise à jour 5.5.2 et découverte de l'application Python
vendredi 28 août 17h45-19h00 : nouveautés de la version 5.5.2

Les participants seront invités à participer à 4 nouvelles sessions fin septembre, différenciées pour les enseignants de Mathématiques et Physique-Chimie :

Exemples de scripts utilisant les modules ti_plotlib et ti_system
Exemples de scripts liés aux programmes scolaires (partie 1)
Exemples de scripts liés aux programmes scolaires (partie 2)
Créer un scénario pédagogique intégrant la programmation en Python

A l'issue du parcours de formation, comme l'année dernière Texas Instruments t'enverra gratuitement son nouveau cahier d'activités Programmation en Python au lycée de cette rentrée 2020, justement coécrit par Jérôme Lenoir, avec 6 activités Python clés en main en Mathématiques et 6 autres en Physique-Chimie !

Inscription : https://tiedtech.webex.com/mw3300/myweb ... &service=6

de **critor** » 19 Aoû 2020, 10:49

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: Tout sélectionner: 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: Tout sélectionner: 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: Tout sélectionner: 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: Tout sélectionner: 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: Tout sélectionner: 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: Tout sélectionner: (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: Tout sélectionner: (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: Tout sélectionner: (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: Tout sélectionner: 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: Tout sélectionner: ?→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: Tout sélectionner: 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

de **critor** » 18 Aoû 2020, 13:09

L'année dernière, Texas Instruments avait accompagné les enseignants dans la prise en main de la nouvelle TI-83 Premium CE Edition Python dans le cadre de ses journées d'été TI-Python.
Une formation de 2 jours organisée la semaine d'avant la rentrée dans pas moins de 7 villes de France métropolitaine, et qui avait bénéficié d'un succès phénoménal, la calculatrice étant en prime fournie et offerte aux participants accompagnée de ses supports de formation et d'activités !

L'épidémie étant passée par là entre temps, il n'est hélas pas possible d'organiser le même genre d'événement cette année.

Toutefois ne t'inquiète pas, Texas Instruments ne te laisse pas tomber pour autant, et a prévu en remplacement quelque chose de différent pour cette rentrée 2020, les Journées d’été T³.

Cet événement organisé cette année en ligne, sera l'occasion de se former en Python dans le contexte de nouveaux produits compatibles de la marque ainsi que des nouveaux programmes du lycée général et technique et même du lycée professionnel !

Au menu les nouveautés de la dernière mise à jour 5.5.2 pour TI-83 Premium CE Edition Python :

jeudi 27 août : 17h45-19h00
vendredi 28 août : 17h45-19h00

Inscription : https://tiedtech.webex.com/mw3300/myweb ... &service=6

Source : https://twitter.com/TIEducationFR/statu ... 44/photo/1

de **critor** » 18 Aoû 2020, 10:30

Pour cette rentrée 2020, la formidable application Python des Casio Graph 90+E et Graph 35+E II si correctement mise à jour (ce qu'il est notamment conseillé de faire si tu viens d'acheter la calculatrice) t'offre 3 modules importables pour tes scripts :

math pour les fonctions mathématiques, un standard
random pour l'aléatoire, un standard
et casioplot, un module graphique propriétaire permettant à tes scripts d'allumer des pixels de l'écran dans la couleur de ton choix

De plus, Casio diffuse 2 scripts Python à rajouter manuellement dans ta calculatrice et qui s'appuient sur le module casioplot précédent :

turtle.py, un script fantastique de plus de 300 lignes qui reproduit sur ta calculatrice le fonctionnement du module turtle standard
matplotl.py, un script monumental de plus de 600 lignes qui s'occupe quant à lui de reproduire sur ta calculatrice le fonctionnement du module standard matplotlib.pyplot

Il s'agit donc de réimplémentations en Python des modules standard turtle et matplotlib.pyplot, un travail à la fois colossal et d'excellente facture, car hautement fidèle aux modules standard en question !

Tous les liens de téléchargement seront disponibles en fin d'article.

Cela n'enlève rien à leurs énormes qualités supérieures par rapport à ce qui est disponible sur certaines Pythonnettes concurrentes, mais une réécriture intégrale ne peut pas être parfaite du premier coup.

Nous nous intéresserons ici au script matplotl.py, et plus précisément à sa fonction de tracé de flèche/vecteur notamment pour l'enseignement de Physique-Chimie en Seconde, arrow().
Absolument pas pour se moquer de Casio, mais simplement parce que c'est intéressant et hautement formateur.

Voici un petit script avec de quoi te tracer un soleil de vecteurs (ou un champ de vecteurs radial pour ceux qui préfèrent) :

Code: Tout sélectionner: try: from matplotlib.pyplot import * except ImportError: from matplotl import * from math import cos, sin, pi def radians(x): return x * pi / 180 def autoround(x): xr = round(x, 0) if abs(x - xr) < 10 ** -15: x = xr return x def rotarrow(x0, y0, rx, ry, t1, t2, ts, hw, hl, ec, fc): for k in range(t1, t2 + ts, ts): kr = radians(k) w, h = autoround(rx * cos(kr)), autoround(ry * sin(kr)) arrow(x0, y0, w, h, head_width=hw, head_length=hl, ec=ec, fc=fc)

Graph 35+E II	Graph 90+E	NumWorks	ordi

Code: Tout sélectionner `rotarrow(.0625, .0625, .75, .75, 0, 90, 10, .075, .1875, 'r', 'b') show()`

Bon la NumWorks semble ignorer les paramètres de couleur pour faire absolument n'importe quoi, mais ce n'est pas ce qui nous intéresse aujourd'hui. Voyons donc plutôt les défauts chez Casio.

Sur Graph 35+E II tout semble bon. Par contre sur Graph 90+E il y a un problème avec la couleur des pointes, dans le cas particulier où elles sont orientées horizontalement ou verticalement.

Effectivement ça ne va pas, tentons de comprendre et corriger directement le fichier de Casio puisque ce dernier a eu la gentillesse de laisser le code source consultable et modifiable contrairement à d'autres.

La variable color est donc la couleur utilisée pour le tracé du segment via un appel plot() commun à toutes les orientations.
La variable headcolor est quant à elle la couleur souhaitée pour la pointe.
Pour le tracé de la pointe il y a 2 cas particuliers pour les directions horizontales et verticales, et effectivement les appels plot() associés sont faux, réutilisant color comme paramètre de couleur. La correction est triviale, lignes n°23 et 29 dans les extraits de code ci-dessous :

maptplotl.py de Casio	matplotl.py corrigé

Code: Tout sélectionner def arrow(x,y,dx,dy,*kwargs): global win_scaling a=x+dx b=y+dy win_scaling='fixed' color=kwargs.get('ec','k') color=kwargs.get('edgecolor',color) headcolor=kwargs.get('fc',color) headcolor=kwargs.get('facecolor',headcolor) L=kwargs.get('head_width',0.003) l=kwargs.get('head_length',1.5L) plot((x,a),(y,b),color) def resol(A,B,C): D=B*2-4AC if D>0: return((-B-D0.5)/(2A),(-B+D*0.5)/(2A)) if dx==0: if dy>=0: c=1 else: c=-1 plot((a-L/2,a+L/2,a,a-L/2),(b,b,b+cl,b),color) elif dy==0: if dx>=0: c=1 else: c=-1 plot((a,a,a+cl,a),(b-L/2,b+L/2,b,b-L/2),color)	Code: Tout sélectionner def arrow(x,y,dx,dy,*kwargs): global win_scaling a=x+dx b=y+dy win_scaling='fixed' color=kwargs.get('ec','k') color=kwargs.get('edgecolor',color) headcolor=kwargs.get('fc',color) headcolor=kwargs.get('facecolor',headcolor) L=kwargs.get('head_width',0.003) l=kwargs.get('head_length',1.5L) plot((x,a),(y,b),color) def resol(A,B,C): D=B*2-4AC if D>0: return((-B-D0.5)/(2A),(-B+D*0.5)/(2A)) if dx==0: if dy>=0: c=1 else: c=-1 plot((a-L/2,a+L/2,a,a-L/2),(b,b,b+cl,b),headcolor) elif dy==0: if dx>=0: c=1 else: c=-1 plot((a,a,a+cl,a),(b-L/2,b+L/2,b,b-L/2),headcolor)

Bon mais ça c'était un détail. Voici maintenant beaucoup plus dérangeant et épicé :

Graph 35+E II	Graph 90+E	NumWorks	ordi

Code: Tout sélectionner `rotarrow(.475, .5, .45, .4, 0, 360, 10, .05, .1, 'r', 'b') axis([0, 1, 0, 1]) show()`

Mais sur Graph 35+E II et Graph 90+E ça ne va pas du tout... Mais qu'est-ce que c'est que cette horreur de soleil à moitié fané ?...

Dans certains cas, les pointes de flèches/vecteurs sont visiblement tracées à l'envers. Là pour le coup c'est un bug bien plus profond et non une simple étourderie.

Tentons de comprendre un peu mieux quand est-ce que cela se produit :

Graph 35+E II	Graph 90+E	NumWorks	ordi

Code: Tout sélectionner `for k in range(4): rotarrow(.475 - (k <= 1), .5 - (k % 2), .45, .4, 0, 360, 15, .075, .1, 'r', 'b') axis([-1, 1, -1, 1]) show()`

Il semble que les pointes de flèches soient ainsi montées à l'envers lorsqu'elles ont une abscisse négative (x<0). Il s'agirait donc a priori d'une erreur de signe, faut-il encore trouver où changer le signe dans le code.

Notons que le problème concerne des flèches qui ne sont ni horizontales ni verticales, et l'erreur est donc à chercher cette fois-ci dans le bloc traitant le cas général. Or il y a justement un test de signe dans ce cas, ligne 34 ci-dessous. Changeons cela...

maptplotl.py de Casio	matplotl.py corrigé

Code: Tout sélectionner def arrow(x,y,dx,dy,*kwargs): global win_scaling a=x+dx b=y+dy win_scaling='fixed' color=kwargs.get('ec','k') color=kwargs.get('edgecolor',color) headcolor=kwargs.get('fc',color) headcolor=kwargs.get('facecolor',headcolor) L=kwargs.get('head_width',0.003) l=kwargs.get('head_length',1.5L) plot((x,a),(y,b),color) def resol(A,B,C): D=B*2-4AC if D>0: return((-B-D0.5)/(2A),(-B+D*0.5)/(2A)) if dx==0: if dy>=0: c=1 else: c=-1 plot((a-L/2,a+L/2,a,a-L/2),(b,b,b+cl,b),headcolor) elif dy==0: if dx>=0: c=1 else: c=-1 plot((a,a,a+cl,a),(b-L/2,b+L/2,b,b-L/2),headcolor) else: m=dy/dx p=y-mx S=resol(m2+1,2(-a-bm+mp),p2+a2+b2-l2-2bp) if S[0]dx<0: X=S[0] else: X=S[1] Y=mX+p k=b+a/m T=resol(1+1/m*2,2(-a-k/m+b/m),a2+k2-2bk+b2-(L2)/4) plot((T[0],T[1],X,T[0]),(-T[0]/m+k,-T[1]/m+k,Y,-T[0]/m+k),headcolor)	Code: Tout sélectionner def arrow(x,y,dx,dy,*kwargs): global win_scaling a=x+dx b=y+dy win_scaling='fixed' color=kwargs.get('ec','k') color=kwargs.get('edgecolor',color) headcolor=kwargs.get('fc',color) headcolor=kwargs.get('facecolor',headcolor) L=kwargs.get('head_width',0.003) l=kwargs.get('head_length',1.5L) plot((x,a),(y,b),color) def resol(A,B,C): D=B*2-4AC if D>0: return((-B-D0.5)/(2A),(-B+D*0.5)/(2A)) if dx==0: if dy>=0: c=1 else: c=-1 plot((a-L/2,a+L/2,a,a-L/2),(b,b,b+cl,b),headcolor) elif dy==0: if dx>=0: c=1 else: c=-1 plot((a,a,a+cl,a),(b-L/2,b+L/2,b,b-L/2),headcolor) else: m=dy/dx p=y-mx S=resol(m2+1,2(-a-bm+mp),p2+a2+b2-l2-2bp) if S[0]dxx<0: X=S[0] else: X=S[1] Y=mX+p k=b+a/m T=resol(1+1/m2,2(-a-k/m+b/m),a2+k2-2bk+b2-(L2)/4) plot((T[0],T[1],X,T[0]),(-T[0]/m+k,-T[1]/m+k,Y,-T[0]/m+k),headcolor)

Ah ben non, ce n'est pas encore ça... cela corrige bien les pointes enfichées sur une extrémité de segment d'abscisse négative, mais pas celles qui franchissent l'axe des ordonnées donnant donc une pointe d'abscisse négative bien que montée sur une extrémité d'abscisse positive.

Les deux sens de montage de la flèche pour l'orientation du segment sont en fait retournées en abscisses par un appel resol(), simple fonction donnant les racines d'un polynôme du second degré.

Reste donc à choisir le bon sens de montage, et le test officiel S[0]*dx<0 ainsi que notre test S[0]*dx*x<0 semblent donc tous les deux faux.

En fait nous ne voyons même pas en quoi la réponse dépendrait du signe de la racine S[0]... à la rigueur de l'ordre de S[0] et S[1] pour savoir qui est à gauche et qui est à droite, mais pas du signe... et ici il n'y a même pas à se préoccuper de l'ordre puisque 1+1/m**2, premier paramètre de l'appel resol(), est strictement positif.

Faire pointer à gauche ou à droite, non ici cela ne dépend plus que d'une seule et unique chose, le signe de dx, et le bon test corrigé en ligne 34 ci-dessous est donc dx<0.
On peut bien se permettre une petite coquille après s'être tapé plus de 320 lignes.

maptplotl.py de Casio	matplotl.py corrigé

Code: Tout sélectionner def arrow(x,y,dx,dy,*kwargs): global win_scaling a=x+dx b=y+dy win_scaling='fixed' color=kwargs.get('ec','k') color=kwargs.get('edgecolor',color) headcolor=kwargs.get('fc',color) headcolor=kwargs.get('facecolor',headcolor) L=kwargs.get('head_width',0.003) l=kwargs.get('head_length',1.5L) plot((x,a),(y,b),color) def resol(A,B,C): D=B*2-4AC if D>0: return((-B-D0.5)/(2A),(-B+D*0.5)/(2A)) if dx==0: if dy>=0: c=1 else: c=-1 plot((a-L/2,a+L/2,a,a-L/2),(b,b,b+cl,b),headcolor) elif dy==0: if dx>=0: c=1 else: c=-1 plot((a,a,a+cl,a),(b-L/2,b+L/2,b,b-L/2),headcolor) else: m=dy/dx p=y-mx S=resol(m2+1,2(-a-bm+mp),p2+a2+b2-l2-2bp) if S[0]dx<0: X=S[0] else: X=S[1] Y=mX+p k=b+a/m T=resol(1+1/m*2,2(-a-k/m+b/m),a2+k2-2bk+b2-(L2)/4) plot((T[0],T[1],X,T[0]),(-T[0]/m+k,-T[1]/m+k,Y,-T[0]/m+k),headcolor)	Code: Tout sélectionner def arrow(x,y,dx,dy,*kwargs): global win_scaling a=x+dx b=y+dy win_scaling='fixed' color=kwargs.get('ec','k') color=kwargs.get('edgecolor',color) headcolor=kwargs.get('fc',color) headcolor=kwargs.get('facecolor',headcolor) L=kwargs.get('head_width',0.003) l=kwargs.get('head_length',1.5L) plot((x,a),(y,b),color) def resol(A,B,C): D=B*2-4AC if D>0: return((-B-D0.5)/(2A),(-B+D*0.5)/(2A)) if dx==0: if dy>=0: c=1 else: c=-1 plot((a-L/2,a+L/2,a,a-L/2),(b,b,b+cl,b),headcolor) elif dy==0: if dx>=0: c=1 else: c=-1 plot((a,a,a+cl,a),(b-L/2,b+L/2,b,b-L/2),headcolor) else: m=dy/dx p=y-mx S=resol(m2+1,2(-a-bm+mp),p2+a2+b2-l2-2bp) if dx<0: X=S[0] else: X=S[1] Y=mX+p k=b+a/m T=resol(1+1/m2,2(-a-k/m+b/m),a2+k2-2bk+b2-(L2)/4) plot((T[0],T[1],X,T[0]),(-T[0]/m+k,-T[1]/m+k,Y,-T[0]/m+k),headcolor)