Exploration module Python ti_plotlib TI-83 Premium CE 5.5

[critor]

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.

Attention, nous ne disposons que d'une préversion. Il est donc parfaitement possible que plusieurs points traités soient améliorés d'ici la sortie.

Sommaire :

1. ti_plotlib et fonctions de configuration
2. ti_plotlib et fonctions d'affichage de primitives
3. ti_plotlib et fonctions d'affichage de diagrammes
4. Exploration ti_plotlib
5. ti_plotlib et fonctions secrètes
6. Conclusion

1) ti_plotlib et fonctions de configuration

Go to top

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.

2) ti_plotlib et fonctions d'affichage de primitives

Go to top

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

3) ti_plotlib et fonctions d'affichage de diagrammes

Go to top

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

4) exploration ti_plotlib

Go to top

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 :

aux examens
français en classe
uniquement

	Casio Graph 35+E II 90+E	version alpha HP Prime	NumWorks	TI-83PCE Ed. Python
builtins array collections cmath gc math matplotlib matplotlib.pyplot micropython os random sys time turtle uerrno	84-175 . . . . 25 . . . . 8 . . . .	97-440 3-13 . 13-17 9-13 42-46 . . 10-14 . . 17-63 . . 25-29	88-188 . . 12 . 41 3 11 6 . 9 . 3 38 .	92-189 2-4 2 . 7 28 . . . . 8 15-42 4 . .
spécifique	casioplot:6	prime:3-7	ion:48 kandinsky:6	ti_graphics:? ti_hub:? ti_plotlib:49-56 ti_system:12 ti_rover:?
Modules	4	9	11	13
Eléments	123-214	219-642	265-365	219-352

	Casio Graph 35+E II 90+E	CasioPython Casio Graph 35+E II 35+E/USB 75/85/95	MicroPython TI-Nspire	TI-Python	firmware tiers TI-Python
builtins array collections cmath gc math matplotlib matplotlib.pyplot micropython os random sys time turtle uerrno	84-175 . . . . 25 . . . . 8 . . 69 .	91-204 2-4 . 12 7 41 . . 6 . 8 12 . . 24	93-218 2-4 . 12 7 41 . . 3 . . 15-45 . . .	92-189 2-4 2 . 7 28 . . . . 8 15-42 4 . .	93-191 2-4 2 12 7 41 . . 6 15 8 15-45 8-10 . .
spécifique	casioplot:6 matplotl:25		nsp:3-10		board:22 storage:7-21
Modules	6	9	8	9	13
Eléments	217-308	203-318	176-340	158-284	238-384

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

Aux examens français :

1. 13 modules :
   TI-83 Premium CE Edition Python
2. 11 modules :
   NumWorks
3. 9 modules :
   HP Prime (version alpha)
4. 4 modules :
   Casio Graph 35+E II
   Casio Graph 90+E

En classe :

1. 13 modules :
   TI-Python (firmware tiers)
   TI-83 Premium CE Edition Python
2. 11 modules :
   NumWorks
3. 9 modules :
   HP Prime (version alpha)
   Casio Graph 35+E II
   Casio Graph 35+E/USB
   Casio Graph 75/85/95
   Casio fx-9750GII/GIII
   Casio fx-9860G/GII/GIII
   (appli CasioPython)
4. 8 modules :
   TI-Nspire (appli MicroPython)
   TI-Python
5. 6 modules :
   Casio Graph 35+E II
   Casio Graph 90+E
   Casio fx-9750/9860GIII
   Casio fx-CG50

Aux examens français :

1. 219-642 éléments :
   HP Prime (version alpha)
2. 265-365 éléments :
   NumWorks
3. 219-352 éléments :
   TI-83 Premium CE Edition Python
4. 123-214 éléments :
   Casio Graph 35+E II
   Casio Graph 90+E

En classe :

1. 219-642 éléments :
   HP Prime (version alpha)
2. 265-365 éléments :
   NumWorks
3. 238-384 éléments :
   TI-Python (firmware tiers)
4. 219-352 éléments :
   TI-83 Premium CE Edition Python
5. 217-308 éléments :
   Casio Graph 35+E II
   Casio Graph 90+E
   Casio fx-9750/9860GIII
   Casio fx-CG50
6. 203-318 éléments :
   Casio Graph 35+E II
   Casio Graph 35+E/USB
   Casio Graph 75/85/95
   Casio fx-9750GII/GIII
   Casio fx-9860G/GII/GIII
   (appli CasioPython)
7. 176-340 éléments :
   TI-Nspire (appli MicroPython)
8. 158-284 éléments :
   TI-Python

5) ti_plotlib et fonctions secrètes

Go to top

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

Même si nous allons les documenter autant que possible ici, il est à noter que comme ces éléments ne sont pas listés au menu, leur fonctionnement n'est pas garanti par TI.

C'est-à-dire que leur fonctionnement peut changer ou qu'ils peuvent même disparaître complètement lors d'une mise à jour ultérieure.

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.

Conclusion

Go to top

Le module ti_plotlib nous apporte donc enfin la possibilité en Python de tracer dans un repère, un module très pertinent par rapport aux programmes de Mathématiques et Physique-Chimie.
Du travail très conséquent de la part de Texas Instruments qui s'est donc tapé la conception intégrale du module à partir de zéro, une mise à jour majeure et historique comme nous en avons rarement vue !

Contrairement au casioplotl.py de Casio, ti_plotlib a de plus le gros avantage de rester disponible en mode examen !

Nous regrettons toutefois à ce jour des possibilités d'affichage de texte très inférieures à celles du langage TI-Basic historique. Entre les effets de bord vus plus haut et le système de positionnement lié paradoxalement à l'écran et non au repère, faire cohabiter affichages d'objets graphiques et de textes va être bien difficile.

Aussi cela ne t'a sans doute pas échappé, contrairement à la concurrence ti_plotlib n'est pas compatible matplotlib.pyplot. Les fonctions n'ont pas les mêmes spécifications ou mêmes noms.
Nous le regrettons également, ce ne seront donc pas les mêmes appels que ceux mis en avant auprès des nouveaux enseignants lors des épreuves du CAPES, ou auprès des élèves dans les livres scolaire.
Personnellement cela ne nous cause aucune difficulté, mais ce besoin d'apprendre une nouvelle bibliothèque non standard risque d'en rebuter certains, aussi bien parmi les lycéens que les enseignants.

Mais c'est justement pour cela que nous t'avons détaillé méticuleusement les spécifications et fonctionnements de chaque fonction publique ou même privée, afin de rendre possible un jour le développement d'une interface de compatibilité permettant d'utiliser ti_plotlib avec les appels matplotlib.pyplot, interface qui nous l'espérons ralliera les derniers récalcitrants.

Tutos Python TI-83 Premium CE Édition Python 5.5 :

• Tuto-vidéo de représentation graphique de fonctions avec ti_plotlib
• Tuto-vidéo de représentation graphique de vecteurs avec ti_plotlib
• Tuto-vidéo de représentation graphique de régression linéaire avec ti_plotlib
• Tutos Python TI-Code (voir l'unité 4 pour le module ti_plotlib)

[Lionel Debroux]

Super boulot de test et de rédaction, qui a pris beaucoup de temps, je le sais

Je suis partagé entre le "bien, TI a enfin fourni des fonctionnalités de dessin de type plot" et le "bouh, c'est limité et de plus, incompatible avec ce que proposent les autres constructeurs". Mais on ne peut pas espérer de miracles avec une plate-forme aussi stupidement limitée que l'ATSAMD21... on en revient toujours au même point, TI a fait une grosse bêtise en n'équipant pas les 83PCE EP d'un ATSAMD51. Passait encore que les TI-Python Adapter, qui représentaient une mesure d'urgence pour occuper le terrain, aient été équipés d'ATSAMD21 afin de gagner quelques sous; pour un modèle de production, ça aurait être dû différent, les ATSAMD21 ayant montré leurs limitations du temps du TI-Python Adapter.

[critor]

Merci.

Je suis partagé entre le "bien, TI a enfin fourni des fonctionnalités de dessin de type plot" et le "bouh, c'est limité et de plus, incompatible avec ce que proposent les autres constructeurs". Mais on ne peut pas espérer de miracles avec une plate-forme aussi stupidement limitée que l'ATSAMD21... on en revient toujours au même point, TI a fait une grosse bêtise en n'équipant pas les 83PCE EP d'un ATSAMD51. Passait encore que les TI-Python Adapter, qui représentaient une mesure d'urgence pour occuper le terrain, aient été équipés d'ATSAMD21 afin de gagner quelques sous; pour un modèle de production, ça aurait être dû différent, les ATSAMD21 ayant montré leurs limitations du temps du TI-Python Adapter.

Il y a aussi la possibilité que ce ne soit pas une erreur.

La TI-83 Premium CE Edition Python serait alors dédiée aux petits algo-amusements de quelques lignes bien scolaires que l'on fait en Maths ou Physique-Chimie...
Et pour ceux ayant des besoins supérieurs (NSI, projets, ...) il y aurait un autre produit, la TI-Nspire CX II-T.

J'ignore si c'est voulu, mais je trouve que ça se tient en terme de gamme.

Après, la TI-Nspire CX II-T peut-elle marcher en France et surtout avec la crise actuelle aux prix à 3 chiffres que je constate chez nos voisins européens, ça c'est une autre question...
Il faut savoir que nombre de nos voisins européens (Pays-Bas, Portugal, Italie, Royaume-Uni...) interdisent le calcul formel et donc le haut de gamme TI-Nspire CX II-T CAS. Et dans ces pays les revendeurs en profitent bien, vendant la TI-Nspire CX II-T inférieure quasiment aux mêmes prix.

[CaptainLuigi]

Critor , sauf erreur de lecture de ma part , tu n'as pas mentionné le module ce_turtle ( que tu avsi découvert il y a peu de temps )

[critor]

Parce qu'il n'y est pas, tout simplement.

[CaptainLuigi]

Parce qu'il n'y est pas, tout simplement.

Mais alors ... Ca sort d'ou ?

[critor]

Il faudra le rajouter manuellement après mise à jour si j'ai bien compris, comme chez Casio.

[critor]

Mais c'est quand même déjà pas mal le ti_plotlib non, qu'en penses-tu ?
Matière à l'aborder à un prochain TI-Planet FM ?

[CaptainLuigi]

Pourquoi pas