TI-Planet | News

de **critor** » 19 Aoû 2021, 14:09

Quelle Calculatrice Choisir 2021 édition Universelle

Épisode 7 - Performances générales

Pour fêter les 10 ans de TI-Planet en cette rentrée 2021, nous te publions la base de données intégrale de nos classements de rentrée QCC organisés depuis la rentrée 2015.

Nous en profitons de plus pour te réaliser le travail titanesque d'étendre les tests aux modèles plus anciens :

toutes les calculatrices graphiques Texas Instruments (depuis la première TI-81 de 1990)
toutes les calculatrices graphiques Casio à technologie Flash (depuis 2003)

Ce qui donne pas moins de 136 modèles différents de calculatrices testés sous toutes leurs coutures, 10 ans de tests et découvertes à portée de clic !

Aujourd'hui, commençons à parler performances.

Nous effectuerons jusqu'à 2 tests, lorsque possible, et chronométrerons leur durée :

un test avec un gros calcul
un test avec un programme

Le test avec le programme ne concernera pour le moment que les langages constructeur/historiques, pas le Python. En effet sur nombre de modèles l'application en question ne bénéficie pas d'une intégration à l'environnement de la calculatrice, mais tourne à part dans son coin, souvent sans pouvoir échanger/partager de données. Elle n'est donc pas représentative des performances générales du logiciel de la calculatrice.

Pour les modèles disposant d'un moteur de calcul exact, littéral ou même formel (CAS), les deux tests seront effectués en mode de calcul décimal.

Certains modèles comme les Lexibook GC3000FR et Esquisse GCEXFR sont tellement limités en capacités qu'ils ne remplissent même pas les conditions pour passer un seul de ces deux tests.

Commençons par le test de performances via un calcul. Pour les modèles disposant de l'opérateur de sommation, nous retenons le calcul développé par pier4r sur HP Museum, en mode degrés :

$mathjax$\sum\limits_{x=1}^{1000}{\sqrt[3]{e^{sin\left(Arctan\left(x\right)\right)}}}$mathjax$

Pour les modèles plus puissants terminant le calcul parfois avant même que l'on ait le temps de relâcher la dernière touche, la borne supérieure de la somme sera augmentée, et le temps mesuré corrigé en conséquence par proportionnalité.

Pour la fx-92+ Spéciale Collège qui ne dispose pas de l'opérateur de sommation, nous testerons à la place le modèle haut de gamme allemand fx-991DE X utilisant exactement le même matériel.

Voici dès maintenant le classement des modèles selon leurs performances sur ce calcul :

sans
overclock avec
overclock

0,130s : HP Prime G2 (32 bits : Cortex-A7/ARMv7 @528MHz)
0,448s : HP Prime G1 (32 bits : ARM9/ARMv5 @400MHz)
0,997s : TI-Nspire CX II (32 bits : ARM9/ARMv5 @396MHz)
1,481s : NumWorks N0110 (32 bits : Cortex-M7/ARMv7 @216MHz)
2,069s : NumWorks N0100 (32 bits : Cortex-M4/ARMv7 @100MHz)
2,119s : TI-Nspire (32 bits : ARM9/ARMv5 @120MHz)
2,256s : TI-Nspire CX (révisions W+) (32 bits : ARM9/ARMv5 @156MHz)
2,604s : TI-Nspire CX (révisions ≤V) (32 bits : ARM9/ARMv5 @132MHz)
6,330s : Casio fx-CP400 (32 bits : SH4 @117,96MHz)
8,550s : Casio Graph 90+E (32 bits : SH4 @117,96MHz)
13,15s : TI-84 Plus CE-T Python Edition / TI-84 Plus CE-T (révisions M+) (8 bits : eZ80 @48MHz)
13,59s : Casio Graph 25+E II (32 bits : SH4 @58,98MHz)
13,76s : TI-82 Advanced Edition Python (8 bits : eZ80 @48MHz)
14,11s : Casio Graph 35+E II (32 bits : SH4 @58,98MHz)
14,11s : TI-83 Premium CE Edition Python (8 bits : eZ80 @48MHz)
20,11s : Casio Graph 25+E (32 bits : SH4 @29,49MHz)
23,05s : Casio Graph 35/75+E (32 bits : SH4 @29,49MHz)
36,05s : TI-84 Plus CE-T (révisions ≤L) (8 bits : eZ80 @48MHz)
36,99s : TI-83 Premium CE (8 bits : eZ80 @48MHz)
52,79s : TI-84 Plus T (8 bits : z80 @15MHz)
56,25s : TI-82 Advanced (8 bits : z80 @15MHz)
108,6s : Casio fx-92+ Spéciale Collège (8 bits : nX-U8/100 @?MHz)

0,130s : HP Prime G2 (32 bits : Cortex-A7/ARMv7 @528MHz)
0,448s : HP Prime G1 (32 bits : ARM9/ARMv5 @400MHz)
0,609s : TI-Nspire CX II (32 bits : ARM9/ARMv5 ~~396MHz~~ overclocké @480MHz NoverII)
1,481s : NumWorks N0110 (32 bits : Cortex-M7/ARMv7 @216MHz)
1,571s : TI-Nspire (32 bits : ARM9/ARMv5 ~~@120MHz~~ overclocké @150MHz Nover)
1,857s : TI-Nspire CX (révisions ≤V) (32 bits : ARM9/ARMv5 ~~@132MHz~~ overclocké @222MHz Nover)
1,992s : TI-Nspire CX (révisions W+) (32 bits : ARM9/ARMv5 ~~@156MHz~~ overclocké @216MHz Nover)
2,069s : NumWorks N0100 (32 bits : Cortex-M4/ARMv7 @100MHz)
3,220s : Casio Graph 35/75+E (32 bits : SH4 ~~@29,49MHz~~ overclocké @267,78MHz Ftune2)
4,320s : Casio Graph 35+E II (32 bits : SH4 ~~@58,98MHz~~ overclocké @274,91MHz Ftune3)
5,240s : Casio Graph 90+E (32 bits : SH4 ~~@117,96MHz~~ overclocké @270,77MHz Ptune3)
6,330s : Casio fx-CP400 (32 bits : SH4 @117,96MHz)
13,15s : TI-84 Plus CE-T Python Edition / TI-84 Plus CE-T (révisions M+) (8 bits : eZ80 @48MHz)
13,59s : Casio Graph 25+E II (32 bits : SH4 @58,98MHz)
13,76s : TI-82 Advanced Edition Python (8 bits : eZ80 @48MHz)
14,11s : TI-83 Premium CE Edition Python (8 bits : eZ80 @48MHz)
20,11s : Casio Graph 25+E (32 bits : SH4 @29,49MHz)
26,75s : TI-84 Plus CE-T (révisions ≤L) (8 bits : eZ80 @48MHz accéléré AWSC)
31,97s : TI-83 Premium CE (8 bits : eZ80 @48MHz accéléré AWSC)
52,79s : TI-84 Plus T (8 bits : z80 @15MHz)
56,25s : TI-82 Advanced (8 bits : z80 @15MHz)
108,6s : Casio fx-92+ Spéciale Collège (8 bits : nX-U8/100 @?MHz)

Maintenant sur les modèles programmables, nous allons programmer un algorithme de seuil sur une suite numérique, niveau Première, programme que nous te transcrivons ici en Python à des fins de lisibilité :

Code: Tout sélectionner: def seuil(d): n = 0 u = 2. d = d**2 while (u-1)**2 >= d: u = 1 + 1/((1-u) * (n+1)) n = n + 1 return [n, u]

Nous appellerons seuil(0.008).

Mais comme dit plus haut, ce code sera donc transcrit ligne à ligne dans le langage de programmation historique de chaque constructeur, bien souvent du Basic.

Et voilà le classement des modèles selon leurs performances sur le programme de seuil :

sans
overclock avec
overclock

0,690s : HP Prime G2 (32 bits : Cortex-A7/ARMv7 @528MHz)
2,410s : HP Prime G1 (32 bits : ARM9/ARMv5 @400MHz)
8,930s : TI-Nspire CX II (32 bits : ARM9/ARMv5 @396MHz)
12,24s : TI-Nspire (32 bits : ARM9/ARMv5 @120MHz)
18,94s : TI-Nspire CX (révisions W+) (32 bits : ARM9/ARMv5 @156MHz)
20,92s : TI-Nspire CX (révisions ≤V) (32 bits : ARM9/ARMv5 @132MHz)
50,77s : Casio Graph 90+E (32 bits : SH4 @117,96MHz)
73,50s : Casio Graph 25+E II (32 bits : SH4 @58,98MHz)
81,03s : Casio Graph 35+E II (32 bits : SH4 @58,98MHz)
93,19s : TI-82 Advanced Edition Python (8 bits : eZ80 @48MHz)
94,26s : TI-84 Plus CE-T Python Edition / TI-84 Plus CE-T (révisions M+) (8 bits : eZ80 @48MHz)
98,64s : TI-83 Premium CE Edition Python (8 bits : eZ80 @48MHz)
101,1s : Casio Graph 35/75+E (32 bits : SH4 @29,49MHz)
119,6s : Casio Graph 25+E (32 bits : SH4 @29,49MHz)
194,4s : TI-84 Plus CE-T (révisions ≤L) (8 bits : eZ80 @48MHz)
196,8s : TI-83 Premium CE (8 bits : eZ80 @48MHz)
255,9s : TI-84 Plus T (8 bits : z80 @15MHz)
260,4s : TI-82 Advanced (8 bits : z80 @15MHz)
607.9s : Casio fx-CP400 (32 bits : SH4 @117,96MHz)
672,7s : Casio fx-92+ Spéciale Collège (8 bits : nX-U8/100 @?MHz)

0,690s : HP Prime G2 (32 bits : Cortex-A7/ARMv7 @528MHz)
2,410s : HP Prime G1 (32 bits : ARM9/ARMv5 @400MHz)
7,690s : TI-Nspire CX II (32 bits : ARM9/ARMv5 ~~396MHz~~ overclocké @480MHz NoverII)
10,02s : TI-Nspire (32 bits : ARM9/ARMv5 ~~@120MHz~~ overclocké @150MHz Nover)
18,64s : TI-Nspire CX (révisions W+) (32 bits : ARM9/ARMv5 ~~@156MHz~~ overclocké @216MHz Nover)
19,56s : TI-Nspire CX (révisions ≤V) (32 bits : ARM9/ARMv5 ~~@132MHz~~ overclocké @222MHz Nover)
23,26s : Casio Graph 35/75+E (32 bits : SH4 ~~@29,49MHz~~ overclocké @267,78MHz Ftune2)
26,36s : Casio Graph 35+E II (32 bits : SH4 ~~@58,98MHz~~ overclocké @274,91MHz Ftune3)
38,33s : Casio Graph 90+E (32 bits : SH4 ~~@117,96MHz~~ overclocké @270,77MHz Ptune3)
73,50s : Casio Graph 25+E II (32 bits : SH4 @58,98MHz)
93,19s : TI-82 Advanced Edition Python (8 bits : eZ80 @48MHz)
94,26s : TI-84 Plus CE-T Python Edition / TI-84 Plus CE-T (révisions M+) (8 bits : eZ80 @48MHz)
98,64s : TI-83 Premium CE Edition Python (8 bits : eZ80 @48MHz)
119,6s : Casio Graph 25+E (32 bits : SH4 @29,49MHz)
169,5s : TI-84 Plus CE-T (révisions ≤L) (8 bits : eZ80 @48MHz accéléré AWSC)
171,3s : TI-83 Premium CE (8 bits : eZ80 @48MHz accéléré AWSC)
255,9s : TI-84 Plus T (8 bits : z80 @15MHz)
260,4s : TI-82 Advanced (8 bits : z80 @15MHz)
607.9s : Casio fx-CP400 (32 bits : SH4 @117,96MHz)
672,7s : Casio fx-92+ Spéciale Collège (8 bits : nX-U8/100 @?MHz)

Deux indices de performances représentant chacun de ces deux tests sont dès maintenant disponibles, également pour les modèles plus anciens que nous avions encore sous la main :

Accès QCC 2021 Universel

de **critor** » 20 Aoû 2021, 12:45

Quelle Calculatrice Choisir 2021 édition Universelle

Épisode 8 - Écrans et profondeurs

Pour fêter les 10 ans de TI-Planet en cette rentrée 2021, nous te publions la base de données intégrale de nos classements de rentrée QCC organisés depuis la rentrée 2015.

Nous en profitons de plus pour te réaliser le travail titanesque d'étendre les tests aux modèles plus anciens :

toutes les calculatrices graphiques Texas Instruments (depuis la première TI-81 de 1990)
toutes les calculatrices graphiques Casio à technologie Flash (depuis 2003)

Ce qui donne pas moins de 136 modèles différents de calculatrices testés sous toutes leurs coutures, 10 ans de tests et découvertes à portée de clic !

L'écran est décidément un élément incontournable de ta calculatrice graphique. Après avoir couvert dans des épisodes précédents ses dimensions, définition et zone graphique, nous allons aujourd'hui traiter de sa profondeur, c'est-à-dire du nombre de couleurs différentes qu'il permet d'afficher.

Commençons par enfoncer les portes ouvertes, avec les modèles dont le contrôleur écran ne gère que 1 bit de profondeur, ne permettant donc que 2¹= 2 couleurs différentes.

D'une part, voici les modèles à cristaux liquides bleus souffrant en conséquence d'une lisibilité assez pénible sans un excellent éclairage extérieur :

Esquisse GCEXFR
Lexibook GC3000FR
Casio Graph 25+E

Et voici les modèles à cristaux liquides noirs, de bien meilleure lisibilité :

Casio Graph 25+E II
Casio Graph 35+E
Casio Graph 35+E II
Casio Graph 75+E
TI-82 Advanced
TI-84 Plus T
Casio fx-92+ Spéciale Collège

Passons maintenant aux choses intéressantes ; nous allons te présenter notre protocole de test.

Notre idée est donc d'afficher une mire avec des dégradés des composantes primaires rouge-vert-bleu, afin de déterminer le nombre de bits utilisés par chacune.

Il y a 2 façons de coder les couleurs dans le contexte des pixels en Python :

soit avec un tuple (r,g,b) décrivant les valeurs de chaque composante primaire rouge-vert-bleu par un entier de 0 à 255
soit par un nombre entier qui sera directement la valeur fournie au contrôleur écran

Prévoyons une fonction pour tester le codage utilisé, par simple vérification du type de retour d'une lecture de pixel.
Dans le cas d'un retour de type entier, tentons de plus en passant de détecter le nombre de bits gérés par le contrôleur écran, en écrivant des valeurs de pixels de plus en plus grandes et vérifiant à chaque fois si le pixel concerné a bien pris la valeur en question.

Code: Tout sélectionner: #0: (R,G,B) >0: RGB-bits def get_color_mode(): c = get_pixel(0, 0) try: c[2] return 0 except: b, v = 0, 1 x, y = 0, sy0 set_pixel(x, y, v) while get_pixel(x, y) == v: b += 1 v *= 2 set_pixel(x, y, v) return b

Un appel color_mode = get_color_mode() pourra donc renvoyer par exemple :

0 : pour un codage des couleurs par des tuples (r,g,b)
15 : pour un codage des couleurs sur des entiers de 15 bits
16 : pour un codage des couleurs sur des entiers de 16 bits
24 : pour un codage des couleurs sur des entiers de 24 bits
...

Pour notre script universel il faudra bien choisir un codage plutôt qu'un autre, alors prévoyons une fonction de conversion :

Code: Tout sélectionner: def fixcolor(c, bits=16): try: if not color_mode: return c r, g, b = c[0], c[1], c[2] except: if color_mode == bits: return c if bits == 16: br, bg, bb = 5, 6, 5 else: br, bg, bb = 8, 8, 8 r, g, b = c & (2**br - 1) * 2**(8 - br), c & ((2**bg - 1) * 2**br) // 2**br * 2**(8 - bg), c & ((2**bb - 1) * 2**(br + bg)) // 2**(br + bg) * 2**(8 - bb) if not color_mode: return (r, g, b) else: if color_mode == 16: br, bg, bb = 5, 6, 5 else: br, bg, bb = 8, 8, 8 r, g, b = r // 2**(8 - br), g // 2**(8 - bg) * 2**br, b // 2 **(8 - bb) * 2**(br + bg) c = r + g - (r & g) return c + b - (c & b)

Voici de quoi tracer des lignes verticales et horizontales :

Code: Tout sélectionner: def draw_vline(x, y1, y2, c): for j in range(y2 - y1 + 1): set_pixel(x, y1 + j, c) def draw_hline(y, x1, x2, c): for j in range(x2 - x1 + 1): set_pixel(x1 + j, y, c)

Et voici enfin notre code de tracé de la mire :

Code: Tout sélectionner: #o: 0=horizontal, 1=vertical #s: 0=no_shadow, 1=shadow left/up, -1=shadow right/down def mire(w, h, y0=0, s=1, o=0): if o: l1, l2, f, i1, i2 = h, w, draw_hline, y0, 0 else: l1, l2, f, i1, i2 = w, h, draw_vline, 0, y0 n = 8 for m in range(l1): v = 255 if s != 0: v = v * (s*m % l1) // (l1 - 1) for j in range(n): f(m + i1, j * l2 // n + i2, (j + 1) * l2 // n - 1 + i2, fixcolor(color8(j, v))) def color8(j, v): c = [0, 0, 0] for b in range(3): if j & 2**b: c[b] = v return c

Tu vas vite comprendre tout ça avec notre premier exemple.

Commençons donc par les TI-83 Premium CE Edition Python et TI-84 Plus CE-T Python Edition que nous allons tester en Python.
Nous considérerons que c'est pareil sur les anciennes TI-83 Premium CE et TI-84 Plus CE, ainsi que sur la nouvelle TI-82 Advanced Edition Python.

Ici les fonctions relatives aux pixels sont ti_graphic.getPixel(x,y) et ti_graphic.setPixel(x,y,couleur). Nous disposons comme déjà vu d'une zone graphique utile en Python de 320×210 pixels, accessibles à partir de y=30.

Cela ne t'apprendra sans doute rien mais histoire de vérifier que ça marche, d'après get_color_mode() sur TI-83 Premium CE Edition Python et TI-84 Plus CE Python Edition les couleurs de pixels sont codées en Python par des tuples (r,g,b).

Voici donc ci-contre l'affichage de l'appel associé mire(320,240,30). On peut noter que le vert ainsi que les couleurs composées de vert (cyan, jaune et blanc) ont un dégradé beaucoup moins saccadé, beaucoup plus fluide. En effet si tu regardes bien elles utilisent 2 fois plus de teintes intermédiaires, très exactement 64 teintes contre 32 pour les autres :

canal rouge sur 5 bits pour 2⁵= 32 teintes
canal vert sur 6 bits pour 2⁶= 64 teintes
canal bleu sur 5 bits pour 2⁵= 32 teintes

Total donc 16 bits pour 2¹⁶= 65536 couleurs affichables, et un contrôleur écran fonctionnant donc au format RGB 565.

Voici maintenant la Casio Graph 90+E et son superbe écran.

Les fonctions relatives aux pixels à utiliser sont casioplot.get_pixel(x,y) et casioplot.set_pixel(x,y,couleur). Nous disposons comme déjà vu en Python d'une zone graphique utile de 384×192 pixels.

Ici encore les paramètres de couleur sont passés sous forme de tuples (r,g,b).

Appelons donc mire(384,192). Même constat ici, nous notons 2 fois plus de teintes intermédiaires pour les dégradés de vert et de couleurs incluant du vert :

canal rouge sur 5 bits pour 2⁵= 32 teintes
canal vert sur 6 bits pour 2⁶= 64 teintes
canal bleu sur 5 bits pour 2⁵= 32 teintes

Total donc 16 bits pour 2¹⁶= 65536 couleurs affichables, et un contrôleur écran fonctionnant donc au format RGB 565.

Arrive maintenant la NumWorks.

Les fonctions de pixels sont kandinsky.get_pixel(x,y) et kandinsky.set_pixel(x,y,couleur). Avec l'application Python officielle, les paramètres de couleur prennent toujours la forme de tuples (r,g,b). La zone graphique utile en Python est ici de 320×222 pixels.

Appelons mire(320,222). Encore pareil, 2 fois plus de teintes intermédiaires dans le vert :

canal rouge sur 5 bits pour 2⁵= 32 teintes
canal vert sur 6 bits pour 2⁶= 64 teintes
canal bleu sur 5 bits pour 2⁵= 32 teintes

Total donc 16 bits pour 2¹⁶= 65536 couleurs affichables, et un contrôleur écran fonctionnant donc au format RGB 565.

Passons donc aux TI-Nspire CX II testables en Python.
Nous considérerons le résultat représentatif des anciennes TI-Nspire CX et TI-Nspire CM.

Les fonctions relatives aux pixels à utiliser sont ti_image.get_pixel(x,y) et ti_image.set_pixel(x,y,couleur). Nous disposons comme déjà vu en Python d'une zone graphique utile de 318×212 pixels.

Ici encore les paramètres de couleur sont passés sous forme de tuples (r,g,b).

Appelons donc mire(318,212). Toujours 2 fois plus de teintes intermédiaires tirant sur le vert :

canal rouge sur 5 bits pour 2⁵= 32 teintes
canal vert sur 6 bits pour 2⁶= 64 teintes
canal bleu sur 5 bits pour 2⁵= 32 teintes

Total donc 16 bits pour 2¹⁶= 65536 couleurs affichables, et un contrôleur écran fonctionnant donc au format RGB 565.

Sur les anciennes TI-Nspire monochromes, le langage interprété ne dispose hélas pas des fonctions de tracé.

Adaptons donc notre mire dans le langage de script Lua :

Code: Tout sélectionner: o = false s = 1 function on.charIn(c) print(c) olds, oldo = s, o if c == "−" or c == "-" then s = -1 elseif c == "+" then s = 1 elseif c == "0" then s = 0 elseif c == "*" or c == "/" then o = not o end if s ~= olds or o ~= oldo then platform.window.invalidate() end end function on.resize(w, h) platform.window.invalidate() end function color8(j, v) l={0, 0, 0} for k = 1, #l do if math.floor(j / 2^(k - 1)) % 2 ~= 0 then l[k] = v end end return l end function on.paint(gc) pw = platform.window w, h = pw.width(), pw.height() if o then l1, l2 = h, w function f(gc, y, x1, x2, c) gc:setColorRGB(c[1], c[2], c[3]) gc:drawRect(x1, y, x2, y) end else l1, l2 = w, h function f(gc, x, y1, y2, c) gc:setColorRGB(c[1], c[2], c[3]) gc:drawRect(x, y1, x, y2) end end n = 8 for m = 0, l1 - 1 do v = 255 if s ~=0 then v = v * (s * m % l1) / (l1 - 1) end for j = 0, n - 1 do f(gc, m, j * l2 / n, (j + 1)*l2/n - 1, color8(j, v)) end end end

Sur les TI-Nspire monochromes nous avons donc 4 bits pour 2⁴= 16 niveaux de gris.

Sur Casio fx-CP400+E nous ne pouvons hélas pas te programmer de mire.

En effet dans le langage interprété historique de la machine et seul langage qui nous est accessible, le paramètre de couleur des fonctions graphiques ne peut prendre que 7 valeurs différentes.

Alors plan B, générons et enregistrons notre mire sous forme d'image, et convertissons-la en image .c2p pour la calculatrice à l'aide de notre convertisseur en ligne.

Toujours le même résultat avec 2 fois plus de teintes intermédiaires dans les tons de vert :

canal rouge sur 5 bits pour 2⁵= 32 teintes
canal vert sur 6 bits pour 2⁶= 64 teintes
canal bleu sur 5 bits pour 2⁵= 32 teintes

Total donc 16 bits pour 2¹⁶= 65536 couleurs affichables, et un contrôleur écran fonctionnant donc au format RGB 565.

On peut remarquer un petit bug d'affichage dans le dégradé de bleu, comme si la teinte la plus claire avait été marquée en tant que couleur transparente.

Mais ce n'est pas un bug lié à notre convertisseur, nous obtenons exactement le même défaut en utilisant le logiciel de conversion officiel de Casio.

Et enfin nous arrive la HP Prime.

Nous y bénéficions en Python d'une formidable zone graphique de 320×240 pixels.

Le module Python hpprime nous offre de quoi écrire un pixel : pixon(numero_calque,x,y,couleur).

Il ne fournit pas directement de quoi lire un pixel, mais par contre une fonction eval() permettant de faire appel au langage constructeur HPPPL où cette fonction existe. On peut alors se redéfinir une fonction get_pixel() en Python :

Code: Tout sélectionner: def get_pixel(x, y): return int(eval("get_pixel(" + str(x) + "," + str(y) + ")"))

Ici c'est ainsi fantastique, l'appel mire(320,240) nous fournit des dégradés extrêmement fluides et ce peu importe la teinte !

canal rouge sur 8 bits pour 2⁸= 256 teintes
canal vert sur 8 bits pour 2⁸= 256 teintes
canal bleu sur 8 bits pour 2⁸= 256 teintes

Total donc 24 bits pour 2²⁴= 16777216 couleurs affichables, et un contrôleur écran fonctionnant donc au format RGB 888 !

Ces nouvelles mesures sont dès maintenant disponibles dans nos tableaux, ainsi que pour les modèles plus anciens :

Accès QCC 2021 Universel

de **critor** » 22 Aoû 2021, 09:45

Combien Consomme ma Calculatrice 2021

Épisode 8 - NumWorks, TI-Nspire CX, HP Prime
index des épisodes

Nous sommes en plein QCC 2021 Universel, événement au cours duquel nous te publions et alimentons la base de données intégrale de nos classements de rentrée QCC organisés depuis la rentrée 2015.

Nous t'avons également lancé un événement dans l'événement, le CCC 2021, pour Combien Consomme ma Calculatrice.

Jusqu'à présent, nous utilisions un protocole dédié aux seuls modèles fonctionnant sur piles AAA.

Et bien surprise, nous traitons dès aujourd'hui des modèles fonctionnant sur batterie rechargeable avec un tout nouveau protocole !

Nous allons alimenter nos calculatrices en USB, et mesurerons ce qu'elles consomment a l'aide d'un testeur USB.

Ici il s'agit donc d'une mesure ponctuelle que nous relèverons une fois stabilisée sous 3 situations :

Calculatrice éteinte
Calculatrice allumée mais inoccupée
Calculatrice en train d'effectuer un calcul suffisamment long
Nous choisissons en mode degrés :
$mathjax$\sum{\sqrt[3]{e^{sin\left(Arctan\left(x\right)\right)}}}$mathjax$

Ne pouvant effectuer de moyenne avec cet appareil, nous n'activerons pas le mode examen.

De plus, lorsque possible nous effectuerons les mesures sous différents réglages de la luminosité de l'écran :

maximal
minimal

En théorie, l'USB sert aussi bien à alimenter la calculatrice qu'à recharger sa batterie. Or nous souhaitons ici mesurer ce que fait consommer le fonctionnement de la calculatrice, et non la charge de la batterie.

Donc nous retirerons la batterie afin d'éliminer cette consommation parasite, voici ci-contre à quoi ressemble alors le protocole.

Aussi, lorsque la calculatrice est alimentée par un ordinateur ou tout autre hôte USB actif, il y a échange de données ce qui peut générer également des parasites. De plus dans ce contexte, les TI-Nspire CX II ralentissent même leur processeur, de 396 MHz à 288 MHz.

Ici encore pour éliminer toute consommation parasite faussant nos mesures et comparaisons, nous connecterons le tout à un simple adaptateur secteur et non à un ordinateur. Il n'y aura donc pas de communication USB.

Les TI-83 Premium CE et TI-84 Plus CE seront hélas exclues des tests et comparaisons cette année.

Ce protocole ne leur convient pas, elles s'éteignent dès que l'on retire la batterie, même avec une alimentation USB déjà présente.

Dans notre base de données QCC, les HP Prime sont scindées en 3 suite à des changements matériels d'importance, susceptibles d'influer sur la consommation :

HP Prime G1 révision A
HP Prime G1 révision C (mode USB hôte pour la gestion des périphériques USB)
HP Prime G2 révision D (nouveau processeur passant de 400 MHz à 528 MHz)

Nous effectuons donc les mesures sur une calculatrice de chaque :

HP Prime G1-A	éclairage minimal	éclairage maximal
éteinte	1.800 mA
inoccupée	72.400 mA	100.600 mA
calcul	111.000 mA	140.000 mA

HP Prime G1-C	éclairage minimal	éclairage maximal
éteinte	1.800 mA
inoccupée	67.500 mA	95.100 mA
calcul	107.400 mA	135.500 mA

HP Prime G2	éclairage minimal	éclairage maximal
éteinte	7.900 mA
inoccupée	118.800 mA	144.400 mA
calcul	124.300 mA	149.700 mA

En 10 ans de TI-Nspire CX nous avons ici aussi eu droit à plusieurs évolutions matérielles significatives. Notre base de données QCC scinde ces modèles en 4 :

TI-Nspire CX révisions ≤N
TI-Nspire CX révisions O-V (remplacement de la batterie à câble par une nouvelle batterie type Samsung)
TI-Nspire CX révisions W+ (accélération du processeur de 132 MHz à 156 MHz + nouvel écran)
TI-Nspire CX II (nouveau processeur passant de 156 MHz à 396 MHz)

Nous effectuons ici les mesures sur plusieurs calculatrices de chaque, et retenons la moyenne :

TI-Nspire CX rév.≤N	éclairage minimal	éclairage maximal
éteinte	35.000 mA
inoccupée	50.775 mA	92.550 mA
calcul	57.350 mA	99.350 mA

TI-Nspire CX rév.O-V	éclairage minimal	éclairage maximal
éteinte	38.600 mA
inoccupée	55.600 mA	63.500 mA
calcul	108.900 mA	116.700 mA

TI-Nspire CX rév.W+	éclairage minimal	éclairage maximal
éteinte	34.750 mA
inoccupée	51.750 mA	103.650 mA
calcul	60.750 mA	113.250 mA

TI-Nspire CX II	éclairage minimal	éclairage maximal
éteinte	49.033 mA
inoccupée	63.833 mA	110.667 mA
calcul	84.067 mA	131.233 mA

Et enfin, terminons avec les NumWorks. Nous les scindons en 2 :

NumWorks N0100
NumWorks N0110 (nouveau processeur passant de 100 MHz à 216 MHz)

Elles sont très embêtantes, dans le sens où il nous faut ici les démonter pour déconnecter la batterie. Mais le pire c'est sur la N0100 :

la batterie doit être déconnectée alors que la calculatrice est déjà allumée et alimentée en USB, sinon la machine démarre en mode de récupération avec l'écran éteint
de plus, au remontage, il suffit de serrer les vis d'une fraction de millimètre de trop pour fendre le boîtier tellement il est fragile

NumWorks N0100	éclairage minimal	éclairage maximal
éteinte	37.400 mA
inoccupée	61.600 mA	136.500 mA
calcul	81.500 mA	156.800 mA

NumWorks N0110	éclairage minimal	éclairage maximal
éteinte	64.400 mA
inoccupée	105.300 mA	194.700 mA
calcul	173.300 mA	262.500 mA

Et voilà, nous clôturons aujourd'hui le CCC 2021. Cette première édition nous a demandé beaucoup de travail et des heures de préparation (conception des protocoles, achat des éléments nécessaires, mesures...), nous espérons qu'elle t'a intéressé(e).

N'hésite pas à nous faire part de tes retours, à nous dire si l'événement serait à reproduire une autre année, ou encore à nous partager des suggestions d'améliorations des protocoles, aussi bien pour pouvoir inclure les calculatrices de la gamme CE que pour une meilleure précision.

Qui consomme le plus (ou le moins), tu as dès maintenant l'information dans notre base de données complétée. Mais n'oublie toutefois pas de tenir compte du type d'écran (monochrome ou couleur avec éclairage) lors de tes comparaisons.

Accès QCC 2021 Universel

Rapidement, parmi les modèles monochromes actuels sur piles :

le meilleur semble être les Casio Graph 25/35+E II
et le pire la TI-82 Advanced

Bien que les valeurs mesurées soient très proches, la différence se fera de plus en plus sentir avec le temps.

Parmi les modèles actuels à écran couleur éclairé :

le meilleur semble être de loin la Casio fx-CP400+E ou encore mieux la fantastique Graph 90+E
et le pire la NumWorks N0110, qui contrairement à son prédécesseur réussit le très regrettable exploit de battre le triste record de la HP Prime G2, avec pourtant un processeur aux performances ridicules en comparaison

Décidément, quelque soit le groupe de modèles comparés, les produits Casio semblent être les plus économiques et écologiques, félicitations !

C'est peut-être lié au label Green Star que Casio décerne en interne chaque année à ses produits les plus performants en terme de critères écologiques, dont les calculatrices Graph 35+E II en 2019 et fx-9860GIII en 2020.

de **critor** » 23 Aoû 2021, 10:02

Quelle Calculatrice Choisir 2021 édition Universelle

Épisode 9 - Performances Python

Pour fêter les 10 ans de TI-Planet en cette rentrée 2021, nous te publions la base de données intégrale de nos classements de rentrée QCC organisés depuis la rentrée 2015.

Nous en profitons de plus pour te réaliser le travail titanesque d'étendre les tests aux modèles plus anciens :

toutes les calculatrices graphiques Texas Instruments (depuis la première TI-81 de 1990)
les calculatrices graphiques Casio de la génération Icon Menu Power Graphic (depuis 1996)

Ce qui donne pas moins de 163 modèles différents testés sous toutes leurs coutures, 10 ans de tests et découvertes à portée de clic !

Aujourd'hui parlons à nouveau performances, mais en Python.

Contrairement aux langages constructeurs/historiques, Python distingue les nombres entiers des nombres flottants. Nous effectuerons 2 tests et chronométrerons leur durée :

un test de calcul en virgule flottante
un test de calcul sur des entiers

Dans un premier temps, nous allons évaluer les performances de calcul en virgule flottante. Voici la transcription en Python d'un algorithme de seuil sur une suite numérique, niveau Première :

Code: Tout sélectionner: 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 appellerons seuil(0.008).

en exam
officiel en exam
tiers en exam
tiers + overclock hors exam
officiel hors exam
tiers hors exam
tiers + overclock

0,087s : HP Prime G2 (32 bits : Cortex-A7/ARMv7 @528MHz Python)
0,258s : HP Prime G1 (32 bits : ARM9/ARMv5 @400MHz Python)
0,297s : TI-Nspire CX II (32 bits : ARM9/ARMv5 @396MHz)
0,376s : HP Prime G2 (32 bits : Cortex-A7/ARMv7 @528MHz CAS)
0,498s : NumWorks N0110 (32 bits : Cortex-M7/ARMv7 @216MHz)
0,785s : NumWorks N0100 (32 bits : Cortex-M4/ARMv7 @100MHz)
1,61s : HP Prime G1 (32 bits : ARM9/ARMv5 @400MHz CAS)
3,27s : Casio Graph 90+E (32 bits : SH4 @117,96MHz)
3,99s : TI-83 Premium CE Edition Python (8 + 32 bits : eZ80 @48MHz + Cortex-M0+/ARMv6 @48MHz)
4,01s : TI-82 Advanced Edition Python (8 + 32 bits : eZ80 @48MHz + Cortex-M0+/ARMv6 @48MHz)
9,21s : Casio Graph 35+E II (32 bits : SH4 @58,98MHz)

0,087s : HP Prime G2 (32 bits : Cortex-A7/ARMv7 @528MHz Python)
0,258s : HP Prime G1 (32 bits : ARM9/ARMv5 @400MHz Python)
0,297s : TI-Nspire CX II (32 bits : ARM9/ARMv5 @396MHz)
0,376s : HP Prime G2 (32 bits : Cortex-A7/ARMv7 @528MHz CAS)
0,609s : TI-Nspire CX (révisions A-V) (32 bits : ARM9/ARMv5 @132MHz - Ndless + KhiCAS Micropython)
0,498s : NumWorks N0110 (32 bits : Cortex-M7/ARMv7 @216MHz)
0,544s : NumWorks N0110 (Delta / Omega + KhiCAS Micropython)
0,785s : NumWorks N0100 (32 bits : Cortex-M4/ARMv7 @100MHz)
0,868s : TI-Nspire CX CR4+ (révisions W+) (32 bits : ARM9/ARMv5 @156MHz - Ndless + KhiCAS Micropython)
1,61s : HP Prime G1 (32 bits : ARM9/ARMv5 @400MHz CAS)
3,27s : Casio Graph 90+E (32 bits : SH4 @117,96MHz)
3,99s : TI-83 Premium CE Edition Python (8 + 32 bits : eZ80 @48MHz + Cortex-M0+/ARMv6 @48MHz)
4,01s : TI-82 Advanced Edition Python (8 + 32 bits : eZ80 @48MHz + Cortex-M0+/ARMv6 @48MHz)
5,45s : TI-Nspire CX (révisions A-V) (32 bits : ARM9/ARMv5 @132MHz - Ndless + KhiCAS compatibilité Python)
6,69s : NumWorks N0110 (Delta / Omega + KhiCAS compatibilité Python)
7,63s : TI-Nspire CX CR4+ (révisions W+) (32 bits : ARM9/ARMv5 @156MHz - Ndless + KhiCAS compatibilité Python
9,21s : Casio Graph 35+E II (32 bits : SH4 @58,98MHz)

0,087s : HP Prime G2 (32 bits : Cortex-A7/ARMv7 @528MHz Python)
0,258s : HP Prime G1 (32 bits : ARM9/ARMv5 @400MHz Python)
0,297s : TI-Nspire CX II (32 bits : ARM9/ARMv5 @396MHz)
0,376s : HP Prime G2 (32 bits : Cortex-A7/ARMv7 @528MHz CAS)
0,396s : TI-Nspire CX (révisions A-V) (32 bits : ARM9/ARMv5 ~~@132MHz~~ overclocké @222MHz Nover - Ndless + KhiCAS Micropython)
0,498s : NumWorks N0110 (32 bits : Cortex-M7/ARMv7 @216MHz)
0,544s : NumWorks N0110 (Delta / Omega + KhiCAS Micropython)
0,65s : TI-Nspire CX CR4+ (révisions W+) (32 bits : ARM9/ARMv5 ~~@156MHz~~ overclocké @216MHz Nover - Ndless + KhiCAS Micropython)
0,785s : NumWorks N0100 (32 bits : Cortex-M4/ARMv7 @100MHz)
1,61s : HP Prime G1 (32 bits : ARM9/ARMv5 @400MHz CAS)
3,27s : Casio Graph 90+E (32 bits : SH4 @117,96MHz)
3,99s : TI-83 Premium CE Edition Python (8 + 32 bits : eZ80 @48MHz + Cortex-M0+/ARMv6 @48MHz)
4,01s : TI-82 Advanced Edition Python (8 + 32 bits : eZ80 @48MHz + Cortex-M0+/ARMv6 @48MHz)
4,13s : TI-Nspire CX (révisions A-V) (32 bits : ARM9/ARMv5 ~~@132MHz~~ overclocké @222MHz Nover - Ndless + KhiCAS compatibilité Python)
6,69s : NumWorks N0110 (Delta / Omega + KhiCAS compatibilité Python)
7,19s : TI-Nspire CX CR4+ (révisions W+) (32 bits : ARM9/ARMv5 ~~@156MHz~~ overclocké @216MHz Nover - Ndless + KhiCAS compatibilité Python)
9,21s : Casio Graph 35+E II (32 bits : SH4 @58,98MHz)

0,087s : HP Prime G2 (32 bits : Cortex-A7/ARMv7 @528MHz Python)
0,258s : HP Prime G1 (32 bits : ARM9/ARMv5 @400MHz Python)
0,297s : TI-Nspire CX II (32 bits : ARM9/ARMv5 @396MHz)
0,376s : HP Prime G2 (32 bits : Cortex-A7/ARMv7 @528MHz CAS)
0,498s : NumWorks N0110 (32 bits : Cortex-M7/ARMv7 @216MHz)
0,785s : NumWorks N0100 (32 bits : Cortex-M4/ARMv7 @100MHz)
1,61s : HP Prime G1 (32 bits : ARM9/ARMv5 @400MHz CAS)
3,27s : Casio Graph 90+E / fx-CG50 (32 bits : SH4 @117,96MHz)
3,73s : TI-83 Premium CE + TI-Python (8 + 32 bits : eZ80 @48MHz + Cortex-M0+/ARMv6 @48MHz)
3,99s : TI-83 Premium CE Edition Python / TI-84 Plus CE Python Edition (8 + 32 bits : eZ80 @48MHz + Cortex-M0+/ARMv6 @48MHz)
4,01s : TI-82 Advanced Edition Python (8 + 32 bits : eZ80 @48MHz + Cortex-M0+/ARMv6 @48MHz)
9,21s : Casio Graph 35+E II / fx-9750/9860GIII (32 bits : SH4 @58,98MHz)

0,025s : TI-Nspire CX II (32 bits : ARM9/ARMv5 @396MHz - Ndless + KhiCAS Micropython)
0,087s : HP Prime G2 (32 bits : Cortex-A7/ARMv7 @528MHz Python)
0,232s : TI-Nspire CX II (32 bits : ARM9/ARMv5 @396MHz - Ndless + MicroPython)
0,258s : HP Prime G1 (32 bits : ARM9/ARMv5 @400MHz Python)
0,297s : TI-Nspire CX II (32 bits : ARM9/ARMv5 @396MHz)
0,376s : HP Prime G2 (32 bits : Cortex-A7/ARMv7 @528MHz CAS)
0,47s : TI-Nspire (32 bits : ARM9/ARMv5 @120MHz - Ndless + MicroPython)
0,48s : TI-Nspire CX (révisions A-V) (32 bits : ARM9/ARMv5 @132MHz - Ndless + MicroPython)
0,498s : NumWorks N0110 (32 bits : Cortex-M7/ARMv7 @216MHz)
0,544s : NumWorks N0110 (Delta / Omega + KhiCAS Micropython)
0,609s : TI-Nspire CX (révisions A-V) (32 bits : ARM9/ARMv5 @132MHz - Ndless + KhiCAS Micropython)
0,68s : TI-Nspire CX CR4+ (révisions W+) (32 bits : ARM9/ARMv5 @156MHz - Ndless + MicroPython)
0,785s : NumWorks N0100 (32 bits : Cortex-M4/ARMv7 @100MHz)
0,868s : TI-Nspire CX CR4+ (révisions W+) (32 bits : ARM9/ARMv5 @156MHz - Ndless + KhiCAS Micropython)
1,61s : HP Prime G1 (32 bits : ARM9/ARMv5 @400MHz CAS)
1,909s : TI-Nspire CX II (32 bits : ARM9/ARMv5 @396MHz - Ndless + KhiCAS compatibilité Python)
3,27s : Casio Graph 90+E / fx-CG50 (32 bits : SH4 @117,96MHz)
3,73s : TI-83 Premium CE + TI-Python (8 + 32 bits : eZ80 @48MHz + Cortex-M0+/ARMv6 @48MHz)
3,9s : Casio Graph 35+E II / fx-9750/9860GIII (32 bits : SH4 @58,98 - CasioPython)
3,99s : TI-83 Premium CE Edition Python / TI-84 Plus CE Python Edition (8 + 32 bits : eZ80 @48MHz + Cortex-M0+/ARMv6 @48MHz)
4s : Casio Graph 35/75+E / 35/75/95 / fx-9750/9860GII (32 bits : SH4 @29,49MHz - CasioPython)
4,01s : TI-82 Advanced Edition Python
4,4s : TI-83 Premium CE + TI-Python (8 + 32 bits : eZ80 @48MHz + Cortex-M0+/ARMv6 @48MHz CircuitPython)
5,29s : Casio Graph 35/75/85/95 / fx-9750/9860GII / fx-9860G (32 bits : SH3 @29,49MHz - CasioPython)
5,45s : TI-Nspire CX (révisions A-V) (32 bits : ARM9/ARMv5 @132MHz - Ndless + KhiCAS compatibilité Python)
5,48s : Casio Graph 90+E / fx-CG50 (32 bits : SH4 @117,96MHz - KhiCAS)
6,69s : NumWorks N0110 (Delta / Omega + KhiCAS compatibilité Python)
9,21s : Casio Graph 35+E II / fx-9750/9860GIII (32 bits : SH4 @58,98MHz)
13,93s : Casio Graph 35+E II / fx-9750/9860GIII (32 bits : SH4 @58,98MHz - KhiCAS)
7,63s : TI-Nspire CX CR4+ (révisions W+) (32 bits : ARM9/ARMv5 @156MHz - Ndless + KhiCAS compatibilité Python)
15,05s : Casio fx-CG10/20 (32 bits : SH4 @58,98MHz - KhiCAS)

0,022s : TI-Nspire CX II (32 bits : ARM9/ARMv5 ~~@396MHz~~ overclocké @468MHz NoverII - Ndless + KhiCAS Micropython)
0,087s : HP Prime G2 (32 bits : Cortex-A7/ARMv7 @528MHz Python)
0,142s : TI-Nspire CX II (32 bits : ARM9/ARMv5 ~~@396MHz~~ overclocké @468MHz NoverII - Ndless + MicroPython)
0,257s : TI-Nspire CX II (32 bits : ARM9/ARMv5 ~~@396MHz~~ overclocké @468MHz NoverII)
0,258s : HP Prime G1 (32 bits : ARM9/ARMv5 @400MHz Python)
0,27s : TI-Nspire CX (révisions A-V) (32 bits : ARM9/ARMv5 ~~@132MHz~~ overclocké @222MHz Nover - Ndless + MicroPython)
0,376s : HP Prime G2 (32 bits : Cortex-A7/ARMv7 @528MHz CAS)
0,38s : TI-Nspire (32 bits : ARM9/ARMv5 overclocké ~~@120MHz~~ @150MHz Nover - Ndless + MicroPython)
0,396s : TI-Nspire CX (révisions A-V) (32 bits : ARM9/ARMv5 ~~@132MHz~~ overclocké @222MHz Nover - Ndless + KhiCAS 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 Nover - Ndless + MicroPython)
0,544s : NumWorks N0110 (Delta / Omega + KhiCAS Micropython)
0,59s : Casio Graph 35/75+E / 35/75/95 / fx-9750/9860GII (32 bits : SH4 ~~@29,49MHz~~ overclocké @267,78MHz Ftune2 - CasioPython)
0,65s : TI-Nspire CX CR4+ (révisions W+) (32 bits : ARM9/ARMv5 ~~@156MHz~~ overclocké @216MHz Nover - Ndless + KhiCAS Micropython)
0,785s : NumWorks N0100 (32 bits : Cortex-M4/ARMv7 @100MHz)
0,79s : Casio Graph 35+E II / fx-9750/9860GIII (32 bits : SH4 ~~@58,98MHz~~ overclocké @274,91MHz Ftune3 - CasioPython)
1,589s : TI-Nspire CX II (32 bits : ARM9/ARMv5 ~~@396MHz~~ overclocké @468MHz NoverII - Ndless + KhiCAS compatibilité Python)
1,61s : HP Prime G1 (32 bits : ARM9/ARMv5 @400MHz CAS)
1,86s : Casio Graph 35+E II / fx-9750/9860GIII (32 bits : SH4 ~~@58,98MHz~~ overclocké @274,91MHz Ftune3)
1,876s : Casio Graph 35/75/85/95 / fx-9750/9860GII / fx-9860G (32 bits : SH3 ~~@29,49MHz~~ overclocké @117,96MHz Ftune - CasioPython)
2,15s : Casio Graph 90+E / fx-CG50 (32 bits : SH4 ~~@117,96MHz~~ overclocké @270,77MHz Ptune3)
2,96s : Casio Graph 35+E II / fx-9750/9860GIII (32 bits : SH4 ~~@58,98MHz~~ overclocké @274,91MHz Ftune3 - KhiCAS)
3,65s : Casio Graph 90+E / fx-CG50 (32 bits : SH4 ~~@117,96MHz~~ overclocké @270,77MHz Ptune3 - KhiCAS)
3,718s : Casio fx-CG10/20 (32 bits : SH4 ~~@58,98MHz~~ overclocké @267,78MHz Ptune2 - KhiCAS)
3,73s : TI-83 Premium CE + TI-Python (8 + 32 bits : eZ80 @48MHz + Cortex-M0+/ARMv6 @48MHz)
3,99s : TI-83 Premium CE Edition Python / TI-84 Plus CE Python Edition (8 + 32 bits : eZ80 @48MHz + Cortex-M0+/ARMv6 @48MHz)
4,01s : TI-82 Advanced Edition Python
4,13s : TI-Nspire CX (révisions A-V) (32 bits : ARM9/ARMv5 ~~@132MHz~~ overclocké @222MHz Nover - Ndless + KhiCAS compatibilité Python)
4,4s : TI-83 Premium CE + TI-Python (8 + 32 bits : eZ80 @48MHz + Cortex-M0+/ARMv6 @48MHz CircuitPython)
6,69s : NumWorks N0110 (Delta / Omega + KhiCAS compatibilité Python)
7,19s : TI-Nspire CX CR4+ (révisions W+) (32 bits : ARM9/ARMv5 ~~@156MHz~~ overclocké @216MHz Nover - Ndless + KhiCAS compatibilité Python)

Passons maintenant aux entiers avec un test de primalité, que voici en Python :

Code: Tout sélectionner: 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

Nous appellerons ici isprimep(10000019).

en exam
officiel en exam
tiers en exam
tiers + overclock hors exam
officiel hors exam
tiers hors exam
tiers + overclock

0,171s : HP Prime G2 (32 bits : Cortex-A7/ARMv7 @528MHz Python)
0,449s : HP Prime G1 (32 bits : ARM9/ARMv5 @400MHz Python)
0,451s : TI-Nspire CX II (32 bits : ARM9/ARMv5 @396MHz)
0,581s : NumWorks N0110 (32 bits : Cortex-M7/ARMv7 @216MHz)
1,17s : NumWorks N0100 (32 bits : Cortex-M4/ARMv7 @100MHz)
1,58s : Casio Graph 90+E (32 bits : SH4 @117,96MHz)
4,39s : Casio Graph 35+E II (32 bits : SH4 @58,98MHz)
4,42s : HP Prime G2 (32 bits : Cortex-A7/ARMv7 @528MHz CAS)
8,91s : TI-83 Premium CE Edition Python (8 + 32 bits : eZ80 @48MHz + Cortex-M0+/ARMv6 @48MHz)
9,22s : TI-82 Advanced Edition Python (8 + 32 bits : eZ80 @48MHz + Cortex-M0+/ARMv6 @48MHz)
16,05s : HP Prime G1 (32 bits : ARM9/ARMv5 @400MHz CAS)

0,171s : HP Prime G2 (32 bits : Cortex-A7/ARMv7 @528MHz Python)
0,449s : HP Prime G1 (32 bits : ARM9/ARMv5 @400MHz Python)
0,451s : TI-Nspire CX II (32 bits : ARM9/ARMv5 @396MHz)
0,794s : TI-Nspire CX (révisions A-V) (32 bits : ARM9/ARMv5 @132MHz - Ndless + KhiCAS Micropython)
0,581s : NumWorks N0110 (32 bits : Cortex-M7/ARMv7 @216MHz)
0,715s : NumWorks N0110 (Delta / Omega + KhiCAS Micropython)
1,17s : NumWorks N0100 (32 bits : Cortex-M4/ARMv7 @100MHz)
1,18s : TI-Nspire CX CR4+ (révisions W+) (32 bits : ARM9/ARMv5 @156MHz - Ndless + KhiCAS Micropython)
1,58s : Casio Graph 90+E (32 bits : SH4 @117,96MHz)
4,39s : Casio Graph 35+E II (32 bits : SH4 @58,98MHz)
4,42s : HP Prime G2 (32 bits : Cortex-A7/ARMv7 @528MHz CAS)
8,91s : TI-83 Premium CE Edition Python (8 + 32 bits : eZ80 @48MHz + Cortex-M0+/ARMv6 @48MHz)
9,22s : TI-82 Advanced Edition Python (8 + 32 bits : eZ80 @48MHz + Cortex-M0+/ARMv6 @48MHz)
16,05s : HP Prime G1 (32 bits : ARM9/ARMv5 @400MHz CAS)
36,26s : TI-Nspire CX (révisions A-V) (32 bits : ARM9/ARMv5 @132MHz - Ndless + KhiCAS compatibilité Python)
42,75s : NumWorks N0110 (Delta / Omega + KhiCAS compatibilité Python)
53,24s : TI-Nspire CX CR4+ (révisions W+) (32 bits : ARM9/ARMv5 @156MHz - Ndless + KhiCAS compatibilité Python

0,171s : HP Prime G2 (32 bits : Cortex-A7/ARMv7 @528MHz Python)
0,449s : HP Prime G1 (32 bits : ARM9/ARMv5 @400MHz Python)
0,451s : TI-Nspire CX II (32 bits : ARM9/ARMv5 @396MHz)
0,511s : TI-Nspire CX (révisions A-V) (32 bits : ARM9/ARMv5 ~~@132MHz~~ overclocké @222MHz Nover - Ndless + KhiCAS Micropython)
0,581s : NumWorks N0110 (32 bits : Cortex-M7/ARMv7 @216MHz)
0,715s : NumWorks N0110 (Delta / Omega + KhiCAS Micropython)
0,821s : TI-Nspire CX CR4+ (révisions W+) (32 bits : ARM9/ARMv5 ~~@156MHz~~ overclocké @216MHz Nover - Ndless + KhiCAS Micropython)
1,17s : NumWorks N0100 (32 bits : Cortex-M4/ARMv7 @100MHz)
1,58s : Casio Graph 90+E (32 bits : SH4 @117,96MHz)
4,39s : Casio Graph 35+E II (32 bits : SH4 @58,98MHz)
4,42s : HP Prime G2 (32 bits : Cortex-A7/ARMv7 @528MHz CAS)
8,91s : TI-83 Premium CE Edition Python (8 + 32 bits : eZ80 @48MHz + Cortex-M0+/ARMv6 @48MHz)
9,22s : TI-82 Advanced Edition Python (8 + 32 bits : eZ80 @48MHz + Cortex-M0+/ARMv6 @48MHz)
16,05s : HP Prime G1 (32 bits : ARM9/ARMv5 @400MHz CAS)
29,20s : TI-Nspire CX (révisions A-V) (32 bits : ARM9/ARMv5 ~~@132MHz~~ overclocké @222MHz Nover - Ndless + KhiCAS compatibilité Python)
42,75s : NumWorks N0110 (Delta / Omega + KhiCAS compatibilité Python)
45,34s : TI-Nspire CX CR4+ (révisions W+) (32 bits : ARM9/ARMv5 ~~@156MHz~~ overclocké @216MHz Nover - Ndless + KhiCAS compatibilité Python)

0,171s : HP Prime G2 (32 bits : Cortex-A7/ARMv7 @528MHz Python)
0,449s : HP Prime G1 (32 bits : ARM9/ARMv5 @400MHz Python)
0,451s : TI-Nspire CX II (32 bits : ARM9/ARMv5 @396MHz)
0,581s : NumWorks N0110 (32 bits : Cortex-M7/ARMv7 @216MHz)
1,17s : NumWorks N0100 (32 bits : Cortex-M4/ARMv7 @100MHz)
1,58s : Casio Graph 90+E / fx-CG50 (32 bits : SH4 @117,96MHz)
4,39s : Casio Graph 35+E II / fx-9750/9860GIII (32 bits : SH4 @58,98MHz)
4,42s : HP Prime G2 (32 bits : Cortex-A7/ARMv7 @528MHz CAS)
8,1s : TI-83 Premium CE + TI-Python (8 + 32 bits : eZ80 @48MHz + Cortex-M0+/ARMv6 @48MHz)
8,91s : TI-83 Premium CE Edition Python / TI-84 Plus CE Python Edition (8 + 32 bits : eZ80 @48MHz + Cortex-M0+/ARMv6 @48MHz)
9,22s : TI-82 Advanced Edition Python (8 + 32 bits : eZ80 @48MHz + Cortex-M0+/ARMv6 @48MHz)
16,05s : HP Prime G1 (32 bits : ARM9/ARMv5 @400MHz CAS)

0,171s : HP Prime G2 (32 bits : Cortex-A7/ARMv7 @528MHz Python)
0,307s : TI-Nspire CX II (32 bits : ARM9/ARMv5 @396MHz - Ndless + MicroPython)
0,323s : TI-Nspire CX II (32 bits : ARM9/ARMv5 @396MHz - Ndless + KhiCAS Micropython)
0,449s : HP Prime G1 (32 bits : ARM9/ARMv5 @400MHz Python)
0,451s : TI-Nspire CX II (32 bits : ARM9/ARMv5 @396MHz)
0,581s : NumWorks N0110 (32 bits : Cortex-M7/ARMv7 @216MHz)
0,62s : TI-Nspire CX (révisions A-V) (32 bits : ARM9/ARMv5 @132MHz - Ndless + MicroPython)
0,67s : TI-Nspire (32 bits : ARM9/ARMv5 @120MHz - Ndless + MicroPython)
0,715s : NumWorks N0110 (Delta / Omega + KhiCAS Micropython)
0,794s : TI-Nspire CX (révisions A-V) (32 bits : ARM9/ARMv5 @132MHz - Ndless + KhiCAS Micropython)
0,99s : TI-Nspire CX CR4+ (révisions W+) (32 bits : ARM9/ARMv5 @156MHz - Ndless + MicroPython)
1,17s : NumWorks N0100 (32 bits : Cortex-M4/ARMv7 @100MHz)
1,18s : TI-Nspire CX CR4+ (révisions W+) (32 bits : ARM9/ARMv5 @156MHz - Ndless + KhiCAS Micropython)
1,58s : Casio Graph 90+E / fx-CG50 (32 bits : SH4 @117,96MHz)
3,04s : Casio Graph 35+E II / fx-9750/9860GIII (32 bits : SH4 @58,98 - CasioPython)
4,39s : Casio Graph 35+E II / fx-9750/9860GIII (32 bits : SH4 @58,98MHz)
4,42s : HP Prime G2 (32 bits : Cortex-A7/ARMv7 @528MHz CAS)
4,89s : Casio Graph 35/75+E / 35/75/95 / fx-9750/9860GII (32 bits : SH4 @29,49MHz - CasioPython)
5,24s : Casio Graph 35/75/85/95 / fx-9750/9860GII / fx-9860G (32 bits : SH3 @29,49MHz - CasioPython)
8,1s : TI-83 Premium CE + TI-Python (8 + 32 bits : eZ80 @48MHz + Cortex-M0+/ARMv6 @48MHz)
8,91s : TI-83 Premium CE Edition Python / TI-84 Plus CE Python Edition (8 + 32 bits : eZ80 @48MHz + Cortex-M0+/ARMv6 @48MHz)
9,22s : TI-82 Advanced Edition Python (8 + 32 bits : eZ80 @48MHz + Cortex-M0+/ARMv6 @48MHz)
11,26s : TI-83 Premium CE + TI-Python (8 + 32 bits : eZ80 @48MHz + Cortex-M0+/ARMv6 @48MHz CircuitPython)
11,62s : TI-Nspire CX II (32 bits : ARM9/ARMv5 @396MHz - Ndless + KhiCAS compatibilité Python)
16,05s : HP Prime G1 (32 bits : ARM9/ARMv5 @400MHz CAS)
32,76s : Casio Graph 90+E / fx-CG50 (32 bits : SH4 @117,96MHz - KhiCAS)
36,26s : TI-Nspire CX (révisions A-V) (32 bits : ARM9/ARMv5 @132MHz - Ndless + KhiCAS compatibilité Python)
42,75s : NumWorks N0110 (Delta / Omega + KhiCAS compatibilité Python)
53,24s : TI-Nspire CX CR4+ (révisions W+) (32 bits : ARM9/ARMv5 @156MHz - Ndless + KhiCAS compatibilité Python)
91,71s : Casio Graph 35+E II / fx-9750/9860GIII (32 bits : SH4 @58,98MHz - KhiCAS)
102,04s : Casio fx-CG10/20 (32 bits : SH4 @58,98MHz - KhiCAS)

0,171s : HP Prime G2 (32 bits : Cortex-A7/ARMv7 @528MHz Python)
0,206s : TI-Nspire CX II (32 bits : ARM9/ARMv5 ~~@396MHz~~ overclocké @468MHz NoverII - Ndless + MicroPython)
0,263s : TI-Nspire CX II (32 bits : ARM9/ARMv5 ~~@396MHz~~ overclocké @468MHz NoverII - Ndless + KhiCAS Micropython)
0,382 : TI-Nspire CX II (32 bits : ARM9/ARMv5 ~~@396MHz~~ overclocké @468MHz NoverII)
0,42s : TI-Nspire CX (révisions A-V) (32 bits : ARM9/ARMv5 ~~@132MHz~~ overclocké @222MHz Nover - Ndless + MicroPython)
0,449s : HP Prime G1 (32 bits : ARM9/ARMv5 @400MHz Python)
0,511s : TI-Nspire CX (révisions A-V) (32 bits : ARM9/ARMv5 ~~@132MHz~~ overclocké @222MHz Nover - Ndless + KhiCAS Micropython)
0,57s : TI-Nspire (32 bits : ARM9/ARMv5 overclocké ~~@120MHz~~ @150MHz Nover - Ndless + MicroPython)
0,58s : Casio Graph 35/75+E / 35/75/95 / fx-9750/9860GII (32 bits : SH4 ~~@29,49MHz~~ overclocké @267,78MHz Ftune2 - CasioPython)
0,581s : NumWorks N0110 (32 bits : Cortex-M7/ARMv7 @216MHz)
0,59s : Casio Graph 35+E II / fx-9750/9860GIII (32 bits : SH4 ~~@58,98MHz~~ overclocké @274,91MHz Ftune3 - CasioPython)
0,63s : TI-Nspire CX CR4+ (révisions W+) (32 bits : ARM9/ARMv5 ~~@156MHz~~ overclocké @216MHz Nover - Ndless + MicroPython)
0,715s : NumWorks N0110 (Delta / Omega + KhiCAS Micropython)
0,821s : TI-Nspire CX CR4+ (révisions W+) (32 bits : ARM9/ARMv5 ~~@156MHz~~ overclocké @216MHz Nover - Ndless + KhiCAS Micropython)
0,86s : Casio Graph 35+E II / fx-9750/9860GIII (32 bits : SH4 ~~@58,98MHz~~ overclocké @274,91MHz Ftune3)
1,08s : Casio Graph 90+E / fx-CG50 (32 bits : SH4 ~~@117,96MHz~~ overclocké @270,77MHz Ptune3)
1,17s : NumWorks N0100 (32 bits : Cortex-M4/ARMv7 @100MHz)
1,688s : Casio Graph 35/75/85/95 / fx-9750/9860GII / fx-9860G (32 bits : SH3 ~~@29,49MHz~~ overclocké @117,96MHz Ftune - CasioPython)
4,42s : HP Prime G2 (32 bits : Cortex-A7/ARMv7 @528MHz CAS)
8,1s : TI-83 Premium CE + TI-Python (8 + 32 bits : eZ80 @48MHz + Cortex-M0+/ARMv6 @48MHz)
8,91s : TI-83 Premium CE Edition Python / TI-84 Plus CE Python Edition (8 + 32 bits : eZ80 @48MHz + Cortex-M0+/ARMv6 @48MHz)
9,22s : TI-82 Advanced Edition Python (8 + 32 bits : eZ80 @48MHz + Cortex-M0+/ARMv6 @48MHz)
9.964s : TI-Nspire CX II (32 bits : ARM9/ARMv5 ~~@396MHz~~ overclocké @468MHz NoverII - Ndless + KhiCAS compatibilité Python)
11,26s : TI-83 Premium CE + TI-Python (8 + 32 bits : eZ80 @48MHz + Cortex-M0+/ARMv6 @48MHz CircuitPython)
16,05s : HP Prime G1 (32 bits : ARM9/ARMv5 @400MHz CAS)
19,06s : Casio Graph 35+E II / fx-9750/9860GIII (32 bits : SH4 ~~@58,98MHz~~ overclocké @274,91MHz Ftune3 - KhiCAS)
22,77s : Casio Graph 90+E / fx-CG50 (32 bits : SH4 ~~@117,96MHz~~ overclocké @270,77MHz Ptune3 - KhiCAS)
29,20s : TI-Nspire CX (révisions A-V) (32 bits : ARM9/ARMv5 ~~@132MHz~~ overclocké @222MHz Nover - Ndless + KhiCAS compatibilité Python)
30,85s : Casio fx-CG10/20 (32 bits : SH4 ~~@58,98MHz~~ overclocké @267,78MHz Ptune2 - KhiCAS)
42,75s : NumWorks N0110 (Delta / Omega + KhiCAS compatibilité Python)
53,24s : TI-Nspire CX CR4+ (révisions W+) (32 bits : ARM9/ARMv5 ~~@156MHz~~ overclocké @216MHz Nover - Ndless + KhiCAS compatibilité Python)

Deux indices de performances représentant chacun de ces deux tests sont dès maintenant disponibles, également pour les modèles plus anciens que nous avions encore sous la main via leurs solutions Python non officielles :

Accès QCC 2021 Universel