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.
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: Tout sélectionner
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: Tout sélectionner
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: Tout sélectionner
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: Tout sélectionner
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: Tout sélectionner
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: Tout sélectionner
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: Tout sélectionner
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: Tout sélectionner
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: Tout sélectionner
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 :
Aux examens français :
- 13 modules :
TI-83 Premium CE Edition Python - 11 modules :
NumWorks - 9 modules :
HP Prime (version alpha) - 4 modules :
Casio Graph 35+E II
Casio Graph 90+E
En classe :
- 13 modules :
TI-Python (firmware tiers)
TI-83 Premium CE Edition Python - 11 modules :
NumWorks - 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) - 8 modules :
TI-Nspire (appli MicroPython)
TI-Python - 6 modules :
Casio Graph 35+E II
Casio Graph 90+E
Casio fx-9750/9860GIII
Casio fx-CG50
Aux examens français :
- 219-642 éléments :
HP Prime (version alpha) - 265-365 éléments :
NumWorks - 219-352 éléments :
TI-83 Premium CE Edition Python - 123-214 éléments :
Casio Graph 35+E II
Casio Graph 90+E
En classe :
- 219-642 éléments :
HP Prime (version alpha) - 265-365 éléments :
NumWorks - 238-384 éléments :
TI-Python (firmware tiers) - 219-352 éléments :
TI-83 Premium CE Edition Python - 217-308 éléments :
Casio Graph 35+E II
Casio Graph 90+E
Casio fx-9750/9860GIII
Casio fx-CG50 - 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) - 176-340 éléments :
TI-Nspire (appli MicroPython) - 158-284 éléments :
TI-Python
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.
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.
Avant l'avènement des calculatrices graphiques, c'est Nintendo qui lança le tout premier jeu électronique de poche muni d'un écran LCD (cristaux liquides) exploitant les deux dimensions, Ball en avril 1980. Comme indiqué par sa référence AC-01, c'était le premier né de la gamme Game & Watch, largement imitée au siècle dernier par d'autres constructeurs asiatiques pour le meilleur et pour le pire. Au lieu de simples points, les pixels ici allumés à l'écran ont des formes représentant des éléments du jeu.
Jouer à des jeux pour t'occuper en confinement c'est bien, mais les créer c'est encore mieux non ? 
As-tu bien compris ?
#/media/File:Parker_brothers_merlin_hand_held_electronic_game.jpg){kind=link}