by 
NumWorks continue à se démener pour t'apporter à domicile le meilleur outil possible en ces temps difficiles. La nouvelle version NumWorks 13.2 est déjà disponible, et malgré la numérotation les avancées en sont majeures ! 
1) Python et mémoires
Go to topParlons maintenant mémoire. En Python il y a plus précisément 3 mémoires :
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 pratique, le heap / tas était selon nous de taille insuffisante sur NumWorks quand on considère les tailles énormes occupées en mémoire par les objets Python les plus simples.
Si les algorithmes de calculs mathématiques passaient certes nickel, il n'en allait pas de même pour ceux qui sortaient des sentiers battus.
Utilisation de chaînes ou fonctions graphiques pour créer des interfaces, utilisation de listes ou pire listes de listes, projets de SNT ou NSI, ... l'utilisateur un peu plus intéressé que la moyenne par la programmation en Python de sa NumWorks était condamné à rencontrer très rapidement des erreurs de mémoire et des problèmes d'optimisation de l'utilisation du tas / heap de plus en plus insolubles...
L'appel
Et bien NumWorks n'a pas manqué le rendez-vous et s'est bien occupé du heap / tas pour cette version. 
La capacité en est doublée, passant de 16K à 32K, enfin !
Une véritable bouffée d'oxygène qui devrait booster ta créativité, te permettant de poursuivre tes projets bien plus loin avant de ressentir le moindre besoin d'optimisation !
D'où le classement :
- 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
En pratique, le heap / tas était selon nous de taille insuffisante sur NumWorks quand on considère les tailles énormes occupées en mémoire par les objets Python les plus simples.Si les algorithmes de calculs mathématiques passaient certes nickel, il n'en allait pas de même pour ceux qui sortaient des sentiers battus.
Utilisation de chaînes ou fonctions graphiques pour créer des interfaces, utilisation de listes ou pire listes de listes, projets de SNT ou NSI, ... l'utilisateur un peu plus intéressé que la moyenne par la programmation en Python de sa NumWorks était condamné à rencontrer très rapidement des erreurs de mémoire et des problèmes d'optimisation de l'utilisation du tas / heap de plus en plus insolubles...
L'appel
mem() avec le script mem.py suivant permet d'estimer la capacité du heap / tas, et retournait jusqu'à présent autour de 16K sur NumWorks.- 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
Et bien NumWorks n'a pas manqué le rendez-vous et s'est bien occupé du heap / tas pour cette version. La capacité en est doublée, passant de 16K à 32K, enfin !
Une véritable bouffée d'oxygène qui devrait booster ta créativité, te permettant de poursuivre tes projets bien plus loin avant de ressentir le moindre besoin d'optimisation !
D'où le classement :
Aux examens :
Hors examens :
- 2,049276 Mo :
TI-Nspire (application MicroPython) - 1,032942 Mo :
Casio Graph 90+E - 1,022145 Mo :
HP Prime (version alpha) - 257,636 Ko :
Casio Graph 35/75+E (application CasioPython) - 100,560 Ko :
Casio Graph 35+E II - 31,899 Ko :
Casio Graph 35+E II (application CasioPython) - 32,339 Ko
NumWorks (firmware Omega) - 31,624 Ko
NumWorks - 22,605 Ko
TI-83 Premium CE + TI-Python (firmware tiers) - 20,200 Ko
TI-83 Premium CE Edition Python - 19,924 Ko
TI-83 Premium CE + TI-Python 16,238 Ko(ancienne version)
NumWorks
2) Python et module matplotlib
Go to top
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 | MicroPython TI-Nspire | CasioPython Casio Graph 35+E II 35+E/USB 75/85/95 | 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 !
Aux examens :
- 13 modules :
TI-83 Premium CE Edition Python - 11 modules :
NumWorks - 9 modules :
HP Prime (version alpha) - 3 modules :
Casio Graph 35+E II
Casio Graph 90+E
Hors examens :
- 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
Casio fx-9860GII
Casio fx-9860G
(appli CasioPython) - 8 modules :
TI-Nspire
(appli MicroPython)
TI-Python - 3 éléments :
Casio Graph 35+E II
Casio Graph 90+E
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 !
Aux examens :
- 219-642 éléments :
HP Prime (version alpha) - 265-365 éléments :
NumWorks - 170-296 éléments :
TI-83 Premium CE Edition Python - 117-208 éléments :
Casio Graph 35+E II
Casio Graph 90+E
Hors examens :
- 219-642 éléments :
HP Prime (version alpha) - 238-384 éléments :
TI-Python (firmware tiers) - 265-365 éléments :
NumWorks - 176-340 éléments :
TI-Nspire
(appli MicroPython) - 203-318 éléments :
Casio Graph 35+E II
Casio Graph 35+E/USB
Casio Graph 75/85/95
Casio fx-9750GII
Casio fx-9860GII
Casio fx-9860G
(appli CasioPython) - 170-296 éléments :
TI-83 Premium CE Edition Python - 158-284 éléments :
TI-Python - 117-208 éléments :
Casio Graph 35+E II
Casio Graph 90+E
3) Mon premier script matplotlib
Go to top
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()
4) matplotlib et possibilités
Go to top
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()
5) matplotlib et compatibilités
Go to topMais 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 :
On peut d'ailleurs même avoir du code compatible absolument identique avec la petite astuce d'importation suivante :
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 :
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 :
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 :
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 :
Personne ne semble tracer les pointes de flèches de la même façon, mais au moins ça marche.
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
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 |
 |  |  |
| ||
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 |
 |  |  |
| ||
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 |
 |  |  |
| ||
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 |
 |  |  |
| ||
Personne ne semble tracer les pointes de flèches de la même façon, mais au moins ça marche.
Conclusion
Go to topGrosse surprise donc de la part de NumWorks que ce soit pour le tas / heap Python de 32K ou pour la bibliothèque de tracés dans un repère matplotlib, nous ne nous y attendions pas.
Bravo pour avoir su écouter les retours et fournir un tas / heap qui devrait permettre d'aborder sereinement certains des projets de SNT / NSI, plus ambitieux que les petits algos de calcul traités en Mathématiques.
C'est en tous cas un très bon signal envoyé aux enseignants-prescripteurs concernés par ces matières pour la rentrée 2020.
Félicitations pour avoir réussi à incorporer une bibliothèque de tracés dans un repère fonctionnelle, et ce dans un temps apparemment plus court que la concurrence.
Et surtout, merci d'avoir opté dans ce cadre pour un standard déjà existant, matplotlib.pyplot, en conformité avec ce qui est mis en avant auprès des futurs enseignants de NSI à l'oral de leur concours, et donc pour la compatibilité aussi bien avec Casio qu'avec les implémentations Python complètes !
L'enseignant pourra ainsi gérer des classes disposant de modèles de marques différentes, et librement faire des aller-retours entre calculatrices et ordinateurs !
Bravo pour avoir su écouter les retours et fournir un tas / heap qui devrait permettre d'aborder sereinement certains des projets de SNT / NSI, plus ambitieux que les petits algos de calcul traités en Mathématiques.
C'est en tous cas un très bon signal envoyé aux enseignants-prescripteurs concernés par ces matières pour la rentrée 2020.
Félicitations pour avoir réussi à incorporer une bibliothèque de tracés dans un repère fonctionnelle, et ce dans un temps apparemment plus court que la concurrence.
Et surtout, merci d'avoir opté dans ce cadre pour un standard déjà existant, matplotlib.pyplot, en conformité avec ce qui est mis en avant auprès des futurs enseignants de NSI à l'oral de leur concours, et donc pour la compatibilité aussi bien avec Casio qu'avec les implémentations Python complètes !
L'enseignant pourra ainsi gérer des classes disposant de modèles de marques différentes, et librement faire des aller-retours entre calculatrices et ordinateurs !
Et puis petite surprise, visiblement NumWorks tient compte en un temps record de toutes les critiques, même des plus insignifiantes. 
Malgré les ajouts importants le nouveau firmware 13.2.0 est sensiblement moins gros que le 13.1.0.
Il semble y avoir donc eu quelques optimisations dans ce court laps de temps, et l'ancien modèle NumWorks N0100 malgré sa Flash de seulement 1 Mio devrait donc pouvoir continuer à bénéficier de l'ensemble des nouveautés pendant quelques mises à jour encore.
Liens :
- Mise à jour (suivre les instructions)
- Simulateur en ligne
- Code source
