[Admin]

Dans la crise sanitaire actuelle, NumWorks reste à tes côtés. Afin de t'accompagner dans tes apprentissages et devoirs avec un outil toujours plus exceptionnel, la nouvelle version NumWorks 13 est maintenant disponible.

Plus précisément il s'agit de la version 13.1.0 et nous allons découvrir ensemble les nouveautés apportées :

1. Clavier et interface
2. Paramètres et mode examen
3. Paramètres et Python
4. Python
5. Calculs
6. Probabilités
7. Équations
8. Fonctions
9. Régressions
10. Conclusion

1) Clavier et interface

Go to top

Déjà grande nouveauté, dans l'ensemble des applications il t'est enfin possible de sélectionner naturellement du texte dans une zone de saisie. Cela se passe aussi naturellement que sur ordinateur, en maintenant la touche

shift

puis une touche fléchée.

La sélection pourra alors être coupée-copiée-collée-effacée à l'aide des raccourcis clavier.

C'est particulièrement bienvenu dans le cadre de l'application Python, pour une saisie encore plus rapide et donc agréable de tes scripts lorsqu'ils comporteront plusieurs lignes ou blocs similaires !

Notons également que le défilement des tableaux de valeurs présentés par les divers applications a été accéléré.

2) Paramètres et mode examen

Go to top

Afin de cibler les besoin des différents pays et examens, la calculatrice dispose désormais de 2 modes examen au choix :

1. Standard, qui efface le contenu mémoire sans limitation de fonctionnalités comme exigé en France.
2. Dutch, ciblant la réglementation plus restrictive des Pays-Bas qui viennent tout juste d'autoriser la calculatrice NumWorks aux examens.

Si tu ne vois rien c'est normal, le choix de ce 2^ème mode examen n'est pas proposé lorsque la calculatrice est réglée en langue française. La calculatrice ne parlant pas non plus néerlandais pour le moment, à ce jour tu devras la basculer en anglais pour le faire apparaître.

En plus du contenu mémoire, ce mode examen Dutch désactive comme indiqué l'application Python, car les Pays-Bas interdisent l'accès à tout éditeur de texte pendant les épreuves.

Et bien évidemment, une fois le mode examen néerlandais activé, il n'est plus possible d'altérer ces restrictions sans désactiver le mode examen et donc éteindre la diode. A priori NumWorks a bien codé la chose; changer la langue ou réactiver le mode examen ne permet pas de récupérer l'accès à l'application Python.

Les deux modes examens produiront de plus un signal différent sur la diode :

• rouge en mode examen Standard
• jaune en mode examen Dutch

Voilà qui permettra aux surveillant de détecter les candidats qui n'auraient pas activé le bon mode, surtout aux Pays-Bas.

Enfin en ce qui nous concerne, notons qu'une fois le mode examen activé, son écran affiche maintenant les instructions permettant de le désactiver, à savoir la connexion à toute source d'alimentation USB (ordinateur, tablette, smartphone OTG, batterie USB, chargeur USB, ...).

3) Paramètres et Python

Go to top

L'application Paramètres offre de plus désormais un nouveaux choix, celui de la taille de police qui sera utilisée dans l'application Python :

• Grande qui correspond à la taille utilisée jusqu'ici et permet d'afficher 12 lignes sur 29 colonnes
• Petite qui permet quant à elle d'afficher 16 lignes sur 42 colonnes

Notons de plus que ce réglage s'applique aussi bien à l'éditeur qu'à la console Python. De quoi te permettre une bien meilleur vue d'ensemble de tes scripts ainsi que de leur affichage - merci NumWorks !

4) Python

Go to top

En ce qui concerne maintenant le langage Python nous avons beaucoup d'améliorations et nouveautés, n'ayons pas peur des mots et disons même énormément.

Déjà, autre amélioration de saisie mais dans le contexte Python, le catalogue accessible via la boîte à outils inclut désormais les fonctions associées à la classe list :

• list.append(x)
• list.clear()
• list.count(x)
• list.index(x)
• list.insert(i,x)
• list.pop(i)
• list.remove(x)
• list.reverse()
• list.sort()

En Python les possibilités d'interactions avec des interfaces, notamment pour des menus ou jeux, étaient très limitées sur la NumWorks.

En effet, il n'y avait pas de fonction permettant de tester la pression d'une touche. Pas d'autre choix donc jusqu'à présent que de passer par la fonction input(), avec donc obligation pour l'utilisateur de valider avec

EXE

à chaque action, ce qui déjà rendait impossibles nombre de types de jeux.

NumWorks s'attaque enfin au problème dans cette dernière version, avec un nouveau module ion à cette fin dont voici l'exploration avec notre script explmod.py :

Code: Tout sélectionner

def getplatform():
  id=-1
  try:
    import sys
    try:
      if sys.platform=='nspire':id=0
      if sys.platform.startswith('TI-Python') or sys.platform=='Atmel SAMD21':id=4
    except:id=3
  except:
    try:
      import kandinsky
      id=1
    except:
      try:
        if chr(256)==chr(0):id=5+(not ("HP" in version()))
      except:
        id=2
  return id

platform=getplatform()
#lines shown on screen
plines=[29,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]

C'est l'occasion pour nous de te fournir une table des codes clavier retenus, où la logique visuelle de numérotation t'aidera peut-être à retenir :

← 0	↑ 1	→ 3	⌂ 6	OK 4	↩ 5
	↓ 2		⏻
shift 12	alpha 13	x,n,t 14	var 15	╒╕ 16	⌫ 17
e^x 18	ln 19	log 20	i 21	, 22	x^y 23
sin 24	cos 25	tan 26	π 27	√ 28	x² 29
7 30	8 31	9 32	( 33	) 34
4 36	5 37	6 38	× 39	÷ 40
1 42	2 43	3 44	+ 45	- 46
0 48	. 49	×10^x 50	Ans 51	EXE 52

On peut toutefois remarquer que la seule fonction fournie keydown() par le nouveau module ion ne permet que de savoir si une touche donnée est pressée ou pas.
Des scripts Python implémentant des jeux ou interfaces (pourquoi pas une boîte de saisie texte) vont donc devoir appeler cette fonction autant de fois qu'il y a de touches clavier traitées. On peut donc légitimement s'interroger sur ce que donne le temps d'exécution de la fonction potentiellement multiplié par les 46 touches clavier (ou plutôt 45, la touche d'allumage/exinction n'étant pas gérée par le module).

Et bien testons, voici getkeys.py, notre script où il te suffira d'un simple et unique appel getkeys() pour scanner l'ensemble de la matrice clavier et récupérer la liste des codes des touches actuellement pressées :

Code: Tout sélectionner

from ion import keydown

def keycodes():
  lc = list(range(0,6)) + list(range(12,35))
  for k in range(36,53):
    if (k+1)%6:
      lc.append(k)
  return lc

def getkeys():
  lk = []
  for k in keycodes():
    if keydown(k):
      lk.append(k)
  return lk

Nous allons de plus chronométrer l'appel getkeys() à l'aide de notre script timer.py :

Code: Tout sélectionner

from time import monotonic

def timer(f, *par):
  start=monotonic()
  f(*par)
  return monotonic()-start

L'appel maintenant devenu timer(getkeys) nous mesure donc autour 0,08 seconde pour le scan intégral du clavier, aussi bien sur N0100 que N0110.

8 centièmes de seconde ce n'est certes pas rien, mais c'est quand même très loin d'être la catastrophe que nous craignions. NumWorks semble avoir bien fait les choses.
Les jeux Python utilisant beaucoup de touches clavier seraient donc en théorie limités au mieux à 25 fps (images par seconde), ce qui est tout de même déjà humainement très acceptable. En pratique il suffira aux jeux en question de ne pas scanner l'intégralité du clavier mais seulement les touches utiles, et de toutes façons la lenteur des fonctions graphiques à ce jour ne pemet pas d'atteindre les 25 fps en Python même sans aucune lecture clavier.

En passant, si toi aussi tu souhaites optimiser tes tests de touches clavier dans le même style que notre fonction getkeys(), n'hésite pas à consulter le tutoriel associé à la nouvelle fonction keydown().

De toutes nouvelles interfaces et jeux deviennent envisageables possibles sur ta NumWorks, et cent20 s'est dépêché de te les illustrer ci-contre avec le premier jeu utilisant le module ion, un démineur !

Suite à cet ajout majeur, profitons-en pour voir où nous en sommes niveau Python sur calculatrices. Voici déjà l'éventail des modules disponibles :

	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 micropython os random sys time turtle uerrno	✓ . . ✓ . ✓ ✓ . ✓ . ✓ ✓ .	✓ . . . . ✓ . . ✓ . . . .	✓ ✓ ✓ . ✓ ✓ . . ✓ ✓ ✓ . .	✓ ✓ . ✓ ✓ ✓ ✓ . . ✓ . . ✓	✓ ✓ . ✓ ✓ ✓ ✓ . . ✓ . . .	✓ ✓ . ✓ ✓ ✓ ✓ . ✓ ✓ . . ✓	✓ ✓ ✓ . ✓ ✓ . . ✓ ✓ ✓ . .	✓ ✓ ✓ ✓ ✓ ✓ ✓ ✓ ✓ ✓ ✓ . .
spécifique	kandinsky ion			prime	nsp			board storage
Total	9	3	8	9	8	9	9	13

En terme de quantité de modules, la NumWorks arrive ainsi désormais au premier rang des solutions Python utilisables aux examens français, félicitations !

Aux examens :

1. 9 modules :
   NumWorks
   HP Prime (version alpha)
2. 8 modules :
   TI-83 Premium CE Edition Python
3. 3 modules :
   Casio Graph 35+E II
   Casio Graph 90+E

Hors examens :

1. 13 modules :
   TI-Python (firmware tiers)
2. 9 modules :
   NumWorks
   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)
   HP Prime (version alpha)
3. 8 modules :
   TI-83 Premium CE Edition Python
   TI-Python
   TI-Nspire (appli MicroPython)
4. 3 modules :
   Casio Graph 35+E II
   Casio Graph 90+E
   Casio fx-CG50

Et voici maintenant pour le contenu de ces mêmes modules :

	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 micropython os random sys time turtle uerrno	88-188 . . 12 . 41 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	6(kandinsky) 48(ion)			3-7(prime)	3-10(nsp)			22(board) 7-21(storage)
Total	251-351	117-208	158-284	219-642	176-340	203-318	158-284	238-384

En terme de richesse des modules, la NumWorks varie donc entre les 2^ème et 3^ème rangs !

Aux examens :

1. 219-642 éléments :
   HP Prime (version alpha)
2. 251-351 éléments :
   NumWorks
3. 158-284 éléments :
   TI-83 Premium CE Edition Python
4. 117-208 éléments :
   Casio Graph 35+E II
   Casio Graph 90+E

Hors examens :

1. 219-642 éléments :
   HP Prime (version alpha)
2. 238-384 éléments :
   TI-Python (firmware tiers)
3. 251-351 éléments :
   NumWorks
4. 176-340 éléments :
   TI-Nspire
   (appli MicroPython)
5. 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)
6. 158-284 éléments :
   TI-83 Premium CE Edition Python
   TI-Python
7. 117-208 éléments :
   Casio Graph 35+E II
   Casio Graph 90+E

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

Avec la dernière version, tu disposais d'une mémoire de stockage pouvant accueillir jusqu'à 16 Kio de scripts Python.
La nouvelle version te double dès maintenant l'espace de stockage, avec pas moins de 32 Kio !

Pour le reste, le stack / pile limite donc la quantité d'objets différents utilisables simultanément, alors que le heap / tas en limite le volume.

La NumWorks était très décevante dans les deux cas, se retrouvant sur ces points littéralement à la queue de l'ensemble des solutions Python sur calculatrices graphiques.

Notre script mem.py permet d'estimer la capacité du heap / tas :

Code: Tout sélectionner

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

Celle-ci faisait 16 Kio sur les firmwares officiel, et cela n'a malheureusement pas changé pour la version 13.1.0.

En conséquence, vu les tailles non négligeables prises en mémoire par les objets Python les plus simples, tu seras très rapidement limité(e) dès que tes scripts vont commencer à travailler sur des tuples, listes ou pire listes de listes.

D'où le classement :

Aux examens :

1. 1,032942 Mo :
   Casio Graph 90+E
2. 1,022145 Mo :
   HP Prime (version alpha)
3. 100,560 Ko :
   Casio Graph 35+E II
4. 32,339 Ko
   NumWorks (firmware Omega)
5. 20,200 Ko
   TI-83 Premium CE Edition Python
6. 16,259 Ko
   NumWorks

Hors examens :

1. 2,049276 Mo :
   TI-Nspire (application MicroPython)
2. 1,032942 Mo :
   Casio Graph 90+E
3. 1,022145 Mo :
   HP Prime (version alpha)
4. 257,636 Ko :
   Casio Graph 35/75+E (application CasioPython)
5. 100,560 Ko :
   Casio Graph 35+E II
6. 32,339 Ko
   NumWorks (firmware Omega)
7. 31,899 Ko :
   Casio Graph 35+E II (application CasioPython)
8. 22,605 Ko
   TI-83 Premium CE + TI-Python (firmware tiers)
9. 20,200 Ko
   TI-83 Premium CE Edition Python
10. 19,924 Ko
    TI-83 Premium CE + TI-Python
11. 16,238 Ko
    NumWorks

Par contre, NumWorks annonce avoir quadruplé la taille de la pile / stack pour la version 13.1, voyons cela. Comme déjà expliqué, cette augmentation devrait permettre d'avoir simultanément davantage d'objets en mémoire (mais pas davantage de données, les valeurs de ces objets allant comme déjà dit dans le tas / heap). C'est la même capacité que l'on peut partager entre davantage d'objets différents.

Comment mesurer cela ? Une situation qui permet de créer plein de références dans la pile / stack, c'est la récursivité, soit les fonctions qui se rappellent elles-mêmes. Prenons notre script recur.py :

Code: Tout sélectionner

def sumr(n):return n>0 and n+sumr(n-1)

def maxr(fct):
  n=0
  try:
    while True:
      fct(n)
      n=n+1
  except Exception as e:print(e)
  return n

L'appel maxr(sumr) permet en effet de constater un bon quadruplement du nombre maximal d'appels récursifs, passant de 30 à 143 avant le déclenchement de l'erreur maximum recursion depth exceeded, de quoi étudier et exploiter désormais bien plus sérieusement la récursivité !

Là encore une nette progression au classement en terme de capacité de pile / stack. Merci NumWorks, la calculatrice est donc dès maintenant le meilleur choix aux examens français sur le critère de la récursivité !

Aux examens :

1. 143 :
   NumWorks (nouvelle version)
2. 82 :
   Casio Graph 90+E
   Casio Graph 35+E II
3. 77 :
   HP Prime (version alpha)
4. 30 :
   NumWorks (ancienne version)
5. 23
   TI-83 Premium CE Edition Python

Hors examens :

1. 5362 :
   Casio Graph 35/75+E (application CasioPython)
2. 655 :
   Casio Graph 35+E II (application CasioPython)
3. 143 :
   NumWorks (nouvelle version)
4. 130 :
   TI-Nspire (application MicroPython)
5. 82 :
   Casio Graph 90+E
   Casio Graph 35+E II
6. 77 :
   HP Prime (version alpha)
7. 30 :
   NumWorks (ancienne version)
8. 23
   TI-83 Premium CE Edition Python
9. 20
   TI-83 Premium CE + TI-Python
10. 15
    TI-83 Premium CE + TI-Python (firmware tiers)

5) Calculs

Go to top

NumWorks n'a également pas chômé avec l'application Calculs et nous apporte ici encore pléthore de nouveautés.

Déjà petite mise en bouche, NumWorks améliore l'intelligence de sa saisie. Lorsque par exemple on note f(5), sans connaître le contexte il y a ambiguité. Selon le contexte, cela peut être :

• si f est une fonction, la fonction f appliquée à 5
• sinon, le produit de f par 5

Jusqu'à la dernière version, la NumWorks considérait systématiquement que c'était un appel de fonction, même si f n'en était pas une, et ne te donnait donc aucun résultat.

Désormais ta NumWorks tiens compte du contexte, et t'interprétera automatiquement cette saisie en tant que produit si f n'a pas été définie en tant que fonction.

La NumWorks te permet désormais de calculer avec des nombres écrits en base non décimale :

• base binaire en préfixant le nombre saisi par 0b
• base hexadécimale en préfixant le nombre saisi par 0x

Le résultat reste certes affiché en base décimale, et il n'y a pas d'option pour changer cela.
Toutefois, NumWorks a prévu autre chose pour tes conversions dans l'autre sens. Si tu remontes dans l'historique de calculs avec la touche

↑

, chaque résultat entier sélectionné se verra adjoindre un bouton qu'il te suffira de valider pour obtenir automatiquement des résultats additionnels :

• la conversion en base hexadécimale
• la conversion en base binaire
• la décomposition en facteurs premiers

Et nul besoin de les noter sur ton brouillon, les différents résultats peuvent de plus être sélectionnés puis directement copiés-collés à des fins de réutilisation immédiate !

Mais ce n'est pas tout, NumWorks te propose également des résultats additionnels de façon similaire en cas de résultat rationnel (écriture exacte en fraction), avec :

• la conversion en fraction mixte (entier suivi d'une fraction propre, soit avec son numérateur inférieur au dénominateur)
• le détail de la division euclidienne du numérateur par le dénominateur

Lorsque le résultat écrit sous forme exacte est un cosinus ou sinus de quelque chose, là NumWorks s'est déchaîné pour les résultats additionnels, avec :

• représentation automatique et légendée du point associé sur le cercle trigonométrique
• cosinus associé sous forme exacte et décimale
• sinus associé sous forme exacte et décimale

Et alors attends tu n'as pas vu les nombres complexes, ici c'est de la folie avec comme résultats additionnels proposés :

• la représentation automatique et légendée du point associé dans le plan complexe
• le module sous forme exacte et décimale
• l'argument sous forme exacte et décimale
• la partie réelle sous forme exacte et décimale
• la partie imaginaire sous forme exacte et décimale

Et non, ce n'est pas fini. Grâce au formidable travail de NumWorks, l'application Calculs gère désormais les unités, avec une toute nouvelle entrée pour t'en facilité la saisie dans la boîte à outils. De très nombreuses catégories d'unités sont présentes, de quoi couvrir l'ensemble de tes problèmes de Géométrie, Physique ou Chimie :

• Temps
• Distance
• Masse
• Intensité du courant électrique
• Température
• Quantité de matière
• Intensité lumineuse
• Fréquence
• Force
• Pression
• Energie
• Puissance
• Charge électrique
• Tension électrique
• Capacité électrique
• Résistance électrique
• Conductance électrique
• Induction électrique
• Inductance
• Superficie
• Volume

Les unités sont notées avec le caractère tiret bas comme préfixe, que tu pourras une fois habitué saisir directement au clavier avec

shift

,

. Le menu se donne même la peine de les légender dans ta langue une fois de plus !
Bien que toutes les combinaisons ne soient pas au menu, précisons que la calculatrice reconnaît bien l'ensemble des préfixes du système international de 10¹² (Tera) à 10^-12 (pico) !

Rien à voir avec les unités proposée sur la concurrence de milieu de gamme où si c'est pas au menu c'est foutu. Ici les unités sont de véritables éléments gérés au niveau du moteur de calcul et que tu peux donc librement intégrer à ces derniers.

Tu peux notamment sommer différentes unités compatibles, avec un résultat automatiquement converti dans l'unité jugée la plus pertinente !

Tu as peut-être remarqué qu'il n'y avait pas de catégorie vitesse au menu, ces unités étant obtenues par un simple quotient. Les possibilités de combinaison sont infinies et permettront de gérer les unités les plus complexes !

Si jamais l'unité déterminée automatiquement pour le résultat ne te convient pas, tu pourras parfaitement la convertir dans toute unité compatible à l'aide de l'opérateur d'affectation obtenu via

shift

x^y

!

Les unités sont tellement bien intégrées et gérées, qu'elles peuvent même accompagner les valeurs que tu stockes dans des variables. En Physique-Chimie notamment, si tu te donnes la peine de saisir chaque constante ou donnée d'une formule avec son unité, tu pourras obtenir automatiquement le résultat accompagné de son unité la plus pertinente pour rafler un maximum de points à tes exercices !

C'est fantastique, les équivalences d'unités sont même connues de la machine, comme ici le kilogramme mètre par seconde carrée automatiquement remplacé par le Newton !

Inversement, si l'énoncé de Physique-Chimie tente de te piéger en ne précisant de façon générique que SI (Système International) comme unité pour les constantes qu'il te rappelle, les formidables possibilités de combinaisons infinies de la NumWorks te permettront de retrouver la bonne unité !

6) Probabilités

Go to top

L'application Probabilités n'est pas en reste, NumWorks se donne la peine d'y rajouter une nouvelle loi, la loi de Fisher.

7) Équations

Go to top

La NumWorks te permettait déjà de résoudre des équations paramétrées, c'est-à-dire faisant intervenir des variables qui ne sont pas des inconnues mais ont bien été définies avec une valeur.

Il était donc dommage à l'écran des solutions de ne pas savoir à quelle(s) valeur(s) de paramètre(s) celles-ci correspondaient.

Dans la droite lignée de sa volonté de proposer des écrans aussi complets et compréhensibles que possible, NumWorks te rajoute à cet écran la liste des éventuels paramètres utilisés ainsi que leurs valeurs associées.

8) Fonctions

Go to top

NumWorks te permet désormais de parcourir plus rapidement tes courbes de fonctions, le déplacement du curseur s'accélérant par augmentation du pas si tu maintenant la touche fléchée enfoncée.

9) Régressions

Go to top

NumWorks s'est également occupé de l'application Régressions.

Le modèle de calcul utilisé pour les régressions Puissance et Trigonométrique n'était en effet pas celui majoritairement choisi par les logiciels de Mathématiques. Si bien que la concurrence était unanime à contredire à l'unisson les résultats de la NumWorks dans ces cas-là :

Désormais, le nouveau modèle utilisé est bien cohérent avec la concurrence.

10) Conclusion

Go to top

Les bonnes choses prennent du temps et franchement cela valait le coup d'attendre; nous ne sommes absolument pas déçus aujourd'hui avec cette dernière version absolument exceptionnelle pour ta NumWorks, riche de fonctionnalités innovantes ou jamais vu sur un modèle à ce prix-là !

Entiers, rationnels, fonctions trigonométriques et nombres complexes... à chaque fois, ce sont littéralement de mini-études que te réalise désormais NumWorks dans l'application Calculs !
Des représentations différentes qui t'amèneront à mieux comprendre chacun de ces résultats, ainsi qu'à développer ta compétence Représenter et passer à l'avenir plus naturellement d'une forme à l'autre. Une fonctionnalité donc d'une haute pertinence !
On peut de plus rajouter qu'il s'agit de fonctionnalités exclusives à ce jour, ou plus précisément dans le contexte particulier de cette année 2020 avec le mode examen.
Il n'y a en effet rien d'équivalent sur les modèles concurrents, il faut y comprendre/retenir plusieurs commandes spécifiques et encore pour obtenir à chaque fois un seul des éléments de la série de résultats additionnels présentés.
De telles choses n'y étaient possibles qu'en y chargeant des programmes que nous te proposions gratuitement les années précédentes, programmes hélas bloqués par le mode examen cette année.
NumWorks se met donc ainsi à te recréer gratuitement dans son propre mode examen des fonctionnalités équivalentes aux programmes les plus pertinents produits par la communauté pour la concurrence ces dernières années. N'oubliant pas les besoins des élèves, NumWorks semble ainsi être le constructeur ayant le mieux compris l'ensemble des conséquences de la réforme du mode examen !

On apprécie également la gestion des unités directement intégrée au niveau du moteur de calcul et donc sans contrainte, avec des possibilités infinies qui ne feront que faciliter la bonne compréhension des unités !

Et une fois encore, bravo pour le nouveau module importable ion pour Python, avec des possibilités débordant du cadre des Mathématiques qui seront appréciées en Physique-Chimie, SNT et NSI !

Toutes nos félicitations à NumWorks, cette version 13.1 c'est du grand art !
Et au plaisir de la prochaine version !

Toutes ces superbes nouveautés ont toutefois un coût, la taille du firmware bondissant dans les 933 Kio avec la version 13.1.0.

Certes, aucune inquiétude à avoir pour le modèle de rentrée 2019 NumWorks N0110 avec ses 8 Mio de Flash.

Mais il n'en va pas de même pour le modèle initial NumWorks N0100 de rentrée 2017 avec seulement 1 Mio de Flash. A moins de possibilités d'optimisation encore inexploitées la NumWorks N0100 semble arriver en bout de course; elle ne pourra bientôt plus bénéficier de l'ensemble des ajouts des mises à jour à venir.

Liens :

• Mise à jour (suivre les instructions)
• Simulateur en ligne
• Code source

[critor]

Dans le contexte sanitaire actuel, Texas Instruments met à disposition gratuitement sa toute nouvelle application d'émulation TI-SmartView CE pour les Chromebook, ordinateurs équipés du système d'exploitation Chrome OS. Plus précisément il s'agit d'un émulateur du modèle international TI-84 Plus CE, et pas du modèle français équivalent TI-83 Premium CE.

Nous découvrions justement à cette occasion que l'émulateur était équipé d'un système (OS) en version 5.4.1.0052, soit plus récent donc que la dernière version diffusée à ce jour sur le site de Texas Instruments, la 5.4.0.0034 compilée le 31 Mai 2019.

Peut-être cette nouvelle version 5.4.1 n'est elle incluse que dans les calculatrices sortant actuellement d'usine, ou peut-être s'agit-il simplement d'une version mineure intermédiaire.

Quoi qu'il en soit, les émulateurs TI-SmartView CE ayant l'avantage d'être suffisamment fidèles au matériel, nous avons pu dumper le contenu de la mémoire Flash virtuelle contenant la version 5.4.1, et en générer un fichier de mise à jour pour la calculatrice.

Et bingo, la version 5.4.1 marche parfaitement une fois installée sur une véritable TI-84 Plus CE comme tu peux le constater ci-contre !

Nous ignorons toutefois à ce jour les changements associés à cette version 5.4.1, n'hésite pas à la tester et à les partager si tu en découvres.

Il est à noter que la version 5.4.1 ne renforce pas la protection contre la réinstallation de versions inférieures. Comme ses prédécesseurs, la version minimale autorisée qui lui est associée reste 5.3.6.
Si tu as donc déjà mis à jour ta TI-84 Plus CE en version 5.3.6 ou supérieure, tu peux donc installer sans crainte la version 5.4.1 et par la suite si tu le souhaites revenir librement aux versions 5.4.0 ou 5.3.6.

Téléchargement : archives_voir.php?id=2618650

[critor]

Dans sa prochaine mise à jour 5.5 gratuite prévue pour Mai 2020, Texas Instruments va rajouter de formidables possibilités à l'application Python de ta TI-83 Premium CE Édition Python.

Nous sommes honorés aujourd'hui de pouvoir t'en tester une préversion, la 5.5.0031 compilée le 12 Mars 2020.

Cette mise à jour système s'accompagne d'une mise à jour de l'application Python, également en version 5.5.0031.

Toutefois pas de mise à jour de l'application PyAdaptr, sans doute suite à la décision d'interdire le module externe TI-Python aux examens français. Aussi, les anciens modèles TI-83 Premium CE ne sont-ils hélas pas concernés par les nouveautés Python que nous allons aborder.

Rien que sur le Python il s'agit d'une mise à jour fonctionnelle majeure, et nous ne pourrons pas tout traiter aujourd'hui. Nous n'en allons pas moins te faire déjà découvrir une partie des formidables nouveautés.

1. Menus et complexes
2. Modules importables et module time
3. Menu ti_system et assistant de saisie
4. Exploration ti_system et touches clavier
5. ti_system et fonctions d'affichage()
6. ti_system et importation/exportation de données

1) Menus et complexes

Go to top

Une première piste pour découvrir les nouveautés, c'est d'accéder aux menus avec

F1

depuis la console ou l'éditeur de script. Ces menus ne présentent pas la totalité des fonctionnalités, mais une sélection que Texas Instruments a choisi de mettre en avant pour une saisie rapide.

Fonctionnellement ce ne sont pas des nouveautés, mais on peut déjà noter quelques ajouts dans les onglets List et E/S, avec donc l'avantage désormais d'une saisie facilitée :

• la fonction de classe list.count()
• la fonction de classe str.format()

Dans l'onglet Type par contre, on note :

• certes la mise au menu de la fonction type()
• mais surtout une nouvelle fonction complex(real,imag)

Cette fonction complexe(real,imag) à la différence n'était pas simplement non listée sur l'ancienne version mais inexistante. En effet, les nombres complexes n'étaient même pas gérés, contrairement à l'ensemble de la concurrence. Cela voudrait-il dire que c'est le cas désormais ?

Et bien oui les nombres complexes sont maintenant gérés !

Ta TI-83 Premium CE Édition Python devient donc optimale aussi bien pour le programme de Mathématiques Terminales S, STI2D et STL spécialé SPCL pour le BAC 2020, ainsi que le programme de Mathématiques Expertes de Terminale G et Maths-Physique-Chimie de Terminale STI2D pour le BAC 2021 !

2) Modules importables et module time

Go to top

Passons maintenant à l'onglet Modul pour consulter la sélection de modules importables. Outre math et random qui était déjà listés, nous avons maintenant :

• time
• ti_system
• ti_plotlib
• ti_hub
• ti_rover

En réalité, le menu ne liste qu'une sélection et non tous les modules disponibles. Pour cela, on peut appeler help('modules').

Les véritables nouveautés sont donc les seuls modules suivants :

• 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_system, pour enfin pouvoir interagir avec les variables hors application Python; enfin l'application Python pourra véritable servir à résoudre des problèmes et non plus à coder un truc dans un coin !
• 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

Le module time était quant à lui déjà présent, même si on apprécie désormais sa présence au menu et donc la possibilité de lister et accéder rapidement son contenu.
Cela signifie aussi qu'il est désormais officiel et ne risque plus de disparaître lors d'une prochaine mise à jour - tu peux donc l'utiliser sans crainte !

Nous nous proposons donc aujourd'hui de découvrir avec toi les possibilités d'un premier des nouveaux modules, ti_system.

3) Menu ti_system et assistant de saisie

Go to top

On remarque ici plusieurs choses essentielles.

On note une fonction sleep() qui fait apparemment doublon avec celle du module time, même comportement.
Au moins cela évitera d'avoir à importer les deux modules dans certains cas.

Nous avons donc une fonction escape() qui en pratique indique si les touches

annul

ou

on

sont pressées.
C'est bienvenu, cela permettra d'afficher des informations et d'attendre une confirmation de lecture par l'utlisateur avant de passer à la suite.
Si l'on pense conception de menus, interfaces et jeux c'est toutefois insuffisant, et en attendant mieux il y aura la possibilité d'utiliser la bibliothèque tierce TIKEYLIB de CaptainLuigi, qui tente de son mieux de fournir des fonctions utilisables en exploitant le flux d'entrée sys.stdin.

Des fonctions recall…() permettent d'importer des informations depuis les variables des autres applications de la calculatrice, et store…() inversement d'en exporter.

Des fonctions disp…() permettent quant à elles d'afficher des caractères à l'écran.

Notons à ce sujet le fonction disp_at(ligne,'txt','align'), qui est suffixée au menu d'un petit triangle vert orienté vers la droite.
Non il ne t'invite pas à taper

→

comme on pourrait le croire, mais t'indique que la validation de ce choix va ouvrir un assistant illustré ci-contre.
En effet, cette fonction attend ici comme dernier paramètre une chaîne avec comme seules valeurs autorisées 'left', 'center' ou 'right', pénibles à saisir.
L'assistant est donc là pour te lister les valeurs autorisées pour ce genre de paramètres, et t'en faciliter la saisie.

Nous explorerons plus en détails ces deux dernières catégories de fonctions ci-après.

4) Exploration ti_system et touches clavier

Go to top

Et si le module ti_system contenait des choses non listées au menu ?

Réalisons-en une exploration complète à l'aide du script suivant :

Code: Tout sélectionner

#platforms:
#0: MicroPython / TI-Nspire
#1: MicroPython / NumWorks
#2: MicroPython / G90+E / G35+E II
#3: MicroPython / G35+E/USB / G75/85/95
#4: CircuitPython / TI-Python / 83PCE / Trinket M0
#5: Xcas / HP Prime
#6: KhiCAS / Graph 90+E
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

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]

Un import ti_system suivi d'un appel explmod(ti_system) nous révèle effectivement plusieurs fonctions cachées :

• wait()
• et wait_key()

La fonction wait() semble se comporter exactement comme sleep().

Et bien finalement non, pas besoin d'aller chercher une bibliothèque tierce de détection des touches pressées pour tes menus, interfaces et jeux, la fonction wait_key() semble être exactement ce qu'il nous fait.
Comme le getKey du TI-Basic, elle renvoie toujours un même code numérique pour chaque touche pressée.

Quelques différences toutefois :

• ce ne sont, bizarrement, pas les mêmes codes qu'en TI-Basic
• ici la fonction attend la pression d'une touche avant de renvoyer une valeur
• les touches modificatrices

  2nde

  et

  alpha

  ne sont pas gérées

Ah ben en fait voilà qui explique l'utilisation de codes touches différents; lorsque précédant l'appui sur une touche,

2nde

et

alpha

modifient le code retourné.

Toutefois, tant que ce n'est pas au menu, ce n'est pas officiel et ça peut être retiré à tout moment.

Voici ici documenté les codes de chacune des touches, suivis à chaque fois des codes obtenus en combinaison avec les modificateurs

2nde

puis

alpha

si différents :

f(x) 73 48	fenêtre 72 75	zoom 46 87	trace 90 59	graphe 68 74
2nde	mode 69 64	suppr 10 11	← 2 14	↑ 3
alpha	X,T,θ,n 180 65	stats 49 58	↓ 4	→ 1 15
math 50 51 154	matrice 55 182 155	prgm 45 47 156	var 53 56	annul 9
◄► 64018 57 157	trig 64017 181 158	résol 64020 44 159	□/□ 64458 64016 160	^ 132 161
x² 189 190 162	, 139 152 163	( 133 236 164	) 134 237 165	/ 131 239 166
log 193 194 167	7 149 249 168	8 150 250 169	9 151 251 170	× 130 135 171
ln 191 192 172	4 146 246 173	5 147 247 174	6 148 248 175	- 129 136 176
sto→ 138 12 177	1 143 243 178	2 144 244 179	3 145 245 204	+ 128 54 203
on 0	0 142 153 62	. 141 238 198	(-) 140 197 202	entrée 5 13

Ah ben en fait, nous avons beau y regarder ces codes nous sont totalement obscurs. Nous n'y voyons aucune logique globale.

C'est donc en effet un travail inachevé; si ces codes sont conservés en l'état il faudra concevoir un menu dédié pour faciliter leur utilisation.

5) ti_system et fonctions disp…

Go to top

Contrairement à la fonction Python print() qui ne permet d'afficher qu'à la fin de la console et te pousse donc à la gymnastique pour des affichages multilignes, les fonctions d'affichage fournis par le module ti_system tiennent compte de la géométrie écran de la calculatrice pour t'offrir le choix d'afficher une chaîne où tu veux et quand tu veux, dans le même esprit que le langage de programmation historique TI-Basic.

disp_cursor(0) et disp_cursor(1) permettant respectivement de désactiver et réactiver l'affichage du curseur de texte pendant l'exécution de tes scripts Python.

disp_clr() quant à elle efface l'écran de la console et ramène le curseur tout en haut à gauche pour le prochain affichage.

disp_wait() attend l'appui sur une touche d'annulation puis efface l'écran, semblant être équivalent au code suivant :

Code: Tout sélectionner

while not escape():
  pass
disp_clr()

Enfin nous arrivons à la fonction principale, disp_at(ligne,'txt','align'), et allons tenter d'en comprendre le fonctionnement. On peut l'illustrer ci-contre à l'aide du code suivant :

Code: Tout sélectionner

from ti_system import *

for k in range(1, 12):
  disp_at(k,('Ligne {:02d} ' + '*'*23).format(k),'left')
disp_at(6,'left','left')
disp_at(8,'center','center')
disp_at(10,'right','right')
disp_at(3,'123456789ABCDEFGHIJKLMNOPQRSTUVWXYZ','left')

Tu peux donc afficher tes caractères à largeur fixe où tu veux sur 11 lignes numérotées de 1 à 11, et 32 colonnes.
Pour tout affichage la fonction disp_at() n'efface pas le début de ligne, écrase les caractères déjà affichés au même endroit si il y en a, et va automatiquement à la ligne au-delà de la 32^ème colonne.
En ce sens, elle est comparable à la fonction Output() du langage TI-Basic historique, et te permettra donc de réaliser des interfaces et menus textuels mais cette fois-ci en Python.

Toutefois, précisons que la fonction disp_at() diffère également de Output() de plusieurs façons.

• pour tout affichage effectué, si elle n'efface pas le début de ligne elle efface quand même systématiquement la fin de la ligne
• si elle te permet de choisir la ligne de ton affichage elle ne te permet que très peu d'en contrôler la colonne, ne te donnant que le choix d'afficher ton texte aligné à gauche, droite ou centré

Porter tes programmes TI-Basic fonctionnant en mode texte nécessitera donc d'en adapter la logique d'affichage.

Voyons voir si nous pouvons remédier à ces derniers points, et te proposer quelque chose d'un peu plus proche de la fonction Output() du TI-Basic.

Voici par exemple une fonction outputl() qui te permet de choisir en prime le numéro de colonne de 1 à 32, et utilise l'alignement à gauche :

Code: Tout sélectionner

from ti_system import *

def outputl(l, c, s):
  s = ' ' * (c-1) + s
  disp_at(l, s, 'left')

for k in range(1, 12):
  disp_at(k, '*' * 32, 'left')

outputl(3, 6, 'test1')

while not espace():
  pass

La fonction outputl() préfixe ici ta chaîne d'autant d'espaces que nécessaires pour l'afficher à la colonne de ton choix.
Toutefois elle a le défaut d'afficher non seulement la fin de ligne mais également le début de ligne, te contraignant donc à construire ton affichage en réalisant un unique affichage par ligne.

Changeons de méthode, voici une fonction outputr() qui utilise pour sa part l'alignement à droite :

Code: Tout sélectionner

from ti_system import *

def outputr(l, c, s):
  s += ' ' * (32-len(s)-c+1)
  disp_at(l, s, 'right')

for k in range(1, 12):
  disp_at(k, '*' * 32, 'left')

outputr(3, 6, 'test2')

while not espace():
  pass

Ici la fonction affiche la chaîne en alignement à droite en la suffixant d'autant d'espaces que nécessaire pour atteindre la position demandée, avec l'avantage de ne pas effacer le début de ligne.
Même si elle efface quand même la fin de ligne, tu pourras à la différence avec cette fonction réaliser plusieurs affichages par ligne pour tes scripts, à la condition de les effectuer dans l'ordre du plus à gauche au plus à droite.

Et si on tentait avec un alignement au centre ? Ici l'avantage serait d'avoir à rajouter beaucoup moins d'espaces.
A priori cela n'empêchera certes pas l'effacement de la fin de ligne, mais et si on tenter de suffixer le tout d'un caractère retour à la ligne ?

Code: Tout sélectionner

from ti_system import *

def outputc(l, c, s):
  s += ' ' * (32-2*c-len(s))
  s += '\n'
  disp_at(l, s, 'center')

for k in range(1, 12):
  disp_at(k, '*' * 32, 'left')

outputr(3, 6, 'test3')

while not espace():
  pass

Ici donc pas d'effacement du début de ligne, et la fin de ligne n'est que partiellement effacée.
Toutefois la fonction a l'inconvénient d'effacer la ligne suivante, et c'est donc ici dans l'ordre de haut en bas que tu devras effectuer tes affichages.

Pour afficher tes interfaces multilignes, le meilleur choix semble donc être entre ces deux dernières fonctions, outputr() et outputc(), avec chacune des avantages et des inconvénients. Tu es libre de les reprendre pour tes futurs scripts TI-83 Premium CE Édition Python.

6) ti_system et importation/exportation de données

Go to top

Grâce au module ti_system, on peut désormais importer dans l'application Python des données provenant des autres applications de la calculatrice.

recall_RegEQ() par exemple récupère sous forme de chaine le membre de droite l'expression réduite

$mathjax$y=f(x)$mathjax$

trouvée lors de la dernière régression statistique effectuée sur la calculatrice.

recall_list("nom") quant à elle permet de récuperer en Python l'une des listes créées dans le contexte des autres applications de la calculatrice.

Exemple de suite sur ce dernier point, utilisation l'application ProbSim pour lancer simulatanément 3 dés, et ce 100 fois de suite.

L'application permet alors d'exporter les données générées dans des listes aux noms prédéfinis.

Comme le menu de l'application Python nous y invitait, on peut alors mettre le contenu d'une de ces listes, par example ⌊SOMME, dans l'une des listes prédéfinies L₁ à L₆, par exemple L₁.

On peut alors récupérer les données brutes de la somme des dés en Python en utilisant recall_list('1') et commencer à les exploiter, par exemple en les convertissant en données de modalités et effectifs ou encore en en demandant les paramètres statistiques à l'aide des fonctions suivantes.

Note bien que hors du contexte Python, ta calculatrice ne travaille que sur des nombres flottants. Comme tu peux l'observer ci-contre tu récupères donc ici forcément une liste de flottants, il faudra éventuellement en tenir compte selon ce que tu comptes faire avec.

Code: Tout sélectionner

from math import *

def brut2valeff(l):
  """ Prend en paramètre une liste de valeurs.
      Renvoie une liste de 2 liste :
      - les valeurs uniques
      - les effectifs associés
  """
  d=dict()
  for v in l:
    if not(v in d.keys()):
      d[v]=0
    d[v]+=1
  return [list(d.keys()),list(d.values())]

def stats1var(lv, lf=[]):
  """ Prend en paramètre :
      - une liste de valeurs
      - liste optionnelle des effectifs / fréquences associées
      Renvoie la liste des paramètres statisques correspondants :
      effectif total, moyenne, variance, écart-type, mode,
      minimum, maximum, quartile 1, médiane, quartile3
  """
  if(len(lf) == 0):
    lf = [1 for k in range(len(lv))]

  params = []
  lz = sorted(zip(lv, lf))

  params.append(sum(lf))
  print('Effect tot:', params[0])

  s, s2 = 0, 0
  for k in lz:
    s += k[0]*k[1]
    s2 += k[0]**2*k[1]
  params.append(s/params[0])
  params.append(s2/params[0]-params[1]**2)
  print('Moyenne   :', params[1])
  print('Variance  :', params[2])

  params.append(sqrt(params[2]))
  print('Ecart-type:', params[3])

  zmode, zmin, zmax = lz[0], lz[0], lz[0]
  for k in lz:
    if k[1]>zmode[1]:
      zmode = k
    if k[0]<zmin[0]:
      zmin = k
    if k[0]>zmax[0]:
      zmax = k
  params.extend([zmode[0], zmin[0], zmax[0]])
  print('Mode      :', params[4])
  print('Minimum   :', params[5])

  s, k = 0, -1
  while(s<params[0]/4):
    k += 1
    s += lz[k][1]
  params.append(lz[k][0])
  print('Quartile1:', params[7])

  while(s<params[0]/2):
    k += 1
    s += lz[k][1]
  if(2*s == params[0]):
    params.append((lz[k][0]+lz[k+1][0])/2)
  else:
    params.append(lz[k][0])
  print('Médiane  :', params[8])

  while(s<params[0]*3/4):
    k += 1
    s += lz[k][1]
  params.append(lz[k][0])
  print('Quartile3:', params[9])

  print('Maximum  :', params[6])

  return params

Petite limitation à ce jour, la liste importée ne doit pas comporter plus de 100 éléments, sans quoi l'importation sera refusée. C'est dommage, les programmes scolaire invitant à faire travailler les statistiques avec des données réelles notamment dans le contexte de l'outil numérique, données qui excéderont bien souvent les 100 éléments.

Remarque, contrairement à ce que nous suggérait le menu Python nous n'avions ici aucun besoin de passer par la liste prédéfinie L₁.

Inversement maintenant, grâce à la fonction store_list("nom",var) on peut exporter les listes remplies dans le contexte Python vers des variables listes qui seront utilisables par les autres applications de la calculatrice.

Les nombres entiers sont alors convertis en nombres flottants comme l'on peut le constater en réimportant immédiatement les exportations.

A noter que la calculatrice hors du contexte Python gère deux types de listes :

• les listes de nombres réels
• les listes de nombres complexes

Si l'un des éléments de la liste exportée est de type complexe, ce sont tous les nombres de la liste qui seront convertis en type complexe comme l'on peut le constater à la réimportation.

Et puis c'est tout, la calculatrice ne gère hors Python que des listes de nombres. Tout élément non numérique interrompra l'exportation.

Mine de rien, il s'agit de fonctionnalités formidables, en parfaite adéquation avec les programmes scolaires. Ces derniers demandent en effet :

• pour les statistiques, de travailler sur des données réelles, qui une fois transférées à la calculatrice seront donc maintenant récupérables dans l'application Python
• d'enseigner le Python non pas dans le bête but de coder, compétence technique peu intéressante en soi, mais comme outil transversal de résolution de problèmes

Jusqu'à présent la TI-83 Premium CE Édition Python avait le défaut d'avoir son application Python qui tournait en vase clos, sans aucun échange possible avec le reste des applications du logiciel de Mathématiques intégré de la calculatrice. Elle ne permettait donc bêtement que de coder dans son coin et pas de résoudre des problèmes, c'est-à-dire de faire appel à plusieurs applications de la calculatrice pour traiter différemment les mêmes données. Et d'ailleurs, même reproche à ce jour pour l'ensemble de la concurrence.

Texas Instruments est donc le premier constructeur à s'attaquer à ce défaut et à nous proposer quelque chose d'innovant, le Python de ta TI-83 Premium CE Édition Python va enfin pouvoir te servir à faire des Maths/Sciences et non plus seulement du code, félicitations !

De plus, rappelons que TI-Connect CE te permet d'importer des fichiers de données .csv que tu peux notamment exporter à partir de feuilles de calculs, de quoi travailler encore plus facilement et rapidement sur des données réelles !

Tutos TI-83 Premium CE Édition Python 5.5 :

• Tuto-vidéo d'importation de données .csv en Python
• Tuto-vidéo d'importation de données ProbSim en Python
• Tuto-vidéo d'exportation de listes Python vers les variables calculatrice
• Tutos Python TI-Code (voir l'unité 5 pour le module ti_system)

[Admin]

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
2. Python et module matplotlib
3. Mon premier script matplotlib
4. matplotlib et possibilités
5. matplotlib et compatibilité
6. Conclusion

1) Python et mémoires

Go to top

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.

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: Tout sélectionner

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 :

1. 1,032942 Mo :
   Casio Graph 90+E
2. 1,022145 Mo :
   HP Prime (version alpha)
3. 100,560 Ko :
   Casio Graph 35+E II
4. 32,339 Ko
   NumWorks (firmware Omega)
5. 31,624 Ko
   NumWorks
6. 20,200 Ko
   TI-83 Premium CE Edition Python
7. 16,259 Ko
   NumWorks (ancienne version)

Hors examens :

1. 2,049276 Mo :
   TI-Nspire (application MicroPython)
2. 1,032942 Mo :
   Casio Graph 90+E
3. 1,022145 Mo :
   HP Prime (version alpha)
4. 257,636 Ko :
   Casio Graph 35/75+E (application CasioPython)
5. 100,560 Ko :
   Casio Graph 35+E II
6. 31,899 Ko :
   Casio Graph 35+E II (application CasioPython)
7. 32,339 Ko
   NumWorks (firmware Omega)
8. 31,624 Ko
   NumWorks
9. 22,605 Ko
   TI-83 Premium CE + TI-Python (firmware tiers)
10. 20,200 Ko
    TI-83 Premium CE Edition Python
11. 19,924 Ko
    TI-83 Premium CE + TI-Python
12. 16,238 Ko
    NumWorks (ancienne version)

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: Tout sélectionner

def getplatform():
  id=-1
  try:
    import sys
    try:
      if sys.platform=='nspire':id=0
      if sys.platform.startswith('TI-Python') or sys.platform=='Atmel SAMD21':id=4
    except:id=3
  except:
    try:
      import kandinsky
      id=1
    except:
      try:
        if chr(256)==chr(0):id=5+(not ("HP" in version()))
      except:
        id=2
  return id

platform=getplatform()
#lines shown on screen
plines=[29,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 !

Aux examens :

1. 13 modules :
   TI-83 Premium CE Edition Python
2. 11 modules :
   NumWorks
3. 9 modules :
   HP Prime (version alpha)
4. 3 modules :
   Casio Graph 35+E II
   Casio Graph 90+E

Hors examens :

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
   Casio fx-9860GII
   Casio fx-9860G
   (appli CasioPython)
4. 8 modules :
   TI-Nspire
   (appli MicroPython)
   TI-Python
5. 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 :

1. 219-642 éléments :
   HP Prime (version alpha)
2. 265-365 éléments :
   NumWorks
3. 170-296 éléments :
   TI-83 Premium CE Edition Python
4. 117-208 éléments :
   Casio Graph 35+E II
   Casio Graph 90+E

Hors examens :

1. 219-642 éléments :
   HP Prime (version alpha)
2. 238-384 éléments :
   TI-Python (firmware tiers)
3. 265-365 éléments :
   NumWorks
4. 176-340 éléments :
   TI-Nspire
   (appli MicroPython)
5. 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)
6. 170-296 éléments :
   TI-83 Premium CE Edition Python
7. 158-284 éléments :
   TI-Python
8. 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: Tout sélectionner

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: Tout sélectionner

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 top

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: Tout sélectionner

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: Tout sélectionner 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: Tout sélectionner 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: Tout sélectionner 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: Tout sélectionner 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.

Conclusion

Go to top

Grosse 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 !

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