[critor]

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
• les
  TI-Nspire CX II
  sur lesquelles on peut rajouter une bibliothèque
  turtle
  officielle à l'environnement
  Python
• 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 Instruments

avait 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.

1. Informations et fonctionnement
2. Le tour des menus
3. Premier script comparatif

   (ce_turtl + turtle)
4. Tests de conformité comparatifs

   (tous modèles)
5. 17 exemples comparatifs

   (tous modèles)
   
   
   1. La dalle aux ammonites
   2. Le défilé automobile
   3. L'escargot de lumière
   4. Les flocons de Koch
   5. La linea
   6. Pavage d'une lagogne
   7. Le triangle de Penrose
   8. La courtepointe de Mamie
   9. Les vitraux rhombiques
   10. Les roses par 12
   11. Les triangles de Sierpiński
   12. Sous le soleil exactement
   13. Le labyrinthe du Minotaure
   14. Le carreau de carreaux
   15. Les étoiles jumelles
   16. La toile de l'araignée
   17. ♫ Le tournesol, le tournesol, ... ♫

A) Informations et fonctionnement

Go to top

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
  bytecode
  Python
• 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.

Code: Select all

from ti_image import *
load_image("GRID")
show_image(0, 0)
show_screen()

Cette image sera affichée automatiquement à chaque début d'appel à des fonctions de tracé

turtle

, se comportant donc comme une sorte de fond d'écran.

Code: Select all

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.

B) Le tour des menus

Go to top

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 !

C) Premier script comparatif

(ce_turtl + turtle)

Go to top

Tentons un premier script dessinant une cible :

ce_turtl	turtle
Code: Select all from ce_turtl import * turtle.clear() turtle.goto(0,-95) s = 3 for r in range(0, 159, r):   turtle.circle(r) turtle.show()	Code: Select all 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é...

D) Tests de conformité comparatifs

(tous modèles)

Go to top

Tentons donc un autodiagnostic des différences entres tous les modules

turtle

, c'est-à-dire la vérification de tout ce qui peut différer du standard.

Voici des scripts en ce sens, une amélioration majeure de ceux développés dans le code de notre test de rentrée

QCC 2021

:

ttl_chk.py

ttl_diags.py

Code: Select all

_turtle_errors = 0

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 color argument types
_color_types = 0
try:
  pencolor([0, 0, 0])
  _color_types |= 1 << 0
except: _turtle_error(4)
try:
  pencolor((0, 0, 0))
  _color_types |= 1 << 1
except: _turtle_error(5)
try:
  pencolor(0, 0, 0)
  _color_types |= 1 << 2
except: _turtle_error(6)
try:
  pencolor("black")
  _color_types |= 1 << 3
except: _turtle_error(7)

# 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)

try:
  turtle.position()
except:
  try:
    turtle.pos()
  except:
    _turtle_error(10)

Code: Select all

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

:

TI-83PCE/84+CE ce_turtl	TI-83PCE/84+CE turtle	TI-Nspire CX II turtle

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 :

Casio Graph 90/35+E II	NumWorks	KhiCAS NumWorks TI-Nspire CX II CX

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 :

Code: Select all

from ttl_chk import *
from ttl_chk import _color_types, _turtle_errors, _colors_fix, _missing_fct, _missing_alias

_fix_turtle = True

def nop(*argv): return None
idty = lambda c: c

try: # can turtle be patched ?
  turtle._fixcolorlist = idty
  turtle._fixcolorval = idty
  turtle._fixcolorstring = idty
  turtle._fixcolorargs = idty
  turtle._fixcolor = lambda c: turtle._fixcolorlist(turtle._fixcolorval(turtle._fixcolorstring(turtle._fixcolorargs(c))))
except:
  _fix_turtle = False

if _fix_turtle:

  # fix color() + pencolor()
  if _turtle_errors & 0x1000:
    turtle.fillcolor, turtle.begin_fill, turtle.end_fill = idty, nop, nop
  if _turtle_errors & 2:
    def _pencolor_(*argv):
      if len(argv): turtle.color(argv)
      else: return turtle.color()[0]
    turtle.pencolor = _pencolor_
  if _turtle_errors & 4:
    def _color_(*argv):
      if len(argv) == 2:
        turtle.pencolor(argv[0])
        turtle.fillcolor(argv[1])
      elif len(argv):
        turtle.pencolor(argv)
      else:
        return (turtle.pencolor(), turtle.fillcolor())
    turtle.color = _color_

  _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

  # fix circle(,)
  if _turtle_errors & 0x200:
    turtle._circle = turtle.circle
    def _circle(r, a=360): turtle._circle(r)
    turtle.circle = _circle

  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.

E) 17 exemples comparatifs

(tous modèles)

Go to top

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

heap

Python

bien plus restreint des

TI-83 Premium CE

et compatibles.

1. La dalle aux ammonites
2. Le défilé automobile
3. L'escargot de lumière
4. Les flocons de Koch
5. La linea
6. Pavage d'une lagogne
7. Le triangle de Penrose
8. La courtepointe de Mamie
9. Les vitraux rhombiques
10. Les roses par 12
11. Les triangles de Sierpiński
12. Sous le soleil exactement
13. Le labyrinthe du Minotaure
14. Le carreau de carreaux
15. Les étoiles jumelles
16. La toile de l'araignée
17. ♫ Le tournesol, le tournesol, ... ♫

Exemple n°1 : La dalle aux ammonites

Go to top

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 :

Code: Select all

from ttl_fix import *
from math import pi

turtle.speed(0)
turtle.pencolor((0,0,0))
turtle.pendown()
turtle.pensize(1)

turtle.goto(0,-8)
x,y = turtle.pos()
turtle.left(115)
for i in range(132):
  turtle.forward(10)
  try:
    h = turtle.towards(x,y)
    turtle.setheading(h)
  except: pass
  d=10*pi
  turtle.forward(d)
  turtle.backward(d)
  turtle.right(90)

try: turtle.show() #TI-83 Premium CE
except: pass

TI-83PCE/84+CE turtle	TI-Nspire CX II turtle	Casio Graph 90+E	KhiCAS NumWorks TI-Nspire CX II CX
TI-83PCE/84+CE ce_turtl	NumWorks	Casio Graph 35+E II

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

Exemple n°2 : Le défilé automobile

Go to top

Nous t'emmenons maintenant au défilé automobile, avec les logos de plusieurs grands constructeurs :

Code: Select all

from ttl_fix import *

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)

try: turtle.show() #TI-83 Premium CE
except: pass

TI-83PCE/84+CE turtle	TI-Nspire CX II turtle	Casio Graph 90+E	KhiCAS NumWorks TI-Nspire CX II CX
TI-83PCE/84+CE ce_turtl	NumWorks	Casio Graph 35+E II

ce_turtl

nous révélait ici nombre de problèmes :

• absence des méthodes de remplissage de formes
• 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.

Exemple n°3 : L'escargot de lumière

Go to top

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

Code: Select all

from math import exp
from ttl_fix import *

turtle.speed(0)
turtle.pensize(1)
turtle.colormode(1.0)

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)

try: turtle.show() #TI-83 Premium CE
except: pass

TI-83PCE/84+CE turtle	TI-Nspire CX II turtle	Casio Graph 90+E	KhiCAS NumWorks TI-Nspire CX II CX
TI-83PCE/84+CE ce_turtl	NumWorks	Casio Graph 35+E II

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.

Exemple n°4 : Les flocons de Koch

Go to top

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

:

Code: Select all

from ttl_fix import *

def rotate_list(l):
  l[1:],l[0] = l[0:-1],l[-1]

def koch(n, l):
  if n<=0:
    turtle.forward(l)
  else:
    koch(n - 1, l / 3)
    turtle.left(60)
    koch(n - 1, l / 3)
    turtle.right(120)
    koch(n - 1, l / 3)
    turtle.left(60)
    koch(n - 1, l / 3)

def flock(n, l):
  koch(n, l)
  turtle.right(120)
  koch(n, l)
  turtle.right(120)
  koch(n, l)

turtle.speed(0)
turtle.colormode(255)

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)

try: turtle.show() #TI-83 Premium CE
except: pass

TI-83PCE/84+CE turtle	TI-Nspire CX II turtle	Casio Graph 90+E	KhiCAS NumWorks TI-Nspire CX II CX
TI-83PCE/84+CE ce_turtl	NumWorks	Casio Graph 35+E II

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.

Exemple n°5 : La linea

Go to top

Code: Select all

try: #TI-83 Premium CE
  from ti_system import disp_clr
  disp_clr()
except: pass
from ttl_fix import *

def spiral(k,a,l):
  x0, y0 = turtle.pos()
  h0 = turtle.heading()
  while True:
    for s in l:
      turtle.forward(s*k)
      turtle.left(180-a)
    x, y = turtle.pos()
    if abs(x - x0) + abs(y - y0) + abs(turtle.heading() - h0) <= 1:
      break

turtle.speed(0)
turtle.pensize(1)
turtle.colormode(255)
turtle.color((0,0,0),(255,255,0))

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)

try: turtle.show() #TI-83 Premium CE
except: pass

TI-83PCE/84+CE turtle	TI-Nspire CX II turtle	Casio Graph 90+E	KhiCAS NumWorks TI-Nspire CX II CX
TI-83PCE/84+CE ce_turtl	NumWorks	Casio Graph 35+E II

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.

Exemple n°6 : Pavage d'une lagogne

Go to top

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 :

Code: Select all

from math import sqrt
from ttl_fix import *

turtle.speed(0)
turtle.pensize(1)
turtle.colormode(255)
turtle.pencolor((0,0,0))

a=16

try:
  j = 0
  while -5 < j < 4:
    col = ((0,0,255),(255,0,0),(255,180,0))[j%3]
    i = 0
    while -2 + (j % 2) < i < 2:
      for c in range(3):
        turtle.penup()
        turtle.goto(sqrt(3)*3*a*(i*2-(j%2)), 3*a*j)
        turtle.setheading(-30 + 120*c)
        turtle.pendown()
        turtle.fillcolor(col)
        turtle.begin_fill()
        for k in range(-17, 18):
          l = a*sqrt(7)
          tf = ((1,141.787), (0,l), (1,-100.893), (0,a), (1,120), (0,a/2), [1,-120], [0,-a], [0,a], [1,120], (0,a/2), (1,60), (0,a), (1,-120), (0,a), (1,100.893), (0,l), [1,-40.893])[abs(k)]
          if k==6 or k==9 or k==17: tf[1] -= 180
          elif k==7 or k==8: tf[1] *= -1
          (turtle.forward, turtle.left)[tf[0]](tf[1])
        turtle.end_fill()
        turtle.forward(6*a)
        turtle.backward(5*a)
        turtle.penup()
        turtle.right(90)
        l = a*sqrt(3)/6
        for k in range(2):
          turtle.forward(l)
          turtle.pencolor((255,255,255))
          turtle.dot(a//4)
          turtle.pencolor((0,0,0))
          turtle.dot(a//8)
          turtle.backward(l)
          turtle.left(180)
      i = -i + (i <= 0)
    j = -j - (j >= 0)
except Exception as e: print(e)

try: turtle.show() #TI-83 Premium CE
except: pass

TI-83PCE/84+CE turtle	TI-Nspire CX II turtle	Casio Graph 90+E	KhiCAS NumWorks TI-Nspire CX II CX
TI-83PCE/84+CE ce_turtl	NumWorks	Casio Graph 35+E II

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()

.

Exemple n°7 : Le triangle de Penrose

Go to top

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 :

Code: Select all

from math import sqrt
from ttl_fix import *

def hook(a, c):
  turtle.penup()
  turtle.goto(0,-15)
  turtle.setheading(a)
  turtle.forward((l - 4*b) / sqrt(3))
  turtle.right(150)
  turtle.pendown()
  lf = ((turtle.left, 60),[turtle.forward,b],(turtle.left,120),(turtle.forward,l-b),[turtle.right,120],[turtle.forward,l-3*b])
  try:
    turtle.fillcolor(c)
    turtle.begin_fill()
  except: pass
  for k in range(-len(lf) + 1, len(lf)):
    tf = lf[abs(k)]
    if k == 1: tf[1] = l
    elif k == 4: tf[0] = turtle.left
    elif k == 5: tf[1] = b
    tf[0](tf[1])
  try: turtle.end_fill()
  except: pass
 
turtle.speed(0)
turtle.pensize(2)
turtle.colormode(255)

l=180
b=23

for i in range(112):
  turtle.pencolor(232 - int(i * 23 / 11), 249 - int(i * 29 / 55), 255)
  turtle.penup()
  turtle.goto(-192, 111 - 2*i)
  turtle.pendown()
  turtle.forward(384)

turtle.pencolor((0,0,0))
turtle.pensize(1)

hook(330, (255,255,0))
hook(90, (0,0,255))
hook(210, (255,0,0))

try: turtle.show() #TI-83 Premium CE
except: pass

TI-83PCE/84+CE turtle	TI-Nspire CX II turtle	Casio Graph 90+E	KhiCAS NumWorks TI-Nspire CX II CX
TI-83PCE/84+CE ce_turtl	NumWorks	Casio Graph 35+E II

C'est cette fois-ci

ce_turtl

dont le tracé ne ressemblait à rien d'attendu...
Heureusement, le problème est corrigé avec le nouveau

turtle

.

Exemple n°8 : La courtepointe de Mamie

Go to top

Voici maintenant la courtepointe brodée avec amour et soin par Mamie :

Code: Select all

from ttl_fix import *

def rotate_list(l):
  l[1:],l[0] = l[0:-1],l[-1]

def poly_reg_a(l, a):
  h0 = turtle.heading()
  while True:
    turtle.forward(l)
    turtle.left(a)
    if abs(h0 - turtle.heading()) < .1:
      break

turtle.hideturtle()
turtle.speed(0)
turtle.pensize(1)
turtle.colormode(255)

c = [191, 127, 0]
cf = [127, 255, 0]
i = 0
while i > -3:
  j = 0
  while j > -2:
    turtle.penup()
    turtle.goto((i - 1)*88, (j - 1)*85 + 28)
    turtle.pendown()
    turtle.color(c, cf)
    try: turtle.begin_fill()
    except: pass
    poly_reg_a(80, 140)
    try: turtle.end_fill()
    except: pass
    rotate_list(c)
    rotate_list(cf)
    j = -j + (j <= 0)
  i = -i + (i <= 0)

try: turtle.show() #TI-83 Premium CE
except: pass

TI-83PCE/84+CE turtle	TI-Nspire CX II turtle	Casio Graph 90+E	KhiCAS NumWorks TI-Nspire CX II CX
TI-83PCE/84+CE ce_turtl	NumWorks	Casio Graph 35+E II

Exemple n°9 : Les vitraux rhombiques

Go to top

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 :

Code: Select all

from ttl_fix import *

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)

try: turtle.show() #TI-83 Premium CE
except: pass

TI-83PCE/84+CE turtle	TI-Nspire CX II turtle	Casio Graph 90+E	KhiCAS NumWorks TI-Nspire CX II CX
TI-83PCE/84+CE ce_turtl	NumWorks	Casio Graph 35+E II

Exemple n°10 : Les roses par 12

Go to top

Voici maintenant une rose, cette fois-ci sur un fond d'écran en dégradé radial. Nous utiliserons pour cela une boucle de

.dot()

:

Code: Select all

from math import pi, sin, cos, sqrt
from ttl_fix import *

def rpoly(c, n):
  a=360/n
  for k in range(n):
    turtle.forward(c)
    turtle.left(a)
def carre(c): rpoly(c, 4)

turtle.speed(0)
turtle.colormode(255)
turtle.penup()

r=80
alpha=(15 * pi / 180)

for i in range(320):
  c=int(255/320*i)
  turtle.pencolor(c,c,c)
  try: turtle.dot(320-i)
  except: pass

turtle.goto(20,-76)
turtle.color((255,255,255),(0,0,0))

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

try: turtle.show() #TI-83 Premium CE
except: pass

TI-83PCE/84+CE turtle	TI-Nspire CX II turtle	Casio Graph 90+E	KhiCAS NumWorks TI-Nspire CX II CX
TI-83PCE/84+CE ce_turtl	NumWorks	Casio Graph 35+E II

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 :

• .circle()
  attend le rayon du cercle à tracer
• .dot()
  attend le diamètre du disque à remplit

Exemple n°11 : Les triangles de Sierpiński

Go to top

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 :

Code: Select all

from ttl_fix import *

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)

turtle.colormode(255)
turtle.speed(0)
turtle.pensize(1)

turtle.penup()
turtle.goto(-110, -95)
turtle.pendown()
turtle.pencolor((255,0,0))
sierp(6, 220)
turtle.penup()
turtle.forward(400)

try: turtle.show() #TI-83 Premium CE
except: pass

TI-83PCE/84+CE turtle	TI-Nspire CX II turtle	Casio Graph 90+E	KhiCAS NumWorks TI-Nspire CX II CX
TI-83PCE/84+CE ce_turtl	NumWorks	Casio Graph 35+E II

Exemple n°12 : Sous le soleil exactement

Go to top

Plaçons-nous maintenant

sous le soleil exactement

, profitant ainsi de toutes les couleurs de la lumière blanche :

Code: Select all

from math import exp
from ttl_fix import *

def rpoly(c, n):
  a=360/n
  for k in range(n):
    turtle.forward(c)
    turtle.left(a)
def carre(c): rpoly(c, 4)

turtle.speed(0)
turtle.pensize(1)
turtle.colormode(1.0)

n = 36
for i in range(n):
  k=.4 + 4*i/255
  cp = [.7*exp(-.5 * ((n - i - k) / (n / 3))**2) for k in (6, 18, 30)]
  turtle.pencolor(cp)
  try:
    turtle.fillcolor((k,k,0))
    turtle.begin_fill()
  except: pass
  carre(60)
  try: turtle.end_fill()
  except: pass
  turtle.right(360 / n)

try: turtle.show() #TI-83 Premium CE
except: pass

TI-83PCE/84+CE turtle	TI-Nspire CX II turtle	Casio Graph 90+E	KhiCAS NumWorks TI-Nspire CX II CX
TI-83PCE/84+CE ce_turtl	NumWorks	Casio Graph 35+E II

Exemple n°13 : Le labyrinthe du Minotaure

Go to top

Explorons maintenant dans la labyrinthe du Minotaure :

Code: Select all

from ttl_fix import *

turtle.speed(0)
turtle.colormode(255)
turtle.pendown()

turtle.right(48)
turtle.pencolor((0,0,0))
for i in range(98):
  turtle.forward(2*i)
  turtle.left(90.5)

try: turtle.show() #TI-83 Premium CE
except: pass

TI-83PCE/84+CE turtle	TI-Nspire CX II turtle	Casio Graph 90+E	KhiCAS NumWorks TI-Nspire CX II CX
TI-83PCE/84+CE ce_turtl	NumWorks	Casio Graph 35+E II

Exemple n°14 : Le carreau de carreaux

Go to top

Code: Select all

from math import sqrt
from ttl_fix import *

def rotate_list(l):
  l[1:],l[0] = l[0:-1],l[-1]

def reg_poly(l, n):
  for i in range(n):
    turtle.forward(l)
    turtle.left(360/n)

def square(l):
  reg_poly(l, 4)

turtle.colormode(255)
turtle.pencolor(0,0,0)
turtle.speed(0)

turtle.pensize(3)
d=190
c=[0,255,127]
turtle.penup()
turtle.goto(-d/2,-d/2)
turtle.setheading(0)
turtle.pendown()
for i in range(8):
  try:
    turtle.fillcolor(tuple(c))
    turtle.begin_fill()
  except: pass
  square(d)
  try:
    turtle.end_fill()
  except: pass
  turtle.penup()
  turtle.forward(d/2)
  turtle.left(45)
  turtle.pendown()
  d/=sqrt(2)
  rotate_list(c)

try: turtle.show() #TI-83 Premium CE
except: pass

TI-83PCE/84+CE turtle	TI-Nspire CX II turtle	Casio Graph 90+E	KhiCAS NumWorks TI-Nspire CX II CX
TI-83PCE/84+CE ce_turtl	NumWorks	Casio Graph 35+E II

Grosse erreur de tracé ici encore avec

ce_turtle

, heureusement corrigée avec le nouveau

turtle

.

Exemple n°15 : Les étoiles jumelles

Go to top

Code: Select all

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)

try: turtle.show() #TI-83 Premium CE
except: pass

TI-83PCE/84+CE turtle	TI-Nspire CX II turtle	Casio Graph 90+E	KhiCAS NumWorks TI-Nspire CX II CX
TI-83PCE/84+CE ce_turtl	NumWorks	Casio Graph 35+E II

À nouveau le

heap

TI-83 Premium CE

et compatibles est insuffisant pour permettre le remplissage, le 1^er des 2 remplissages n'aboutissant même pas cette fois-ci.

Exemple n°16 : La toile de l'araignée

Go to top

Suivons maintenant le fil de l'araignée :

Code: Select all

from ttl_fix import *

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
   
turtle.speed(0)
turtle.colormode(255)
turtle.pensize(1)

a=17
b=194

spiral(a,b)

try: turtle.show() #TI-83 Premium CE
except: pass

TI-83PCE/84+CE turtle	TI-Nspire CX II turtle	Casio Graph 90+E	KhiCAS NumWorks TI-Nspire CX II CX
TI-83PCE/84+CE ce_turtl	NumWorks	Casio Graph 35+E II

Exemple n°17 : ♫ Le tournesol, le tournesol, ... ♫

Go to top

Terminons enfin avec un exemple absolument bluffant de réalisme pour du

turtle

, faisons pousser un tournesol :

Code: Select all

from math import pi, sin, cos, sqrt
from ttl_fix import *

def spiral():
  phi = (1+sqrt(5))/2
  a  =0
  r = 0
  dr = 0.15
  turtle.penup()
  for i in range(300):
    turtle.forward(r)
    turtle.pencolor((0,0,0))
    try: turtle.dot(3)
    except: pass
    turtle.pencolor((205,133,63))
    try: turtle.dot(2)
    except: pass
    turtle.goto(0,0)
    turtle.setheading(0)
    a+=360/phi
    turtle.right(a)
    if a>=360:
      r+=dr
      a-=360   

def feuille(core,a):
    try: turtle.begin_fill()
    except: pass
    turtle.right(a/2)
    turtle.forward(core)
    turtle.left(a)
    turtle.forward(core)
    turtle.left(180-a)
    turtle.forward(core)
    turtle.left(a)
    turtle.forward(core)
    try: turtle.end_fill()
    except: pass

turtle.speed(0)
turtle.colormode(255)
turtle.pencolor((30,144,255))
try: turtle.dot(320)
except: pass

d=25
core=40
turtle.pencolor((160,82,45))
try: turtle.dot(40)
except: pass

c=((255,215,0),(255,255,0))

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)

spiral()

try: turtle.show() #TI-83 Premium CE
except: pass

TI-83PCE/84+CE turtle	TI-Nspire CX II turtle	Casio Graph 90+E	KhiCAS NumWorks TI-Nspire CX II CX
TI-83PCE/84+CE ce_turtl	NumWorks	Casio Graph 35+E II

Conclusion

Go to top

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

.

Téléchargements

Go to top

• turtle
  Français English
• pack de mises à jour
  5.7
  pour
  TI-83 Premium CE
  TI-84 Plus CE
  , ou séparément :
  
  • Système 5.7
    pour
    TI-83 Premium CE
    TI-84 Plus CE
  • Application Python 5.7
    (nécessite le système

    5.7

    pour fonctionner)
  • tracé par pixels ou dans un repère ti_draw ti_image

[critor]

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.

Sommaire

1. Appli Fonctions
2. Appli Probabilités
3. Appli Calculs
4. Boîte à outils
5. Appli Paramètres
6. Transversal
7. Conclusion

1) Appli Fonctions

Go to top

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 :

• $mathjax$f(x)=…$mathjax$
  pour les fonctions cartésiennes
• $mathjax$f(θ)=…$mathjax$
  pour les fonctions polaires
• $mathjax$f(t)=\left[\begin{array}{}…\\…\end{array}\right]$mathjax$
  pour les fonctions paramétriques

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.

2) Appli Probabilités

Go to top

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.

Pour les tests, tu as donc au choix :

• 2 tests
  t
  : 1 moyenne, 2 moyennes
• 4 tests
  z
  : 1 moyenne, 2 moyennes, 1 proportion, 2 proportions
• test
  χ²

Pour les intervalles de confiance, sont au choix :

• 2 intervalles
  t
  : 1 moyenne, 2 moyennes
• 4 intervalles
  z
  : 1 moyenne, 2 moyennes, 1 proportion, 2 proportions

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é.

1. Etablir un intervalle de fluctuation asymptotique au seuil de
   95%
   de la proportion attendue de cadenas défectueux dans un tel échantillon.
2. Au risque de
   5%
   , ce contrôle remet-il en cause l'affirmation du constructeur ?

Pour informations, les réponses attendues sont :

1. $mathjax$I≈[0,015;0,045]$mathjax$
2. $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 !

3) Appli Calculs

Go to top

Tu es encore là après tout ça ? Accordons-nous une petite pause avant de reprendre, car les grandes nouvelles ne sont pas terminées.

L'application

Calculs

dispose maintenant d'un raccourci permettant de vider facilement et rapidement l'historique :

shift

⌫

.

4) Boîte à outils

Go to top

🧰

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
• k_e
  : constante de Coulomb
• m_e
  : masse de l'électron
• m_n
  : masse du neutron
• m_p
  : masse du proton
• Na
  : constante d'Avogadro
• R
  : constante des gaz parfaits
• ε₀
  : permitivité du vide
• μ₀
  : 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 !

5) Appli Paramètres

Go to top

Passons maintenant à l'application

Paramètres

.

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 :

Mode examen	FR	NL	PT	IB	PTT
Diode examen	rouge	orange	verte
Contenu mémoire préexistant	Interdit	Interdit	Interdit	Interdit	Interdit
Calcul exact irrationnels	Autorisé	Interdit	Autorisé	Autorisé	Autorisé
Calcul vectoriel	Autorisé	Autorisé	Autorisé	Interdit	Désactivable
Unités + constantes	Autorisé	Interdit	Autorisé	Interdit	Autorisé
Logarithme base a	Autorisé	Autorisé	Autorisé	Autorisé	Désactivable
Opérateur sommation Σ	Autorisé	Autorisé	Autorisé	Autorisé	Désactivable
Appli Equations	Autorisé	Autorisé	Autorisé	Autorisé	Désactivable
Graphes inégalités	Autorisé	Autorisé	Autorisé	Autorisé	Désactivable
Graphes implicites	Autorisé	Autorisé	Autorisé	Autorisé	Désactivable
Appli Python	Autorisé	Interdit	Autorisé	Autorisé	Autorisé
Interprétation tests statistiques	Autorisé	Autorisé	Autorisé	Interdit	Autorisé
Interprétation régressions	Autorisé	Autorisé	Autorisé	Autorisé	Désactivable

6) Transversal

Go to top

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()

.

Conclusion

Go to top

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 officiel 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.

Liens

:

• Mise à jour
  (suivre les instructions)
• Simulateur en ligne
• Application
  NumWorks
  pour
  Android
  /
  iPhone/iPad
• Code source

[SlyVTT]

Lors d'une news précédente, nous vous informions de la réalisation en cours d'un puzzle game intitulé

Magic Light

sur

Casio Graph 90+E

par SlyVTT en remerciement du gain de cette machine lors du concours de rentrée 2021.

L'idée du jeu étant aussi fortement liée au thème du concours d'Automne de Planète Casio CPC #28 qui se résumait en un simple mot :

GLACIAL

et pour lequel un prototype de test avait été implémenté.

Le développement de

Magic Light

est désormais terminé, et nous sommes heureux de vous en faire une brève présentation, accompagnée de quelques infos supplémentaires.

En effet, depuis la précédente information, de l'eau a coulé sous les ponts, et le développement de la version 1.0 de Magic Light s'est accompagné de la réécriture du jeu pour le rendre compatible avec les TI nSpire CX/CX-II.

Ce n'est donc pas

une

release que nous annonçons aujourd'hui, mais

deux

. Oui Madame, vous avez bien entendu, deux versions pour le prix d'une seule.

• Magic Light v1.0A pour Casio Graph 90+E téléchargeable ici http://ti-pla.net/a2831121
• Magic Light v1.0A pour TI nSpire CX/CX-II (firmware <5.3.0 pour profiter de Ndless) téléchargeable ici http://ti-pla.net/a2832368

Magic Light est un puzzle game et pour le coup une création originale tirant pleinement profit des écrans couleurs de la Graph 90+E et de la TI nSpire CX/CX-II comme nous allons le voir ensemble. Après un menu d'accueil stylé et animé, entrons donc dans le vif du sujet.

Une démo du gameplay sur Graph 90+E est disponible via cette petite vidéo capturé sur l'émulateur :

En tant que héro du jeu, tu te dois ici d'arpenter les différentes salles d'un donjon ... à la recherche des fragments de lumière dérobés aux villageois par le Sorcier Noir et ses 4 Magiciennes de Filles ... afin de ramener couleurs et joie disparues au village. Pour cela, tu dois te rendre dans le chateau forteresse du Magicien où il a caché son butin.

Mais les portes sont fermées et ne peuvent s'ouvrir que si tu résous le puzzle de lumière que te posera chaque salle. Autour de chaque salle sont donc disposés des portes ainsi que des capteurs réagissant à certaines couleurs. Chaque porte est connectée à un certain nombre de capteurs, de 1 à 3, et ne s'ouvre que si ils sont tous éclairés simultanément par les bonnes couleurs.

Pour cela tu disposes dans chaque salle de plusieurs éléments déplaçables avec les touches fléchées du clavier, après les avoir sélectionnés avec les touches ad-hoc correspondant au menu de bas d'écran :

• le personnage à faire sortir de la salle
• une boule de cristal émettant une lumière blanche, initialement au centre
• les blocs filtrant la lumière et ne laissant passer que certaines couleurs : les blocs rouge, vert, bleu et noir

Pour savoir quels capteurs sont associés à une porte, il te faut les éclairer. Un indicateur s'allumera alors au-dessus des portes concernées.



Bien entendu, le château grouille de monstres en tout genre et le Sorcier ainsi que les Magiciennes feront tout pour te dissuader de reprendre leur butin et le ramener au village. Il te faudra donc faire preuve de prudence et de dextérité en plus de jugeote pour traverser cette épreuve.

Le moteur physique codé pour le jeu permet de projeter la forme correcte des faisceaux lumineux sur les murs et les obstacles, mais pas seulement :

• selon les niveaux, des blocs fixes peuvent également être présents et bloquer le passage de la lumière
• et les blocs filtrant la lumière peuvent être combinés pour former de nouvelles couleurs par synthèse additive

Il vous faudra donc réfléchir à deux fois pour positionner tout ce petit monde à la bonne place, sachant les monstres sont là pour vous embêter et ne vous veulent pas forcément que du bien.
Et il ne faudra pas oublier de ramasser les trésors, vous y trouverez des points de vie pour récupérer de la santé, mais aussi des points pour augmenter votre score, et surtout, n'oublions pas le plus important, les fragments de couleurs à récupérer pour sauver le village ...



Les menus devraient être assez clairs pour vous permettre de jouer simplement.

Le jeu offre 3 niveaux de difficulté :

• facile : avec 5 points de vie, permet de ne pas galérer
• normal : avec 3 points de vie, permet de mieux ressentir la pression des monstres
• hardcore : c'est simple, t'es touché ... t'es mort !!

Il vous faudra donc réussir à parcourir les

33 niveaux

du jeu et affronter 1000 dangers afin de retrouver les

5 fragments du "Jewel of Colors"

et ainsi rapporter la lumière et les couleurs aux villageois.


Bien entendu les deux versions ne sont pas strictement similaires, les machines ayant des spécificité techniques très différentes. Néanmoins, comme visible sur les captures suivantes d'écran issues de la version nSpire, le design a été ajusté au mieux pour adapter le jeu le plus fidèlement possible à la TI nSpire.

Nous vous souhaitons un très bon moment sur

Magic Light

, en espèrant que vous saurez rapporter la couleur au village.

[SlyVTT]

Lors d'une news précédente, nous vous informions de la réalisation en cours d'un puzzle game intitulé

Magic Light

sur

Casio Graph 90+E

par SlyVTT en remerciement du gain de cette machine lors du concours de rentrée 2021.

L'idée du jeu étant aussi fortement liée au thème du concours d'Automne de Planète Casio CPC #28 qui se résumait en un simple mot :

GLACIAL

et pour lequel un prototype de test avait été implémenté.

Le développement de

Magic Light

est désormais terminé, et nous sommes heureux de vous en faire une brève présentation, accompagnée de quelques infos supplémentaires.

En effet, depuis la précédente information, de l'eau a coulé sous les ponts, et le développement de la version 1.0 de Magic Light s'est accompagné de la réécriture du jeu pour le rendre compatible avec les TI nSpire CX/CX-II.

Ce n'est donc pas

une

release que nous annonçons aujourd'hui, mais

deux

. Oui Madame, vous avez bien entendu, deux versions pour le prix d'une seule.

• Magic Light v1.0A pour Casio Graph 90+E téléchargeable ici http://ti-pla.net/a2831121
• Magic Light v1.0A pour TI nSpire CX/CX-II (firmware <5.3.0 pour profiter de Ndless) téléchargeable ici http://ti-pla.net/a2832368

Magic Light est un puzzle game et pour le coup une création originale tirant pleinement profit des écrans couleurs de la Graph 90+E et de la TI nSpire CX/CX-II comme nous allons le voir ensemble. Après un menu d'accueil stylé et animé, entrons donc dans le vif du sujet.

Une démo du gameplay sur Graph 90+E est disponible via cette petite vidéo capturé sur l'émulateur :

En tant que héro du jeu, tu te dois ici d'arpenter les différentes salles d'un donjon ... à la recherche des fragments de lumière dérobés aux villageois par le Sorcier Noir et ses 4 Magiciennes de Filles ... afin de ramener couleurs et joie disparues au village. Pour cela, tu dois te rendre dans le chateau forteresse du Magicien où il a caché son butin.

Mais les portes sont fermées et ne peuvent s'ouvrir que si tu résous le puzzle de lumière que te posera chaque salle. Autour de chaque salle sont donc disposés des portes ainsi que des capteurs réagissant à certaines couleurs. Chaque porte est connectée à un certain nombre de capteurs, de 1 à 3, et ne s'ouvre que si ils sont tous éclairés simultanément par les bonnes couleurs.

Pour cela tu disposes dans chaque salle de plusieurs éléments déplaçables avec les touches fléchées du clavier, après les avoir sélectionnés avec les touches ad-hoc correspondant au menu de bas d'écran :

• le personnage à faire sortir de la salle
• une boule de cristal émettant une lumière blanche, initialement au centre
• les blocs filtrant la lumière et ne laissant passer que certaines couleurs : les blocs rouge, vert, bleu et noir

Pour savoir quels capteurs sont associés à une porte, il te faut les éclairer. Un indicateur s'allumera alors au-dessus des portes concernées.



Bien entendu, le château grouille de monstres en tout genre et le Sorcier ainsi que les Magiciennes feront tout pour te dissuader de reprendre leur butin et le ramener au village. Il te faudra donc faire preuve de prudence et de dextérité en plus de jugeote pour traverser cette épreuve.

Le moteur physique codé pour le jeu permet de projeter la forme correcte des faisceaux lumineux sur les murs et les obstacles, mais pas seulement :

• selon les niveaux, des blocs fixes peuvent également être présents et bloquer le passage de la lumière
• et les blocs filtrant la lumière peuvent être combinés pour former de nouvelles couleurs par synthèse additive

Il vous faudra donc réfléchir à deux fois pour positionner tout ce petit monde à la bonne place, sachant les monstres sont là pour vous embêter et ne vous veulent pas forcément que du bien.
Et il ne faudra pas oublier de ramasser les trésors, vous y trouverez des points de vie pour récupérer de la santé, mais aussi des points pour augmenter votre score, et surtout, n'oublions pas le plus important, les fragments de couleurs à récupérer pour sauver le village ...



Les menus devraient être assez clairs pour vous permettre de jouer simplement.

Le jeu offre 3 niveaux de difficulté :

• facile : avec 5 points de vie, permet de ne pas galérer
• normal : avec 3 points de vie, permet de mieux ressentir la pression des monstres
• hardcore : c'est simple, t'es touché ... t'es mort !!

Il vous faudra donc réussir à parcourir les

33 niveaux

du jeu et affronter 1000 dangers afin de retrouver les

5 fragments du "Jewel of Colors"

et ainsi rapporter la lumière et les couleurs aux villageois.


Bien entendu les deux versions ne sont pas strictement similaires, les machines ayant des spécificité techniques très différentes. Néanmoins, comme visible sur les captures suivantes d'écran issues de la version nSpire, le design a été ajusté au mieux pour adapter le jeu le plus fidèlement possible à la TI nSpire.

Nous vous souhaitons un très bon moment sur

Magic Light

, en espèrant que vous saurez rapporter la couleur au village.

[critor]

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

Ndless

.

Te souviens-tu également de notre cher et très prolifique

gameblabla

? 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.

Et bien aujourd'hui

gameblabla

nous emmène pour une fois sur le chemin inverse ; il vient de réaliser un portage de

Crafti

pour la console de jeux

Microsoft Xbox

!

Ndless

ayant hélas cessé d'être adapté aux nouvelles mises à jour

TI-Nspire CX

depuis bientôt une année, retrouve donc maintenant sur ta

Xbox

les joies et plaisirs des

TI-Nspire Ndlessées

:

Téléchargements

:

• Crafti Xbox
• Crafti TI-Nspire

[critor]

Omega

était un

firmware

alternatif pour ta calculatrice

NumWorks

. Basé sur le code source du

firmware

officiel

Epsilon

comme la licence l'autorisait,

Omega

avait pour but de regrouper et mettre en avant les meilleures contributions au code d'

Epsilon

, en incluant justement celles ignorées ou refusées par le constructeur.

Difficile de tout citer ici mais voici déjà par exemple un des fantastiques ajouts d'

Omega

. La

NumWorks

travaille en interne sur des arbres de calcul, mais n'accepte que des valeurs numériques.

Omega

étendait ces arbres en autorisant également des lettres / inconnues, ce qui nous donnait ainsi un moteur de calcul littéral. De quoi même dériver, du jamais vu à seulement

80€

!
Il y avait aussi un tableau périodique des éléments, ou encore

100K

de mémoire

heap

pour tes projets

Python

au lieu de

32K

!

Outre ce qu'il intégrait,

Omega

offrait également l'avantage de pouvoir installer à chaud des applications. Plusieurs applications de très haute facture furent développées, on peut citer entre autres :

• KhiCAS
  , une formidable application intégrée de Mathématiques et de Sciences par
  Bernard Parisse
  , enseignant-chercheur à l'Université de Grenoble, qui étendait gratuitement les capacités de ta calculatrice au niveau d'une
  HP Prime
  . L'application intégrait le moteur de calcul formel
  GIAC
  développé pour le logiciel
  Xcas
  du même auteur pour des possibilités en calcul encore plus étendues. Étaient également inclus un tableur, une bibliothèque de constantes physiques, un convertisseur d'unités, un tableau périodique des éléments et bien d'autres choses encore. Le tout était en prime programmable en
  Python
  , avec une collection de modules importables bien plus étoffée que celle de l'application
  Python
  officielle, et surtout ici de façon intégrée, tes scripts
  Python
  pouvant en effet faire appel au moteur de calcul formel
  GIAC
  par l'intermédiaire du module
  cas
  .
• Nofrendo
  , un émulateur de console de jeux
  Nintendo NES
  par
  zardam
• Peanut-GB
  , un émulateur de console de jeux
  Nintendo GameBoy
  par
  M4x1m3
• Periodic
  , un tableau périodique des éléments par
  M4x1m3

Un gros avantage de plus était ici que

KhiCAS

et l'ensemble des fonctionnalités rajoutées restaient accessibles en mode examen, de façon parfaitement légale et légitime en France, puisque ces fonctionnalités venaient directement intégrées à des modèles concurrents haut de gamme parfaitement autorisés.

Hélas pour cette rentrée 2021,

NumWorks

a brutalement pris un virage ultra-sécuritaire. Toute mise à jour en version

16.3.0

ou supérieure verrouille définitivement ta calculatrice

NumWorks N0110

contre l'

installation

de tout code tiers, et ce sans même que tu en sois prévenu(e) sur la page concernée.

En conséquence, nous t'annoncions il y a quelques semaines le cœur serré l'abandon officiel du projet

Omega

.

Dans un premier temps nous t'annoncions que

Bernard Parisse

se proposait de reprendre et continuer à maintenir le projet

Omega

à travers un

fork

: un nouveau

firmware

nommé

Khi

.

Construit à partir du code source de la dernière version d'

Omega

,

Khi

reprenait l'intégralité des avantages de ce dernier !

Toutefois hors fonctionnalités,

Khi

apportait divers changements clivants qui n'ont pas été du goût de nombre d'utilisateurs et contributeurs historiques de la communauté

Omega

:

• abandon du support du modèle intial
  NumWorks N0100
  de la rentrée 2017
• une interface d'installation en ligne n'ayant absolument rien à voir avec celle qu'
  Omega
  proposait
• pas de simulateur en ligne
• pas d'interface en ligne pour choisir les applications à installer ainsi que les fichiers
  ROMs
  pour accompagner les applications d'émulation
• et surtout à la différence, pas de disponibilité du projet
  Khi
  sur la plateforme
  GitHub
  , cassant ainsi les habitudes des nos jeunes contributeurs, notamment le caractère public des contributions ainsi que des suites leur étant apportées ou pas

Ce dernier point était bien le problème majeur : si l'application

KhiCAS

installée avec

Khi

a continué à évoluer de façon très significative, ce ne fut hélas pas le cas du reste du

firmware

.

Le

firmware

Khi

semble ne pas avoir bénéficié d'une ambition autre que celle d'être un moyen de lancer l'application

KhiCAS

.

Ce n'est pas un problème en soit, c'est un choix qui se défend, mais nombre d'utilisateurs et contributeurs

Omega

se sont ainsi sentis mis de côté.

Nous y sommes donc aujourd'hui ; la communauté des utilisateurs et contributeurs

Omega

brillamment conduite par

Lauryy06

et

lolocomotive

lance à son tour un nouveau

fork

qui se veut cette fois-ci être enfin le véritable successeur de l'esprit

Omega

:

Upsilon

.

Upsilon

qui nous sort donc aujourd'hui en version

1.0

:

• est basé sur le code du
  firmware
  Espilon
  officiel dans sa version
  15.5.0
  ; toutes les nouveautés annoncées depuis ne pouvant être incluses suite au changement de licence
• apporte bien évidemment entre autres toutes les nouveautés et ajouts développés dans le cadre d'
  Omega
  jusqu'à l'arrêt du projet

Mais

Upsilon

ne se contente absolument pas de cela loin de là ; découvrons ensemble les nouveautés.

Sommaire

1. Nouveautés application Paramètres
2. Nouveautés application Python
3. Nouvelle application Liseuse
4. Conclusion
5. Téléchargements

1) Nouveautés application Paramètres

Go to top

Commençons donc par l'application

Paramètres

.

Le paramètre

Police Python

est renommée en

Python

est permet maintenant de changer plusieurs choses relatives à cette application.

Outre la taille de police, il permet de désactiver deux choses disponibles par défaut :

• l'auto-complétion qui selon les habitudes de chacun peut perturber la saisie
• la coloration syntaxique qui n'arrange pas forcément tout-le-monde

Dans

À propos

nous avons une nouvelle ligne indiquant le voltage ainsi que le pourcentage de charge de la batterie, informations entre lesquelles on bascule avec la touche

OK

.

Enfin, un nouveau paramètre

USB

permet de configurer une protection de ta calculatrice, activée par défaut.

Lorsque activé, ce paramètre empêche toute installation d'un

firmware

officiel

Epsilon

et donc tout verrouillage définitif de ta calculatrice, enfin !

(à noter toutefois que la protection ne fonctionne que si le firmware

Upsilon

est en fonctionnement ; elle n'est pas active si tu passes par le mode de récupération de la machine)

Toute tentative d'installation d'un

firmware

non souhaité entraînera une déconnexion immédiate de la calculatrice.

Lorsque la protection est activée, tu as le choix entre :

• autoriser la seule installation de
  firmwares
  basés sur
  Upsilon
• autoriser la seule installation de
  firmwares
  basés sur
  Omega
  (ce qui inclut

  Khi

  selon nos tests)
• n'autoriser aucune installation de
  firmware

2) Nouveautés application Python

Go to top

Nous passons maintenant à l'application

Python

où nous sommes gâtés avec nombre de nouveautés délicieusement croustillantes.

Déjà avant toute chose. Jusqu'à présent les

firmwares

disponibles pour ta

NumWorks

n'offrait que

32K

de stockage pour les scripts

Python

de l'application.
Ce n'est franchement pas beaucoup ; on se sent rapidement à l'étroit notamment lorsque l'on commence à vouloir inclure des images dans ses scripts.

Et bien grande nouvelle,

Upsilon

fait passer cet espace de stockage à

64K

!

Commençons par la bibliothèque

kandinsky

. Même si il y a pire, la bibliothèque de tracé par pixels

kandinsky

n'est pas bien généreuse, son offre se résumant à 4 méthodes dans le

firmware

officiel

Epsilon

:

• .set_pixel(x, y, couleur) pour allumer un pixel
• .fill_rect(x, y, largeur, hauteur, couleur) pour remplir un rectangle
• .draw_string(..., x, y) pour écrire

Le

firmware

Omega

avait grandement amélioré cela en ajoutant .draw_line(x1, y1, x2, y2, couleur) pour tracer un segment.

Mais c'était bien peu. La réalisation de projets graphiques nécessitait souvent bien d'autres primitives. Tu avais le choix entre :

• Utiliser des scripts
  Python
  codant des bibliothèques graphiques les fournissant
• Les écrire toi-même.
  Ce n'est pas forcément une mauvaise chose, mais selon le niveau cela pouvait nécessiter une étude mathématique préalable
  (trigonométrie pour le tracé de cercles, triangulation pour le remplissage de formes...)
  , chose qui pouvait être décourageante.
  Et dans tous les cas, la
  NumWorks
  souffra par rapport à la plupart de la concurrence d'une mémoire de tas
  (heap)
  à l'exécution relativement faible en
  Python
  , et un codage non optimal de ces ajouts amputant d'autant la capacité restant pour exécuter le reste du code de ton projet.

Et bien grande nouvelle,

Upsilon

nous gâte dans ce contexte !

La bibliothèque graphique

kandinsky

nous rajoute en natif plusieurs méthodes essentielles, et donc sans consommation supplémentaire de

heap

. Nous avons déjà autour des cercles :

• .draw_circle(x, y, rayon, couleur) pour tracer un cercle
• .fill_circle(x, y, rayon, couleur) pour remplir un disque

Code: Select all

from kandinsky import *

SCREEN_W, SCREEN_H = 320, 222

r = min(SCREEN_W, SCREEN_H) // 2

fill_circle(SCREEN_W - r, r, r, (0, 0, 255))
draw_circle(r, r, r, (255, 0, 0))

Mais ce n'est pas tout. Nous avons aussi de quoi remplir des polygones de formes quelconques : .fill_polygon(..., couleur).

Outre le paramètre de couleur, cette méthode attend une liste de coordonnées :

Code: Select all

from math import ceil
from kandinsky import *

SCREEN_W, SCREEN_H = 320, 222

def mod(l):
  x_min, y_min = l[0]
  x_max, y_max = 0, 0
  for k in range(len(l)):
    x_min = min(x_min, l[k][0])
    y_min = min(y_min, l[k][1])
    x_max = max(x_max, l[k][0])
    y_max = max(y_max, l[k][1])
  fx = max(1, (x_max-x_min)/SCREEN_W)
  fy = max(1, (y_max-y_min)/SCREEN_H)
  for k in range(len(l)):
    l[k][0] = ceil((l[k][0]-x_min)/fx)
    l[k][1] = ceil((l[k][1]-y_min)/fy)

l = [
  [0,200],
  [400,200],
  [400,250],
  [450,150],
  [0,200],
  [2,62],
  [223,236],
  [253,222],
  [274,236],
  [350,184],
  [121,2],
  [2,62]
]

mod(l)
fill_polygon(l, (255, 0, 0)

Mais comme tu peux le voir ci-contre, elle ne semble pas encore être au point dans la triangulation de la forme à remplir, avec plusieurs lignes horizontales laissées en blanc.

Comparons, il ne semble pas y avoir ce problème avec les méthodes natives équivalentes sur la concurrence

TI-83 Premium CE Edition Python

ou

TI-Nspire CX II

:

On se rend compte en poussant la chose que la méthode

.fill_polygon()

est malheureusement limitée, n'acceptant au maximum que 32 couples de coordonnées.

Voici ci-contre un simple morceau du logo

Texas Instruments

à cause de cette limitation, avec les écarts de remplissage qui empirent, non seulement des lignes horizontales laissées en blanc mais également plusieurs lignes horizontales tracées hors de la forme.

Mais pire que cela, le tracé ci-contre bloque la calculatrice et force alors à effectuer un

reset

.

Autre ajout, la méthode .palette() te retournant un dictionnaire avec les différentes couleurs des éléments de l'interface utilisateur

Upsilon

.

Tu as donc de quoi créer des scripts graphiques dont l'affichage s'adaptera automatiquement au thème graphique, notamment pour les utilisateurs qui choisissent d'installer

Upsilon

avec un thème autre que celui par défaut.

Enfin la bibliothèque

ion

t'offrait de quoi tester si une touche est enfoncée via sa méthode .keydown(code_touche).

C'était quand même bien embêtant dans le cas de projets s'attendant à des appuis sur un large éventail de touches : jeux, menus, ou encore pire éditeur de texte.

Tu te devais donc d'interroger une par une l'intégralité des touches clavier via une bouche, ce qui n'est pas négligeable en temps, et pouvait ainsi te faire rater quelques appuis bref ou quelques subtilités comme des appuis simultanés sur plusieurs touches.

Upsilon

nous apporte enfin une alternative mais bizarrement dans

kandinsky

, la méthode .get_keys() qui te retourne la liste de l'ensemble des touches actuellement pressées.

Passons donc maintenant justement à la bibliothèque

ion

.

Nous y trouvons plusieurs nouvelles méthodes permettant d'interroger l'état de la batterie directement depuis tes scripts :

• .battery() pour connaître le voltage de la batterie
• .battery_level() pour avoir le niveau de la batterie, soit le nombre d'éléments de charge à dessiner dans l'icône en haut à droit de l'écran
  (de 0 pour l'état critique à 4 pour une batterie chargée)
• .battery_charging() pour savoir si la batterie est en cours de recharge

L'application additionnelle

KhiCAS

inclut elle-même son propre interpréteur

micropython

distinct de celui de l'application

Python

. Un avantage est la présence de bibliothèques supplémentaires comme

ulab

.

Toutefois, même dans le cadre du

firmware

Khi

, ces ajouts n'avaient malheureusement pas été dupliqués pour l'application

Python

intégrée.

L'application

Python

intégrée a pourtant un net avantage pour les projets les plus gourmands, avec un

heap

de

100K

lorsque tu utilises les

firmware

Upsilon

,

Khi

ou

Omega

, contre seulement

64K

via l'application

KhiCAS

(et pour référence seulement

32K

avec le firmware

Epsilon

officiel)

.

Et bien grande nouvelle entre autres pour les physiciens, avec

Upsilon

la bibliothèque

ulab

débarque enfin dans l'application

Python

intégrée !

Nous avons droit à ses deux sous-bibliothèques ; d'une part

numpy

pour le calcul scientifique optimisé sur les tableaux ou matrices.

D'autre part donc

scipy

qui fédère elle-même divers sous-bibliothèques de calcul scientifique :

• linalg
  : algèbre linéaire
• optimize
  : optimisation de fonctions
  (recherche d'extrema ou points d'inflexion)
• signal
  : traitement de signal
• special

3) Nouvelle application Liseuse

Go to top

Cela commençait à faire longtemps, avec

Upsilon

nous bénéficions enfin d'une nouvelle application intégrée, une

Liseuse

.

Il s'agit donc d'un lecteur de fichiers texte.

Tu va pouvoir lire tous les romans que tu souhaites sur ta calculatrice.

Et bien mieux que ça encore, car les expressions

LaTeX

sont reconnues !

Code: Select all

Ce fichier est un test pour %r%LaTeX%\r%

$\frac{1}{12}+\sqrt[7]{4}-\floor{n+1}+\ceil{n-1}$
$u_{\phi(n)} = u_{2n+1} = (-1)^{2n+1} = -1$
$\times\forall\pm\partial\exists\div\infty\approx\neq\equiv\leq\geq$
$\leftarrow\uparrow\rightarrow\downarrow\leftrightarrow\updownarrow\Leftarrow\Uparrow\Rightarrow\Downarrow$
$\alpha\beta\gamma\delta\epsilon\zeta\eta\theta\iota\kappa\lambda\mu\nu\xi$
$o\pi\rho\sigma\tau\upsilon\phi\chi\psi\omega$
$\Alpha\Beta\Gamma\Delta\Epsilon\Zeta\Eta\Theta\Iota\Kappa\Lambda\Mu\Nu\Xi$
$\Omicron\Pi\Rho\Sigma\Tau\Upsilon\Phi\Chi\Psi\Omega$

La porte est donc maintenant également grande ouverte à tes fichiers de documents scientifiques : formulaires, cours, exercices corrigés, annales et bien d'autres !

Conclusion

Go to top

Avec

Upsilon

l'esprit du projet

Omega

est clairement de retour.

Nous sommes heureux de retrouver un bouillonnement d'idées et formidables nouveautés comparable à ce dont a bénéficié

Omega

!

Un grand merci et bravo à

Lauryy06

,

lolocomotive

, ainsi qu'à tous les contributeurs et testeurs, entre autres :

• @Yaya.Cout
  (1^er contributeur + divers fix assez importants)
• @dl11
  (protection usb)
• @Mino#1289
  (co-auteur de la liseuse)

Téléchargements

Go to top

Si tu n'as pas encore commis l'erreur de verrouiller ta calculatrice, c'est par ici pour en améliorer les capacités.

Installation

:

• firmware :
  Upsilon
  Khi
  Omega
• applications additionnelles et fichiers associés :
  Upsilon
  Omega