Texas Instruments a un temps produit des calculatrices graphiques translucides permettant plus ou moins de voir l'intérieur sans avoir à les ouvrir. À la fois une réussite esthétique et un bijou pour les esprits les plus curieux. On peut citer en ce sens la très éphémère TI-83 Plus Silver Edition sortie pour la rentrée 2001. Il s'agissait d'une version avancée de la TI-83 Plus de la rentrée 1999, avec :
processeur qui passe de 6 MHz à 15 MHz
puce Flash qui passe de 512 Kio à 2 Mio
dont la mémoire de stockage qui passe de 160 Kio à 1,5 Mio
mémoire RAM qui passe de 32 Kio à 128 Kio
Hélas la superbe TI-83 Plus Silver Edition fut arrêtée dès la rentrée 2004 afin de faire de la place pour la sortie des TI-84 Plus et TI-84 Plus Silver Edition. Et ici pas de boîtier translucide, même la version Silver Edition ne s'habillant que de tons de gris totalement opaques.
Toutefois, pour la rentrée 2008 an Amérique du Nord, la chaîne de grande distribution Wal-Mart a commercialisé une édition limitée translucide de la TI-84 Plus, devenue absolument collector de nos jours.
Sur un autre sujet, quand on est habitué aux calculatrices TI-82/83/84 monochromes, on ne peut que tomber amoureux de l'écran éclairé des Casio Graph 75/95 sorties pour la rentrée 2009, une capacité reprise pour la Graph 75+E de la rentrée 2015.
Hélas la Graph 75+E fut arrêtée pour la rentrée 2017. L'actuelle Graph 35+E II sortie pour la rentrée 2019 qui en reprend et fait évoluer le matériel, n'a hélas pas retenu cette capacité.
Et bien aujourd'hui BigMC-OG te propose de fusionner le meilleur des deux mondes !
Il a en effet modifié sa version translucide collector de la TI-84 Plus, afin de lui rajouter un éclairage de l'écran. Une modification très bien réussie permettant une lisibilité remarquable, et qui est ici du plus bel effet avec le boîtier translucide !
Rappelons que ta TI-82 Advanced monochrome utilise le même boîtier, et que tu peux donc toi aussi t'amuser à l'améliorer de façon similaire. Nous avons hâte de voir ça...
Apparu le 3 avril 1860, le Pony Express était un service d'acheminement rapide du courrier en Amérique du Nord, de la Californie au Missouri et vice-versa. Le courrier jusqu'alors acheminé par diligence avec la côte ouest pouvait prendre jusqu'à 6 mois, alors que l'acheminement par les cavaliers solitaires du Pony Express à travers les plaines asséchées de l'ouest à une vitesse moyenne de 16 km/h, réduisait le délai à seulement 10 à 11 jours. Rapidement supplanté par le télégraphe, il cessa toute activité le 24 octobre 1861. Malgré sa courte histoire de 18 mois le Pony Express, emblématique de la conquête de l'Ouest, fait partie intégrante de la culture populaire américaine.
Le 3 avril 2015, c'était le 155ème anniversaire du Pony Express et Google avait sorti un doodle tout spécialement dédié pour ses pages de recherche. Un clic sur le doodle activait un jeu te permettant de revivre l'aventure du Pony Express. À cheval sur ton propre destrier, tu te devrais de collecter 100 lettres à destination du Missouri, réparties à travers 3 niveaux couvrant tout l'ouest américain. Tu te devais d'éviter les nombreux obstacles et dangers (rochers, cactus, clôtures, arbres, rivières, lacs, falaises, chutes de neige, voleurs, ... tout un programme). Pour cela les flèches haut et bas te permettaient à tout moment de choisir entre 6 chemins différents pour ta monture.
Et bien justement aujourd'hui Candledark se propose de faire revivre ce doodle dans ta calculatrice TI-83 Premium CE ou TI-84 Plus CE.
Son jeu Pony Express CE se veut être une adaptation du doodle de Google et est toujours en phase de développement mais est déjà parfaitement jouable et très fluide (entre 30 et 40fps sur calculatrice), avec qui plus est des menus bilingues en Anglais et Français.
Le jeu est codé en langage C puis compilé en langage machine pour ta calculatrice.
Attention, Pony Express CE rentre dans la catégorie des programmes en langage machine dits ASM.
Or, suite à un acte irresponsable d'un enseignant de Mathématiques français avec ses gesticulations aveugles dans le contexte de la réforme du lycée, Texas Instruments a réagi en supprimant la gestion de tels programmes depuis la mise à jour 5.5.1.
Si tu es sur une des versions ainsi bridées, tu peux quand même jouer sans trop d'efforts. Il te faut :
installer arTIfiCE pour remettre la possibilité de lancer des programmes ASM
ensuite de préférence installer Cesium pour pouvoir lancer les programmes ASM plus facilement, ou même AsmHook pour pouvoir les lancer comme avant
installer les bibliothèques C nécessaires au fonctionnement de certains jeux dont celui-ci (mais rien de compliqué, juste à transférer le fichier et c'est tout)
Depuis plusieurs années, Vogtinator est le principal dévelopeur de Ndless, le jailbreak te permettant de lancer du code machine tiers sur les TI-Nspire.
Pour la rentrée 2015 justement Vogtinator t'avait sorti Crafti, un très impressionnant clone de Minecraft pour les TI-Nspire capables d'exploiter le jailbreakNdless.
Te souviens-tu également de notre cher et très prolifiquegameblabla ? Il t'avait porté des émulateurs de consoles de jeux par 10aines pour TI-Nspire CX et Ndless, t'ouvrant ainsi la porte à plusieurs milliers de jeux sur ta calculatrice !
De façon générale, nombre de jeux pour nos calculatrices sont des adaptations ou portages de jeux sortis pour ordinateurs et consoles plusieurs années auparavant.
Dans une actualité précédente, gameblabla innovait en nous emmenant pour une fois sur le chemin inverse, réalisant en effet un nouveau portage de Crafti pour la console de jeux Microsoft Xbox.
Et bien aujourd'hui gameblabla récidive, signant cette fois-ci un portage de Crafti pour la console de jeux Sony Playstation 2 !
Ndless ayant hélas visiblement cessé d'être adapté aux nouvelles mises à jour TI-Nspire CX depuis bientôt une année, retrouve donc maintenant également sur ta Playstation 2 les délices des TI-Nspire Ndlessées :
Pour accompagner en douceur la transition du Scratch au Python en Seconde, la plupart des solutions Python sur calculatrices graphiques offrent turtle, une bibliothèque permettant du tracé relatif comme en Scratch. On peut citer :
la NumWorks dont l'application Python intègre directement turtle
les Casio Graph 35+E II et Graph 90+E dont l'application Python intègre directement turtle
et sur les TI-83 Premium CE Edition Python(France), TI-84 Plus CE-T Python Edition(Europe) et TI-84 Plus CE Python(Amérique du Nord), on pouvait jusqu'ici rajouter une bibliothèque officielle à l'application Python : ce_turtl
L'utilisation de ce_turtl sur TI-83 Premium CE Edition Python et compatible n'était jusqu'à présent pas de tout repos, loin de là. En effet énorme problème, les bibliothèques complémentaires comme ce_turtl n'étaient par défaut pas disponibles au menu.
Ils apparaissaient au menu uniquement lorsque l'on était en train d'éditer un script comportant une ligne les important (dans notre cas forcément sous la forme from ce_turtl import, et pas un simple import ce_turtl).
Lors de la création d'un script, afin d'obtenir le menu te permettant de saisir facilement et rapidement les appels aux différentes méthodes de ce_turtl, tu devrais donc commencer par te taper la saisie lettre par lettre au clavier de sa ligne d'importation, avec en prime le caractère tiret bas qui n'est pas au clavier et était donc à aller chercher dans un menu.
Mais attends car le pire, c'est que c'était encore loin d'être le pire...
Mais surtout bien pire que cela, ce_turtl était une véritable catastrophe ambulante !
Aucun effort ne semblait avoir été fait pour coller au standard : des méthodes essentielles manquantes, des noms de méthodes fantaisistes, des arguments attendus différant du standard dans leur nombre, leur ordre ou leur type... et ne parlons même pas encore du comportement attendu.
Si tu ne faisais pas l'effort d'adapter ton code, il t'était fort probable d'obtenir n'importe quoi. Voici ci-contre ce que donne un escargot sur ordinateur et l'ensemble de la concurrence, et sur TI-83 Premium CE Edition Python et compatibles avec ce_turtl...
Quel professeur allait perdre du temps à faire apprendre un sous-dialecte du turtle ne fonctionnant que sur calculatrices TI-83 Premium CE Edition Python et compatibles, risquant ainsi de mélanger les élèves par rapport aux documents, ouvrages ou autres autres plateformes auxquels ils ont accès (ordinateur, tablette, smartphone, calculatrice d'un autre modèle) ?...
Nous savons parfaitement que la mémoire de tas (heap) du Python des TI-83 Premium CE Edition Python et compatibles est extrêmement limitée, seulement 19,968 Ko de capacité, et en pratique souvent bien moins de disponible car les bibliothèques importées prennent de la place.
Dans ce contexte nous comprenons parfaitement qu'il faille se limiter et faire des choix.
Mais nous persistons à penser que l'on pouvait faire largement mieux niveau compatibilité et conformité que ce que nous a offert ce_turtl, et ce sans augmenter la consommation de heap à l'exécution.
Dans le cadre de sa mise à jour 5.7 pour TI-83 Premium CE Edition Python et compatibles, Texas Instrumentsavait publié une nouvelle bibliothèque complémentaire turtle 2.00. Le changement majeur de numéro de version suggérait des nouveautés significatives, et le changement de nom en turtle pour sa part un bien meilleur respect du standard.
Cette nouvelle bibliothèque turtle pouvait être installée indépendamment de la mise à jour ; elle fonctionnait tout aussi bien sur les versions précédentes selon nos tests.
Mais si tu mettais à jour en version 5.7 tu bénificiais d'un formidable avantage : un nouvel onglet de bas d'écran te permet enfin de lister les bibliothèques complémentaires importables et turtle en faisait partie !
Donc plus de saisie fastidieuse, une seule touche suffisait à coller la ligne d'importation et alors faire apparaître tout le contenu de la nouvelle bibliothèque turtle au menu !
La bibliothèque prédécesseure ce_turtle avait été publiée dans deux versions (Français et Anglais).
Problème par contre, la nouvelle bibliothèque turtle était intégralement en Anglais.
Et bien bonne nouvelle aujourd'hui, Texas Instruments nous publie une nouvelle bibliothèque turtle 2.01 cette fois-ci en Français !
Maintenant que les utilisateurs français sont à leur tour invités à passer à la nouvelle bibliothèque turtle, nous allons te présenter son fonctionnement, tester sa conformité au standard turtle, puis te montrer ce qu'elle donne par rapport à la concurrence sur quelques exemples.
La publication de Texas Instruments consiste en 2 fichiers de variables d'application pour calculatrice :
TURTLE.8xv
GRID.8xv
TURTLE.8xv est la bibliothèque Python complémentaire en question, ici en version 2.0.0. Soit cela signifie qu'il y a eu des versions inférieures de test auxquelles nous n'avons pas eu accès, soit ce changement de numérotation majeure est pour noter une différence significative par rapport à ce_turtle.
Le fichier TURTLE.8xv a été généré par Texas Instruments à l'aide de py2appvar, un outil non public de Texas Instruments permettant à partir d'un fichier source Python :
la conversion du cose source Python en bytecodePython
l'énumération des éléments à mettre au menu à partir de lignes de commentaires spécialement formatées à cette fin dans le code source
Contrairement à CE_TURTL.8xv, TURTLE.8xv a été généré à l'aide d'une version plus récente de l'outil py2appvar, non plus la 1.2.0 mais la 1.2.1. Nous supposons que py2appvar 1.2.1 ajoute la gestion de la nouvelle ligne de commentaire permettant de spécifier l'ajout de la commande d'importation au menu des bibliothèques complémentaires.
GRID.8xv quant à lui n'est rien d'autre qu'une image 320×210 pixels au format IM8C directement affichable par les scripts Python de la calculatrice et que voici justement ci-contre ; il s'agit donc d'une grille.
from turtle import * t = Turtle() t.circle(52) t.done()
Tu peux très bien te passer de GRID, soit ne pas transférer ou effacer la variable en question. Dans ce cas cela ne déclenche pas d'erreur, mais rappelons que le Python sur TI-83 Premium CE Edition Python et compatible ne dispose pas d'un calque dédié aux affichages graphiques, ces derniers étant effectués par-dessus la console. Ne trouvant alors rien à afficher, l'écran ne sera pas nettoyé et il te faudra alors rajouter du code en ce sens.
Tu peux également t'amuser à remplacer le fond d'écran de la bibliothèque turtle comme bon te semble. Notre outil en ligne img2calc te permet de convertir n'importe quelle image au format IM8C de Texas Instruments, et il te suffira alors juste de choisir le nom GRID pour la calculatrice.
Rappelons que comme le buffer d'affichage est ici unique, tu dois effectuer une pause en fin de script sous peine de voir ton tracé une fois terminé être immédiatement écrasé par l'affichage de la console. La bibliothèque turtle t'offre pour cela la méthode .done() qui attend l'appui sur la touche
annul
(ou
clear
sur les TI-84 Plus CE), mais tu es libre d'utiliser n'importe quel autre code générant une attente.
À noter que la bibliothèque turtle t'offre la possibilité de désactiver l'affichage de la grille. Il te suffira d'appeler la méthode .hidegrid() avant ta première instruction d'affichage.
En pratique la méthode .hidegrid() efface simplement l'écran en blanc.
Les méthodes au menu sont réparties sous 5 onglets différents:
Move : pour les déplacements de la tortue
Draw : pour les tracés autres que des segments (cercle, texte, remplissage, ...)
Pen : pour tout ce qui concerne le stylo (levé, baissé, couleur, taille)
Settings : pour différents réglages (effacement du tracé, cacher/montrer la tortue, désactiver l'affichage de la grille comme déjà vu, vitesse)
State : pour interroger l'état de la tortue (position, orientation)
Les noms d'onglets ne sont donc pas traduits ici. Sans doute parce qu'avec des noms en Français il aurait été bien difficile de continuer à afficher ces 5 onglets sur un même écran.
La traduction en Français concerne en fait les noms de paramètres des fonctions au menu, ainsi que les éventuelles indications les accompagnant :
Mais ce qui est extraordinaire ici et à ce jour une exclusivité toute concurrence confondue, c'est la présence des méthodes de remplissage de formes, et nous allons nous régaler dans les exemples qui vont suivre !
De quoi a priori étendre très largement les possibilités et facilités de tracé pour les élèves !
from turtle import * t = Turtle() t.goto(0,-95) s = 3 for r in range(0, 159, r): t.left(90) t.circle(r) t.right(90) t.done()
Déjà ce script met en évidence un bug en Python des TI-83 Premium CE Edition Python et compatibles : au-delà d'une certaine valeur de rayon les tracés de cercles se déforment très rapidement et tendent vers des carrés.
Le bug n'est en fait ni dans ce_turtl ni dans turtle, mais dans le module de tracé par pixels ti_graphics qu'ils utilisent tous les deux sur ces calculatrices, visiblement toujours pas corrigé en version 5.7.
Mais problème... Si tu regardes bien bien que la structure soit similaire, nous avons dû écrire 2 scripts différents pour ce_turtl et turtle.
Si en plus on fait rentrer la concurrence dans l'équation, il n'est pas envisageable pour nous de maintenir jusqu'à 7 versions différentes pour chaque script testé...
def _turtle_error(k): global _turtle_errors _turtle_errors |= 1 << k
# import turtle try: import turtle if not "forward" in dir(turtle): turtle = turtle.Turtle() except ImportError: #TI-83 Premium CE from ce_turtl import turtle _turtle_error(0) try: turtle.clear() except: turtle.reset()
# can turtle be patched ? _fix_turtle = True try: def _fixcolor(c): return c turtle._fixcolor = _fixcolor except: _fix_turtle = False
# test color() + pencolor() + fillcolor() if not "pencolor" in dir(turtle): pencolor = turtle.color _turtle_error(1) else: pencolor = turtle.pencolor if not "color" in dir(turtle): _turtle_error(2) if not "fillcolor" in dir(turtle): _turtle_error(12)
if not "clear" in dir(turtle): _turtle_error(13) if not "reset" in dir(turtle): _turtle_error(14) if not "heading" in dir(turtle): _turtle_error(11)
# test colormode() if not "colormode" in dir(turtle): _turtle_error(3)
# test color strings _colors_fix={ "blue":(0,0,1), "green":(0,1,0), "red":(1,0,0), "cyan":(0,1,1), "yellow":(1,1,0), "magenta":(1,0,1), "white":(1,1,1), "orange":(1,0.65,0), "purple":(0.66,0,0.66), "brown":(0.75,0.25,0.25), "pink":(1,0.75,0.8), "grey":(0.66,0.66,0.66), "black":(0,0,0), } for c in tuple(_colors_fix.keys()): try: pencolor(c) _colors_fix.pop(c) except: pass if len(_colors_fix): if _color_types & 1 << 3: _turtle_error(8)
# test circle(,) try: turtle.circle(0,0) except: _turtle_error(9)
#test towards try: turtle.towards except: _turtle_error(15)
# test for unfixable missing functions _missing_fct=["write","pensize","dot"] for f in tuple(_missing_fct): try: eval("turtle."+f) _missing_fct.remove(f) except: pass if len(_missing_fct): _turtle_error(16)
_missing_alias=[ ["backward","back","bk"], ["forward","fd"], ["right","rt"], ["left","lt"], ["position","pos"], ["goto","setpos","setposition"], ["setheading","seth"], ["pendown","pd","down"], ["penup","pu","up"], ["pensize","width"], ["showturtle","st"], ["hideturtle","ht"], ] for aliases in tuple(_missing_alias): validf = None for f in tuple(aliases): try: eval("turtle."+f) validf = f aliases.remove(f) break except: pass for f in tuple(aliases): try: eval("turtle."+f) aliases.remove(f) except: pass if not len(aliases): _missing_alias.remove(aliases) else: aliases.insert(0, validf) if len(_missing_alias): _turtle_error(17)
from ttl_chk import * from ttl_chk import _fix_turtle, _turtle_errors, _colors_fix, _missing_fct, _missing_alias
def turtle_diags(): print("Type: " + str(type(turtle))) print("Patchable: " + (_fix_turtle and "yes" or "no")) errors_msg = ( "No <import turtle>", "No pencolor()", "No color()", "No colormode()", "No color as list", "No color as tuple", "No color as args", "No color as string", "Missing colors strings: ", "No circle(,angle)", "Can't get position()", "No heading()", "No fill", "No clear()", "No reset()", "No towards()", "Other missing: ", "Missing aliases: ", ) errors = 0 for k in range(len(errors_msg)): if _turtle_errors & 1 << k: errors += 1 msg = "Err " + str(k) + ": " + errors_msg[k] if k == 8: msg += str(len(_colors_fix)) + " " + str(tuple(_colors_fix.keys())) if k == 16: msg += str(len(_missing_fct)) + " " + " ".join(_missing_fct) if k == 17: l = [] for v in _missing_alias: l.extend(v[1:]) msg += str(len(l)) + " " + " ".join(l) print(msg) print(str(errors) + " error" + ((errors > 1) and "s" or ""))
turtle_diags()
Voici ce que nous racontent les scripts sur calculatrices Texas Instruments :
Pas étonnant que ce_turtle fasse n'importe quoi, c'est une véritable calamité. Pas moins de 12 erreurs, et encore ce sont juste celles qui sont détectées. La grande majorité de ce qui est testé ne va pas :
ligne d'importation non standard (à cause du nom)
réglage non standard de la couleur du tracé, utilisant la méthode .color() au lieu de .pencolor()
absence de la méthode .colormode() et donc pas de possibilité de modifier le mode des coordonnées de couleurs (maximum de chaque composante à 1 ou à 255)
refus des paramètres de couleurs sous forme de tuple, liste ou chaîne de caractères, les fonctions concernée prennent obligatoirement 3 paramètres avec les valeurs de chaque composante
la méthode .circle() ne prend qu'un seul argument et ne gère donc pas les arcs de cercle
absence des méthodes de remplissage
absence de la méthode d'effacement et réinitialisation de la tortue .reset()
absence de la méthode d'écriture de texte .write()
absence de 18 alias courts pour les noms de méthodes
Avec la nouvelle bibliothèque turtle nous tombons à seulement 8 erreurs.
Son code source ne semblerait pas dériver de celui de ce_turtl, puisque certains types d'erreurs disparaissent quand d'autres apparaissent.
Restent donc :
absence de la méthode .color()
absence de la méthode .colormode() et donc pas de possibilité de modifier le mode des coordonnées de couleurs (maximum de chaque composante à 1 ou à 255)
refus des paramètres de couleurs sous forme de liste ou chaîne de caractères, mais les tuples sont acceptés
la méthode .circle() ne prend qu'un seul argument et ne gère donc pas les arcs de cercle
absence de la méthode d'effacement et réinitialisation de la tortue .reset()
absence de la méthode .towards() pour orienter la tortue vers une cible de coordonnées données
absence de 16 alias courts pour les noms de méthodes
Le turtle des TI-Nspire CX II pour sa part ne donne que 5 erreurs. Vu la grande similarité, on pourrait se demander si la nouvelle bibliothèque turtle des TI-83 Premium CE Edition Python et compatibles ne découlerait pas de celui des TI-Nspire CX II, avec juste la suppression des paramètres de couleurs sous forme de chaîne de caractères afin d'économiser un peu de place en heap.
Voici pour référence les résultats du même test chez la concurrence :
Un avantage des Texas Instruments et des Casio, c'est que le contenu de la bibliothèque turtle peut être altéré à l'exécution après importation, et la plupart des erreurs sont ainsi corrigeables !
À nuancer toutefois dans les cas des TI-83 Premium CE Edition Python et compatibles, car vu la faible capacité du heap on ne peut pas non plus envisager de tout corriger sauf à réduire drastiquement l'espace mémoire pour les instructions du script au-delà de l'importation.
Voici un script qu'il suffit d'importer à la place de la bibliothèque turtle de chaque machine, et qui lorsque celle-ci est modifiable corrige la plupart des erreurs détectées :
_fix_color = _color_types & 0b11 != 0b11 or not "colormode" in dir(turtle)
# fix list/tuple color argument if _color_types & 0b11 == 0b10: def _fixcolorlist(c): return type(c) is list and tuple(c) or c turtle._fixcolorlist = _fixcolorlist if _color_types & 0b11 == 0b01: def _fixcolorlist(c): return type(c) is list and list(c) or c turtle._fixcolorlist = _fixcolorlist if not _color_types & 4: def _fixcolorargs(*argv): return len(argv) != 1 and argv or argv[0]
if _fix_color: turtle._color = turtle.color turtle._pencolor = turtle.pencolor turtle._fillcolor = turtle.fillcolor if _color_types & 0b11: def _color(*argv): n = len(argv) if not(n): return turtle._color() elif n==2: turtle._color(argv[0], argv[1]) else: turtle._color(n > 1 and argv or argv[0]) def _pencolor(*argv): if not(len(argv)): return turtle._pencolor() turtle._pencolor(turtle._fixcolor(len(argv) > 1 and argv or argv[0])) def _fillcolor(*argv): if not(len(argv)): return turtle._fillcolor() turtle._fillcolor(turtle._fixcolor(len(argv) > 1 and argv or argv[0])) else: def _color(*argv): n = len(argv) if not(n): return turtle._color() c = turtle._fixcolor(n == 3 and argv or argv[0]) turtle._color(c[0], c[1], c[2]) def _pencolor(*argv): if not(len(argv)): return turtle._pencolor() c = turtle._fixcolor(len(argv)>1 and argv or argv[0]) turtle._pencolor(c[0], c[1], c[2]) def _fillcolor(*argv): if not(len(argv)): return turtle._fillcolor() c = turtle._fixcolor(len(argv)>1 and argv or argv[0]) turtle._fillcolor(c[0], c[1], c[2]) turtle.color = _color turtle.pencolor = _pencolor turtle.fillcolor = _fillcolor
# fix colormode() if _turtle_errors & 8: # test color mode try: turtle.pencolor([255, 0, 0]) _color_mode = 255 except: _color_mode = 1.0 turtle._color_mode = _color_mode def _colormode(*argv): if not(len(argv)): return turtle._color_mode if int(argv[0]) in (1, 255): turtle._color_mode = int(argv[0]) == 255 and 255 or 1.0 turtle.colormode = _colormode if _color_mode == 255: turtle._fixcolorval = lambda c: int(turtle._color_mode) == 1 and type(c) in (list, tuple) and [int(c[k] * 255) for k in range(3)] or c else: turtle._fixcolorval = lambda c: turtle._color_mode == 255 and type(c) in (list, tuple) and [c[k] / 255 for k in range(3)] or c
# fix color strings if len(_colors_fix): def _fixcolorstring(c): if type(c) is str and c in _colors_fix: c = _colors_fix[c] if turtle.colormode() == 255: c = [int(c[k] * 255) for k in range(3)] return c turtle._fixcolorstring = _fixcolorstring
if len(_missing_fct): for f in _missing_fct: exec("turtle."+f+"=nop")
if len(_missing_alias): for aliases in _missing_alias: validf = aliases[0] for f in aliases[1:]: exec(validf and "turtle."+f+"=turtle."+validf or "turtle."+f+"=nop")
# fix clear() if _turtle_errors & 0x2000: turtle.clear = turtle.reset
# fix reset() if _turtle_errors & 0x4000: turtle.reset = turtle.clear
# fix towards() if _turtle_errors & 0x8000: from math import atan2, pi def _towards(x, y): x0, y0 = turtle.pos() return atan2(y - y0, x - x0) * 180 / pi turtle.towards = _towards
Nous pouvons envisager à partir de maintenant d'avoir une unique version de chaque script utilisable sur l'ensemble des machines.
Maintenant que nous avons de quoi faire tourner une unique version de chaque script sur l'ensemble des machines, poursuivons l'exploration de l'ensemble des modules turtle avec quelques exemples de script.
Nous allons en profiter pour nous en donner à cœur joie avec les formidables nouvelles fonctions de remplissage, sur le thème de #LesMathématiquesSontBelles.
Cela va justement être l'occasion de voir si il y a d'autres problèmes qui n'ont pas pu être détectés automatiquement.
Plusieurs des exemples qui vont suivre sont inspirés de publications de Bert Wikkerink pour TI-Nspire CX II et très librement et fortement adaptés pour être fonctionnels dans le contexte du heapPython bien plus restreint des TI-83 Premium CE et compatibles.
C'est donc parti pour quelques exemples afin d'approfondir les améliorations de la nouvelle bibliothèque turtle pour TI-83 Premium CE Edition Python et compatibles, ainsi que les points forts et faibles par rapport aux autres modèles de calculatrices.
Précisons que les problèmes récurrents ne seront pas systématiquement réévoqués sur chaque exemple.
Un petit peu au Nord de Digne-les-bains en rive droite de la Bléone se trouve la dalle aux ammonites. Comme il est strictement interdit d'en prélever, voici de quoi en reproduire une sur ta calculatrice :
Il y avait donc avec ce_turtl un problème d'écart par rapport au standard, un décalage d'une unité lors du réglage de l'épaisseur via la méthode turtle.pensize(). Ici l'appel turtle.pensize(1) produisait l'effet d'un turtle.pensize(2). Et plus généralement un appel turtle.pensize(s) produisait l'effet d'un turtle.pensize(s+1). On peut noter que le problème disparaît avec le nouveau module turtle.[/success][/warning]
KhiCAS et la NumWorks ont un tracé incorrect ici, car la méthode .towards() est absente de leur implémentation de turtle. Et malheureusement, le turtle n'est ici pas altérable à l'exécution ce qui nous empêche de corriger.
L'écran de la Casio Graph 35+E II a une définition très inférieure de seulement 128×64 pixels, et bien évidemment le tracé est donc tronqué. Bien dommage que contrairement à KhiCAS il ne soit ici pas possible de faire défiler le tracé en fin d'exécution...
def rpoly(c, n): for k in range(n): turtle.forward(c) turtle.left(360 / n)
def audi(r): ir = 2 * r // 13 turtle.penup() turtle.left(90) turtle.forward(r//2 - 2*ir) turtle.right(90) turtle.forward(-ir) turtle.pendown() turtle.pensize(3) for i in range(4): turtle.penup() turtle.forward(3 * ir) turtle.pendown() turtle.circle(2 * ir)
def mercedez_benz(r): ir = r // 2 turtle.penup() turtle.forward(ir) turtle.left(90) turtle.forward(ir) turtle.pendown() turtle.pensize(2) x, y = turtle.pos() turtle.setheading(210) for i in range(3): turtle.goto(x,y) turtle.forward(ir) turtle.left(120) turtle.setheading(0) turtle.circle(-ir)
def citroen(r): x,y=turtle.pos() turtle.setheading(0) turtle.color((255,0,0), (255,0,0)) turtle.begin_fill() rpoly(r, 4) turtle.end_fill() turtle.fillcolor((255,255,255)) for i in range(2): turtle.setheading(45) turtle.begin_fill() for k in range(2): turtle.forward(.71 * r) turtle.left(k and 172 or -90) for k in range(2): turtle.forward(5 * r / 6) turtle.left(106) turtle.end_fill() y += r / 3 turtle.penup() turtle.goto(x,y) turtle.pendown()
def mitsubichi(r): ir = r // 3 turtle.penup() turtle.left(90) turtle.forward(ir) turtle.right(90) turtle.forward(r // 2) turtle.pendown() for i in range(3): turtle.setheading(60 + 120*i) turtle.color((255,0,0), (255,0,0)) turtle.begin_fill() for k in range(4): turtle.forward(ir) turtle.left((k%2) and 120 or 60) turtle.end_fill()
def jeep(r): a=54 ir = r/0.47552825814758/4 #sin(radians(a))/cos(radians(a)) a=ir/0.85 d=0.93*ir turtle.penup() turtle.forward(r//2) turtle.right(90) turtle.forward(ir - r) turtle.pendown() x, y = turtle.pos() turtle.setheading(234) turtle.forward(ir) turtle.left(126) turtle.fillcolor((180,180,180)) turtle.begin_fill() rpoly(a, 5) turtle.end_fill() for i in range(5): col = i < 3 and (0,0,0) or (255,255,255) for j in range(2): turn = j and turtle.left or turtle.right turtle.goto(x,y) turtle.setheading(90 + 72*i) turtle.fillcolor(col) turtle.begin_fill() turtle.forward(d) turn(172) turtle.forward(0.85*d) turn(44) turtle.forward(0.2*d) turtle.end_fill() col = [255 - col[k] for k in range(3)]
turtle.speed(0) turtle.colormode(255)
r = 92 for iy in range(2): for ix in range(3): i = iy*3+ix if i < 5: y, x = (2*iy - 1) * r//2 - 48, (ix - 1)*r - 50 turtle.penup() turtle.goto(x, y) turtle.setheading(0) turtle.pensize(1) turtle.pencolor((0,0,0)) turtle.pendown() (mercedez_benz,jeep,mitsubichi,citroen,audi)[i](r)
contrairement au standard, les cercles sont tracés non pas en passant par la position de la tortue, mais en prenant pour centre la position de la tortue
la méthode .circle(r) ne comprend pas les valeurs de rayons négatives pour contrôler le sens de tracé
Mis à part ce dernier point, tout le reste est corrigé avec le nouveau turtle !
Les Casio et NumWorks n'ont pas davantage les méthodes de remplissage de formes. KhiCAS en dispose mais souffre hélas d'un autre bug bien gênant ici ; la couleur de remplissage passé en 2ème paramètre de la méthode .color(,) est apparemment ignorée.
Si tu es dans le Sud de la France tu sais qu'il ne pleut pas souvent (par contre, quand il pleut... il pleut !). Alors voici pour toi un escargot bariolé :
turtle.penup() turtle.goto(0, -20) turtle.pendown() turtle.right(90) for i in range(20): c = [exp(-.5 * ((i - k) / 12)**2) for k in (6, 18, 30)] cb = [v/2 for v in c] turtle.color(cb, c) try: turtle.begin_fill() except: pass turtle.circle(27 + i) try: turtle.end_fill() except: pass turtle.right(10)
De nouveau une véritable catastrophe avec ce_turtl qui semble tracer n'importe quoi et surtout pas ce qui est demandé. Toujours le problème du comportement non standard de la méthode .circle(). Heureusement, le nouveau turtle pour sa part se comporte enfin correctement et conformément au standard.
Par contre, dans le cas particulier du tracé de cercles via la méthode .circle(), le nouveau turtle des TI-83 Premium CE et compatibles semble être incapable de remplir l'intérieur de la forme.
Le turtle des TI-Nspire CX II colorie pour sa part bien l'intérieur des cercles avec la couleur de remplissage, mais oublie de tracer le périmètre avec la couleur du crayon.
Encore une fois si tu es dans le Sud de la France, tu n'a pas dû voir de neige depuis des années... Faison donc neiger dans ta calculatrice maintenant, faisons neiger des flocons de Koch :
c = [127, 255, 0] l = 80 for j in range(2): for i in range(3): n = j and 3 + i or 2 - i s = 5 - n turtle.penup() turtle.goto(i*117-157, j*95-25) turtle.pencolor(tuple(c)) turtle.pensize(s) turtle.setheading(0) turtle.pendown() flock(n, l) n += 1 rotate_list(c)
Cette fois impossible de ne pas le voir, énorme décalage avec ce_turtl dont le tracé part littéralement dans le décor pour le flocon en haut à droite. Heureusement, ce problème est corrigé avec le nouveau turtle.
Par contre, turtle introduit un nouveau problème : le réglage de l'épaisseur du crayon avec .pensize() semble ne pas gérer les valeurs 4 et supérieures, l'épaisseur du tracé retombant alors à 1.
Fort bizarrement les NumWorks et KhiCAS tracent le flocon en haut à droite de la mauvaise couleur, respectivement en noir et blanc.
try: for i in range(-1, 2, 2): turtle.penup() turtle.goto(80*i - ((i > 0) and 40 or 50), 0) turtle.pendown() try: turtle.begin_fill() except: pass spiral((i > 0) and 9 or 30, (i > 0) and 90 or 36, (i > 0) and (1,2,3,4,5,6,7,8,9) or (1,2,3)) try: turtle.end_fill() except: pass except MemoryError as e: print(e)
Dans le cas ici de polygones croisés, on peut remarquer que les turtle de KhiCAS, des TI-Nspire CX II ainsi que des TI-83 Premium CE et compatibles semblent partager le même algorithme de remplissage, un algorithme qui semble différer du standard dans le cas du remplissage de polygones croisés.
Le nouveau turtle des TI-83 Premium CE et compatibles ne termine pas le tracé par manque de mémoire de tas (heap), ne remplissant pas la figure de droite. En effet, à compter de l'appel .begin_fill() toutes les étapes de la tortue sont enregistrées dans une liste, liste qui donnera donc les sommets du polygone à remplir lors de l'appel .end_fill(). Sauf que nous avons extrêmement peu de heap sur les TI-83 Premium CE et compatibles, seulement dans les 17K, déjà lourgement consommés par les bibliothèques chargées ici. Cele fait donc beaucoup trop de sommets à enregistrer.
Partons maintenant à la pêche avec un script très hautement impressionnant par rapport aux contraintes de heap des TI-83 Premium CE et compatibles ; ici nous sommes vraiment sur le fil de la limite des possibilités.
Voici donc une lagogne littéralement pavée de poissons :
KhiCAS semble être dans les choux ici, du moins niveau pavage. Par contre ici les couleurs de remplissage sont correctes, car on utilise la méthode .fillcolor() qui, à la différence de .color(), semble fonctionner correctement.
Les Casio et NumWorks se révèlent incapables de tracer les yeux, car ne disposant pas de la méthode .dot().
Tu n'as jamais touché à un triangle de Penrose ? Et bien voici de quoi en afficher le plan dans ta calculatrice, tu n'auras plus qu'à l'imprimer en 3D, si tu arrives à comprendre où est le devant et l'arrière :
Voici maintenant une belle rosace rhombique pour décorer le bâtiment de ton choix.
Nous utilisons ici la méthode .dot() permettant de remplir un disque, afin de générer de quoi avoir une couleur de fond d'écran sur nos calculatrices, suffit-il juste de lui spécifier un diamètre suffisamment grand pour remplir tout l'écran :
turtle.speed(0) turtle.colormode(255) turtle.pencolor((0,0,255)) turtle.dot(320) turtle.pencolor((0,0,0)) turtle.pensize(2) col = ((255,0,0),(255,255,0),(0,255,0),(255,255,255),(255,0,255)) a=60
for i in range(10): c = col[i%5] turtle.color(c, c) turtle.begin_fill() for j in range(5): turtle.forward(a) turtle.right(72) turtle.end_fill() turtle.right(36)
for i in range(10): c = [v//3 for v in col[i%5]] turtle.pencolor(c) for j in range(5): turtle.forward(a) turtle.right(72) turtle.right(36)
for i in range(4): a=r*sin(alpha)*2 d=a/sqrt(2) turtle.pendown() for i in range(12): turtle.right(15) try: turtle.begin_fill() except: pass carre(d) try: turtle.end_fill() except: pass turtle.left(45) turtle.penup() turtle.forward(a) turtle.pendown() turtle.penup() turtle.left(75) turtle.forward(d) turtle.right(60) r=r*cos(alpha)-a/2
Encore une fois, ce_turtl est complètement dans les choux...
Problème heureusement corrigé avec le nouveau turtle.
Par contre, on note avec la méthode .dot() de turtle le bug déjà évoqué plus haut pour .circle(), à savoir la déformation des disques pour de grands rayons.
Avec la méthode .dot(), les turtle de KhiCAS et des TI-Nspire CX II semblent aussi tracer des disques 2 fois trop grands. Une erreur de codage sans doute, car il ne faut pas confondre. Dans le standard :
Revenons aux fractales et à la récursivité avec les triangles de Sierpiński. As-tu déjà réussi à les compter ? Et bien voici de quoi commencer sur ta calculatrice :
def sierp(n, l): if n == 0: for i in range (0, 3): turtle.forward(l) turtle.left(120) if n > 0: sierp(n - 1, l / 2) turtle.forward(l / 2) sierp(n - 1, l / 2) turtle.backward(l / 2) turtle.left(60) turtle.forward(l / 2) turtle.right(60) sierp(n - 1, l / 2) turtle.left(60) turtle.backward(l / 2) turtle.right(60)
try: # TI-83 Premium CE from ti_system import disp_clr disp_clr() except: pass from ttl_fix import *
def rpoly(c, n): a=360/n for k in range(n): turtle.forward(c) turtle.left(a)
def rosace(c, n1, a, n2): try: turtle.begin_fill() except: pass for i in range(n2): turtle.left(a) rpoly(c, n1) try: turtle.end_fill() except: pass
turtle.colormode(255) turtle.pencolor((0,0,0))
try: turtle.dot(320) except: pass turtle.color((255,255,255),(255,255,0)) turtle.speed(0) turtle.pensize(1) try: for i in range(-1, 2, 2): turtle.penup() turtle.goto(80*i, 0) turtle.pendown() rosace((i > 0) and 21 or 30, (i > 0) and 12 or 8, 30, 12) turtle.pensize(2) turtle.pencolor((0,0,255)) except MemoryError as e: print(e)
À nouveau le heapTI-83 Premium CE et compatibles est insuffisant pour permettre le remplissage, le 1er des 2 remplissages n'aboutissant même pas cette fois-ci.
def spiral(a,b): turtle.pencolor((0,0,0)) try: turtle.dot(320) except: pass turtle.pencolor((255,255,0)) for i in range(189): for j in range(6): turtle.forward(i/a) turtle.left(23) turtle.left(b) try: turtle.dot(2) except: pass
for i in range(2): turtle.color(c[0], c[i]) for h in range(10*i,370,20): r=h * pi / 180 x=d*cos(r) y=d*sin(r) turtle.penup() turtle.goto(x,y) turtle.pendown() turtle.setheading(h) feuille(core,32)
Après l'accident ce_turtl qui était inutilisable en pratique, Texas Instruments nous opère un virage à 180° avec le nouveau module turtle pour TI-83 Premium CE Edition Python et compatibles. La conformité au standard de turtle n'est certes pas parmi les meilleures, mais c'est sans comparaison avec ce que valait ce_turtl. La conformité est très proche de celle des TI-Nspire CX II, et de plus une bonne partie des défauts restants ne sont pas majeurs dans le sens où ils sont aisément contournables sans avoir à écrire de code bien conséquent comme nous avons vu.
Qui plus est Texas Instruments s'offre même le luxe d'aller jusqu'à inclure les méthodes de remplissage de formes, à ce jour une exclusivité toute concurrence confondue. Des possibilités et facilités de tracés largement accrues en conséquence et très au-dessus de la concurrence, de quoi inviter encore plus les élèves à tester et créer !
Décidément #LesMathématiquesSontBelles certes, mais à ce jour particulièrement sur calculatrices Texas Instruments.
Après 2 mois de bêta-test de sa formidable version 17(17.0 puis 17.1), c'est aujourd'hui enfin sa sortie. NumWorks vient en effet de publier la mise à jour 17.2.
Découvrons ou redécouvrons ensemble la superbe collection de nouveautés.
Commençons donc par l'application Fonctions qui bénéficie d'une refonte majeure pour le meilleur, comme le suggère déjà le renommage de l'onglet Fonctions en Expressions.
Jusqu'à présent pour définir les fonctions à étudier, tu pouvais basculer au choix entre 3 formes de saisie à compléter :
Notons qu'un gros avantage de la NumWorks par rapport à la concurrence de milieu de gamme des TI-82/83 était comme illustré ci-contre et comme chez Casio, la possibilité de travailler simultanément sur des fonctions de différents types.
Désormais ce choix disparaît dans le sens où la forme de saisie devient totalement libre, tu contrôles intégralement la relation saisie.
La calculatrice détecte automatiquement le type pertinent de fonction ou courbe correspondant à ta relation saisie, et te l'indique en-dessous.
Cela te permet de saisir les relations sous d'autres formes, soit de plus en plus souvent directement la forme de l'énoncé minimisant ainsi le risque d'erreur !
Tu peux par exemple opter pour la forme
$mathjax$y=…$mathjax$
ou même pour toute relation fonction de x et y.
Cela permet à ta calculatrice d'identifier les relations ayant des représentations graphiques remarquables comme des droites, précisant même dans ce cas si elles sont horizontales ou verticales. Oui en passant, les droites verticales deviennent donc enfin traçables sur NumWorks !
Dans le cas où la calculatrice identifie la relation en tant que droite ni horizontale ni verticale, il t'est possible de demander des détails et obtenir ainsi coefficient directeur et ordonnée à l'origine.
Ne crois pas que la forme entièrement libre implique forcément une saisie plus longue ou fastidieuse ; NumWorks a trouvé la parade. En effet lorsque tu choisis d'ajouter une nouvelle relation à étudier, la calculatrice t'offre la possibilité de choisir parmi une liste d'exemples de relations couvrant les différents types remarquables de fonctions et courbes. Tu peux donc en fonction de tes besoins soit choisir la forme vide et tout saisir toi-même, soit partir d'un des exemples proposés et le modifier.
Puisque la forme de saisie est maintenant totalement libre, le vaste univers des coniques s'offre maintenant à nous.
Nous avons par exemple pour commencer les paraboles. Lorsque la calculatrice détecte une courbe de type parabole, il t'est ici aussi possible de demander quelques détails qui pourront t'être utile pour son étude : paramètre et coordonnées du sommet.
Sont également reconnues et gérées, les hyperboles. Dans ce cas les détails calculés automatiquement sont bien riches :
distance centre-sommet
demi axe conjugué
distance centre-foyer
excentricité
coordonnées du centre
Tout juste peut-on regretter que certaines formes d'écriture des équations d'hyperboles ne soient pas identifiées correctement et soient alors non traçables.
Par exemple
$mathjax$x\times y=3$mathjax$
et
$mathjax$y=\frac{3}{x}$mathjax$
sont traçables, mais pas
$mathjax$x=\frac{3}{y}$mathjax$
.
Sont égalements supportées les équations d'ellipses et donc entre autres de cercles. Dans le cas général des ellipses, les détails d'étude pouvant être obtenus sont :
demi grand axe
demi petit axe
distance centre-foyer
excentricité
coordonnées du centre
Dans le cas particulier du cercle, les détails récupérables sont :
rayon
coordonnées du centre
Les cas particuliers dégénérés des ellipses (point), paraboles (droite) et hyperboles (couple de droites sécantes) ne sont certes pas identifiés mais restent pour autant traçables.
Ce qu'il y a d'excellent jusqu'à présent, c'est que les coniques ne nécessitent pas de lancer une application dédiée mais soient étudiables directement dans la même application que les fonctions, bénéficiant ainsi d'une interface commune et nécessitant ainsi moins d'efforts de prise en main !
Cela va peut-être te surprendre, mais sur le milieu de gamme toute concurrence confondue, c'était impossible jusqu'à ce jour. NumWorks nous sert à nouveau une solution haut de gamme toujours au prix du milieu de gamme !
Mais crois-tu avoir tout vu ? Oh que non jusqu'à présent ce n'était rien, juste des cas particuliers avec les axes de coniques parallèles aux axes du repère, correspondant aux possibilités de modèles de milieu de gamme concurrents.
Or il se trouve que NumWorks va bien plus loin que ça et gère le cas général, contrairement à toute la concurrence de milieu de gamme, Casio/TI réservant ces capacités aux seuls modèles haut de gamme. Une fois de plus félicitations NumWorks pour les rendre ainsi bien plus accessibles !
Voilà, cela semble être à peu près tout à ce jour pour les familles de formes traçables. Notons juste la possibilité de tracer quelques autres relations n'étant pas des coniques, dans le sens où elles ne correspondent pas à la section d'un cone de révolution par un plan. Les formes
$mathjax$y^2=k$mathjax$
ou
$mathjax$x^2=k$mathjax$
sont par exemple acceptées.
Mais nous n'en avons pas terminé pour autant. Jusqu'à présent nous n'avons traité que des égalités. Mais les inégalités sont également gérées, et l'on peut donc enfin les représenter graphiquement !
On apprécie même dans ce cadre la distinction visuelle entre les représentations d'inégalités strictes et non strictes.
L'écran couleur est ici un formidable atout, permettant d'identifier facilement la réunion ou intersection de ces différents ensembles de points.
A priori on pourrait s'attendre à quelque chose d'extrêmement simpliste comme chez la concurrence de milieu de gamme, ne faisant que colorier la zone supérieure ou inférieure à la frontière de l'ensemble.
Et bien non c'est bien plus poussé que ça. Les représentations d'inégalités sont possibles dans le cadre de l'ensemble des formes que nous avons couvertes précédemment, dont aussi bien les droites verticales (intervenant pour les bornes d'intégrales, optimisation, ...) que les coniques !
Encore une fois NumWorks casse complètement les codes en nous offrant une fonctionnalité aussi poussée sur le milieu de gamme !
Une superbe capacité déjà présente sur la NumWorks dans le cadre des représentations graphiques de fonctions, c'est la détermination automatique de la fenêtre graphique la plus pertinente, tentant de rendre visible l'ensemble des éléments remarquables.
Il y avait toutefois un problème qui pouvait arriver lorsque l'on demandait un calcul intégral à partir de la représentation graphique.
En effet la barre d'informations en bas d'écran doublait alors de hauteur, et pouvait alors masquer des éléments remarquables de la représentation graphique, un axe, voir même l'interprétation graphique du résultat. Bien embêtant, d'autant plus qu'à l'écran en question il était impossible de corriger les bornes de la fenêtre sans effacer le calcul et sa représentation.
De plus, lors du choix de bornes de l'intégrale avec les flèches clavier, le fenêtre n'était pas rafraîchie en cas de borne hors fenêtre.
Et bien NumWorks a corrigé la chose en version 17, la fenêtre graphique affichée tenant maintenant compte du changement de hauteur de la barre d'informations !
Et les bornes optimales de la fenêtre sont recalculées en permanence, même par exemple lorsque tu positionnes les bornes de l'intégrale.
Avec cette mise à jour l'application Probabilités bénéficie de possibilités grandement étendues, devenant une application 3 en 1.
À la superbe interface historique d'étude de lois de probabilités, s'ajoutent 2 nouvelles interfaces, le tout étant désormais au choix à l'appel de l'application :
tests statistiques
intervalles de confiance
Personnellement je l'avoue, je n'y connais pas grand, mes études supérieures qui commencent à dater n'ayant à l'époque pas inclus de module statistiques et probabilités. Aussi, les possibilités similaires présentes sur les modèles concurrents, trop souvent avec des abréviations anglophones, m'étaient toujours apparues fort obscures et ne m'avaient pas du tout donné envie de creuser la chose.
Ici NumWorks nous signe une fois encore une interface claire donnant envie de faire des Maths dont il a le secret, prenant le temps et la place pour décrire chaque chose en Français.
Regardons tout-de-suite l'utilisation pour vérifier un exercice de l'ancien programme de Terminale S.
Un fournisseur affirme que, parmi ses cadenas haut de gamme, il n’y a pas plus de 3% de cadenas défectueux dans sa production. Un responsable du magasin de bricolage désire vérifier la validité de cette affirmation dans son stock ; à cet effet, il prélève un échantillon aléatoire de 500 cadenas haut de gamme. Le responsable trouve 19 cadenas défectueux dans l'échantillon prélevé.
Etablir un intervalle de fluctuation asymptotique au seuil de 95% de la proportion attendue de cadenas défectueux dans un tel échantillon.
Au risque de 5%, ce contrôle remet-il en cause l'affirmation du constructeur ?
Pour informations, les réponses attendues sont :
$mathjax$I≈[0,015;0,045]$mathjax$
$mathjax$f=\frac{19}{500}\approx 0,038$mathjax$
Donc
$mathjax$f\in I$mathjax$
et on ne peut rejeter l'affirmation du constructeur au risque de 5%.
Commençons donc par la question 1, avec l'intervalle de fluctuation asymptotique au seuil de 95%.
Rappelons que la NumWorks permettait déjà d'obtenir le résultat via la fonction prediction95(), trouvable dans les menus Probabilités puis Statistiques de la boîte à outils (touche
🧰
).
Maintenant, c'est donc également réalisable dans la nouvelle application Probabilités.
Il faut pour cela choisir l'intervalle z à 1 proportion.
On obtient bien le même résultat attendu, mais surtout ici, on en récupère également une interprétation graphique qui en facilitera grandement la compréhension !
Question 2 maintenant. La prise de décision dans ce contexte nécessite de réaliser un test z à 1 proportion.
On obient bien le résultat attendu, accompagné ici encore d'une interprétation graphique, et même d'une phrase explicative en Français !
Passons maintenant à la boîte à outils commune à l'ensemble des applications intégrées utilisant le moteur mathématique Poincaré(c'est simple, c'est-à-dire toutes les applications sauf Python qui dispose d'une boîte à outils spécifique).
Étais-tu déçu(e) suite au verrouillage de ne plus pouvoir installer Omega pour avoir les constantes physiques ?
Et bien cela tombe bien, car le menu Unités se voit maintenant renommé Unités et constantes. Tu devines ce que cela veut dire ?
Autre grande nouveauté donc de cette version, les constantes physiques directement intégrées au firmware officiel, et donc à nouveau disponibles en mode examen !
Les constantes physique sont accessibles en fin de liste des unités. Comme pour les unités, on les appelle en préfixant leur nom d'un tiret bas (_).
13 constantes sont au menu de cette première version officielle les supportant, soigneusement décrites à chaque fois en Français :
c : vitesse de la lumière dans le vide
e : charge élémentaire
G : constante gravitationnelle
g : accélération de pesanteur (appelable en saisissant _g0, car _g est déjà réservé pour l'unité gramme)
k : constante de Boltzmann
ke : constante de Coulomb
me : masse de l'électron
mn : masse du neutron
mp : masse du proton
Na : constante d'Avogadro
R : constante des gaz parfaits
ε0 : permitivité du vide
μ0 : perméabilité du vide
Les valeurs d'unités alors récupérées sont accompagnées de leurs unités, génial !
On note accessoirement que NumWorks ne fait pas les choses à moitié, les valeurs de constantes physiques semblant être à jour par rapport aux dernières corrections apportées lors du CODATA 2018.
Sinon, petit changement fort appréciable de comportement, désormais la boîte à outil se rouvre automatiquement dans le dernier menu validé.
De quoi te faciliter grandement la saisie par exemple pour des expressions faisant intervenir plusieurs unités ou constantes physiques !
Changement appréciable, l'unité d'angle par défaut passe du degré au radian.
D'origine ou en cas de réinitialisation, la calculatrice est donc immédiatement prête à travailler en radians en Mathématiques ou à tracer des courbes de fonctions trigonométriques.
Un nouveau menu permet enfin de réinitialiser la calculatrice sans avoir à manipuler le bouton reset au dos.
Alternative bien pratique pour les situations où tu n'auras pas d'outil suffisamment fin sous la main.
Passons maintenant au mode examen car là il y a des changements importants. Jusqu'à la version 16, la NumWorks disposait de 2 modes examen. Leur accessibilité dépendait de la zone géographique réglée :
mode examen NL pour le seul réglage de la zone sur les Pays-Bas : clignotement de la diode examen en orange + efface le contenu mémoire + interdit l'application Python + désactive le moteur de calcul exact
mode examen par défaut pour tous les réglages de zone : clignotement de la diode examen en rouge + efface le contenu mémoire (aucun blocage de fonctionalité)
Changement pour le mode examen NL, la gestion des unités ainsi que de la bibliothèque de constantes physiques est maintenant désactivée.
Il devient maintenant possible d'accéder à l'ensemble des modes examen disponibles en réglant la zone sur International. Bien pratique pour les étudiants des établissements internationaux (Écoles européennes, établissements français du réseau AEFE, ...) soumis donc à une réglementation qui n'est pas celle du pays hôte.
On nous ajoute ici 3 nouveaux modes examen :
mode examen IB dédié au Baccalauréat International pour un réglage de la zone sur International : pas de clignotement de la diode examen + efface le contenu mémoire + interdit le calcul vectoriel + désactive les résultats additionnels dans l'applications Calculs + bloque l'accès aux unités et constantes + bloque l'écran d'interprétation des tests statistiques
mode examen Press-to-test pour un réglage de la zone sur Etats-Unis : pas de clignotement de la diode examen + efface le contenu mémoire + permet au surveillant/enseignant qui active le mode de choisir les fonctionnalités à interdire (application Equations, tracé d'inéquations, courbes implicites, informations suite aux régressions, calcul vectoriel, logarithme de base a, opérateur de sommation)
mode examen PT pour un réglage de la zone sur Portugal : clignotement de la diode examen en vert + efface le contenu mémoire
Comme quoi, par rapport à ce mode examen PT, NumWorks n'est pas rancunier après le camouflet monumental infligé par l'Institution portugaise en mars 2021, à savoir :
le refus d'approuver la calculatrice NumWorks pour les examens de la session 2021
après des communications pourtant contraires dans la presse à la rentrée 2020
jetant de plus l'opprobre sur le constructeur sans le nommer mais de façon suffisamment précise en accompagnant la liste de modèles approuvés d'une motivation incriminant la possibilité d'installer des fonctionnalités de calcul formel sur de nouveaux modèles testés (la NumWorks étant le seul modèle récent absent des versions précédentes de la liste, aucun doute possible), l'une des raisons qui a conduit au verrouillage de la version 16
en plus de ne pas approuver la NumWorks au niveau national, tentative d'empêcher également son autorisation à l'échelon local comme jamais vu auparavant, avec la publication d'une interdiction discriminatoire et possiblement illégale des calculatrices développées en open source, interdiction heureusement retirée depuis
En dehors de la couleur de la diode, nous n'avons pas trouvé à ce jour de différence fonctionnelle entre les modes examen FR de la France et PT du Portugal.
Pour t'aider à t'y repérer dans ces différents modes examen, voici un tableau comparatif des fonctionnalités disponibles dans les différents modes examen :
Poursuivons hors boîte à outils avec le reste des changements transversaux.
L'alignement des exposants a été modifié afin d'occuper moins de place verticalement.
Cela te permettra par exemple de visualiser correctement sans défilement sur un même écran, davantage de calculs faisant intervenir des exposants :
Le comportement de la touche
x,n,t
dépendait du contexte dans lequel tu l'utilisais. Elle te permettait de saisir :
t dans l'application Fonctions pour la définition d'une fonction paramétrique
θ dans l'application Fonctions pour la définition d'une fonction polaire
n dans l'application Suites
x dans tous les autres cas
Or, il pouvait arriver que ce comportement ne corresponde pas à tes besoins.
Si il te suffisait pour x, n et t d'aller les chercher au clavier alphabétique avec la touche
alpha
, ce n'était par contre pas le cas pour θ.
Il t'était donc pénible de faire appel à la variable de nom θ pour tes calculs de géométrie ou de Physique-Chimie, ou encore pour l'affichage de messages en Python.
Il fallait déclencher l'afficher d'un θ quelque part, par exemple dans l'application Fonctions ou sinon dans l'application Python avec print(chr(952)), le sélectionner pour le copier avec
shift
var
, puis ensuite seulement le coller où bon te semblait avec
shift
🧰
.
Aujourd'hui NumWorks fournit enfin un début de solution à ce problème.
Peu importe le contexte, si la saisie par défaut de la touche
x,n,t
ne correspond pas à tes besoins, il te suffit de retaper
x,n,t
si besoin plusieurs fois de suite pour basculer entre les autres possibilités de saisie x, n, t et θ.
Pour te suggérer cette nouvelle possibilité, la saisie de la touche est immédiatement mise en surbrillance, te permettant alors de réagir avant de poursuivre ta saisie.
Bien dommage toutefois, cela ne fonctionne pas dans le contexte de l'application Python et ne t'aidera donc pas pour les print().
Terminons par une amélioration qui avait été introduite dès la mise à jour 16.4.0 mais bizarrement non annoncée.
Auparavant il n'était pas possible d'appliquer une fonction à un résultat comportant une unité.
Depuis la version 16.4.0 c'est corrigé pour les fonctions pertinentes de la boîte à outils : abs(), floor(), ceil(), round() et sign().
Le verrouillage exigé par certaines institutions étant maintenant derrière nous, NumWorks semble enfin s'être sérieusement remis au travail dans l'intérêt des utilisateurs, renouant ainsi avec ce qui avait fait son succès sur la période 2017-2020.
Cette version 17 apporte en effet plusieurs évolutions majeures avec dans tous les cas de beaux efforts sur l'intuitivité de l'interface :
saisie libre des relations à tracer
représentation graphique de droites
représentation graphique coniques même dans le cas général
représentation graphique d'inéquations pour toutes les formes précédentes d'équations traçables
constantes physiques avec unités et description
tests statistiques
intervalles de confiance
La NumWorks au prix de milieu de gamme poursuit sa progression disruptive dans le monde des calculatrices graphiques, dans le sens où la plupart de ces fonctionnalités sont très supérieures à ce qu'offre le milieu de game chez la concurrence, et ne trouvent d'équivalent que sur le haut de gamme beaucoup plus cher.
Des efforts semblent donc avoir été faits rapidement pour compenser les fonctionnalités non officielles interdites d'installation suite au verrouillage, notamment pour les constantes physiques.
Après, ce n'est certes pas suffisant.
Comme gros manque, il y aurait encore par exemple l'application de tableau périodique des éléments Omega, ou encore l'application tableur de KhiCAS. Mais il semble justement qu'un tableau périodique vienne enfin d'être mis en projet pour une future mise à jour en version 18.
Et bien évidemment, tant qu'il n'y aura pas de remplaçant au moteur de calcul littéral d'Omega ou encore mieux moteur de calcul formel de KhiCAS, on pourra toujours dire que ce n'est pas suffisant.
Mais terminons donc à ce jour sur une note positive en notant donc ces efforts très significatifs, certes insuffisants selon les besoins, en faisant justement le souhait qu'ils se poursuivent au moins au même rythme.
by 
Texas Instruments a un temps produit des calculatrices graphiques translucides permettant plus ou moins de voir l'intérieur sans avoir à les ouvrir. À la fois une réussite esthétique et un bijou pour les esprits les plus curieux. On peut citer en ce sens la très éphémère TI-83 Plus Silver Edition sortie pour la rentrée 2001. 
Hélas la superbe TI-83 Plus Silver Edition fut arrêtée dès la rentrée 2004 afin de faire de la place pour la sortie des TI-84 Plus et TI-84 Plus Silver Edition. Et ici pas de boîtier translucide, même la version Silver Edition ne s'habillant que de tons de gris totalement opaques.
Toutefois, pour la rentrée 2008 an Amérique du Nord, la chaîne de grande distribution Wal-Mart a commercialisé une édition limitée translucide de la TI-84 Plus, devenue absolument collector de nos jours.
Sur un autre sujet, quand on est habitué aux calculatrices TI-82/83/84 monochromes, on ne peut que tomber amoureux de l'écran éclairé des Casio Graph 75/95 sorties pour la rentrée 2009, une capacité reprise pour la Graph 75+E de la rentrée 2015. 
Et bien aujourd'hui BigMC-OG te propose de fusionner le meilleur des deux mondes ! 
