Forum TI-Planet.org

News, programmes, tutoriaux, forum sur les calculatrices TI !
https://tiplanet.org/forum/

NumWorks v14: exploration turtle + tests compatibilité

https://tiplanet.org/forum/viewtopic.php?f=97&t=23935

Page 1 sur 1

NumWorks v14: exploration turtle + tests compatibilité

Message non luPosté: 13 Juin 2020, 15:57
de Admin
12534NumWorks vient de lancer le bêta-test public de sa prochaine version 14, avec un menu pantégruélique.

Nous nous attardons aujourd'hui plus en détail sur les ajouts apportés au module Python turtle.

Lors d'un précédent test comparatif à l'occasion de la dernière mise à jour Casio, nous y avions en effet remarqué quelques faiblesses.




  1. Exploration turtle v14
  2. turtle v14 et compatibilité
  3. Conclusion




1) Exploration turtle

Go to top

À l'aide de notre script explmod.py, commençons par fouiller le module turtle à la recherche de nouveautés.

Nous avions pour référence jusqu'à présent 38 à 60 éléments en comptant les sous-éléments.
Code: Tout sélectionner
def getplatform():
  id=-1
  try:
    import sys
    try:
      if sys.platform=='nspire':id=0
      if sys.platform.startswith('TI-Python') or sys.platform=='Atmel SAMD21':id=4
    except:id=3
  except:
    try:
      import kandinsky
      id=1
    except:
      try:
        if chr(256)==chr(0):id=5+(not ("HP" in version()))
      except:
        id=2
  return id

platform=getplatform()
#lines shown on screen
#plines=[29,12,  7, 9,11,0,0]
plines=[29,16,  7, 9,11,0,0]
#max chars per line
#(error or CR if exceeded)
pcols =[53,99,509,32,32,0,0]

unsafe = ((), (), (), ('sys.argv', 'sys.path'), (), (), ())

if platform>=0:
  curline=0
  _p = print
  nlines=plines[platform]
  ncols=pcols[platform]
  def print(*ls):
    global curline
    st=""
    for s in ls:
      if not(isinstance(s,str)):
        s=str(s)
      st=st+s
    stlines=1+int(len(st)/ncols)
    if curline+stlines>=nlines:
      input("Input to continue:")
      curline=0
    _p(st)
    curline+=stlines

def sstr(obj):
  try:
    s=obj.__name__
  except:
    s=str(obj)
    a=s.find("'")
    b=s.rfind("'")
    if a>=0 and b!=a:
      s=s[a+1:b]
  return s

def isExplorable(obj):
  for k in done:
    try:
      if isinstance(obj, eval(k)):
        t, done[k] = done[k], True
        return not t
    except: pass
  if str(obj).startswith("<module"): return False
  l = ()
  try: l = dir(obj)
  except: pass
  return len(l)

done = {'str':False, 'list':False, 'tuple':False, 'dict':False, 'complex':False, 'set':False, 'frozenset': False}

def explmod(pitm, pitmsl=[], reset=True):
  global curline
  spitm=sstr(pitm)
  if(reset):
    curline=0
    pitmsl=[spitm]
    for k in done: done[k] = False
  hd="."*(len(pitmsl)-1)
  c,c2=0,0
  l = sorted(dir(pitm))
  for i in range(len(l)):
    l[i] = (l[i], getattr(pitm, l[i]))
  try:
    if not isinstanceof(pitm, str):
      for i in range(len(pitm)):
        l.append((spitm+'['+str(i)+']',pitm[i]))
  except: pass
  for itm in l:
    c,c2=c+1,c2+1
    isUnsafe = platform >= 0 and '.'.join(pitmsl + [itm[0]]) in unsafe[platform]
    try:
      if isUnsafe: raise Exception
      print(hd+itm[0]+"="+str(itm[1]))
    except:
      print(hd+itm[0])
    if not isUnsafe and isExplorable(itm[1]) and itm[1] != pitm and itm[0] not in pitmsl:
      pitmsl2=pitmsl.copy()
      pitmsl2.append(itm[0])
      c2=c2+explmod(itm[1], pitmsl2, False)[1]
  if c>0 and reset:
    print(hd+"Total: "+str(c)+" 1st level item(s)")
    if c2>0 and c2!=c:
      print(hd+"       "+str(c2)+" item(s)")
  return [c,c2]

1254612545Nous avons donc désormais de 40 à 62 éléments, avec les deux ajouts suivants :
  • fonction colormode()
  • fonction write()

Nous allons bien évidemment en expliciter l'intérêt, mais en attendant petit bilan au sujet de la richesse des différentes solutions Python sur calculatrices :
Casio Graph
35+E II
90+E
NumWorks
TI-83PCE
Ed. Python
builtins
array
collections
cmath
gc
math
matplotlib
matplotlib.pyplot
micropython
os
random
sys
time
turtle
uerrno		84-197
.
.
.
.
25-47
.
.
.
.
8-30
.
.
.
.		97-1581
3-363
.
13-428
9-404
42-602
.
.
10-410
.
.
17-977
.
.
25-1277		89-211
.
.
12-34
.
41-63
3-25
11-33
6-28
.
9-31
.
3-25
40-62
.		92-211
2-24
2-24
.
7-29
28-50
.
.
.
.
8-30
15-93
4-26
.
.
spécifiquecasioplot:6-28prime:3-368ion:48-162
kandinsky:8-30		ti_graphics:30-75
ti_hub:?
ti_plotlib:49-84
ti_system:12-34
ti_rover:66-92
Modules491113
Eléments123-302219-6042269-703315-772

  1. 315-772 éléments : TI-83 Premium CE Edition Python
  2. 269-703 éléments : NumWorks
  3. 219-6042 éléments : HP Prime (version alpha)
  4. 123-302 éléments : Casio Graph 90+E / 35+E II
Casio Graph
35+E II
90+E
CasioPython
Casio Graph
35+E II
35+E/USB
75/85/95
MicroPython
TI-Nspire
TI-Python
TI-83PCE
Ed. Python
builtins
array
collections
cmath
gc
math
matplotlib
matplotlib.pyplot
micropython
os
random
sys
time
turtle
uerrno		84-197
.
.
.
.
25-47
.
.
.
.
8-30
.
.
69-126
.		91-230
2-28
.
12-38
7-33
41-67
.
.
6-32
.
8-34
12-38
.
.
24-108		93-218
2-28
.
12-38
7-33
41-67
.
.
3-29
.
.
15-86
.
.
.		92-212
2-24
2-24
.
7-29
28-50
.
.
.
.
8-30
15-93
4-26
.
.		93-214
2-25
2-25
12-35
7-30
41-64
.
.
6-29
15-38
8-31
15-99
8-33
.
.		92-211
2-24
2-24
.
7-29
28-50
.
.
.
.
8-30
15-93
4-26
.
.
spécifiquecasioplot:6-28
matplotl:25-68		nsp:3-10board:22
storage:7-47		ce_box:5-32
ce_chart:8-67
ce_quivr:5-41
ce_turtl:?
ti_graphics:30-75
ti_hub:?
ti_plotlib:49-84
ti_system:12-34
ti_rover:66-92
Modules69891317
Eléments217-496203-608176-509158-488238-692333-912

  1. 322-912 éléments : TI-83 Premium CE Edition Python
  2. 269-703 éléments : NumWorks
  3. 238-692 éléments : TI-83 Premium CE + TI-Python (firmware tiers)
  4. 219-6042 éléments : HP Prime (version alpha)
  5. 217-496 éléments : Casio Graph 90+E / 35+E II / fx-CG50 / fx-9750/9860GIII
  6. 203-608 éléments : Casio Graph 75/85/95 / 35+E/USB / 35+E II / fx-9750GII/GIII / fx-9860G/GII/GIII (appli CasioPython)
  7. 176-509 éléments : TI-Nspire (appli MicroPython)
  8. 158-488 éléments : TI-83 Premium CE + TI-Python

NumWorks conforte ainsi sa 2nde place niveau richesse de sa solution Python.

Mais la richesse ne fait pas tout, il faut également voir la compatibilité, et nous y venons de suite.




2) compatibilité turtle

Go to top

Commençons déjà par tester les déplacements relatifs de la tortue. Voici par exemple avec la construction d'une rosace par rotation d'un polygone régulier :
Graph 35+E IIGraph 90+ENumWorksordi
Code: Tout sélectionner
from turtle import *

def rosap(n1=12, n2=8, l=30):
  d1, d2 = 360//n1, 360//n2
  for i in range(n1):
    left(d1)
    for i in range(n2):
      forward(l)
      left(d2)

speed(0)
rosap()

La tortue travaillant en pixels, le code aurait besoin d'être adapté pour l'écran Graph 35+E II à plus faible définition. Mais à part cela, le code passe ici sans problème sur Casio, NumWorks et ordinateur. :)

Complexifions un petit peu la chose avec la fractale de Koch. Rajoutons également un levé de crayon (penup), un déplacement absolu (goto), ainsi que l'utilisation d'une des couleurs prédéfinies :
Graph 35+E IIGraph 90+ENumWorksordi
Code: Tout sélectionner
from turtle import *

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

pencolor('blue')
penup()
goto(-180, -50)
pendown()
koch(4, 360)

Ici pareil, compatibilité totale ! :)

Allons bien plus loin niveau couleurs avec maintenant un soleil :
Code: Tout sélectionner
from math import exp
from turtle import *

for i in range(1,37):
  red=(exp(-0.5 * ((i-6)/12)**2))
  green=(exp(-0.5 * ((i-18)/12)**2))
  blue=(exp(-0.5 * ((i-30)/12)**2))
  pencolor([red, green, blue])
  for i in range(1, 5):
    forward(60)
    right(90)
    right(10)

Problème ici sur NumWorks, qui a fait le choix de ne pas utiliser le même système de coordonnées que le standard pour les composantes de couleurs RVB :
  • nombres flottants de 0.0 à 1.0 sur Casio et ordinateur
  • nombres entiers de 0 à 255 sur NumWorks et TI-83 Premium CE Edition Python
Mais nous disposons donc sur NumWorks de la nouvelle fonction colormode() pour choisir le système de coordonnées. Il suffira donc tout simplement de rajouter un appel colormode(1.) à tout script compatible Casio ou ordinateur pour le rendre également fonctionnel sur NumWorks ! :bj:

Par contre, chez Casio cette fonction certes inutile ici n'est pas présente. Il nous faut donc sécuriser son appel en interceptant toute erreur éventuelle.
Graph 35+E IIGraph 90+ENumWorksordi
Code: Tout sélectionner
from math import exp
from turtle import *

try: colormode(1.)
except: pass

for i in range(1,37):
  red=(exp(-0.5 * ((i-6)/12)**2))
  green=(exp(-0.5 * ((i-18)/12)**2))
  blue=(exp(-0.5 * ((i-30)/12)**2))
  pencolor([red, green, blue])
  for i in range(1, 5):
    forward(60)
    right(90)
    right(10)

Poursuivons avec une coquille d'escargot en appliquant la même astuce, et l'appel à la fonction de tracé de cercle circle() :
Graph 35+E IIGraph 90+ENumWorksordi
Code: Tout sélectionner
from turtle import *
from math import *

try: colormode(1.)
except: pass

penup()
goto(0, -20)
pendown()
for i in range(1,37):
  red=(exp(-0.5 * ((i-6)/12)**2))
  green=(exp(-0.5 * ((i-18)/12)**2))
  blue=(exp(-0.5 * ((i-30)/12)**2))
  mypencolor([red,green,blue])
  circle(50-i)
  right(10)

Sous réserve de cette toute petite astuce donc, compatibilité totale. :)

Faisons maintenant neiger quelques flocons de Koch, en faisant variant l'épaisseur du crayon avec pensize() :
Graph
35+E II
Graph
90+E
NumWorks
ordi
Code: Tout sélectionner
from turtle import *

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

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

try: colormode(1.)
except: pass

l=80

penup()
goto(105,3)
left(120)
pendown()
pencolor((0, 0, 0))
flock(3, l)
left(120)

penup()
goto(105,-10)
right(60)
pendown()
pencolor((1, .5, 0))
flock(4, l)
right(60)

pensize(2)
penup()
goto(5,45)
right(60)
pendown()
pencolor((0, 0, 1))
flock(2, l)
right(60)

penup()
goto(-100,17)
left(120)
pendown()
pencolor((1, 0, 0))
flock(0, l)
left(120)

pensize(3)
penup()
goto(-100,-5)
right(60)
pendown()
pencolor((0, 1, 0))
flock(1, l)
right(60)

penup()
forward(400)

Les réglages d'épaisseur du crayon via pensize() semblent hélas totalement ignorés chez Casio.


Passons maintenant à une rosace construite par rotation d'un cercle, avec une écriture de texte via la fonction write().

Cette fonction standard n'était jusqu'à présent pas disponible dans le module turtle de NumWorks.

Mais maintenant c'est le cas alors voyons ce que ça donne :
Graph 35+E IIGraph 90+ENumWorksordi
12544
Code: Tout sélectionner
from turtle import *

def rosac(r=50,n=10):
  d=360//n
  for k in range(n):
    circle(r)
    left(d)

r=50
rosac(r)
penup()
left(40)
fd(2.1*r)
right(40)
write('Rosace')

Petit écart chez Casio, avec le texte qui est écrit en prenant la position de la tortue comme coin supérieur gauche, alors que le standard la prend comme coin inférieur gauche.



Passons maintenant au script de démo dédié à la Casio Graph 90+E, avec inversion du sens de tracé des cercles.

Il suffisait pour cela de passer un rayon négatif à la fonction circle(), ce qui n'était hélas pas géré chez NumWorks et ignoré.

Mais maintenant apparemment désormais c'est bon : :bj:
Graph 35+E IIGraph 90+ENumWorksordi
12547
Code: Tout sélectionner
from turtle import *

forward(40)
backward(100)
left(90)
forward(30)
right(60)
forward(60)
right(30)
forward(30)
penup()
forward(18)
right(90)
forward(60)
pendown()
right(30)
backward(30)
right(60)
forward(60)
pencolor("red")
penup()
goto(80,40)
right(140)
pendown()
circle(30)
penup()
goto(105,50)
pencolor("green")
pendown()
circle(-50)
penup()
pencolor("red")
right(21)
goto(60,20)
pendown()
circle(40,60)
penup()
pencolor("blue")
goto(-50,15)
setheading(0)
pendown()
write("CASIO")

Juste pour le plaisir, un dernier exemple avec les triangles de Sierpiński :
Graph
35+E II
Graph
90+E
Num
Works
ordi
Code: Tout sélectionner
from turtle import *

def sierp(n, l):
    if n == 0:
        for i in range (0, 3):
            fd(l)
            left(120)
    if n > 0:
        sierp(n-1, l/2)
        fd(l/2)
        sierp(n-1, l/2)
        bk(l/2)
        left(60)
        fd(l/2)
        right(60)
        sierp(n-1, l/2)
        left(60)
        bk(l/2)
        right(60)

try: colormode(1.)
except: pass
penup()
backward(109)
left(90)
backward(100)
right(90)
pendown()
pencolor((1, 0, 0))
sierp(6, 217)
penup()
forward(400)




Conclusion

Go to top

Nous ne pouvons que saluer l'exceptionnelle réactivité de NumWorks, qui s'est empressé de colmater les quelques petites faiblesses que nous avions constatées dans son module turtle.

Nous obtenons ainsi sur la NumWorks version 14 un module turtle en excellente adéquation avec le standard et bénéficiant ainsi d'une non moins excellente compatibilité avec les scripts conçus pour le standard ou pour les plateformes visant à le respecter.
Une compatibilité peut-être un poil meilleure que celle de Casio.

Mais bref dans les deux cas, nous avons donc d'excellentes solutions qui permettront de concevoir et exécuter des scripts Python turtle dans une classe équipée de différents modèles avec un effort très minimal ! :bj:

Liens :

Re: NumWorks v14: exploration turtle + tests compatibilité

Message non luPosté: 13 Juin 2020, 18:03
de redgl0w
D'ailleurs, hormis https://github.com/numworks/epsilon/pull/1519, qui rajoute le support de rayon négatif pour les cercles et https://github.com/numworks/epsilon/pull/1534 qui rajoute
Code: Tout sélectionner
colormode()
dans ce dernier PR on retrouve un changement aussi assez majeur (même si ça n'a pas de rapport avec la compatibilité du module turtle), on peut utiliser des couleurs sur turtle comme on pouvait les utiliser sur kandinsky (via les "b", "blue", ...) et comme sur pyplot ("0.5" pour un gris (oui c'est un string et pas un float), "#ffffff" pour un blanc). Cette nouveauté est d'ailleurs réciproque (donc ces changements sont appliqués sur kandinsky et pyplot).

Re: NumWorks v14: exploration turtle + tests compatibilité

Message non luPosté: 13 Juin 2020, 19:44
de critor
Merci pour tes précieuses précisions. :)

Re: NumWorks v14: exploration turtle + tests compatibilité

Message non luPosté: 13 Juin 2020, 20:46
de cent20
Aucune mention de la TI 83 PCE dans tous ces magnifiques tableaux comparatifs ?

Re: NumWorks v14: exploration turtle + tests compatibilité

Message non luPosté: 13 Juin 2020, 20:53
de Lionel Debroux
La compatibilité des implémentations de TI laisse à désirer...

Re: NumWorks v14: exploration turtle + tests compatibilité

Message non luPosté: 13 Juin 2020, 20:56
de critor
cent20 a écrit:Aucune mention de la TI 83 PCE dans tous ces magnifiques tableaux comparatifs ?


Tu parles du module complémentaire ce_turtl utilisable après la mise à jour 5.5.1 ?

Beaucoup plus éloigné du standard, donc beaucoup plus de travail d'exploration/adaptation à faire. Même pas sûr qu'il soit possible de faire une version compatible de certains exemples sans inclure littéralement 2 versions du code alternées avec un try/except.

Si j'en avais parlé, ça aurait pris une bonne partie de l'article tellement il y a de problèmes / écarts à traiter, et ça aurait franchement fait tache dans un article ciblant NumWorks.
Ce sera traité à part dans un article dédié.

Clairement, le respect du standard Python.turtle existant et donc du langage utilisé dans les livres scolaires n'était pas en bonne position dans le cahier des charges de TI.

Sympa pour les lycées où l'équipe pédagogique n'a pas accordé ses violons pour imposer un unique modèle, il y aura 2 langages Python.turtle incompatibles à enseigner, parfois même dans une même classe...

Re: NumWorks v14: exploration turtle + tests compatibilité

Message non luPosté: 14 Juin 2020, 01:07
de cent20
critor a écrit:Clairement, le respect du standard Python.turtle existant et donc du langage utilisé dans les livres scolaires n'était pas en bonne position dans le cahier des charges de TI.

Sympa pour les lycées où l'équipe pédagogique n'a pas accordé ses violons pour imposer un unique modèle, il y aura 2 langages Python.turtle incompatibles à enseigner, parfois même dans une même classe...


J'ai vraiment l'impression que le navire prend l'eau chez TI. Après, heureusement pour eux, une bonne partie ne s'en rendra pas compte car ils ne feront pas de python sur la calculatrice. Avoir imposé un langage unique, python, et se retrouver avec des constructeurs qui implémentent ça de manière non standard, c'est désespérant :(

Re: NumWorks v14: exploration turtle + tests compatibilité

Message non luPosté: 14 Juin 2020, 02:57
de Adriweb
Lot de consolation, pour de l'algorithmie de base, au moins, c'est du python pur sans lib, donc ca devrait etre bon pour tout le monde... Mais c'est clair que pour des libs externes, s'accorder les violons tous ensemble aurait été bénéfique. C'est presque le cas pour certaines choses mais pas vraiment chez TI...

Re: NumWorks v14: exploration turtle + tests compatibilité

Message non luPosté: 14 Juin 2020, 10:35
de Bobb
On n'a pas utilisé le module turtle une seule fois en seconde, alors que dans ma classe, tout le monde avait une numworks sauf moi qui avait une ti.

Re: NumWorks v14: exploration turtle + tests compatibilité

Message non luPosté: 14 Juin 2020, 10:43
de critor
C'est normal, c'est essentiellement pour la Seconde le temps de la transition Scratch-Python, et encore uniquement pour les enseignants qui souhaitent s'appuyer sur les acquis de collège en Scratch pour faire passer progressivement au Python.
Heures au format UTC + 1 heure
Page 1 sur 1
Powered by phpBB® Forum Software © phpBB Group
http://www.phpbb.com/