QCC 2019 épisode 6 : performances & Python

→ **MyCalcs** profile · by **critor** » 07 Sep 2019, 11:49

Quelle Calculatrice programmable Choisir 2019 - Episode 6
Performances et Python

Nous clôturons aujourd'hui la série des nouveaux tests QCC 2019, avec les performances.

Dans un premier temps, nous allons évaluer les performances de calcul en virgule flottante grâce à un programme dans le langage historique de chaque machine. Parce que le langage historique est normalement le plus intégré au système et illustre ainsi bien les performances globales. Prenons pour cela le script Python suivant, qui sera traduit ligne à ligne pour chaque calculatrice :

Code: Select all: try: from time import * except: pass def hastime(): try: monotonic() return True except: return False def seuil(d): timed,n=hastime(),0 start,u=0 or timed and monotonic(),2. d=d**2 while (u-1)**2>=d: u=1+1/((1-u)*(n+1)) n=n+1 return [(timed and monotonic() or 1)-start,n,u]

Nous allons réaliser le test dans deux contextes :

le contexte exact, le plus souvent par défaut et inutile ici
le contexte numérique (calculs décimaux approchés) optimal pour ce script

En effet la plupart des calculatrices offrent le choix d'obtenir des résultat décimaux ou exacts lorsque possible, et selon le mode courant cela peut influer sur les performances.

Si l'on se donne la peine de régler le mode numérique, l'appel seuil(0.008) donne le classement suivant :

0,498s : NumWorks N0110 (32 bits : Cortex-M7/ARMv7 @216MHz)
0,688s : HP Prime G2 (32 bits : Cortex-A7/ARMv7 @528MHz)
0,785s : NumWorks N0100 (32 bits : Cortex-M4/ARMv7 @100MHz)
2,19s : Casio Graph 35+E II (32 bits : SH4 ~~@58,98MHz~~ overclocké @274,91MHz via Ftune3 avec l'interpréteur C.Basic)
2,23s : Casio Graph 35/75+E (32 bits : SH4 ~~@29,49MHz~~ overclocké @267,78MHz via Ftune2 avec l'interpréteur C.Basic)
2,37s : Casio Graph 90+E (32 bits : SH4 @117,96MHz ~~@58,98MHz~~ overclocké @274,91MHz via Ptune3 avec l'interpréteur C.Basic)
2,41s : HP Prime G1 (32 bits : ARM9/ARMv5 @400MHz)
3,75s : Casio Graph 90+E (32 bits : SH4 @117,96MHz avec l'interpréteur C.Basic)
8,93s : TI-Nspire CX II (32 bits : ARM9/ARMv5 @396MHz)
10,02s : TI-Nspire (32 bits : ARM9/ARMv5 overclocké ~~@120MHz~~ @150MHz via Nover)
11,11s : Casio Graph 35+E II (32 bits : SH4 @58,98 avec l'interpréteur C.Basic)
12,24s : TI-Nspire (32 bits : ARM9/ARMv5 @120MHz)
12,9s : Casio Graph 35/75+E (32 bits : SH4 @29,49MHz avec l'interpréteur C.Basic)
18,64s : TI-Nspire CX CR4+ (révisions W+) (32 bits : ARM9/ARMv5 ~~@156MHz~~ overclocké @216MHz via Nover)
18,94s : TI-Nspire CX CR4+ (révisions W+) (32 bits : ARM9/ARMv5 @156MHz)
19,56s : TI-Nspire CX (révisions A-V) (32 bits : ARM9/ARMv5 ~~@132MHz~~ overclocké @222MHz via Nover)
20,92s : TI-Nspire CX (révisions A-V) (32 bits : ARM9/ARMv5 @132MHz)
25,26s : Casio Graph 35/75+E (32 bits : SH4 ~~@29,49MHz~~ overclocké @267,78MHz via Ftune2)
29,31s : Casio Graph 35+E II (32 bits : SH4 ~~@58,98MHz~~ overclocké @274,91MHz via Ftune3)
38,15s : Casio Graph 90+E (32 bits : SH4 ~~@117,96MHz~~ overclocké @270,77MHz via Ptune3)
50,77s : Casio Graph 90+E (32 bits : SH4 @117,96MHz)
81,03s : Casio Graph 35+E II (32 bits : SH4 @58,98MHz)
101,1s : Casio Graph 35/75+E (32 bits : SH4 @29,49MHz)
117,29s : Casio Graph 25+E (32 bits : SH4 @29,49MHz)
120,51s : TI-83 Premium CE Edition Python / TI-84 Plus CE-T (révisions M+) (8 + 32 bits : eZ80 @48MHz)
171,31s : TI-83 Premium CE / TI-84 Plus CE-T (révisions A-L) (8 bits : eZ80 @48MHz accéléré via AWSC)
196,79s : TI-83 Premium CE / TI-84 Plus CE-T (révisions A-L) (8 bits : eZ80 @48MHz)
260,41s : TI-82 Advanced / TI-84 Plus T (8 bits : z80 @15MHz)
607,91s : Casio fx-CP400+E (32 bits : SH4 @117,96MHz)
672,65s : Casio fx-92+ Spéciale Collège (8 bits : nX-U8/100 >1,5MHz - spécifications ancien modèle fx-92 Collège 2D+, non confirmées sur le nouveau)
≈798,18s : Esquisse GCEXFR / Lexibook GC3000FR (non programmable, estimation relative par comparaison des performances en tracé de graphes avec le modèle le plus proche technologiquement, la TI-82 Advanced)

Revenons donc maintenant en mode exact, fonctionnement donc par défaut des machines si on ne fait pas attention. Pour le même appel seuil(0.008) il y a quelques changements :

0,498s : NumWorks N0110 (32 bits : Cortex-M7/ARMv7 @216MHz)
0,785s : NumWorks N0100 (32 bits : Cortex-M4/ARMv7 @100MHz)
2,19s : Casio Graph 35+E II (32 bits : SH4 ~~@58,98MHz~~ overclocké @274,91MHz via Ftune3 avec l'interpréteur C.Basic)
2,23s : Casio Graph 35/75+E (32 bits : SH4 ~~@29,49MHz~~ overclocké @267,78MHz via Ftune2 avec l'interpréteur C.Basic)
2,37s : Casio Graph 90+E (32 bits : SH4 @117,96MHz ~~@58,98MHz~~ overclocké @274,91MHz via Ptune3 avec l'interpréteur C.Basic)
3,75s : Casio Graph 90+E (32 bits : SH4 @117,96MHz avec l'interpréteur C.Basic)
11,11s : Casio Graph 35+E II (32 bits : SH4 @58,98 avec l'interpréteur C.Basic)
11,26s : TI-Nspire CX II (32 bits : ARM9/ARMv5 @396MHz)
12,9s : Casio Graph 35/75+E (32 bits : SH4 @29,49MHz avec l'interpréteur C.Basic)
16,3s : TI-Nspire (32 bits : ARM9/ARMv5 overclocké ~~@120MHz~~ @150MHz via Nover)
16,51s : HP Prime G2 (32 bits : Cortex-A7/ARMv7 @528MHz)
20,32s : TI-Nspire (32 bits : ARM9/ARMv5 @120MHz)
23,6s : TI-Nspire CX CR4+ (révisions W+) (32 bits : ARM9/ARMv5 ~~@156MHz~~ overclocké @216MHz via Nover)
24,45s : TI-Nspire CX (révisions A-V) (32 bits : ARM9/ARMv5 ~~@132MHz~~ overclocké @222MHz via Nover)
25,23s : TI-Nspire CX CR4+ (révisions W+) (32 bits : ARM9/ARMv5 @156MHz)
25,26s : Casio Graph 35/75+E (32 bits : SH4 ~~@29,49MHz~~ overclocké @267,78MHz via Ftune2)
28,42s : TI-Nspire CX (révisions A-V) (32 bits : ARM9/ARMv5 @132MHz)
29,31s : Casio Graph 35+E II (32 bits : SH4 ~~@58,98MHz~~ overclocké @274,91MHz via Ftune3)
38,15s : Casio Graph 90+E (32 bits : SH4 ~~@117,96MHz~~ overclocké @270,77MHz via Ptune3)
43,13s : HP Prime G1 (32 bits : ARM9/ARMv5 @400MHz)
50,77s : Casio Graph 90+E (32 bits : SH4 @117,96MHz)
81,03s : Casio Graph 35+E II (32 bits : SH4 @58,98MHz)
104,05s : Casio Graph 35/75+E (32 bits : SH4 @29,49MHz)
119,57s : Casio Graph 25+E (32 bits : SH4 @29,49MHz)
152,27s : TI-83 Premium CE Edition Python / TI-84 Plus CE-T (révisions M+) (8 bits : eZ80 @48MHz)
262,82s : TI-82 Advanced / TI-84 Plus T (8 bits : z80 @15MHz)
311,51s : TI-83 Premium CE / TI-84 Plus CE-T (révisions A-L) (8 bits : eZ80 @48MHz accéléré via AWSC)
355,52s : TI-83 Premium CE / TI-84 Plus CE-T (révisions A-L) (8 bits : eZ80 @48MHz)
672,65s : Casio fx-92+ Spéciale Collège (8 bits : nX-U8/100 >1,5MHz - spécifications ancien modèle fx-92 Collège 2D+, non confirmées sur le nouveau)
≈798,18s : Esquisse GCEXFR / Lexibook GC3000FR (non programmable, estimation relative par comparaison des performances en tracé de graphes avec le modèle le plus proche technologiquement, la TI-82 Advanced)
9297,47s : Casio fx-CP400+E (32 bits : SH4 @117,96MHz)

Avec le même script, passons maintenant sur l'évaluateur Python lorsque disponible. L'appel seuil(0.008) nous donne :

0,27s : TI-Nspire CX (révisions A-V) (32 bits : ARM9/ARMv5 ~~@132MHz~~ overclocké @222MHz via Nover avec l'interpréteur MicroPython)
0,376s : HP Prime G2 (32 bits : Cortex-A7/ARMv7 @528MHz)
0,38s : TI-Nspire (32 bits : ARM9/ARMv5 overclocké ~~@120MHz~~ @150MHz via Nover avec l'interpréteur MicroPython)
0,47s : TI-Nspire (32 bits : ARM9/ARMv5 @120MHz avec l'interpréteur MicroPython)
0,48s : TI-Nspire CX (révisions A-V) (32 bits : ARM9/ARMv5 @132MHz avec l'interpréteur MicroPython)
0,498s : NumWorks N0110 (32 bits : Cortex-M7/ARMv7 @216MHz)
0,53s : TI-Nspire CX CR4+ (révisions W+) (32 bits : ARM9/ARMv5 ~~@156MHz~~ overclocké @216MHz via Nover avec l'interpréteur MicroPython)
0,59s : Casio Graph 35/75+E (32 bits : SH4 ~~@29,49MHz~~ overclocké @267,78MHz via Ftune2 avec l'interpréteur CasioPython)
0,68s : TI-Nspire CX CR4+ (révisions W+) (32 bits : ARM9/ARMv5 @156MHz avec l'interpréteur MicroPython)
0,785s : NumWorks N0100 (32 bits : Cortex-M4/ARMv7 @100MHz)
0,79s : Casio Graph 35+E II (32 bits : SH4 ~~@58,98MHz~~ overclocké @274,91MHz via Ftune3 avec l'interpréteur CasioPython)
1,61s : HP Prime G1 (32 bits : ARM9/ARMv5 @400MHz)
1,86s : Casio Graph 35+E II (32 bits : SH4 ~~@58,98MHz~~ overclocké @274,91MHz via Ftune3)
2,15s : Casio Graph 90+E (32 bits : SH4 ~~@117,96MHz~~ overclocké @270,77MHz via Ptune3)
2,96s : Casio Graph 35+E II (32 bits : SH4 ~~@58,98MHz~~ overclocké @274,91MHz via Ftune3 avec l'interpréteur KhiCAS)
3,27s : Casio Graph 90+E (32 bits : SH4 @117,96MHz)
3,65s : Casio Graph 90+E (32 bits : SH4 ~~@117,96MHz~~ overclocké @270,77MHz via Ptune3 avec l'interpréteur KhiCAS)
3,73s : TI-83 Premium CE + module externe TI-Python (8 + 32 bits : eZ80 @48MHz + Cortex-M0+/ARMv6 @48MHz)
3,9s : Casio Graph 35+E II (32 bits : SH4 @58,98 avec l'interpréteur CasioPython)
3,93s : TI-83 Premium CE Edition Python (8 + 32 bits : eZ80 @48MHz + Cortex-M0+/ARMv6 @48MHz)
4s : Casio Graph 35/75+E (32 bits : SH4 @29,49MHz avec l'interpréteur CasioPython)
4,4s : TI-83 Premium CE + module externe TI-Python (8 + 32 bits : eZ80 @48MHz + Cortex-M0+/ARMv6 @48MHz avec firmware CircuitPython)
5,48s : Casio Graph 90+E (32 bits : SH4 @117,96MHz avec l'interpréteur KhiCAS)
9,21s : Casio Graph 35+E II (32 bits : SH4 @58,98MHz)
13,93s : Casio Graph 35+E II (32 bits : SH4 @58,98MHz avec l'interpréteur KhiCAS)

Mais contrairement à la plupart des langages historiques, le Python distingue les nombres entiers des nombres flottants. Voici donc un script pour tester les calculs entiers en Python :

Code: Select all: try:from time import monotonic except:pass def hastime(): try: monotonic() return True except:return False def nodivisorin(n,l): for k in l: if n//k*k==n: return False return True def isprimep(n): t=hastime() s,l,k=0 or t and monotonic(),[3],7 if n==2 or n==5:return True if int(n)!=n or n//2*2==n or n//5*5==5: return False if n<k:return n in l while k*k<n: if nodivisorin(k,l):l.append(k) k+=2+2*((k+2)//5*5==k+2) r=nodivisorin(n,l) return (t and monotonic() or 1)-s,r

L'appel isprimep(10000019) nous donne donc le classement suivant en calcul entier :

0,42s : TI-Nspire CX (révisions A-V) (32 bits : ARM9/ARMv5 ~~@132MHz~~ overclocké @222MHz via Nover avec l'interpréteur MicroPython)
0,57s : TI-Nspire (32 bits : ARM9/ARMv5 overclocké ~~@120MHz~~ @150MHz via Nover avec l'interpréteur MicroPython)
0,58s : Casio Graph 35/75+E (32 bits : SH4 ~~@29,49MHz~~ overclocké @267,78MHz via Ftune2 avec l'interpréteur CasioPython)
0,581s : NumWorks N0110 (32 bits : Cortex-M7/ARMv7 @216MHz)
0,59s : Casio Graph 35+E II (32 bits : SH4 ~~@58,98MHz~~ overclocké @274,91MHz via Ftune3 avec l'interpréteur CasioPython)
0,62s : TI-Nspire CX (révisions A-V) (32 bits : ARM9/ARMv5 @132MHz avec l'interpréteur MicroPython)
0,63s : TI-Nspire CX CR4+ (révisions W+) (32 bits : ARM9/ARMv5 ~~@156MHz~~ overclocké @216MHz via Nover avec l'interpréteur MicroPython)
0,67s : TI-Nspire (32 bits : ARM9/ARMv5 @120MHz avec l'interpréteur MicroPython)
0,86s : Casio Graph 35+E II (32 bits : SH4 ~~@58,98MHz~~ overclocké @274,91MHz via Ftune3)
0,99s : TI-Nspire CX CR4+ (révisions W+) (32 bits : ARM9/ARMv5 @156MHz avec l'interpréteur MicroPython)
1,08s : Casio Graph 90+E (32 bits : SH4 ~~@117,96MHz~~ overclocké @270,77MHz via Ptune3)
1,17s : NumWorks N0100 (32 bits : Cortex-M4/ARMv7 @100MHz)
1,58s : Casio Graph 90+E (32 bits : SH4 @117,96MHz)
3,02s : Casio Graph 35+E II (32 bits : SH4 @58,98 avec l'interpréteur CasioPython)
4,39s : Casio Graph 35+E II (32 bits : SH4 @58,98MHz)
4,42s : HP Prime G2 (32 bits : Cortex-A7/ARMv7 @528MHz)
4,98s : Casio Graph 35/75+E (32 bits : SH4 @29,49MHz avec l'interpréteur CasioPython)
8,1s : TI-83 Premium CE + module externe TI-Python (8 + 32 bits : eZ80 @48MHz + Cortex-M0+/ARMv6 @48MHz)
9s : TI-83 Premium CE Edition Python (8 + 32 bits : eZ80 @48MHz + Cortex-M0+/ARMv6 @48MHz)
11,26s : TI-83 Premium CE + module externe TI-Python (8 + 32 bits : eZ80 @48MHz + Cortex-M0+/ARMv6 @48MHz avec firmware CircuitPython)
16,05s : HP Prime G1 (32 bits : ARM9/ARMv5 @400MHz)
19,06s : Casio Graph 35+E II (32 bits : SH4 ~~@58,98MHz~~ overclocké @274,91MHz via Ftune3 avec l'interpréteur KhiCAS)
22,77s : Casio Graph 90+E (32 bits : SH4 ~~@117,96MHz~~ overclocké @270,77MHz via Ptune3 avec l'interpréteur KhiCAS)
32,76s : Casio Graph 90+E (32 bits : SH4 @117,96MHz avec l'interpréteur KhiCAS)
91,71s : Casio Graph 35+E II (32 bits : SH4 @58,98MHz avec l'interpréteur KhiCAS)

Avant de conclure, une petite page de publicité pour la plus grande arnaque jamais vendue parmi les calculatrices graphiques en rayon scolaire :

Si les performances ont de l'importance pour toi, les meilleurs choix sont donc :

la NumWorks N0110 pour les performances générales
la TI-Nspire CX (révision A-V) pour le Python (hors mode examen uniquement )
la HP Prime G2 pour le Python en mode examen

Le meilleur compromis de performances semble être la NumWorks N0110, dans le sens où contrairement aux autres elle ne s'effondre pas dans les classements où elle n'est pas première, et en prime sans aucun besoin d'installation d'application additionnelle ou d'overclocking !

Citons également la Casio Graph 35+E II qui, munie des bons outils hors mode examen (CasioPython et Ftune3) s'en sort remarquablement bien par rapport à son prix, d'environ ~60€ seulement, sur lequel Casio te rembourse en prime 10€ pour tout achat à neuf d'ici le 30 septembre !

A très bientôt pour le classement final de rentrée 2019 à la fois pour les BAC 2020 et 2021+ !

→ **MyCalcs** profile · by **critor** » 07 Sep 2019, 14:09

Voici un diagramme pour la première moitié de l'épisode, avec les performances générales (langage historique) de chaque machine en modes numérique et exact :

On voit un peu mieux qui c'est qui sort du lot; le couple NumWorks/HP qui se bât pour la première place, suivi de près par Casio, puis Texas Instruments, puis Lexibook/Esquisse/Leclerc.

→ **MyCalcs** profile · by **critor** » 07 Sep 2019, 15:00

Et maintenant le même diagramme pour les performances Python, contextes flottants et entiers :

→ **MyCalcs** profile · by **reminoel** » 07 Sep 2019, 18:47

Bonjour,
2 petites coquilles dans la fonction isprimep:
la ligne 20 doit se terminer par "==n:"
et la ligne 23 doit avoir un "<=".
Cordialement.

→ **MyCalcs** profile · by **critor** » 07 Sep 2019, 19:01

Ah, merci beaucoup.

Par contre je n'ai pas le temps là de refaire toute la batterie de tests.

Je prendrai donc le script corrigé pour les tests futurs : en cours d'année si il y a des nouveautés, ou sinon pour la rentrée 2020.

→ **MyCalcs** profile · by **parisse** » 07 Sep 2019, 19:22

A vrai dire, j'ai beaucoup de mal a comprendre la fonction isprimep. Pourquoi ne pas avoir teste :

Code: Select all: def isprimep(x): for k in range(2,x): if k*k>x: return True if x % k == 0: return False return x==2

C'est beaucoup plus simple tout en testant aussi multiplication et division euclidienne, c'est significativement plus rapide (tout en restant tres lent par rapport a d'autres tests de primalite puisque c'est une methode naive).
Ou alors faire un test de Miller-Rabin, qui permet de tester des operations sur des entiers de taille plus grande.

→ **MyCalcs** profile · by **critor** » 07 Sep 2019, 19:49

Bonsoir.

La fonction saute les multiples de 2 et de 5 dans ses tests.

En fait elle était prévue pour construire et retourner la liste des diviseurs.
Sauf que j'ai supprimé ce retour, car la NumWorks avec ses 16K de mémoire de travail ne retournait alors rien d'autre qu'une erreur de mémoire sur le genre de nombres de l'exemple.

Elle n'est volontairement pas prévue pour être optimale. En effet si les tests se terminent tous en une fraction de seconde, il eut été dur de faire un classement précis.

→ **MyCalcs** profile · by **reminoel** » 07 Sep 2019, 19:54

La fonction isprimep de Critor est fondée sur le crible d'Erathostène, il est vrai plutôt adapté aux listes de nombres premiers qu'à un test de primalité. Mais pour tester la vitesse des calculatrices, cela ne me semble pas gênant...

→ **MyCalcs** profile · by **parisse** » 08 Sep 2019, 06:54

reminoel wrote:La fonction isprimep de Critor est fondée sur le crible d'Erathostène, il est vrai plutôt adapté aux listes de nombres premiers qu'à un test de primalité. Mais pour tester la vitesse des calculatrices, cela ne me semble pas gênant...

Ce n'est pas non plus comme cela que je pense qu'il faut programmer le crible, en tout cas si on suit le principe de barrer les multiples de 2, puis de 3, puis de 5, etc. (http://fr.wikipedia.org/wiki/Crible_d%27%C3%89ratosth%C3%A8ne), dans un crible la boucle interieure ne contient pas de divisions euclidiennes, seulement des additions (ici implicites dans la boucle for/range) :

Code: Select all: def premiers(n): prem=list(range(0,n)) k=2 while k*k<n : for j in range(2*k,n,k): prem[j]=0 k += 1 while prem[k]==0: k += 1 return [k for k in prem if k!=0]

Les algorithmes vont etre lus par des lyceens et par des enseignants, il est dommage de ne pas utiliser des algorithmes comprehensibles et raisonnablement optimaux, il suffit ensuite d'adapter la taille de l'argument pour avoir le temps d'execution souhaitable pour mesurer les performances des calculatrices (disons de l'ordre de quelques secondes).

→ **MyCalcs** profile · by **parisse** » 08 Sep 2019, 07:27

critor wrote:La fonction saute les multiples de 2 et de 5 dans ses tests.

En fait elle était prévue pour construire et retourner la liste des diviseurs.

Je ne comprends pas bien comment votre algorithme fonctionne pour construire une liste de diviseurs.

L'optimisation habituelle pour tester la primalite par division naive consiste a travailler modulo 6, on teste d'abord la divisibilite par 2, 3 et 5, puis pour k>=1 les nombres de la forme 6*k+1 et 6*k+5 (en effet 6*k, 6*k+2, 6*k+3 et 6*k+4 ne sont pas premiers si k>=1). Bien sur on pourrait aussi travailler modulo 10, en testant 2, 3, 5, 7 puis les nombres de la forme 10*k+1, 10*k+3, 10*k+7, 10*k+9, mais c'est moins efficace car cela fait tester 4 entiers sur 10, alors que modulo 6 on est a 1 entier sur 3.