Pour la rentrée 2019,
Casio sort la
Graph 35+E II, une nouvelle déclinaison de son modèle
Graph 35+E numéro 1 au lycée. Une des nouveautés annoncées est l'ajout d'une application
Python.
Avec
Victor D et
Lephe, administrateur de
Planète Casio, nous avons participé à la
tournée pédagogique Casio à Toulouse mercredi 10 avril. Nous avons pu y utiliser une
Graph 35+E II qui contrairement à l'échantillon qui nous a été remis et que nous t'avons
présenté depuis, disposait bien de l'application
Python intégrée.
En attendant que la mise à jour intégrant cette application
Python sorte fin Mai 2019, découvrons ensemble cette version non finale.
Nous constatons donc dès l'écran d'accueil de cette
Graph 35+E II la présence d'une application supplémentaire,
PYTHON.
Un petit tour par la mémoire de stockage ne révélant aucune trace d'un fichier
.g1a associé à cette application, il s'agit donc non pas d'une application additionnelle, mais d'une application intégrée, qui donc , contrairement à l'application additionnelle non officielle
CasioPython aura l'énorme avantage de rester utilisable en mode examen !
Le nombre d'applications intégrées passe donc de 16 à 17 !
Malgré donc la quantité supplémentaire de code qui a été nécessaire, nous apprécions que la mémoire de stockage conserve une capacité de
3Mio.
L'application
SYSTEM intégrée nous permet d'apprendre que la calculatrice faire tourner un système d'exploitation en version
03.05.2200, plus récent donc que le
3.00.2200 de notre échantillon.
Rappelons que le numéro final à quatre chiffres ne fait pas vraiment partie de la numérotation et indique des spécificités issues du matériel ou du logiciel, dans l'ordre :
- zonage géographique; lié entre autres à divers options par défaut (format d'affichage des fractions, langues) ainsi qu'au comportement du mode examen :
- 0 : aucun
- 1 : Australie
- 2 : France
- 3 : Amérique du Nord
- 4 : Chine
- 5 : Singapour
- améliorations du calcul :
- 0 : aucune
- 1 : saisie naturelle + calcul exact (fractions uniquement) + affichage naturel (fractions uniquement) (fx-9860G Slim)
- 2 : saisie naturelle + calcul exact + affichage naturel
- 3 : saisie naturelle + calcul exact (fractions uniquement) + affichage naturel (fractions uniquement) (fx-9860GIIs)
- 7 : calcul exact (fractions uniquement) (fx-9750GII)
- sous-version
processeur :
- 0 : SH3 (SH7355)
- 1 : SH4 (SH7305)
Il s'agit donc plutôt d'une version
3.05.
L'année dernière pour la
Graph 90+E, la version rajoutant
Python sur les salons ainsi qu'à la tournée pédagogique fut la
3.15, alors que les échantillons remis étaient en
3.10 et que la mise à jour finale rajoutant
Python pour la rentrée 2018 fut la
3.20.
Nous pensons donc qu'ici, la mise à jour finale rajoutant
Python qui sera publiée fin Mai 2019 sera en version
3.10.
D'ailleurs si l'on fait défiler cet écran, on remarque que les langues intégrées utilisent déjà une numérotation en
3.10.
Tentons maintenant d'en découvrir davantage sur ce nouveau système d'exploitation en accédant au menu de diagnostic caché. Il suffit pour cela d'allumer la calculatrice tout en maintenant les touches
OPTN
et
×10^x
, puis de taper
F1
9
.
Si nous tapons
4
pour
VERSION, nous apprenons que le système d'exploitation
3.05 a été compilé le
25 mars 2019 à
15h16, ce qui est effectivement plus récent que le
8 février 2019 à
3h03 pour la version
3.00 de notre échantillon.
Accédons donc à l'application
PYTHON et ouvrons la console. Le message d'accueil nous apprend que nous sommes sur une implémentation
MicroPython 1.9.4, exactement comme sur la
Graph 90+E.
Pour référence, voici ce que nous avons sur les solutions concurrentes auxquelles nous allons par la suite confronter la
Graph 35+E II 3.05 :
- Casio Graph 35+E II : MicroPython 1.9.4
- Casio Graph 90+E / fx-CG50 : MicroPython 1.9.4
- application CasioPython sur Casio Graph 35+E II / 35+E/USB / 75/85/95 / fx-9750GII / fx-9860G/GII : MicroPython 1.9.4
- application KhiCAS sur Casio Graph 90+E / fx-CG10/20/50 : couche de traduction
- NumWorks : MicroPython 1.9.4
- application MicroPython sur TI-Nspire : MicroPython 1.4.6
- module externe TI-Python pour TI-83 Premium CE : CircuitPython 3.0.0
- HP Prime : couche de traduction
4) Nombres flottants, complexes, entiers courts et longs :
Go to topCommençons par tester les nombres flottants qui, rappelons-le, sont représentés en mémoire sous la forme
$mathjax$\pm M\times 2^{E-E_{min}}$mathjax$
avec
$mathjax$M\in [1;2[$mathjax$
. Prenons la fonction
Python suivante :
- Code: Select all
def precm(b):
k,b=0,float(b)
while 1+b**-k-1>0:
k+=1
return k
L'appel
precm(2) nous apprend que la mantisse
M des nombres flottants peut avoir jusqu'à
53 bits, et l'appel
precm(10) nous précise que cela correspond à 16 chiffres significatifs.
Continuons à creuser les flottants avec la fonction
Python suivante :
- Code: Select all
def prece():
a=-1
while 2.**a>0:
a*=2
while 2.**a==0:
a+=1
b=1
while str(2.**b)[0:3]!='inf':
b*=2
while str(2.**b)[0:3]=='inf':
b-=1
return [a,b]
L'appel
prece() nous indique que les bits restants permettent à l'exposant des nombres flottants de prendre des valeurs allant de
-1074 à
+1023.
C'est identique à ce qu'apportent dans leurs dernières versions toutes les solutions concurrentes évoquées plus haut.
Les nombres complexes quant à eux sont visiblement gérés, mais le module
cmath apportant les fonctions complexes qui vont avec est ici manquant.
| | NumWorks | Casio
Graph 35+E II
Graph 90+E | | TI-Python pour
TI-83 Premium CE | |
| nombres complexes | ✓ | ✓ | ✓ | ✓ | | ✓ |
module cmath
(fonctions complexes) | ✓ | ✓ | | ✓ | | ✓ |
D'où le classement suivant pour les nombres complexes :
- NumWorks + Casio Graph 35+E II / 35+E/USB / 75/85/95 / fx-9750GII / fx-9860G/GII (application CasioPython) + TI-Nspire (application MicroPython) + module externe TI-Python pour TI-83 Premium CE (firmware tiers) avec nombres et fonctions complexes
- Casio Graph 35+E II / 90+E / fx-CG50 avec nombres complexes
- module externe TI-Python pour TI-83 Premium CE
La faible gestion des nombres complexes est bien dommage pour les élèves de Terminale S/STI2D/STL, même si on peut exceptionnellement passer l'éponge cette année vu que le Python n'a été imposé en Seconde qu'à la rentrée 2017.
Enfin, nous sommes sur une plateforme 32 bits
(processeur SH4) et pouvant visiblement réaliser des calculs entiers nécessitant 33 ou même 65 bits. Aucun doute, la gestion des entiers longs est donc activée.
C'est ici aussi identique à ce qu'apportent dans leurs dernières versions toutes les solutions concurrentes.
Nous venons donc de voir que la
Graph 35+E II ne disposait pas du module
cmath. En fait elle n'a pas grand chose, exactement comme la
Graph 90+E, la
Graph 35+E II ne dispose que de deux modules
Python permettant de rajouter des fonctions,
math et
random, à rajouter bien évidemment au module par défaut
builtins.
D'où le classement suivant en terme d'éventail de modules :
- 13 modules : module externe TI-Python pour TI-83 Premium CE (firmware tiers)
- 8 modules : NumWorks + Casio Graph 35+E II / 35+E/USB / 75/85/95 / fx-9750GII / fx-9860G/GII + TI-Nspire (application MicroPython) + module externe TI-Python pour TI-83 Premium CE
- 3 modules : Casio Graph 35+E II / 90+E / fx-CG50
Dommage donc que la modeste sélection de modules de la Graph 90+E, déjà la plus légère parmi toutes les solutions concurrentes, ait été reprise à l'identique au lieu d'être étoffée pour la Graph 35+E II.
Le script
Python suivant nous permet d'explorer le contenu des modules que nous avons trouvés :
- Code: Select all
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)
print(hd+itms+"="+str(itm))
if isExplorable(itm):
pitmsl2=pitmsl.copy()
pitmsl2.append(itms)
c=c+explmod(itm,pitmsl2,False)
except:
print(hd+itms)
if c>0:
print(hd+"Total: "+str(c)+" item(s)")
return c
Ici, nous apprenons sans surprise que les modules
builtins,
math et
random comportent respectivement
175,
25 et
8 éléments, exactement comme sur
Graph 90+E.
Il semble bien que l'application
PYTHON de la
Graph 35+E II soit un portage à l'identique de l'application déjà disponible pour la
Graph 90+E.
D'où le classement suivant en terme de richesse des modules :
- 354 éléments : module externe TI-Python pour TI-83 Premium CE (firmware tiers)
- 310 éléments : TI-Nspire (application MicroPython)
- 301 éléments : NumWorks
- 294 éléments : Casio Graph 35+E II / 35+E/USB / 75/85/95 / fx-9750GII / fx-9860G/GII (application CasioPython)
- 258 éléments : module externe TI-Python pour TI-83 Premium CE
- 208 éléments : Casio Graph 35+E II / 90+E / fx-CG50
La mémoire de travail en
Python va accueillir :
- les définitions globales (variables, fonctions, classes) issues des scripts importés
- les arguments d'appel de la ou des fonctions en cours d'exécution
- les définitions locales effectuées par la ou les fonctions en cours d'exécution
La taille de la mémoire de travail conditionne donc jusqu'où il sera possible d'aller en
Python, nombre d'appels récursifs par exemple.
Voici quelques tailles occupées en mémoire par des variables
Python :
- 64 octets pour une liste vide
- 8 octets par élément de liste supplémentaire
- 24 octets pour un entier nul
- 28 octets pour un entier court non nul
- 49 octets pour une chaîne vide
- 1 octet par caractère de chaîne supplémentaire
En se basant sur ces tailles, le
script suivant permet d'estimer la capacité de la mémoire de travail en allouant plusieurs blocs de mémoire jusqu'à épuisement :
- Code: Select all
def mem():
try:
l=[]
try:
l+=[0]
l+=[""]
l[1]+="x"
while True:
try:
l[1]+=l[1][l[0]:]
except:
if l[0]<len(l[1])-1:
l[0]=len(l[1])-1
else:
raise(Exception)
except:
print("+",len(l)>1 and len(l[1]))
return 64+8*len(l)+(len(l) and 24+4*(l[0]>0)+(len(l)>1 and 49+len(l[1])))+mem()
except:
return 0
Voici la sortie obtenue par l'appel
mem() :
Graph 35+E II wrote:>>> from mem import *
>>> mem()
+ 40961
+ 14334
+ 10239
+ 10238
+ 4111
+ 4095
+ 3071
+ 2172
+ 1534
+ 1023
+ 575
+ 350
+ 191
+ 64
+ 64
+ 15
95549
>>>
Le script arrive donc à allouer en mémoire de travail un premier bloc continu maximal de près de 41K, pour un total de
95,549 Ko.
D'où le classement suivant :
- 2,046 Mo : TI-Nspire (application MicroPython)
- 1,027 Mo : Casio Graph 90+E / fx-CG50
- 255,07 Ko : Casio Graph 35+E / 35+USB/75/95 SH4 / fx-9750/9860GII SH4 (application CasioPython)
- 95,549 Ko : Casio Graph 35+E II
- 28,625 Ko : Casio Graph 35+E II / 35+USB/75/85/95 SH3 / fx-9750GII SH3 / fx-9860G/GII SH3 (application CasioPython)
- 19,842 Ko : module externe TI-Python pour TI-83 Premium CE (firmware tiers)
- 17,192 Ko : module externe TI-Python pour TI-83 Premium CE
- 13,658 Ko : calculatrice NumWorks
- 5,946 Ko : logiciel web NumWorks
L'application non officielle
CasioPython est actuellement conçue pour travailler avec 256K sur les
Graph 35+E/USB / 75/95 à processeur
SH4, et 32K sur les
Graph 35+USB/75/85/95 à processeur
SH3.
A l'heure d'écriture de ce test, sa dernière version disponible semble à tort détecter le matériel de la nouvelle
Graph 35+E II comme du
SH3.
Enfin, terminons en voyant les performances. Commençons dans le cadre des nombres entiers avec le script suivant :
- Code: Select all
try:
from time import *
except:
pass
def hastime():
try:
monotonic()
return True
except:
return False
def genseed(ndigits):
nmax,s,k=5*10**(ndigits-1),0,1
while s<nmax:
s+=k
k*=2
return s
def genarr(ndigits):
sd,arr=genseed(ndigits),[]
for k in range(1,ndigits):
for j in range(ndigits):
t=sd%10**k
arr.extend([t,-t,10**k-t,t-10**k])
sd=sd//10+(sd%10)*10**(ndigits-1)
arr.extend([sd,-sd])
return arr
def sortarr(arr,sdiff):
segs=[0,len(arr)-1]
while len(segs):
iref=segs[0]
for k in range(segs[0],segs[1]+1):
if sdiff*(arr[k]-arr[iref])>0:
t=arr[iref]
arr[iref]=arr[k]
arr[k]=arr[iref+1]
arr[iref+1]=t
iref+=1
if iref>=segs[0]+2:
segs.extend([segs[0],iref-1])
if iref<=segs[1]-2:
segs.extend([iref+1,segs[1]])
segs.pop(0)
segs.pop(0)
return arr
def test(l,n):
timed=hastime()
start,stop,sdiff,arr=0 or timed and monotonic(),1,-1,[]
arr.extend(genarr(l))
for k in range(n):
arr.extend(sortarr(arr,sdiff))
sdiff=-sdiff
stop=timed and monotonic() or 1
return stop-start,len(arr),arr[0],arr[len(arr)//2-1],arr[len(arr)//2],arr[len(arr)-1]
La ligne d'appel
test(9,2) se termine en
14,93s sur la
Graph 35+E II.
D'où le classement suivant dans le contexte des calculs entiers :
- 1,41s : TI-Nspire (application MicroPython) (32 bits : ARM9/ARMv5 @120MHz)
- 1,56s : TI-Nspire CM / CX CR3- (application MicroPython) (32 bits : ARM9/ARMv5 @132MHz)
- 2,40s : TI-Nspire CX CR4+ (application MicroPython) (32 bits : ARM9/ARMv5 @156MHz)
- 3,74s : NumWorks (32 bits : Cortex/ARMv7 @100MHz)
- 4,75s : Casio Graph 90+E / fx-CG50 (32 bits : SH4 @118MHz)
- 8,81s : HP Prime G2 (32 bits : Cortex/ARMv7 @528MHz)
- 9,56s : Casio Graph 35+E/75+E / 35+USB/75/95 SH4 / fx-9750/9860GII SH4 (application CasioPython) (32 bits : SH4 @29,5MHz)
- 10,19s : Casio Graph 35+E II (application CasioPython) (32 bits : SH4 @59MHz)
- 12,99s : Casio Graph 35+USB/75/85/95 SH3 / fx-9750GII SH3 / fx-9860G/GII SH3 (application CasioPython) (32 bits : SH3 @29,5MHz)
- 14,93s : Casio Graph 35+E II (32 bits : SH4 @59MHz)
- 20,73s : HP Prime G1 (32 bits : ARM9/ARMv5 @400MHz)
- 23,20s : module externe TI-Python pour TI-83 Premium CE (32 bits : Cortex/ARMv7 @48MHz)
- 33,48s : module externe TI-Python pour TI-83 Premium CE (firmware tiers) (32 bits : Cortex/ARMv7 @48MHz)
- 60,71s : application KhiCAS sur Casio Graph 90+E / fx-CG50 (32 bits : SH4 @118MHz)
- 116,93s : application KhiCAS sur Casio fx-CG10/20 (32 bits : SH4 @59MHz)
Bizarrement donc, l'application
Python officielle de la
Graph 35+E II a des performances en calcul entier nettement inférieures à celles de l'application communautaire
CasioPython, et ce alors que ces deux applications sont basées sur
MicroPython.
C'est assez décevant, même si il y a pire dans les deux cas.
Passons maintenant aux nombres flottants avec le script suivant :
- Code: Select all
try:
from time import *
except:
pass
def hastime():
try:
monotonic()
return True
except:
return False
def seuil(d):
timed=hastime()
start,stop,n,u,l,d=0 or timed and monotonic(),1,0,2.,1,d**2
while (u-l)**2>=d: u,n=1+(1/((1-u)*(n+1))),n+1
stop=timed and monotonic() or 1
return [stop-start,n,u]
La ligne d'appel
seuil(0.005) se termine en
25,19s sur la
Graph 35+E II.
D'où le classement suivant dans le contexte des calculs en virgule flottante :
- 0,962s : HP Prime G2 (32 bits : Cortex/ARMv7 @528MHz)
- 1,08s : TI-Nspire CM / CX CR3- (application MicroPython) (32 bits : ARM9/ARMv5 @132MHz)
- 1,29s : TI-Nspire (application MicroPython) (32 bits : ARM9/ARMv5 @120MHz)
- 1,61s : TI-Nspire CX CR4+ (application MicroPython) (32 bits : ARM9/ARMv5 @156MHz)
- 2,036s : NumWorks (32 bits : Cortex/ARMv7 @100MHz)
- 3,068s : HP Prime G1 (32 bits : ARM9/ARMv5 @400MHz)
- 8,94s : Casio Graph 90+E / fx-CG50 (32 bits : SH4 @118MHz)
- 9,68s : module externe TI-Python pour TI-83 Premium CE (32 bits : Cortex/ARMv7 @48MHz)
- 10,68s : Casio Graph 35+E II (application CasioPython) (32 bits : SH4 @59MHz)
- 11,26s : Casio 35+E/75+E / 35+USB/75/95 SH4 / fx-9750/9860GII SH4 (application CasioPython) (32 bits : SH4 @29,5MHz)
- 11,46s : module externe TI-Python pour TI-83 Premium CE (firmware tiers) (32 bits : Cortex/ARMv7 @48MHz)
- 13,87s : Casio Graph 35+USB/75/85/95 SH3 / fx-9750GII SH3 / fx-9860G/GII SH3 (application CasioPython) (32 bits : SH3 @29,5MHz)
- 19,98s : application KhiCAS sur Casio Graph 90+E / fx-CG50 (32 bits : SH4 @118MHz)
- 25,19s : Casio Graph 35+E II (32 bits : SH4 @59MHz)
- 35,55s : application KhiCAS sur Casio fx-CG10/20 (32 bits : SH4 @59MHz)
Avec le changement de contexte l'ordre n'est pas le même, mais nous notons ici encore des performances étrangement très inférieures pour l'application
Python officielle de la
Graph 35+E II, par rapport à celles de l'application communautaire
CasioPython.
On peut regretter que l'application
Python officielle de la nouvelle
Casio Graph 35+E II en version
3.05 soit, comme celle de la
Graph 90+E, l'implémentation la plus légère parmi toutes les calculatrices concernées. On regrette l'absence des fonctions complexes pour les Terminales S/STI2D/STL, ainsi que l'absence d'un module graphique pour la Physique-Chimie en Seconde. On va dire que pour 2019-2020, où seules les Seconde et Première sont concernées par l'obligation de programmer en
Python, et où les enseignants ne s'y mettront certainement pas tous à fond, ça passe. Mais des mises à jour étendant l'implémentation devront rapidement être apportées par le constructeur.
Les performances comme nous l'avons vu sont également décevantes, mais elles le sont juste relativement. Le constructeur doit pouvoir mieux faire vu le matériel, et peut-être le fera-t-il dès la version
3.10 finale qui sortira fin Mai 2019.
Même si non optimale, la
Casio Graph 35+E II reste une belle solution
Python qui, contrairement à la concurrence, a le gros avantage de se positionner sur l'entrée de gamme. L'usage du
Python sur calculatrice pour tester ses algorithmes en classe, aux devoirs, aux épreuves de contrôle continu ainsi qu'à l'épreuve terminale va enfin pouvoir se démocratiser, merci
Casio !
Merci à tous ceux qui ont aidé à notre participation à la tournée pédagogique
Casio 2019 !
Une pensée envers
Casio qui nous a offert à chacun un échantillon de sa nouvelle
Graph 35+E II, ainsi qu'envers tous ceux qui ont participé à notre
campagne de financement participatif, entre autres :
- nos donateurs VIP++ : Adriweb, darthvader, Dubs, grosged, jacobly, MateoConLechuga, nbenm, noelnadal, Paneth, parisse, Persalteas, STaa, telpe51, TheMachine02
- nos donateurs VIP+ : Barrere, Inspire5960, mathys057, rtomczak
- nos donateurs VIP : arthuralbertini279, blanchette831, gersonvmartinez
by 
