Turtle 2.01 Français : bibliothèque Python TI-83 Premium CE

[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

[cent20]

Bravo pour ces magnifiques réalisations, elles sont vraiment réussies et il faudrait vraiment que les constructeurs implémentent tous fillcolor, turtle.begin_fill, turtle.end_fill, cela permet en effet de réaliser de superbes compositions.

Reste à connaitre le nombre de mes élèves qui viendront piocher ici des codes tout fait pour leur devoir maison sur les mathématiques sont belles. S'ils codent une fonction de remplissage je serais ravi.

[critor]

Suite à ce test, l'indice de conformité au standard turtle a été mis à jour dans notre tableau comparatif QCC :
https://tiplanet.org/forum/compare.php?mode=QCC2021

C'est une moyenne qui tient compte :

• du nombre d'erreurs détectées automatiquement par nos scripts
• du nombre d'exemples sur les 17 traités ici qui échouent de façon flagrante (mauvais tracé ou mauvaise couleur de remplissage)

Le lien de téléchargement du turtle des TI-83PCE/84+CE a en passant été mis à jour dans le tableau.

[critor]

La disponibilité des méthodes de remplissage en turtle est maintenant au tableau :
https://tiplanet.org/forum/compare.php?mode=QCC2021