QCC 2020 épisode 0 : liste des participants

[critor]

Bon, on vous rassure, nous avons dès maintenant la nouvelle version TI-Nspire CX II avec Python, et devrions donc pouvoir te publier un classement QCC 2020 aussi à jour et complet que possible.

Dommage donc pour la HP Prime, pas eu de réponse à la même demande, même pas négative, elle risque d'être détrônée cette année. Mais peut-être que la mise à jour avec Python est ici loin d'être prête.

Le Python TI-Nspire CX II est formidable, plein de trucs extra/exceptionnels sur nos tests passés ou à venir, mais hélas nous n'avons pas le droit de publier des informations à son sujet pour le moment.

Donc on va voir comment on peut s'organiser pour la suite du QCC...

Soit on retarde les épisodes Python restants mais sans garantie qu'au mieux une pauvre semaine de décalage puisse changer quelque chose à ce sujet...
Soit on les publie quand même sans aborder le cas TI-Nspire CX II, réservant donc les révélations pour le classement final (en supposant que l'on puisse enfin en parler ce jour-là).

[cent20]

Soit on retarde les épisodes Python restants mais sans garantie qu'au mieux une pauvre semaine de décalage puisse changer quelque chose à ce sujet...
Soit on les publie quand même sans aborder le cas TI-Nspire CX II, réservant donc les révélations pour le classement final (en supposant que l'on puisse enfin en parler ce jour-là).

Il y a du favoritisme ! Visiblement le chouchou peut rendre sa copie quand il veut, même en retard par rapport à la date de remise des copies et il serait noté sur la même base que les autres candidats ?

[critor]

Non non, chaque année nous tentons d'avoir un classement aussi à jour que possible, avec les dernières versions.

Donc tout ce qui est prévu pour être publié pendant la période d'acquisition (jusqu'à fin septembre en gros) est pris en compte.

Il est même déjà arrivé que HP publie une mise à jour courant septembre, en 2017 je crois, ben nous avons modifié le classement, passant la machine de la 2nde à la 1ère place.

[Hamza.S]

Le Python TI-Nspire CX II est formidable, plein de trucs extra/exceptionnels sur nos tests passés ou à venir, mais hélas nous n'avons pas le droit de publier des informations à son sujet pour le moment.

Donc on va voir comment on peut s'organiser pour la suite du QCC...

rassurez moi, ils n'ont pas recopié les même bêtises de la TI 83 Premium CE Edition Python sur la Nspire ?
ils ne l'ont pas fermé encore plus j'espère ? genre 20 Kio de tas (et pile) ou une connerie de ce genre

[cent20]

Le Python TI-Nspire CX II est formidable, plein de trucs extra/exceptionnels sur nos tests passés ou à venir, mais hélas nous n'avons pas le droit de publier des informations à son sujet pour le moment.

Donc on va voir comment on peut s'organiser pour la suite du QCC...

rassurez moi, ils n'ont pas recopié les même bêtises de la TI 83 Premium CE Edition Python sur la Nspire ?
ils ne l'ont pas fermé encore plus j'espère ? genre 20 Kio de tas (et pile) ou une connerie de ce genre

D'après le spoiler on n'aura bien plus de 16 ko ! Sachant qu'il y a 64 Mo de dispo, rien de les empêche techiquement de proposer un tas de 16 Mo, 42 Mo, 60 Mo ...

Après pour pouvoir éxécuter les scripts python depuis les autres aps (ce qui serait très cool) ils ne proposeront pas 63 Mo.

Moi je parierai sur 16 à 32 Mo, mais je ne connais pas la consommation maximale M en mémoire des autres aps.
Donc tas = 64 - M - OS - sécurité, probablement. Dans toutes les cas, ça va dantesque pour la concurrence.

[critor]

Selon nos tests, le heap Python TI-Nspire CX II fait entre 64 Mio et 0 octet.

[critor]

heap Python de la TI-Nspire CX II testé, même script que l'épisode 3.

stack Python de la TI-Nspire CX II testé, même script que l'épisode 4.

Quantité de modules Python offerts sur TI-Nspire CX II testée.

Script de détection de la calculatrice mis à jour avec la détection TI-Nspire CX II :

Code: Select all

# detects calculator Python platform
def get_pf():
  c256 = True
  try:
    if chr(256)==chr(0):
      # Xcas/KhiCAS Python compatibility
      if "HP" in version():
        return 13 # HP Prime
      else:
        if not white:
          return 12 # Graph 35+E II
        elif "Numworks" in version():
          return 10 # NumWorks
        elif "Nspire" in version():
          return 8 # Nspire
        else: # Graph 90+E
          return 11
  except:
    c256 = False
  try:
    import sys
    try:
      if sys.platform == "nspire":
        try: # Nspire Ndless
          import graphic
          return 7 # KhiCAS Micropython
        except: # MicroPython
          return 6
      elif sys.platform == "TI-Nspire":
        return 3 # Nspire CX II
      elif sys.platform == "numworks":
        return 9 # NumWorks KhiCAS Micropython
      elif sys.platform.startswith('TI-Python'):
        return 2 # 83P/84+ CE
    except: # Graph 35+E/USB / 75/85/95
      return 5
  except:
    pass
  if not c256:
    return 1 # Graph 90/35+E II
  try:
    import kandinsky
    return 0 # NumWorks
  except:
    try: # HP Prime
      import hpprime
      return 4
    except:
      pass
  return -1

#return get_pixel and set_pixel functions for the platform
gp_prime = lambda x, y: GETPIX_P(x, y)
sp_prime = lambda x, y, c: PIXON_P(x, y, c)
def get_pixel_functions(pf):
  gp, sp = lambda: None, lambda: None
  if pf == 0: # NumWorks
    import kandinsky
    gp, sp = kandinsky.get_pixel, kandinsky.set_pixel
  elif pf == 1: # Graph 90/35+E II
    import casioplot
    gp, sp = casioplot.get_pixel, casioplot.set_pixel
  elif pf == 2: # 83P/84+ CE
    import ti_graphics
    gp, sp = ti_graphics.getPixel, ti_graphics.setPixel
  elif pf == 3: # Nspire CX II
    pass
  elif pf == 4: # HP Prime
    import hpprime
    sp = hpprime.pixon
  elif pf == 6: # Nspire: Ndless MicroPython
    from nsp import Texture
    canvas = Texture(320, 240, 0)
    gp, sp = canvas.getPx, canvas.setPx
  elif pf == 7 or pf == 9: # Nspire/NumWorks: KhiCAS-MicroPython
    import graphic
    gp, sp = graphic.get_pixel, graphic.set_pixel
  elif pf == 13: # HP Prime
    gp, sp = gp_prime, sp_prime
  return gp, sp

#returns platform screen infos : width, height, color_mode/bits
def scr_infos(pf):
  #                                              uPy       uPy
  #                G352                CPy  uPy  KhiCAS--------------------->  CAS
  #           NW   G90  CE   CX2  HP   GXX  NS   NS   NS   NW   NW   G90  G352 HP
  l_vlines = (222, 192, 210, 212, 240, 064, 240, 222, 222, 222, 222, 192, 064, 240)
  l_vcols  = (320, 384, 320, 318, 320, 128, 320, 320, 320, 320, 320, 384, 128, 320)
  l_y0     = (000, 000, 030, 000, 000, 000, 000, 000, 000, 000, 000, 000, 000, 000)
  l_modes  = (000, 000, 000, 016, 032, 000, 016, 000, 016, 000, 016, 016, 001, 032)
  return l_vcols[pf], l_vlines[pf], l_y0[pf], l_modes[pf]

#returns platform shell infos : visible lines, visible columns, if larger strings are displayed on several lines or not
def shell_infos(pf):
  #NW small: [00] 12.5x30 -> 16   x 42
  #HP small: [03] 11.5x39 -> 15.5 x 45 [12] 14  x39 -> 18.5 x 45
  #HP big  : [03] 11.5x39 -> 09   x 35 [12] 14  x39 -> 11   x 35
  #                                       uPy     uPy
  #               G352            CPy uPy KhiCAS--------------->  CAS
  #           NW  G90 CE  CX2 HP  GXX NS  NS  NS  NW  NW  G90 G352HP
  l_vlines = (12, 07, 11, 11, 12, 09, 29, 11, 11, 11, 11, 09, 07, 14)
  l_vcols =  (30, 21, 32, 00, 39, 32, 53, 32, 32, 29, 29, 30, 19, 39)
  b_vcr = 0b1111100
  if pf >= 0:
    return l_vlines[pf], l_vcols[pf], b_vcr // 2**pf % 2
  else:
    return max(l_vlines), max(l_vcols), 1

Richesse des modules Python offerts sur TI-Nspire CX II testée avec un script explmod.py nettement amélioré et plus équitable (ne compte plus les doublons, particulièrement pour les sous-éléments) :

Code: Select all

from autopfrm import *

pf = get_pf()
sh_inf = shell_infos(pf)

unsafe = ()
if pf == 4: #HP Prime
  unsafe = ('count','encode','endswith','find','format','index','islower','lstrip','replace','rfind','rindex','rsplit','rstrip','split','splitlines','startswith','strip','from_bytes','to_bytes','fromkeys','get','pop','setdefault','update','values','sort','__enter__','__exit__','read','readinto','readline','seek','write')
if pf == 5 or pf == 7 or pf == 9: #CasioPython / Nspire+NumWorks KhiCAS MicroPython
  unsafe = ('sys.argv', 'sys.path')

if pf >= 0:
  curline=0
  _p = print
  def print(*ls):
    global curline
    st=""
    for s in ls:
      if not(isinstance(s,str)):
        s=str(s)
      st=st+s
    stlines=1
    if sh_inf[1]:
        stlines += sh_inf[2]*int(len(st)/sh_inf[1])
    if curline+stlines>=sh_inf[0]:
      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):
  if str(obj).startswith("<module"): return False
  l = ()
  try: l = dir(obj)
  except: pass
  return len(l)

def explmodr(pitm, pitm_name_l=[], pitm_str_l=[], pitm_val_l=[], reset=True):
  global curline, found
  pitm_name=sstr(pitm)
  if(reset):
    curline=0
    found = []
    pitm_name_l=[pitm_name]
    pitm_str_l=[str(pitm)]
    pitm_val_l=[pitm]
  hd="."*(len(pitm_name_l)-1)
  c = 0
  l = sorted(dir(pitm))
  for i in range(len(l)):
    l[i] = (l[i], getattr(pitm, l[i]), str(l[i]))
  try:
    if not isinstanceof(pitm, str):
      for i in range(len(pitm)):
        l.append((pitm_name+'['+str(i)+']',pitm[i],str(pitm[i])))
  except: pass
  for itm in l:
    isFound = itm[0] in found
    c += not isFound
    isUnsafe = '.'.join(pitm_name_l + [itm[0]]) in unsafe or itm[0] in unsafe
    try:
      if isUnsafe: raise Exception
      print(hd+itm[0]+"="+str(itm[1]))
    except:
      print(hd+itm[0])
    if not isFound:
      found.append(itm[0])
    if not isUnsafe and isExplorable(itm[1]) and itm[1] not in pitm_val_l and itm[2] not in pitm_str_l:
      pitm_name_l2, pitm_val_l2, pitm_str_l2 = pitm_name_l.copy(), pitm_val_l.copy(), pitm_str_l.copy()
      pitm_name_l2.append(itm[0])
      pitm_val_l2.append(itm[1])
      pitm_str_l2.append(itm[2])
      c += explmodr(itm[1], pitm_name_l2, pitm_str_l2, pitm_val_l2, False)
  return c

def explmod(s):
  global found
  module = __import__(s)
  found = []
  return explmodr(module)

J'ignore si nous ferons des épisodes QCC détaillés à ce sujet cette année. Le temps manque, nous avons obtenu la mise à jour CX II bien tard (mais mieux vaut tard que jamais ), et le temps que l'on obtienne éventuellement le droit de parler des résultats il ne manquera que davantage.
Mais on vous garantit que c'est testé aussi minutieusement et équitablement que tout ce qui vous a déjà été présenté.

[Hamza.S]

Vous pouvez quand-même parler d'ordre de grandeur des valeurs pour QCC 3 & 4, non ?

[critor]

Je ne pense pas.

Ils prennent leurs précautions maintenant je suppose sur ce qui peut être rendu public ou pas avant la sortie, vu que ça fait plusieurs fois que TI/Casio annoncent des nouveautés des mois à l'avance, et que NumWorks sort comme par hasard quelque chose de similaire entre temps...

Comme matplotlib sorti la semaine d'avant la date annoncée par Casio si je me souviens bien.

[Hamza.S]

Ou l'auto-complétion annoncée par TI, NumWorks a fait la même chose peu de temps après l'annonce.