Forum TI-Planet.org

Dans sa prochaine mise à jour 5.5 gratuite prévue pour Mai 2020, Texas Instruments va rajouter de formidables possibilités historiques à ta TI-83 Premium CE :

• mise à jour en 5.5 de l'application SciTools
• mise à jour en 5.5 de l'application Periodic
• mise à jour en 5.5 de l'application Python (TI-83 Premium CE Édition Python uniquement)

Python 5.5 offre de nouveaux modules intégrés pour tes scripts Python :

• time, certes déjà présent mais maintenant listé au menu et donc officiel
• ti_system, avec diverses possibilités :
  
  • détection des simples pressions de touches clavier, y compris avec un clavier USB externe !
  • affichage dans la console à la ligne que tu veux
  • exportation de listes de nombres du contexte Python vers l'environnement de la calculatrice
  • importation dans le contexte Python de listes existant dans l'environnement de la calculatrice vers
  • et donc plus généralement un début d'intégration du Python à l'environnement mathématique de la calculatrice; plus besoin de traiter les tâches numériques à part, l'application Python 5.5 va enfin pouvoir servir s'articulier naturellement au sein de la résolution de problèmes et tâches complexes !
  
• ti_plotlib, une bibliothèque graphique pour tracer dans un repère othogonal, conformément aux programmes de Mathématiques et Physique-Chimie, comparable à matplotl chez Casio ou encore matplotlib.pyplot, et gérant ici les diagrammes suivants :
  
  • nuage de points
  • diagramme en ligne brisée
  • droite de régression linéaire
• ti_graphics pour contrôler directement les pixels de l'écran, comparable à kandinsky chez NumWorks ou encore casioplot
• ti_hub, pour les projets d'objects connectés à l'aide de l'interface TI-Innovator Hub
• ti_rover, pour les projets de robotique à l'aide du TI-Innovator Rover

Mais ce n'est pas tout car Python 5.5 gère également la possibilité inédite de rajouter des modules Python complémentaires :

• ce_turtl, comparable à turtle
• ce_box pour les diagrammes en boîte
• ce_chart pour les histogrammes et aires entre courbes
• ce_quivr pour les diagrammes utilisant des champs de vecteurs

Une fois le fichier ce_quivr.8xv chargé dans la calculatrice, à première vue aucun changement.

ce_quivr n'apparaît pas dans la liste des script Python, et la calculatrice ne l'identifie d'ailleurs clairement pas comme un script Python.

ce_quivr n'apparaît pas non plus dans la liste des modules disponibles.

Mais pas grave, tentons quand même notre première importation de ce_quivr.

A l'aide du module intégré gc et du script suivant, voyons ce que cette importation consomme sur le tas (heap) Python de 17 Ko et quelques.

Code: Select all

from gc import mem_free as mf

smod = input('Module : ')
mf1, mf2 = 0, 0
scmd = 'from ' + s + ' import *'
mf1 = mf()
exec(scmd)
mf2 = mf()
print(mf1 - mf2)

Comme tu peux voir, la consommation de tas est significative, le module ce_quivr fait 8,832 Ko. Il nous reste maintenant moins de 8 Ko de heap Python disponible, on ne va pas pouvoir coder des monuments...

On peut toutefois facilement comprendre cela. Il s'agit d'un module de tracé :

• qui probablement importe lui-même en interne ti_plotlib (7,232 Ko)
• ti_plotlib importe à son tour le module sys (224 o)
• ti_plotlib importe lui-même à son tour ti_graphics (2,896 Ko)
• ti_graphics importe également le module sys (224 o)
• ti_graphics import aussi le module math (336 o)

Donc en contrepartie de cette consommation de heap, tu aurais déjà à ta disposition une bonne partie des modules et de leurs fonctionnalités sans avoir à rien importer d'autre.

Le module ce_quivr n'est en fait rajouté aux menus qu'à partir du moment où tu édites ou crées un script qui l'importe.

En l'absence de menus jusque-là, il te faudra donc saisir toi-même le nom du module pour la commande d'imporation.

Nous avions déjà vu que la possibilité de tracer des nuages de points était couverte par le nouveau module Python ti_plotlib.


Découvrons cela de suite à travers quelques exemples.

Voici pour étudier un mouvement rectiligne qui semble alors uniformément accéléré :

Code: Select all

import ti_plotlib as plt
from ti_system import *
from ce_quivr imort *

#Les fonctions
def calc_vitesses(absc, temps):
  v = []
  for n in range(len(absc) - 1):
    v.append((absc[n + 1] - absc[n]) / (temps[n + 1] - temps[n]))
  temps = temps[:-1]
  return v, temps

def rep_vitesses(absc, vitesses):
  for i in range(len(vitesses)):
  quiver(absc[i], 0, vitesses[i], 0, 0.06, "b", "vector")

#Le programme
plt.cls()
plt.title("Etude du MRUA")
plt.window(-0.2, 1.2, -1, 1)
x = recall_list("2")
t = recall_list("1")
v, temps_v = calc_vitesses(x, t)
rep_vitesses(x, v)
plt.show_plot()

Et maintenant pour l'étude d'un mouvement à une dimension sur un axe :

Code: Select all

import ti_plotlib as plt
from ce_quivr import *

fx = lambda x: x**3 - 4*x**2 + 3*x - 2
dx = lambda x: 3*x**2 - 8*x + 3
d2x = lambda x: 6*x - 8

def motion(min, max, n):
  dt = (max-min) / n
  t = min
  for i in range(n):
    quiver(t, fx(t), t+dt, fx(t+dt), 1, 'blk', 'line')
    if i % 7 == 0:
      quiver(t, fx(t), 0, dx(t), .4, 'r', 'vector')
      quiver(t, fx(t), 0, d2x(t), .4, 'b')
    t += dt

plt.window(-.25, 4, -5, 7)
plt.cls()
plt.title('Motion in one Dimension')
plt.color(0, 0, 0)
plt.axes('on')
plt.labels('Time', '   X Position     ', 7, 3)
motion(0, 4, 49)
plt.show_plot()

Enfin, terminons par une exploration intégrale du contenu du module ce_quivr, à l'aide du script suivant :

Code: Select all

#platforms:
#0: MicroPython / TI-Nspire
#1: MicroPython / NumWorks
#2: MicroPython / G90+E / G35+E II
#3: MicroPython / G35+E/USB / G75/85/95
#4: CircuitPython / TI-Python / 83PCE / Trinket M0
#5: Xcas / HP Prime
#6: KhiCAS / Graph 90+E

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

Notons en passant la présence d'une fonction permettant à tes scripts de tester la version ce_quivr, ici 1.0.

On valide en passant l'hypothèse formulée plus haut, le module ti_plotlib est bien inclus dans ce_quivr et accessible via ce_quivr.plt.

Le module ce_quivr offre donc 5 éléments au premier niveau, et jusqu'à 41 en comptant les sous-éléments.

De quoi mettre à jour notre comparatif de la richesse des différentes solutions Python sur calculatrices :