TI-Planet

by **critor** » 17 Aug 2021, 20:15

Quelle Calculatrice Choisir 2021 édition Universelle

Épisode 6 - Python zone graphique utile

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 132 modèles différents de calculatrices testés sous toutes leurs coutures, 10 ans de tests et découvertes à portée de clic !

Dans un épisode précédent, nous t'avons révélé les dimensions de la zone graphique utile de chaque modèle, c'est-à-dire la zone dont l'utilisateur peut librement allumer les pixels :

par tracé de graphes
par exécution de programmes en langage constructeur/historique (très souvent un langage Basic)

Nous avions volontairement laissé de côté les scripts Python que nous allons donc traiter séparément aujourd'hui. En effet la zone graphique contrôlable par les scripts Python a bien souvent des dimensions différentes.

Comment donc faire maintenant pour tester la taille de la zone graphique, rien qu'en lisant / écrivant des pixels ? Et bien c'est très simple, tu ne vas pas être dépaysé(e).

Nous allons procéder comme avec une tortue (langage Scratch ou module Python turtle). Nous allons parcourir l'écran, en diagonale, en tentant de lire et modifier chaque pixel rencontré.

Pour savoir si un pixel est accessible en écriture, nous tenterons d'inverser sa couleur :

Code: Select all: def invert_color(c): try: ci = [0, 0, 0] for k in range(3): ci[k] = 255 - c[k] except: ci = ~(c&0xffffff) & 0xffffff return ci def is_pixel_writable(x, y, bad_pixel): if is_pixel_readable(x, y, bad_pixel): c0 = get_pixel(x, y) set_pixel(x, y, invert_color(c0)) c = get_pixel(x, y) return c != c0

Pour savoir si un pixel que l'on arrive à lire correspond bien à un pixel visible de l'écran, nous prendrons comme référence la mauvaise valeur de pixel retournée par une lecture clairement hors écran, coordonnées (-2, -2).
Dans le seul cas où l'on rencontre cette valeur qui peut très bien être justifiée, nous tenterons ici encore de l'inverser.

Code: Select all: def is_pixel_readable(x, y, bad_pixel): c = None try: c = get_pixel(x, y) except: pass if c != None: if c == bad_pixel: set_pixel(x, y, invert_color(c)) c = get_pixel(x, y) return c != bad_pixel

Voici donc les fonctions principales utilisant tout ça :

Code: Select all: def scr_test(x0, y0, dx0, dy0, test): bad_pixel = None try: bad_pixel = get_pixel(-2, -2) except: pass x, y, dx, dy = x0, y0, dx0, dy0 while not test(x, y, bad_pixel): x += dx y += dy if test(x, y - dy, bad_pixel): y = y0 elif test(x - dx, y, bad_pixel): x = x0 x0, y0 = x, y x += dx y += dy while(dx or dy): if not test(x - ((dx == 0) and dx0),y - ((dy == 0) and dy0), bad_pixel): if test(x - ((dx == 0) and dx0), y - ((dy == 0) and dy0) - dy0, bad_pixel): dy = 0 elif test(x - ((dx == 0) and dx0) - dx0, y - ((dy == 0) and dy0), bad_pixel): dx = 0 else: dx, dy = 0, 0 x += dx y += dy return x0, y0, (x - x0) // dx0, (y - y0) // dy0 def scr_size(): xrd0, yrd0, xrd, yrd = scr_test(0, 0, -1, -1, is_pixel_readable) xra0, yra0, xra, yra = scr_test(1, 1, 1, 1, is_pixel_readable) xr0, yr0 = xrd0 - xrd + 1, yrd0 - yrd + 1 xr, yr = xra + xrd, yra + yrd xw0, yw0, xw, yw = scr_test(xr0, yr0, 1, 1, is_pixel_writable) print("at (" + str(xr0) + "," + str(yr0) + "): " + str(xr) + "x" + str(yr) + " readable pixels") print("at (" + str(xw0) + "," + str(yw0) + "): " + str(xw) + "x" + str(yw) + " writable pixels") return xr0, yr0, xr, yr, xw0, yw0, xw, yw

Il suffit donc d'appeler scr_size(), et tu vas vite comprendre avec notre premier exemple.

Les TI-83 Premium CE Edition Python et TI-84 Plus CE-T Python Edition t'offrent donc un écran 320×240 pixels, et une zone utile pour graphes et programmes de 265×165 pixels (56,93%).

En Python, les fonctions relatives aux pixels sont ti_graphic.getPixel(x, y) et ti_graphic.setPixel(x, y, couleur).

Après donc parcours de l'écran en diagonale par notre tortue virtuelle, cette dernière nous reporte :

321×241= 77361 pixels pouvant être lus à partir des coordonnées (-1, -1)
321×210= 67410 pixels pouvant être écrits à partir des coordonnées (-1, 30)

Si le fonctionnement est simple, plusieurs bizarreries dans le résultat sont toutefois à traiter ici.

Déjà sur les deux zones différentes qui nous sont retournées :

la première signifie que l'on peut lire l'intégralité des pixels de l'écran
la deuxième ne retient donc plus que les pixels pouvant être modifiés, ici situés en-dessous de la barre d'état de 30 pixels de hauteur, et c'est celle-ci qui correspond à la zone graphique, la seule zone où la tortue a réussi à tracer son chemin comme tu vois ci-contre

Ensuite, selon notre tortue nous aurions donc un écran de 321×241 pixels, soit plus que les 320×240 pixels précédemment annoncés, avec :

une ligne de pixels d'ordonnée -1 pouvant être lus
une colonne de pixels d'abscisse -1 pouvant être lus, et également écrits à partir de l'ordonnée 30 marque le début de la zone graphique précédente

Or une tentative d'écriture donc sur cette dernière colonne ne donne visiblement rien à l'écran.

Soit il y a un bug dans notre code expliquant ce résultat différent de la réalité, et tu verras bien ci-dessous si la même anomalie est présente sur d'autres modèles ou pas avec exactement le même code.

Soit la chose vient de Texas Instruments. Nous aurions donc un écran de 320×240 pixels, mais avec en mémoire un buffer associé de 321×241 pixels. Ou bien c'est un bug, ou bien il y a une raison technique que nous ignorons à ce jour pour disposer en mémoire d'1 ligne et d'1 colonne supplémentaires de pixels sans aucune existence physique.

Pour notre classement, nous retiendrons donc ici une zone graphique correspondant à la réalité, c'est-à-dire de 320×210, soit 87,50% de la définition de l'écran, c'est déjà bien mieux qu'avec le langage historique !

La Casio Graph 90+E t'offre un écran de 396×224 pixels, avec une zone utile pour graphes et programmes de 379×187 pixels (79,90%).

En Python, les fonctions relatives aux pixels sont casioplot.get_pixel(x, y) et casioplot.set_pixel(x, y, couleur).

Mais voyons maintenant ce que cela donne dans l'application Python.

Et c'est fantastique, Casio ici aussi a fait un effort, ce sont pas moins de 384×192 pixels qui sont contrôlables en Python, soit 83,12% de l'écran !

Sur les modèles précédents Casio fx-CG10 et fx-CG20, pas de mise à jour avec Python.

Toutefois tu as également la possibilité d'installer l'application KhiCAS, une adaptation pour ta calculatrice du logiciel de mathématiques intégré Xcas par Bernard Parisse, enseignant-chercheur à l'Université de Grenoble.

L'environnement est également programmable avec une syntaxe proche du Python. Pas de fonctions pour contrôler individuellement les pixels ici, mais par contre nous y disposons d'une tortue dont on peut spécifier les déplacements en pixels. Tentons de tracer un rectangle le plus grand possible à l'aide du code suivant :

Code: Select all: def scrtest(w, h): efface leve_crayon tourne_gauche 180 avance w // 3 tourne_gauche 90 avance h // 2 baisse_crayon for k in range(2): tourne_gauche 90 avance w tourne_gauche 90 avance h

C'est l'appel scrtest(383, 191) qui nous permet de rentrer le plus grand rectangle possible dans l'écran. Comme les paramètres concernent ici des déplacements de la tortue cela correspond à une zone graphique de 384×192 (83,12%), soit exactement comme avec l'application Python officielle.

La Casio Graph 35+E II dispose d'un écran de 128×64 pixels, avec une zone utile pour graphes et programmes de 127×63 pixels (97,67%).

En Python, les fonctions relatives aux pixels sont ici encore casioplot.get_pixel(x, y) et casioplot.set_pixel(x, y, couleur).

Et en Python c'est donc superbe, nous contrôlons apparemment 128×64 pixels soit 100% de l'écran.

Les TI-Nspire CX II utilisent un écran 320×240 pixels, avec une zone utile pour graphes et programmes de 318×212 pixels (87,78%).

Le module Python de tracé par pixels est ti_draw. Il ne dispose pas de fonction permettant d'allumer un pixel isolé comme un set_pixel(). On pourrait certainement remplacer cela par un appel draw_rect(x, y, 0, 0) pour tracer un rectangle d'1 pixel de surface. Mais surtout, ti_draw ne dispose pas de fonction get_pixel().

En fait, get_pixel() et set_pixel() sont offertes dans le cadre d'une autre module ti_image, permettant de travailler sur un calque avant de l'afficher. Mais comme il faut définir les dimensions du calque en question, un test basé là-dessus ne serait pas pertinent.

Toutefois, ti_draw fournit une fonction get_screen_dim() nous permettant de récupérer les dimensions de la zone graphique utilisable, sans surprise ici les mêmes 318×212 pixels.

Sur les anciennes TI-Nspire CX, pas de mise à jour avec Python.

Toutefois, si ta calculatrice n'a pas été mise à jour avec la dernière version 4.5.5, tu peux installer Ndless et ensuite l'application KhiCAS.

KhiCAS intègre un interpréteur Python et surtout un mode examen compatible avec celui de Texas Instruments. Si tu actives le mode examen depuis les menus de KhiCAS, ce dernier restera disponible en mode examen !

Les fonctions get_pixel() et set_pixel() sont ici offertes via le module graphic. Ce module est également accessible via les alias casioplot et kandinsky, ce qui permet une compatibilité directe avec les scripts conçus pour Casio et NumWorks !

Notre script de test détecte ici 320×222 pixels pouvant à la fois être lus et écrits, soit 92,5%.

Sur les TI-Nspire CM et TI-Nspire monochromes, nous n'avons pas que 32 Mio de SDRAM au lieu de 64 Mio. Ce n'est pas suffisant pour lancer KhiCAS.

Tu peux ici installer Ndless puis ensuite l'application MicroPython.

On y contrôle alors 320×240 pixels soit 100% de l'écran !

Attention toutefois, l'activation du mode examen t'interdira l'usage de cette application.

La NumWorks t'apporte un écran de 320×240 pixels, dont comme nous avons vu 320×204 pixels pour les graphes (85%).

En Python, les fonctions qui nous intéressent ici sont kandinsky.get_pixel(x, y) et kandinsky.set_pixel(x, y, couleur).

Nous avons donc accès ici à une zone graphique de 320×222 pixels, soit 92,5% !

La HP Prime t'offre un écran de 320×240 pixels, intégralement utilisables par les graphes et programmes en langage constructeur (HPPPL).

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: Select all: def get_pixel(x, y): return int(eval("get_pixel(" + str(x) + "," + str(y) + ")"))

Sans surprise ici aussi, nous contrôlons les mêmes 320×240 pixels soit 100% de l'écran !

Les mesures sont toutes disponibles et facilement comparables sur le lien ci-dessous :

Accès QCC 2021 Universel

by **critor** » 16 Aug 2021, 16:27

Quelle Calculatrice Choisir 2021 édition Universelle

Épisode 5 - Python et tas (heap)

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 132 modèles différents de calculatrices testés sous toutes leurs coutures, 10 ans de tests et découvertes à portée de clic !

Les interpréteurs MicroPython ou similaires qui tournent sur calculatrices font appel à différents types de mémoires :

La mémoire de stockage comme son nom l'indique stocke physiquement tes scripts Python.
La pile (stack) référence, à l'exécution, les objets Python créés. Sa capacité limite donc le nombre d'objets Python pouvant coexister simultanément en mémoire.
Le tas (heap) stocke, à l'exécution, le contenu des objets Python créés. Il limite donc la taille globale utilisée pour les données de ces différents objets.

Aujourd'hui nous allons donc nous intéresser au heap. Cet espace est extrêmement important et surtout sur les plateformes nomades, car contrairement à d'autres langages les objets Python les plus simples ont le défaut d'être assez gros. Ce sera bien souvent le heap le facteur le plus limitant pour tes projets Python, d'où son caractère essentiel.

Le temps de construire notre protocole de test, concentrons-nous sur la TI-83 Premium CE Edition Python.

Nous avons justement la chance ici de disposer du module gc (garbage collector - ramasse miettes), avec plusieurs fonctions bien utiles :

gc.collect() pour nettoyer le heap en supprimant les valeurs d'objets Python qui ne sont plus référencées
gc.mem_alloc() pour connaître la consommation du heap en octets
gc.mem_free() pour connaître l'espace heap disponible en octets

Exécutons donc le petit script suivant afin de découvrir la capacité heap Python de la TI-83 Premium CE Edition Python :

Code: Select all: import gc a, f = gc.mem_alloc(), gc.mem_free() (a, f, a + f)

Nous avons donc sur TI-83 Premium CE Edition Python une capacité heap de 19,968 Ko.

Mais lorsque l'on accède à l'environnement Python, nombre de choses sont initialisées et ce heap n'est pas vide. Plus que 17,104 Ko de libres.

Précisons que cet espace libre a de plus ici été amputé de par notre importation du module gc. Ce module n'étant hélas disponible que sur une minorité de Pythonnettes, il va nous falloir procéder autrement, surtout si l'on souhaite obtenir des mesures comparables.

Donnons quelques éléments de taille en mémoire d'objets Python usuels, du moins sur les plateformes 32 bits que sont nos calculatrices :

pour un entier nul : 24 octets déjà...
pour un entier court non nul (codable sur 31 bits + 1 bit de signe) : 28 octets
pour un entier long :
- 28 octets
- + 4 octets pour chaque groupe de 30 bits utilisé par son écriture binaire au-delà des 31 bits précédents
pour une chaîne :
- 49 octets
- + 1 octet par caractère
pour une liste :
- 64 octets
- + 8 octets par élément
- + les tailles de chaque élément

Voici une fonction qui retourne la taille d'un objet selon ces règles :

Code: Select all: def size(o): t = type(o) s = t == str and 49 + len(o) if t == int: s = 24 while o: s += 4 o >>= 30 elif t == list: s = 64 + 8*len(o) for so in o: s += size(so) return s

Nous allons donc tenter plutôt de remplir le heap avec plusieurs objets que nous allons faire grandir chacun son tour jusqu'à déclenchement d'une erreur, et retourner la capacité maximale que nous avons réussi à consommer. Voici donc un script en ce sens :

Code: Select all: def mem(v=1): try: l=[] try: l.append(0) l.append(0) l.append("") l[2] += "x" while 1: try: l[2] += l[2][l[1]:] except: if l[1] < len(l[2]) - 1: l[1] = len(l[2]) - 1 else: raise(Exception) except: if v: print("+", size(l)) try: l[0] += size(l) except: pass try: l[0] += mem(v) except: pass return l[0] except: return 0

Exécuter ce script va ainsi nous permettre d'évaluer équitablement tous les modèles.

L'appel mem(0) semble marcher comme souhaité, retournant une valeur qui peut comme prévu légèrement dépasser les 17,104 Ko trouvés plus haut.

Mais voilà autre petit problème, le résultat n'est pas toujours le même, dépendant en effet de l'état du heap lors de l'appel. Rien que sur les résultats ci-contre, nous avons une marge d'erreur de 1 à 2%.

C'est beaucoup, en tous cas suffisamment pour inverser injustement des modèles au classement. Or nous tenons à être aussi précis que possible, afin justement de produire un classement aussi équitable que possible.

Certes, on pourrait nettoyer le heap avant chaque appel avec gc.collect(), mais ce ne serait pas juste puisque nous n'aurons pas cette possibilité sur nombre de modèles concurrents. Il nous faut donc trouver autre chose.

Précisons que l'absence du module gc et donc de gc.collect() ne signifie absolument pas que le heap ne sera jamais nettoyé. C'est juste que nous ne contrôlons pas le moment où il le sera.

Et bien voici l'élément final du protocole de test que nous te proposons, avec une boucle répétant des appels mem(0), ce qui devrait finir par déclencher des nettoyages du heap, et te signalant à chaque fois que la valeur retournée bat ainsi un nouveau record :

Code: Select all: def testmem(): m1, m2 = 0, 0 while 1: t1, t2 = mem(0) if t1 > m1 or t2 > m2: m1 = max(t1, m1) m2 = max(t2, m2) input(str((m1,m2)))

Sur les TI-83 Premium CE Edition Python et TI-84 Plus CE-T Python Edition, nous pouvons donc exploiter jusqu'à 17,601 Ko de heap.

C'est extrêmement faible, tes projets Python ne pourront pas aller bien loin !

Prenons maintenant l'ancienne TI-83 Premium CE munie du module externe TI-Python interdit aux examens français, mais restant utilisable en classe ainsi qu'aux évaluations si l'enseignant le permet.

Ce n'est pas la panacée mais c'est quand même sensiblement mieux, avec 19,496 Ko. Cela s'explique par l'absence de nombre de modules rajoutés dans le contexte de la TI-83 Premium CE Edition Python, dont les modules de tracé.

Conscient du problème de sous-dimensionnement de ce heap, Lionel Debroux a développé un firmware tiers pour le module externe TI-Python.

Attention, il n'est toutefois utilisable qu'avec des calculatrices en version 5.3.5, Texas Instruments ayant rajouté des protections pour interdire cela depuis.

Si tu l'installes tu bénéficieras donc d'un espace heap disponible nettement amélioré, avec 22,158 Ko.

C'est donc au-delà de la capacité heap de 19,968 Ko trouvée plus haut pour le firmware officiel, mais c'est normal puisque l'on se rend compte que Lionel a en effet passé la capacité heap à 22,912 Ko.

La nouvelle TI-82 Advanced Edition Python de cette rentrée 2021 offre quant à elle 19,700 Ko.

Encore une fois, cette amélioration cache en réalité l'absence de nombre de modules.

Arrive maintenant la NumWorks. Avec le firmware officiel Epsilon, elle nous offre 32,571 Ko de heap.

Nous sommes certes moins à l'étroit que sur les modèles précédents, il y a de quoi commencer à aborder des projets un peu plus gourmands en ressources, mais pas aller très loin non plus.

Sous conditions, tu as la possibilité d'installer très facilement le firmware tiers Omega qui t'offrira pour sa part pas moins de 98,928 Ko de heap !

Attention toutefois, le constructeur a décidé de t'interdire cette possibilité. Si ta machine vient avec une version 16.3+ du firmware officiel Epsilon, ou est mise à jour avec une de ces versions, elle sera verrouillée contre l'installation de firmwares tiers, et ce à notre connaissance à ce jour sans aucun retour possible.

Avec la Casio Graph 35+E II, nous avons enfin d'origine quelque chose de très correct, pas moins de 100,432 Ko de heap !

Il existe aussi une application Python tierce pour les Casio Graph monochromes, CasioPython. Elle est compatible avec les modèles suivants, mais hélas bloquée par le mode examen :

Graph 75+E
Graph 35+E via une installation du système Graph 75+E
Graph 35+E II

Sur les deux premiers nous nous envolons à pas moins de 257,026 Ko !

En effet selon le module gc, la capacité heap a ici été réglée à 258,048 Ko.

Hélas, un bug toujours pas corrigé depuis l'année dernière fait que CasioPython reconnaît bêtement la Graph 35+E II comme un ancien modèle, n'y réservant alors qu'une capacité heap de 32,256 Ko.

Nous n'obtenons alors qu'un espace heap libre de 31,163 Ko, ici donc sans aucun intérêt par rapport à l'application Python officielle.

La Casio Graph 90+E nous met maintenant littéralement en orbite avec un formidable 1032,967 Ko soit 1,033 Mo, de quoi développer des projets absolument fantastiques !

Les TI-Nspire CX II sont encore plus extraordinaires. 2051,137 Ko, soit 2,051 Mo de heap, pour des projets Python absolument formidables !

Sur les TI-Nspire CX, tu peux installer l'application KhiCAS qui intègre un interpréteur Micropython.

Nous avons donc par défaut 1024,540 Ko de heap, soit 1,025 Mo !

KhiCAS intègre de plus son propre mode examen que tu peux activer depuis ses menus. Parfaitement compatible avec celui de Texas Instruments, ce mode examen a le gros avantage de laisser KhiCAS disponible !

Attention toutefois, le mode examen de KhiCAS n'est pas compatible avec les TI-Nspire CX II.

De plus, l'installation de Micropython nécessite Ndless.

À ce jour Ndless n'est pas installable sur les TI-Nspire CX II et TI-Nspire CX munies des dernières mises à jour 5.3.2 ou 4.5.5, et il n'y a aucun moyen de revenir à une version précédente.

En théorie KhiCAS permet de configurer la taille du heap. Cela semblait marcher sur des versions précédentes, mais apparemment ce n'est plus le cas sur les dernières versions. Toute modification même infime de la taille par défaut nous amène très rapidement à des plantages avant même d'avoir réussi à exécuter notre script.

Dommage, pour le moment nous ne pourrons donc pas en tenir compte cette année.

Les TI-Nspire CM et TI-Nspire monochromes n'ont que 32 Mio de mémoire SDRAM, ce qui n'est pas suffisant pour KhiCAS. À la place on peut prendre Micropython qui nous fait littéralement quitter l'attraction terrestre avec pas moins de 2049,201 Ko soit 2,049 Mo !

En creusant un petit peu grâce au module gc ici disponible, nous découvrons que la capacité heap est de 2,049 Mo.

Attention, l'installation de Micropython nécessite Ndless.

À ce jour Ndless n'est pas installable sur les TI-Nspire CX II et TI-Nspire CX munies des dernières mises à jour 5.3.2 ou 4.5.5, et il n'y a aucun moyen de revenir à une version précédente.

De plus, Micropython disparaîtra en mode examen.

Et enfin il y a la HP Prime. Ah la HP Prime... ici nous ne sommes plus en orbite mais déjà dans une galaxie lointaine, très lointaine...

Distinguons les HP Prime G1 avec 32 Mio de SDRAM, et HP Prime G2 avec 256 Mio de SDRAM, testées toutes deux juste après un reset :

La HP Prime G1 offre 1020,293 Ko de heap, soit 1,020 Mo
La HP Prime G2 offre 1023,804 Ko de heap, soit 1,024 Mo

Par contre, la capacité du heap est ici réglable via

Shift

Plot

.

Sur pas moins de 3 HP Prime G1, on arrive à régler très exactement jusqu'à 16127 Ko avant plantage.
Sur HP Prime G2, on arrive à régler à peine davantage, jusqu'à 16384 Ko, un bug nous interdisant de régler des valeurs supérieures via cette boîte de dialogue.

Mais ne nous avouons pas encore vaincus. Les HP Prime permettent d'exécuter des scripts et fonctions Python depuis l'éditeur de programmes historique grâce à la fonction PYTHON(). Or, il se trouve que cette fonction permet de spécifier la capacité heap à allouer : PYTHON({nom_python,taille_heap},...).

Réalisons de quoi saisir et tester des capacités :

Code: Select all: #python heaptest_python from gc import mem_alloc,mem_free a,f=mem_alloc(),mem_free() print("allocated heap: "+str(f+a)) print("free heap: "+str(f)) #end Export heaptest_ppl(v) Begin PRINT("allocating heap: "+v); PRINT(""); PYTHON({heaptest_python,v}); End;

La HP Prime G2 nous permet ainsi de spécifier jusqu'à 258 Mo et quelques, en pratique restons sur 258 Mo.

La capacité heap alors réellement reportée par le module gc est d'environ 252,1 Mo !

Les mesures sont facilement comparables sur le lien ci-dessous, et même disponibles pour bien d'autres modèles plus anciens :

Accès QCC 2021 Universel

en exam
officiel en exam
tiers hors exam
officiel hors exam
tiers

252,1 Mo : HP Prime G2
15,6 Mo : HP Prime G1
2,051 Mo : TI-Nspire CX II
1,033 Mo : Casio Graph 90+E
100,432 Ko : Casio Graph 35+E II
32,571 Ko : NumWorks
19,700 Ko : TI-82 Advanced Edition Python
17,601 Ko : TI-83 Premium CE Edition Python

252,1 Mo : HP Prime G2
15,6 Mo : HP Prime G1
2,051 Mo : TI-Nspire CX II
1,033 Mo : Casio Graph 90+E
1,025 Mo : TI-Nspire CX (Ndless + KhiCAS)
100,432 Ko : Casio Graph 35+E II
98,928 Ko : NumWorks (firmware Omega)
64,954 Ko : NumWorks N0110 (firmware Delta / Omega + appli KhiCAS)
32,571 Ko : NumWorks
25,235 Ko : NumWorks N0110 (firmware Delta)
19,700 Ko : TI-82 Advanced Edition Python
17,601 Ko : TI-83 Premium CE Edition Python

252,1 Mo : HP Prime G2
15,6 Mo : HP Prime G1
2,051 Mo : TI-Nspire CX II
1,033 Mo : Casio Graph 90+E / fx-CG50
100,432 Ko : Casio Graph 35+E II / fx-9750/9860GIII
32,571 Ko : NumWorks
19,496 Ko : TI-83 Premium CE + TI-Python
19,700 Ko : TI-82 Advanced Edition Python
17,601 Ko : TI-83 Premium CE Edition Python / TI-84 Plus CE Python Edition

252,1 Mo : HP Prime G2
15,6 Mo : HP Prime G1
2,051 Mo : TI-Nspire CX II
2,049 Mo : TI-Nspire (Ndless + MicroPython)
1,033 Mo : Casio Graph 90+E / fx-CG50
1,025 Mo : TI-Nspire CX / CX II (Ndless + KhiCAS CX / KhiCAS CX II)
257,026 Ko : Casio Graph 35/75+E / 35/75/95 / fx-9750/9860GII (SH4 - appli CasioPython)
100,432 Ko : Casio Graph 35+E II / fx-9750/9860GIII
98,928 Ko : NumWorks (firmware Omega)
64,954 Ko : NumWorks N0110 (firmware Omega + appli KhiCAS)
32,571 Ko : NumWorks
32,256 Ko : Casio Graph 35+E II / 35/75/85/95(SH3) / fx-9750/9860GIII / fx-9750/9860GII(SH3) / fx-9860G (appli CasioPython)
25,235 Ko : NumWorks N0110 (firmware Delta)
22,158 Ko : TI-83 Premium CE + TI-Python (firmware tiers)
19,496 Ko : TI-83 Premium CE + TI-Python
19,700 Ko : TI-82 Advanced Edition Python
17,601 Ko : TI-83 Premium CE Edition Python / TI-84 Plus CE Python Edition

by **critor** » 15 Aug 2021, 22:37

Quelle Calculatrice Choisir 2021 édition Universelle

Épisode 4 - Écrans et zone graphique utile

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 132 modèles différents de calculatrices testés sous toutes leurs coutures, 10 ans de tests et découvertes à porté de clic !

Dans un épisode précédent, nous t'avons révélé les définitions en pixels des écrans de nos calculatrices graphiques.

Mais la définition ne fait pas tout, faut-il encore pouvoir utiliser les pixels en question. Bien souvent ce n'est qu'une partie de l'écran qui comporte des pixels contrôlables par l'utilisateur (c'est-à-dire allumables dans la couleur ou teinte souhaitée). Nous appellerons cette partie de l'écran zone graphique utile.

Nous allons donc déterminer la taille en pixels de la zone graphique utile de chaque modèle. Pour aujourd'hui nous le ferons dans le contexte du tracé de graphes, ainsi que de l'exécution de programmes en langage constructeur (hors Python donc).

Dans la plupart des cas, il nous suffira d'effectuer 2 simples calculs :

$mathjax$\frac{x_{max}-x_{min}}{Δx}+1$mathjax$
$mathjax$\frac{y_{max}-y_{min}}{Δy}+1$mathjax$

x_min et x_max étant les bornes horizontales de la fenêtre graphique, y_min et y_max les bornes verticales, Δx la distance entre 2 pixels sur l'axe horizontal, et Δy la distance entre 2 pixels sur l'axe vertical

Les Lexibook GC3000FR et Esquisse GCEXFR offrent un écran de 47×32+40×8 pixels + 33 drapeaux.

Que contrôle-t-on dans tout ça ? Déjà pas grand chose car la machine n'est pas programmable malgré la présence trompeuse d'une touche

PROG

au clavier, une inadéquation manifeste aux programmes scolaires, et encore ce n'est même pas le pire de ses défauts de ce point de vue...

Bref pour tester la zone graphique (in)utile, il ne nous reste plus que les graphiques. Par défaut nous avons donc un repère orthonormal, avec un pas de 0.2 entre deux pixels horizontaux ou verticaux.
Récupérons les bornes de la fenêtre, une par une car la technologie archaïque qu'il semble y avoir sous le capot est incapable d'afficher simultanément plusieurs nombres à l'écran :

Allons-y pour les calculs :

$mathjax$\frac{\left(4.6-\left(-4.6\right)\right)}{0.2}+1=\frac{\left(4.6+4.6\right)}{0.2}+1\\
\phantom{\frac{\left(4.6-\left(-4.6\right)\right)}{0.2}+1}=\frac{9.2}{0.2}+1\\
\phantom{\frac{\left(4.6-\left(-4.6\right)\right)}{0.2}+1}=46+1\\
\phantom{\frac{\left(4.6-\left(-4.6\right)\right)}{0.2}+1}=47$mathjax$
$mathjax$\frac{\left(3-\left(-3\right)\right)}{0.2}+1=\frac{\left(3+3\right)}{0.2}+1\\
\phantom{\frac{\left(3-\left(-3\right)\right)}{0.2}+1}=\frac{6}{0.2}+1\\
\phantom{\frac{\left(3-\left(-3\right)\right)}{0.2}+1}=30+1\\
\phantom{\frac{\left(3-\left(-3\right)\right)}{0.2}+1}=31$mathjax$

Zone graphique utilisable donc de 47×31 pixels.
Oui, la zone matricielle correspondant sur l'écran faisant 32 pixels de hauteur, il y a donc physiquement et bêtement une ligne de 47 pixels qui ne s'allument jamais...

Ce qui nous permet en passant de dénoncer un autre mensonge de l'emballage et du manuel, si tu comptes bien la sinusoïde donnée en exemple y est en effet tracée sur une zone graphique 48×32 pixels, soit une surestimation de plus de 5%... Forcément avec ça, la sinusoïde réellement obtenue est loin d'être aussi belle que celle de l'emballage...

Comment peut-on avoir un packaging aussi mensonger, aussi trompeur, sans le faire exprès ?...

Les TI-82 Advanced et TI-84 Plus T t'offrent donc un écran monochrome 96×64 pixels.

Effectuons notre calcul :

Code: Select all: (Xmax-Xmin)/PasX+1 (Ymax-Ymin)/PasY+1

La zone graphique contrôlable par l'utilisateur est pour sa part de 95×63 pixels soit 97,41% !

Les TI-82 Advanced Edition Python, TI-83 Premium CE et TI-84 Plus CE t'offrent un écran couleur 320×240 pixels.

De même :

Code: Select all: (Xmax-Xmin)/ΔX+1 (Ymax-Ymin)/ΔY+1

La zone graphique utile pour les graphes et programmes est ici de 265×165 pixels, soit seulement 56,93%, à peine plus de la moitié des pixels !

Les Casio Graph 25+E, Graph 35+E et Graph 75+E ont un écran de 128×64 pixels.

Il n'y a ici pas de variable système équivalente au Δy pour notre calcul, mais on peut se débrouiller en faisant attention à bien avoir un repère orthonormal, ce qui est justement le cas par défaut :

Code: Select all: (Xmax-Xmin)/Xdot+1 (Ymax-Ymin)/Xdot+1

La zone graphique utile pour l'utilisateur est ici de 127×63 pixels soit 97,41% !

La Casio Graph 90+E t'offre un écran de 396×224 pixels.

Même difficulté que l'on contourne comme pour les modèles précédents :

Code: Select all: (Xmax-Xmin)/Xdot+1 (Ymax-Ymin)/Xdot+1

La zone graphique contrôlable par les graphes et programmes est ici de 379×187 pixels soit seulement 79,90%.

La Casio fx-92+ Spéciale Collège intègre un écran de 192×63 pixels et 20 drapeaux.

La calculatrice est programmable dans un langage orienté tracé, avec des déplacements spécifiés en pixels. Nous pouvons donc ici tenter de dessiner un rectangle le plus grand possible :

Code: Select all: ?→A ?→B Stylo relevé Tourner de ↺ 180 degrés Avancer de Ent(A÷2pixels Tourner de ↺ 90 degrés Avancer de Ent(B÷2pixels Stylo écrit Répéter 2 Tourner de ↺ 90 degrés Avancer de A pixels Tourner de ↺ 90 degrés Avancer de B pixels ⤴

C'est en saisissant 191 et 46 que l'on arrive à tracer le plus grand rectangle, ce qui correspond donc à une zone graphique contrôlable de 192×47 pixels, soit 74,48% de la zone matricielle de l'écran.

Les TI-Nspire, qu'elles soient à écran couleur ou monochrome, nous offrent toutes 320×240 pixels.

Pour déterminer la taille de la zone graphique utile, nous pouvons reprendre la technique précédente de tracé de rectangle :

Code: Select all: Define test(longueur, largeur)= Prgm SetColor 255, 0, 0 DrawRect 0, 0, longueur, largeur EndPrgm

C'est en appelant test(317, 211) que l'on arrive à tracer le plus grand rectangle, ce qui correspond donc à une zone graphique utilisateur de 318×212 pixels, soit 87,78% de l'écran.

La HP Prime t'offre un écran de 320×240 pixels.

Reprenons la méthode du rectangle :

Code: Select all: EXPORT test(long, larg) BEGIN RECT_P(0, 0, long, larg, #FF0000h, #FF000000h); WAIT(); END;

C'est l'appel test(319, 239) qui nous affiche le plus grand rectangle rentrant dans l'écran. Cela correspond donc à une zone graphique utilisateur de 320×240 pixels, soit 100% de l'écran !

La Casio fx-CP400+E inclut niveau définition de loin le meilleur écran tous modèles confondus, 320×528 pixels.

Niveau zone graphique utile maintenant, c'est compliqué, ou plutôt ça dépend.

Code: Select all: (xmax-xmin)/xdot+1 (ymax-ymin)/ydot+1

En orientation portrait nous avons par défaut 309×185 pixels.

Si tu te donnes la peine de redimensionner la fenêtre graphique en pleine page à l'aide du bouton tactile physique Resize en bas d'écran, ce seront 309×401 pixels.

Tu peux également utiliser ta calculatrice en orientation paysage. Mais pas d'accéléromètre ici et donc rien d'automatique, c'est le bouton tactile physique Resize en bas d'écran qui est à utiliser ici à chaque fois que tu souhaites changer, un peu comme sur la console portable Lynx d'Atari.

Par défaut tu disposes dans ce sens d'une zone graphique de 517×81 pixels, une zone que nous trouvons bien trop écrasée et donc peu adaptée à étudier autre chose que des fonctions trigonométriques.

Si tu redimensionnes en pleine page, tu peux étendre la chose à 517×193 pixels

Bref, que retenir de tout ça pour confrontation à la concurrence ?

Déjà on peut préciser qu'il est impossible d'exécuter des programmes en orientation paysage, donc autant prendre l'orientation portrait commune.
Optons donc pour les 309×401 pixels, soit 73,33%.

La NumWorks t'apporte un écran de 320×240 pixels.

Pour les graphes nous n'avons pas trouvé de moyen automatique de mesurer la fenêtre graphique. Alors tant pis comptons les pixels à la main, ci-contre 320×204 pixels, soit 85%.

Les mesures sont facilement comparables sur le lien ci-dessous, et même disponibles pour bien d'autres modèles plus anciens :

Accès QCC 2021 Universel

by **critor** » 15 Aug 2021, 11:25

Quelle Calculatrice Choisir 2021 édition Universelle

Épisode 3 - Écrans et luminosités

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 :

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

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

Dans l'épisode précédent nous avons donc commencé à nous intéresser aux écrans de nos calculatrices. Certains de ces écrans, souvent en couleurs, disposent d'un éclairage. Nous allons aujourd'hui mesurer leur luminosité.

L'année dernière nous avions mesuré les luminosités à l'aide d'un TI-Innovator Hub connecté à une TI-83 Premium CE, le TI-Innovator Hub intégrant en effet un capteur de luminosité.

Toutefois sa forme non parfaitement parallélépipédique ne permettait pas de le poser de façon parfaitement stable sur chaque écran, et nécessitait donc de nous placer en chambre noire pour éliminer la luminosité ambiante parasite.

Cette année nous avons mieux. cent20 nous a en effet bien gracieusement envoyé sa sonde de luminosité Vernier.

La sonde est munie d'une prise BT-A (le format historique de British Telecom pour la téléphonie analogique), et peut être connectée à notre TI-83 Premium CE à l'aide de l'interface Vernier EasyLink.

Le capteur est ici enfermé dans le renfoncement d'un cylindre ce qui, une fois posé à la verticale sur les écrans à mesurer, atténue ici très fortement la luminosité ambiante extérieure. Plus de besoin absolu d'une chambre noire donc, nous pouvons ainsi te mesurer rapidement les luminosités non seulement pour les modèles actuels mais également leurs prédécesseurs.

La mesure va être effectuée :

avec la sonde posée à la verticale au centre de l'écran
sur écran blanc (obtenu selon le modèle sur un écran de calcul vidé de son historique, à l'écran graphique en désactivant les axes, ou encore par utilisation d'un programme)
avec différents réglages de luminosité

La Casio Graph 75+E dispose d'un éclairage manuel de l'écran, activable via

SHIFT

OPTN

.

La luminosité n'est pas réglable, nous obtenons sur 2 machines une valeur faiblarde de 0,0011, sans doute suffisante pour un écran monochrome.

Sur HP Prime, la luminosité se règle au clavier avec

On

et

On

. Nous ignorons la valeur par défaut, le redémarrage de la calculatrice conservant la dernière valeur réglée.

Nous obtenons en moyenne sur 4 machines :

0,0111 avec la luminosité réglée au maximum
0,0012 avec la luminosité réglée au minimum

Nous sommes du côté obscur, clairement le pire écran couleur niveau luminosité tous modèles confondus.

Passons à la Casio fx-CP400+E. La luminosité est ici ajustable dans l'application Système. Par défaut de 7/13, elle peut être réglée sur des valeurs allant de 1/13 à 13/13. Après 30 secondes d'inutilisation (également réglable sur 1, 3 ou même 10 minutes), la calculatrice passe en mode économie d'énergie avec un réglage correspondant à 0/13.

Sur 2 machines, nous mesurons en moyenne :

0,0112 avec la luminosité réglée au maximum (13/13)
0,0058 avec la luminosité par défaut (7/13)
0,0017 avec la luminosité réglée au minimum (1/13)
0,0006 une fois la calculatrice passée en mode économie d'énergie

Ici non plus, nous n'avons clairement pas une lumière...

Voici maintenant la Casio Graph 90+E. La luminosité est ici réglable dans l'application Système. La valeur est de 3/5 par défaut, et peut être réglée de 1/5 à 5/5. Après 30 secondes d'inutilisation, la calculatrice passe en mode économie d'énergie avec un réglage correspondant à 0/5. A noter qu'en mode examen le comportement de ce mode économie d'énergie est différent, réglant la luminosité non pas à 0/5 mais 1/5, peut-être pour que l'écran soit davantage visible et donc plus facilement vérifiable pour les surveillants qui circulent.

Nous mesurons en moyenne sur 5 machines :

0,01486 avec la luminosité réglée au maximum (5/5)
0,00618 avec la luminosité par défaut (3/5)
0,00202 avec la luminosité réglée au minimum (1/5)
0,00076 en économie d'énergie hors mode examen (0/5)

La luminosité maximale de 5/5 est ici aussi très décevante, un écran couleur fort peu lumineux malgré ses indéniables autres qualités (dimensions, définition).

Voici maintenant les TI-Nspire CX. La luminosité est ici ajustable au clavier avec

⌂

et

⌂

. Nous ignorons hélas la luminosité par défaut car il ne semble pas y avoir de moyen de la réinitialiser, la dernière valeur réglée étant conservée après redémarrage de la calculatrice. Il aurait fallu avoir une machine neuve jamais utilisée sous la main. Le mode économie d'énergie sur un délai d'inutilisation réglable de 1 minute à 30 minutes, consiste ici à éteindre radicalement la calculatrice et n'est donc pas pertinent à mesurer niveau luminosité.

Les mesures collectées sur pas moins de 12 machines produites sur près de 10 ans sont moins nettes. Il est possible que nous ayons à la fois une atténuation de la luminosité avec l'âge des machines, et ce qui semble être un changement matériel par Texas Instruments pour un éclairage moins lumineux à compter de la révision matérielle W de fin 2015.

Nous retiendrons en moyenne, d'une part sur les machines de révision matérielle W ou supérieure (dont les dernières TI-Nspire CX II) produites depuis fin 2015 :

0,017175 avec la luminosité réglée au maximum
0,00245 avec la luminosité réglée au minimum

D'autre part sur les machines de révision matérielle V ou inférieure produites jusqu'à la rentrée 2015 :

0,018975 avec la luminosité réglée au maximum
0,0027125 avec la luminosité réglée au minimum

C'est déjà pas mal du tout, après la nuit le jour pointe enfin à l'horizon.

Nous passons maintenant aux TI-83 Premium CE et TI-82 Advanced Edition Python. La luminosité est réglable au clavier avec

2nde

↑

et

2nde

↓

. La machine passe en mode économie d'énergie après 1min30 d'inutilisation.

Ici aussi, sur un échantillon de 12 machines produites avec jusqu'à 6 d'écart dans la production, les mesures ne sont pas claires. Il est possible que nous ayons à la fois une atténuation de l'éclairage avec la duré d'utilisation de la machine, et un changement matériel par Texas Instruments pour un écran plus lumineux à compter de la révision matérielle M, ou de certaines révisions matérielles M (assemblées pour la rentrée 2019).

Nous retiendrons en moyenne, d'une part sur les machines de révision matérielle M ou supérieure (dont les dernières TI-83 Premium CE Edition Python et TI-82 Advanced Edition Python) :

0,0200 avec la luminosité réglée au maximum
0,0095 avec la luminosité par défaut
0,0025 avec la luminosité réglée au minimum
0,0007 une fois la machine passée en mode économie d'énergie

D'autre part sur les machines de révision matérielle M ou inférieure :

0,0153 avec la luminosité réglée au maximum
0,0074 avec la luminosité par défaut
0,0019 avec la luminosité réglée au minimum
0,0007 une fois la machine passée en mode économie d'énergie

Enfin de la lumière !

Et enfin arrive la NumWorks. La luminosité y est ajustable dans l'application Paramètres sur 13 valeurs différentes avec le firmware officiel. Nous ne sommes pas sûrs de la valeur par défaut, le réglage étant ici encore persistant. La machine passe en économie d'énergie après 30 secondes, mais cela correspond très exactement au réglage minimal de la luminosité.

Les mesures ne sont ici non plus pas uniques, mais au moins la distinction est très nette.

D'une part sur l'ancien modèle N0100 de la rentrée 2017, nous avons de façon formidable :

0,03187 avec la luminosité réglée au maximum
0,00187 aussi bien avec la luminosité réglée au minimum qu'en mode économie d'énergie

Sur le nouveau modèle N0110 depuis la rentrée 2019 c'est encore plus extraordinaire :

0,04435 avec la luminosité réglée au maximum
0,00285 aussi bien avec la luminosité réglée au minimum qu'en mode économie d'énergie

Une machine brillante !

Rappelons qu'avec le firmware tiers Omega tu ~~auras~~ avais le choix entre 17 valeurs de réglages de la luminosité, et qu'en prime la luminosité était réglable à tout moment au clavier via

shift

et

shift

.

Les mesures maximales sont facilement comparables sur le lien ci-dessous, et même disponibles pour bien d'autres modèles plus anciens :

Accès QCC 2021 Universel

by **critor** » 14 Aug 2021, 09:25

Quelle Calculatrice Choisir 2021 édition Universelle

Épisode 2 - Écrans ; définition et diagonale

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 132 modèles différents de calculatrices testés sous toutes leurs coutures !

Dans l'épisode précédent nous avons donc mesuré les boîtiers de nos calculatrices. Mais, pour une calculatrice, être petit n'a pas que des avantages, et être gros n'a pas que des inconvénients. En effet une grande taille permet, en théorie, un plus grand écran.

Passons donc dans l'épisode aujourd'hui aux écrans, avec leurs définition et diagonale.

Pour la diagonale de l'écran c'est certes une information fournie par les constructeurs, mais nous ignorons si ils la mesurent tous selon le même protocole. Diagonale de la pièce écran ? Diagonale du cadre ou fenêtre sur le boîtier de la calculatrice ? Diagonale affichable ?
La communication des constructeurs a tendance a ne retenir que la mesure qui les arrange, pas toujours la plus naturelle pour l'utilisateur final.

Nous ne tiendrons compte pour notre part bien évidemment que de la zone utile de l'écran, c'est-à-dire pouvant afficher quelque chose, excluant donc les bordures notamment sur les modèles monochromes. Pour les écrans hybrides disposant de drapeaux, nous exclurons ces derniers de cette mesure pour nous concentrer sur leur zone matricielle.

Si Maman te rapporte des courses à la rentrée une Esquisse GCEXFR ou Lexibook GC3000FR, tu auras sans doute à t'interroger sur le sens caché de ce message d'une rare violence.

Le packaging est mensonger, te présentant via un sticker un écran à cristaux liquides noirs, qui se transforme une fois allumé en cristaux liquides bleus fort mal contrastés et ainsi désagréables à lire, et contrairement à tous les modèles précédents aucune fonctionnalité n'a été prévue pour en régler le contraste !

L'écran n'est pas matriciel mais hybride. Tellement dur à lire que pour mieux t'en détailler l'intégralité des faibles capacités, nous avons dû te faire un petit montage ci-contre. Nous avons donc :

une zone matricielle dédiée aux graphiques de 47×32=1504 pixels en bas à gauche soit un timbre poste, littéralement...
une zone matricielle complémentaire de 40×8=320 pixels en bas à droite, qui par juxtaposition permet la saisie de tes calculs et l'affichage de leurs résultats sur 87 pixels de largeur
2 afficheurs numériques à 7 segments dédiés à l'affichage des exposants de 10 pour les résultats en notation scientifique
19 autres drapeaux de formes diverses

Il s'agit donc d'un écran assimilable à du 47×32+40×8+2×7+19=1857 pixels.

L'écran est ainsi également un mensonge en lui-même, une bonne partie de sa surface ne pouvant rien afficher. Avec de plus une zone matricielle qui n'est même pas rectangulaire, quelle diagonale mesurer alors ? Nous retenons la principale zone matricielle en bas à gauche, soit un ridicule 1,64" de diagonale.

Les TI-82 Advanced et TI-84 Plus T t'offrent un écran monochrome de 96×64=6144 pixels soit un rapport de 3/2. Un écran utilisant de plus des cristaux liquides noirs fort bien contrastés.

Avec 2,48", c'est l'écran le plus étroit toutes calculatrices confondues

L'ancienne Graph 25+E utilise un écran monochrome de 128×64=8192 pixels soit un rapport de 2/1 caractérisant un écran large.

Avec 2,39" pour la plus petite diagonale d'écran, il compte parmi les plus petits écrans toutes calculatrices graphiques confondues. Attention, c'est ici aussi encore un des rares écrans mal contrastés car utilisant des cristaux liquides bleus, et ainsi peu agréable à lire sans un bon éclairage extérieur.

Les Graph 25+E II et Graph 35+E restent sur le format 128×64=8192 pixels

Ici par contre la diagonale est nettement mieux dimensionnée, 2,57", et ici en prime l'écran est correctement contrasté avec des cristaux liquides noirs très lisibles.

La très regrettée ancienne Graph 75+E reprend le même format 128×64=8192 pixels.

Mais ici c'est un formidable 2,96" de diagonale.

La Casio fx-92+ Spéciale Collège intègre un contrôleur écran gérant 192×64=12288 pixels, soit un rapport de 3/1 caractérisant un écran ultra large.
En réalité son écran est hybride, avec :

une zone matricielle de 192×63=12096 pixels
20 drapeaux indicatifs en haut d'écran, assimilables à des pixels mais aux formes non élémentaires

Ce qui nous donne par assimilation 192×63+20=12116 pixels, mine de rien un écran aux capacités supérieures à celles des écrans de certaines calculatrices graphiques.

La zone matricielle occupe 2,38" en diagonale, comparable à certains écrans de calculatrices graphiques bien que légèrement plus petit, à vraiment pas grand chose le plus petit écran toutes calculatrices confondues. C'est son format atypique allongé horizontalement qui lui permet mine de rien de rivaliser.

Les TI-Nsire monochromes disposent d'un écran 320×240=76800 pixels, soit l'ancien rapport 4/3 des écrans de télévisions et ordinateurs.

Nous bénéficions ici d'un formidable 3,44" de diagonale.

Les TI-82 Advanced Edition Python, TI-83 Premium CE, TI-84 Plus CE et NumWorks restent sur le format 320×240=76800 pixels mais cette fois-ci avec un écran couleur.

Avec 2,83" de diagonale, elles ont aussi le plus petit écran couleur.

Avec les TI-Nspire CX, nous restons sur l'écran couleur 320×240=76800 pixels.

Mais nous profitons ici d'une diagonale un peu plus généreuse avec 3,13".

La HP Prime reste sur du 320×240=76800 pixels couleur mais en tactile.

Mais nous sautons ici directement à du 3,44" de diagonale, formidable !

La Casio Graph 90+E utilise un formidable écran couleur en 396×224=88704 pixels, soit à peu près le rapport 16/9 plus contemporain des écrans de télévisions et ordinateurs.

Avec un formidable 3,28" de diagonale affichable, c'est aussi l'écran le plus large toutes calculatrices graphiques confondues.

La Casio fx-CP400+E inclut niveau définition de loin le meilleur écran tous modèles confondus, un écran couleur tactile 320×528=168960 pixels.

Nous bondissons enfin à du 4,76" de diagonale, absolument gigantesque !

Les caractéristiques et mesures sont facilement comparables sur le lien ci-dessous, et même disponibles pour bien d'autres modèles plus anciens :

Accès QCC 2021 Universel