La nouvelle version
10.1.0 pour ta calculatrice
NumWorks est dès maintenant disponible. Découvrons ensemble les nouveautés :
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 !
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.
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.
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 :
| | NumWorks | Casio
Graph 90+E | | 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 :
- TI-Nspire avec 7 modules et 307 entrées, hors mode examen
- NumWorks avec 7 modules et 295 entrées, même en mode examen
- Casio Graph 35+E/75+E avec 7 modules et 288 entrées, hors mode examen
- module externe TI-Python pour TI-83 Premium CE avec 8 modules et 258 entrées, même en mode examen
- 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.
by 
A la rentrée 2019 en Seconde, le Python débarque en Physique-Chimie pour illustrer graphiquement divers phénomènes physiques.
Avertissement pour les codeurs NumWorks dont les scripts manipulent des couleurs.
