Casio
nous sort une nouvelle édition de sa Graph 35
Graph 35+E II
.La mise à jour
3.10
gratuite qui sera disponible mercredi 22 mai lui rajoutera la gestion des scripts Python
. 
Ce n'est pas la seule nouveauté puisque lors de notre test initial nous avons notés plusieurs améliorations matérielles significatives par rapport aux anciennes
Graph 35/75+E
- le doublement de la fréquence processeur avec 59 MHz
- le doublement de la capacité de la puce Flashavec8 Mio
- en conséquence le doublement de la mémoire de stockage avec 3 Mio
La n'est que partielle.
Graph 35+E II
gère désormais les applications, mais avec tous ces changements la compatibilité avec les applications Graph 75+E
Il n'empêche que nombre d'applications parmi les plus utiles fonctionnent déjà. Tu peux notamment dès maintenant rajouter à ta
Graph 35+E II
:- l'application de programmation PythonCasioPython- même pas la peine d'attendre mercredi
- l'application de calcul formel CASpar la communauté jeuxcasio.com
- l'application de calcul formel Algebrabasée sur le moteur du logicielEigenMath
Toutefois, on pouvait reprocher à ces deux applications de calcul formel d'être relativement limitées même dans le contexte du lycée, ainsi qu'une maintenance inexistante pour la première et très occasionnelle pour la dernière.
Mais voici venir l'infatigable avec le moteur de calcul formel
Aujourd'hui, grâce au travail acharné de
En prime, l'application 
Elle inclut son propre éditeur de scripts, qui a l'avantage d'une belle innovation par rapport à l'éditeur de
Et en prime nous y avons même un module !
Giac
de son logiciel Xcas
.Bernard
avait déjà rendu disponible son moteur Giac
pour plusieurs calculatrices graphiques, avec :- le programme Ndless KhiCASpourTI-Nspire
- l'application KhiCASpourCasio Graph 90+Eetfx-CG10/20/50
Bernard
et à l'aide formidable de Lephenixnoir
, administrateur Planète Casio
, KhiCAS
débarque sur ta Graph 35+E II
! KhiCAS
est programmable dans une syntaxe proche du Python
, que demander de plus ?... Elle inclut son propre éditeur de scripts, qui a l'avantage d'une belle innovation par rapport à l'éditeur de
Casio
que nous avons testé. En effet l'éditeur de KhiCAS
se donne même la peine de compenser l'absence d'écran couleur et donc de coloration syntaxique par quelques enrichissements ! Et en prime nous y avons même un module
turtle
pour programmer du tracé comme en Scratch / Logo
Précisons toutefois qu'il ne s'agit pas d'un véritable interpréteur
Nombre de scripts
Python
, mais d'une couche de traduction syntaxique vers le langage de programmation historique de Xcas
.Nombre de scripts
Python
pourront ne pas fonctionner correctement sans des modifications qui ne seront pas toujours évidentes.Mais pourquoi obtenons-nous et ?
Comme nous l'avons vu dans notre test, la.
Matériellement, la capacité de la mémoire à à faisait déjà légèrement moins de 2 Mio, ce qui ne rentrait pas sur les anciens modèles.
Mais ce n'était pas la seule raison. Les anciens modèles monochromes et étaient incapables de gérer les applications faisant plus de . Cette limitation avait été repoussée à , et en empruntant au code de ces modèles la limitation de taille passe aussi à
KhiCAS
seulement maintenant sur Graph 35+E II
, et pourquoi ne l'avons-nous pas eu plus tôt sur les anciennes Graph 35+E/USB
Graph 75/85/95
Comme nous l'avons vu dans notre test, la
Graph 35+E II
a bénéficié de plusieurs améliorations matérielles, et ses fonctionnalités logicielles ont également été fortement rafraîchies en empruntant beaucoup à la Graph 90+E
Matériellement, la capacité de la mémoire
Flash ROM
a doublé, passant de 4 Mio
8 Mio
. En conséquence, la capacité de la mémoire de stockage a également doublé, passant de 1,5 Mio
3 Mio
. Or, il se trouve que l'application KhiCAS
pour Graph 90+E
Mais ce n'était pas la seule raison. Les anciens modèles monochromes
Graph 35+E/USB
Graph 75/85/95
512 Kio
2 Mio
sur les modèles couleur Graph 90+E
et fx-CG10/20/50
2 Mio
sur la nouvelle Graph 35+E II
! 
A la seule différence près que la saisie et l'écriture naturelle ne sont pas directement gérées à l'écran des calculs. Pour saisir en écriture naturelle plutôt qu'en ligne tu devrais taper
F3sur la ligne de saisie, ce qui te donnera accès à un éditeur d'expression plein écran. De façon similaire, pour les résultats où l'application le jugera pertinent, l'application te présentera une vue temporaire plein écran en affichage naturel avant de te ramener à l'historique des calculs.
Rappelons que comme ses soeurs la
Graph 35+E II
ne gère d'origine que deux familles résultats exacts :- $mathjax$\pm\frac{a\pi}{b}$mathjax$pour la trigonométrie bien évidemment
- $mathjax$\frac{\pm a\sqrt{b} \pm c\sqrt{d}}{f}$mathjax$qui est une famille de nombres avec des propriétés aisément vérifiables par les processeurs légers, et couvrant jusqu'ici l’essentiel des besoins des lycéens jusqu’en Première
Avec
KhiCAS
où le calcul exact s'appuie sur un moteur de calcul formel nous n'avons pas ce genre de limitation, les résultats pourront utiliser des exponentielles et bien d'autres choses encore ! Enfin, parlons performances puisque l'application
KhiCAS
est programmable dans un langage proche du Python
.Dans le contexte des nombres entiers, prenons 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 140,13s
.D'où le classement pour les performances en calcul entier
Python
:- 1,41s:TI-Nspire(32 bits : ARM9/ARMv5 @120MHz)
- 1,56s:TI-Nspire CM / CX révisions A-V(32 bits : ARM9/ARMv5 @132MHz)
- 2,40s:TI-Nspire CX révisions W+/CR4+(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(32 bits : SH4 @29,5MHz)
- 10,19s:Casio Graph 35+E II(32 bits : SH4 @59MHz)
- 12,99s:Casio Graph 35+USB/75/85/95 SH3 / fx-9750GII SH3 / fx-9860G/GII SH3(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 externeTI-Python pour TI-83 Premium CE(32 bits : Cortex/ARMv7 @48MHz)
- 26,60s:TI-83 Premium CE Edition Python(?)
- 33,48s: module externeTI-Python pour TI-83 Premium CE(32 bits : Cortex/ARMv7 @48MHz)
- 60,71s:Casio Graph 90+E / fx-CG50(32 bits : SH4 @118MHz)
- 116,93s:Casio fx-CG10/20(32 bits : SH4 @59MHz)
- 140,13s:Casio Graph 35+E II(application KhiCAS)(32 bits : SH4 @59MHz)
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]
seuil(0.005) se termine en 69,55s
.D'où le classement pour les performances en virgule flottante
Python
:- 0,962s:HP Prime G2(32 bits : Cortex/ARMv7 @528MHz)
- 1,08s:TI-Nspire CM / CX CR3-(32 bits : ARM9/ARMv5 @132MHz)
- 1,29s:TI-Nspire(32 bits : ARM9/ARMv5 @120MHz)
- 1,61s:TI-Nspire CX CR4+(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 externeTI-Python pour TI-83 Premium CE(32 bits : Cortex/ARMv7 @48MHz)
- 10,38s:TI-83 Premium CE Edition Python(?)
- 10,68s:Casio Graph 35+E II(32 bits : SH4 @59MHz)
- 11,26s:Casio 35+E/75+E / 35+USB/75/95 SH4 / fx-9750/9860GII SH4(32 bits : SH4 @29,5MHz)
- 11,46s: module externeTI-Python pour TI-83 Premium CE(32 bits : Cortex/ARMv7 @48MHz)
- 13,87s:Casio Graph 35+USB/75/85/95 SH3 / fx-9750GII SH3 / fx-9860G/GII SH3(32 bits : SH3 @29,5MHz)
- 19,98s:Casio Graph 90+E / fx-CG50(32 bits : SH4 @118MHz)
- 25,19s:Casio Graph 35+E II(32 bits : SH4 @59MHz)
- 35,55s:Casio fx-CG10/20(32 bits : SH4 @59MHz)
- 69,55s:Casio Graph 35+E II(application KhiCAS)(32 bits : SH4 @59MHz)
Ce sont donc les performances qui pèchent à ce jour. Mais on peut noter que c'était relativement déjà le cas pour l'application
KhiCAS
originelle sur Graph 90+E
, et que pour un usage courant au niveau lycée cela devrait suffire.Avec
Ton extraordinaire
Ne terminons pas sans rappeler que cette application d'excellente facture n'en reste pas moins des plus pertinentes sur le plan pédagogique des nouveaux programme du lycée, avec :
KhiCAS
, bénéficie gratuitement d'un moteur de calcul formel aux capacités exhaustives qui couvriront cette fois-ci l'ensemble des tâches réalisées au lycées ainsi que nombre de besoins de l'enseignement supérieur !Ton extraordinaire
Graph 35+E II
au prix d'entrée de gamme numéro un au lycée n'aura désormais plus rien à envier aux modèles haut de gamme, c'est une première historique, une révolution ! Ne terminons pas sans rappeler que cette application d'excellente facture n'en reste pas moins des plus pertinentes sur le plan pédagogique des nouveaux programme du lycée, avec :
- une programmation en syntaxe proche du Python
- un enrichissement syntaxe en remplacement de la coloration syntaxique impossible sur écran noir et blanc
- le module turtlequi permet aux nouveaux élèves de Seconde de passer progressivement de la programmation par blocs à la programmation textuelle, tout en s'appuyant sur les acquis de la programmation de tracés enScratchdu collège
Merci
Bernard
, et les constructeurs de modèles haut de gamme feraient bien d'en prendre de la graine pour leurs prochains modèles ou mises à jour ciblant la France. Téléchargement
:Source
:
