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

Cette dernière application apporte de nouveaux modules importables pour tes scripts Python :

• time, certes déjà présent mais maintenant listé au menu et donc officiel; il ne risque plus de disparaitre
• ti_system, avec diverses possibilités :
  
  • détection des simples pressions de touches clavier (sans validation donc) par l'utilisateur, avec même l'éventuel modificateur actif (

    2nde

    ou

    alpha

    ), et ça marche aussi avec un clavier USB !
  • affichage dans la console à la ligne que tu veux
  • exportation de listes de nombres (entiers, flottants ou complexes) existant dans le contexte Python vers l'environnement de la calculatrice, pour traitement à l'aide d'autres applications
  • importation depuis le contexte Python de listes ou équation de régression existant dans l'environnement de la calculatrice
  • et donc plus généralement un début d'intégration du Python à l'environnement mathématique de la calculatrice, enfin l'application Python va pouvoir servir non plus seulement à coder un truc déconnecté dans un coin, mais à traiter des problèmes et tâches complexes dans leur globalité !
• ti_plotlib, une bibliothèque graphique conformément aux programmes de Physique-Chimie, SNT et NSI, tout en permettant également nombre d'applications en Mathématiques !
• 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
• ainsi qu'un mystérieux ti_graphics, pour sa part non listé au menu

Après une exploration des possibilités du module ti_system, nous te proposons aujourd'hui l'exploration du module ti_plotlib.
Pour te donner un point de repère, nous pouvons donc a priori le rapprocher de l'interface matplotl.py sur Casio Graph 90/35+E II ou matplotlib.pyplot chez NumWorks.

Le menu nous permet de commencer à comprendre le fonctionnement du module ti_plotlib. Il comprend 4 variables xmin, xmax, ymin et ymax, qui une fois accédées permettent de configurer les bornes de la fenetre graphique.

Les valeurs par défaut respectives de -10, 10, -6.56 et 6.56 ont été choisies exprès par TI pour te donner un repère orthonormal (même unité en abscisse et un ordonnée, c'est-à-dire que la programmation d'un cercle affiche bien un cercle).

Première chose à faire donc configurer les axes, avec axes("mode"). L'assistant de saisie présente 4 valeurs autorisées pour les paramètres :

• 'on' : affiche les axes et les bornes de la fenêtre
• 'axes' : affiche les axes mais pas les bornes de la fenêtre
• 'window' : affiche les bornes de la fenêtre mais pas les axes
• 'off' : n'affiche rien de tout ça

Rien que ces appels nous permettent déjà de constater un fonctionnement très différent de matplotlib.pyplot.

Déjà les affichages graphique ne sont pas effectués sur un écran dédié mais directement surimprimés sur l'écran de la console.

Il faudra donc commencer tes scripts en effaçant la console via l'appel cls() ou ti_system.disp_clr(), les deux semblant faire la même chose : vider l'écran et remettre le curseur en haut à gauche.

A noter qu'il ne s'agit pas vraiment d'un vidage de la console. En réalité c'est juste une astuce de défilement, la dernière ligne de la console est marquée comme devant être affichée en haut de l'écran. L'historique de la console est intact et reste consultable avec

↑

ou défilable avec

2nde

↑

.

Ensuite, il est à noter que les affichages sont ici effectués immédiatement à chaque appel. Toutefois, tout retour à la console fait disparaître tous les affichages effectués via ti_plotlib.

Pour avoir le temps d'observer tes affichages, il te faudra donc insérer une boucle d'attente à la fin de tes scripts. Cela peut-être fait via les appels équivalents show_plot() ou ti_system.disp_wait().
A noter qu'ici contrairement à la NumWorks, il n'est pas possible de faire défiler le repère pendant l'observation.

show_plot() n'a donc rien à voir avec matplotlib.pyplot.show() puisque ne faisant pas du tout ce que son nom indique. L'appel est en réalité équivalent à la boucle suivante qui s'interrompt à l'appui sur

annul

,

on

ou

2nde

mode

:

Code: Select all

while not ti_system.escape():
  pass

Vu l'affichage des axes, on peut déjà avancer que ti_plotlib nous permet de contrôler une zone graphique de 320×210 pixels, les 30 lignes de la barre d'état supérieure étant exclues.

Nos axes étant maintenant configurés, on peut décider de l'affichage ou pas d'une grille via l'appel grid(xscl, yscl, "type"), avec :

• xscl pour l'unité de grille horizontale
• yscl pour l'unité de grille verticale
• et pour le type, au choix :
  
  • 'dot' pour des lignes de tirets courts
  • 'dash' pour des lignes de tirets longs
  • 'solid' pour des lignes continues
  • 'point' pour des lignes de petits points

title('titre') permet de rajouter un titre au repère. Nous n'en contrôlons pas la position, il est affiché en centré en haut d'écran.

Par exemple ci-contre, title('mon titre').

labels("xétiq", "yétiq", x, y) permet pour sa part de rajouter des étiquettes aux axes.

Par exemple ci-contre, labels('abscisses (x)', 'ordonnées (y)', 1, 12).

Les paramètres x et y permettent ici de contrôler les positions respectives de ces deux étiquettes, mais de façon très partielle :

• l'étiquette de l'axe des abscisses est affichée à droite de l'écran, à la ligne numéro x
• l'étiquette de l'axe des ordonnées est affichée à gauche de l'écran, à la ligne numéro y

Les numéros de ligne n'ont absolument rien à voir avec les bornes de la fenêtre réglées pour ti_plotlib. Elles suivent la règle déjà présentée pour ti_system.disp_at(), à savoir que chaque ligne est une bande de 17 pixels de hauteur numérotée de haut en bas en partant de 1.
La police est quant à elle à largeur fixe de 10 pixels, permettant un affichage de 32 caractères par ligne.

On pourrait donc dire que l'appel labels("xétiq", "yétiq", x, y) est équivalent au code suivant :

Code: Select all

ti_system.disp_at(x, "xétiq", "right")
ti_system.disp_at(y, "yétiq", "left")

Équivalent à quelques petits détails près toutefois :

• ti_system.disp_at() n'autorisait que des numéros de ligne de 1 à 11, alors qu'ici nous avons droit d'afficher sur la 12^ème correspondant au menu par onglets en bas d'écran
• ti_system.disp_at() avait le défaut d'effacer tout ce qui restait à droite de l'affichage sur la ligne concernée, ce qui n'est pas le cas ici

Enfin, il nous reste à pouvoir régler les bornes de la fenêtre. Encore une particularité d'écriture ici, ce n'est pas matplotlib.pyplot.axis([xmin, xmax, ymin, ymax]), mais window(xmin, xmax, ymin, ymax).

auto_window(xliste, yliste) te permet également de régler automatiquement les bornes d'un repère afin que les points dont tu fournis les listes de coordonnées soient tous visibles avec en prime une marge.
Attention toutefois, le repère ainsi réglé ne sera pas forcément orthonormal.

Bon, maintenant que nous savons configurer la fenêtre graphique, voyons donc ce que l'on peut tracer comme formes de base.

Déjà, la fonction color(r, g, b) permet de régler la couleur du stylo, noir par défaut. Nous avons donc ici un format de couleur RGB (rouge-vert-bleu) sur 24-bits (8-bits par composante, soit des valeurs entières de 0 à 255 comme indique).

Commençons donc par l'affichage de chaînes de caractères, avec text_at(ligne, "txt", "align"). Comme on pouvait s'y attendre au fonctionnement inattendu du placement des étiquettes des axes, c'est assez décevant.

En effet rien à avoir avec les coordonnées dans le repère. La fonction fonctionne comme ti_system.disp_at() :

• Pour le positionnement vertical on fournit un simple numéro de ligne, chaque ligne correspondant à une bande de 17 pixels numérotée de haut en bas de 1 à 12.
• Pour le positionnement horizontale il y a encore moins de choix, on ne peut choisir qu'entre un alignement à gauche (par défaut), centré ou à droite

Le système de positionnement n'ayant rien à voir avec les coordonnées dans le repère est déjà très embêtant. Tu vas devoir te plier à des acrobaties calculatoires pour positionner correctement tes textes par rapport à tes autres affichages effectués avec les coordonnées dans le repère.
On peut regretter également des possibilités de positionner ses textes extrêmement limitées, très inférieures à ce que permet le langage historique TI-Basic aussi bien à l'écran de calcul qu'à l'écran graphique.

Regardons de plus près le fonctionnement avec le code ci-dessous :

Code: Select all

from ti_system import *
import ti_plotlib as plt

plt.cls()
plt.axes('on')

for k in range(1,13):
  plt.text_at(k, 'ligne {:02d}: '.format(k) + '*'*22)

la = ('left', 'center', 'right')
for k in range(len(la)):
  plt.text_at(4*k+2, 'Hello TI', la[k])
  #disp_at(4*k+2, 'Hello TI', la[k])

On peut noter à ce jour un autre gros défaut de la fonction text_at(), c'est qu'elle efface en prime au préalable la ligne concernée et ce dans toute sa largeur. Impossible donc avec cette fonction de faire 2 affichages de chaînes de caractères sur une même ligne, et elle devra en prime être appelée en début de script, avant tous les autres affichages dans le repère, sous peine de les détruire.

Mais puisque les affichages ti_plotlib sont comme vu plus haut tout simplement surimprimés sur l'écran de la console, alors on peut remplacer l'appel text_at() par un ti_system.disp_at().

Il est à noter que, bizarrement, c'est déjà nettement mieux même si cela reste décevant. Ici il n'y a pas effacement intégral de chaque ligne utilisée, juste de la fin de ligne non utilisée à droite.
Par contre la fonction ti_system.disp_at() malgré ses avantages sera à la différence inutilisable dans certains cas particuliers :

• elle n'accepte pas d'afficher sur la 12^ème ligne, réservée dans le contexte de la console au menu par onglets de bas d'écran.
• elle ne tient pas compte de la couleur du stylo et affiche toujours en noir

Avant de poursuivre, commençons par régler notre stylo via l'appel pen("taille", "type"), avec :

• pour la taille au choix :
  
  • 'thin' pour une plume fine
  • 'medium' pour une plume moyenne
  • 'thick' pour une plume épaisse
• et pour le type au choix :
  
  • 'solid' pour un tracer continu
  • 'dot' pour un tracé en pointillé avec des tirets courts
  • 'dash' pour un tracé en pointillé avec des tirets longs

Notre stylo étant maintenant réglé, autre primitive donc, le segment traçable via un appel line(x1, y1, x2, y2, "mode").
Le paramètre mode peut prendre les valeurs suivantes :

• '' ou 'default' pour le tracer d'un simple segment
• 'arrow' pour rajouter une flèche à l'extrémité de coordonnées (x2, y2)

Voici ci-contre illustrées par le script ci-dessous toutes les possibilités par l'usage combiné de ces deux dernières fonctions :

Code: Select all

from ti_system import *
import ti_plotlib as plt

lta = ('thin', 'medium', 'thick')
lty = ('solid', 'dot', 'dash')
lmo = ('default', 'arrow')
nta, nty = len(lta), len(lty)
lx = [plt.xmin + k*(plt.xmax-plt.xmin)/(2*nta+1) for k in range(1, 2*nta+1)]
ly = [plt.ymin + k*(plt.ymax-plt.ymin)/(2*nty+1) for k in range(1, 2*nty+1)]
l = (plt.xmax-plt.xmin) / (2*nta+1)

plt.cls()
disp_at(1, ' '*4 + (' '*4).join(lta), 'left')
for i in range(len(lty)):
  disp_at(10 - 4*i, lty[i], 'left')
  for j in range(len(lta)):
    plt.pen(lta[j], lty[i])
    for k in range(len(lmo)):
      plt.line(lx[j*2], ly[i*2 + k], lx[j*2 + 1], ly[i*2 + k], lmo[k])
plt.show_plot()

Directement utile en l'état pour représenter les vecteurs en Mathématiques ou Physique-Chimie, non ?

Code: Select all

import ti_plotlib as plt
import ti_system as ti
import math

def hsv2c(h, s, v):
  c=v*s
  x, m, k=c*(1-abs((h%(2/3))*3-1)), v-c, (h*3)//1
  return round(255*(m+x*(k%3==1)+c*(k%5==0))), round(255*(m+c*(k==1 or k==2)+x*(k%3==0))), round(255*(m+x*(k%3==2)+c*(k==3 or k==4)))

def colorvec(v):
  a = math.atan2(v[1], v[0])/math.pi
  if a<0: a+=2
  plt.color(hsv2c(a, 1, 1))

def sumvec(u, v):
  return [u[0]+v[0], u[1]+v[1]]

def arrowvec(p0, v):
  a = math.atan2(v[1], v[0])/math.pi
  if a<0: a+=2
  colorvec(v)
  plt.line(p0[0], p0[1], p0[0]+v[0], p0[1]+v[1], 'arrow')

u, v = [1, 5], [5, 1]
w=sumvec(u, v)
lp=[[-7, -5], [3, -5]]

plt.cls()
plt.grid(1, 1, 'dash')
plt.axes('axes')

colorvec(u)
plt.text_at(2, 'u')
colorvec(v)
plt.text_at(3, 'v')
colorvec(w)
plt.text_at(4, 'w')
ti.disp_at(1, 'w=u+v', 'center')

plt.pen('medium', 'solid')
arrowvec(lp[0], u)
arrowvec(sumvec(lp[0], u), v)
plt.pen('thick', 'solid')
arrowvec(lp[0], w)
plt.pen('medium', 'solid')
arrowvec(lp[1], u)
arrowvec(lp[1], v)
plt.pen('thin', 'dash')
arrowvec(sumvec(lp[1], u), v)
arrowvec(sumvec(lp[1], v), u)
plt.pen('thick', 'solid')
arrowvec(lp[1], w)
plt.show_plot()

Enfin dernière primitive, le point allumable via plot(x, y, "marq").
Le paramètre marq admet ici pour valeurs autorisées :

• 'o' pour un rond
• '+' pour un plus
• 'x' pour une croix
• '.' pour un simple pixel

Le réglage du stylo est ici sans effet. Voici ci-contre illustrés les différents résultats :

Code: Select all

from ti_system import *
import ti_plotlib as plt

lma = ('o', '+', 'x', '.')
n = 1
lx = [plt.xmin + k*(plt.xmax-plt.xmin)/(n+1) for k in range(1, n+1)]
n = len(lma)
ly = [plt.ymin + k*(plt.ymax-plt.ymin)/(n+1) for k in range(1, n+1)]

plt.cls()
for k in range(len(lma)):
  disp_at(11 - 3*k, lma[k], 'left')
  plt.plot(lx[0], ly[k], lma[k])
plt.show_plot()

Voyons maintenant les fonctions qui utilisent en interne les primitives précédentes afin de construire des diagrammes.

La fonction scatter(xliste, yliste, "marq") permet de tracer un nuage de points, avec comme plus haut les choix de 'o', '+', 'x' ou '.' pour la forme de chaque point.

Voici par exemple ci-contre ce que donne l'appel graphe(math.sqrt, 0, 16, 17) avec le script ci-dessous :

Code: Select all

import ti_plotlib as plt

def graphe(f, a, b, n):
  lx=[a+i*(b-a)/n for i in range(n+1)]
  ly=[f(x) for x in lx]
  plt.cls()
  plt.window(a-1, b+1, min(ly)-1, max(ly)+1)
  plt.color(0, 0, 0)
  plt.axes('on')
  plt.grid(1, 1, 'dot')
  plt.color(0, 0, 255)
  plt.labels('x', 'y', 12, 1)
  plt.color(255, 0, 255)
  plt.scatter(lx, ly, 'x')
  plt.show_plot()

On peut remplacer la fonction scatter() par la fonction plot() qui attend les mêmes arguments, pour tracer cette fois-ci un diagramme en ligne brisée.

On peut également appeler la fonction lin_reg(xliste, yliste, "aff", ligne=11) pour tracer une régression linéaire des données.

Le paramètre indiqué ici en tant que "aff" est l'alignement horizontal du texte comme pour les fonctions vues plus haut, donc 'left', 'center' ou 'right'.

Code: Select all

import ti_plotlib as plt

def graphe(f, a, b, n):
  lx=[a+i*(b-a)/n for i in range(n+1)]
  ly=[f(x) for x in lx]
  plt.cls()
  plt.window(a-1, b+1, min(ly)-1, max(ly)+1)
  plt.color(0, 0, 0)
  plt.axes('on')
  plt.grid(1, 1, 'dot')
  plt.color(0, 0, 255)
  plt.labels('x', 'y', 12, 1)
  plt.color(0, 255, 0)
  plt.scatter(lx, ly, 'x')
  plt.color(255, 0, 255)
  plt.lin_reg(lx, ly, 'center', 11)
  plt.show_plot()

Voyons maintenant si ti_plotlib ne renfermerait pas quelques secrets non listés au menu. Pour cela procédons à son exploration à l'aide du script suivant :

Code: Select all

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]

nlines=plines[platform]
ncols=pcols[platform]
curline=0

def mprint(*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
  print(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):
  s=str(obj)
  return s.startswith("<") and s.find(" ")>=0 and not s.startswith("<module")

def explmod(pitm,pitmsl=[],reset=True):
  global curline
  if(reset):
    curline=0
    pitmsl=[sstr(pitm)]
  hd="."*(len(pitmsl)-1)
  spath=".".join(pitmsl)
  c,c2=0,0
  spitm=str(pitm)
  for itms in sorted(dir(pitm)):
    c,c2=c+1,c2+1
    try:
      itm=eval(spath+"."+itms)
      mprint(hd+itms+"="+str(itm))
      if isExplorable(itm) and itm!=pitm:
        pitmsl2=pitmsl.copy()
        pitmsl2.append(itms)
        c2=c2+explmod(itm,pitmsl2,False)[1]
    except:
      mprint(hd+itms)
  if c>0 and reset:
    mprint(hd+"Total: "+str(c)+" 1st level item(s)")
    if c2>0 and c2!=c:
      mprint(hd+"       "+str(c2)+" item(s)")
  return [c,c2]

Et effectivement il y a des bien des choses encore non abordées, l'appel explmod(ti_plotlib) retourne pas moins de 56 éléments, soit bien plus que ce qu'il y a au menu !


Nous allons les explorer sans tarder, mais en attendant cela nous permet de mettre à jour notre petit classement des Pythonettes :


En terme d'éventail puis de richesse des modules, cela nous donne :

Selon le test précédent, plusieurs secrets donc qu'il nous reste à explorer dans le module ti_plotlib.


On note donc déjà dans le module ti_plotlib la présence de plusieurs fonctions répliquant les fonctionnalités d'autres modules, la plupart déjà présents dans la calculatrice mais pas tous :

• copysign() (math)
• isnan() (numpy, non présent)
• escape() (ti_system)
• monotonic() (time)
• sleep() (time)
• sqrt() (math)

Existent également plusieurs variables privées .

_pensize et _penstyle accueillent des entiers de 0 à 2 représentant respectivement la taille et le style du stylo :

• 0 pour 'thin' et 'solid'
• 1 pour 'medium' et 'dot'
• 2 pour 'thick' et 'dash'

Toute autre valeur numérique est considérée comme équivalente à 2 selon nos tests.

_pencolor accueille pour sa part un tuple représentant la couleur du stylo.

On peut donc aussi bien affecter directement ces variables.

Nous avons également droit à des fonctions privées.

Les fonctions privées _numtest(v) et _strtest(v) semblent être utilisées en interne par les fonctions publiques ti_plotlib pour s'assurer qu'elles sont appelées avec les bons types d'arguments.
Effectivement elles ne font rien si elles sont respectivement appelées avec un argument de type attendu, et déclenchent justement dans le cas contraire la même exception que les fonctions publiques.

_excpt(v) pour sa part déclenche justement une exception sous le nom que tu lui communiques.

_write(v) semble quant à elle être utilisée en interne pour les affichages de chaînes de caractères :

• elle affiche ce qu'on lui donne, mais on peut remarquer que plusieurs caractères système qui produisent un affichage lorsque appelées dans la console, sont ici filtrés et remplacés par la fonction _write(), comme par hasard de façon identique à ce que font déjà les fonctions d'affichage publiques de ti_plotlib
• elle renvoie de plus un nombre, qui ne semblerait pas être le nombre de caractères de la chaîne mais la taille qu'occupe ces derniers en octet, apparemment :
  
  • 1 octet pour les caractères de codes 0 à 127
  • 2 octets pour les caractères de codes 128 et supérieurs
  
  On passe maintenant à _xy(x,y), qui pourrait bien t'être utile.
  Tu lui passes des coordonnées dans le repère, et elle te les convertit en pixels, comptés à partir du coin supérieur gauche de l'écran.
  
  
  Passons maintenant à _clipseg(x1,y1,x2,y2), qui retourne un quadruplet de valeurs (x'1,y'1,x'2,y'2). Ces valeurs semblent identiques à celles fournies lorsque les coordonnées tombent bien dans la partie visible du repère, et altérées lorsque au moins l'une d'entre elles est hors écran. Il semble donc que la fonction travaille sur un segment à tracer d'extrémités de coordonnées (x1,y1) et (x2,y2), et tronque si besoin ce segment de la ou des parties situées hors écran. Tu obtiens donc en retour les coordonnées des extrémités de la seule partie visible du segment. Fonction sans doute appelée en interne afin d'accélérer la boucle de traçage de line().
  
  Pour les fonctions _xytest([l1],[l2]), _mark(v1,v2,v3) et sema(), ici nous n'arrivons pour le moment à obtenir ni valeur de retour, ni affichage, ni même exception, et ignorons donc ce qu'elles peuvent faire.
  
  
  Mais nous t'avons gardé le meilleur pour la fin. Le module ti_plotlib contient lui-même des sous-modules :
  
  • d'une part le module sys que tu n'aurais donc pas besoin d'importer dans ce contexte
  • mais d'autre part, et c'est peut-être la découverte la plus extraordinaire, sous le nom de gr un mystérieux module ti_graphics non listé au menu !
  D'autres formidables possibilités en perspective, donc ? La suite au prochain épisode.