by 
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
oualpha
), 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é !
- détection des simples pressions de touches clavier (sans validation donc) par l'utilisateur, avec même l'éventuel modificateur actif (
- 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
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
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,
onou
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
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
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 topVoyons 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 :
Et effectivement il y a des bien des choses encore non abordées, l'appel
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 :
- 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 :
Casio Graph 35+E II 90+E | 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 | ||
| 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 :
- 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
5) ti_plotlib et fonctions secrètes
Go to topSelon 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 :
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 :
_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
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.
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.
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'
_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)etsema(), 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 !
Conclusion
Go to topLe 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 !
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.
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 :
Ca sort d'ou ?
