Forum TI-Planet.org

Parlons maintenant mémoire. En Python il y a plus précisément 3 mémoires :

• la mémoire de stockage qui accueille et conserve tes scripts
• le stack (pile) qui, à l'exécution, accueille les références vers les objets créés
• le heap (tas) qui, à l'exécution, accueille les valeurs de ces objets

En gros le stack / pile limite donc le nombre d'objets différents pouvant exister simultanément en mémoire, alors que le heap / tas limite la taille globale occupé par ces objets.

Dans la dernière version NumWorks avait déjà fortement amélioré la mémoire Python :

• en doublant la mémoire de stockage
• en quadruplant le stack / pile

Il restait donc encore à s'occuper du heap / tas.

Code: Select all

def sizeenv():
  s=0
  import __main__
  for o in dir(__main__):
    try:s+=size(eval(o))
    except:pass
  return s
def size(o):
  s,t=0,type(o)
  if t==str:s=49+len(o)
  if str(t)=="<class 'function'>":s=136
  if t==int:
    s=24
    while o:
      s+=4
      o>>=30
  if t==list:
    s+=64
    for so in o:s+=8+size(so)
  return s
def mem(v=1,r=1):
  try:
    l=[]
    try:
      l+=[r and 793+sizeenv()]
      if v*r:print(" ",l[0])
      l+=[0]
      l+=[""]
      l[2]+="x"
      while 1:
        try:l[2]+=l[2][l[1]:]
        except:
          if l[1]<len(l[2])-1:l[1]=len(l[2])-1
          else:raise(Exception)
    except:
      if v:print("+",size(l))
      try:l[0]+=size(l)
      except:pass
      try:l[0]+=mem(v,0)
      except:pass
      return l[0]
  except:return 0

D'où le classement :

Accroche-toi bien à ta chaise, le module Python de tracé dans un repère tant teasé par la concurrence depuis des mois sort enfin là où on ne l'attendait pas, c'est-à-dire sur ta NumWorks et même en exclusivité à ce jour !

Il prend le nom de matplotlib.pyplot, avec les fonctions listées et documentées ci-dessous :


Réalisons en une fouille un peu plus approfondie à l'aide du script explmod.py, à la recherche d'éventuels éléments cachés :

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,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

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]

Rien de bien extraordinaire ici, mais on découvre quand même que matplotlib.pyplot est lui-même un sous-module de matplotlib, ce que le nommage suggérait déjà.

Suite à cet ajout majeur, profitons-en pour voir où nous en sommes niveau richesse du Python sur calculatrices:

	autorisés aux examens français				inutilisables aux examens français
	NumWorks	Casio Graph 35+E II 90+E	TI-83PCE Ed. Python	version alpha HP Prime	MicroPython TI-Nspire	CasioPython Casio Graph 35+E II 35+E/USB 75/85/95	TI-Python	firmware tiers TI-Python
builtins array collections cmath gc math matplotlib matplotlib.pyplot micropython os random sys time turtle uerrno	88-188 . . 12 . 41 3 11 6 . 9 . 3 38 .	84-175 . . . . 25 . . . . 8 . . . .	92-189 2-4 2 . 7 28 . . . . 8 15-42 4 . .	97-440 3-13 . 13-17 9-13 42-46 . . 10-14 . . 17-63 . . 25-29	93-218 2-4 . 12 7 41 . . 3 . . 15-45 . . .	91-204 2-4 . 12 7 41 . . 6 . 8 12 . . 24	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	ion:48 kandinsky:6		ti_graphics:? ti_hub:? ti_plotlib:? ti_system:12 ti_rover:?	prime:3-7	nsp:3-10			board:22 storage:7-21
Modules	11	3	13	9	8	9	9	13
Eléments	265-365	117-208	170-296	219-642	176-340	203-318	158-284	238-384

En terme de diversité des modules, la NumWorks se fixe donc au 2^ème rang, un excellent choix !

En terme de richesse des modules, la NumWorks varie également entre les 2^ème et 3^ème rangs, toujours de loin un des meilleurs choix !

L'utilisation de matplotlib.pyplot est extrêmement simple.

Avant de faire appel à matplotlib.pyplot, tes scripts doivent commencer par importer ce module d'une façon ou d'une autre, par exemple avec from matplotlib.pyplot import *.

Les tracés que tu demandes sont donc effectués dans un repère, sur un calque distinct de celui de la console Python. Sans instruction en ce sens, c'est le seul calque de la console qui restera affiché.
A chaque fois que tu souhaites rendre visible le calque du repère avec tes derniers tracés (par exemple avant la fin de ton script, ou avant que l'utilisateur ait à saisir quelque chose), il te faut faire appel à la fonction show().
Cette dernière affiche non seulement le calque du repère avec tes derniers tracés, mais te permet de le faire défiler avec les touches fléchées, et attend l'appui sur la touche d'annulation

↩

pour rendre la main au script.

Tu peux si tu le souhaites activer/désactiver l'affichage d'une grille permettant de mieux lire les coordonnées du repère avec grid().

Tu peux également configurer toi-même les bornes de la fenêtre à l'aide de axis([xmin, xmax, ymin, ymax]).
Note toutefois que ce n'est absolument pas obligatoire. Par défaut la fenêtre s'adapte automatiquement pour que soient visibles l'ensemble de tes tracés comme illustré ci-contre par le code ci-dessous !
Une petite marge t'est même ménagée. Toutefois, on peut noter ici que l'on n'obtient pas forcément un repère orthonormal (même unité en abscisse et en ordonnée).

Code: Select all

from matplotlib.pyplot import *

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

def arrowvec(p0, v, s=''):
  arrow(p0[0], p0[1], v[0], v[1])
  text(p0[0] + v[0]/2, p0[1] + v[1]/2, s)

u = [1, 5]
v = [5, 1]
w = sumvec(u, v)
grid()
lp = [[-5, 0], [5, 0]]
arrowvec(lp[0], u, 'u')
print(sumvec(lp[0], u))
arrowvec(sumvec(lp[0], u), v, 'v')
arrowvec(lp[0], w, 'w')
arrowvec(lp[1], u, 'u')
arrowvec(lp[1], v, 'v')
arrowvec(sumvec(lp[1], u), v, 'v')
arrowvec(sumvec(lp[1], v), u, 'u')
arrowvec(lp[1], w, 'w')
text(0, 0, 'w=u+v')

show()

Comme la bibliothèque Python standard matplotlib, le matplotlib de NumWorks dispose d'une fonction bar(x, height) pour le tracé de diagrammes en barres.
La fonction hist(x, bins) sera quant à elle à privilégier pour les histogrammes au sens large (barres de largeurs différentes).

Toujours comme avec matplotlib, la fonction scatter(x, y) permet d'afficher une représentation en nuage de points.
plot(x, y) pour sa part reliera en prime les points, mais attention dans l'ordre avec lequel tu les fournis.

C'est déjà une réponse claire aux besoins du programme de Physique-Chimie de Seconde, même si un usage en Mathématiques n'est pas à exclure, dans la partie Statistiques ou encore pour étudier le fonctionnement d'un grapheur de fonctions et éviter les pièges des lectures graphiques.

Et puis ce n'est pas tout, arrow(x, y, dx, dy) permettra de tracer des flèches pour représenter des vecteurs, aussi bien en Physique-Chimie (vecteurs force, vecteur vitesse, ...) qu'en Mathématiques !
Un petit lancer parabolique avec ça ?

Code: Select all

from matplotlib.pyplot import *
from math import *

g=9.81

def x(t,v_0,alpha):
  return v_0*cos(alpha)*t
def y(t,v_0,alpha,h_0):
  return -0.5*g*t**2+v_0*sin(alpha)*t+h_0

def vx(v_0,alpha):
  return v_0*cos(alpha)
def vy(t,v_0,alpha):
  return -g*t+v_0*sin(alpha)

def t_max(v_0,alpha,h_0):
  return (v_0*sin(alpha)+sqrt((v_0**2)*(sin(alpha)**2)+2*g*h_0))/g

def simulation(v_0=15,alpha=pi/4,h_0=2):
  tMax=t_max(v_0,alpha,h_0)
  accuracy=1/10**(floor(log10(tMax))-1)
  T_MAX=floor(tMax*accuracy)+1
  X=[x(t/accuracy,v_0,alpha) for t in range(T_MAX)]
  Y=[y(t/accuracy,v_0,alpha,h_0) for t in range(T_MAX)]
  VX=[vx(v_0,alpha) for t in range(T_MAX)]
  VY=[vy(t/accuracy,v_0,alpha) for t in range(T_MAX)]
  for i in range(T_MAX):
    arrow(X[i],Y[i],VX[i]/accuracy,VY[i]/accuracy)
  grid()
  show()

Mais ce qu'il y a de fantastique avec la bibliothèque matplotlib.pyplot de NumWorks , c'est que les scripts créés sont compatibles aussi bien avec le Python des calculatrices Casio qu'avec les implémentations Python complètes pour ordinateur !
Si si, pour la rentrée 2020 les mêmes scripts graphiques Python seront exécutables à la fois sur NumWorks et sur Casio !

En réalité chez Casio, si nous avons bien compris/deviné il y a :

• une bibliothèque graphique spécifique du constructeur, casioplot
• un script préchargé matplotl.py (d'où la limitation historique à 8 caractères en passant), qui joue le rôle d'interface pour cette bibliothèque, une interface fournissant des fonctions d'appel aux spécifications compatibles avec matplotlib.pyplot
• et de même un script préchargé turtle.py fournissant pour sa part des fonctions d'appel compatibles avec les spécifications de la bibliothèque turtle standard

Les scripts Casio seront donc compatibles à un détail près, la ligne import matplotl.pyplot étant à remplacer par import matplotl ou inversement.

On peut d'ailleurs même avoir du code compatible absolument identique avec la petite astuce d'importation suivante :

Code: Select all

try:
  from matplotlib.pyplot import *
except:
  from matplotl import *

Traitons quelques exemples à la fois sur NumWorks, Casio et ordinateur pour voir jusqu'où va cette compatibilité.
Ne disposant pas encore de la prochaine mise à jour de Casio rajoutant ces fonctionnalités, nous reprendrons des exemples déjà fournis et illustrés par ce constructeur.

Un petit diagramme en barres avec fenêtre automatique :

NumWorks	Casio	ordi
Code: Select all try:   from matplotlib.pyplot import * except:   from matplotl import * x = [119.1, 119.3, 119.5, 119.6, 119.9, 120.0, 120.1, 120.3, 120.4] y = [1, 3, 4, 3, 1, 3, 1, 3, 1] bar(x, y, 0.08) show()

Des couleurs différentes, des barres qui sont parfois remplies parfois non, mais cela n'en est pas moins parfaitement fonctionnel sans le moindre changement autre que l'importation, c'est fantastique !

Un petit nuage de points en précisant la fenêtre et avec un titre :

NumWorks	Casio	ordi
Code: Select all try:   from matplotlib.pyplot import * except:   from matplotl import * x = [100, 110, 120, 130, 140, 150, 160] y = [105, 95, 75, 68, 53, 46, 31] scatter(x, y) axis([80, 170, 10, 130]) text(110, 125, "Nombre d'acheteurs vs prix de vente") show()

Casio utilisant ici pour le titre des coordonnées absolues prévues pour son écran, forcément ça passe moins bien sur l'écran NumWorks de géométrie différente et il faut ici faire défiler avec les flèches.

Un diagramme en ligne brisée pour approcher une fonction :

NumWorks	Casio	ordi
Code: Select all try:   from matplotlib.pyplot import * except:   from matplotl import * def fonction():     def f(x):         return x**3-6*x**2+9*x+1     start = -0.5     end = 4.5     steps = 0.1     x = [start+i*steps for i in range(int((end-start)/steps)+1)]     y = [f(j) for j in x]     plot(x, y)     show()

On remarque mieux ici que NumWorks utilise une graduation sur les axes, alors que les autres utilisent une graduation en bordure de fenêtre.

Et enfin quelques flèches/vecteurs :

NumWorks	Casio	ordi
Code: Select all try:   from matplotlib.pyplot import * except:   from matplotl import * arrow(0.20, 0.54, 0, -0.15) arrow(0.30, 0.46, 0, -0.15) arrow(0.40, 0.59, 0, -0.15) show()

Personne ne semble tracer les pointes de flèches de la même façon, mais au moins ça marche.