[Admin]

Selon les lycées, il arrive plus ou moins souvent que les élèves n'aient pas leur calculatrice graphique :

• les premiers jours voir premières semaines après la rentrée en Seconde, parce qu'ils ne l'ont pas encore achetée/reçue
• parce qu'ils l'ont oubliée, perdue, ou encore qu'on leur a volée
• parce qu'ils ne l'ont pas rechargée ou n'ont pas changé les piles
• parce qu'ils l'ont cassée matériellement (même si c'est rare tellement les modèles ont majoritairement été conçus pour le contexte hostile du milieu scolaire)
• parce qu'ils l'ont bloquée/coincée logiciellement
• ou encore parce qu'ils n'ont aucune envie de faire cette dépense, même si sous la réglementation actuelle il faudra bien qu'ils s'y décident avant leur examen

Dans ces situations, comment peut faire l'enseignant sans s'embêter à aller en salle informatique/multimédia quand il y a besoin de la calculatrice graphique, que ce soit pour une activité de recherche, des travaux pratiques, des projets, de la programmation Python, des exercices ou encore des devoirs surveillés ?

Et bien NumWorks nous apporte une fois de plus la solution à ce problème d'enseignement !

En effet, à la différence les élèves disposent à une quasi unanimité d'une tablette ou d'un smartphone, d'ailleurs souvent payé d'une façon ou d'une autre bien plus cher qu'une calculatrice graphique.

La calculatrice graphique NumWorks est dès ce soir disponible sous la forme d'applications pour Android et iPhone/iPad!

Contrairement à Texas Instruments avec son application TI-Nspire, l'application NumWorks est entièrement gratuite !
Et contrairement à Casio et Hewlett Packard avec leurs applications Classpad fx-CP400 et HP Prime, cette gratuité n'implique aucun bridage !

NumWorks t'offre donc gracieusement l'accès à l'ensemble de son écosystème, dont entre autres tout ce qui en fait ses remarquables qualités selon nous :

• son moteur de calcul littéral
• sa sous-application de probabilités
• sa sous-application Python

A noter que l'application fait actuellement tourner une version 10.0.0 du système NumWorks.
Nous ignorons si cela implique des différences de fonctionnalités avec la version 10.1.0 qui vient juste de sortir.

Aussi, c'est assez déroutant d'avoir le menu d'accueil des applications NumWorks sur un écran tactile - nous avons le réflexe de vouloir tapoter directement dessus mais la calculatrice n'étant pas tactile ça ne marche pas, il faut tapoter sur les touches du clavier.
Peut-être que le tactile serait pour le coup une fonctionnalité à implémenter sur certains menus de la version application de la calculatrice NumWorks ?

On peut toutefois regretter que, contrairement à la véritable calculatrice, cette première version de l'application ne dispose pas d'un système de sauvegarde. Si l'application est fermée (par l'utilisateur, par un économiseur de batterie, par un plantage, ou encore parce que le smartphone a redémarré, a été arrêté ou s'est déchargé...), tout ce qui a été saisi ne sera pas retrouvé à son prochain lancement.
Particulièrement dérangeant dans le cadre de la saisie de scripts Python...

Installation : Application NumWorks pour Android / iPhone/iPad

Référence : https://twitter.com/numworks/status/1109032300849885184

[Admin]

La nouvelle version 10.1.0 pour ta calculatrice NumWorks est dès maintenant disponible. Découvrons ensemble les nouveautés :

Application Calculs

Go to top

Le moteur de calcul a été amélioré dans le contexte des nombres complexes, de quoi ravir les élèves de Terminale S/STI2D/STL.

Le moteur est désormais capable de renvoyer des résultats exacts lorsque l'on passe un argument complexe aux fonctions de module et d'argument !

Mais ce n’est pas tout, le moteur simplifie maintenant également correctement les quotients de nombres complexes !

Notons que les résultats littéraux faisant apparaître plusieurs termes avec un même symbole sont dorénavant triés par puissances décroissantes de ce symbole. De quoi avoir une présentation bien plus claire des polynômes de Première !

Toujours pour plus de clarté à la lecture, l’ajout d’une division en écriture naturelle met maintenant au numérateur du quotient l’ensemble des facteurs précédents éventuels, et non plus le seul dernier d’entre eux. De même en cas d'insertion en milieu d'expression, les facteurs suivants sont eux aussi tous pris en compte au lieu du seul premier d'entre eux, et automatiquement et mis au dénominateur.

Applications Paramètres et Equations

Go to top

Pour rester sur le thème des nombres complexes, l’option Forme complexe dans l’application Paramètres accueille un nouveau choix, Reel, qui devient de plus le choix par défaut.

Lorsque l’utilisateur effectue des manipulations dans un contexte réel (racine carrée de nombre négatif, polynôme du second degré à coefficients réels de discriminant négatif…), si la forme complexe est réglée sur Reel, alors la calculatrice répondra dans le contexte des nombres réels au lieu d’aller chercher des nombres complexes.
Une adaptation fort louable au plus près des besoins de chacun des utilisateurs, permettant ainsi de leur fournir une réponse réutilisable en toute confiance, peu importe qu’ils soient en Terminale S/STI2D/STL ou ailleurs !

Application Probabilités

Go to top

Notons que l’application Probabilités permet désormais de travailler avec des rapports

$mathjax$\frac{\mu}{\sigma}$mathjax$

supérieurs, la valeur limite passant de 1000 à 1000000.

Applications Fonctions et Suites

Go to top

Les applications Fonctions et Suites partagent pour leur part nombre d’améliorations.

Dès le départ, le projet NumWorks avait pour louable ambition d’utiliser le bel espace offert par l’écran 320x240 pixels pour communiquer rigoureusement dans le langage mathématiques, contribuant ainsi à l’apprentissage puis l’usage correct de ce langage par l’utilisateur. Le constructeur poursuit dans cette voie, avec les onglets de définition de suites et de fonctions qui relient désormais correctement avec le symbole égal chaque objet à sa définition.

Les onglets de représentations graphiques bénéficient quant à eux de plusieurs nouveautés :

• la grille utilise désormais différentes teintes pour bien distinguer les graduations principales et secondaires
• dans le cas où un axe se situe hors de la fenêtre graphique, les valeurs de ses graduations sont quand même affichées sur le bord de fenêtre adéquat
• dans le cas où il y a superposition des valeurs de graduations, seules les valeurs extrêmes sont affichées

Notons que le réglage de fenêtre graphique automatique avait le défaut de mettre en évidence à l’extrême de petites approximations de calcul, notamment sur les fonctions constantes comme par exemple la fonction d’expression

$mathjax$f(x)={cos}^2(x)+{sin}^2(x)$mathjax$

. C’est maintenant corrigé.

Lorsque l’on désactive le fenêtrage automatique pour pouvoir préciser ses propres bornes pour l’axe (Oy), la calculatrice se permettait malgré tout de réajuster automatiquement ces bornes à chaque ajout de fonction. C’est corrigé également.

Enfin, les coordonnées communiquées pour les points sur les courbes de fonctions dans la fenêtre graphique tiennent maintenant compte correctement de leur ensemble de définition, comme par exemple avec la fonction d’expression

$mathjax$f(x)=\frac{x}{x}$mathjax$

en x=0.

Application Python

Go to top

Comme déjà annoncé grâce au travail de jean-baptiste boric, l’application Python bénéficie maintenant d’origine d’un tout nouveau module de dessin importable, turtle. Il complète donc les capacités de dessin du module kandinsky, en permettant cette fois-ci de concevoir ses scripts en relatif plutôt qu’en absolu.

Y sont disponibles des équivalents pour l'ensemble des fonctions Scratch du collège :

De quoi tracer facilement aussi bien des objets mathématiques comme des vecteurs que des objets artistiques comme des fleurs !

Code: Select all

from turtle import *
import kandinsky

def forbackward(d):
  forward(d)
  backward(d)
 
def pf(d=1,gd=-1,nervure=False):
  n=9
  pos=position()
  for j in range(2):
    for k in range(n):
      forward(d)
      right(gd*90/n)
    right(gd*90)
  if nervure:
    right(gd*40)
    forbackward(5*d)
    right(-gd*40)

def fleur(npetales=8,nfeuilles=2,ltige=160,kfeuille=1,c=kandinsky.color(255,255,0)):
  d=ltige/(nfeuilles+1)
  color(0,191,0)
  for j in range(nfeuilles):
    forward(d)
    pf(kfeuille,2*(j%2)-1,True)
  forward(d)
  color((c>>11)<<3,((c>>5)%64)<<2,(c%32)<<3)
  for j in range(npetales):
    pf(kfeuille,-1)
    left(360/npetales)

#example
from math import *

def hsv2color(h,s=1,v=1):
  c=v*s
  x=c*(1-abs((h%120)/60-1))
  m=v-c
  k=int(h/60)
  r=255*(m+x*(k==1 or k==4)+c*(k==5 or k==0))
  g=255*(m+c*(k==1 or k==2)+x*(k==3 or k==0))
  b=255*(m+x*(k==2 or k==5)+c*(k==3 or k==4))
  return kandinsky.color(round(r),round(g),round(b))

def horiz(y,col):
  for x in range(320):
    kandinsky.set_pixel(x,y,col)

for j in range(112):
  horiz(111-j,hsv2color(210,0+1*j/111,1))
  horiz(111+j,hsv2color(30,.1+.9*j/111,.7))

sw=320
sh=222
ymax=sh/2
ymin=ymax-sh+1
xmin=-sw/2
xmax=xmin+sw-1
penup()
goto(0,ymin)
setheading(90)
pendown()
fleur(12,9,ymax-ymin+1-26,3,kandinsky.color(255,255,0))

Une nouveauté qui s’inscrit parfaitement dans l’ère du temps, et pourra donc être utilisée dans maintes situations différentes :

• en Mathématiques collège : pour les quelques élèves et établissements qui font un équipement en calculatrices graphiques
• en Mathématiques Seconde : le temps d’une transition entre le langage de programmation visuel (Scratch) du collège et le langage de programmation textuel interprété du lycée
• en Physique-Chimie Seconde : pour le nouveau programme de rentrée 2019 qui demande de coder des représentations des vecteurs, ce qui sera beaucoup plus facilement abordable en réinvestissant les acquis du collège avec les déplacements relatifs de la tortue, plutôt qu’en s’attaquant au problème trigonométrique des coordonnées absolues
• en Mathématiques CAP : où, si le projet de nouveau programme 2019 se confirme, l’on poursuit la programmation visuelle du collège

Une fois de plus, le constructeur NumWorks nous prouve sa très grande réactivité en n'attendant pas le dernier moment pour nous apporter des solutions !

Creusons un petit peu la chose, et explorons ce que renferme ce module à l'aide du script suivant :

Code: Select all

#platforms:
#0: MicroPython / TI-Nspire
#1: MicroPython / NumWorks
#2: MicroPython / G90+E
#3: MicroPython / G35+E/USB / G75/85/95
#4: CircuitPython / TI-Python / 83PCE
#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=='TI-Python Adapter':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]
#max chars per line
#(error or new line 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("<module '") or s.startswith("<class '")

def explmod(pitm,pitmsl=[],reset=True):
  global curline
  if(reset):
    curline=0
    pitmsl=[sstr(pitm)]
  hd="."*(len(pitmsl)-1)
  spath=".".join(pitmsl)
  c=0
  for itms in sorted(dir(pitm)):
    c=c+1
    try:
      itm=eval(spath+"."+itms)
      mprint(hd+itms+"="+str(itm))
      if isExplorable(itm):
        pitmsl2=pitmsl.copy()
        pitmsl2.append(itms)
        c=c+explmod(itm,pitmsl2,False)
    except:
      mprint(hd+itms)
  if c>0:
    mprint(hd+"Total: "+str(c)+" item(s)")
  return c

38 éléments donc, de quoi mettre à jour notre bilan comparatif de la richesse des différentes pythonnettes disponibles à ce jour :

	TI-Nspire	NumWorks	Casio Graph 90+E	Casio Graph 35+E/USB Graph 75/85/95	module externe TI-Python pour TI-83 Premium CE
builtins	218	188	175	204	190
array	4			4	4
collections					2
cmath	12	12		12
gc	7			7	7
math	41	41	25	41	28
random		8	8	8	8
sys	15			12	15
time		3			4
turtle		38
spécifique	10 (nsp)	5 (kandinsky)
Modules	7	7	3	7	8
Éléments	307	295	208	288	258
Compatible mode examen		✔	✔		✔

D'où le classement suivant :

1. TI-Nspire avec 7 modules et 307 entrées, hors mode examen
2. NumWorks avec 7 modules et 295 entrées, même en mode examen
3. Casio Graph 35+E/75+E avec 7 modules et 288 entrées, hors mode examen
4. module externe TI-Python pour TI-83 Premium CE avec 8 modules et 258 entrées, même en mode examen
5. Casio Graph 90+E avec 3 modules et 208 entrées, même en mode examen

Précisions enfin que la nouvelle version 10.1.0 occupera désormais 727Kio sur les 1024Kio offerts par la puce Flash de la calculatrice.

Liens :

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

[Admin]

NumWorks travaille actuellement sur la prochaine mise à jour 10.0.0 de sa calculatrice. Celle-ci est déjà disponible en version bêta, à condition de la compiler à partir du code source officiel.

Mais cette fois-ci, une version compilée de la 10.0.0 bêta vient d'être diffusée par jean-baptiste boric dans le contexte de son Python amélioré pour les jeux. Profitons-en donc pour découvrir les nouveautés à venir.

D'une part, nous notons des améliorations apportées au moteur de calcul.

Il est désormais capable de renvoyer des résultats exacts lorsque l'on passe un argument complexe aux fonctions de module et d'argument !

D'autre part, pour la rentrée 2019, selon le nouveau programme de Physique-Chimie de la Seconde Générale et Technologique, il faudra programmer des tracés en langage Python :

• mouvement plan d'un objet ponctuel
• nuage de points
• vecteurs vitesse et variations

La NumWorks est certes le seul modèle à ce jour à disposer d'une implémentation Python constructeur (et donc disponible en mode examen) permettant de dessiner sur l'écran, à l'aide du module kandinsky.

Mais le dernier point évoqué, à savoir représenter des vecteurs, c'est-à-dire une direction, un sens et peut-être même la flèche qu'il y a au bout, n'en reste pas moins un problème trigonométrique bien conséquent, qui ne nous semble pas évident à faire résoudre à un niveau Seconde.
A moins bien sûr de distribuer des fonctions Python précodées par l'enseignant, ce qui n'aura alors pas grand intérêt...

Une fois de plus, le constructeur NumWorks nous prouve sa grande réactivité en n'attendant pas le dernier moment pour apporter une solution, l'inclusion dans son application Python du module turtle développé par jean-baptiste boric en novembre 2018.

Tracer maintenant un vecteur en coordonnées relatives et non absolues, même avec la flèche au bout, n'a plus du tout la même complexité !
C'est doublement une excellente solution à notre problème, puisque c'est également l'occasion de réinvestir les acquis de collège avec le codage de tracés en langage Scratch, mais dans le cadre maintenant d'un langage textuel conformément aux programmes du lycée.

Y sont disponibles des équivalents pour l'ensemble des fonctions Scratch du collège :

De quoi tracer facilement des vecteurs ou même encore plus complexe comme des fleurs !

Code: Select all

from turtle import *
import kandinsky

def forbackward(d):
  forward(d)
  backward(d)
 
def pf(d=1,gd=-1,nervure=False):
  n=9
  pos=position()
  for j in range(2):
    for k in range(n):
      forward(d)
      right(gd*90/n)
    right(gd*90)
  if nervure:
    right(gd*40)
    forbackward(5*d)
    right(-gd*40)

def fleur(npetales=8,nfeuilles=2,ltige=160,kfeuille=1,c=kandinsky.color(255,255,0)):
  d=ltige/(nfeuilles+1)
  color(0,191,0)
  for j in range(nfeuilles):
    forward(d)
    pf(kfeuille,2*(j%2)-1,True)
  forward(d)
  color((c>>11)<<3,((c>>5)%64)<<2,(c%32)<<3)
  for j in range(npetales):
    pf(kfeuille,-1)
    left(360/npetales)

#example
from math import *

def hsv2color(h,s=1,v=1):
  c=v*s
  x=c*(1-abs((h%120)/60-1))
  m=v-c
  k=int(h/60)
  r=255*(m+x*(k==1 or k==4)+c*(k==5 or k==0))
  g=255*(m+c*(k==1 or k==2)+x*(k==3 or k==0))
  b=255*(m+x*(k==2 or k==5)+c*(k==3 or k==4))
  return kandinsky.color(round(r),round(g),round(b))

def horiz(y,col):
  for x in range(320):
    kandinsky.set_pixel(x,y,col)

for j in range(112):
  horiz(111-j,hsv2color(210,0+1*j/111,1))
  horiz(111+j,hsv2color(30,.1+.9*j/111,.7))

sw=320
sh=222
ymax=sh/2
ymin=ymax-sh+1
xmin=-sw/2
xmax=xmin+sw-1
penup()
goto(0,ymin)
setheading(90)
pendown()
fleur(12,9,ymax-ymin+1-26,3,kandinsky.color(255,255,0))

Creusons un petit peu la chose, et explorons ce que renferme ce module à l'aide du script suivant :

Code: Select all

#platforms:
#0: MicroPython / TI-Nspire
#1: MicroPython / NumWorks
#2: MicroPython / G90+E
#3: MicroPython / G35+E/USB / G75/85/95
#4: CircuitPython / TI-Python / 83PCE
#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=='TI-Python Adapter':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]
#max chars per line
#(error or new line 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("<module '") or s.startswith("<class '")

def explmod(pitm,pitmsl=[],reset=True):
  global curline
  if(reset):
    curline=0
    pitmsl=[sstr(pitm)]
  hd="."*(len(pitmsl)-1)
  spath=".".join(pitmsl)
  c=0
  for itms in sorted(dir(pitm)):
    c=c+1
    try:
      itm=eval(spath+"."+itms)
      mprint(hd+itms+"="+str(itm))
      if isExplorable(itm):
        pitmsl2=pitmsl.copy()
        pitmsl2.append(itms)
        c=c+explmod(itm,pitmsl2,False)
    except:
      mprint(hd+itms)
  if c>0:
    mprint(hd+"Total: "+str(c)+" item(s)")
  return c

38 éléments donc, soit de quoi chambouler notre classement de la richesse des implémentations de pythonnettes dès la sortie de cette mise à jour !

	TI-Nspire	NumWorks	Casio Graph 90+E	Casio Graph 35+E/USB Graph 75/85/95	module externe TI-Python pour TI-83 Premium CE
builtins	218	188	175	204	190
array	4			4	4
collections					2
cmath	12	12		12
gc	7			7	7
math	41	41	25	41	28
random		8	8	8	8
sys	15			12	15
time		3			4
turtle		38
spécifique	10 (nsp)	5 (kandinsky)			4 (handshake)
Modules	7	7	3	7	9
Éléments	307	295	208	288	262

D'où le classement suivant :

1. TI-Nspire avec 7 modules et 307 entrées
2. NumWorks avec 7 modules et 295 entrées
3. Casio Graph 35+E/75+E avec 7 modules et 288 entrées
4. module externe TI-Python pour TI-83 Premium CE avec 9 modules et 262 entrées
5. Casio Graph 90+E avec 3 modules et 208 entrées

Attention le firmware 10.0.0 téléchargeable ci-dessous est donc en version bêta non finale. Des problèmes peuvent apparaître même en dehors des points évoqués; il t'est déconseillé de l'installer si tu as de prochains rendez-vous importants (DS, examens, concours...).

Téléchargement : firmware 10.0.0 bêta (installable facilement via webdfu_numworks )

[Admin]

jean-baptiste boric avait déjà travaillé à une modification du firmware NumWorks afin d'étendre les possibilités graphiques du module Python kandinsky, lui rajoutant les fonctions :

• draw_line(x1,y1,x2,y2,color) pour le tracer de lignes
• fill_rect(x,y,w,h,color) pour le tracer de rectangles pleins

Dans les deux cas ces fonctions n'étaient pas connectées à la fonction Python setpixel(x,y,color) mais à du code C permettant donc des tracés optimaux, notamment pour le rafraichissement de sprites dans des jeux.

Aujourd'hui jean-baptiste boric poursuit son chemin dans le but de nous permettre enfin de coder en Python des jeux graphiques jouables, en nous diffusant une nouvelle version de son firmware amélioré.

Voyons donc ensemble les dernières nouveautés

A première vue, bizarrement,pas de nouveauté kandinsky.

L'on note toujours comme seuls et uniques ajouts :

• draw_line(x1,y1,x2,y2,color)
• fill_rect(x,y,w,h,color)

Mais histoire d'être sûr, explorons le module kandinsky à l'aide du script suivant :

Code: Select all

#platforms:
#0: MicroPython / TI-Nspire
#1: MicroPython / NumWorks
#2: MicroPython / G90+E
#3: MicroPython / G35+E/USB / G75/85/95
#4: CircuitPython / TI-Python / 83PCE
#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=='TI-Python Adapter':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]
#max chars per line
#(error or new line 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("<module '") or s.startswith("<class '")

def explmod(pitm,pitmsl=[],reset=True):
  global curline
  if(reset):
    curline=0
    pitmsl=[sstr(pitm)]
  hd="."*(len(pitmsl)-1)
  spath=".".join(pitmsl)
  c=0
  for itms in sorted(dir(pitm)):
    c=c+1
    try:
      itm=eval(spath+"."+itms)
      mprint(hd+itms+"="+str(itm))
      if isExplorable(itm):
        pitmsl2=pitmsl.copy()
        pitmsl2.append(itms)
        c=c+explmod(itm,pitmsl2,False)
    except:
      mprint(hd+itms)
  if c>0:
    mprint(hd+"Total: "+str(c)+" item(s)")
  return c

Et bingo, oh que oui il y a des choses, simplement elles ne sont pas listées dans la boîte à outils.

Déjà après les sorties graphiques, Jean-Baptise s'attaque maintenant aux entrées clavier en définissant des codes pour l'ensemble des touches du clavier et rajoutant la fonction get_keys() pour connaître la ou les touches pressées !

Mais ce n'est pas tout, nous avons également de nouvelles fonctions de sorties graphiques :

• get_pixels(x,y,width,data)
• set_pixels(x,y,width,data)
• wait_vblank()

Alors, mission remplie ou pas avec tout ça ? Peut-on enfin coder un Mario pour la calculatrice NumWorks ?

Nous te proposons d'aller juger par toi-même en testant la fluidité du jeu PONG codé par Jean-Baptiste en exploitant ces nouvelles fonctionnalités, premier jeu Python contrôlable au clavier !

Attention au fait que le firmware diffusé par Jean-Baptiste dans ce contexte est basé sur l'état actuel du code source public de la calculatrice NumWorks, et que celui-ci est actuellement en phase bêta de la future version 10.0.0. Des problèmes peuvent donc apparaître même en dehors des points évoqués; il t'est déconseillé de l'installer si tu as de prochains rendez-vous importants (DS, examens, concours...).

Téléchargement : firmware 1.10.0 bêta précompilé avec ces améliorations (installable facilement via webdfu_numworks )
Code : https://github.com/numworks/epsilon/pull/746
Source : viewtopic.php?t=22284&p=239388#p239388

[Admin]

La nouvelle version 9.2.0 pour ta calculatrice NumWorks est maintenant disponible.

Il y a donc un changement de numérotation, puisque nous sommes passés de 1.8.1 à 1.9.0 et 1.9.1 en bêta, et puis maintenant à 9.2.0. On pourrait donc qualifier cette version de 1.9.2.0, mais il va falloir se faire à cette nouvelle numérotation.

Commençons déjà par les améliorations transversales puisque cette version (1.)9.2.0 introduit de grands changements internes.

Partage des variables entre applications :

Mise à part l’application Python qui pour l’instant reste dans son coin comme chez la concurrence ainsi que l’application Paramètres non concernée, toutes les autres applications deviennent enfin capables de partager des données autrement que par une opération de copier/coller.

On accède à ces données via la touche

var

qui listera maintenant, à chaque fois avec un aperçu de leurs valeurs :

• les expressions (variables numériques et matricielles) mais désormais seulement celles définies (par ordre d’affectation) et non tout l’alphabet comme avant
• les fonctions et ça c’est nouveau

Oui grâce à cela il devient enfin possible d’utiliser dans l’application Calculs des fonctions définies dans l’application Fonctions, et même d’y définir directement des fonctions via une simple opération d'affectation !

La solution mathématique NumWorks franchit ainsi un cap historique. On ne peut plus parler d'un simple agrégat d'applications comme chacun peut s'en faire sur son smartphone; il s'agit désormais d'une suite mathématique intégrée !

Libre nommage des variables :

Mais ce n’est pas tout… les noms de variables et de fonctions peuvent désormais être choisis librement sur 7 caractères au maximum, peu importe qu’il s’agisse de nombres, matrices ou fonctions !
Ils acceptent :

• les lettres majuscules A à Z
• les lettres minuscules a à z
• les chiffres, mais uniquement après une lettre
• le caractère tiret-bas (_), mais uniquement après une lettre

De formidables possibilités d’avoir des noms de fonctions beaucoup plus intelligibles et même collant davantage aux notations imposées par les énoncés !

Rajoutons que selon le même esprit, les fonctions de dérivation, intégration, somme et produit acceptent désormais un argument supplémentaire pour préciser librement le choix de la variable.

Maintenant voici ce qui concerne plus spécifiquement chacune des applications, mais non moins important pour autant :

Application Calculs :Go to top

Pour alléger/clarifier l’affichage, les undef ne sont plus affichés inutilement dans les résultats. Notamment lorsqu’un résultat exact/littéral a été trouvé.

Application Fonctions :Go to top

Dans le cas des définitions effectuées dans l’application Fonctions, il suffit maintenant de faire

OK

après avoir sélectionné le nom d’une fonction pour se voir proposer la possibilité de la renommer.

Plus de limite, l'on peut désormais définir plus de 4 fonctions depuis cette application !

Il devient même enfin possible de définir une fonction en fonction d’une autre !

Application Python :Go to top

Plusieurs fonctions du module builtins étaient parfaitement utilisables mais non listées au catalogue; elles devaient donc être saisies à la main. Les fonctions eval() et float() sont maintenant rajoutées au catalogue.

Plus de limite ici non plus, on peut maintenant créer plus de 8 scripts depuis la calculatrice.

Le Python bénéficie lui aussi d’une énorme nouveauté, l’ajout du module time bien que non listé au catalogue, et qu’il faudra donc importer à la main en tapant import time. Une exclusivité à ce jour parmi les implémentations de Python sur calculatrices !

En l’absence donc de catalogue, on peut par exemple l’explorer avec notre script explmod.

Outre le nom du module et donc les sous-fonctions de chaîne qui en découlent, on peut noter les deux fonctions time.monotonic() et time.sleep().

Enfin sur le simulateur en ligne, les dessins via le module kandinsky sont désormais affichés progressivement au fur et à mesure de leur réalisation, et non brutalement en fin d’exécution.
De quoi bien mieux comprendre ce qui se passe et éventuellement corriger, surtout dans le contexte du nouveau programme de Physique-Chimie de Seconde à la rentrée 2019.

Application Régressions :Go to top

Dans l’onglet Stats présentant les différents paramètres de notre ou nos séries statistiques à deux variables, l’on note la réservation d’un espace bien plus grand pour les colonnes associées à chaque variable.

Par rapport à la dernière version sortie (1.8.1), le microgiciel de la calculatrice a pris dans les 33Kio, ce qui est relativement peu par rapport à l'importance des nouveautés apportées. Il occupe désormais 688,7Kio soit 67,2% de la Flash de 1024Kio de la calculatrice.

Liens :

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