Sortie/test TI-Nspire CX II 5.2 Python + QCC 2020 épilogue

[critor]

Texas Instruments nous sort enfin aujourd'hui sa tant attendue mise à jour de rentrée TI-Nspire CX II, la version 5.2.

Il s'agit plus précisément d'une version 5.2.0.771 compilée le 15 août 2020 à 4h52.

Cette mise à jour apporte une grande nouveauté, une application Python, que nous allons nous empresser de découvrir avec toi, et qui reste entièrement accessible en mode examen.


Sommaire :

1. Editeur et modèles de scripts
2. 1er script et console - nombres flottants et complexes
3. Modules importables et modules standard
4. Saisie et assistant d'aide à la saisie
5. Mémoire pile/stack
6. Mémoire tas/heap
7. Module sys - implementation et entiers
8. Module ti_system - intégration, clavier et souris
9. Module de tracé par pixels ti_draw
10. Module de tracé par pixels ti_image
11. Module de tracé par pixels ti_picture
12. Bilan modules
13. Performances en virgule flottante
14. Performances en calcul entier
15. Conclusion

1) Editeur et modèles de script :

Go to top

Sur TI-Nspire CX II, le Python n'est pas une application ayant l'honneur d'être directement disponible à l'écran d'accueil de la calculatrice. Il te faut créér un document et ensuite le Python sera listé en tant que 10^ème type d'application rajoutable sur chaque page. L'application peut de plus être rajoutée sous deux formes différentes dont on nous propose le choix :

• éditeur de script (nouveau ou ouvrir)
• console (shell)

Commençons donc par l'éditeur avec un nouveau script. Afin de pouvoir démarrer très vite dans nombre de situations au lycée, Texas Instruments t'a conçu sur-mesure pas moins de 9 modèles de scripts prédéfinis :

Calculs
mathématiques Simulations
aléatoires Graphiques
géométriques Traitement
d'image Tracé (x,y)
et texte Partage
des données Projet
hub Codage
du Rover

Code: Select all

# Math Calculations
#================================
from math import *
#================================

Code: Select all

# Random Simulations
#================================
from math import *
from random import *
#================================

Code: Select all

# Geometry Graphics
#================================
from ti_draw import *
#================================

Code: Select all

# Image Processing
#================================
from ti_image import *
from ti_draw import get_screen_dim
#================================

Code: Select all

# Plotting (x,y) & Text
#================================
import ti_plotlib as plt
#================================
plt.window(,,,)
plt.grid(1,1,"dotted")
plt.axes("on")

Code: Select all

# Data Sharing
#================================
from ti_system import *
#================================

Code: Select all

# Hub Project
#================================
from ti_hub import *
from math import *
from time import sleep
from ti_plotlib import text_at,cls
from ti_system import get_key
#================================

Code: Select all

# Rover Coding
#================================
import ti_rover as rv
from math import *
import ti_plotlib as plt
from ti_system import *
from time import *
#================================

Nous accédons donc à un très bel éditeur. Notons en passant que TI a même pensé à nous rajouter une petite icône Python dans l'interface en question, histoire qu'on ne la confonde avec celle de l'éditeur de programmes.

Il bénéficie de la coloration syntaxique, de l'indentation automatique, peut afficher simultanément jusqu'à 11 lignes, et le numéro de la ligne courante étant reporté en haut à droite, fort utile pour corriger les éventuelles erreurs d'exécution.

Un éditeur très complet, on peut y réaliser des sélections en maintenant enfoncée la touche

shift

comme sur ordinateur, couper-copier-coller-effacer la sélection courante à l'aide des racourcis

ctrl

X

,

ctrl

C

,

ctrl

V

et

del

. La touche

menu

donnera accès à d'autres fonctionnalités tout en en rappelant les raccourcis clavier : aller en début/fin de ligne, en début/fin de script, aller à un numéro de ligne, rechercher, remplacer.

Gros avantage par rapport à la concurrence, on y trouve également un vérificateur syntaxique qui te permettra de gagner du temps en anticipant nombre d'erreurs qui t'auraient embêté(e) à l'exécution. En prime contrairement aux erreurs d'exécution dans la console Python qui habituellement n'indiquent qu'un numéro de ligne, la vérification syntaxique depuis l'éditeur t'amènera directement sur la ou les lignes à corriger !

2) 1er script et console - nombres flottants et complexes :

Go to top

Bon, maintenant que nous savons utiliser l'éditeur, tentons de premiers tests simples histoire de se mettre en jambe. Etudions un petit peu le moteur de calcul numérique du Python en question.

Commençons par les nombres en virgule flottante dits flottants. Ce type de donnée utile pour les nombres non entiers sous la forme

$mathjax$M\times 2^{E-E_{min}}$mathjax$

, avec :

• M, un nombre entier relatif dit mantisse
• E_min, nombre entier négatif indique l'exposant minimal pouvant être codé
• E, nombre entier naturel codant l'exposant

Voici donc nos toutes premières fonctions Python sur TI-Nspire CX II :

Code: Select all

def precm(b):
  k,b=0,float(b)
  while 1+b**-k-1>0:
    k+=1
  return k

def prece():
  a=-1
  while 2.**a>0:
    a*=2
  while 2.**a==0:
    a+=1
  b=1
  while str(2.**b)[0:3]!='inf':
    b*=2
  while str(2.**b)[0:3]=='inf':
    b-=1
  return [a,b]

Pour exécuter tout ça on peut certes recommencer comme plus haut et insérer une application Python cette fois-ci format console (shell) sur une nouvelle page, console dans laquelle il faudra donc importer manuellement notre script.

Mais on peut également utiliser la touche

menu

pour demander directement l'exécution du script depuis l'éditeur, auquel cas ce dernier sera importé automatiquement.

Notons la touche

var

qui te permet de lister et saisir rapidement les noms de fonctions et variables globales définies dans le script.

L'appel precm(2) nous répond que le moteur travaille en virgule flottante avec des mantisses dont la précision est codée sur 53 bits, permettant environ 16 chiffres significatifs en écriture décimale (precm(10)), et auxquels il faut bien évidemment rajouter 1 bit de signe.
L'appel prece() nous indique pour sa part que les valeurs codables pour les exposants dans la formule vont de -1075 à +1023.
Il s'agit du standard double précison du Python, un excellent choix pour le contexte scientifique du lycée, et à ce jour toutes les calculatrices concurrentes disposant d'une véritable implémentation Python répondent la même chose.

Notons au passage avec la saisie 1j la gestion des nombres complexes dits imaginaires (Option Maths Expertes + série STI2D).

3) Modules importables et modules standard :

Go to top

Tentons maintenant de réaliser ensemble une première esquisse de l'étendue de la solution Python TI-Nspire CX II, avec l'éventail de modules disponibles.

Pour explorer, nous allons commencer par aller dans la console, ici encore flanquée du logo Python histoire qu'on ne le confonde pas avec l'application calculs.

La touche

menu

nous donne alors un accès très rapide à une sélection de différentes fonctions Python classées par catégories correspondant justement à des modules.

Outre le module builtins (intégrés), nous notons donc la disponibilité des modules :

• math
• random pour les fonctions aléatoires
• ti_plotlib, module de tracé par coordonnées
• ti_hub pour les projets d'objets connectés avec l'interface TI-Innovator Hub
• ti_rover pour les projets de robotique avec le robot TI-Innovator Rover

Une sélection complémentaire de modules est également accessible via un sous-menu :

• cmath pour les fonctions relatives aux nombres imaginaires/complexes (Option Maths Expertes + série STI2D)
• time
• ti_system
• ti_draw, module de tracé par pixels
• ti_image, autre module de tracé par pixels

Mais nous savons par expérience que tous les modules disponibles ne sont pas forcément au menu. Tentons donc d'en demander une liste via la fonction help(), et plus précisément help('modules').

Nous obtenons alors une liste qui n'est pas complète, reprenant certains des modules précédents mais pas tous. Par contre, elle nous en annonce d'autres que voici :

• array
• binascii
• collections
• ctypes
• errno
• gc
• hashlib
• heapq
• micropython
• re
• sys
• ti_picture
• ti_st

Commençons par traiter les modules Python standard. Nous indiquerons en rouge les modules qui ne sont utilisables qu'hors examen.

La solution Python de la TI-Nspire CX II semble être excellente niveau standard avec pas moins de 16 modules, de loin la meilleure sélection officielle sur ce critère, aussi bien en examen qu'en classe !

TI- 83PCE TI- Python

TI- 83PCE Edition Python

TI- 84+CE-T Python Edition

TI- Nspire CX II

Casio Graph 90+E 35+E II

Num Works

HP Prime α

TI- 83PCE TI- Python tiers

TI- Nspire Ndless μPython

TI- Nspire CX Ndless χCAS

Casio Graph 35/75+E 35+E II CasioPython

Num Works Ω

Num Works Ω χCAS

builtins array (u)binascii board cmath (u)collections (u)ctypes (u)errno gc (u)hashlib (u)heapq (u)io (u)json linalg math matplotlib .pyplot micropython numpy os (u)random (u)re storage (u)struct sys time (u)timeq turtle (u)zlib TOTAL

✓ ✓ . . . ✓ . . ✓ . . . . . ✓ . . . . . ✓ . . . ✓ ✓ . . . 8

✓ ✓ . . . ✓ . . ✓ . . . . . ✓ . . . . . ✓ . . . ✓ ✓ . . . 8

✓ ✓ . . . ✓ . . ✓ . . . . . ✓ . . . . . ✓ . . . ✓ ✓ . . . 8

✓ ✓ ✓ . ✓ ✓ ✓ ✓ ✓ ✓ ✓ . . . ✓ . . ✓ . . ✓ ✓ . . ✓ ✓ . . . 16

✓ . . . . . . . . . . . . . ✓ . ✓ . . . ✓ . . . . . . ✓ . 3-5

✓ . . . ✓ . . . . . . . . . ✓ ✓ ✓ ✓ . . ✓ . . . . ✓ . ✓ . 9

✓ ✓ . . ✓ . . ✓ ✓ . . . . . ✓ . . ✓ . . . . . . ✓ . . . . 8

✓ ✓ . ✓ ✓ ✓ . . ✓ . . . . . ✓ . . ✓ . ✓ ✓ . ✓ . ✓ ✓ . . . 13

✓ ✓ . . ✓ . . . ✓ . . . . . ✓ . . ✓ . . . . . . ✓ . . . . 7

✓ . ✓ . ✓ ✓ ✓ ✓ ✓ ✓ ✓ ✓ ✓ ✓ ✓ . ✓ ✓ ✓ ✓ ✓ ✓ . ✓ ✓ . . ✓ ✓ 23

✓ ✓ . . ✓ . . . ✓ . . . . . ✓ . . ✓ . . ✓ . . . ✓ . . . . 8

✓ . . . ✓ . . . . . . . . . ✓ ✓ ✓ ✓ . ✓ ✓ . . . . ✓ . ✓ . 10

✓ . ✓ . ✓ ✓ ✓ . ✓ ✓ ✓ ✓ ✓ ✓ ✓ . ✓ ✓ ✓ ✓ ✓ ✓ . ✓ ✓ . ✓ ✓ ✓ 23

Passons maintenant aux modules propriétaires lorsque disponibles :

TI- 83PCE Edition Python	TI- 84+CE-T Python Edition	TI- Nspire CX II	Casio Graph 90+E 35+E II	Num Works	HP Prime α	TI- Nspire Ndless μPython	TI- Nspire CX Ndless χCAS	Num Works Ω	Num Works Ω χCAS
analogin analogout bbport brightns ce_box ce_chart ce_quivr ce_turtl color colorinp conservo dht digital led light lightlvl loudness magnetic mb_butns mb_disp mb_grove mb_music mb_neopx mb_pins mb_radio mb_sensr microbit moisture potentio power ranger relay rgb rgb_arr sound squarewv temperat thermist ti_graphics ti_hub ti_plotlib ti_rover ti_system speaker timer vernier vibmotor	analogin analogout bbport brightns ce_box ce_chart ce_quivr ce_turtl color colorinp conservo dht digital led light lightlvl loudness magnetic mb_butns mb_disp mb_grove mb_music mb_neopx mb_pins mb_radio mb_sensr microbit moisture potentio power ranger relay rgb rgb_arr sound squarewv temperat thermist ti_graphics ti_hub ti_plotlib ti_rover ti_system speaker timer vernier vibmotor	ti_draw ti_hub ti_image ti_innovator ti_picture ti_plotlib ti_rover ti_st ti_system	casioplot	ion kandinsky	prime	nsp	arit cas graphic nsp	ion kandinsky	arit cas graphic nsp
34-47	47	9	1	2	1	1	4	2	4

Il ne nous semble pas pertinent de baser un classement comparatif sur les modules propriétaires, un unique module sur un modèle haut de gamme pouvant apparemment être éclaté en plein de petits modules différents sur un modèle disposant de moins de mémoire. Il faudrait en fait regarder le contenu, ce que nous ferons plus loin. En attendant, voici donc un classement donnant la priorité aux modules standard :

en exam
officiel en exam
tiers hors exam
officiel hors exam
tiers résumé
diagramme

1. 16 modules standard + 9 modules propriétaires : TI-Nspire CX II
2. 9 modules standard + 2 modules propriétaires : NumWorks
3. 8 modules standard + 34 modules propriétaires : TI-83 Premium CE Edition Python
4. 8 modules standard + 1 module propriétaire : HP Prime (version alpha)
5. 3 modules standard + 1 module propriétaire : Casio Graph 90+E / 35+E II

1. 23 modules standard + 4 modules propriétaires : NumWorks (firmware Omega + appli KhiCAS)
2. 16 modules standard + 9 modules propriétaires : TI-Nspire CX II
3. 10 modules standard + 2 modules propriétaires : NumWorks (firmware Omega)
4. 9 modules standard + 2 modules propriétaires : NumWorks
5. 8 modules standard + 34 modules propriétaires : TI-83 Premium CE Edition Python
6. 8 modules standard + 1 module propriétaire : HP Prime (version alpha)
7. 3 modules standard + 1 module propriétaire : Casio Graph 90+E / 35+E II

1. 16 modules standard + 9 modules propriétaires : TI-Nspire CX II
2. 9 modules standard + 2 modules propriétaires : NumWorks
3. 8 modules standard + 47 modules propriétaires : TI-83 Premium CE Edition Python / TI-84 Plus CE-T Python Edition
4. 8 modules standard + 1 module propriétaire : HP Prime (version alpha)
5. 8 modules standard : TI-83 Premium CE + TI-Python
6. 5 modules standard + 1 module propriétaire : Casio Graph 90+E / 35+E II

1. 23 modules standard + 4 modules propriétaires : NumWorks (firmware Omega + appli KhiCAS) + TI-Nspire CX (Ndless + KhiCAS CX)
2. 16 modules standard + 9 modules propriétaires : TI-Nspire CX II
3. 13 modules standard : TI-83 Premium CE + TI-Python (firmware tiers)
4. 10 modules standard + 2 modules propriétaires : NumWorks (firmware Omega)
5. 9 modules standard + 2 modules propriétaires : NumWorks
6. 8 modules standard + 47 modules propriétaires : TI-83 Premium CE Edition Python / TI-84 Plus CE-T Python Edition
7. 8 modules standard + 1 module propriétaire : HP Prime (version alpha)
8. 8 modules standard : TI-83 Premium CE + TI-Python + Casio Graph 35/75+E (appli CasioPython)
9. 7 modules standard + 1 module propriétaire : TI-Nspire (Ndless + MicroPython)
10. 5 modules standard + 1 module propriétaire : Casio Graph 90+E / 35+E II

4) Saisie et assistant d'aide à la saisie :

Go to top

Exclusivité de la solution Python TI-Nspire CX II à ce jour, nous y disposons d'un formidable assistant d'aide à la saisie, à un niveau jusqu'à présent jamais vu.

L'assistant est fonctionnel aussi bien dans l'éditeur que dans la console, dans le contexte des saisies effectuées via un menu.

Par exemple ci-contre avec l'insertion via le menu de blocs d'instructions if et for.

Les différents éléments que tu te dois de compléter dans la saisie te sont notés en gris clair, avec même une inscription indicative. C'est un peu comme un texte à trous.

Si ton curseur se trouve dans l'une des zones en question son affichage passe en inversé. Pas besoin non plus de t'acharner sur les touches fléchées pour aller rejoindre les différents bouts à compléter, tu peux passer instantanément au prochain élément à compléter à l'aide de la touche

tab

!

Cette formidable assistance à la saisie marche de façon similaire avec les paramètres d'appels de fonction insérés via les menus !

D'ailleurs sur certaines fonctions, l'activation d'un des paramètres à compléter pourra même t'afficher des explications ou indications complémentaires sur la saisie attendue !

Sur d'autres paramètres ne pouvant prendre qu'un nombre fini de valeurs, l'activation de leur zone de saisie affichera automatiquement un menu contextuel à partir duquel tu pourras saisir instantanément l'une des valeurs autorisées !

Dans le cas où les valeurs autorisées sont trop nombreuses, tu pourras à la place obtenir ici encore une indication fort utile sous forme d'info bulle.

Enfin, précisons que la saisie d'un point à la suite d'un objet de type prédéfini proposant des méthodes ou sous objets, pourra t'afficher automatiquement un menu contextuel avec les choix en question, et que tu bénéficieras encore dans ce contexte de toutes les fonctionnalités de l'assistant !

Cet assistant d'aide à la saisie TI-Nspire CX II est véritablement exceptionnel et va te permettre d'être encore plus efficace et autonome, minimisant les besoins d'aller recourir à une quelconque documentation !

5) Mémoire pile/stack :

Go to top

Les interpréteurs MicroPython ou similaires qui tournent sur calculatrices font appel à différents types de mémoires. 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.

Tentons donc de déclencher une consommation massive de stack, afin de pouvoir comparer et voir comment s'en sortent la TI-Nspire CX II et les autres. Une situation très simple qui peut être grand consommatrice de stack c'est la récursivité, soit les fonctions qui se rappellent elles-mêmes. Prenons le script suivant, issu du QCC 2020 :

Code: Select all

def compte_r(n):
  return n>0 and 1 + compte_r(n-1)

def test(f):
  n = 0
  try:
    while 1:
      n = f(n) + 1
  except Exception as e:
    print(e)
  return n

Nous atteignons donc sur TI-Nspire CX II un maximum de 202 niveaux de récursion avant erreur. C'est extraordinaire, à la fois le record de toutes les solutions officielles, et le record de toutes les solutions compatibles avec une utilisation mode examen !

D'où le classement des solutions Python niveau stack :

en exam
officiel en exam
tiers hors exam
officiel hors exam
tiers résumé
diagramme

1. 202 : TI-Nspire CX II
2. 129 : NumWorks
3. 82 : Casio Graph 90+E / 35+E II
4. 77 : HP Prime (version alpha)
5. 28 : TI-83 Premium CE Edition Python

1. 202 : TI-Nspire CX II
2. 129 : NumWorks
3. 126 : NumWorks (firmware Omega + appli KhiCAS)
4. 82 : Casio Graph 90+E / 35+E II
5. 77 : HP Prime (version alpha)
6. 28 : TI-83 Premium CE Edition Python

1. 202 : TI-Nspire CX II
2. 129 : NumWorks
3. 82 : Casio Graph 90+E / 35+E II
4. 77 : HP Prime (version alpha)
5. 28 : TI-83 Premium CE Edition Python / TI-84 Plus CE-T Edition Python
6. 20 (45,74% contigu) : TI-83 Premium CE + TI-Python

1. 5362 : Casio Graph 35/75+E (appli CasioPython)
2. 655 : Casio Graph 35+E II (appli CasioPython)
3. 202 : TI-Nspire CX II
4. 155 : TI-Nspire CX (Ndless + KhiCAS CX)
5. 130 : TI-Nspire (Ndless + MicroPython)
6. 129 : NumWorks
7. 126 : NumWorks (firmware Omega + appli KhiCAS)
8. 82 : Casio Graph 90+E / 35+E II
9. 77 : HP Prime (version alpha)
10. 28 : TI-83 Premium CE Edition Python / TI-84 Plus CE-T Edition Python
11. 20 : TI-83 Premium CE + TI-Python
12. 15 : TI-83 Premium CE + TI-Python

6) Mémoire tas/heap :

Go to top

Les interpréteurs MicroPython ou similaires qui tournent sur calculatrices font appel à différents types de mémoires. 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.

Nous avons justement la chance ici de disposer du module gc, 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

Appelons donc le petit script suivant afin d'enfin découvrir la tant attendue taille de heap Python TI-Nspire CX II :

Code: Select all

import gc
a, f = mem_alloc(), mem_free()
(a, f, a + g)

Nous disposons donc ici d'un heap d'une capacité impressionnante, la plus grand actuellement parmi toutes les solutions concurrentes officielles, 2,073 Mo, de quoi a priori te lancer dans des projets Python très ambitieux !
Plus précisément nous avons ici 2,072 Mo de libres, mais auxquels il faut ajouter la taille consommée par l'importation du module gc.

Toutefois, toutes les calculatrices Python ne disposent pas du module gc. Afin de pouvoir faire des comparaisons équitables, nous allons construire notre propre script de test d'estimation de la capacité heap à partir des informations suivantes sur les tailles des objets Python, du moins sur les plateformes 32 bits que sont à ce jour 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

Nous allons donc tenter 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.
Nous récupérerons de plus la plus grand taille d'objet que nous avons réussi à utiliser lors de ce test, on t'explique de suite.

Voici donc le script, toujours issu du QCC 2020 :

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

def mem(v=1):
  try:
    l=[]
    try:
      l.append(0)
      l.append(0)
      l.append("")
      l[2] += "x"
      l.append(0)
      l.append(0)
      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[3], l[4] = mem(v)
      except:
        pass
      return l[0] + l[3], max(l[0], l[4])
  except:
    return 0, 0

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)))

On trouve bien sur TI-Nspire CX II une capacité heap de 2,067 Mo proche de la mesure précédente, à laquelle bien sûr il faut rajouter la consommation du script que nous estimons à 1,056 Ko.
Nous avons ici en prime une autre valeur de 683,256 Ko, correspondant à la taille du plus gros objet qui a pu être créé au cours du test et donc au plus grand espace libre disponible de façon contiguë dans le heap.

D'où le classement des solutions Python niveau heap :

en exam
officiel en exam
tiers hors exam
officiel hors exam
tiers résumé
diagramme

1. 2,068 Mo (33,36% contigu) : TI-Nspire CX II
2. 1,033 Mo (38,18% contigu) : Casio Graph 90+E
3. 1,014 Mo (38,91% contigu) : HP Prime (version alpha)
4. 101,262 Ko (41,74% contigu) : Casio Graph 35+E II
5. 33,545 Ko (40,58% contigu) : NumWorks
6. 18,354 Ko (40,70% contigu) : TI-83 Premium CE Edition Python

1. 2,068 Mo (33,36% contigu) : TI-Nspire CX II
2. 1,033 Mo (38,18% contigu) : Casio Graph 90+E
3. 1,014 Mo (38,91% contigu) : HP Prime (version alpha)
4. 101,262 Ko (41,74% contigu) : Casio Graph 35+E II
5. 64,954 Ko (33,69% contigu) : NumWorks (firmware Omega + appli KhiCAS)
6. 33,545 Ko (40,58% contigu) : NumWorks
7. 18,354 Ko (40,70% contigu) : TI-83 Premium CE Edition Python

1. 2,068 Mo (33,36% contigu) : TI-Nspire CX II
2. 1,033 Mo (38,18% contigu) : Casio Graph 90+E
3. 1,014 Mo (38,91% contigu) : HP Prime (version alpha)
4. 101,262 Ko (41,74% contigu) : Casio Graph 35+E II
5. 33,545 Ko (40,58% contigu) : NumWorks
6. 20,839 Ko (45,74% contigu) : TI-83 Premium CE + TI-Python
7. 18,354 Ko (40,70% contigu) : TI-83 Premium CE Edition Python / TI-84 Plus CE-T Edition Python

1. 4,100 Mo (38,40% contigu) : TI-Nspire CX (Ndless + KhiCAS CX)
2. 2,068 Mo (33,36% contigu) : TI-Nspire CX II
3. 2,050 Mo (32,35% contigu) : TI-Nspire (Ndless + MicroPython)
4. 1,033 Mo (38,18% contigu) : Casio Graph 90+E
5. 1,014 Mo (38,91% contigu) : HP Prime (version alpha)
6. 258,766 Ko (38,51% contigu) : Casio Graph 35/75+E (appli CasioPython)
7. 101,262 Ko (41,74% contigu) : Casio Graph 35+E II
8. 64,954 Ko (33,69% contigu) : NumWorks (firmware Omega + appli KhiCAS)
9. 33,545 Ko (40,58% contigu) : NumWorks
10. 32,648 Ko (41,70% contigu) : Casio Graph 35+E II (appli CasioPython)
11. 23,685 Ko (40,24% contigu) : TI-83 Premium CE + TI-Python (firmware tiers)
12. 20,839 Ko (45,74% contigu) : TI-83 Premium CE + TI-Python
13. 18,354 Ko (40,70% contigu) : TI-83 Premium CE Edition Python / TI-84 Plus CE-T Edition Python

En examen ou parmi les solutions officielles, la TI-Nspire CX II est la meilleure niveau heap !

7) Module sys - implémentation et entiers :

Go to top

Un module très intéressant à explorer pour découvrir des choses, c'est le module standard sys. Il n'est certes pas au menu, mais on peut quand même obtenir la liste des différents éléments qu'il permet d'appeler via un simple dir(sys).

sys.platform == 'TI-Nspire' sera par exemple une astuce de test bien utile pour tes scripts en ayant besoin d'identifier la plateforme sur laquelle ils tournent.

Comme on pouvait s'en douter sys.implementation nous confirme que nous sommes sur un Micropython, en précisant qu'il s'agit d'une version 1.11.0, et implémentant lui-même le Python 3.4.0 comme l'indique sys.version.

sys.maxsize pour sa part indique le plus grand entier pouvant être codé nativement sur la plateforme utilisée, avec ici une organisation little endian comme l'indique sys.byteorder. sys.maxsize détermine la taille maximale de nombre de structures telles les listes. Les variables peuvent quand même prendre des valeurs entières supérieures qui sont alors gérées logiciellement en tant qu'entiers longs.

Sur toute la concurrence nous avions jusqu'à présent sys.maxsize == 2**31 -1, valeur habituelle pour les plateformes 32 bits, 1 bit étant réservé pour le signe.

Ici, on a bizarrement 2**63-1 sur le logiciel ordinateur et 32767 sur calculatrice, ce qui n'est pourtant clairement pas le maximum

8) Module ti_system - intégration, clavier et souris :

Go to top

Tentons maintenant d'en apprendre davantage sur la valeur ajoutée apportée par Texas Instruments à la solution Python de la TI-Nspire CX II. Nous allons pour cela explorer les modules propriétaires ; commençons par regarder du côté du module système de Texas Instruments, le ti_system, et nous évoquerons le module du même nom sur TI-83 Premium CE Edition Python.

Chez la concurrence à ce jour, l'application Python a le défaut de tourner en vase clos dans son coin. Elle ne permet pas de partager des données avec le reste des applications de la calculatrice, et ne s'intègre donc pas naturellement dans la démarche de résolution d'un problème.

Texas Instruments avait déjà proposé un début d'intégration du Python à l'environnement mathématique de la calculatrice avec le module de la TI-83 Premium CE Edition Python. Au menu la possibilité de faire rentrer et sortir des données de l'application Python :

• importation dans l'application Python de variables de type liste existant dans l'environnement de la calculatrice
• exportation depuis l'application Python de variables de type liste vers l'environnement de la calculatrice

Listes de nombres réels uniquement, les nombres complexes étant exclus. Les mêmes données devenaient ainsi traitables sous différentes applications pour une bien meilleure recherche et résolution de problème, faisant intervenir diverses représentations et compétences.

Une fonctionnalité toujours exclusive à Texas Instruments à ce jour et que nous avons le grand plaisir de retrouver ici avec les fonctions store_list() et recall_list().

Texas Instruments en profite même pour étendre la chose. store_value() et recall_value() te permettront la même chose mais cette fois-ci avec des variables numériques (réelles).

Texas Instruments va même beaucoup plus loin que ça avec eval_function(). Cette fonction permet à tes scripts Python de faire appel à une fonction définie dans ton classeur courant, fonctions à une variable uniquement mais c'est déjà un très bon début !

Autre bonne nouvelle, nous avons de quoi tester la pression sur les touches clavier. Non pas une fonction wait_key() blocante ne permettant pas de coder autre chose que des menus et jeux tour par tour comme sur TI-83 Premium CE, mais un véritable get_key() non blocant qui te donnera une totale liberté pour tes projets d'interfaces et jeux !
La fonction get_key() renvoie une chaîne de caractères, identifiant la touche ou combinaison de touches pressée, et en voici une petite carte afin de t'y retrouver :

esc		up		home
scratchpad	left	center	right	doc
tab		down		menu
			var	del

=	trig	7	8	9	template	cat
^	square	4	5	6	*	/
exp	10power	1	2	3	+	-
(	)	0	.	−	enter

E	A/a	B/b	C/c	D/d	E/e	F/f	G/g	?!
pi	H/h	I/i	J/j	K/k	L/l	M/m	N/n
,	O/o	P/p	Q/q	R/r	S/s	T/t	U/u	return
	V/v	W/w	X/x	Y/y	Z/z	/_

Enfin tu vas ici pouvoir donner une toute nouvelle dimension à tes projets d'interfaces en Python, car tu disposes même d'une fonction get_mouse() pour tester la position du pointeur souris !

9) Module de tracé par pixels ti_draw :

Go to top

ti_draw est donc le module de tracé par pixels de la TI-Nspire CX II. Avec un nom différant du ti_graphics de la TI-83 Premium CE Edition Python nous ne nous attendons certes pas à de la compatibilité, mais également pas au même fonctionnement.

Déjà à la différence de ce dernier, nous notons ici la possibilité d'utiliser du double-buffering.

get_screen_dim() nous apprend que la zone graphique que l'on contrôle fait 318×212 pixels, comme pour les scripts Lua supportés depuis la version 3.0.
A la différence près que pour les scripts Lua la zone graphique était liée aux dimensions de l'application concernée. Ici cela semble être indépendant. L'affichage graphique ne semble pas être redimensionnable et se fait toujours sur une fenêtre popup plein écran offrant donc 318×212 pixels.

set_pen("épaisseur", "style") permet de régler la plume du stylo. La fonction accepte les paramètres listés ci-contre par l'assistant de saisie, mais également des numéros selon les équivalences suivantes :

• 0 = thin
• 1 = medium
• 2 = thick

• 0 = solid
• 1 = dotted
• 2 = dashed

Nous allons t'illustrer de suite ce que les différentes combinaisons de réglages signifient :

Code: Select all

import ti_draw as scr

sw, sh = scr.get_screen_dim()
tw, th = 8, 15
xmin, xmax, ymin, ymax = tw, sw - 1, th, sh - 1

nta, nty = 3, 3
lx = [xmin + k*(xmax-xmin)/(2*nta+1) for k in range(1, 2*nta+1)]
ly = [ymin + k*(ymax-ymin)/(2*nty+1) for k in range(1, 2*nty+1)]
l = (xmax-xmin+1) / (2*nta+1)

for i in range(nty):
  scr.draw_text(xmin-tw, ly[i*2], str(i))
  for j in range(nta):
    scr.draw_text(lx[j*2], ymin+th, str(j))
    scr.set_pen(j, i)
    scr.draw_line(lx[j*2], ly[i*2], lx[j*2 + 1], ly[i*2])

Nous notons donc diverses fonctions de tracé de primitives :

• draw_line(x1, y1, x2, y2) : segment
• draw_rect(x, y, largeur, hauteur) : rectangle
• fill_rect(x, y, largeur, hauteur) : rectangle plein
• draw_circle(x, y, rayon) : cercle
• draw_arc(x, y, largeur, hauteur, angle_initial, angle_de_l_arc) : arc d'ellipse
• fill_arc(x, y, largeur, hauteur, angle_initial, angle_de_l_arc) : secteur d'ellipse
• draw_poly(x_liste, y_liste) : polygone
• fill_poly(x_liste, y_liste) : polygone plein
• plot_xy(x, y, figure)
• draw_text(x, y, ...)

La fonction draw_poly() permet donc de tracer une ligne brisée.
La fonction fill_poly() permet quant à elle de colorier le polygone obtenu en fermant cette ligne brisée.

Code: Select all

import ti_draw as scr

sw, sh = scr.get_screen_dim()
tw, th = 8, 15
xmin, xmax, ymin, ymax = tw, sw - 1, th, sh - 1

nta, nty = 3, 3
lx = [xmin + k*(xmax-xmin)/(2*nta+1) for k in range(1, 2*nta+1)]
ly = [ymin + k*(ymax-ymin)/(2*nty+1) for k in range(1, 2*nty+1)]
l = (xmax-xmin+1) / (2*nta+1)

for i in range(nty):
  scr.draw_text(xmin-tw, ly[i*2], str(i))
  for j in range(nta):
    scr.draw_text(lx[j*2], ymin+th, str(j))
    scr.set_pen(j, i)
    scr.set_color((255,0,0))
    scr.fill_poly([lx[j*2], lx[j*2 + 1], lx[j * 2], lx[j*2 + 1]], [ly[i*2], ly[i*2], ly[i*2+1], ly[i*2+1]])
    scr.set_color((0,0,0))
    scr.draw_poly([lx[j*2], lx[j*2 + 1], lx[j * 2], lx[j*2 + 1]], [ly[i*2], ly[i*2], ly[i*2+1], ly[i*2+1]])

drawRect(x, y, w, h) permet donc de tracer un rectangle :

• de dimensions w et h données en pixels
• aux côtés parallèles aux bords de l'écran
• et en utilisant le point de coordonnées (x, y) comme sommet supérieur gauche

La fonction fillRect() quant à elle permet de colorier le rectangle en question.

Code: Select all

import ti_draw as scr

sw, sh = scr.get_screen_dim()
tw, th = 8, 15
xmin, xmax, ymin, ymax = tw, sw - 1, th, sh - 1

nta, nty = 3, 3
lx = [xmin + k*(xmax-xmin)/(2*nta+1) for k in range(1, 2*nta+1)]
ly = [ymin + k*(ymax-ymin)/(2*nty+1) for k in range(1, 2*nty+1)]
l = (xmax-xmin+1) / (2*nta+1)

for i in range(nty):
  scr.draw_text(xmin-tw, ly[i*2], str(i))
  for j in range(nta):
    scr.draw_text(lx[j*2], ymin+th, str(j))
    scr.set_pen(j, i)
    scr.set_color((255,0,0))
    scr.fill_rect(lx[j*2], ly[i*2], lx[j*2+1]-lx[j*2], ly[i*2+1]-ly[i*2])
    scr.set_color((0,0,0))
    scr.draw_rect(lx[j*2], ly[i*2], lx[j*2+1]-lx[j*2], ly[i*2+1]-ly[i*2])

Voici maintenant du lourd avec drawArc(x, y, w, h, t1, t2) et fillArc(x, y, w, h, t1, t2) :

Code: Select all

import ti_draw as scr

sw, sh = scr.get_screen_dim()
tw, th = 8, 15
xmin, xmax, ymin, ymax = tw, sw - 1, th, sh - 1

nta, nty = 3, 3
lx = [xmin + k*(xmax-xmin)/(2*nta+1) for k in range(1, 2*nta+1)]
ly = [ymin + k*(ymax-ymin)/(2*nty+1) for k in range(1, 2*nty+1)]
l = (xmax-xmin+1) / (2*nta+1)

for i in range(nty):
  scr.draw_text(xmin-tw, ly[i*2], str(i))
  for j in range(nta):
    scr.draw_text(lx[j*2], ymin+th, str(j))
    scr.set_pen(j, i)
    scr.set_color((255,0,0))
    scr.fill_arc(lx[j*2], ly[i*2], lx[j*2+1]-lx[j*2], ly[i*2+1]-ly[i*2], 0, 315)
    scr.set_color((0,0,0))
    scr.draw_arc(lx[j*2], ly[i*2], lx[j*2+1]-lx[j*2], ly[i*2+1]-ly[i*2], 0, 315)

La fonction drawArc(x, y, dx, dy, t1, t2) permet donc de tracer un arc d'une ellipse elle-même inscrite dans un rectangle :

• de dimensions w et h données en pixels
• aux côtés parallèles aux bords de l'écran
• et en utilisant le point de coordonnées (x, y) comme sommet supérieur gauche

t1 et t2 sont les angles au centre orientés délimitant l'arc en question, exprimés en degrés.

Et la fonction fillArc() permet quant à elle de colorier le secteur d'ellipse obtenu par balayage de l'arc en question.

draw_text(x, y, 'texte') écrit bien évidemment du texte en prenant les coordonnées spécifiées comme coin supérieur gauche :

Code: Select all

import ti_draw as scr

sw, sh = scr.get_screen_dim()
tw = 10
s = 'Thank you TI'
xmin, xmax, ymin, ymax = 0, sw - 1, 0, sh - 1
x, y, dx, dy = xmin, ymin, 1, 9

while x <= xmax - tw*len(s):
  scr.draw_text(x, y, s)
  y += dy
  x += dx
  dx += 1

Enfin, plot_xy(x, y, style) te permet d'allumer un point, et selon pas moins de 13 formes prédéfinies selon l'assistant de saisie !

Tentons donc de découvrir tout cela :

Code: Select all

import ti_draw as scr

sw, sh = scr.get_screen_dim()
tw, th = 8, 15
xmin, xmax, ymin, ymax = tw, sw - 1, th, sh - 1

n = 13
lx = [xmin + k*(xmax-xmin)/(2*n+1) for k in range(1, 2*n+1)]
y = ymin + (ymax-ymin)/2
l = (xmax-xmin+1) / (2*n+1)

for j in range(n):
  scr.draw_text(lx[j*2], ymin+th, str(j + 1))
  scr.plot_xy(lx[j*2+1], y ,j + 1)

Si l'on souhaite allumer un simple pixel, c'est donc la forme numéro 7.

Petit classement déjà en terme de zone graphique :

en exam
officiel en exam
tiers hors exam
officiel hors exam
tiers résumé
diagramme

1. 320×240= 76800 pixels : HP Prime (version alpha)
2. 384×192= 73728 pixels : Casio Graph 90+E
3. 320×222= 71040 pixels : NumWorks
4. 318×212= 67416 pixels : TI-Nspire CX II
5. 320×210= 67200 pixels : TI-83 Premium CE Edition Python
6. 128×64= 8192 pixels : Casio Graph 35+E II

1. 320×240= 76800 pixels : HP Prime (version alpha)
2. 384×192= 73728 pixels : Casio Graph 90+E
3. 320×222= 71040 pixels : NumWorks
4. 318×212= 67416 pixels : TI-Nspire CX II
5. 320×210= 67200 pixels : TI-83 Premium CE Edition Python
6. 128×64= 8192 pixels : Casio Graph 35+E II

1. 320×240= 76800 pixels : HP Prime (version alpha)
2. 384×192= 73728 pixels : Casio Graph 90+E
3. 320×222= 71040 pixels : NumWorks
4. 318×212= 67416 pixels : TI-Nspire CX II
5. 320×210= 67200 pixels : TI-83 Premium CE Edition Python / TI-84 Plus CE-T Python Edition
6. 128×64= 8192 pixels : Casio Graph 35+E II

1. 320×240= 76800 pixels : TI-Nspire (Ndless + MicroPython) + HP Prime (version alpha)
2. 384×192= 73728 pixels : Casio Graph 90+E
3. 320×222= 71040 pixels : NumWorks + TI-Nspire CX (Ndless + KhiCAS CX)
4. 318×212= 67416 pixels : TI-Nspire CX II
5. 320×210= 67200 pixels : TI-83 Premium CE Edition Python / TI-84 Plus CE-T Python Edition
6. 128×64= 8192 pixels : Casio Graph 35+E II

Mais si donc nous venons de terminer avec une fonction permettant d'allumer un pixel, nous n'avons pas vu de trace de fonction permettant de tester l'état d'un pixel.
C'est en fait que nous n'en avons pas terminé avec les modules de tracé par pixels...

10) Module de tracé par pixels ti_image :

Go to top

ti_image est donc un module de tracé par pixels complémentaire du précédent, avec a priori pas beaucoup de fonctions.

Comme son nom l'indique, il permet de charger et afficher des images. Il s'agit ici d'images insérées en tant que ressources dans ton classeur, il te faudra pour cela utiliser le logiciel TI-Nspire et l'éditeur de script Lua.

L'objet image Python correspondant est ensuite créé d'un simple img = load_image(n), mais pas affiché.

En fait c'est l'objet image ainsi créé qui apporte les fonctions utiles, dont ici le img.show_image(x, y).

Une gestion des images qui a ici le gros avantage de ne nécessiter que 2 lignes de code en Python, de ne pas inclure les données des images dans ton script Python, et donc d'économiser grandement la consommation du heap !

Par contre, il n'y aurait pas comme un petit bug, non ?

Le module ti_image semble afficher les ressources images du classeur à l'envers... alors que l'image en question avait un aperçu correct dans l'éditeur montré précédemment, et que la même ressource est visiblement affichée correctement ci-contre par un script Lua.

Code: Select all

img = image.new(_R.IMG.g200)

function on.paint(gc)
  gc:drawImage(img, 0, 0)
end

Mais ti_image est très loin de ne servir qu'aux images...

En réalité il s'agit d'un module qui permet en fait de travailler en pixels sur des calques hors écran, autant de calques que tu veux. Un calque se crée dans la couleur que tu souhaites d'un simple layer = new_image(w, h, (r, g, b)), et tu disposes ensuite de méthodes set_pixel() et enfin get_pixel() pour faire tout ce que tu veux avec !

Très pratique ces deux dernières fonctions également pour faire du traitement d'image en SNT.

11) Module de tracé par pixels ti_picture :

Go to top

ti_picture est donc quant à lui un module de tracé par pixels secret, puisque n'étant pas au menu.

On peut l'interroger sur son contenu d'un dir(ti_picture).

Il semble bizarrement offrir quasiment les mêmes possibités que le module ti_image précédent...

A une petite différence près, c'est qu'ici les données des calques sont stockés sous le type standard bytearray au format RGB 24 bits.

Selon comment tu souhaites travailler sur tes calques et images (par pixels ou par octets), ainsi que le degré de compatibilité que tu souhaites te laisser avec d'autres plateformes, ti_picture pourra donc parfois être un meilleur choix que ti_image.

13) Bilan modules :

Go to top

Plus haut nous avions donc évalué la richesse de la plateforme en nous basant sur le nombre de modules standard disponibles. Nous avions exclu les modules propriétaires du classement, car cela n'avait pas de sens : un gros module propriétaire sur TI-Nspire CX II se voit découpé en plein de petits modules propriétaires sur TI-83 Premium CE Edition Python.

Tentons une autre approche incluant cette fois-ci les modules propriétaires avec le script suivant, initialement conçu pour notre classement QCC 2020. Et comme nous n'avions justement pas traité ce point publiquement dans ce contexte, c'est maintenant l'occasion :

explmod.py autopfrm.py

Code: Select all

from autopfrm import *

pf = get_pf()
sh_inf = shell_infos(pf)

unsafe = ()
if pf == 4: #HP Prime
  unsafe = ('count','encode','endswith','find','format','index','islower','lstrip','replace','rfind','rindex','rsplit','rstrip','split','splitlines','startswith','strip','from_bytes','to_bytes','fromkeys','get','pop','setdefault','update','values','sort','__enter__','__exit__','read','readinto','readline','seek','write')
if pf == 5 or pf == 7 or pf == 9: #CasioPython / Nspire+NumWorks KhiCAS MicroPython
  unsafe = ('sys.argv', 'sys.path')

if pf >= 0:
  curline=0
  _p = print
  def print(*ls):
    global curline
    st=""
    for s in ls:
      if not(isinstance(s,str)):
        s=str(s)
      st=st+s
    stlines=1
    if sh_inf[1]:
        stlines += sh_inf[2]*int(len(st)/sh_inf[1])
    if curline+stlines>=sh_inf[0]:
      input("Input to continue:")
      curline=0
    _p(st)
    curline+=stlines

def sstr(obj):
  try:
    s=obj.__name__
  except:
    s=str(obj)
    a=s.find("'")
    b=s.rfind("'")
    if a>=0 and b!=a:
      s=s[a+1:b]
  return s

def isExplorable(obj):
  if str(obj).startswith("<module"): return False
  l = ()
  try: l = dir(obj)
  except: pass
  return len(l)

def explmodr(pitm, pitm_name_l=[], pitm_str_l=[], pitm_val_l=[], reset=True):
  global curline, found
  pitm_name=sstr(pitm)
  if(reset):
    curline=0
    found = []
    pitm_name_l=[pitm_name]
    pitm_str_l=[str(pitm)]
    pitm_val_l=[pitm]
  hd="."*(len(pitm_name_l)-1)
  c = 0
  l = sorted(dir(pitm))
  for i in range(len(l)):
    l[i] = (l[i], getattr(pitm, l[i]), str(l[i]))
  try:
    if not isinstanceof(pitm, str):
      for i in range(len(pitm)):
        l.append((pitm_name+'['+str(i)+']',pitm[i],str(pitm[i])))
  except: pass
  for itm in l:
    isFound = itm[0] in found
    c += not isFound
    isUnsafe = '.'.join(pitm_name_l + [itm[0]]) in unsafe or itm[0] in unsafe
    try:
      if isUnsafe: raise Exception
      print(hd+itm[0]+"="+str(itm[1]))
    except:
      print(hd+itm[0])
    if not isFound:
      found.append(itm[0])
    if not isUnsafe and isExplorable(itm[1]) and itm[1] not in pitm_val_l and itm[2] not in pitm_str_l:
      pitm_name_l2, pitm_val_l2, pitm_str_l2 = pitm_name_l.copy(), pitm_val_l.copy(), pitm_str_l.copy()
      pitm_name_l2.append(itm[0])
      pitm_val_l2.append(itm[1])
      pitm_str_l2.append(itm[2])
      c += explmodr(itm[1], pitm_name_l2, pitm_str_l2, pitm_val_l2, False)
  return c

def explmod(s):
  global found
  module = __import__(s)
  found = []
  return explmodr(module)

Code: Select all

# detects calculator Python platform
def get_pf():
  c256 = True
  try:
    if chr(256)==chr(0):
      # Xcas/KhiCAS Python compatibility
      if "HP" in version():
        return 13 # HP Prime
      else:
        if not white:
          return 12 # Graph 35+E II
        elif "Numworks" in version():
          return 10 # NumWorks
        elif "Nspire" in version():
          return 8 # Nspire
        else: # Graph 90+E
          return 11
  except:
    c256 = False
  try:
    import sys
    try:
      if sys.platform == "nspire":
        try: # Nspire Ndless
          import graphic
          return 7 # KhiCAS Micropython
        except: # MicroPython
          return 6
      elif sys.platform == "TI-Nspire":
        return 3 # Nspire CX II
      elif sys.platform == "numworks":
        return 9 # NumWorks KhiCAS Micropython
      elif sys.platform.startswith('TI-Python'):
        return 2 # 83P/84+ CE
    except: # Graph 35+E/USB / 75/85/95
      return 5
  except:
    pass
  if not c256:
    return 1 # Graph 90/35+E II
  try:
    import kandinsky
    return 0 # NumWorks
  except:
    try: # HP Prime
      import hpprime
      return 4
    except:
      pass
  return -1

#return get_pixel and set_pixel functions for the platform
gp_prime = lambda x, y: GETPIX_P(x, y)
sp_prime = lambda x, y, c: PIXON_P(x, y, c)
def get_pixel_functions(pf):
  gp, sp = lambda: None, lambda: None
  if pf == 0: # NumWorks
    import kandinsky
    gp, sp = kandinsky.get_pixel, kandinsky.set_pixel
  elif pf == 1: # Graph 90/35+E II
    import casioplot
    gp, sp = casioplot.get_pixel, casioplot.set_pixel
  elif pf == 2: # 83P/84+ CE
    import ti_graphics
    gp, sp = ti_graphics.getPixel, ti_graphics.setPixel
  elif pf == 3: # Nspire CX II
    pass
  elif pf == 4: # HP Prime
    import hpprime
    sp = hpprime.pixon
  elif pf == 6: # Nspire: Ndless MicroPython
    from nsp import Texture
    canvas = Texture(320, 240, 0)
    gp, sp = canvas.getPx, canvas.setPx
  elif pf == 7 or pf == 9: # Nspire/NumWorks: KhiCAS-MicroPython
    import graphic
    gp, sp = graphic.get_pixel, graphic.set_pixel
  elif pf == 13: # HP Prime
    gp, sp = gp_prime, sp_prime
  return gp, sp

#returns platform shell infos : visible lines, visible columns, if larger strings are displayed on several lines or not
def shell_infos(pf):
  #NW small: [00] 12.5x30 -> 16   x 42
  #HP small: [03] 11.5x39 -> 15.5 x 45 [12] 14  x39 -> 18.5 x 45
  #HP big  : [03] 11.5x39 -> 09   x 35 [12] 14  x39 -> 11   x 35
  #                                       uPy     uPy
  #               G352            CPy uPy KhiCAS--------------->  CAS
  #           NW  G90 CE  CX2 HP  GXX NS  NS  NS  NW  NW  G90 G352HP
  l_vlines = (12, 07, 11, 11, 12, 09, 29, 11, 11, 11, 11, 09, 07, 14)
  l_vcols =  (30, 21, 32, 00, 39, 32, 53, 32, 32, 29, 29, 30, 19, 39)
  b_vcr = 0b1111100
  if pf >= 0:
    return l_vlines[pf], l_vcols[pf], b_vcr // 2**pf % 2
  else:
    return max(l_vlines), max(l_vcols), 1

L'appel explmod('nom_module') explore le module en question et en compte les différents éléments internes, en évitant les doublons :

	TI- 83PCE TI- Python	TI- 83PCE Edition Python	TI- 84+CE-T Python Edition	TI- Nspire CX II	Casio Graph 90+E 35+E II	Num Works	HP Prime α	TI- 83PCE TI- Python tiers	TI- Nspire Ndless μPython	TI- Nspire CX Ndless χCAS	Casio Graph 35/75+E 35+E II CasioPython	Num Works Ω	Num Works Ω χCAS
builtins array (u)binascii board cmath (u)collections (u)ctypes (u)errno gc (u)hashlib (u)heapq (u)io (u)json linalg math matplotlib .pyplot micropython numpy os (u)random (u)re storage (u)struct sys time (u)timeq turtle (u)zlib TOTAL	152 26 . . . 24 . . 29 . . . . . 50 . . . . . 30 . . . 68 26 . . . 405	153 26 . . . 24 . . 29 . . . . . 50 . . . . . 30 . . . 68 26 . . . 406	153 26 . . . 24 . . 29 . . . . . 50 . . . . . 30 . . . 68 28 . . . 406	166 33 33 . 40 48 60 68 36 32 32 . . . 69 . . 41 . . 36 35 . . 80 40 . . . 849	141 . . . . . . . . . . . . . 47 . 58 . . . 30 . . . . . . 112 . 218-388	146 . . . 34 . . . . . . . . . 63 25 22 29 . . 31 . . . . 25 . 62 . 437	165 32 . . 40 . . 68 36 . . . . . 69 . . 37 . . . . . . 80 . . . . 527	154 27 . 22 35 25 . . 30 . . . . . 64 . . 29 . 38 31 . 45 . 71 31 . . . 602	160 30 . . 38 . . . 33 . . . . . 67 . . 29 . . . . . . 62 . . . . 419	165 . 31 . 38 46 66 66 34 30 30 45 31 67 69 . 44 34 81 28 34 34 . 32 73 . . 82 32 1192	155 30 . . 38 . . . 33 . . . . . 67 . . 32 . . 34 . . . 55 . . . . 444	146 . . . 34 . . . . . . . . . 63 25 22 29 . 27 31 . . . . 25 . 62 . 472	168 . 34 . 41 49 69 . 37 30 33 48 34 70 72 . 47 38 46 31 37 37 . 35 77 . 34 85 35 1187

Passons maintenant aux modules propriétaires lorsque disponibles :

TI- 83PCE Edition Python	TI- 84+CE-T Python Edition	TI- Nspire CX II	Casio Graph 90+E 35+E II	Num Works	HP Prime α	TI- Nspire Ndless μPython	TI- Nspire CX Ndless χCAS	Num Works Ω	Num Works Ω χCAS
analogin:44 analogout:46 bbport:40 brightns:29 ce_box:32 ce_chart:58 ce_quivr:41 ce_turtl:65 color:30 colorinp:39 conservo:45 dht:45 digital:46 led:45 light:30 lightlvl:44 loudness:44 magnetic:46 mb_butns:38 mb_disp:40 mb_grove:51 mb_music:37 mb_neopx:54 mb_pins:48 mb_radio:40 mb_sensr:54 microbit:28 moisture:44 potentio:44 power:45 ranger:43 relay:45 rgb:45 rgb_arr:51 sound:29 squarewv:44 temperat:43 thermist:44 ti_graphics:67 ti_hub:42 ti_plotlib:78 ti_rover:79 ti_system:34 speaker:35 timer:35 vernier:44 vibmotor:45	analogin:44 analogout:46 bbport:40 brightns:29 ce_box:32 ce_chart:58 ce_quivr:41 ce_turtl:65 color:30 colorinp:39 conservo:45 dht:45 digital:46 led:45 light:30 lightlvl:44 loudness:44 magnetic:46 mb_butns:38 mb_disp:40 mb_grove:51 mb_music:37 mb_neopx:54 mb_pins:48 mb_radio:40 mb_sensr:54 microbit:28 moisture:44 potentio:44 power:45 ranger:43 relay:45 rgb:45 rgb_arr:51 sound:29 squarewv:44 temperat:43 thermist:44 ti_graphics:67 ti_hub:42 ti_plotlib:78 ti_rover:79 ti_system:34 speaker:35 timer:35 vernier:44 vibmotor:45	ti_draw:54 ti_hub:193 ti_image:53 ti_innovator:48 ti_picture:35 ti_plotlib:90 ti_rover:142 ti_st:41 ti_system:83	casioplot	ion:72 kandinsky:28	prime:30	nsp:10	arit:38 cas:28 graphic:55 nsp:37	ion:72 kandinsky:28	arit:41 cas:31 graphic:58 nsp:32
1509-2095	2095	739	28	100	30	10	158	100	162

En comptant donc les modules non standard la TI-Nspire CX II reste parmi les meilleures solutions Python et c'est toujours Texas Instruments qui majore la promotion :

en exam
officiel en exam
tiers hors exam
officiel hors exam
tiers résumé
diagramme

1. 1915 éléments + (dont 406 éléments standard) : TI-83 Premium CE Edition Python
2. 1588 éléments + (dont 849 éléments standard) : TI-Nspire CX II
3. 557 éléments + (dont 527 éléments standard) : HP Prime (version alpha)
4. 537 éléments + (dont 437 éléments standard) : NumWorks
5. 246 éléments + (dont 218 éléments standard) : Casio Graph 90+E / 35+E II

1. 1915 éléments + (dont 406 éléments standard) : TI-83 Premium CE Edition Python
2. 1588 éléments + (dont 849 éléments standard) : TI-Nspire CX II
3. 1349 éléments + (dont 1187 éléments standard) : NumWorks (firmware Omega + appli KhiCAS)
4. 578 éléments + (dont 472 éléments standard) : NumWorks (firmware Omega)
5. 557 éléments + (dont 527 éléments standard) : HP Prime (version alpha)
6. 537 éléments + (dont 437 éléments standard) : NumWorks
7. 246 éléments + (dont 218 éléments standard) : Casio Graph 90+E / 35+E II

1. 2501 éléments + (dont 406 éléments standard) : TI-83 Premium CE Edition Python / TI-84 Plus CE-T Python Edition
2. 1588 éléments + (dont 849 éléments standard) : TI-Nspire CX II
3. 557 éléments + (dont 527 éléments standard) : HP Prime (version alpha)
4. 537 éléments + (dont 437 éléments standard) : NumWorks
5. 405 éléments : TI-83 Premium CE + TI-Python
6. 416 éléments + (dont 388 éléments standard) : Casio Graph 90+E / 35+E II

1. 2501 éléments + (dont 406 éléments standard) : TI-83 Premium CE Edition Python / TI-84 Plus CE-T Python Edition
2. 1588 éléments + (dont 849 éléments standard) : TI-Nspire CX II
3. 1350 éléments + (dont 1192 éléments standard) : TI-Nspire CX (Ndless + KhiCAS CX)
4. 1349 éléments + (dont 1187 éléments standard) : NumWorks (firmware Omega + appli KhiCAS)
5. 602 éléments : TI-83 Premium CE + TI-Python (tiers)
6. 578 éléments + (dont 472 éléments standard) : NumWorks (firmware Omega)
7. 557 éléments + (dont 527 éléments standard) : HP Prime (version alpha)
8. 537 éléments + (dont 437 éléments standard) : NumWorks
9. 429 éléments + (dont 419 éléments standard) : TI-Nspire (Ndless + MicroPython)
10. 416 éléments + (dont 388 éléments standard) : Casio Graph 90+E / 35+E II
11. 405 éléments : TI-83 Premium CE + TI-Python + Casio Graph 35/75+E (appli CasioPython)

14) Performances en virgule flottante :

Go to top

Autre point très attendu, les performances du Python TI-Nspire CX II.

Commençons par les évaluer dans le contexte des calculs en virgule flottante à l'aide du script suivant, développé et utilisé pour le QCC 2020 même si nous n'avons pas eu le temps de faire un compte-rendu public des résultats. Petit algorithme de seuil dans le contexte d'une suite récurrente, niveau Première :

Code: Select all

try:
  from time import *
except:
  pass

def hastime():
  try:
    monotonic()
    return True
  except:
    return False

def seuil(d):
  timed,n=hastime(),0
  start,u=0 or timed and monotonic(),2.
  d=d**2
  while (u-1)**2>=d:
    u=1+1/((1-u)*(n+1))
    n=n+1
  return [(timed and monotonic() or 1)-start,n,u]

Pour un appel de seuil(0.008), la TI-Nspire CX II te répond au quart de tour en seulement 0,24s !

La TI-Nspire CX II est vraiment extraordinaire en calcul flottant Python écrasant toute concurrence de sa toute puissance, même en comptant les solutions Python tierces, et même en dopant la concurrence avec un overclocking au max !

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

1. 0,24s : TI-Nspire CX II (32 bits : ARM9/ARMv5 @396MHz)
2. 0,325s : HP Prime G1 (32 bits : ARM9/ARMv5 @400MHz alpha)
3. 0,376s : HP Prime G2 (32 bits : Cortex-A7/ARMv7 @528MHz compatibilité Python)
4. 0,498s : NumWorks N0110 (32 bits : Cortex-M7/ARMv7 @216MHz)
5. 0,785s : NumWorks N0100 (32 bits : Cortex-M4/ARMv7 @100MHz)
6. 1,61s : HP Prime G1 (32 bits : ARM9/ARMv5 @400MHz compatibilité Python)
7. 3,27s : Casio Graph 90+E (32 bits : SH4 @117,96MHz)
8. 3,93s : TI-83 Premium CE Edition Python (8 + 32 bits : eZ80 @48MHz + Cortex-M0+/ARMv6 @48MHz)
9. 9,21s : Casio Graph 35+E II (32 bits : SH4 @58,98MHz)

1. 0,24s : TI-Nspire CX II (32 bits : ARM9/ARMv5 @396MHz)
2. 0,325s : HP Prime G1 (32 bits : ARM9/ARMv5 @400MHz alpha)
3. 0,376s : HP Prime G2 (32 bits : Cortex-A7/ARMv7 @528MHz compatibilité Python)
4. 0,498s : NumWorks N0110 (32 bits : Cortex-M7/ARMv7 @216MHz)
5. 0,785s : NumWorks N0100 (32 bits : Cortex-M4/ARMv7 @100MHz)
6. 1,61s : HP Prime G1 (32 bits : ARM9/ARMv5 @400MHz compatibilité Python)
7. 3,27s : Casio Graph 90+E (32 bits : SH4 @117,96MHz)
8. 3,93s : TI-83 Premium CE Edition Python (8 + 32 bits : eZ80 @48MHz + Cortex-M0+/ARMv6 @48MHz)
9. 6,69s : NumWorks N0110 (Omega + KhiCAS compatibilité Python)
10. 9,21s : Casio Graph 35+E II (32 bits : SH4 @58,98MHz)
11. 33,41s : NumWorks N0110 (Omega + KhiCAS Micropython)

1. 0,24s : TI-Nspire CX II (32 bits : ARM9/ARMv5 @396MHz)
2. 0,325s : HP Prime G1 (32 bits : ARM9/ARMv5 @400MHz alpha)
3. 0,376s : HP Prime G2 (32 bits : Cortex-A7/ARMv7 @528MHz compatibilité Python)
4. 0,498s : NumWorks N0110 (32 bits : Cortex-M7/ARMv7 @216MHz)
5. 0,785s : NumWorks N0100 (32 bits : Cortex-M4/ARMv7 @100MHz)
6. 1,61s : HP Prime G1 (32 bits : ARM9/ARMv5 @400MHz compatibilité Python)
7. 3,27s : Casio Graph 90+E (32 bits : SH4 @117,96MHz)
8. 3,73s : TI-83 Premium CE + TI-Python (8 + 32 bits : eZ80 @48MHz + Cortex-M0+/ARMv6 @48MHz)
9. 3,93s : TI-83 Premium CE Edition Python / TI-84 Plus CE-T Python Edition (8 + 32 bits : eZ80 @48MHz + Cortex-M0+/ARMv6 @48MHz)
10. 9,21s : Casio Graph 35+E II (32 bits : SH4 @58,98MHz)

1. 0,24s : TI-Nspire CX II (32 bits : ARM9/ARMv5 @396MHz)
2. 0,27s : TI-Nspire CX (révisions A-V) (32 bits : ARM9/ARMv5 @132MHz overclocké @222MHz Nover - Ndless + MicroPython)
3. 0,325s : HP Prime G1 (32 bits : ARM9/ARMv5 @400MHz alpha)
4. 0,376s : HP Prime G2 (32 bits : Cortex-A7/ARMv7 @528MHz compatibilité Python)
5. 0,38s : TI-Nspire (32 bits : ARM9/ARMv5 overclocké @120MHz @150MHz Nover - Ndless + MicroPython)
6. 0,396s : TI-Nspire CX (révisions A-V) (32 bits : ARM9/ARMv5 @132MHz overclocké @222MHz Nover - Ndless + KhiCAS CX Micropython)
7. 0,47s : TI-Nspire (32 bits : ARM9/ARMv5 @120MHz - Ndless + MicroPython)
8. 0,48s : TI-Nspire CX (révisions A-V) (32 bits : ARM9/ARMv5 @132MHz - Ndless + MicroPython)
9. 0,498s : NumWorks N0110 (32 bits : Cortex-M7/ARMv7 @216MHz)
10. 0,53s : TI-Nspire CX CR4+ (révisions W+) (32 bits : ARM9/ARMv5 @156MHz overclocké @216MHz Nover - Ndless + MicroPython)
11. 0,59s : Casio Graph 35/75+E (32 bits : SH4 @29,49MHz overclocké @267,78MHz Ftune2 - CasioPython)
12. 0,609s : TI-Nspire CX (révisions A-V) (32 bits : ARM9/ARMv5 @132MHz - Ndless + KhiCAS CX Micropython)
13. 0,65s : TI-Nspire CX CR4+ (révisions W+) (32 bits : ARM9/ARMv5 @156MHz overclocké @216MHz Nover - Ndless + KhiCAS CX Micropython)
14. 0,68s : TI-Nspire CX CR4+ (révisions W+) (32 bits : ARM9/ARMv5 @156MHz - Ndless + MicroPython)
15. 0,785s : NumWorks N0100 (32 bits : Cortex-M4/ARMv7 @100MHz)
16. 0,79s : Casio Graph 35+E II (32 bits : SH4 @58,98MHz overclocké @274,91MHz Ftune3 - CasioPython)
17. 0,868s : TI-Nspire CX CR4+ (révisions W+) (32 bits : ARM9/ARMv5 @156MHz - Ndless + KhiCAS CX Micropython)
18. 1,61s : HP Prime G1 (32 bits : ARM9/ARMv5 @400MHz compatibilité Python)
19. 1,86s : Casio Graph 35+E II (32 bits : SH4 @58,98MHz overclocké @274,91MHz Ftune3)
20. 2,15s : Casio Graph 90+E (32 bits : SH4 @117,96MHz overclocké @270,77MHz Ptune3)
21. 2,96s : Casio Graph 35+E II (32 bits : SH4 @58,98MHz overclocké @274,91MHz Ftune3 - KhiCAS)
22. 3,27s : Casio Graph 90+E (32 bits : SH4 @117,96MHz)
23. 3,65s : Casio Graph 90+E (32 bits : SH4 @117,96MHz overclocké @270,77MHz Ptune3 - KhiCAS)
24. 3,73s : TI-83 Premium CE + TI-Python (8 + 32 bits : eZ80 @48MHz + Cortex-M0+/ARMv6 @48MHz)
25. 3,9s : Casio Graph 35+E II (32 bits : SH4 @58,98 - CasioPython)
26. 3,93s : TI-83 Premium CE Edition Python / TI-84 Plus CE-T Python Edition (8 + 32 bits : eZ80 @48MHz + Cortex-M0+/ARMv6 @48MHz)
27. 4s : Casio Graph 35/75+E (32 bits : SH4 @29,49MHz - CasioPython)
28. 4,13s : TI-Nspire CX (révisions A-V) (32 bits : ARM9/ARMv5 @132MHz overclocké @222MHz Nover - Ndless + KhiCAS CX compatibilité Python)
29. 4,4s : TI-83 Premium CE + TI-Python (8 + 32 bits : eZ80 @48MHz + Cortex-M0+/ARMv6 @48MHz CircuitPython)
30. 5,45s : TI-Nspire CX (révisions A-V) (32 bits : ARM9/ARMv5 @132MHz - Ndless + KhiCAS CX compatibilité Python)
31. 5,48s : Casio Graph 90+E (32 bits : SH4 @117,96MHz - KhiCAS)
32. 6,69s : NumWorks N0110 (Omega + KhiCAS compatibilité Python)
33. 7,19s : TI-Nspire CX CR4+ (révisions W+) (32 bits : ARM9/ARMv5 @156MHz overclocké @216MHz Nover - Ndless + KhiCAS CX compatibilité Python)
34. 7,63s : TI-Nspire CX CR4+ (révisions W+) (32 bits : ARM9/ARMv5 @156MHz - Ndless + KhiCAS CX compatibilité Python)
35. 9,21s : Casio Graph 35+E II (32 bits : SH4 @58,98MHz)
36. 13,93s : Casio Graph 35+E II (32 bits : SH4 @58,98MHz - KhiCAS)
37. 33,41s : NumWorks N0110 (Omega + KhiCAS Micropython)

15) Performances en calcul entier :

Go to top

Mais contrairement aux langages historiques de nos calculatrices, le Python distingue les nombres entiers des nombres flottants.

Pousuivons donc les tests de performances dans le contexte des nombres entiers, afin de voir si la TI-Nspire CX II s'en sort toujours aussi bien. Voici donc un script réalisant un test de primalité :

Code: Select all

try:from time import monotonic
except:pass

def hastime():
  try:
    monotonic()
    return True
  except:return False

def nodivisorin(n,l):
  for k in l:
    if n//k*k==n:
      return False
  return True

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

La TI-Nspire CX II répond ici à l'appel isprimep(10000019) en 0,56s !

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

1. 0,56s : TI-Nspire CX II (32 bits : ARM9/ARMv5 @396MHz)
2. 0,581s : NumWorks N0110 (32 bits : Cortex-M7/ARMv7 @216MHz)
3. 0,974s : HP Prime G1 (32 bits : ARM9/ARMv5 @400MHz alpha)
4. 1,17s : NumWorks N0100 (32 bits : Cortex-M4/ARMv7 @100MHz)
5. 1,58s : Casio Graph 90+E (32 bits : SH4 @117,96MHz)
6. 4,39s : Casio Graph 35+E II (32 bits : SH4 @58,98MHz)
7. 4,42s : HP Prime G2 (32 bits : Cortex-A7/ARMv7 @528MHz)
8. 9s : TI-83 Premium CE Edition Python (8 + 32 bits : eZ80 @48MHz + Cortex-M0+/ARMv6 @48MHz)
9. 16,05s : HP Prime G1 (32 bits : ARM9/ARMv5 @400MHz)

1. 0,56s : TI-Nspire CX II (32 bits : ARM9/ARMv5 @396MHz)
2. 0,581s : NumWorks N0110 (32 bits : Cortex-M7/ARMv7 @216MHz)
3. 0,974s : HP Prime G1 (32 bits : ARM9/ARMv5 @400MHz alpha)
4. 1,17s : NumWorks N0100 (32 bits : Cortex-M4/ARMv7 @100MHz)
5. 1,58s : Casio Graph 90+E (32 bits : SH4 @117,96MHz)
6. 4,39s : Casio Graph 35+E II (32 bits : SH4 @58,98MHz)
7. 4,42s : HP Prime G2 (32 bits : Cortex-A7/ARMv7 @528MHz)
8. 9s : TI-83 Premium CE Edition Python (8 + 32 bits : eZ80 @48MHz + Cortex-M0+/ARMv6 @48MHz)
9. 16,05s : HP Prime G1 (32 bits : ARM9/ARMv5 @400MHz)
10. 33,41s : NumWorks N0110 (Omega + KhiCAS Micropython)
11. 42,75s : NumWorks N0110 (Omega + KhiCAS compatibilité Python)

1. 0,56s : TI-Nspire CX II (32 bits : ARM9/ARMv5 @396MHz)
2. 0,581s : NumWorks N0110 (32 bits : Cortex-M7/ARMv7 @216MHz)
3. 0,974s : HP Prime G1 (32 bits : ARM9/ARMv5 @400MHz alpha)
4. 1,17s : NumWorks N0100 (32 bits : Cortex-M4/ARMv7 @100MHz)
5. 1,58s : Casio Graph 90+E (32 bits : SH4 @117,96MHz)
6. 4,39s : Casio Graph 35+E II (32 bits : SH4 @58,98MHz)
7. 4,42s : HP Prime G2 (32 bits : Cortex-A7/ARMv7 @528MHz)
8. 9s : TI-83 Premium CE Edition Python / TI-84 Plus CE-T Python Edition (8 + 32 bits : eZ80 @48MHz + Cortex-M0+/ARMv6 @48MHz)
9. 11,26s : TI-83 Premium CE + TI-Python (8 + 32 bits : eZ80 @48MHz + Cortex-M0+/ARMv6 @48MHz CircuitPython)
10. 16,05s : HP Prime G1 (32 bits : ARM9/ARMv5 @400MHz)

1. 0,42s : TI-Nspire CX (révisions A-V) (32 bits : ARM9/ARMv5 @132MHz overclocké @222MHz Nover - Ndless + MicroPython)
2. 0,511s : TI-Nspire CX (révisions A-V) (32 bits : ARM9/ARMv5 @132MHz overclocké @222MHz Nover - Ndless + KhiCAS CX Micropython)
3. 0,56s : TI-Nspire CX II (32 bits : ARM9/ARMv5 @396MHz)
4. 0,57s : TI-Nspire (32 bits : ARM9/ARMv5 overclocké @120MHz @150MHz Nover - Ndless + MicroPython)
5. 0,58s : Casio Graph 35/75+E (32 bits : SH4 @29,49MHz overclocké @267,78MHz Ftune2 - CasioPython)
6. 0,581s : NumWorks N0110 (32 bits : Cortex-M7/ARMv7 @216MHz)
7. 0,59s : Casio Graph 35+E II (32 bits : SH4 @58,98MHz overclocké @274,91MHz Ftune3 - CasioPython)
8. 0,62s : TI-Nspire CX (révisions A-V) (32 bits : ARM9/ARMv5 @132MHz - Ndless + MicroPython)
9. 0,63s : TI-Nspire CX CR4+ (révisions W+) (32 bits : ARM9/ARMv5 @156MHz overclocké @216MHz Nover - Ndless + MicroPython)
10. 0,67s : TI-Nspire (32 bits : ARM9/ARMv5 @120MHz - Ndless + MicroPython)
11. 0,794s : TI-Nspire CX (révisions A-V) (32 bits : ARM9/ARMv5 @132MHz - Ndless + KhiCAS CX Micropython)
12. 0,86s : Casio Graph 35+E II (32 bits : SH4 @58,98MHz overclocké @274,91MHz Ftune3)
13. 0,821s : TI-Nspire CX CR4+ (révisions W+) (32 bits : ARM9/ARMv5 @156MHz overclocké @216MHz Nover - Ndless + KhiCAS CX Micropython)
14. 0,974s : HP Prime G1 (32 bits : ARM9/ARMv5 @400MHz alpha)
15. 0,99s : TI-Nspire CX CR4+ (révisions W+) (32 bits : ARM9/ARMv5 @156MHz - Ndless + MicroPython)
16. 1,08s : Casio Graph 90+E (32 bits : SH4 @117,96MHz overclocké @270,77MHz Ptune3)
17. 1,17s : NumWorks N0100 (32 bits : Cortex-M4/ARMv7 @100MHz)
18. 1,18s : TI-Nspire CX CR4+ (révisions W+) (32 bits : ARM9/ARMv5 @156MHz - Ndless + KhiCAS CX Micropython)
19. 1,58s : Casio Graph 90+E (32 bits : SH4 @117,96MHz)
20. 3,02s : Casio Graph 35+E II (32 bits : SH4 @58,98 - CasioPython)
21. 4,39s : Casio Graph 35+E II (32 bits : SH4 @58,98MHz)
22. 4,42s : HP Prime G2 (32 bits : Cortex-A7/ARMv7 @528MHz)
23. 4,98s : Casio Graph 35/75+E (32 bits : SH4 @29,49MHz - CasioPython)
24. 8,1s : TI-83 Premium CE + TI-Python (8 + 32 bits : eZ80 @48MHz + Cortex-M0+/ARMv6 @48MHz)
25. 9s : TI-83 Premium CE Edition Python / TI-84 Plus CE-T Python Edition (8 + 32 bits : eZ80 @48MHz + Cortex-M0+/ARMv6 @48MHz)
26. 11,26s : TI-83 Premium CE + TI-Python (8 + 32 bits : eZ80 @48MHz + Cortex-M0+/ARMv6 @48MHz CircuitPython)
27. 16,05s : HP Prime G1 (32 bits : ARM9/ARMv5 @400MHz)
28. 19,06s : Casio Graph 35+E II (32 bits : SH4 @58,98MHz overclocké @274,91MHz Ftune3 - KhiCAS)
29. 22,77s : Casio Graph 90+E (32 bits : SH4 @117,96MHz overclocké @270,77MHz Ptune3 - KhiCAS)
30. 29,20s : TI-Nspire CX (révisions A-V) (32 bits : ARM9/ARMv5 @132MHz overclocké @222MHz Nover - Ndless + KhiCAS CX compatibilité Python)
31. 32,76s : Casio Graph 90+E (32 bits : SH4 @117,96MHz - KhiCAS)
32. 33,41s : NumWorks N0110 (Omega + KhiCAS Micropython)
33. 36,26s : TI-Nspire CX (révisions A-V) (32 bits : ARM9/ARMv5 @132MHz - Ndless + KhiCAS CX compatibilité Python)
34. 42,75s : NumWorks N0110 (Omega + KhiCAS compatibilité Python)
35. 45,34s : TI-Nspire CX CR4+ (révisions W+) (32 bits : ARM9/ARMv5 @156MHz overclocké @216MHz Nover - Ndless + KhiCAS CX compatibilité Python)
36. 53,24s : TI-Nspire CX CR4+ (révisions W+) (32 bits : ARM9/ARMv5 @156MHz - Ndless + KhiCAS CX compatibilité Python)
37. 91,71s : Casio Graph 35+E II (32 bits : SH4 @58,98MHz - KhiCAS)

16) Conclusion :

Go to top

Last but not least... Texas Instruments ne publie habituellement qu'1 à 2 mises à jour par an, mais alors quelle mise à jour cette fois-ci !
"Gute Dinge brauchen Zeit..." comme dit le proverbe allemand, "... and better things even longer" complète-t-on sans doute à Dallas.

Cela valait vraiment le coup d'attendre le Python TI-Nspire CX II, une solution supérieure sur nombre de points à tout ce qui a pu se faire sur calculatrices concurrentes jusqu'à présent !

Texas Instruments semble avoir fait appel à des experts en Python et en pédagogie, l'assistant d'aide à la saisie, à ce jour une exclusivité à un tel niveau, est un fidèle compagnon qui devrait permettre de commencer à coder très rapidement et en grande autonomie, ravissant petits et grands, lycéens comme enseignants !

Texas Instruments semble également avoir été présent sur tous les fronts, on retient :

• la meilleure implémentation Python officielle pour le nombre de modules standard disponibles
• une capacité de tas / heap offert à la hauteur des grandes capacités de la machine, le plus grand tas / heap en mode examen, ce qui te permettra d'aborder sans contrainte des projets conséquents (interfaces, jeux, ...)
• également la plus grande capacité de stack / pile en mode examen
• de loin la plus grande bibliothèque de fonctions de tracé à ce jour, que ce soit par pixels ou par coordonnées, quoi que tu veuilles tracer il y a une solution !
• cerise sur le gâteau la gestion fort bienvenue dans ce contexte du double buffering, des calques hors écran, ainsi que des images
• des images pour ceux qui le veulent affichables sans effort et quasiment sans consommation mémoire d'une simple ligne, permettant à ceux qui le souhaitent de choisir d'avancer sur les graphismes d'un projet sans se casser la tête à coder des fonctions annexes - bref plusieurs niveaux d'entrée matière à différenciation pédagogique, mettant la réalisation de chefs-d'oeuvre à la portée de chacun et œuvrant pour la réussite de tous, de grands pédagogues chez TI
• la solution Python la plus performante en mode examen, une fois encore à la mesure du matériel offert

Tout petit bémol, en espérant être entendu, nous regrettons par contre le non respect d'un standard comme matplotlib.pyplot pour le module de tracé dans un repère.
C'est la bibliothèque mise en avant aux concours de recrutement des enseignants ; nous craignons que peu d'enseignants se lancent dans l'utilisation d'un ti_plotlib propriétaire qui sera incompatible avec les scripts des livres ainsi qu'avec la solution Python tournant en classe sur la tablette ou l'ordi, nuisant ainsi à l'interopérabilité.
Autant sur le matériel limité de la TI-83 Premium CE Edition Python on pouvait comprendre ce choix, autant ici ce n'est pas le cas.

Il n'empêche que c'est une très belle mise à jour, le fruit doré d'un immense travail construit méticuleusement dès le départ autour des besoins des enseignants et des élèves, merci TI !

Téléchargements :

• Mise à jour 5.2.0 pour calculatrice :
  
  • TI-Nspire CX II CAS, TI-Nspire CX II-T CAS, TI-Nspire CX II-C CAS
  • TI-Nspire CX II-T
  • TI-Nspire CX II
• Logiciel 5.2.0 pour ordinateur :
  
  • TI-Nspire CX CAS édition enseignant pour Windows / Mac
  • TI-Nspire CX CAS édition élève pour Windows / Mac
  • TI-Nspire CX édition élève pour Windows / Mac

[parisse]

Merci pour toutes ces informations et tests!
Quelques remarques:
* il faudrait ajouter 2 modules MicroPython KhiCAS: linalg et numpy, pour faire du calcul matriciel
* il faudra regarder de plus pres ce qui peut expliquer les mauvaises performances relatives du MicroPython KhiCAS Numworks pour le calcul flottant. C'est completement anormal que ca mette plus de temps qu'avec KhiCAS. De meme dans une moindre mesure pour le calcul entier.
* pour isprimep ca serait interessant de comparer avec le temps mis par la fonction isprime du module arit de MicroPython KhiCAS.

[critor]

Merci pour le retour.

* il faudrait ajouter 2 modules MicroPython KhiCAS: linalg et numpy, pour faire du calcul matriciel

C'est peut-être difficile à lire au format tableau utilisé, mais ils sont bien comptabilisés, tout comme ils l'ont été au QCC.
KhiCAS pour Ti-Nspire CX et NumWorks est la solution Python la plus complète, avec l'avantage du mode examen sur cette dernière.

il faudra regarder de plus pres ce qui peut expliquer les mauvaises performances relatives du MicroPython KhiCAS Numworks pour le calcul flottant.

Je ne sais pas, j'ai l'impression que ça plante, peut-être un problème de mémoire...
Avec le heap par défaut, seuil(0.012) répond en un instant, seuil(0.008) ne répond pas, l'écran reste figé, et la machine finit par s'éteindre.
Quand je la rallume, l'écran est rafraîchi et parle de script interrompu par appui sur une touche...
J'ai l'impression que seuil(0.008) consommant davantage de mémoire il y a une erreur quelque part, et que l'écran n'est pas rafraîchi.

Après, j'utilise une version KhiCAS qui n'est peut-être pas la dernière, celle modifiée par M4x1m3 pour la compatibilité Omega dont j'ai besoin :
https://m4xi1m3.github.io/nw-external-apps/
Peut-être faudrait-il lui demander de la mettre à jour.

[jean-baptiste boric]

Impressionnant, pour une première version c'est très abouti, complet et sans bavures... Mais c'est quand même cocasse de voir à quel point les deux implémentations Python sur calculatrice de TI ont relativement peu de choses en commun au final.

Je note quand même l'absence du module turtle, Texas Instruments sont résolument pionniers dans la lutte contre l'exploitation animale

[critor]

Je note quand même l'absence du module turtle, Texas Instruments sont résolument pionniers dans la lutte contre l'exploitation animale

Ils ont clairement quelque chose contre les tortues.
Sur TI-83PCE on a un module ce_turtl non standard, et qui en prime disparaît en mode examen.

Je suppose que pour eux ce n'est pas au programme du lycée. Mais ça s'appuie sur les acquis Scratch du collège, donc pour moi ce serait parfaitement pertinent. Sans compter les projets où ça pourrait également servir.

[Lionel Debroux]

Sans surprise, pendant ces derniers mois, TI n'a pas fait que supprimer l'accès (officiel ) au code natif sur les TI-eZ80, et donc se mettre en condition de recevoir des baffes en retour.
Globalement, ils ont en effet bien travaillé sur l'ajout de fonctionnalités utiles aux CX II, malgré quelques fautes de goût notées ici: petite pile d'exécution, absence du module turtle
Aux chiottes l'interopérabilité, c'est manifestement la devise de TI, et c'est peu excusable sur une machine de la puissance de la famille CX II.

L'absence persistante, manifestement décidée pour des raisons non techniques, des mêmes nouveautés sur les CX I n'est quant à elle pas excusable du tout...

[parisse]

Merci pour le retour.
C'est peut-être difficile à lire au format tableau utilisé, mais ils sont bien comptabilisés, tout comme ils l'ont été au QCC.

En effet, c'est un probleme d'alignement dans le tableau.

Après, j'utilise une version KhiCAS qui n'est peut-être pas la dernière, celle modifiée par M4x1m3 pour la compatibilité Omega dont j'ai besoin :
https://m4xi1m3.github.io/nw-external-apps/
Peut-être faudrait-il lui demander de la mettre à jour.

Je testerai ce week-end avec KhiCAS+Delta, je n'ai pas ma Numworks avec moi. Mais c'est tres bizarre, parce que seuil est une boucle tres simple en calcul flottant, je ne vois pas comment ca pourrait poser des problemes memoire. J'ai plutot l'impression qu'il y a un probleme avec l'initialisation de u, qui serait initialise en entier plutot qu'en flottant avec ensuite des calculs avec des rationnels. Ca expliquerait que ca aille plus vite avec KhiCAS Xcas qu'avec KhiCAS MicroPython car les entiers Xcas sont des entiers GMP, dont l'arithmetique est implementee de maniere bien plus efficace que les entiers de MicroPython.

[parisse]

L'absence persistante, manifestement décidée pour des raisons non techniques, des mêmes nouveautés sur les CX I n'est quant à elle pas excusable du tout...

Elle est tout ce qu'il y a de plus logique d'un point de vue commercial. C'est une des raisons qui m'a amene a ajouter MicroPython dans KhiCAS pour les Nspire CX (et du coup dans tout l'ecosysteme Xcas), pour que les possesseurs de CX ne se sentent pas obliges de racheter une CX II.

[Zocipal]

Merci beaucoup pour cette présentation ! Super mise à jour !

[Adriweb]

D'apres le changelog de TI, le TI-Basic a maintenant de la coloration syntaxique, wooo \o/