π
<-
Chat plein-écran
[^]

Exploration module Python ti_plotlib TI-83 Premium CE 5.5

:32ti73: :32ti73e: :32ti73e2: :32ti76f: :32ti80: :32ti81: :32ti82: :32ti85: :32ti86: :32ti82s: :32ti82sf: :32ti82sfn: :32ti83: :32ti83p: :32ti83pb: :32ti83pr: :32ti83pfr: :32ti83pse: :32ti84p: :32ti84pse: :32ti84ppse: :32ti84pfr: :32ti84pcse: :32ti83pfrusb: :32ti82p: :32ti82a: :32ti84pce: :32ti83pce:
Online

Exploration module Python ti_plotlib TI-83 Premium CE 5.5

Unread postby critor » 27 Apr 2020, 11:55

12382Dans 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 :)
  • , 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
      ! :bj:
    • affichage dans la console à la ligne que tu veux :bj:
    • 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 :bj:
    • importation depuis le contexte
      Python
      de listes ou équation de régression existant dans l'environnement de la calculatrice :bj:
    • 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é ! :bj:
  • 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
    ! :bj:
  • ti_hub
    , pour les projets d'objects connectés à l'aide de l'interface :)
  • ti_rover
    , pour les projets de robotique à l'aide du :)
  • 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

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 ! :bj:


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:6prime:3-7ion: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-10board: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 ! :bj:
    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 ! :D

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

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
:

Image
User avatar
critorAdmin
Niveau 19: CU (Créateur Universel)
Niveau 19: CU (Créateur Universel)
Level up: 5.1%
 
Posts: 35281
Images: 9403
Joined: 25 Oct 2008, 00:00
Location: Montpellier
Gender: Male
Calculator(s):
Class: Lycée
YouTube: critor3000
Twitter: critor2000
Facebook: critor.ti

Re: Exploration module Python ti_plotlib TI-83 Premium CE 5.

Unread postby Lionel Debroux » 27 Apr 2020, 14:53

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.
Membre de la TI-Chess Team.
Co-mainteneur de GCC4TI (documentation en ligne de GCC4TI), TIEmu et TILP.
User avatar
Lionel DebrouxSuper Modo
Niveau 14: CI (Calculateur de l'Infini)
Niveau 14: CI (Calculateur de l'Infini)
Level up: 6.5%
 
Posts: 6492
Joined: 23 Dec 2009, 00:00
Location: France
Gender: Male
Calculator(s):
Class: -
GitHub: debrouxl

Online

Re: Exploration module Python ti_plotlib TI-83 Premium CE 5.

Unread postby critor » 27 Apr 2020, 14:58

Merci. :)

Lionel Debroux wrote: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.
Image
User avatar
critorAdmin
Niveau 19: CU (Créateur Universel)
Niveau 19: CU (Créateur Universel)
Level up: 5.1%
 
Posts: 35281
Images: 9403
Joined: 25 Oct 2008, 00:00
Location: Montpellier
Gender: Male
Calculator(s):
Class: Lycée
YouTube: critor3000
Twitter: critor2000
Facebook: critor.ti

Re: Exploration module Python ti_plotlib TI-83 Premium CE 5.

Unread postby CaptainLuigi » 27 Apr 2020, 19:23

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 )
User avatar
CaptainLuigiPremium
Niveau 9: IC (Compteur Infatigable)
Niveau 9: IC (Compteur Infatigable)
Level up: 31.8%
 
Posts: 17
Joined: 04 Dec 2019, 12:36
Gender: Male
Calculator(s):
Class: Première générale
YouTube: Tutodev
GitHub: PaulThorel

Online

Re: Exploration module Python ti_plotlib TI-83 Premium CE 5.

Unread postby critor » 27 Apr 2020, 19:31

Parce qu'il n'y est pas, tout simplement. :)
Image
User avatar
critorAdmin
Niveau 19: CU (Créateur Universel)
Niveau 19: CU (Créateur Universel)
Level up: 5.1%
 
Posts: 35281
Images: 9403
Joined: 25 Oct 2008, 00:00
Location: Montpellier
Gender: Male
Calculator(s):
Class: Lycée
YouTube: critor3000
Twitter: critor2000
Facebook: critor.ti

Re: Exploration module Python ti_plotlib TI-83 Premium CE 5.

Unread postby CaptainLuigi » 27 Apr 2020, 19:53

critor wrote:Parce qu'il n'y est pas, tout simplement. :)

Mais alors ... :? Ca sort d'ou ?
User avatar
CaptainLuigiPremium
Niveau 9: IC (Compteur Infatigable)
Niveau 9: IC (Compteur Infatigable)
Level up: 31.8%
 
Posts: 17
Joined: 04 Dec 2019, 12:36
Gender: Male
Calculator(s):
Class: Première générale
YouTube: Tutodev
GitHub: PaulThorel

Online

Re: Exploration module Python ti_plotlib TI-83 Premium CE 5.

Unread postby critor » 27 Apr 2020, 19:58

Il faudra le rajouter manuellement après mise à jour si j'ai bien compris, comme chez
Casio
.
Image
User avatar
critorAdmin
Niveau 19: CU (Créateur Universel)
Niveau 19: CU (Créateur Universel)
Level up: 5.1%
 
Posts: 35281
Images: 9403
Joined: 25 Oct 2008, 00:00
Location: Montpellier
Gender: Male
Calculator(s):
Class: Lycée
YouTube: critor3000
Twitter: critor2000
Facebook: critor.ti

Online

Re: Exploration module Python ti_plotlib TI-83 Premium CE 5.

Unread postby critor » 27 Apr 2020, 20:03

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
? ;)
Image
User avatar
critorAdmin
Niveau 19: CU (Créateur Universel)
Niveau 19: CU (Créateur Universel)
Level up: 5.1%
 
Posts: 35281
Images: 9403
Joined: 25 Oct 2008, 00:00
Location: Montpellier
Gender: Male
Calculator(s):
Class: Lycée
YouTube: critor3000
Twitter: critor2000
Facebook: critor.ti

Re: Exploration module Python ti_plotlib TI-83 Premium CE 5.

Unread postby CaptainLuigi » 28 Apr 2020, 09:11

Pourquoi pas :whistle:
User avatar
CaptainLuigiPremium
Niveau 9: IC (Compteur Infatigable)
Niveau 9: IC (Compteur Infatigable)
Level up: 31.8%
 
Posts: 17
Joined: 04 Dec 2019, 12:36
Gender: Male
Calculator(s):
Class: Première générale
YouTube: Tutodev
GitHub: PaulThorel


Return to News TI-z80 (TI-73, 76, 80, 81, 82, 83, 84, 85, 86)

Who is online

Users browsing this forum: No registered users and 7 guests

-
Search
-
Featured topics
L'OS 5.5 de la TI-83 Premium CE / 84 Plus CE supprime l'assembleur - la plupart des jeux et certains programme ne fonctionneront plus
Omega, le fork étendant les capacités de ta NumWorks, même en mode examen !
Découvre les nouvelles fonctionnalités en Python de l'OS 5.5 pour la 83PCE/84+C-T Python Edition
Comparaisons des meilleurs prix pour acheter sa calculatrice !
1234
-
Donations / Premium
For more contests, prizes, reviews, helping us pay the server and domains...

Discover the the advantages of a donor account !
JoinRejoignez the donors and/or premium!les donateurs et/ou premium !


Partner and ad
Notre partenaire Jarrety 
-
Stats.
441 utilisateurs:
>433 invités
>2 membres
>6 robots
Record simultané (sur 6 mois):
6892 utilisateurs (le 07/06/2017)
-
Other interesting websites
Texas Instruments Education
Global | France
 (English / Français)
Banque de programmes TI
ticalc.org
 (English)
La communauté TI-82
tout82.free.fr
 (Français)