[critor]

Concours TI-Planet de l'Avent 2021
L'énigme des 3 portes : jour n°29
(index des publications)

Viens rassembler les indices et bouts de code Python chaque jour de l'Avent ; sois parmi les premiers à passer l'une des portes pour gagner de superbes cadeaux de Noël !

La porte NumWorks s'ouvrira 2 fois. Dernier indice NumWorks ce 30 décembre. Rendez-vous à partir de 14 heures.

Code: Select all

from math import ceil

platform = ''
try: from sys import platform
except: pass

def nop(*argv): pass
show, wait = nop, nop
neg_fill_rect = False
has_color = True

try: # NumWorks, NumWorks + KhiCAS, TI-Nspire CX + KhiCAS
  import kandinsky
  fill_rect = kandinsky.fill_rect
  screen_w, screen_h = 320, 222
  neg_fill_rect = platform!='nspire' and platform!='numworks'
except:
  try: # TI
    import ti_draw
    try: # TI-Nspire CX II
      ti_draw.use_buffer()
      show = ti_draw.paint_buffer
    except: # TI-83PCE/84+CE Python
      wait = ti_draw.show_draw
    screen_w, screen_h = ti_draw.get_screen_dim()
    try: # check TI-83PCE/84+CE ti_draw 1.0 fill_rect bug
      ti_draw.fill_rect(0,0,1,1)
      def fill_rect(x, y, w, h, c):
        ti_draw.set_color(c[0], c[1], c[2])
        ti_draw.fill_rect(x, y, w, h)
    except: # workaround
      def fill_rect(x, y, w, h, c):
        ti_draw.set_color(c[0], c[1], c[2])
        ti_draw.fill_rect(x - 1, y - 1, w + 2, h + 2)
  except:
    try: # Casio Graph 90/35+E II, fx-9750/9860GIII, fx-CG50
      import casioplot
      casioplot.set_pixel(0, 0, (0, 0, 255))
      col = casioplot.get_pixel(0, 0)
      has_color = col[0] != col[2]
      screen_w, screen_h = has_color and (384, 192) or (128, 64)
      show = casioplot.show_screen
      def fill_rect(x, y, w, h, c):
        for dy in range(h):
          for dx in range(w):
            casioplot.set_pixel(x + dx, y + dy, c)
    except:
      try: # HP Prime
        import hpprime
        screen_w, screen_h = hpprime.grobw(0), hpprime.grobh(0)
        hpprime.dimgrob(1, screen_w, screen_h, 0)
        def col3_2_rgb(c, bits=(8,8,8), bgr=1):
          return c[2*bgr]//2**(8 - bits[0]) + c[1]//2**(8 - bits[1])*2**bits[0] + c[2*(not(bgr))]//2**(8-bits[2])*2**(bits[0] + bits[1])
        def fill_rect(x, y, w, h, c):
          hpprime.fillrect(1, x, y, w, h, col3_2_rgb(c), col3_2_rgb(c))
        def show():
          hpprime.strblit(0, 0, 0, screen_w, screen_h, 1)
        def wait():
          while hpprime.keyboard(): pass
          while not(hpprime.keyboard()): pass
      except:
        pass
if not neg_fill_rect:
  _fill_rect = fill_rect
  def fill_rect(x, y, w, h, c):
    if w < 0:
      x += w
      w = -w
    if h < 0:
      y += h
      h = -h
    _fill_rect(x, y, w, h, c)

def draw_image(rle, x0, y0, w, pal, zoomx=1, zoomy=1, itransp=-1):
  if not has_color:
    pal = list(pal)
    g_min, g_max = 255, 0
    for k in range(len(pal)):
      c = pal[k]
      g = 0.299*c[0] + 0.587*c[1] + 0.114*c[2]
      g_min = min(g_min, g)
      g_max = max(g_max, g)
      pal[k] = g
    for k in range(len(pal)):
      pal[k] = pal[k]<(g_min + g_max) / 2 and (0,0,0) or (255,255,255)
  i, x = 0, 0
  x0, y0 = int(x0), int(y0)
  nvals = len(pal)
  nbits = 0
  nvals -= 1
  while(nvals):
    nvals >>= 1
    nbits += 1
  maskval = (1 << nbits) - 1
  maskcnt = (0xFF >> nbits >> 1) << nbits
  while i<len(rle):
    v = rle[i]
    mv = v & maskval
    c = (v & maskcnt) >> nbits
    if (v & 0b10000000 or nbits == 8):
      i += 1
      c |= rle[i] << (7 - nbits + (nbits == 8))
    c = (c + 1)
    while c:
      cw = min(c, w - x)
      if mv != itransp:
        fill_rect(x0 + x*zoomx, y0, cw*zoomx, zoomy, pal[mv])
      c -= cw
      x = (x + cw) % w
      y0 += x == 0 and zoomy
    i += 1

palettes = (
  (
    (247,176,36),(247,207,73),(231,89,0),(247,131,8),
  ),
)
images = (
  (
    b"\b\x05\n?\n\x05\x18\x05\n7\n\x05\x20\x05\n/\n\x05(\x05\n'\n\x050\x05\n\x1f\n\x058\x05\n\x17\n\x05@\x05\n\x0f\n\x05H\x05\n\a\n\x05P\x05\x16\x05X\x05\x0e\x05`\x05\x06\x05d\a\x06\a`\a\x02\x04\x02\aX\a\x02\x0c\x02\aP\a\x02\x04\a\x04\x02\aH\a\x02\x04"
    b"\x0f\x04\x02\a@\a\x02\x04\x17\x04\x02\a8\a\x02\x04\x1f\x04\x02\a0\a\x02\x04'\x04\x02\a(\a\x02\x04/\x04\x02\a\x20\a\x02\x047\x04\x02\a\x18\a\x02\x04?\x04\x02\a\x10\a\x02\x04G\x04\x02\a\b\a\x02\x04O\x04\x02\a\x00\a\x02\x04W\x04\x02\x0b\x02\x04_\x04"
    b"\x02\x03\x02\x04g\x04\x0eg\n\x01\n_\n\t\nW\n\x05\x00\x05\nO\n\x05\b\x05\nG\n\x05\x04"
  ),
)
for y in range(ceil(screen_h / 32)):
  for x in range(ceil(screen_w / 32)):
    draw_image(images[0], x*32, y*32, 32, palettes[0])
show()

palettes = (
  (
    (7,97,182),(55,139,223),(99,176,247),(141,216,247),
  ),
)
images = (
  (
    b"\x80\x01!\x14!\x18\x1e\x19\x1e\x19\x06\x17\x1a\x1f\x1a\x1f\x1a\x1f\x1a\x17\x06\x19\x1e\x19\x1e\x18!\x14!\x80\x01"
  ),
)
for x in range(ceil(screen_w / 16)):
  draw_image(images[0], x*16, screen_h-16, 16, palettes[0])
show()

palettes = (
  (
    (239,89,107),(247,207,81),(0,0,0),(182,26,36),(239,97,0),(0,0,0),
  ),
)
images = (
  (
    b"\xc0\x011\xc0\x01\x02)\xc0\x01\x03\x02!\xc0\x01\x0b\x02!\xc0\x01\x0b!\xc8\x011\xc0\x011\xb8\x01!\x021\x90\x01\x11\n\x03)\x02\x88\x01\t\n\x13!\x02\x03\x88\x01\n#\x19\x02\x0b\x88\x01+\x00\x19\x0b\x90\x01\x1b\x10!\x98\x01\x0b\x20!\xd0\x01\x02!\xc8\x01"
    b"\x03\n\x11\xc8\x01\x13\n\t\xc0\x01#\n\xe8\x01\x0b\xb8\x02\tX\x13p\t@+h\x19\x18Kh\x19[Pi#\x18C\x02Y\x02\x0b0K\x02I\x02\x03@S\x029\x02\x03(\xfb\x009\x03\x20\x1b\b3\x18I\x18\x13pI\b\x1b\x18\x03H!\n!\x1b\x18\x0bH\x11\n\x0b\n\x11\x13\x20\x03\x04@\t\n+\n"
    b"\t\x03\x20\x0b\x04@\nK\n(\x0b\x04@c(\x13\x04\x018[0\x0b\x0c\x01(c0\x13\x0c\t\x83\x010\x1b\x0c\ts@\x13\x141;H\x1b\x14)\x02+P\x1b\x1c!\x02\x1b`#\x1c\x19\x02\x0bp#\x1c\x05\x19\x80\x01+\x14\r!p+\x1c\r!h+\x1c\x15\x02!X+$\x15\x03\n\x11P+$\x1d\x13\n\t83,"
    b"\x1d#\n(;,%\x00+\x10K,-\x10\xfb\x00,5\x8b\x01,=\xfb\x004Ek<M[DUCT]#dm\xfc\x00\xfd\x00\x01d\x8d\x01\tL\x9d\x01\x04\t,\xb5\x01\x0c\t\x14\xc5\x01"
  ),
)
for x in range(ceil(screen_w / 64)):
  draw_image(images[0], x*64, 0, 32, palettes[0], 1, 1, 5)
  draw_image(images[0], (x+1)*64, 0, 32, palettes[0], -1, 1, 5)
show()

def draw_rect_z(x, y, w, h, c, z=1):
  for dy in (0, h - 1):
    fill_rect(x, y + dy*z, w*z, z, c)
  for dx in (0, w - 1):
    fill_rect(x + dx*z, y, z, h*z, c)

def qr_mark(x, y, s, c, z=1):
  draw_rect_z(x, y, s, s, c, z)
  fill_rect(x + 2*z, y + 2*z, (s - 4)*z, (s - 4)*z, c)

palettes = (
  (
    (0,0,0),(247,172,107),(133,71,73),(157,114,18),(207,147,55),(247,247,247),
  ),
  (
    (0,0,0),(36,35,36),(198,0,18),(247,26,55),(157,0,0),(231,97,81),(239,147,90),(247,183,133),(55,114,167),(247,247,247),(72,155,207),(36,71,133),(166,80,0),(239,199,45),(223,131,45),
  ),
  (
    (0,0,0),(0,0,0),(255,183,45),(255,255,247),(255,216,141),
  ),
  (
    (0,0,0),(0,0,0),(27,58,157),(157,172,215),(247,251,247),
  ),
  (
    (0,0,0),(223,41,45),
  ),
)
images = (
  (
    b"\x80\x01a\x02\b\x01[\x02\b\x01\x03\x19\x0b\x19\x03\x02\b\x01\x03\x01\x0b\x01\x0b\x01\x0b\x01\x03\x02\b\x01\x03\x01\x0c\x01\x0b\x01\x0c\x01\x03\x02\b\x01\x03\x01\x0c\x01\x0b\x01\x0c\x01\x03\x02\b\x01\x03\x01\x0c\x01\x0b\x01\x0c\x01\x03\x02\b\x01\x03"
    b"\x01\x0c\x01\x0b\x01\x0c\x01\x03\x02\b\x01\x03\x01\x0c\x01\x0b\x01\x0c\x01\x03\x02\b\x01\x03\x19\x0b\x19\x03\x02\b\x01[\x02\b\x05Y\x02\b\x01\\\x02\b\x01\r\x03\x14\x01$\x02\b\x01\r\x02\x0c\x01\x0c\x01\x14\x02\b\x01\x03\n\x04\x01\x0c\x01\x1c\x02\b"
    b"\x01\x13\x04\x0b\x04#\x02\bj\b\x01[\x02\b\x01\x03\x19\x0b\x19\x03\x02\b\x01\x03\x01\x0b\x01\x0b\x01\x0b\x01\x03\x02\b\x01\x03\x01\x0c\x01\x0b\x01\x0c\x01\x03\x02\b\x01\x03\x01\x0c\x01\x0b\x01\x0c\x01\x03\x02\b\x01\x03\x01\x0c\x01\x0b\x01\x0c\x01"
    b"\x03\x02\b\x01\x03\x01\x0c\x01\x0b\x01\x0c\x01\x03\x02\b\x01\x03\x01\x0c\x01\x0b\x01\x0c\x01\x03\x02\b\x01\x03\x01\x0c\x01\x0b\x01\x0c\x01\x03\x02\b\x01\x03\x19\x0b\x19\x03\x02\b\x01[\x02\bj\x80\x01"
  ),
  (
    b"\xe0\n1\x90\x01\x11\x02#\x01\xf0\x00\x01\x04\"\x13\x01`\x01\x04\"Q0\x01$\x81\x01\x20\x01\x14\x11E\x11\x20A\x05\x16\x01\x06\x110\x01\x16\x11\x05\x16\x01\x06!\x20\x01\x16!\x056\x17\x01\x10\x01\x05\x06\x05\x01\x05\x06\x01\x15&\x01\x20\x01%\x061\x15!"
    b"\x20\x11\x15\x16A0\x11\b\x01E\x01@\x01\x04\x02\x01\bAP\x01\x12\x03!\x04\x03\x11\x00\x01\x10\x01\x04\x02\x03\x01&\x01\x04\x03\x11\x06\x01\x00\x01\x04\x02\x01\x05\x06\x17\x06\x01\x04\x02\x01\x05\x01\x00\x01\x14\x01\x15&A\x10\x11\x14\x01%\x01\t\x1a\t"
    b"\x01\x20!\x0b!\x19\x1a\t\x01\x20\x01+\x18\n\b*\b\x010\x01\x0b\x18\n\b\x0b8\x11\x10\x01\x0c\x01\x0b\x18\x0b\x01\x1b\b\x01\r\x0e\x01\x00\x01\x0c\x01+\x01\x00\x01\x0b\x01\r\x0e\x0c\x01\x00\x01\x0c\x0e!\x20\x01\x1e\x0c\x01\x20\x01\x0c\x1e\x0c\x01\x10"
    b"\x01\x1c\x01@A\x20\x11\x20"
  ),
  (
    b"\x80\x01i\x00\x01j\tj\t\x12\x03\x04\x1a\x04\x03\x12\t\x12\x0b\x04\x12\x04\x03\x12\t\x12\x13\x12\x04\x03\x12\t\x12\x03\x04\x0b\n\x04\x03\x12\t\x12\x03\x0c\x03\x04\x02\x04\x03\x12\t\x12\x03\x04\x02\x04\x03\x0c\x03\x12\t\x12\x03\x04\n\x0b\x04\x03\x12"
    b"\t\x12\x03\x04\x12\x13\x12\t\x12\x03\x04\x12\x04\x0b\x12\t\x12\x03\x04\x1a\x04\x03\x12\tj\tj\x01"
  ),
  (
    b"\x80\x01i\x00\x01j\t\n\x0b,\x0b\n\t\x02\x03T\x02\t\x02\\\x03\t\x03\x14\x03\"\x14\x03\t\x03\x14J\t\x03\x14J\t\x03\x14J\t\x03\x14*\x14\x03\t\x02\x14+\x14\x03\t\x02\x03T\x03\t\n\x03D\x03\x02\t\x1a3\x12\tj\x01"
  ),
  (
    b"\x06\a\x16\a\x02\x03\x0e\a\x16\t\x00\x01\x00\x05\b\t\x00\x01\x00\x05\b\a\x00\x03\x02\x03\x00\r\x02\x03\x00\a\x00\r\x00\x01\x00\t\x02\x0b\x00\x01\x00\t\x02\x0b\x00\x01\x00\t\x04\x03\x00\x03\x06\x05\x0e\x01\x04\x03\x12\t\x16\a\x16\x05\x1a\x05\x06"
  ),
)
for j in range(-1, 2, 2):
  for i in range(1, 3):
    x = screen_w//2 - j*(screen_w * i // 6)
    if i+j != 3:
      qr_mark(x - 7, screen_h - 15, 7, [(k + 2) % 3 == i + j and 255 or 0 for k in range(3)], 2)
      show()
      draw_image(images[2 + i + j], x - 8, screen_h - 64, 16, palettes[2 + i + j], itransp=0)
      show()
    draw_image(images[i+j == 3], x - 8, screen_h - 48, 16, palettes[i+j == 3], itransp= i+j!=3 and -1)
    show()

palettes = (
  (
    (0,0,0),(0,0,0),(190,232,247),(190,97,0),(231,139,18),(157,199,239),(247,247,247),(247,176,64),(149,54,0),(133,172,207),
  ),
)
images = (
  (
    b"Q\x061\x05\xc1\x02\x19\x01\t\x01\x16\x11\x02\x05\x01\t\x01\x19\x01\t\x01\x89\x01\x01\t\x11\x15\x01\x05\x01\x16\x11\x02\x05\x01\x05\x01\x15\x01\x05\x01\x85\x01\x01\x05\x11\x12!\x16\x11\x02\x05!\x12\x01\x05\xa1\x01\x05\x11\x12\x01\b\x01B\x05\x01\b\x01\x12"
    b"\x01\x05\x01\x88\x01\x01\x05\x11\x16\x01\x18Q\x18\x01\x16\x01\x05\x01\x88\x01\x01\x05\x11\x12\x01\b\x03h\x04\x01\x12\x01\x05\x01\x88\x01\x01\x05\x11\x16\x01\bc\x14\x01\x16\x01\x05\x01h\x03\b\x01\x05\x11\x16\x01\bS$\x01\x16\x01\x05\x01X\x13\b\x01\x05\x11"
    b"\x12\x01\bC$\x03\x01\x12\x01\x05\x01H#\b\x01\x05\x11\x16\x01\b3$\x13\x01\x16\x01\x05\x018#\x18\x01\x05\x11\x12\x01\x98\x01\x01\x12\x01\x05\x01\x88\x01\x01\x05\x11\x12\xb1\x01\x12\x01\x05\xa1\x01\x05\x11\x12\x01\x19\x05b\x01\x12\x01\x05\x01e\x19\x01\x05"
    b"\x11\x12\x01\x19\x05b\x01\x12\x01\x05\x01e\x19\x01\x05\x81\x04"
  ),
  (
    b"P\xb1\x02\x90\x01\x11\x12\x11\xf4\x00\x01\x12\x11%\x11`\x01\x16\x11\x04\xf7\x00\x01\x16\x01\x15!\x15\x01@\x01\x16\x01\x04\x87\x01\x01\x16\x01\x05\x11(\x11\x05\x010\x01\x16\x01\x04\x87\x01\x01\x16\x01\x05\x01H\x01\x05\x01\x20\x01\x16\x01\x03\x84\x01\x01"
    b"\x16\x01\x05\x01h\x01\x05\x01\x10\x01\x16\x01\x03\x84\x01\x01\x16\x01\x05\x01h\x01\x05\x01\x10\x01\x16\x01\x03\x84\x01\x01\x16\x01\x05\x01h\x01\x05\x01\x00\x01\x12\x01\b\x83\x01\x01\x12\x01\x05\x01h\x03\b\x01\x05\x11\x16\x01\b\x83\x01\x01\x16\x01\x05"
    b"\x01X\x13\b\x01\x05\x11\x16\x01\b\x83\x01\x01\x16\x01\x05\x01H#\b\x01\x05\x11\x12\x01\b\x83\x01\x01\x12\x01\x05\x018#\x18\x01\x05\x11\x16\x01\b\x03Q\b\x03\x01\x16\x01\x05\x01(#(\x01\x05\x11\x12\x01\b\x01&\x12\x05\x01\b\x01\x12\x01\x05\x01\x18#8\x01\x05"
    b"\x11\x12\x01\b\x01\x16\x11\x02\x05\x01\b\x01\x12\x01\x05\x01\b#(\x03\b\x01\x05\x11\x15\x01\b\x01\x061\x05\x01\b\x01\x15\x01\x05\x01\x88\x01\x01\x05\x01"
  ),
  (
    b"P\xc1\x02\x80\x01\x11\x12\x01\x03\x84\x01\x01\x12\x11%\x11P\x01\x16\x01\x14\x87\x01\x01\x16\x01\x15!\x15\x01@\x01\x16\x01\x04\x97\x01\x01\x16\x01\x05\x01(\x01\x05\x010\x01\x16\x01\x04\x97\x01\x01\x16\x01\x05\x01H\x01\x05\x01\x20\x01\x16\x01\x03\x94\x01"
    b"\x01\x16\x01\x05\x01H\x01\x05\x01\x20\x01\x12\x01\x03\x94\x01\x01\x12\x01\x05\x01H\x01\x05\x01\x20\xa1\x02\x05\x01X\x01\x05\x01\x20\x01\x89\x02\x11X\x01\x05\x010\x01\t\xe1\x01\t\x11H\x01\x05\x01@\x01\t\xe1\x01\t\x118\x01\x05\x01P\x01\t\xe1\x01\t\x11("
    b"\x01\x05\x01P\x91\x02\t\x11\x18\x01\x05\x01@\x01&\x12\x05\xc1\x01\t\x11\b\x01\x05\x01@\x01\x16\x11\x02\x05\xd1\x01\t!\x05\x01@\x01\x061\x05\xe1\x01\t\x11\x05\x01"
  ),
)
for i in range(2):
  draw_image(images[-i], screen_w//2-16, screen_h-32-16*i, 32, palettes[0], itransp=0)
show()

def qr_size(v):
  return 17 + 4*v

qr_ver = 3
qr_margin = 4
qr_size_code = qr_size(qr_ver)
qr_size_code_margin = qr_size_code + 2*qr_margin + 4
qr_zoom = max(1, min(screen_w // qr_size_code_margin, (screen_h - 128) // qr_size_code_margin))
qr_size_code_margin -= 4
qr_width = qr_size_code_margin * qr_zoom
x_qr = (screen_w - qr_width) // 2
y_qr = (screen_h - qr_width) // 2
for k in range(1, 3):
  draw_rect_z(x_qr - k*qr_zoom, y_qr - k*qr_zoom, qr_size_code_margin + 2*k, qr_size_code_margin + 2*k, k > 1 and (0, 0, 0) or (255, 255, 255), qr_zoom)
qr_margin *= qr_zoom
fill_rect(x_qr, y_qr, qr_width, qr_width, (0,64,64))

def qr_alignments(v):
  s = qr_size(v)
  positions = []
  n = v // 7 + 2
  first = 4
  positions.append(first)
  last = s - 5 - first
  step = last - ((first + last*(n - 2) + (n - 1)//2) // (n - 1) & -2)
  second = last - (n - 2) * step
  positions.extend(range(second, last + 1, step))
  return positions

def qr_frame(v, x, y, c, z=1):
  s = qr_size(v)
  l = (0, s - 7)
  for dy in l:
    for dx in l:
      if not dx or not dy:
        qr_mark(x + dx*z, y + dy*z, 7, c, z)
  for i in range(8, s-8, 2):
    fill_rect(x + i*z, y + 6*z, z, z, c)
    fill_rect(x + 6*z, y + i*z, z, z, c)
  l = qr_alignments(v)
  for dy in l:
    for dx in l:
      if not (dy < 8 and (dx < 8  or dx > s - 10) or dx < 8 and dy > s - 10):
        qr_mark(x + (dx - 0)*z, y + (dy - 0)*z, 5, c, z)

qr_frame(qr_ver, x_qr + qr_margin, y_qr + qr_margin, (255,255,255), qr_zoom)

palettes = (
  (
    (0,0,0),(255,255,255),
  ),
  (
    (0,0,0),(255,255,255),
  ),
  (
    (0,0,0),(0,0,255),
  ),
  (
    (0,0,0),(255,0,0),(255,0,255),
  ),
)
images = (
  (
    b"\x1e\x01\x02\x03,\x05\x02\x012\x014\x014\x01\x00\x056\x01n\x030\x01\x00\x01\x00\x01\x00\x01\x00\x01\x00\x01\x20\a\x00\a\x04\x01\x1a\a\x02\x03\x02\x01\"\x01\x00\x01\x00\x05\x02\x01\x00\x01\x00\x01\x1c\x01\x00\x03\x0c\x03\x1e\x05\x02\x0b\x04\x01\x1c"
    b"\x01\n\x01\x00\x05&\x03\x00\x03\x00\x01\x02\x01$\x01\x00\x01\x02\x01\x00\x03\"\x01\x02\x0b\x00\x01\x00\x01\x1c\x03\x00\x01\x00\x01\x02\x03\x00\x01\"\x01\x00\x05\n\x01\x1c\x01\x00\x01\x00\x03\n\x05\x1c\x03\x0e\a\x1c\x01\x02\x03\b\x03$\x05\x0c\x032"
    b"\x05\x1c\x01\x00\x03\x00\x01\x06\x03\x20\x01\x00\a\x00\x0b\x1e\x03\x00\x01\x00\x01\x04\x03\x00\x01\x1e\x03\x00\x01\x02\x01\x00\a\x02"
  ),
  (
    b"\x16\x01\x00\x01*\x01\x04\x038\x01*\x01\x06\x01f\x01\n\x01n\x01\x1a\t\x02\x03\b\x01$\x01\x02\x01:\x01^\x01\x0c\x01(\x01<\x01\x00\x01\b\x01\"\x01\x0c\x01:\x01\x00\x01\x18\x01\x02\x01\x00\x01\x04\x01\x02\x01\x1e\x01\x14\x01\x1e\x016\x01\n\x018\x01"
    b"\x02\x01\x00\x01,\x03\x02\x016\x01.\x01\x06\x03*\x01\x06\x01,\x016\x016\x01\x00\x01\""
  ),
  (
    b"J\x018\x01\x00\x01\x02\x01*\x03\x04\x030\x03.\x01\x00\x01\x06\x01f\x012\x03\x00\x03\x00\x01\x18\x01\x0e\x03\x00\x03&\x01\x04\x01\x04\x01$\x01\x06\x01\x00\x03\"\x01\x02\x01\x02\x01\x04\x01,\x03\x04\x03\x1c\x01\x02\x01\x06\x01\x00\x01\x04\x01$\x01"
    b"\x06\x01\x04\x010\x03,\x01.\x05\x04\x01(\x05\x04\x01\x00\x01&\x01\x00\x03\n\x012\x01\x04\x010\x01\x00\x01\x02\x01(\x03\x02\x05*\x01\x02\x010\x01\x02\x01\x00\x01,\a\x00\x01,\x058\x01\x1e"
  ),
  (
    b"\x20\x01\x00\x01\x00\x01\x00\x01h\x01`\x01\b\x02T\x02\x04\x01`\x01\x0c\x01X\x02\x01\x00\x01\x00\x01\xcc\x01\x05\x0c\x05P\x02\x04\x02\x04\x02\x010\x05\x00\x01\x14\x01\x04\x014\t\x00\x01\x14\x05<\x05$\x02D\x02\x05\x04\x01\x04\x01\x00\x02\x01H\x01\x04"
    b"\x06L\x02\x18\x02\x01\x00\x01@\x01\x00\x01\x10\x01\b\x01<\x01\x04\t\x00\x01\x00\x05\x06\b\x014\x01l\x01\x18\x01L\x02\x04\x01\x14\x01H\x01\x02\x0c\x01\b\x01\\\x01\x04\x01\x00\x02\\\x01\b\x01\x00\x02P\x02\x10\x02`\x02l\x02`\x06p\x02\tX\x01\x04\x02<"
  ),
)

for k in range(len(images)):
  draw_image(images[k], x_qr + qr_margin, y_qr + qr_margin, qr_size_code, palettes[k], zoomx=qr_zoom, zoomy=qr_zoom, itransp=0)
show()
wait()

Lien : lots et ressources

[critor]

Avant d'adopter le format calculatrice de poche, les futurs modèles de Texas Instruments prennent dans un premier temps la forme de cartes de développement.

Voici par exemple ci-contre un exemplaire de la carte de développement ayant servi à développer la légendaire TI-89 de 1998. Elle est ici connectée via une nappe à un boîtier TI-89 quasiment dépourvu de toute électronique interne, n'étant là que pour fournir le clavier et l'écran, soit de quoi tester malgré tout dans des conditions aussi proches que possible de celles de l'utilisateur final.

Cette pièce d'un intérêt historique exceptionnel, peut-être le dernier exemplaire sur Terre, a été dénichée par parrotgeek1 puis achetée par Brandon Wilson.

De passage à TI-Dallas en 2011, Adriweb nous avait brièvement photographié une carte de développement TI-Phoenix 1, ancien nom des prototypes TI-Nspire+ et TI-Nspire CAS+ de 2006-2007 sur processeur OMAP, photos reproduites avec autorisation de Texas Instruments.

Ici la carte était reliée à un boîtier TI-Nspire n'étant là que pour fournir le clavier, et Adriweb avait bien pris le temps de te montrer qu'il était complètement vide en dehors de ça :

Un peu plus récent, voici la carte de développement des TI-Nspire monochromes finalement très différentes de 2007, migrant du processeur OMAP à un ASIC.

Ici l'écran était directement intégré à la carte, mais une nappe servait quand même à avoir le clavier externe.

Probablement mise en public par erreur dans sa galerie photos par l'un des développeurs de la TI-Nspire, Zac Bowling.

Justement à ce sujet, parrotgeek1 et Brandon Wilson ont également déniché et acheté d'autres pièces intéressantes.

Ci-dessous plusieurs boîtiers TI-Nspire TouchPad destinés à être reliés via des nappes à une carte de développement TI-Nspire, ne fournissant ici encore comme tu peux le voir ci-contre que l'électronique minimale permettant d'avoir le clavier et l'écran.

Une grosse protubérance latérale permet de faire ici sortir du boîtier 4 connecteurs de nappe :

Toujours dans le même lot, voici maintenant un boîtier TI-Nspire TouchPad muni d'un écran couleur, et donc destiné à être utilisé avec une une carte de développement TI-Nspire CX :

Toujours dans ce domaine, nouvelle découverte historique très précieuse aujourd'hui par Frédéric Desautels alias mr womp womp. Il vient de dénicher et acheter des boîtiers encore différents pour carte de développement TI-Nspire.

Cette fois-ci il y a 2 protubérances latérales bien plus modestes de part et d'autre faisant sortir seulement 2 connecteurs de nappe au nombre de broches différent, sans doute un pour le clavier et un pour l'écran :

Ces boîtiers n'ont toutefois pas d'intérêt en dehors des personnes se sentant l'âme d'un conservateur ou d'un collectionneur. Dépourvus de tout élément interne actif, ils sont totalement inutilisables sans la carte de développement TI-Nspire sur laquelle les brancher. Quel dommage qu'elle ne soit toujours pas venue avec. Peut-être la prochaine fois ?...

[critor]

Historiquement, transférer des données sur ta calculatrice graphique avait toujours été compliqué. Cela nécessitait l'installation et l'utilisation d'un logiciel dédié propriétaire, usuellement disponible pour ordinateur sous Windows et Mac.

On peut citer de façon non exhaustive :

• TI-Graph Link
• TI-Connect
• TI-Connect CE
• TI-Nspire Computer Link
• TI-Nspire Student ou TI-Nspire Teacher
• Casio FA-123
• Casio FA-124
• Casio FA-CP1
• HP Connectivity Kit

Il y avait certes déjà le problème des ordinateurs du lycée, l'installation du logiciel et des pilotes associés nécessitant les droits d'administration.

Mais pire encore de nos jours, il y a multiplication des appareils utilisant d'autres systèmes d'exploitations : Linux, Android ou iOS (smartphones, tablettes), ou encore Chrome OS (Chromebooks). En plus d'être compliquée cette solution était donc désormais totalement inadaptée.

Casio a été le premier constructeur à réagir. Lors du renouvellement progressif de ses modèles, le constructeur a fait le choix de les faire se comporter en tant que périphériques de stockage de masse USB. Une solution parfaitement standard qui permet désormais le transfert de données par simple copié-collé de fichiers, aussi facilement qu'avec une clé USB, fonctionnant ainsi sur n'importe quel système d'exploitation !

On peut citer :

• pour les modèles couleur les fx-CG10 et fx-CG20 (rentrée 2011), remplacées aujourd'hui par les fx-CG50 et Graph 90+E
• pour les modèles formels la Classpad 330 Plus (rentrée 2012), remplacée aujourd'hui par les fx-CG500 et fx-CP400
• pour le milieu de gamme les Graph 35+E II en France (rentrée 2019) puis les fx-9750GIII et fx-9860GIII dans le reste du monde (rentrée 2020)

Et puis depuis son arrivée à la rentrée 2017, nous avons la solution différente apportée par NumWorks, une solution en ligne, historiquement appelée workshop avant d'être rebaptisée pour cette rentrée 2021. Il suffit en effet de se connecter à my.numworks.com pour pouvoir à la fois transférer des scripts Python et mettre à jour sa calculatrice.

La page en question est compatible avec les navigateurs Internet gérant les requêtes de connexion à des périphériques USB, soit à ce jour Google Chrome et les navigateurs utilisant le moteur Chromium (Microsoft Edge, Opera/Vivaldi, ...).

Outre le besoin donc d'une connexion Internet, on peut reprocher plusieurs défauts majeurs à cette solution :

• l'impossibilité de de transférer un fichier de script Python local, il y a obligation d'héberger son script Python sur le site NumWorks avant de pouvoir le transférer, ce qui se révélera rapidement très lourd si tu as plusieurs scripts à transférer
• inversement, l'impossibilité de sauvegarder un script Python de ta calculatrice en local sur ton ordinateur, sa seule destination sera ici encore le site NumWorks, alors que tu n'as pas forcément envie de mettre le bazar dans ton compte NumWorks avec de petits scripts de test mal nommés

Cela semble être une volonté du constructeur de vouloir que tout passe par lui, souhaitant ainsi pouvoir tout contrôler.

Le problème, c'est que la gestion de projets de la solution en ligne est absolument rudimentaire, et pèse alors très lourdement sur les usages qui nous sont imposés :

• impossibilité de classer ses scripts Python dans des dossiers sur son compte NumWorks, tous tes scripts seront présentés par ordre alphabétique sur la même page, tu ne peux au mieux que les renommer mais cela cassera alors bêtement les adresses que tu auras éventuellement partagées
• impossibilité de gérer des projets de plusieurs scripts Python, ce qui pousse salement à la duplication de code et par conséquent à une maintenance de plus en plus pénible

Hélas aucune évolution sur ces très douloureux manques depuis 2017 malgré plusieurs retours.

Il restait donc Texas Instruments et Hewlett Packard à ne pas avoir encore effectué leur transition.

Historiquement avec les TI-Nspire CX , nous disposions de 2 solutions officielles pour les transferts de fichiers :

• le logiciel TI-Nspire Computer Link, léger et gratuit
• les logiciels TI-Nspire CX Student ou TI-Nspire CX Teacher, reproduisant intégralement l'environnement TI-Nspire sur ton ordinateur, nécessitant un numéro de licence au-delà de 90 jours d'utilisation (un numéro de licence à usage unique vient avec chaque calculatrice achetée à neuf, ou sinon peut être acquis séparément)

Problème, avec le lancement des TI-Nspire CX II pour la rentrée 2019, Texas Instruments a fait le choix de ne plus mettre à jour le logiciel gratuit TI-Nspire Computer Link. Une décision qui a rapidement rendu le transfert des fichiers sur TI-Nspire CX II absolument cauchemardesque, même pour nous :

• le moindre petit transfert de fichier ou capture d'écran nécessitait donc de lancer le logiciel TI-Nspire CX Student ou TI-Nspire CX Premium, un logiciel extrêmement lourd étant très loin de se lancer instantanément contrairement au précédent
• impossible d'utiliser durablement plusieurs ordinateurs pour cela, un numéro de licence t'étant réclamé au-delà de 90 jours d'utilisation, et tu n'en as qu'un seul dans la boîte
• et même pire, si tu prends ta TI-Nspire CX II d'occasion il est probable qu'elle vienne sans numéro de licence utilisable, et que donc tu sois rapidement dans l'impossibilité d'y transférer quoi que ce soit

Il y a quelques mois, nous t'annoncions que Texas Instruments lançait lui aussi une solution de connectivité en ligne pour ses TI-Nspire CX II avec le site TI-Nspire CX II Connect.

Mais à l'époque cette solution ne concernait que le système d'exploitation Chrome OS et donc que les Chromebooks, l'accès aux fonctionnalités étant refusé si tout autre système d'exploitation était détecté.

C'est finalement avec la solution de connectivité en ligne que Texas Instruments a choisi de répondre à la problématique. En effet pour cette rentrée 2021, Texas Instruments nous officialise enfin TI-Nspire CX II Connect en tant que solution universelle de connectivité légère pour les TI-Nspire CX II. Le code qui interdisait l'utilisation depuis des systèmes d'exploitation autres que Chrome OS vient d'être retiré. Tu peux désormais transférer facilement des fichiers sur ta TI-Nspire CX II depuis ton navigateur Google Chrome ou compatible, et ce peu importe que tu sois sous Windows, Mac, Android, iOS, Linux ou autre !

Le bouton de connexion te liste donc le ou les périphériques compatibles. Comme le nom de l'outil l'indique, précisons que seules les TI-Nspire CX II sont gérées. Les anciennes TI-Nspire CX n'apparaîtront pas.

Tu dois alors choisir ce que tu veux faire. 3 tâches sont au choix :

• prendre une capture d'écran
• transférer des fichiers (vers la calculatrice ou depuis la calculatrice)
• ou mettre à jour le système d'exploitation

Ici contrairement à la solution NumWorks, on apprécie la liberté. Les captures d'écran et fichiers récupérés depuis la calculatrice, peuvent au choix être :

• copiés dans le presse-papier (captures d'écran uniquement)
• enregistrées en local sur l'ordinateur
• ou bien enregistrées directement sur ton compte Google Drive

Et donc que tu choisisses le stockage local ou en ligne sur Google Drive, tu bénéficies dans les deux cas de la possibilité très avantageuse d'organiser tes fichiers selon des dossiers !

Inversement pour le transfert de fichier vers la calculatrice, tu peux ici encore de façon similaire choisir un fichier local ou bien un fichier de ton compte Google Drive.

Seul point sur lequel Texas Instruments n'a par contre pas fait le choix de la liberté (mais pas pire que NumWorks pour autant), c'est pour la mise à jour. Tu n'as pas le choix de la version, l'outil t'installe obligatoirement la dernière.

Si faute d'alternative TI-Nspire CX II Connect se démocratise en tant que nouvelle solution de connectivité de référence pour les TI-Nspire CX II, il pourra ainsi devenir un formidable levier pour contrer Ndless. L'utilisation d'une version suffisamment récente pourrait en effet devenir à tout moment obligatoire afin de pouvoir continuer à profiter du service par exemple.

Des solutions tierces sur navigateur existent désormais cela dit, mais ce sera l'objet d'un autre article de news bien mérité, prochainement

Lien : TI-Nspire CX II Connect
Source : https://twitter.com/TIEducationFR/statu ... 5724782597

[critor]

Combien Consomme ma Calculatrice 2021

Épisode 9 - TI-Nspire CX révision ≤N (batterie avec câble)
index des épisodes

Nous sommes en plein QCC 2021 Universel, événement au cours duquel nous te publions et alimentons la base de données intégrale de nos classements de rentrée QCC organisés depuis la rentrée 2015.

Nous t'avons également lancé un événement dans l'événement, le CCC 2021, pour Combien Consomme ma Calculatrice.

Nous nous étions d'abord occupés de mesurer l'intensité tirée par les modèles à piles AAA. Pour cela nous avions ouvert le circuit en utilisant une fausse pile, bricolée à cette fin.

Puis nous étions passés aux modèles à batterie. Nous ne pouvions bien évidemment pas utiliser le même protocole. Nous avions retenu un testeur USB. Afin d'espérer éliminer la consommation due au circuit de recharge de la batterie, nous avions réalisé les mesures avec la batterie retirée, la calculatrice étant donc intégralement alimentée via son port USB.

Pour des intensités très faibles, calculatrices éteintes, vu les mesures obtenues nous doutions de la précision et donc fiabilité de ce testeur USB.
On pouvait toutefois supposer que les mesures avec calculatrice allumée était bien plus correctes, et probablement comparables d'un modèle à un autre.

Restait toutefois une inconnue. Même avec batterie déconnectée, le circuit de recharge ne viendrait-il pas perturber les mesures en question ?

Aujourd'hui donc, nous reprenons les mesures concernant les TI-Nspire CX de révision matérielle N ou inférieure (produites jusqu'en octobre 2015), c'est-à-dire celles utilisant une batterie avec câble.

Remercions cent20 qui a grandement contribué à la faisabilité de ce test. Il nous a en effet fort gracieusement envoyé une de ces batteries jamais utilisée et donc entièrement neuve, l'idéal pour le test.

Nous nous munissons d'éléments permettant de lui adjoindre une rallonge. Il suffit pour cela de chercher de la connectique pour batteries LiPo à 4 câbles.

Rajoutons sur la voie d'alimentation de la rallonge en question un interrupteur inverseur :

• position I pour une alimentation normale de la calculatrice
• position II pour la connexion d'un ampèremètre sur les bornes externes

Et voici donc le protocole de mesure final.

Le même style de protocole serait réalisable pour les NumWorks, mais nous ne disposons pas encore des références de connectique batterie les concernant.

Pour les HP Prime et TI-Nspire CX plus récentes utilisant une batterie format smartphone Samsung, impossible de procéder de cette façon puisqu'elles sont dépourvues de câble.
Il nous faudra trouver autre chose...

Les mesures sont effectuées à l'aide d'une TI-Nspire CX II. Nous utiliserons un capteur d'intensité Vernier, muni d'une prise BT-A (le standard historique de téléphonie analogique chez British Telecom). Nous le relions donc à la TI-Nspire CX II à l'aide de l'interface Vernier EasyLink.

Nous configurons la TI-Nspire CX II pour effectuer :

• 50 mesures par seconde
• pendant une durée de 29 secondes

Les mesures sont effectuées avec la batterie chargée à 100%

Nous allons effectuer les mesures sous différentes conditions :

• Calculatrice éteinte (hors mode examen + en mode examen)
• Calculatrice allumée mais inoccupée (hors mode examen + en mode examen)
• Calculatrice en train d'effectuer un calcul suffisamment long (hors mode examen + en mode examen)
  Nous choisissons en mode degrés :
  $mathjax$\sum{\sqrt[3]{e^{sin\left(Arctan\left(x\right)\right)}}}$mathjax$

De plus, nous effectuerons les mesures sous différents réglages de la luminosité de l'écran :

• maximal
• minimal

Enfin, les mesures seront effectuées sur 4 calculatrices différentes, et nous retiendrons la moyenne :

• TI-Nspire CX en révision matérielle C
• TI-Nspire CX CAS en révision matérielle C
• TI-Nspire CX CAS en révision matérielle D
• TI-Nspire CX CAS en révision matérielle J

Bien meilleure précision ici (ou absence d'élément perturbateur), les mesures relevées sont comme tu peux le constater ci-contre extrêmement proches d'une calculatrice à une autre, confirmant la pertinence du regroupement de toutes les machines de révision N ou inférieure.

Éteintes, ces TI-Nspire CX tirent donc en moyenne 0,726 mA.

Une fois le mode examen activé, la diode examen s'active toutes les 2 secondes avec un double flash, ce qui génère des pics de consommation comme illustré sur le diagramme ci-contre. Cela fait monter l'intensité moyenne mesurée à 1,107 mA.

Voici le reste des mesures :

TI-Nspire CX rév. ≤N	hors mode examen	en mode examen	éclairage écran
éteinte	0,829 mA	1,093 mA (+31,75%)
inoccupée	24,468 mA 73,163 mA	24,851 mA (+1,56%) 73,567 mA (+0,55%)	minimal maximal
calcul	39,873 mA 89,189 mA	40,232 mA (+0,90%) 89,671 mA (+0,54%)	minimal maximal

Comme sur certains modèles à écran couleur, nous n'avons pas moyen de rerégler la luminosité par défaut, nous retenons pour les comparaisons les mesures effectuées sous la luminosité maximale.

Tableau comparatif :
Accès QCC 2021 Universel

[critor]

Quelle Calculatrice Choisir 2021 édition Universelle

Épisode 10 - Python turtle + compatibilité

Pour fêter les 10 ans de TI-Planet en cette rentrée 2021, nous te publions la base de données intégrale de nos classements de rentrée QCC organisés depuis la rentrée 2015.

Nous en profitons de plus pour te réaliser le travail titanesque d'étendre les tests aux modèles plus anciens :

• toutes les calculatrices graphiques Texas Instruments (depuis la première TI-81 de 1990)
• les calculatrices graphiques Casio de la génération Icon Menu Power Graphic (depuis 1996)

Ce qui donne pas moins de 163 modèles différents testés sous toutes leurs coutures, 10 ans de tests et découvertes à portée de clic !

Aujourd'hui restons sur le Python et parlons turtle. Il y a justement du nouveau à ce sujet, puisque Texas Instruments vient tout juste de sortir un module turtle additionnel pour ses TI-Nspire CX II.

Mais qu'est-ce que c'est que turtle ? Les interpréteurs Python sur nos calculatrices peuvent offrir usuellement jusqu'à 3 types de modules de tracé :

• tracé par pixels, habituellement propriétaire au constructeur
• tracé dans un repère, plus ou moins proche du standard matplotlib.pyplot
• et tracé relatif à la tortue, plus ou moins proche du standard turtle, le plus proche de ce qui a été pratiqué au collège avec le langage Scratch

Nous allons profiter de l'occasion pour faire d'une pierre deux coup. Nous allons à la fois découvrir ensemble le nouveau turtle des TI-Nspire CX II, et directement le comparer à ce qui existe déjà chez la concurrence, à savoir :

• turtle pour TI-Nspire CX II
• turtle sur Casio Graph 35+E II et Graph 90+E
• turtle sur NumWorks
• turtle via KhiCAS sur NumWorks et TI-Nspire CX
• ce_turtl sur TI-83 Premium CE Edition Python, TI-84 Plus CE-T Python Edition et TI-84 Plus CE Python

Nous allons donc exécuter quelques scripts turtle et comparer leurs affichages à ce que donne le turtle Python standard sur ordinateur, et donc la plus ou moins grande facilité que tu auras à exécuter des scripts Python turtle conçus pour d'autres plateformes. ce_turtl était particulièrement mauvais sur ce dernier point ; nous allons donc voir si Texas Instruments a apporté davantage de soin à son module turtle pour TI-Nspire CX II.

Commençons déjà par détecter quelques problèmes bloquants avant l'exécution, et peut-être même les corriger. Voici notre tout nouveau Turtle Doctor :

Code: Select all

_turtle_errors = 0

def _turtle_error(k):
  global _turtle_errors
  _turtle_errors |= 1 << k

# import turtle
try: #TI-83 Premium CE
  from ce_turtl import turtle
  turtle.clear()
  _turtle_error(0)
except ImportError:
  import turtle
  if not "forward" in dir(turtle):
    turtle = turtle.Turtle()

# can turtle be patched ?
_fix_turtle = True
try:
  def _fixcolorlist(c): return c
  def _fixcolorval(c): return c
  def _fixcolorstring(c): return c
  def _fixcolor(c): return turtle._fixcolorlist(turtle._fixcolorval(turtle._fixcolorstring(c)))
  turtle._fixcolorlist = _fixcolorlist
  turtle._fixcolorval = _fixcolorval
  turtle._fixcolorstring = _fixcolorstring
  turtle._fixcolor = _fixcolor
except:
  _fix_turtle = False

# test/fix color() + pencolor()
if not "pencolor" in dir(turtle):
  _turtle_error(1)
  if _fix_turtle: turtle.pencolor = turtle.color
if not "color" in dir(turtle):
  _turtle_error(2)
  if _fix_turtle: turtle.color = turtle.pencolor

# test color argument types
_color_types = 0
try:
  turtle.pencolor([0, 0, 0])
  _color_types |= 1 << 0
except: _turtle_error(4)
try:
  turtle.pencolor((0, 0, 0))
  _color_types |= 1 << 1
except: _turtle_error(5)
try:
  turtle.pencolor(0, 0, 0)
  _color_types |= 1 << 2
except: pass
try:
  turtle.pencolor("black")
  _color_types |= 1 << 3
except: _turtle_error(6)
_fix_color = not _color_types & 1 << 0 or not _color_types & 1 << 1 or not "colormode" in dir(turtle)

# fix list/tuple color argument
if _fix_turtle:
  if not _color_types & 1 << 0 and _color_types & 1 << 1:
    def _fixcolorlist(c): return type(c) is list and tuple(c) or c
    turtle._fixcolorlist = _fixcolorlist
  if not _color_types & 1 << 1 and _color_types & 1 << 0:
    def _fixcolorlist(c): return type(c) is list and list(c) or c
    turtle._fixcolorlist = _fixcolorlist

# fix color() + pencolor()
if _fix_turtle and _fix_color:
    turtle._color = turtle.color
    turtle._pencolor = turtle.pencolor
    if _color_types & 1 << 0 or _color_types & 1 << 1:
      def _color(*argv):
        if not(len(argv)): return turtle._color()
        turtle._color(turtle._fixcolor(argv[0]))
      def _pencolor(*argv):
        if not(len(argv)): return turtle._pencolor()
        turtle._pencolor(turtle._fixcolor(argv[0]))
    else:
      def _color(*argv):
        if not(len(argv)): return turtle._color()
        c = turtle._fixcolor(argv[0])
        turtle._color(c[0], c[1], c[2])
      def _pencolor(*argv):
        if not(len(argv)): return turtle._pencolor()
        c = turtle._fixcolor(argv[0])
        turtle._pencolor(c[0], c[1], c[2])
    turtle.color = _color
    turtle.pencolor = _pencolor

# test/fix colormode()
_color_mode = 0
if not "colormode" in dir(turtle):
  _turtle_error(3)
  # test color mode
  try:
    turtle.pencolor([255, 0, 0])
    _color_mode = 255
  except: _color_mode = 1.0
  if _fix_turtle:
    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:
      def _fixcolorval(c): return int(turtle._color_mode) == 1 and type(c) in (list, tuple) and [int(c[k] * 255) for k in range(3)] or c
    else:
      def _fixcolorval(c):
        return turtle._color_mode == 255 and type(c) in (list, tuple) and [int(c[k] / 255) for k in range(3)] or c
    turtle._fixcolorval = _fixcolorval

# test/fix color strings
_colors_fix={"black":(0,0,0),"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)}
for c in list(_colors_fix.keys()):
  try:
    turtle.pencolor(c)
    _colors_fix.pop(c)
  except: pass
turtle.pencolor((0, 0, 0))
if len(_colors_fix):
  if _color_types & 1 << 3:
    _turtle_error(7)
  if _fix_turtle:
    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

# test/fix circle(,)
try: turtle.circle(0,0)
except:
  _turtle_error(8)
  if _fix_turtle:
    turtle._circle = turtle.circle
    def _circle(r, a=360): turtle._circle(r)
    turtle.circle = _circle

if not "write" in dir(turtle):
  _turtle_error(9)
  if _fix_turtle:
    def _write(s): pass
    turtle.write = _write

if not "pensize" in dir(turtle):
  _turtle_error(10)
  if _fix_turtle:
    def _pensize(s): pass
    turtle.pensize = _pensize

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(): " + str(_color_mode),
    "No color as list",
    "No color as tuple",
    "No color as string",
    "Missing colors strings: ",
    "No circle(,angle)",
    "No write()",
    "No pensize()",
  )
  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 == 7:
        msg += str(len(_colors_fix)) + " " + str(tuple(_colors_fix.keys()))
      print(msg)
  print(str(errors) + " error" + ((errors > 1) and "s" or ""))

Le but de Turtle Doctor et donc d'anticiper les erreurs, afin que les scripts qui vont suivre puissent bien afficher quelque chose d'utile.

Par exemple, Turtle Doctor ne détecte a priori strictement aucun problème bloquant sur la NumWorks

Aucun problème non plus avec KhiCAS pour NumWorks et TI-Nspire CX !

Sur Casio Graph 35+E II et Graph 90+E, quelques détails :

• absence de la méthode .color()
• absence de la méthode .colormode()

Mais ici, Turtle Doctor détecte que le module turtle est modifiable : on peut le patcher à chaud (à chaque exécution) afin de corriger.

Le but des corrections n'est pour le moment pas d'obtenir quelque chose d'identique au standard, mais juste de permettre l'exécution des scripts qui vont suivre :

• Nous choisissons de créer une méthode .color() synonyme de .pencolor()
• Et pour .colormode(), outre la création de la méthode, il nous faut détecter le format de coordonnées de couleurs attendu par le module, afin de convertir le cas échéant. La méthode .colormode() lorsque présente permet de basculer entre les 2 systèmes de coordonnées suivants :
  
  • mode 255 : couleurs RGB avec chaque composante prenant une valeur entière de 0 à 255
  • mode 1.0 : couleurs RGB avec chaque composante prenant une valeur flottante de 0 à 1
  Le module turtle travaille en fait en format 1.0, mode qu'il est donc impossible de modifier ici.

Voici maintenant donc enfin turtle pour TI-Nspire CX II.

Une fois installé correctement dans le dossier /PyLib/ comme expliqué, les fonctions offertes par turtle sont alors rajoutées au menu.

Attention toutefois, comme tout module présent dans le dossier /PyLib/, turtle ne sera pas disponible en mode examen.

Le module s'importe de la façon suivante, qui est bien une des façons standard :

Code: Select all

from turtle import Turtle
turtle = Turtle()

Si jusqu'à présent les quelques écarts avec le standard pouvaient être qualifiés de quelques détails de cas particuliers, ici cela commence à faire beaucoup. Pas moins de 4 problèmes sont détectés dont un majeur :

• absence de la méthode .colormode(), avec un fonctionnement bloqué en mode 255
• absence de gestion du 2^ème argument de la méthode .circle() pour tracer un arc de cercle
• et pire, pour les paramètres de couleur :
  
  • refus des paramètres de type liste, n'accepte que des tuples - est-ce un bug ?...
  • accepte les paramètres de type chaîne de caractères, mais ignore plusieurs codes de couleur usuels : "pink", "grey", "brown", "purple"

Heureusement ici, le module turtle importé est modifiable à chaud et peut donc être librement modifié et donc corrigé. En approfondissant la chose, la méthode Turtle Doctor devrait même permettre de pouvoir atteindre une conformité quasi parfaite au standard.

Et enfin nous avons le ce_turtl pour les éditions Python des TI-83 Premium CE et TI-84 Plus CE. Comme annoncé hélas, c'est une véritable catastrophe niveau conformité au standard. Pas moins de 8 erreurs sont anticipées :

• déjà, de par son nom il ne s'importe pas de façon standard, c'est-à-dire qu'aucune des 3 méthode suivantes ne fonctionne :
  import turtle, from turtle import *, ou encore
  

  Code: Select all

  from turtle import Turtle
turtle = Turtle()

• absence de la méthode .pencolor(), qui est remplacée ici par .color()
• absence de la méthode .colormode(), avec un fonctionnement bloqué en mode 255
• absence de la méthode .write() pour écrire du texte
• absence de gestion du 2^ème argument de la méthode .circle() pour tracer un arc de cercle
• et pire, pour les paramètres de couleur, refus de toute les formes standard : aussi bien liste que tuple ou chaîne de caractère. La méthode color() attend non pas 1 mais 3 arguments, soit un argument par composante.

Le module turtle importé est certes modifiable à chaud et la méthode Turtle Doctor va fonctionner pour débloquer l'exécution. Toutefois pour une conformité au standard il manquerait encore beaucoup de code, et malheureusement comme nous avons déjà vu nous sommes extrêmement à l'étroit niveau mémoire de tas (heap) Python sur ces calculatrices. Nous sommes déjà à peine à quelques lignes de l'erreur de mémoire, aller plus loin dans cette voie n'est pas envisageable sur ces modèles.

Pour comparer, il y a malgré tout moyen d'avoir du code d'importation fonctionnant à la fois sur l'ensemble de ces plateformes et sur ordinateur. Par exemple :

Code: Select all

try: # TI-83PCE/84+CE
  from ce_turtl import turtle
  turtle.clear()
except ImportError:
  import turtle # multiplateformes
  if not "forward" in dir(turtle): # TI-Nspire CX II
    turtle = turtle.Turtle()

Voilà, c'est parti pour les tests de conformité du module turtle standard, ainsi que la compatibilité entre différentes calculatrices graphiques.

Nous allons pour cela prendre plusieurs exemples et lancerons le même code sur différents modèles.

On commence par une petite rosace ; tout possesseur de Graph 35+E II sait que Casio adore ça :

ordi	NumWorks	Graph 90+E Graph 35+E II	TI-Nspire CX II turtle	KhiCAS TI-Nspire / NumWorks	TI-83PCE/84+CE ce_turtl
Code: Select all from turtldoc import * turtle.speed(0) turtle.pensize(1) for i in range(12):   turtle.left(30)   for i in range(8):     turtle.forward(30)     turtle.left(45) try: turtle.show() #TI-83 Premium CE except: pass

Petit léger détail, le turtle.pensize(1) n'est respecté ni par KhiCAS ni par ce_turtl.

Ceci mis à part, le code passe ici sans problème.

Poursuivons avec la fractale de Koch :

ordi	NumWorks	Graph 90+E Graph 35+E II	TI-Nspire CX II turtle	KhiCAS TI-Nspire / NumWorks	TI-83PCE/84+CE ce_turtl
Code: Select all from turtldoc import * 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) turtle.speed(0) turtle.pensize(1) turtle.pencolor("blue") turtle.penup() turtle.goto(-180, -50) turtle.pendown() koch(4, 360) try: turtle.show() #TI-83 Premium CE except: pass

Pas de nouveau problème ici.

Passons maintenant aux flocons de Koch :

ordi	NumWorks	Graph 90+E Graph 35+E II	TI-Nspire CX II turtle	KhiCAS TI-Nspire / NumWorks	TI-83PCE/84+CE ce_turtl
Code: Select all from turtldoc import * 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) l=80 turtle.pensize(1) turtle.penup() turtle.goto(105,3) turtle.left(120) turtle.pendown() flock(3, l) turtle.left(120) turtle.penup() turtle.goto(105,-10) turtle.right(60) turtle.pendown() turtle.pencolor("orange") flock(4, l) turtle.right(60) turtle.pensize(2) turtle.penup() turtle.goto(5,45) turtle.right(60) turtle.pendown() turtle.pencolor("blue") flock(2, l) turtle.right(60) turtle.penup() turtle.goto(-100,17) turtle.left(120) turtle.pendown() turtle.pencolor("red") flock(0, l) turtle.left(120) turtle.pensize(3) turtle.penup() turtle.goto(-100,-5) turtle.right(60) turtle.pendown() turtle.pencolor("green") flock(1, l) turtle.right(60) turtle.penup() turtle.forward(400) try: turtle.show() #TI-83 Premium CE except: pass

Pour ce que l'on obtient pas de problème de tracé avec le module turtle de KhiCAS, le problème vient d'autre chose. Ce module turtle a l'air d'être extrêmement gourmand, arrivant à déclencher une erreur de mémoire en cours d'exécution alors que d'autres modèles avec un heap Python absolument ridicule en comparaison s'en sortent parfaitement.

On comprend mieux ici le problème du .pensize() sur ce_turtl et KhiCAS. Malgré les réglages différents tous les flocons sont ici trop épais d'1 pixel, il y a visiblement un décalage.
Mais notons justement par rapport à ce_turtl, que notre script Turtle Doctor a visiblement correctement injecté l'interception des paramètres de couleurs passés sous la forme de chaînes de caractères.

Nous arrivons maintenant à un soleil :

ordi	NumWorks	Graph 90+E Graph 35+E II	TI-Nspire CX II turtle	KhiCAS TI-Nspire / NumWorks	TI-83PCE/84+CE ce_turtl
Code: Select all from turtldoc import * from math import exp turtle.speed(0) turtle.pensize(1) turtle.colormode(1.0) for i in range(36):   turtle.pencolor([exp(-.5 * ((i - k) / 12)**2) for k in (6, 18, 30)])   for i in range(1, 5):     turtle.forward(60)     turtle.right(90)   turtle.right(10) try: turtle.show() #TI-83 Premium CE except: pass

Notons que Turtle Doctor a réussi à parfaitement corriger les paramètres de couleurs sur ce_turtl, tuples et listes étant maintenant utilisables !

Poursuivons avec une coquille d'escargot :

ordi	NumWorks	Graph 90+E Graph 35+E II	TI-Nspire CX II turtle	KhiCAS TI-Nspire / NumWorks	TI-83PCE/84+CE ce_turtl
Code: Select all from turtldoc import * from math import exp turtle.speed(0) turtle.pensize(1) turtle.colormode(1.0) turtle.penup() turtle.goto(0, -20) turtle.pendown() for i in range(36):   turtle.pencolor([exp(-.5 * ((i - k) / 12)**2) for k in (6, 18, 30)])   turtle.circle(50 - i)   turtle.right(10) try: turtle.show() #TI-83 Premium CE except: pass

ce_turtl nous fait ici une véritable catastrophe. Le problème vient de la méthode .circle() qui ne respecte pas du tout le standard. Au lieu de tracer un cercle qui passe par la position de la tortue, elle trace un cercle qui prend pour centre la position de la tortue.

Passons maintenant aux triangles de Sierpiński :

ordi	NumWorks	Graph 90+E Graph 35+E II	TI-Nspire CX II turtle	KhiCAS TI-Nspire / NumWorks	TI-83PCE/84+CE ce_turtl
Code: Select all from turtldoc 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.speed(0) turtle.pensize(1) turtle.penup() turtle.backward(109) turtle.left(90) turtle.backward(100) turtle.right(90) turtle.pendown() turtle.pencolor("red") sierp(6, 217) turtle.penup() turtle.forward(400) try: turtle.show() #TI-83 Premium CE except: pass

Et mince, c'est justement le piège qui fait trébucher pas mal de modèles.
Ici encore, après avoir commencé un tracé parfait, KhiCAS se met à manquer de mémoire.

La Casio Graph 90+E s'en sort fort honorablement jusqu'à présent, non ? Dédions-lui un tableau :

ordi	NumWorks	Graph 90+E Graph 35+E II	TI-Nspire CX II turtle	KhiCAS TI-Nspire / NumWorks	TI-83PCE/84+CE ce_turtl
Code: Select all from turtldoc import * turtle.speed(0) turtle.forward(40) turtle.backward(100) turtle.left(90) turtle.forward(30) turtle.right(60) turtle.forward(60) turtle.right(30) turtle.forward(30) turtle.penup() turtle.forward(18) turtle.right(90) turtle.forward(60) turtle.pendown() turtle.right(30) turtle.backward(30) turtle.right(60) turtle.forward(60) turtle.pencolor("red") turtle.penup() turtle.goto(80,40) turtle.right(140) turtle.pendown() turtle.circle(30) turtle.penup() turtle.goto(105,50) turtle.pencolor("green") turtle.pendown() turtle.circle(-50) turtle.penup() turtle.pencolor("red") turtle.right(21) turtle.goto(60,20) turtle.pendown() turtle.circle(40,60) turtle.penup() turtle.pencolor("blue") turtle.goto(-50,15) turtle.setheading(0) turtle.pendown() turtle.write("CASIO") try: turtle.show() #TI-83 Premium CE except: pass

Et mince, c'est justement le piège qui fait trébucher pas mal de modèles.
Rapidement, très léger détail sur les Casio Graph 35+E II et Graph 90+E. La méthode .write() prend les coordonnées indiquées comme coin supérieur gauche du texte affiché, alors que le standard est de les prendre comme coin inférieur gauche.

Pour les modules qui ne gèrent pas l'appel .circle(rayon, angle) les arcs de cercles sont ici remplacés par des cercles, ce qui naturellement perturbe le reste du tracé.

Le cas KhiCAS est toutefois plus surprenant, cet appel étant bien géré...

Le nouveau turtle TI-Nspire CX II est une superbe réalisation. On apprécie particulièrement la grille et le repère entièrement configurables, une véritable valeur ajoutée !

Sur la conformité au standard turtle ce n'est certes pas le meilleur, même si cela reste honorable. Il y a bien pire et plus grave que cela. Texas Instruments a déjà fait un fort bel effort relativement à la catastrophe qu'était ce_turtl.

Nous ignorons si Texas Instruments poursuivra ses efforts, mais à défaut nous avons quand même une excellente nouvelle. Bien que l'on n'ait pas accès au code source du module turtle TI-Nspire CX II celui-ci a le gros avantage de nous présenter des éléments modifiables à chaud. Comme de plus nous bénéficions ici d'un heap Python extrêmement généreux, pas moins de 2 Mo soit l'un des plus larges tous modèles concurrents confondus, une conformité parfaite au standard est bel et bien envisageable, pourvu que quelqu'un se donne le temps de creuser la question.

En attendant donc mieux, les différentes solutions Python turtle disposent désormais dans nos tableaux d'un indice de compatibilité / conformité au standard, basé sur les tests précédents :

Accès QCC 2021 Universel