Test Casio Graph 35+E II Python (préversion 3.05)
Posted: 01 May 2019, 18:45
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.
1) Applications intégrées :
Go to top
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.
2) Version système :
Go to top
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)
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.
OPTNet
×10^x, puis de taper
F1
9.
Si nous tapons
4pour 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.
3) Implémentation Python :
Go to top
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
L'appel
Continuons à creuser les flottants avec la fonction Python suivante :
L'appel
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. 
D'où le classement suivant pour les nombres complexes :
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.
$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
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]
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.
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.
C'est ici aussi identique à ce qu'apportent dans leurs dernières versions toutes les solutions concurrentes.
5) Liste modules Python :
Go to topNous 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 :
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.
6) Exploration modules Python :
Go to topLe script Python suivant nous permet d'explorer le contenu des modules que nous avons trouvés :
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 :
- 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
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
7) Mémoire de travail Python :
Go to topLa mémoire de travail en Python va accueillir :
Voici quelques tailles occupées en mémoire par des variables Python :
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 :
Voici la sortie obtenue par l'appel
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 :
- 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
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
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.
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.
8) Performances Python :
Go to topEnfin, terminons en voyant les performances. Commençons dans le cadre des nombres entiers avec le script suivant :
La ligne d'appel
D'où le classement suivant dans le contexte des calculs entiers :
Passons maintenant aux nombres flottants avec le script suivant :
La ligne d'appel
D'où le classement suivant dans le contexte des calculs en virgule flottante :
- 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.
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.
Conclusion :
Go to topOn 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 !
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 :
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
), cela on a juste un problème de backend qui nous empêche de les utiliser comme il faudrait.