π
<-
Chat plein-écran
[^]

NumWorks Coques NumWorks édition limitée Mai 2021 à gagner

New postby critor » 01 May 2021, 16:47

13036Pour la
rentrée
2019
,
NumWorks
te sortait une coque
collector
en édition limitée pour sa calculatrice, la
Macaremaths
, illustrée tout en humour et talent sur le thème des Mathématiques. :bj:

Dans le même genre
NumWorks
renouvelle l'expérience en mieux cette année scolaire 2020-2021. Tu as déjà eu plusieurs opportunités d'habiller ta calculatrice de façon unique au monde ; tu as déjà eu l'occasion de gagner les coques édition limitée de :
1323013229

Aujourd'hui
NumWorks
te souhaite comme il se doit un joyeux 1er Mai 2021. Voici donc à gagner sa coque en édition limitée de
Mai 2021
. :favorite:

Nouvelle chance pour toi de compléter ta collection sur les différents comptes sociaux du constructeur : :D

13731Pour participer et peut-être gagner c'est très simple, il te faut :
  1. suivre, aimer ou t'abonner au compte du constructeur
  2. partager en photo ton tracé de courbe
    "le plus élégant"

    (et sans doute que le tracé sera plus élégant si affiché sur une calculatrice
    NumWorks
    ? ;) )

Tu as jusqu'au
Lundi 31 Mai 2021
, et n'hésite pas à nous montrer ça. ;)

HP Alerte diffusion versions HP Prime 2.1.14575 problématiques

New postby critor » 01 May 2021, 15:48

11694Suite à de lourdes réorganisations au sein de
Hewlett Packard
en 2019-2020, les 2 seuls développeurs qu'il restait pour la
HP Prime
,
Cyrille de Brébisson
et
Tim Wessman
, avaient été réaffectés à d'autres missions. À notre grand regret la formidable calculatrice
HP Prime
que nous avions plusieurs fois classée première dans nos tests de rentrée
QCC
, avait cessé d'évoluer depuis maintenant des années :
  • la dernière mise à jour hélas très mineure remontait à
    Janvier 2020
  • et la dernière mise à jour majeure remontait à
    Novembre 2018
Comme nous te l'annoncions dans un article précédent, il y a eu un incident concernant la
HP Prime
aux Pays-Bas. Le calcul exact
QPiRac
est interdit aux examens à compter de cette session 2021, sauf que comme la
HP Prime
n'avait plus été mise à jour depuis des années son mode examen ne tenait bien évidemment pas compte de cette nouvelle règle. L'Institution néerlandaise avait exigé une mise à jour d'ici la fin du mois d'avril.

Pour ce mois d'Avril
Hewlett Packard
a donc autorisé
Cyrille
et
Tim
à travailler davantage sur la
HP Prime
. Plusieurs versions ont été diffusées dans le cadre d'un bêta-test public, et les plus réussies ont fait l'objet d'un test complet chez nous :
  • 13 avril 2021 :
  • 16 avril 2021 :
    2.1.14549
    (régression du mode
    CAS
    : menu des fonctions
    CAS
    inutilisable)
  • 22 avril 2021 :
    2.1.14558
    (régression sur
    HP Prime G1
    : bloque la calculatrice)
  • 26 avril 2021 :
    2.1.14563
    (régression de l'appli
    Python
    : les opérations/fonctions construisant des chaînes retournent des chaînes vides)
  • 27 avril 2021 :
  • 28 avril 2021 :
    2.1.14575
L'
ultimatum
de l'Institution néerlandaise expirait donc ce
vendredi 30 avril
à minuit.

Bien qu'annoncée en tant que version bêta, la version
2.1.14575
a été publié le
29 avril
au soir à l'identique sur le serveur
FTP
de distribution des versions de production.

Et le
30 avril
au soir soit juste à temps pour les Pays-Bas, le fichier
.xml
indiquant les noms de fichiers correspondant à la dernière version a été mis à jour, activant donc les alertes de mise à jour dans les logiciels de connectivité et d'émulation
HP Prime
partout dans le monde, et signant donc le début de la diffusion à grande échelle de cette version
2.1.14575
.

Cette mise à jour
2.1.14575
concerne donc :
  • les calculatrices
    HP Prime G1
    et
    HP Prime G2
  • le logiciel
    HP Prime
    pour machines
    Windows 32 bits
    et
    Windows 64 bits
  • le logiciel de connectivité pour machines
    Windows 32 bits
    et
    Windows 64 bits
Attention donc, les logiciels pour
Mac
et
Linux
, ainsi que les applications pour
Android
et
iOS
ne sont à ce jour pas concernés par la mise à jour.

Nous ne manquerons pas de te publier un test complet de la version
2.1.14575
, mais à ce jour nous avons hélas quelque chose de bien plus urgent et grave à t'annoncer à son sujet.

Problème, les logiciels de connectivité et d'émulation
HP Prime
2.1.14575
diffusés sont marqués en tant que version
bêta
.

Peut-être est-ce une erreur, ou peut-être était-ce intentionnel devant le calendrier imposé.

Mais tu dois savoir que cela a des conséquences non annoncées : les versions bêta cesseront définitivement de fonctionner
60 jours
après leur date de compilation. Ce qui du
28 avril 2021
nous amène donc au
28 juin 2021
.

Nous ne sommes pas sûr que le
28 juin
les épreuves d'examens soient terminées partout dans le monde, certains candidats pourraient bien avoir une très mauvaise surprise, c'est regrettable...

Surtout que la solution de réinstaller alors la dernière version stable précédente
2.1.14425
de
Janvier 2020
te sera alors refusée. Il te faudra commencer par désinstaller les logiciels.

Et ce n'est peut-être pas le plus grave. Avec les formidables évolutions qu'il y a eu niveau programmation, comme découvert par , la version
2.1.14575
du logiciel de connectivité
HP Prime
souffre hélas d'une grave régression dans le support des fichiers
HP Prime
.

Les applications
HP Prime
utilisent un format
.hpappdir
, et notamment en interne un format
.hpappprgm
pour le script de l'application en question.
Les programmes
HP Prime
pour leur part utilisent un format
.hpprgm
similaire.

Les formats
.hpprgm
et
.hpappprgm
ont évolué dans le temps, se complexifiant au fur et à mesure des ajouts de nouvelles fonctionnalités.

Attention donc, il semble que la version
2.1.14575
du logiciel de connectivité
HP Prime
ne gère plus correctement les formats
.hpprgm
et
.hpappprgm
initiaux.

Cela concerne des programmes et applications publiés chez nous il y a plusieurs années, comme par exemple :
Mais également bien plus grave, l'intégralité des images et documents
.pdf
convertis en applications
HP Prime
chez nous. :mj:

Les versions bêtas précédentes étant également concernées, nous ne pouvons que te conseiller fortement de désinstaller au plus tôt la version
2.1.14575
du logiciel de connectivité, et de revenir à la version
2.1.14425
stable et pleinement fonctionnelle de
Janvier 2020
. Cela ne t'empêchera pas de mettre à jour ta calculatrice ni de profiter de ses nouvelles formidables fonctionnalités.

Tu peux par contre si tu le souhaites conserver le logiciel d'émulation, du moins jusqu'à sa date d'expiration.

Avec bien évidemment des développeurs qui ne répondent plus le Samedi, nous regrettons de n'avoir dans l'urgence pas d'autre solution que cette communication pour limiter les conséquences dramatiques à la veille des examens.

Téléchargements
:

  • mise à jour pour
    HP Prime 2.1.14575
  • logiciel de connectivité
    HP Prime
    :
    • 2.1.14425
      pour
      (pleinement fonctionnel + sans expiration)
    • 2.1.14575
      pour
      (défectueux + expire le
      28 juin 2021
      )
  • logiciel/appli d'émulation
    HP Prime
    :

NumWorks NumWorks Omega 1.21 : 100K de heap pour scripts Python !

New postby critor » 29 Apr 2021, 20:59

Les interpréteurs
MicroPython
ou similaires qui tournent sur nos calculatrices font appel à différents types de mémoires :
  • La mémoire de stockage, qui contient physiquement tes scripts prêts à l'emploi.
  • La pile
    (
    stack
    )
    qui 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
    )
    qui 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.
Le langage
Python
est un très gros consommateur de mémoire
heap
. En effet sur les plateformes 32 bits, un entier nul occupe déjà pas moins de 24 octets. Alors imagine tout le reste...

Tout ceci pour dire que la mémoire
heap
sera très souvent le facteur limitant lors de tes projets
Python
sur calculatrices.

Afin de te permettre de choisir ton modèle en toute connaissance de cause, nous t'avions déjà communiqué un classement des différents modèles
Python
par capacité
heap
:
  1. 252,1 Mo
    :
    HP Prime G2
  2. 15,6 Mo
    :
    HP Prime G1
  3. 2,068 Mo
    :
    TI-Nspire CX II
  4. 1,033 Mo
    :
    Casio Graph 90+E
  5. 101,262 Ko
    :
    Casio Graph 35+E II
  6. 33,545 Ko
    :
    NumWorks
  7. 18,354 Ko
    :
    TI-83 Premium CE Edition Python
  1. 252,1 Mo
    :
    HP Prime G2
  2. 15,6 Mo
    :
    HP Prime G1
  3. 4,100 Mo
    :
    TI-Nspire CX
  4. 2,068 Mo
    :
    TI-Nspire CX II
  5. 1,033 Mo
    :
    Casio Graph 90+E
  6. 101,262 Ko
    :
    Casio Graph 35+E II
  7. 64,954 Ko
    :
    NumWorks
    (firmware Omega + appli KhiCAS)
  8. 33,545 Ko
    :
    NumWorks
  9. 18,354 Ko
    :
    TI-83 Premium CE Edition Python
  1. 252,1 Mo
    :
    HP Prime G2
  2. 15,6 Mo
    :
    HP Prime G1
  3. 2,068 Mo
    :
    TI-Nspire CX II
  4. 1,033 Mo
    :
    Casio Graph 90+E / fx-CG50
  5. 101,262 Ko
    :
    Casio Graph 35+E II / fx-9750/9860GIII
  6. 33,545 Ko
    :
    NumWorks
  7. 20,839 Ko
    :
    TI-83 Premium CE + TI-Python
  8. 18,354 Ko
    :
    TI-83 Premium CE Edition Python / TI-84 Plus CE Python Edition
  1. 252,1 Mo
    :
    HP Prime G2
  2. 15,6 Mo
    :
    HP Prime G1
  3. 4,100 Mo
    :
    TI-Nspire CX / CX II
  4. 2,068 Mo
    :
    TI-Nspire CX II
  5. 2,050 Mo
    :
    TI-Nspire
  6. 1,033 Mo
    :
    Casio Graph 90+E / fx-CG50
  7. 258,766 Ko
    :
    Casio Graph 35/75+E / 35/75/95 / fx-9750/9860GII
    (SH4 - appli CasioPython)
  8. 101,262 Ko
    :
    Casio Graph 35+E II / fx-9750/9860GIII
  9. 64,954 Ko
    :
    NumWorks
    (firmware Omega + appli KhiCAS)
  10. 33,545 Ko
    :
    NumWorks
  11. 32,648 Ko
    :
    Casio Graph 35+E II / 35/75/85/95
    (SH3)
    / fx-9750/9860GIII / fx-9750/9860GII
    (SH3)
    / fx-9860G
    (appli CasioPython)
  12. 23,685 Ko
    :
    TI-83 Premium CE + TI-Python
  13. 20,839 Ko
    :
    TI-83 Premium CE + TI-Python
  14. 18,354 Ko
    :
    TI-83 Premium CE Edition Python / TI-84 Plus CE Python Edition

De nouveaux éléments concernant la
NumWorks
nécessitent aujourd'hui la mise à jour de ce classement : une bonne et une mauvaise nouvelle. Commençons par la mauvaise.

Sur
NumWorks N0110
, tu as la possibilité d'installer
KhiCAS
, une application t'offrant un environnement intégré de Mathématiques et de Sciences développé par
Bernard Parisse
, enseignant-chercheur à l'Université de Grenoble, en parallèle de son logiciel
Xcas
pour ordinateur. Elle intègre nombre de choses : moteur de calcul formel
GIAC
, bibliothèques d'unités et de constantes physiques, application tableur, application de tableau périodique des éléments, langages de programmation
Python
et
Xcas
, ...

Le
firmware
officiel ne gérant pas les applications additionnelles, pour l'installer il te fallait commencer par passer ta calculatrice sous un
firmware
tiers, comme par exemple
Omega
. Or, l'application
KhiCAS
distribuée sur la page du
firmware
tiers
Omega
est sûrement suffisante pour nombre de choses, mais n'est pas stable.

Si tu es un utilisateur exigeant de
KhiCAS
, il te faut une version aussi fiable que possible et elle existe ; il te suffit de prendre l'application
KhiCAS
distribuée pour
Delta
, un autre
firmware
tiers.

Mise à part la gestion des applications,
Delta
apporte beaucoup moins d'améliorations qu'
Omega
, et malheureusement ces deux éditions de l'application
KhiCAS
ne sont pas interchangeables. En attendant une éventuelle résolution du problème, nous nous devons donc de tenir compte de
Delta
au classement.

D'autre part, nous ne l'avions pas remarqué mais
Omega
a changé la capacité du
heap
Python
à compter de sa version
1.21
un peu plus tôt cette année... ;)

Alors découvrons tout cela sans plus attendre.

Le module
Python
standard
gc
permet de connaître la capacité exacte du
heap
, d'un simple appel gc.mem_alloc() + gc.mem_free(). Toutefois, toutes les calculatrices
Python
n'intègrent pas ce module.

Afin de pouvoir faire des comparaisons équitables, nous construisons notre propre script d'estimation de la capacité
heap
. Il utilise les tailles des objets
Python
suivantes, valides pour 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
Notre script va tenter de remplir le
heap
. Il utilise pour cela plusieurs objets qu'il va tenter de faire grandir chacun son tour, jusqu'à déclenchement d'une erreur, et retourner alors le calcul de la capacité ainsi consommée.


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


Selon l'état de l'interpréteur
Python
, la capacité retournée par un appel mem() peut légèrement varier. Aussi lancerons-nous le test plusieurs fois et conserverons-nous la valeur maximale, voici une fonction en ce sens :
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
NumWorks
munies du
firmware
officiel
Epsilon
nous trouvons
32,526 Ko
, et c'était pareil avec le
firmware
tiers
Omega
jusqu'à la version
1.20.3
.

Sur la
NumWorks N0110
munie du
firmware
tiers
Delta
, nous trouvons nettement moins pour le
heap
de l'application
Python
officielle, seulement
24,179 Ko
.

Est-ce cette économie de mémoire qui permet à
KhiCAS
de fonctionner correctement ? En tous cas l'interpréteur
Python
de
KhiCAS
retourne pour le même test la superbe capacité de
63,898 Ko
.

13823Si tu munis maintenant ta
NumWorks
des dernières version
1.21
du
firmware
tiers
Omega
, tu obtiens alors une fantastique capacité
heap
de désormais
98,928 Ko
! :bj:

Avec la nouvelle capacité
heap
Python
de près de
100 Ko
dans
Omega 1.21
, ta
NumWorks
a enfin presque terminé de rattraper son retard sur la
Casio Graph 35+E II
bien moins chère ! :bj:

Précisons que pour être aussi exact que possible, il faut rajouter à ces valeurs de retour la consommation mémoire des définitions du script, soit
1,056 Ko
.

D'où le classement maintenant à jour :
  1. 252,1 Mo
    :
    HP Prime G2
  2. 15,6 Mo
    :
    HP Prime G1
  3. 2,068 Mo
    :
    TI-Nspire CX II
  4. 1,033 Mo
    :
    Casio Graph 90+E
  5. 101,262 Ko
    :
    Casio Graph 35+E II
  6. 33,582 Ko
    :
    NumWorks
  7. 18,354 Ko
    :
    TI-83 Premium CE Edition Python
  1. 252,1 Mo
    :
    HP Prime G2
  2. 15,6 Mo
    :
    HP Prime G1
  3. 4,100 Mo
    :
    TI-Nspire CX
  4. 2,068 Mo
    :
    TI-Nspire CX II
  5. 1,033 Mo
    :
    Casio Graph 90+E
  6. 101,262 Ko
    :
    Casio Graph 35+E II
  7. 98,928 Ko
    :
    NumWorks
    (firmware Omega)
  8. 64,954 Ko
    :
    NumWorks N0110
    (firmware Delta / Omega + appli KhiCAS)
  9. 33,582 Ko
    :
    NumWorks
  10. 25,235 Ko
    :
    NumWorks N0110
    (firmware Delta)
  11. 18,354 Ko
    :
    TI-83 Premium CE Edition Python
  1. 252,1 Mo
    :
    HP Prime G2
  2. 15,6 Mo
    :
    HP Prime G1
  3. 2,068 Mo
    :
    TI-Nspire CX II
  4. 1,033 Mo
    :
    Casio Graph 90+E / fx-CG50
  5. 101,262 Ko
    :
    Casio Graph 35+E II / fx-9750/9860GIII
  6. 33,582 Ko
    :
    NumWorks
  7. 20,839 Ko
    :
    TI-83 Premium CE + TI-Python
  8. 18,354 Ko
    :
    TI-83 Premium CE Edition Python / TI-84 Plus CE Python Edition
  1. 252,1 Mo
    :
    HP Prime G2
  2. 15,6 Mo
    :
    HP Prime G1
  3. 4,100 Mo
    :
    TI-Nspire CX / CX II
  4. 2,068 Mo
    :
    TI-Nspire CX II
  5. 2,050 Mo
    :
    TI-Nspire
  6. 1,033 Mo
    :
    Casio Graph 90+E / fx-CG50
  7. 258,766 Ko
    :
    Casio Graph 35/75+E / 35/75/95 / fx-9750/9860GII
    (SH4 - appli CasioPython)
  8. 101,262 Ko
    :
    Casio Graph 35+E II / fx-9750/9860GIII
  9. 98,928 Ko
    :
    NumWorks
    (firmware Omega)
  10. 64,954 Ko
    :
    NumWorks N0110
    (firmware Omega + appli KhiCAS)
  11. 33,582 Ko
    :
    NumWorks
  12. 32,648 Ko
    :
    Casio Graph 35+E II / 35/75/85/95
    (SH3)
    / fx-9750/9860GIII / fx-9750/9860GII
    (SH3)
    / fx-9860G
    (appli CasioPython)
  13. 25,235 Ko
    :
    NumWorks N0110
    (firmware Delta)
  14. 23,685 Ko
    :
    TI-83 Premium CE + TI-Python
  15. 20,839 Ko
    :
    TI-83 Premium CE + TI-Python
  16. 18,354 Ko
    :
    TI-83 Premium CE Edition Python / TI-84 Plus CE Python Edition


À quand les
120K
histoire que cela change l'ordre du classement ? ;)

HP Mise à jour HP Prime 2.1.14567 révolutionnaire avec Python !

New postby critor » 29 Apr 2021, 10:21

11694Suite à de lourdes réorganisations au sein de
Hewlett Packard
en 2019-2020, les 2 seuls développeurs qu'il restait pour la
HP Prime
,
Cyrille de Brébisson
et
Tim Wessman
, avaient été réaffectés à d'autres missions.

À notre grand regret la formidable calculatrice
HP Prime
que nous avions plusieurs fois classée première dans nos tests de rentrée
QCC
, avait cessé d'évoluer depuis maintenant des années :
  • la dernière mise à jour hélas très mineure remontait à
    Janvier 2020
  • et la dernière mise à jour majeure remontait à
    Novembre 2018
La machine n'était donc plus en adéquation avec les dernières évolutions de programmes dans le cadre de la réforme du lycée, et notamment l'avènement du
Python
en tant que langage de programmation universel, commun à l'ensemble des matières scientifiques.

C'était d'autant plus regrettable qu'une application
Python
était bel et bien en préparation au moins depuis octobre 2019 ; les développeurs avaient bien donc fait la veille institutionnelle, anticipé et prévu de quoi être à l'heure, avant que l'on vienne leur mettre des bâtons dans les roues.

Or comme nous te l'annoncions dans un article précédent, il y a eu un incident concernant la
HP Prime
aux Pays-Bas. Le calcul exact
QPiRac
est interdit aux examens à compter de cette session 2021, sauf que comme la
HP Prime
n'a plus été mise à jour depuis des années son mode examen ne tient bien évidemment pas compte de cette nouvelle règle. L'Institution néerlandaise a exigé une mise à jour d'ici la fin du mois d'avril.

Énorme bonne nouvelle en conséquence que nous traitions la semaine dernière, avec la sortie d'une version bêta publique
2.1.14541
. Compilée le
13 avril
il s'agissait d'une mise à jour majeure incluant non seulement enfin l'application
Python
mais faisant également évoluer très significativement d'autres fonctionnalités de la machine ! :bj:

D'autres versions bêta sont sorties depuis :
  • 2.1.14549
    le
    16 avril
  • 2.1.14558
    le
    22 avril
  • 2.1.14563
    le
    26 avril
Toutefois nous ne les avions pas autant mises en avant. Certes, elles amélioraient plusieurs des points que nous avions évoqués, mais elles souffraient également toutes de régressions majeures :
  • saisie incorrecte via les menus pour appeler les fonctions
    CAS
    en mode
    CAS
  • blocage des calculatrices
    HP Prime G1
  • en
    Python
    , renvoi d'une chaîne vide pour tout calcul ou fonction construisant une chaîne
De notre point de vue la version bêta initiale
2.1.14541
était préférable, dans le sens où elle souffrait certes d'inconvénients plus nombreux mais néanmoins beaucoup moins graves.

Voici maintenant disponible la nouvelle version bêta publique
14567
compilée le
27 avril 2021
. Cette mise à jour concerne :
  • les calculatrices
    HP Prime G1
    et
    HP Prime G2
  • le logiciel
    HP Prime
    pour machines
    Windows 32 bits
    et
    Windows 64 bits
  • le logiciel de connectivité pour machines
    Windows 32 bits
    et
    Windows 64 bits
Les développeurs
HP Prime
t'invitent à la tester et à communiquer tes retours de préférence par courriel à
calcbeta@hp.com
.

N'ayant pas détecté de régression majeure avec cette version, la voici annoncée en grand chez nous.

Nous allons prendre le temps de te rappeler l'ensemble des nouveautés déjà annoncées, d'en approfondir de nouvelles, et de traiter des changements apportés par cette dernière version. De plus pour chaque point nous allons tester, te donner notre avis, et également t'expliquer l'utilisation à l'aide d'exemples.

N'hésite pas à utiliser le sommaire ci-dessous afin d'accéder directement aux points qui t'intéressent le plus.



Sommaire :





Périphériques USB - HP Prime G2

Go to top

13767Commençons par une nouveauté révolutionnaire spécifique à la
HP Prime G2
que nous n'avions pas réussi à faire fonctionner correctement la dernière fois.

Il t'est maintenant possible de connecter des périphériques
USB
et de communiquer avec. Tu as pour cela à ta disposition les fonctions suivantes :
  • USBOpen(vid, pid) pour établir une connexion avec le périphérique
    USB
    correspondant
  • USBSend({...}) pour envoyer des données au périphérique
  • USBReceive() pour lire des données depuis le périphérique
  • USBOpen() qui permet maintenant de lister les identifiants
    vid/pid
    du ou des appareils
    USB
    branchés sur ta calculatrice, fort pratique pour écarter une erreur d'identifiant en cas d'échec de la connexion

13799Il t'est par exemple possible de connecter une 2ème calculatrice
HP Prime
, peut-être enfin un pas vers la possibilité de transférer des données entre deux calculatrices.

Cela ouvre la voie vers bien d'autres possibilités ; clavier
USB
, souris optique
USB
, clé
USB
:
13801138031380213800


13804Et même les immenses possibilités de projets
STEM
offertes par exemple par une carte
BBC micro:bit
! :D

Toutefois pour l'instant les fonctions sont basiques. C'est-à-dire que les périphériques ainsi connectés ne sont pas fonctionnels en l'état ; les souris ne font rien et les touches clavier pas mieux. C'est-à-dire que ces fonctions doivent être utilisées pour programmer des pilotes ciblant chacun des types de périphériques que tu souhaites utiliser.

Précisons de plus que la détection de périphériques via un appel
USBOpen()
n'est pas très fiable. Nous n'avons réussi à détecter que 2 souris sur 3... 1 clé
USB
sur 10... Et si cela a marché avec la carte
BBC micro:bit v1
, cela n'a pas été le cas avec une carte
BBC micro:bit v2
.

Peut-être y a-t-il des différences de consommation électrique entre ces périphériques gênant la détection au-delà d'un certain seuil, mais si c'est ça la limite serait bien basse par rapport à ce que l'on observe sur les modèles
Texas Instruments
concurrents.




USB - HP Prime G2

Go to top

13821Autre nouveauté spécifique à la
HP Prime G2
que nous n'avions pas trouvé la dernière fois.

D'origine, la
HP Prime G2
rafraîchit son écran à une fréquence de
55 Hz
.

Désormais, grâce aux nouveaux raccourcis
On
Shift
+
et
On
Shift
-
, tu peux monter cette fréquence par pas de
10 Hz
jusqu'à
125 Hz
.

Une fréquence plus élevée ralentit très légèrement la machine, mais te permet alors des changements d'écrans/menus visuellement plus instantanés et agréables, et notamment des animations bien plus fluides :





Assistant de résolution de polynômes - boîte à outils CAS

Go to top

Pour résoudre tes équations polynomiales, plus besoin de saisir un appel de la fonction
solve()
avec l'ensemble de ses paramètres. Nous avons maintenant un assistant de résolution de polynômes, accessible via l'onglet
CAS
de la boîte à outils.

Il suffit de saisir les coefficients, et on obtient alors automatiquement les racines accompagnées d'une représentation graphique sur un intervalle jugé pertinente.

Un bel ajout, cela va bien évidemment dans la bonne direction. Nous pouvons toutefois regretter peut-être des erreurs de jeunesse :
  • une interface de saisie encore rudimentaire, réclamant les coefficients sous la forme d'un vecteur, ne simplifiant pas vraiment la chose sur ce point par rapport à la saisie habituelle de l'appel à
    solve()
  • l'affichage de l'expression du polynôme avec :
      des signes
      +
      inutiles
    • des parenthèses oubliées avec un affichage faux, notamment en cas de coefficients complexes
    • un oubli d'affichage du terme de degré zéro, si celui-ci vaut +1 ou -1
  • l'absence de résultats en écriture exacte bien que l'option
    Intelligent Math
    soit activée, ce qui reste ici hélas un gros manque par rapport à la concurrence




Test χ² GOF - application Inférence

Go to top

Dans l'application
Inférence
, le test χ² GOF te permet maintenant d'imposer le nombre de degrés de libertés.

Ce nouveau paramètre est utilisable aussi bien sur l'interface de l'application que lors d'un appel direct à sa fonction
CHI2GOF()
.




Application Tableur - HP Prime G2

Go to top

L'application
Tableur
souffrait d'un petit
bug
, mais bizarrement il ne se déclenchait que sur
HP Prime G2
.

Si tu choisissais d'aller directement à une cellule via le menu
Aller
en bas d'écran et validais une saisie d'adresse vide, la calculatrice redémarrait immédiatement.
C'est maintenant corrigé.




Moteur de calcul exact QPiRac - Home

Go to top

La
HP Prime
est un agrégat de 2 mondes :
  • le mode numérique avec l'écran de calcul accessible via
    ⌂Home
    et les diverses applications accessibles via
    Apps
    , le tout développé par
    HP
    , agrémenté de diverses interfaces graphiques et offrant pléthore de fonctions avec des noms en majuscules
  • le mode
    CAS
    avec l'écran de calculs
    CAS
    offrant pour sa part un moteur de calcul formel
    (le moteur
    GIAC
    développé pour le logiciel
    Xcas
    par
    Bernard Parisse
    enseignant-chercheur à l'Université de Grenoble)
    , accompagné ici d'interfaces spécifiques en mode texte et offrant des fonctions avec des noms en minuscules

L'écran
⌂Home
cible le calcul numérique. C'est-à-dire qu'il fournit les résultats en écriture décimale, approchés si besoin.

Si tu souhaitais obtenir des résultats exacts, plusieurs possibilités s'offraient à toi :
  • soit utiliser l'écran de calcul
    CAS
    avec ce qu'il impliquait, soit interfaces en texte, noms de fonctions différents et en minuscules
  • soit rester sur l'écran
    ⌂Home
    mais y spécifier un appel au moteur
    CAS
    sous la forme CAS.eval(...), rapidement lourd si tu devais le faire pour chaque calcul
  • soit encore sur l'écran
    ⌂Home
    spécifier tes calculs au sein d'un appel QPI(...) plus rapide à saisir, recherchant alors un résultat exact approchant sous les formes
    $mathjax$\pm a\sqrt{\frac{b}{c}}$mathjax$
    (
    QRac
    )
    ou
    $mathjax$\pm a\sqrt{\frac{b}{c}}\pi$mathjax$
    (
    QPi
    )
    pas toujours pertinentes
  • soit encore sur l'écran
    ⌂Home
    sélectionner un résultat numérique puis taper
    ab/c
    , mais cela ne faisait que rechercher une forme
    $mathjax$\frac{a}{b}$mathjax$
    proche du résultat en question et ne fournissait qu'encore plus rarement des résultats pertinents


La mise sous forme exacte via la touche
ab/c
commettait parfois des erreurs impressionnantes, comme ci-contre de pas moins de 10 milliards sur e24. Normal puisque l'on sortait de l'intervalle de fiabilité de l'algorithme approchant le résultat par une fraction.

L'appui sur
ab/c
évite maintenant de traiter les nombres trop grands.

Déjà avant toute chose, notons un petit changement de forme très agréable concernant
QPI()
. La forme recherchée n'est plus
$mathjax$a\sqrt{\frac{b}{c}}$mathjax$
mais
$mathjax$a\frac{\sqrt{b}}{c}$mathjax$
, ce qui évite maintenant les racines carrées au dénominateur.

Plus besoin de t'embêter avec cette gymnastique désormais, grande nouveauté, après des années la mise à jour nous rajoute enfin un moteur de calcul exact sur l'écran de calcul
⌂Home
comme la plupart des modèles concurrents ! :bj:

Attention toutefois, actuellement il ne semble pas activé par défaut. Il te faut accéder aux paramètres via
Shift
, et cocher
Intelligent Math
sur la 2ème page.

Une fois ceci fait tu obtiens enfin par défaut des résultats exacts à chaque fois que possible, la plupart du temps plus besoin de réaliser des manipulations spécifiques pour cela ! :bj:

Les formes gérées sont un peu plus larges qu'avec la fonction
QPI()
, elles semblent s'étendre cette fois-ci au
QPiRac
, c'est-à-dire à tout ce qui appartient aux 2 familles de nombres suivantes :
  • QPi
    : multiples rationnels de
    π
    -
    $mathjax$\pm\frac{a\pi}{b}$mathjax$
    (pour les angles en radians notamment)
  • binômes de rationnels et/ou radicaux -
    $mathjax$\frac{\pm a\sqrt{b} \pm c\sqrt{d}}{f}$mathjax$
    (ce qui couvre un large ensemble allant des fractions du collège aux racines de polynômes du 2nd degré au lycée en passant par nombre de valeurs remarquables en trigonométrie)
Bref, activer
Intelligent Math
c'est comme si une fonction
QPI(...)
beaucoup plus évoluée était automatiquement appliquée à chacun de tes résultats.

Accessoirement si tu préfères obtenir des résultats en écriture décimale puis éventuellement les mettre en écriture exacte, la touche
ab/c
gère désormais elle aussi les formes
QPi
et
QRac
, activables à l'écran de configuration.

Par contre, on remarque que le moteur de calcul exact
QPiRac
ne semble pas fonctionner si le résultat calculé est directement affecté à une variable.

À partir de l'affectation la valeur exacte semble définitivement perdue, ne pouvant être retrouvée automatiquement.

Même problème de moteur de calcul exact ineffectif dans le contexte des objets composés à partir de plusieurs nombres
(listes, matrices, nombres complexes...)
.


En passant grande nouveauté que tu viens peut-être de remarquer sur les captures d'écran, le menu de bas d'écran te permet enfin de sauvegarder et recharger des états de l'écran de calcul
⌂Home
. Très pratique pour travailler en parallèle les problèmes des différents cours de sciences du jour.

En parlant d'affectations nouveauté également, tu as enfin la possibilité d'affecter simultanément plusieurs variables.

Pour rester sur le calcul, la justesse des calculs par des fonctions trigonométriques en radians a été améliorée.

Dans la version bêta précédente, les erreurs de calcul dans ce contexte
(résultat proche de zéro au lieu d'un résultat nul, résultat très grand au lieu d'une erreur)
se faisaient bien plus rares, mais ne disparaissaient pas complètement pour autant.

Cette nouvelle version bêta va encore plus loin, mais commet alors quelques erreurs. Pourquoi est-ce que
$mathjax$tan\left(\frac{3\pi}{2}\right)=+\infty$mathjax$
? Erreur que nous n'avions pourtant pas pour
$mathjax$tan\left(\frac{\pi}{2}\right)$mathjax$
...

Ces améliorations ne se limitent d'ailleurs pas à la trigonométrie et sont bien plus générales que cela.




Mode examen - Pays-Bas et France

Go to top

Comme nous te l'avions expliqué cette mise à jour, pour le moment en bêta, sort en urgence pour les examens aux Pays-Bas.

Aux Pays-Bas les examens de l'enseignement secondaire exigent l'activation du mode examen des calculatrices, mais interdisent de plus certaines fonctionnalités :
  • le calcul formel
    (CAS)
  • tout élément logiciel additionnel
    (ce qui interdit certes les programmes préchargés mais également toute application additionnelle, c'est-à-dire sur certains modèles même les applications officielles préchargées lorsqu'elles ont le tort de ne pas être intégrées au système)
  • tout accès à un éditeur de texte
    (ce qui interdit entre autres l'ouverture de l'éditeur de programmes, et par conséquent toute création de programme pendant l'examen)

Pour activer correctement le mode examen, les candidats devaient choisir de personnaliser sa configuration et tout remplir correctement :
  • durée suffisante
    (4 heures)
  • contenu mémoire préexistant masqué ou effacé
  • et en prime préciser des fonctionnalités à verrouiller via le bouton tactile
    Configuration
    en bas d'écran :
    • Apps utilisateur
    • CAS
    • Remarques et programmes
    • Nouv. remarques et programmes

Nouveauté à compter de cette session 2021, en dehors des quotients de nombres entiers le reste des résultats exacts
QPiRac
sont désormais également interdits aux examens des Pays-Bas.

Or il n'y avait aucune option relative à cela ; les résultats exacts
QPiRac
restaient dans tous les cas accessibles en mode examen via la fonction
QPI(...)
.

Le nouveau mode examen de cette version bêta résout le problème en rajoutant 2 limitations de fonctionnalités relatives au calcul exact à l'écran de configuration du mode examen :
  • Intelligent Math
  • a b/c Key options

HP
va même très loin pour faire plaisir aux Pays-Bas, jusqu'à présent le mode examen personnalisé n'avait par défaut aucune limitation de fonctionnalités activée.

Et bien désormais gros changement désormais, le
a b/c Key options
est coché par défaut.

a b/c Key options
désactive à la fois :
  • la mise sous forme exacte via la touche
    ab/c
  • la mise sous forme exacte via la fonction
    QPI(...)
Par contre cela ne désactive apparemment pas le moteur de calcul exact
QPiRac
rajouté à l'écran
⌂Home
.

Il semble donc que les candidats aux Pays-Bas devront dès cette année cocher quand même 1 limitation supplémentaire à l'écran de configuration des fonctionnalités en mode examen :
  • Apps utilisateur
  • CAS
  • Intelligent Math
  • Remarques et programmes
  • Nouv. remarques et programmes
  • a b/c Key options
    (coché par défaut)

Autre changement pour faire plaisir aux Pays-Bas dans l'application
Suites
.

Lorsque la calculatrice est réglée en Néerlandais, les champs permettant de choisir le type de définition de suite ainsi que le rang initial éventuel passent en premier.

Le mode examen gagne des façons de désactiver seulement certaines fonctions
CAS
:
  • une nouvelle option permet de désactiver les fonctions
    CAS
    d'arithmétique
    ifactor()
    ,
    idivis()
    ,
    igcd()
    et
    lcm()
  • Do1VStats
    désactive désormais également les fonctions
    CAS
    de médiane, quartile et moyenne
  • Stat2Vars
    désactive désormais également les fonctions de régression du mode
    CAS
  • le même réglage unique désactive désormais les fonctions
    comb()
    ,
    perm()
    ,
    min()
    et
    max()
    aussi bien en mode numérique que
    CAS
Cela permettra peut-être aux candidats de certains pays ou examens de ne pas avoir à désactiver complètement le moteur
CAS
.

Dans les pays comme la France où ce sont les candidats qui activent le mode examen, la
HP Prime
était bien embêtante. En effet, pour ceux qui arrivaient à leur épreuve avec un mode examen déjà activé
(et donc potentiellement une mémoire non vide)
, il n'y avait pas de moyen simple de réinitialiser le mode examen.

La bouton
reset
n'efface pas les données, et à moins de disposer sur place d'un ordinateur ou autre hôte
USB
avec la bonne connectique sous la main pour désactiver puis réactiver le mode examen, la seule solution était d'aller tout effacer dans le menu mémoire.

Grande nouveauté avec cette version, lorsque activé, l'écran de statut du mode examen présente enfin un
Restart
en menu de bas d'écran.

Finies les manipulations compliquées ou impossibles pour le surveillant, une simple pression sur ce bouton tactile suffira ! :bj:




Assistant de résolution de lois de probabilités - boîte à outils

Go to top

Résoudre un problème de loi de probabilités jusqu'à présent, c'était complexe
(et pas que sur
HP Prime
)
.

Tu avais une fonction pour chaque type de loi de probabilités, et également une fonction pour chaque type de question à résoudre
(densité, cumulatif et inverse)
. Soit pas moins de 7×3=21 fonctions avec des noms différents et bien sûr des paramètres différents.

Et bien autre grande nouveauté, la boîte à outils
🧰
te permet désormais d'accéder à un
solveur
de problèmes de lois de probabilités continues.

Pas moins de 5 lois t'y sont proposées au choix :
  • normale
  • Student
  • χ2
  • Fisher
  • géométrique

Tu dois ensuite choisir le type de question :
  • center
    pour travailler sur la forme
    p(...≤X≤...)
  • lower tail
    pour travailler la forme
    p(X≤...)
  • upper tail
    pour travailler la forme
    p(X≥...)
  • tails
    pour travailler la forme
    p(X≤... ∪ X≥...)

Il te faut ensuite saisir :
  • le ou les paramètres de la loi de probabilité concernée
  • ainsi que l'information dont tu disposes dans ton problème, soit au choix :
    • la valeur de la probabilité
    • la ou les bornes de l'intervalle
Il te suffit alors de sélectionner la seule information manquante que tu n'as pas complétée et de taper
Résoudre
pour l'obtenir automatiquement ! :D

Simple, intuitif, avec même en prime un diagramme t'illustrant la question travaillée ainsi que sa réponse, bravo
HP
! :bj:

Cela nous semble beaucoup ressembler à la superbe application de probabilités que la
NumWorks
propose depuis la rentrée 2017, ainsi qu'à celle que
Casio
est en train de préparer pour la rentrée 2021.

Mais ce n'est absolument pas un reproche. Quand c'est génial, pourquoi se gêner ? ;)

On peut justement déjà comparer le nombre de lois disponibles :

HP Prime
NumWorks
Casio
binomiale
géométrique
hypergéométrique
Poisson
Discrètes

exponentielle
Fisher
normale
Student
uniforme
χ²
Continues

TOTAL
.

.
.
1

.



.

4

5


.

3







6

9




4

.



.

4

8


Si la
HP Prime
propose moins de lois, notons par contre que son interface permet bien davantage de choses que celle de la
NumWorks
(par rapport à
Casio
nous ne savons pas encore)
.

En effet, pour l'ensemble des lois proposées, la
HP Prime
permet de résoudre les questions de probabilité inverse dans le cadre d'une forme
p(...≤X≤...)
, là où la
NumWorks
ne l'autorise que pour la seule loi normale.

Mais surtout autre exclusivité à ce jour, l'option cochable
Linked
en bas d'écran te permet de préciser pour ce genre de forme si tu souhaites obtenir les 2 bornes d'un intervalle centré, ou bien seulement l'une des deux bornes, déterminée alors dans ce cas par rapport à la valeur que tu as précisée pour l'autre.




Solveur d'équations

Go to top

L'application de résolution d'équations autorise maintenant la saisie d'équations comportant des variables non encore définies.

Plutôt qu'une erreur, elle te propose dans ce cas de les définir.
Toutefois dans la bêta précédente, refuser de créer ces variables déclenchait alors une erreur de syntaxe.
C'est maintenant corrigé.




Assistant de résolution de triangles

Go to top

Dans le même style, tu disposais déjà d'une très belle application permettant de résoudre les problèmes de géométrie autour du triangle.

Il te suffisait de saisir 3 informations
(longueur d'un côté ou mesure d'un angle)
afin d'obtenir les 3 mesures manquantes, peu importe qu'elles concernent des côtés ou des angles ! :bj:

Cerise sur la gâteau dans cette mise à jour, lors de la résolution tu obtiendras en prime l'aire du triangle.




Bibliothèque d'unités

Go to top

Nouveauté dans la bibliothèque d'unités physiques accessible via
Shift
□/□
, les unités relatives aux couples de forces.

En mode
CAS
, nous bénéficions de meilleures simplifications d'unités.




Graphes, fonctions et coordonnées

Go to top

Passons aux fonctions. En mode réel, les graphes de fonctions dont les expressions utilisent des puissances fractionnaires sont maintenant tracés au complet.

Il devient maintenant possible d'intégrer une fonction dérivée.

Tu pouvais jusqu'à présent convertir des coordonnées :
  • de cartésiennes à polaires avec la fonction
    polar_coordinates()
  • de polaires à cartésiennes avec la fonction
    rectangular_coordinates()
Nous bénéficions d'une nouvelle fonction
CoordinateConvert()
permettant de convertir des coordonnées de façon cette fois-ci unifiée.

Elle gère non seulement les coordonnées 2D cartésiennes et polaires, mais également en prime les coordonnées 3D cartésiennes, cylindriques et sphériques !




Listes et matrices

Go to top

Tu pouvais déjà récupérer et modifier un élément de liste ou matrice en appelant le nom de cette dernière avec son numéro
(attention, commençant à 1 et non à 0 comme en
Python
)
.

Tu peux maintenant réaliser ces mêmes opérations en appelant les fonctions
GET()
ou
PUT()
.

Un avantage notamment pour
PUT()
est que cela permet l'imbrication de son appel au sein d'une autre fonction, ce qui n'était pas possible avec l'opérateur d'affectation.

Tu pouvais déjà convertir des listes en matrices et vice-versa, grâce aux fonctions
list2mat()
et
mat2list()
.

Tu as maintenant de nouvelles fonctions au comportement légèrement différent et qui peut-être te seront utiles,
ListToMat()
et
MatToList()
.




Saisie en notation RPN

Go to top

La
HP Prime
te permet plusieurs formes de saisie de tes expressions :
  • Livre
    pour la saisie en écriture naturelle comme dans tes livres et énoncés
  • Algébrique
    pour une saisie sur une seule ligne, pouvant nécessiter par rapport à la précédente l'ajout de parenthèses
  • RPN
    , une notation post-fixée dite notation polonaise inverse utilisée par défaut sur les calculatrices
    HP
    des années 1980 et 1990, une notation logique très rapide ne nécessitant aucune parenthèse, un bel hommage

Si la notation
RPN
fonctionnait à l'écran de calculs, elle causait quelques problèmes lorsque l'on saisissait des formes erronées dans le tableur, les boîtes de dialogue, ainsi que l'éditeur de données statistiques. C'est maintenant corrigé.




Moteur de calcul formel - CAS

Go to top

Dans le mode
CAS
, nous bénéficions de toute une collection d'améliorations du moteur de calcul, soit l'ensemble des améliorations apportées entre temps au moteur
GIAC
de
Xcas
.







De nouveaux avertissements accompagnent certains résultats.




Applications

Go to top

La
HP Prime
te permet de développer et rajouter des applications. Ces applications tierces sont écrites dans les mêmes langages que les programmes, mais sont rajoutées et lançables depuis l'écran d'accueil.

Petite nouveauté pour le développement d'applications, la fonction
Apps()
te permet d'obtenir la liste des applications installées sur la calculatrice, avec en premier élément le nom de l'application courante.

Particulièrement pratique pour les applications qui ont besoin de ressources présentes dans d'autres applications, ou dont les fonctionnalités sont réparties entre différentes applications à cause de la limite de taille à 4,5 Mo par application.

DelApp("nom_appli") te permet également de réinitialiser une application contrairement à ce que son nom indique.




Python : Éditeur et aide en ligne

Go to top

Dans l'application
Python
, il y a 2 vues :
  • la vue
    Symb
    avec l'éditeur de script
  • la vue
    Num
    avec la console
Pour le moment nous allons nous concentrer sur l'éditeur de script.

Justement, grande nouveauté par rapport à la bêta précédente, l'éditeur est enfin accessible sur
HP Prime G1
.


L'éditeur en soi est assez rudimentaire. Il ne bénéficie ni de coloration syntaxique, ni d'autocomplétion, et n'indente pas non plus automatiquement lorsque l'on retourne à la ligne.

Il est accompagné d'un menu de bas d'écran
Tmplt
permettant de saisir rapidement différents blocs de commandes
Python
.

Toutefois quelque chose de remarquablement bien conçue, c'est le menu
Cmds
.

Celui-ci liste les éléments des différents modules disponibles, et va même de façon fort logique jusqu'à lister les sous-éléments lorsqu'il y en a ! :bj:

Bien dommage par contre que ces menus n'aient apparemment rien prévu pour saisir rapidement une commande incontournable comme
import
.

Autre fonctionnalité absolument remarquable, tu disposes d'une formidable aide en ligne qui t'explique de façon exhaustive le fonctionnement et l'utilisation de chaque élément
Python
! :bj:

Il te suffit dans les menus précédents de sélectionner l'élément mais de ne pas valider, et à la place de taper
Help
.

Bref, de gros manques d'une part, mais également des avancées inédites hautement intéressantes d'autre part.




Python : Console et clavier

Go to top

La touche
Num
permet donc d'accéder à la vue de la console. La console à sa première ouverture importe automatiquement l'ensemble des scripts associés à l'application
Python
.

Par la suite elle te proposera de rafraîchir lors de tes aller-retours entre la console et l'éditeur, certes en Anglais alors que nous avons réglé la machine en Français.

C'était d'ailleurs lourd puisque ce rafraîchissement t'était proposé de façon systématique, même si tu étais allé consulter la vue éditeur sans rien modifier, mais c'est corrigé sur cette dernière bêta.

Attention toutefois, contrairement à toute la concurrence ces importations automatiques utilisent la commande import ... et non pas from ... import *.

Tu devras donc systématiquement préfixer à la main tous tes appels aux éléments d'un script du nom du script en question.

Sinon, il te faudra saisir toi-même la commande from ... import * adéquate.

C'est d'autant plus dommage que, rappelons-le, il n'y a apparemment rien au menu permettant de saisir rapidement des commandes
import
.


Tu saisis donc sur la ligne en bas d'écran, et tu as l'historique défilable des sorties au-dessus.

Nous avons toujours le menu
Cmds
en bas d'écran, mais plus le menu
Tmplt
pour saisir les blocs de commandes.

Cela peut s'expliquer par le fait que la console
Python
de la
HP Prime
ne gère pas les saisies sur plusieurs lignes. Peu de solutions
Python
concurrentes les supportent à ce jour, juste les
TI-83 Premium CE
,
TI-84 Plus CE
,
TI-Nspire CX II
et le programme pour les
TI-Nspire
.

Commençons par toute une série de grosses améliorations.
Sur la bêta précédente il y avait plusieurs façons de semi-bloquer ta calculatrice depuis la console
Python
. La calculatrice restait alors coincée sur la vue console de l'application
Python
, sans accepter de saisie, sans permettre de changer de vue, et sans permettre de changer d'application.

La calculatrice n'était pas complètement figée, les menus de bas d'écran continuaient à réagir bien que ineffectifs, et la calculatrice pouvait encore être éteinte et rallumée.

Mais il n'empêche qu'elle n'en restait pas moins inutilisable et que seul le bouton
Reset
au dos te la décoinçait.

Depuis la console, il te fallait donc éviter :
  • de taper
    Esc
    sur une ligne de saisie vide
  • de retaper
    Num
  • de taper
    Plot
  • de taper
    View
    pour aller dans
    Messages
Ces défauts majeurs semblent avoir tous été corrigés.

Pour rester sur les défauts majeurs, il n'y avait sur la bêta précédente aucun moyen d'interrompre un script
Python
qui pour une raison ou une autre prenait trop de temps ou ne se terminait pas.
Ce point a également été pris en compte, la touche
On
suffira dans ces cas-là désormais, plus besoin du bouton
Reset
.

Sur la dernière bêta présentée, la fonction
input()
ne marchait pas. Elle te faisait bien effectuer la saisie demandée sur la ligne dédiée, mais renvoyait systématiquement une chaîne vide peu importe ce que tu tapais.
C'est maintenant corrigé, même si on peut regretter l'absence de retour à la ligne dans l'historique de la console.

Ligne de saisie et historique sont donc ici deux zones bien distinctes. Ce qui était très gênant dans la bêta précédente, c'est qu'il n'y avait aucun moyen de donner le
focus
à l'historique. Tu ne pouvais donc pas :
  • remonter dans l'historique avec
    comme tu en avais peut-être l'habitude, tu devais utiliser l'écran tactile
  • faire passer le curseur de texte dans l'historique
  • et par conséquent reprendre une saisie précédente, un résultat ou une partie d'un affichage ; tu ne pouvais rien sélectionner et donc rien copier-coller
C'était hautement embêtant, à la moindre erreur tu devais reprendre intégralement la saisie, et systématiquement accompagner chacune de tes saisies d'une affectation si tu souhaitais pouvoir en réutiliser le résultat.
C'est corrigé ici encore. Tu peux maintenant cliquer dans l'historique pour en sélectionner une ligne, passer alors de ligne en ligne avec les flèches, et copier la ligne de ton choix vers le champ de saisie à l'aide du menu de bas d'écran.

Autre gros problème de la bêta précédente, une bonne moitié du clavier ainsi que divers menus usuels étaient inutilisables dans le contexte de l'application
Python
. Les touches et menus avec des symboles ou fonctions mathématiques une fois actionnés effectuaient des saisies en langage
HPPPL
. Non traduites en langage
Python
, ces saisies déclenchaient la plupart du temps des erreurs alors que le module
math
était pourtant bien importé, ou alors retournaient de mauvais résultats.

L'ensemble des touches avec fonctions et symboles mathématiques au clavier est maintenant fonctionnel dans l'éditeur et la console
Python
.

L'interface de saisie de nombres en base hexadécimale, octale ou binaire accessible via
Shift
-
, a été elle aussi corrigée en ce sens, les nombres une fois validés étant bien saisis en syntaxe
Python
.
La plupart des opérateurs de comparaison et de logique accessibles via
Shift
6
sont maintenant saisis correctement dans le contexte
Python
.

Il ne reste plus que 3 opérateurs de la boîte
Shift
6
à dysfonctionner
  • le non logique
    NOT
    , bizarrement remplacé dans le contexte
    Python
    par
    !
    ce qui n'est pas correct en
    Python
    ; il faut remplacer par
    not
  • le ou exclusif
    xor
    , à remplacer par
    ^
    dans le contexte
    Python
  • la fonction
    EQ()
    à remplacer par
    ==
    en
    Python
    ou bien à supprimer si ça fait doublon

Un menu qui par contre semble avoir été oublié dans ces nombreuses traductions, c'est le menu des unités Mathématiques accessible via
Shift
□/□
.

Dans la version bêta précédente, la console
Python
semblait faire partie des choses qui avaient été le moins bien travaillées.

Avec cette nouvelle version, le retard semble clairement avoir été rattrapé ! :bj:




HPPPL / Python / CAS : Editeur programmes hybride projets HPPPL / Python / CAS et nouveautés HPPPL

Go to top

L'éditeur de programmes subit avec ces versions bêta une formidable révolution.

Déjà de façon évidente nous avons désormais des numéros de lignes affichés. De façon complémentaire le nouveau menu de bas d'écran
Plus
permet d'aller directement au numéro de ligne de son choix.

Mais ce décalage de l'affichage déclenchait un petit
bug
dans la bêta précédente, le curseur de texte pouvait sortir de l'écran par la droite selon une petite marge sans déclencher de défilement, assez gênant.
C'est maintenant corrigé.


Avais-tu tendance à te perdre dans tes lignes de code ? Ce même menu te permet également de définir jusqu'à 10 signets, c'est-à-dire des endroits de ton code où tu pourras alors aller rapidement.

Tu peux également procéder sans menu directement avec les raccourcis clavier :
On
Shift
avec un numéro de 0 à 9 pour placer un signet à la position courante. Pour te rendre ensuite instantanément au signet en question, c'est
On
avec le numéro du signet concerné.

La
HP Prime
bénéficiait déjà d'une fonctionnalité absolument fantastique pour la programmation et toujours exclusive à ce jour, un débogueur permettant de dérouler l'exécution de ses programmes pas à pas tout en consultant l'état des variables.

Tu pouvais toi-même préciser ta sélection de variables locales ou globales à surveiller en cours de débogage.

Mais problème, la calculatrice plantait salement si jamais tu avais le malheur de saisir un nom de variable locale inexistante.
C'est maintenant corrigé.



Venons-en à la révolution. L'éditeur de programmes gérait par défaut le langage
HPPPL
(HP Prime Programming Language)
.

Mais il permettait également de gérer le langage
Xcas
. Les blocs en langage
Xcas
étaient à encadrer de balises #cas et #end.
La langage
Xcas
pouvait utiliser 2 syntaxes : la syntaxe historique de
Xcas
ainsi qu'une syntaxe proche du
Python
.

Et bien voilà, en plus des 2 langages précédents, tu peux désormais inclure des blocs en
Python
, à délimiter ici par les balises #python et #end.

Oui oui, l'éditeur de programmes historique de la
HP Prime
gère désormais 3 langages,
HPPPL
,
Xcas
et
Python
. Un même éditeur pour les coder tous, quand sur nombre de solutions concurrentes tu dois te taper un éditeur différent par langage sans aucun mélange possible !

Tu peux alors appeler le bloc
Python
comme si c'était un script, en spécifiant son nom à une fonction
PYTHON()
, ainsi que ses paramètres éventuels. Le bloc
Python
récupère alors les valeurs des paramètres éventuels dans la liste sys.argv :
Code: Select all
#PYTHON name
import sys
print("Python says "+sys.argv[0])
#end

Export ppl(a)
Begin
  PYTHON(name, a);
End;

Mais tu peux également écrire différemment le bloc
Python
en question, afin de pouvoir l'appeler comme une fonction, et te passer alors de l'appel à la fonction
PYTHON()
:
Code: Select all
#PYTHON EXPORT name(param)
import sys
print("Python says "+sys.argv[0])
#end

Export ppl(a)
Begin
  name(a);
End;


La langage
HPPPL
disposait d'une très large bibliothèque de fonctions de tracé par pixels ou coordonnées. De quoi programmer de superbes interfaces pour tes programmes de sciences ou jeux.

Un petit manque, c'était dans le cadre du tracé de chaînes de caractères avec par exemple la fonction
TEXTOUT_P()
. Il n'y avait en effet pas de moyen simple de connaître l'espace occupé par le texte affiché
(largeur et hauteur)
, ce qui pouvait être embêtant :
  • pour bien positionner les autres éléments graphiques à tracer
  • pour donner un fond coloré à certains affichages de texte
Une estimation des bonnes dimensions n'était pas simple, surtout que la calculatrice gère pas moins de 7 tailles différentes de polices de caractères.

Voici donc enfin la solution pour programmer encore plus facilement tes interfaces graphiques, la fonction
TEXTSIZE(texte,taille_police)
.

Elle retourne en pixels les dimensions du rectangle occupé par l'affichage de la chaîne de caractères fournie selon la taille de police spécifiée
(de 1 pour la plus petite à 7 pour la plus grande, ou sinon 0 pour tout simplement la taille courante)
. De quoi positionner parfaitement tes affichages en un minimum de lignes ! :bj:
Code: Select all
Export demo(txt,fcol,bcol)
Begin
  X:=0;
  Y:=0;
  FOR F FROM 1 TO 7 DO
    L1:=TEXTSIZE(txt,F);
    TEXTOUT_P(txt,G0,X,0,F,fcol,L1[1],bcol);
    TEXTOUT_P(txt,G0,0,Y,F,fcol,L1[1],bcol);
    Y:=Y+L1[2];
    X:=X+L1[1];
  END;
  WAIT();
End;


En
Python
les fonctions peuvent être définies avec des valeurs par défaut pour les derniers arguments. Cela évite à l'utilisateur d'avoir à spécifier les derniers arguments lors de son appel de la fonction, pourvu que les valeurs par défaut correspondent bien à un cas fréquent.

Le langage
HPPPL
ne permet pour sa part pas de définir des fonctions avec des valeurs d'arguments par défaut.

Par contre, une nouveauté dans cette mise à jour, il est maintenant possible de définir plusieurs fonctions partageant le même nom.

Pratique pour l'utilisateur de ne plus avoir à retenir différents noms de fonction ayant le même rôle mais dans des contextes différents :
Code: Select all
EXPORT DIST(x1,y1,x2,y2):
  RETURN (x2-x1)^2+(y2-y1)^2
END;

EXPORT DIST(x1,y1,z1,x2,y2,z2):
  RETURN (x2-x1)^2+(y2-y1)^2+(z2-z1)^2
END;


Et surtout, cela permet de simuler des valeurs d'arguments par défaut. Il suffit de définir plusieurs fois le même nom de fonction avec des nombres d'arguments qui diffèrent, et c'est au code d'agir en conséquence :
Code: Select all
EXPORT POLY2(a,b,c)
BEGIN
LOCAL d,ex;
ex:="("+a+")*x^2"+"+("+b+")*x+"+c;
d:=b^2-4*a*c;
RETURN CONCAT({CAS.expr(ex)},(−b+{1,−1}*√(d))/(2*a));
END;

EXPORT POLY2(a,b)
BEGIN
  RETURN POLY2(a,b,0);
END;

EXPORT POLY2(a)
BEGIN
  RETURN POLY2(a,0,0);
END;


Peut-être que cela te choque de pouvoir ainsi définir plusieurs fois et différemment le même nom de fonction... ou pas.

Dans tous les cas tu as une alternative avec une autre formidable nouveauté, une fonction
HPPPL
peut désormais être définie pour accepter un nombre variable d'argument ! :bj:

Il suffit de préfixer le dernier argument de la fonction de points de suspension, et ce dernier recevra la liste de tous les arguments optionnels spécifiés au-delà des éventuels premiers arguments obligatoires.
Code: Select all
EXPORT POLY22(...l)
BEGIN
  LOCAL a,b,c,d,n,ex;
  {'a','b','c'}:={1,0,0};
  n:=SIZE(l);
  IF n>=1 THEN
    a:=l[1];
    IF n>=2 THEN
      b:=l[2];
      IF n>=3 THEN
        c:=l[3];
      END;
    END;
  END;
  ex:="("+a+")*x^2"+"+("+b+")*x+"+c;
  d:=b^2-4*a*c;
  RETURN CONCAT({CAS.expr(ex)},(−b+{1,−1}*√(d))/(2*a));
END;

Pour le moment il y a un maximum de 16 arguments au total, qu'ils soient obligatoires ou optionnels.

Précisons si tu lances un programme via l'interface de l'éditeur, le cas où sa fonction principale prend un nombre variable d'arguments est bien géré.

Toujours pour plus de libertés, pour rester sur les fonctions tu n'as plus besoin dans un programme
HPPPL
de placer leur déclaration de fonctions avant la première ligne les appelant.

Cela autorise également de nouvelles possibilités, comme des fonctions qui s'appellent mutuellement l'une l'autre :
Code: Select all
FUNC1(a)
BEGIN
  IF a==0 THEN RETURN 1; END;
  RETURN FUNC2(a-1);
END;

FUNC2(a)
BEGIN
  IF a==0 THEN RETURN 1; END;
  RETURN FUNC1(a-1);
END;


Tu peux maintenant déclarer et affecter des variables en tant que constantes, et même les exporter en tant que telles vers l'environnement
HPPPL
:
Code: Select all
CONST C1=6;
EXPORT CONST C2=7;


Les affichages non graphiques de tes programmes via la fonction
PRINT()
étaient pour leur part redirigés vers une sorte de console ici appelée terminal. Et bien grande nouveauté, il y a désormais une nouvelle fonction
PRINT2D()
pour afficher dans le terminal des lignes en écriture naturelle.

En pratique pour que la fonction
PRINT2D()
fonctionne correctement, il est nécessaire de bloquer l'évaluation/simplification des expressions que tu lui passes. C'est possible en les entourant d'un appel de fonction
quote()
, ou encore en les mettant entre guillemets simples.
Code: Select all
EXPORT test2d()
BEGIN
  PRINT("");
  PRINT("Hello 2D");
  PRINT2D(quote(5^2));
  PRINT2D('5^2');
  PRINT2D('√5');
  PRINT2D('√2022/19');
END;


Tu peux également afficher des expressions en écriture naturelle à la position de ton choix sur l'écran grâce aux fonctions
TEXTOUT_P()
et
TEXTOUT()
, en précisant le nouveau drapeau
"2D"
:
TEXTOUT_P('√2022/19', G0, 0, 60, {"2D"});
Il semble y avoir toujours le même bug sur cette dernière version bêta. En mode 2D donc, si l'on précise à
TEXTOUT_P()
une valeur strictement positive pour l'abscisse
x
, elle n'affiche rien...


Autre point, on pouvait inclure le caractère tabulation
'\t'
dans les chaînes de caractères, mais les fonctions d'affichage
(PRINT, PRINT2D, TEXTOUT, TEXTOUT_P)
le remplaçaient par un rectangle peu esthétique.

C'est maintenant amélioré, ces mêmes fonctions remplacent à l'affichage le caractère tabulation par un espace.

Autre nouveauté, il t'est maintenant possible de déclencher via la fonction
READLINE()
une saisie qui sera réalisée directement dans le terminal. L'utilisateur bénéficiera ainsi lors de sa saisie de tout ce qui aura pu y être affiché auparavant.

Nous avons donc vu plus haut qu'il était possible d'inclure des blocs de code
Python
dans tes programmes
HPPPL
.

C'est en fait l'arbre qui cache la forêt ; cela va beaucoup plus loin que ça. L'éditeur de programmes devient désormais un véritable éditeur de projets.

Nouveau menu de bas d'écran
Plus
qui nous révèle plein de choses. Les fichiers
.hpprgm
peuvent maintenant comporter plusieurs onglets dont tu définis le nom et le type à la création, et entre lesquels tu peux basculer par la suite. Les types d'onglets proposés sont :
  • PPL Program
    pour donc du code
    HPPPL
    comportant éventuellement des blocs en langage
    Python
    ou
    Xcas
  • Cas Program
    pour donc du code
    Xcas
  • Python Program
    pour du code
    Python
  • Binary asset
    pour des données brutes
  • Jpg image
    pour une image
    JPEG
  • Png image
    pour une image
    PNG
Données brutes et images peuvent ensuite être lues / écrites via la fonction
Resource(nom_onglet)
.

Par exemple pour charger une image
Jpg/Png
ainsi dans le calque
G1
, c'est G1:= Resource("nom_onglet").

L'éditeur de programme du logiciel de connectivité reproduit les mêmes nouveautés.

L'appel de code
Python
est similaire à ce qui a été vu plus haut avec la commande
PYTHON()
, peu importe que le code soit maintenant sur un onglet distinct.

Il t'est possible de mettre un programme en lecture seule, le protégeant ainsi contre des modifications accidentelles.

Et accessoirement, il t'est désormais possible de crypter tes programmes/projets dans ce même menu
Plus
, afin de rendre leur code source illisible. Attention l'opération est définitive, aussi te créera-t-elle une copie cryptée du programme courant, copie que tu pourras donc diffuser tout en conservant l'original modifiable.




Python : Nombres flottants et performances - transfert de scripts

Go to top

Poursuivons l'étude du moteur de calcul numérique du
Micropython
en question, avec cette fois-ci les nombres en virgule flottante dits flottants.

Ce type de donnée représente les nombres non entiers sous la forme
$mathjax$M\times 2^{E-E_{min}}$mathjax$
, avec :
  • M
    , un nombre entier relatif dit mantisse
  • Emin
    , nombre entier négatif indique l'exposant minimal pouvant être codé
  • E
    , nombre entier naturel codant l'exposant

Nous pourrions bien sûr saisir à la main le script ci-dessous, le transférer comme déjà vu entre balises #python et #end dans un programme
HPPPL
. Mais nous allons plutôt te montrer cette fois-ci comment envoyer directement un fichier
.py
à l'application
Python
, car oui la machine les gère.

Pour cela, dans le logiciel de connectivité, il faut rajouter le ou les scripts
Python
souhaités aux fichiers de l'application
Python
, via un appel au menu contextuel
(clic droit)
sur le dossier en question.
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]


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écision du
Python
(64 bits)
, un bon choix pour le contexte scientifique du lycée.

Normalement, toutes les implémentations utilisant ce standard sont censées donner les mêmes résultats, ce qui est un gros avantage pour développer du code
Python
multi-plateformes. Sur la bêta précédente, bizarrement, ce n'était pas toujours le cas avec la
HP Prime G2
. Par exemple le calcul round(3/7,6) donnait :
  • 0,428571 sur
    HP Prime G1
    ainsi que toutes les calculatrices
    Python
    concurrentes évoquées jusqu'à présent
  • 0,4285709999999999 sur la seule
    HP Prime G2
C'est maintenant corrigé.


Puisque tout-le-monde est à égalité là-dessus, voyons donc les performances du
Python
dans le contexte des calculs flottants sur
HP Prime
.

Nous utiliserons pour cela le script suivant, développé et utilisé pour le , 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]


Pas de module
time
ici, nous allons lancer une série de 15 seuil(0.008) via une boucle, chronométrer à la main et effectuer la moyenne.

Donc en moyenne pour un appel de seuil(0.008) :
  • la
    HP Prime G1
    termine en seulement
    0,258s
    , presque aussi vite qu'une
    TI-Nspire CX II
    ! :bj:
  • la
    HP Prime G2
    répond plus vite que tu ne relâches la touche,
    0,087s
    ! :#tritop#:
Les
HP Prime
sont vraiment extraordinaires en calcul flottant
Python
et la
HP Prime G2
écrase même toute concurrence de sa toute puissance, même en dopant cette dernière à l'
overclocking
! :#tritop#:

À la fois parmi les solutions
Python
officielles et les solutions
Python
compatibles avec le mode examen, la
HP Prime G2
est clairement la plus puissante que ce soit en calcul entier ou en calcul flottant, et de loin, félicitations ! :bj:

  1. 0,087s
    :
    HP Prime G2
    (32 bits : Cortex-A7/ARMv7 @
    528MHz
    Python)
  2. 0,258s
    :
    HP Prime G1
    (32 bits : ARM9/ARMv5 @
    400MHz
    Python)
  3. 0,297s
    :
    TI-Nspire CX II
    (32 bits : ARM9/ARMv5 @
    396MHz
    )
  4. 0,376s
    :
    HP Prime G2
    (32 bits : Cortex-A7/ARMv7 @
    528MHz
    CAS)
  5. 0,498s
    :
    NumWorks N0110
    (32 bits : Cortex-M7/ARMv7 @
    216MHz
    )
  6. 0,785s
    :
    NumWorks N0100
    (32 bits : Cortex-M4/ARMv7 @
    100MHz
    )
  7. 1,61s
    :
    HP Prime G1
    (32 bits : ARM9/ARMv5 @
    400MHz
    CAS)
  8. 3,27s
    :
    Casio Graph 90+E
    (32 bits : SH4 @
    117,96MHz
    )
  9. 3,93s
    :
    TI-83 Premium CE Edition Python
    (8 + 32 bits : eZ80 @
    48MHz
    + Cortex-M0+/ARMv6 @
    48MHz
    )
  10. 9,21s
    :
    Casio Graph 35+E II
    (32 bits : SH4 @
    58,98MHz
    )
  1. 0,087s
    :
    HP Prime G2
    (32 bits : Cortex-A7/ARMv7 @
    528MHz
    Python)
  2. 0,258s
    :
    HP Prime G1
    (32 bits : ARM9/ARMv5 @
    400MHz
    Python)
  3. 0,297s
    :
    TI-Nspire CX II
    (32 bits : ARM9/ARMv5 @
    396MHz
    )
  4. 0,376s
    :
    HP Prime G2
    (32 bits : Cortex-A7/ARMv7 @
    528MHz
    CAS)
  5. 0,609s
    :
    TI-Nspire CX
    (révisions A-V)
    (32 bits : ARM9/ARMv5 @
    132MHz
    - Ndless + KhiCAS Micropython)
  6. 0,498s
    :
    NumWorks N0110
    (32 bits : Cortex-M7/ARMv7 @
    216MHz
    )
  7. 0,544s
    :
    NumWorks N0110
    (Omega + KhiCAS Micropython)
  8. 0,785s
    :
    NumWorks N0100
    (32 bits : Cortex-M4/ARMv7 @
    100MHz
    )
  9. 0,868s
    :
    TI-Nspire CX CR4+
    (révisions W+)
    (32 bits : ARM9/ARMv5 @
    156MHz
    - Ndless + KhiCAS Micropython)
  10. 1,61s
    :
    HP Prime G1
    (32 bits : ARM9/ARMv5 @
    400MHz
    CAS)
  11. 3,27s
    :
    Casio Graph 90+E
    (32 bits : SH4 @
    117,96MHz
    )
  12. 3,93s
    :
    TI-83 Premium CE Edition Python
    (8 + 32 bits : eZ80 @
    48MHz
    + Cortex-M0+/ARMv6 @
    48MHz
    )
  13. 5,45s
    :
    TI-Nspire CX
    (révisions A-V)
    (32 bits : ARM9/ARMv5 @
    132MHz
    - Ndless + KhiCAS compatibilité Python)
  14. 6,69s
    :
    NumWorks N0110
    (Omega + KhiCAS compatibilité Python)
  15. 7,63s
    :
    TI-Nspire CX CR4+
    (révisions W+)
    (32 bits : ARM9/ARMv5 @
    156MHz
    - Ndless + KhiCAS compatibilité Python
  16. 9,21s
    :
    Casio Graph 35+E II
    (32 bits : SH4 @
    58,98MHz
    )
  1. 0,087s
    :
    HP Prime G2
    (32 bits : Cortex-A7/ARMv7 @
    528MHz
    Python)
  2. 0,258s
    :
    HP Prime G1
    (32 bits : ARM9/ARMv5 @
    400MHz
    Python)
  3. 0,297s
    :
    TI-Nspire CX II
    (32 bits : ARM9/ARMv5 @
    396MHz
    )
  4. 0,376s
    :
    HP Prime G2
    (32 bits : Cortex-A7/ARMv7 @
    528MHz
    CAS)
  5. 0,396s
    :
    TI-Nspire CX
    (révisions A-V)
    (32 bits : ARM9/ARMv5 @132MHz
    overclocké
    @
    222MHz
    Nover - Ndless + KhiCAS Micropython)
  6. 0,498s
    :
    NumWorks N0110
    (32 bits : Cortex-M7/ARMv7 @
    216MHz
    )
  7. 0,544s
    :
    NumWorks N0110
    (Omega + KhiCAS Micropython)
  8. 0,65s
    :
    TI-Nspire CX CR4+
    (révisions W+)
    (32 bits : ARM9/ARMv5 @156MHz
    overclocké
    @
    216MHz
    Nover - Ndless + KhiCAS Micropython)
  9. 0,785s
    :
    NumWorks N0100
    (32 bits : Cortex-M4/ARMv7 @
    100MHz
    )
  10. 1,61s
    :
    HP Prime G1
    (32 bits : ARM9/ARMv5 @
    400MHz
    CAS)
  11. 3,27s
    :
    Casio Graph 90+E
    (32 bits : SH4 @
    117,96MHz
    )
  12. 3,93s
    :
    TI-83 Premium CE Edition Python
    (8 + 32 bits : eZ80 @
    48MHz
    + Cortex-M0+/ARMv6 @
    48MHz
    )
  13. 4,13s
    :
    TI-Nspire CX
    (révisions A-V)
    (32 bits : ARM9/ARMv5 @132MHz
    overclocké
    @
    222MHz
    Nover - Ndless + KhiCAS compatibilité Python)
  14. 6,69s
    :
    NumWorks N0110
    (Omega + KhiCAS compatibilité Python)
  15. 7,19s
    :
    TI-Nspire CX CR4+
    (révisions W+)
    (32 bits : ARM9/ARMv5 @156MHz
    overclocké
    @
    216MHz
    Nover - Ndless + KhiCAS compatibilité Python)
  16. 9,21s
    :
    Casio Graph 35+E II
    (32 bits : SH4 @
    58,98MHz
    )
  1. 0,087s
    :
    HP Prime G2
    (32 bits : Cortex-A7/ARMv7 @
    528MHz
    Python)
  2. 0,258s
    :
    HP Prime G1
    (32 bits : ARM9/ARMv5 @
    400MHz
    Python)
  3. 0,297s
    :
    TI-Nspire CX II
    (32 bits : ARM9/ARMv5 @
    396MHz
    )
  4. 0,376s
    :
    HP Prime G2
    (32 bits : Cortex-A7/ARMv7 @
    528MHz
    CAS)
  5. 0,498s
    :
    NumWorks N0110
    (32 bits : Cortex-M7/ARMv7 @
    216MHz
    )
  6. 0,785s
    :
    NumWorks N0100
    (32 bits : Cortex-M4/ARMv7 @
    100MHz
    )
  7. 1,61s
    :
    HP Prime G1
    (32 bits : ARM9/ARMv5 @
    400MHz
    CAS)
  8. 3,27s
    :
    Casio Graph 90+E / fx-CG50
    (32 bits : SH4 @
    117,96MHz
    )
  9. 3,73s
    :
    TI-83 Premium CE
    +
    TI-Python
    (8 + 32 bits : eZ80 @
    48MHz
    + Cortex-M0+/ARMv6 @
    48MHz
    )
  10. 3,93s
    :
    TI-83 Premium CE Edition Python / TI-84 Plus CE Python Edition
    (8 + 32 bits : eZ80 @
    48MHz
    + Cortex-M0+/ARMv6 @
    48MHz
    )
  11. 9,21s
    :
    Casio Graph 35+E II / fx-9750/9860GIII
    (32 bits : SH4 @
    58,98MHz
    )
  1. 0,025s
    :
    TI-Nspire CX II
    (32 bits : ARM9/ARMv5 @
    396MHz
    - Ndless + KhiCAS Micropython)
  2. 0,087s
    :
    HP Prime G2
    (32 bits : Cortex-A7/ARMv7 @
    528MHz
    Python)
  3. 0,232s
    :
    TI-Nspire CX II
    (32 bits : ARM9/ARMv5 @
    396MHz
    - Ndless + MicroPython)
  4. 0,258s
    :
    HP Prime G1
    (32 bits : ARM9/ARMv5 @
    400MHz
    Python)
  5. 0,297s
    :
    TI-Nspire CX II
    (32 bits : ARM9/ARMv5 @
    396MHz
    )
  6. 0,376s
    :
    HP Prime G2
    (32 bits : Cortex-A7/ARMv7 @
    528MHz
    CAS)
  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,544s
    :
    NumWorks N0110
    (Omega + KhiCAS Micropython)
  11. 0,609s
    :
    TI-Nspire CX
    (révisions A-V)
    (32 bits : ARM9/ARMv5 @
    132MHz
    - Ndless + KhiCAS Micropython)
  12. 0,68s
    :
    TI-Nspire CX CR4+
    (révisions W+)
    (32 bits : ARM9/ARMv5 @
    156MHz
    - Ndless + MicroPython)
  13. 0,785s
    :
    NumWorks N0100
    (32 bits : Cortex-M4/ARMv7 @
    100MHz
    )
  14. 0,868s
    :
    TI-Nspire CX CR4+
    (révisions W+)
    (32 bits : ARM9/ARMv5 @
    156MHz
    - Ndless + KhiCAS Micropython)
  15. 1,61s
    :
    HP Prime G1
    (32 bits : ARM9/ARMv5 @
    400MHz
    CAS)
  16. 1,909s
    :
    TI-Nspire CX II
    (32 bits : ARM9/ARMv5 @
    396MHz
    - Ndless + KhiCAS compatibilité Python)
  17. 3,27s
    :
    Casio Graph 90+E / fx-CG50
    (32 bits : SH4 @
    117,96MHz
    )
  18. 3,73s
    :
    TI-83 Premium CE
    +
    TI-Python
    (8 + 32 bits : eZ80 @
    48MHz
    + Cortex-M0+/ARMv6 @
    48MHz
    )
  19. 3,9s
    :
    Casio Graph 35+E II / fx-9750/9860GIII
    (32 bits : SH4 @
    58,98
    - CasioPython)
  20. 3,93s
    :
    TI-83 Premium CE Edition Python / TI-84 Plus CE Python Edition
    (8 + 32 bits : eZ80 @
    48MHz
    + Cortex-M0+/ARMv6 @
    48MHz
    )
  21. 4s
    :
    Casio Graph 35/75+E / 35/75/95 / fx-9750/9860GII
    (32 bits : SH4 @
    29,49MHz
    - CasioPython)
  22. 4,4s
    :
    TI-83 Premium CE
    +
    TI-Python
    (8 + 32 bits : eZ80 @
    48MHz
    + Cortex-M0+/ARMv6 @
    48MHz
    CircuitPython)
  23. 5,29s
    :
    Casio Graph 35/75/85/95 / fx-9750/9860GII / fx-9860G
    (32 bits : SH3 @
    29,49MHz
    - CasioPython)
  24. 5,45s
    :
    TI-Nspire CX
    (révisions A-V)
    (32 bits : ARM9/ARMv5 @
    132MHz
    - Ndless + KhiCAS compatibilité Python)
  25. 5,48s
    :
    Casio Graph 90+E / fx-CG50
    (32 bits : SH4 @
    117,96MHz
    - KhiCAS)
  26. 6,69s
    :
    NumWorks N0110
    (Omega + KhiCAS compatibilité Python)
  27. 9,21s
    :
    Casio Graph 35+E II / fx-9750/9860GIII
    (32 bits : SH4 @
    58,98MHz
    )
  28. 13,93s
    :
    Casio Graph 35+E II / fx-9750/9860GIII
    (32 bits : SH4 @
    58,98MHz
    - KhiCAS)
  29. 15,05s
    :
    Casio fx-CG10/20
    (32 bits : SH4 @
    58,98MHz
    - KhiCAS)
  30. 7,63s
    :
    TI-Nspire CX CR4+
    (révisions W+)
    (32 bits : ARM9/ARMv5 @
    156MHz
    - Ndless + KhiCAS compatibilité Python)
  1. 0,022s
    :
    TI-Nspire CX II
    (32 bits : ARM9/ARMv5 @396MHz
    overclocké
    @
    468MHz
    NoverII - Ndless + KhiCAS Micropython)
  2. 0,087s
    :
    HP Prime G2
    (32 bits : Cortex-A7/ARMv7 @
    528MHz
    Python)
  3. 0,142s
    :
    TI-Nspire CX II
    (32 bits : ARM9/ARMv5 @396MHz
    overclocké
    @
    468MHz
    NoverII - Ndless + MicroPython)
  4. 0,257s
    :
    TI-Nspire CX II
    (32 bits : ARM9/ARMv5 @396MHz
    overclocké
    @
    468MHz
    NoverII)
  5. 0,258s
    :
    HP Prime G1
    (32 bits : ARM9/ARMv5 @
    400MHz
    Python)
  6. 0,27s
    :
    TI-Nspire CX
    (révisions A-V)
    (32 bits : ARM9/ARMv5 @132MHz
    overclocké
    @
    222MHz
    Nover - Ndless + MicroPython)
  7. 0,376s
    :
    HP Prime G2
    (32 bits : Cortex-A7/ARMv7 @
    528MHz
    CAS)
  8. 0,38s
    :
    TI-Nspire
    (32 bits : ARM9/ARMv5
    overclocké
    @120MHz @
    150MHz
    Nover - Ndless + MicroPython)
  9. 0,396s
    :
    TI-Nspire CX
    (révisions A-V)
    (32 bits : ARM9/ARMv5 @132MHz
    overclocké
    @
    222MHz
    Nover - Ndless + KhiCAS Micropython)
  10. 0,498s
    :
    NumWorks N0110
    (32 bits : Cortex-M7/ARMv7 @
    216MHz
    )
  11. 0,53s
    :
    TI-Nspire CX CR4+
    (révisions W+)
    (32 bits : ARM9/ARMv5 @156MHz
    overclocké
    @
    216MHz
    Nover - Ndless + MicroPython)
  12. 0,544s
    :
    NumWorks N0110
    (Omega + KhiCAS Micropython)
  13. 0,59s
    :
    Casio Graph 35/75+E / 35/75/95 / fx-9750/9860GII
    (32 bits : SH4 @29,49MHz
    overclocké
    @
    267,78MHz
    Ftune2 - CasioPython)
  14. 0,65s
    :
    TI-Nspire CX CR4+
    (révisions W+)
    (32 bits : ARM9/ARMv5 @156MHz
    overclocké
    @
    216MHz
    Nover - Ndless + KhiCAS Micropython)
  15. 0,785s
    :
    NumWorks N0100
    (32 bits : Cortex-M4/ARMv7 @
    100MHz
    )
  16. 0,79s
    :
    Casio Graph 35+E II / fx-9750/9860GIII
    (32 bits : SH4 @58,98MHz
    overclocké
    @
    274,91MHz
    Ftune3 - CasioPython)
  17. 1,589s
    :
    TI-Nspire CX II
    (32 bits : ARM9/ARMv5 @396MHz
    overclocké
    @
    468MHz
    NoverII - Ndless + KhiCAS compatibilité Python)
  18. 1,61s
    :
    HP Prime G1
    (32 bits : ARM9/ARMv5 @
    400MHz
    CAS)
  19. 1,86s
    :
    Casio Graph 35+E II / fx-9750/9860GIII
    (32 bits : SH4 @58,98MHz
    overclocké
    @
    274,91MHz
    Ftune3)
  20. 1,876s
    :
    Casio Graph 35/75/85/95 / fx-9750/9860GII / fx-9860G
    (32 bits : SH3 @29,49MHz
    overclocké
    @
    117,96MHz
    Ftune - CasioPython)
  21. 2,15s
    :
    Casio Graph 90+E / fx-CG50
    (32 bits : SH4 @117,96MHz
    overclocké
    @
    270,77MHz
    Ptune3)
  22. 2,96s
    :
    Casio Graph 35+E II / fx-9750/9860GIII
    (32 bits : SH4 @58,98MHz
    overclocké
    @
    274,91MHz
    Ftune3 - KhiCAS)
  23. 3,65s
    :
    Casio Graph 90+E / fx-CG50
    (32 bits : SH4 @117,96MHz
    overclocké
    @
    270,77MHz
    Ptune3 - KhiCAS)
  24. 3,718s
    :
    Casio fx-CG10/20
    (32 bits : SH4 @58,98MHz
    overclocké
    @
    267,78MHz
    Ptune2 - KhiCAS)
  25. 3,73s
    :
    TI-83 Premium CE
    +
    TI-Python
    (8 + 32 bits : eZ80 @
    48MHz
    + Cortex-M0+/ARMv6 @
    48MHz
    )
  26. 3,93s
    :
    TI-83 Premium CE Edition Python / TI-84 Plus CE Python Edition
    (8 + 32 bits : eZ80 @
    48MHz
    + Cortex-M0+/ARMv6 @
    48MHz
    )
  27. 4,13s
    :
    TI-Nspire CX
    (révisions A-V)
    (32 bits : ARM9/ARMv5 @132MHz
    overclocké
    @
    222MHz
    Nover - Ndless + KhiCAS compatibilité Python)
  28. 4,4s
    :
    TI-83 Premium CE
    +
    TI-Python
    (8 + 32 bits : eZ80 @
    48MHz
    + Cortex-M0+/ARMv6 @
    48MHz
    CircuitPython)
  29. 6,69s
    :
    NumWorks N0110
    (Omega + KhiCAS compatibilité Python)
  30. 7,19s
    :
    TI-Nspire CX CR4+
    (révisions W+)
    (32 bits : ARM9/ARMv5 @156MHz
    overclocké
    @
    216MHz
    Nover - Ndless + KhiCAS compatibilité Python)




Python : Mémoire tas/heap - import gc

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
(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 d'enfin découvrir la tant attendue taille de
heap
Python
HP Prime
:
Code: Select all
import gc
a, f = gc.mem_alloc(), gc.mem_free()
(a, f, a + f)

Nous disposons donc ici d'un
heap
d'une capacité impressionnante, parmi les plus grands actuellement,
1,025 Mo
aussi bien sur
HP Prime G1
que
HP Prime G2
, de quoi a priori te lancer dans des projets
Python
très ambitieux ! :#tritop#:
Plus précisément nous avons ici
1,022 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, 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
HP Prime
une capacité
heap
de
1,025 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
393,486 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
.

Pour le moment, dans le contexte de la
HP Prime
la capacité
heap
Python
serait bien décevante.

Autant sur
HP Prime G1
avec seulement
32 Mio
de
SDRAM
sollicités par bien d'autres choses, on pouvait comprendre de se modérer sur le
heap
Python
...

Mais la
HP Prime G2
dispose d'une capacité
SDRAM
de
256 Mio
écrasant littéralement toute concurrence. Nous attendions ici bien mieux que cela, de quoi se lancer dans des projets
Python
ambitieux...


Mais ne nous avouons pas encore vaincus.

Certes l'application
Python
ne se lance donc qu'avec
1,025 Mo
de
heap
, mais nous avons vu plus haut qu'il était possible 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 capacité
heap
maximale que l'on peut allouer dépend de la mémoire
RAM
disponible, sur laquelle l'écran mémoire accessible via
Shift
🧰
donne une indication.

La
HP Prime G1
dispose de
32 Mio
de
SDRAM
, et en gros sur une calculatrice vide ne contenant que le script de test on peut spécifier jusqu'à un peu plus de 16 Mo, au-delà le bloc
Python
n'est tout simplement pas exécuté. Histoire d'avoir une marge de sécurité puisque cette mémoire libre sera variable, retenons
16 Mo
pour la suite.

En pratique la capacité
heap
reportée par le module
gc
est légèrement inférieure, dans les
15,6 Mo
.

La
HP Prime G2
dispose pour sa part de
256 Mio
de
SDRAM
. De même sur une calculatrice vide ne contenant que le script de test, on peut spécifier jusqu'à 258 Mo et quelques, restons-en à
258 Mo
(non non pas d'erreur ça rentre, puisque 256 Mio ≈ 268,5 Mo)
.

En pratique la capacité
heap
reportée ici par le module
gc
est d'environ
252,1 Mo
.

Encore plus simple que nous n'avions pas remarqué la dernière fois, l'application
Python
dispose de réglages accessibles via
Shift
Plot
.

On peut y spécifier le
heap
, avec le gros avantage d'avoir ici sur le même écran une indication de la mémoire disponible.

Voilà qui change complètement la façon de voir les choses, les capacités
heap
Python
des
HP Prime
sont littéralement en orbite et rendent toute concurrence insignifiante ! :#tritop#:

  1. 252,1 Mo
    :
    HP Prime G2
  2. 15,6 Mo
    :
    HP Prime G1
  3. 2,068 Mo
    :
    TI-Nspire CX II
  4. 1,033 Mo
    :
    Casio Graph 90+E
  5. 101,262 Ko
    :
    Casio Graph 35+E II
  6. 33,545 Ko
    :
    NumWorks
  7. 18,354 Ko
    :
    TI-83 Premium CE Edition Python
  1. 252,1 Mo
    :
    HP Prime G2
  2. 15,6 Mo
    :
    HP Prime G1
  3. 4,100 Mo
    :
    TI-Nspire CX
  4. 2,068 Mo
    :
    TI-Nspire CX II
  5. 1,033 Mo
    :
    Casio Graph 90+E
  6. 101,262 Ko
    :
    Casio Graph 35+E II
  7. 64,954 Ko
    :
    NumWorks
    (firmware Omega + appli KhiCAS)
  8. 33,545 Ko
    :
    NumWorks
  9. 18,354 Ko
    :
    TI-83 Premium CE Edition Python
  1. 252,1 Mo
    :
    HP Prime G2
  2. 15,6 Mo
    :
    HP Prime G1
  3. 2,068 Mo
    :
    TI-Nspire CX II
  4. 1,033 Mo
    :
    Casio Graph 90+E / fx-CG50
  5. 101,262 Ko
    :
    Casio Graph 35+E II / fx-9750/9860GIII
  6. 33,545 Ko
    :
    NumWorks
  7. 20,839 Ko
    :
    TI-83 Premium CE + TI-Python
  8. 18,354 Ko
    :
    TI-83 Premium CE Edition Python / TI-84 Plus CE Python Edition
  1. 252,1 Mo
    :
    HP Prime G2
  2. 15,6 Mo
    :
    HP Prime G1
  3. 4,100 Mo
    :
    TI-Nspire CX / CX II
  4. 2,068 Mo
    :
    TI-Nspire CX II
  5. 2,050 Mo
    :
    TI-Nspire
  6. 1,033 Mo
    :
    Casio Graph 90+E / fx-CG50
  7. 258,766 Ko
    :
    Casio Graph 35/75+E / 35/75/95 / fx-9750/9860GII
    (SH4 - appli CasioPython)
  8. 101,262 Ko
    :
    Casio Graph 35+E II / fx-9750/9860GIII
  9. 64,954 Ko
    :
    NumWorks
    (firmware Omega + appli KhiCAS)
  10. 33,545 Ko
    :
    NumWorks
  11. 32,648 Ko
    :
    Casio Graph 35+E II / 35/75/85/95
    (SH3)
    / fx-9750/9860GIII / fx-9750/9860GII
    (SH3)
    / fx-9860G
    (appli CasioPython)
  12. 23,685 Ko
    :
    TI-83 Premium CE + TI-Python
  13. 20,839 Ko
    :
    TI-83 Premium CE + TI-Python
  14. 18,354 Ko
    :
    TI-83 Premium CE Edition Python / TI-84 Plus CE Python Edition




Python : 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
HP Prime
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
HP Prime G1
un maximum de
77
niveaux de récursion avant erreur, et même
99
niveaux sur
HP Prime G2
.

Mais nous avons vu plus haut qu'il était possible d'appeler un script ou une fonction
Python
depuis l'environnement
HPPPL
grâce à la fonction
PYTHON()
, et que cette dernière permettait de préciser la taille du
heap
alloué à cet appel. De façon similaire, elle permet également de préciser la taille du
stack
à utiliser : PYTHON({nom_python,taille_heap,taille_stack},...).

Réalisons ici encore de quoi saisir et tester des capacités :
Code: Select all
#python stacktest_python
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

print(test(compte_r))
#end

Export stacktest_ppl(v)
Begin
  PRINT("allocating stack: "+v);
  PRINT("");
  PYTHON({stacktest_python,#100000h,v});
End;


Sur
HP Prime G1
nous atteignons la limite initiale de 77 en allouant 40K de
stack
.

On peut atteindre
82
niveaux de récursion en passant à 43K de
stack
.

Mais c'est tout, augmenter davantage le
stack
ne change plus rien et effectivement on note un changement au niveau de l'exception reportée : on passe d'un
"maximum recursion depth exceeded"
à un
"pystack exhausted"
.

Ce n'est donc plus le même facteur limitant qui nous bloque, c'est maintenant autre chose qui interrompt la descente récursive.

Sur
HP Prime G2
il suffit de 26K de
stack
pour atteindre la limite de 99.

Mais le changement d'exception se produit alors immédiatement ; on ne peut pas aller au-delà.

Encore plus simple que nous n'avions pas remarqué la dernière fois, l'application
Python
dispose de réglages accessibles via
Shift
Plot
.

On peut y spécifier le
stack
à utiliser pour l'application. Et apparemment c'est la par défaut de
40 Ko
qui nous donne donc
77
récursions sur
HP Prime G1
et
99
sur
HP Prime G2
.

D'où le classement des solutions
Python
niveau
stack
:
  1. 202
    :
    TI-Nspire CX II
  2. 129
    :
    NumWorks
  3. 99
    :
    HP Prime G2
  4. 82
    :
    Casio Graph 90+E / 35+E II
  5. 82
    :
    HP Prime G1
  6. 28
    :
    TI-83 Premium CE Edition Python
  1. 202
    :
    TI-Nspire CX II
  2. 155
    :
    TI-Nspire CX
  3. 129
    :
    NumWorks
  4. 126
    :
    NumWorks
    (firmware Omega + appli KhiCAS)
  5. 99
    :
    HP Prime G2
  6. 82
    :
    Casio Graph 90+E / 35+E II
  7. 82
    :
    HP Prime G1
  8. 28
    :
    TI-83 Premium CE Edition Python
  1. 202
    :
    TI-Nspire CX II
  2. 129
    :
    NumWorks
  3. 99
    :
    HP Prime G2
  4. 82
    :
    Casio Graph 90+E / 35+E II / fx-CG50 / fx-9750/9860GIII
  5. 82
    :
    HP Prime G1
  6. 28
    :
    TI-83 Premium CE Edition Python / TI-84 Plus CE Python Edition
  7. 20
    :
    TI-83 Premium CE + TI-Python
  1. 5362
    :
    Casio Graph 35/75+E / 35/75/95 / fx-9750/9860GII
    (SH4 - appli CasioPython)
  2. 655
    :
    Casio Graph 35+E II / 35/75/85/95
    (SH3)
    / fx-9750/9860GIII / fx-9750/9860GII
    (SH3)
    / fx-9860G
    (appli CasioPython)
  3. 202
    :
    TI-Nspire CX II
  4. 155
    :
    TI-Nspire CX / CX II
  5. 130
    :
    TI-Nspire
  6. 129
    :
    NumWorks
  7. 126
    :
    NumWorks
    (firmware Omega + appli KhiCAS)
  8. 99
    :
    HP Prime G2
  9. 82
    :
    Casio Graph 90+E / 35+E II / fx-CG50 / fx-9750/9860GIII
  10. 82
    :
    HP Prime G1
  11. 28
    :
    TI-83 Premium CE Edition Python / TI-84 Plus CE Python Edition
  12. 20
    :
    TI-83 Premium CE + TI-Python
  13. 15
    :
    TI-83 Premium CE + TI-Python




Python : Modules intégrés standard et propriétaires

Go to top

Dans la version bêta précédente, l'application
Python
de la
HP Prime
disposait déjà d'une très belle collection de modules standards importables :
  • builtins
  • array
  • cmath
  • gc
  • math
  • micropython
  • sys
  • ucollections
  • uerrno
  • uhashlib
  • uio
  • urandom
  • ure
  • ustruct
  • utimeq

Cette mise à jour s'offre le luxe de nous en rajouter plusieurs, issus du développement de
Xcas
:
  • linalg
    , un module destiné à remplacer le standard
    numpy.linalg
  • matplotl
    , un module destiné à remplacer le module standard de tracé dans un repère,
    matplotlib.pyplot

Histoire d'être sûr de ne rien rater on peut également appeler help("modules") ; mais non c'est bon, tout semble bien être au menu.

Donc pas moins de 17 modules standard intégrés, comparons un peu aux solutions concurrentes :
TI
83PCE
+
Python
TI
83PCE
Python
TI
84+CE
Python
TI
Nspire
CX II
Casio
Graph
90+E
35+EII
Num
Works
HP
Prime
TI
83PCE
+
Python

tiers
TI-
Nspire
CX


Casio
Graph
35/75+E
35+EII

Num
Works

Num
Works


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
+2


.
.
.

.
.

.
.
.
.
.

.
+
.
.
.

.
.
.


.
+
.
10



.







.
.
.

.
+


.
.


.
.


.
.
.
16
+1

.
.
.
.
.
.
.
.
.
.
.
.
.



.
.
.

.
.
.
.
.
.

.
6

.
.
.

.
.
.
.
.
.
.
.
.




.
.

.
.
.
.

.

.
9


.
.


.



.

.
+

.
+

.
.


.


.

.
.
17


.



.
.

.
.
.
.
.

.
.

.


.

.


.
.
.
13


.
.

.
.
.

.
.
.
.
.

.
.

.
.
.
.
.
.

.
.
.
.
7

.

.









+

.






.


.
.


23


.
.

.
.
.

.
.
.
.
.

.
.

.
.

.
.
.

.
.
.
.
8

.
.
.

.
.
.
.
.
.
.
.
.




.


.
.
.
.

.

.
10

.

.



.





+

.






.


.



23

Légende
:

  • module intégré + disponible en mode examen
  • module intégré + interdit en mode examen
  • +
    module propriétaire équivalent + disponible en mode examen
  • +
    module propriétaire équivalent + interdit en mode examen
  • .
    module absent et sans équivalent


La
HP Prime
compte donc parmi les solutions
Python
offrant la plus large collection de modules standard ! :bj:

  1. 17
    modules :
    HP Prime
  2. 16
    modules :
    TI-Nspire CX II
  3. 9
    modules :
    NumWorks
  4. 8
    modules :
    TI-83 Premium CE Edition Python
  5. 6
    modules :
    Casio Graph 90+E / 35+E II
  1. 23
    modules :
    TI-Nspire CX

    NumWorks N0110
  2. 17
    modules :
    HP Prime
  3. 16
    modules :
    TI-Nspire CX II
  4. 10
    modules :
    NumWorks
  5. 9
    modules :
    NumWorks
  6. 8
    modules :
    TI-83 Premium CE Edition Python
  7. 6
    modules :
    Casio Graph 90+E / 35+E II
  1. 17
    modules :
    HP Prime

    TI-Nspire CX II
  2. 10
    modules :
    TI-83 Premium CE Edition Python / TI-84 Plus CE Python Edition
  3. 9
    modules :
    NumWorks
  4. 8
    modules :
    TI-83 Premium CE + TI-Python
  5. 6
    modules :
    Casio Graph 90+E / 35+E II / fx-CG50 / fx-9750/9860GIII
  1. 23
    modules :
    TI-Nspire CX / CX II

    NumWorks N0110
  2. 17
    modules :
    HP Prime

    TI-Nspire CX II
  3. 13
    modules :
    TI-83 Premium CE + TI-Python
  4. 10
    modules :
    NumWorks

    TI-83 Premium CE Edition Python / TI-84 Plus CE Python Edition
  5. 9
    modules :
    NumWorks
  6. 8
    modules :
    Casio Graph 35/75+E / 35+E II / fx-9750GII/GIII / fx-9860G/GII/GIII
    (appli CasioPython)

    TI-83 Premium CE + TI-Python
  7. 7
    modules :
    TI-Nspire
  8. 6
    modules :
    Casio Graph 90+E / 35+E II / fx-CG50 / fx-9750/9860GIII


À ces modules standards ou équivalents s'ajoutent usuellement des modules propriétaires destinés à traiter des spécificités matérielles ou logicielles de la calculatrice
(détection des touches clavier, de la zone pointée, allumage de pixels sur l'écran, importation/exportation de données, connectivité, ...)


La version bêta précédente rajoutait pour cela le module unique
hpprime
que nous allons découvrir ou redécouvrir de suite.

Cette nouvelle version rajoute également, toujours en provenance du développement de
Xcas
:
  • arit
    pour faire de l'arithmétique
  • graphic
    , un module de tracé par pixels
  • cas
    pour appeler le moteur
    CAS




Python : Appels HPPPL / CAS - import hpprime + import cas

Go to top

Le module
hpprime
est donc un module
Python
propriétaire dédié à la
HP Prime
.

Un dir(hpprime) ne révèle rien de plus. Donc pas de cachotteries ici, tout semble bien être montré au menu et c'est déjà pas mal du tout, si bien que nous allons traiter du module
hpprime
en plusieurs parties.

Nous avons donc vu plus haut qu'il était possible d'appeler du
Python
dans le contexte
HPPPL
.

Et bien l'inverse est également possible grâce à la fonction
eval("...")
. La fonction
eval()
permet d'évaluer l'expression fournie dans le contexte
HPPPL
et d'en retourner le résultat.

Mais petite précision avant cela. Contrairement à nombre de solutions concurrentes qui ne travaillent qu'en virgule flottante, la
HP Prime
gérait 2 types de nombres dans son langage propriétaire historique :
  • les flottants
  • et les entiers
Les entiers n'étaient toutefois utilisés que dans de très rares cas. La plupart du temps, les entiers que tu saisissais étaient en effet immédiatement et automatiquement convertis en virgule flottante.

Parmi les rares cas faisant effectivement appel à des nombres de type entier, nous avions :
  • les nombres saisis avec le préfixe
    #
    de base binaire, octale, décimale ou hexadécimale
  • les résultats de certaines fonctions comme par exemple RGB(,,)

La fonction
hpprime.eval()
ne gérait justement pas correctement les résultats de type entier dans la bêta précédente.
C'est maintenant corrigé.


C'est maintenant l'occasion de profiter du formidable catalogue de fonctions de la
HP Prime
notamment lorsqu'elles n'ont ici pas d'équivalent intégré en
Python
, pour effectuer des calculs et mêmes des affectations de variables de l'environnement
HPPPL
:
hpprime.eval("NORMALD_CDF(2)")

Encore mieux que ça, tu peux également évaluer des expressions dans le contexte
CAS
en imbriquant un appel à la fonction
HPPPL
CAS.eval()
, de quoi bénéficier du moteur de calcul formel
CAS
en
Python
: :D
hpprime.eval('CAS.eval("int(ln(x),x)")')

Mais c'est un peu long et donc pénible à saisir, non ?

Et bien justement, cette nouvelle bêta ta rajoute le module
cas
qui permet d'appeler directement le moteur
CAS
grâce aux fonctions
caseval("...")
,
xcas("...")
et
eval_expr("...")
:
Code: Select all
cas.caseval("int(ln(x),x)")
cas.xcas("int(ln(x),x)")
cas.eval_expr("int(ln(x),x)")

Nous ignorons à ce jour si il y a une différence entre ces 3 fonctions.

Pour te donner une idée du formidable niveau d'intégration, on peut comparer à la concurrence sur les critères suivants :
  1. Python appelable en dehors de son environnement
  2. Python peut lire/écrire des variables hors de son environnement
  3. Python peut lire/écrire toute variable hors de son environnement
  4. Python peut évaluer des expressions hors de son environnement
  5. Python peut évaluer toute expression hors de son environnement
TI
83PCE
+
Python
TI
83PCE
Python
TI
84+CE
Python
TI
Nspire
CX II
Casio
Graph
90+E
35+EII
Num
Works
HP
Prime
TI
83PCE
+
Python

tiers
TI-
Nspire
CX


Casio
Graph
35/75+E
35+EII

Num
Works

Num
Works


1
2
3
4
5
TOTAL
.
.
.
.
.
0
.

.
.
.
1
.

.
.
.
1
.



.
3
.
.
.
.
.
0
.
.
.
.
.
0





5
.
.
.
.
.
0
.
.
.
.
.
0
.




4
.
.
.
.
.
0
.
.
.
.
.
0
.




4


On pouvait reprocher aux solutions
Python
concurrentes leur absence d'intégration, le
Python
tournant en vase clos dans son coin sans interaction avec le reste de l'environnement mathématique de la calculatrice, ou avec très peu d'interactions.

Sur
HP Prime
l'intégration du
Python
a été poussée à un niveau formidable, et de plus de façon bidirectionnelle ! :bj:

Enfin de quoi faire du
Python
sur la calculatrice non plus pour faire du
Python
, mais pour résoudre des problèmes de Mathématiques et de Sciences en interaction avec les autres applications de la calculatrice, bravo ! :D

  1. 5
    points :
    HP Prime
  2. 3
    points :
    TI-Nspire CX II
  3. 1
    point :
    TI-83 Premium CE Edition Python
  4. 0
    point :
    NumWorks

    Casio Graph 90+E / 35+E II
  1. 5
    points :
    HP Prime
  2. 4
    points :
    NumWorks N0110

    TI-Nspire CX
  3. 3
    points :
    TI-Nspire CX II
  4. 1
    point :
    TI-83 Premium CE Edition Python
  5. 0
    point :
    NumWorks

    Casio Graph 90+E / 35+E II
  1. 5
    points :
    HP Prime
  2. 3
    points :
    TI-Nspire CX II
  3. 1
    point :
    TI-83 Premium CE Edition Python / TI-84 Plus CE Python Edition
  4. 0
    point :
    NumWorks

    TI-83 Premium CE + TI-Python

    Casio Graph 90+E / 35+E II / fx-CG50 / fx-9750/9860GIII
  1. 5
    points :
    HP Prime
  2. 4
    points :
    NumWorks N0110

    TI-Nspire CX / CX II
  3. 3
    points :
    TI-Nspire CX II
  4. 1
    point :
    TI-83 Premium CE Edition Python / TI-84 Plus CE Python Edition
  5. 0
    point :
    NumWorks

    TI-Nspire

    Casio Graph 90+E / 35+E II / fx-CG50 / fx-9750/9860GIII

    TI-83 Premium CE + TI-Python

    Casio Graph 35/75+E / 35+E II / fx-9750GII/GIII / fx-9860G/GII/GIII
    (appli CasioPython)




Python : Clavier et tactile - import hpprime

Go to top

Le module
hpprime
contient également de quoi permettre à tes scripts de tester les appuis sur les touches du clavier.

La fonction dédiée hpprime.keyboard() cumule vraiment tous les avantages par rapport aux solutions concurrentes :
  • elle est non bloquante, heureusement ;)
  • elle ne te renvoie pas une touche mais l'état global du clavier, c'est-à-dire que tu peux tester en un seul appel des appuis simultanés sur plusieurs touches :bj:
  • elle permet même de tester les touches
    Shift
    ,
    ALPHA
    et
    On
Donc selon l'aide, pour tester par exemple la touche
Vars
il faut faire hpprime.keyboard() & (1 << 15) car ce serait la 15ème touche clavier en partant du coin en haut à gauche.
L'opérateur && affiché à l'écran d'aide en question étant une erreur, hélas cette fois-ci non corrigée.


Sur la version bêta précédente, la fonction
keyboard()
n'utilisait absolument pas la numérotation de touches ainsi documentée, car il y avait une erreur d'inversion d'octets.

C'est maintenant corrigée sur cette dernière version, voici donc la carte finale :

Apps

0
Symb

1

2
Help

3
Esc

4
Plot

6

7

8
View

9

5
Num

11

12
Menu

13
CAS

10
Vars

14
🧰

15
□/□

16
xtθn

17
ab/c

18

19
x^y

20
SIN

21
COS

22
TAN

23
LN

24
LOG

25

26
+/-

27
()

28
,

29
Enter

30
EEX

31
7

32
8

33
9

34
÷

35
ALPHA

36
4

37
5

38
6

39
×

40
Shift

41
1

42
2

43
3

44
-

45
On

46
0

47
.

48
_

49
+

50

À tester donc avec hpprime.keyboard() & (1 << numero_touche)

Évaluons les solutions clavier
Python
concurrentes selon les critères suivants :
  1. possible d'identifier la touche pressée
  2. les touches modificateurs sont identifiables
    (controle, shift, alpha, 2nde)
  3. la touche
    on/off
    est identifiable
  4. le test est non bloquant
  5. possible d'identifier plusieurs touches pressées simultanément
  6. possible d'identifier plusieurs touches pressées simultanément en un seul appel de la fonction de test

Malheureusement avec cette dernière bêta, la fonction ne permet plus d'identifier la touche
On
. En effet ici pas besoin d'un appui long, l'arrêt du script est immédiat.
TI
83PCE
+
Python
TI
83PCE
Python
TI
84+CE
Python
TI
Nspire
CX II
Casio
Graph
90+E
35+EII
Num
Works
HP
Prime
TI
83PCE
+
Python

tiers
TI-
Nspire
CX


Casio
Graph
35/75+E
35+EII

Num
Works

Num
Works


1
2
3
4
5
6
TOTAL
.
.
.
.
.
.
0

.

.
.
.
2

.

.
.
.
2

.


.
.
3
.
.
.
.
.
.
0





.
5


.



5
.
.
.
.
.
.
0
.
.
.
.
.
.
0

.
.
.
.
.
1
.
.
.
.
.
.
0





.
5



.
.
.
3


La
HP Prime
t'offre clairement la meilleure solution
Python
de gestion du clavier, de quoi en adapter intégralement le comportement pour des interfaces et jeux intuitifs et réactifs ! :bj:

  1. 5
    points :
    HP Prime

    NumWorks
  2. 3
    points :
    TI-Nspire CX II
  3. 2
    points :
    TI-83 Premium CE Edition Python
  4. 0
    point :
    Casio Graph 90+E / 35+E II
  1. 5
    points :
    HP Prime

    NumWorks
  2. 3
    points :
    TI-Nspire CX II

    NumWorks N0110
  3. 2
    points :
    TI-83 Premium CE Edition Python
  4. 1
    point :
    TI-Nspire CX
  5. 0
    point :
    Casio Graph 90+E / 35+E II
  1. 5
    points :
    HP Prime

    NumWorks
  2. 3
    points :
    TI-Nspire CX II
  3. 2
    points :
    TI-83 Premium CE Edition Python / TI-84 Plus CE Python Edition
  4. 0
    point :
    Casio Graph 90+E / 35+E II / fx-CG50 / fx-9750/9860GIII

    TI-83 Premium CE + TI-Python
  1. 5
    points :
    HP Prime

    NumWorks
  2. 3
    points :
    TI-Nspire CX II

    NumWorks N0110
  3. 2
    points :
    TI-83 Premium CE Edition Python / TI-84 Plus CE Python Edition
  4. 1
    point :
    TI-Nspire CX / CX II
  5. 0
    point :
    Casio Graph 90+E / 35+E II / fx-CG50 / fx-9750/9860GIII

    Casio Graph 35/75+E / 35+E II / fx-9750GII/GIII / fx-9860G/GII/GIII
    (appli CasioPython)

    TI-Nspire

    TI-83 Premium CE + TI-Python


Le module
cas
offre lui aussi une fonction
get_key()
, mais nous n'allons pas être bien longs à son sujet cette fois-ci. En effet elle ne semble pas fonctionnelle à ce jour ; elle renvoie immédiatement 0, indépendamment du nombre de touches que tu peux presser ou pas.


Mais le clavier n'est pas la seule entrée. La
HP Prime
dispose également d'un écran tactile, et ce dernier est lui aussi géré en
Python
, grâce à la fonction hpprime.mouse().

Ici les comparaisons à la concurrence seront rapides puisqu'il n'y a qu'une solution offrant quelque chose de comparable, les
TI-Nspire CX II
pour leur pavé tactile.

Mais ici encore énorme avantage à la
HP Prime
qui te retourne les coordonnées de non pas 1 pointeur mais 2 pointeurs ! :o

Avec les bons calculs, de quoi donc détecter également en
Python
les événements tactiles à 2 doigts
(zoom notamment)
, une exclusivité à ce jour ! :bj:




Python : Tracé par pixels et performances - import hpprime + import graphic

Go to top

Le module
hpprime
comprend également des fonctions de tracé par pixels. Pour référence, c'est donc l'équivalent chez la concurrence des modules :
  • kandinsky
    (
    NumWorks
    )
  • ti_graphics
    (
    TI-83 Premium CE / TI-84 Plus CE
    )
  • ti_draw
    (
    TI-Nspire CX II
    )
  • casioplot
    (
    Casio Graph 35+E II / 90+E / fx-9750/9860GIII / fx-CG50
    )
  • graphic
    (
    NumWorks
    +
    KhiCAS
    -
    TI-Nspire CX
    +
    KhiCAS
    )
  • nsp
    (
    TI-Nspire
    +
    micropython
    )
Nous y trouvons notamment la fonction pixon(numero_calque, x, y, couleur) pour allumer un pixel.

numero_calque
de 0 à 9 correspond aux variables globales
G0
à
G9
de l'environnement
HPPPL
, avec pour rappel :
  • G0
    : pour un affichage direct sur écran
  • G1
    à
    G9
    : 9 calques hors écran, permettant non plus du
    double buffering
    mais du
    multiple buffering
C'est-à-dire que tu peux construire tranquillement ton affichage hors écran dont tu déclencheras l'affichage quand tu voudras, ce qui évite ainsi les affichages automatiques d'états inachevés ou encore d'états intermédiaires inesthétiques notamment dans le cas d'animations.

Voici le détail des fonctions disponibles dans ce contexte :
  • blit(numero_calque_1, x, y, numero_calque_2) pour copier un calque
    G0
    à
    G9
    sur un autre aux coordonnées indiquées
  • strblit(numero_calque_1, x, y, largeur, hauteur, numero_calque_2), comme le précédent mais permet en prime au passage de redimensionner la copie
    (agrandissement, réduction, ...)
  • strblit(numero_calque_1, x1, y1, largeur1, hauteur1, numero_calque_2, x2, y2, largeur2, hauteur2), comme le précédent mais permet de ne copier qu'une partie du calque
  • dimgrob(numer_calque, largeur, hauteur, couleur) pour redimensionner les calques
    G1
    à
    G9
    (non valide pour l'écran
    G0
    )
  • grobw(numer_calque) récupérer les dimensions d'un calque
    G0
    à
    G9
Par contre
hpprime
ne semble pas fournir de quoi lire la valeur d'un pixel.



L'écran
HP Prime
fait
320×240
pixels. Première chose à se demander, est-ce que l'on contrôle tous les pixels de l'écran ? Car vu la concurrence, ce n'est pas garanti.

Nous allons donc tenter de déterminer automatiquement la zone graphique, c'est-à-dire la zone dans laquelle l'utilisateur peut librement allumer des pixels.

Commençons dès maintenant à construire et expliquer devant toi notre protocole de test
Python
, avec un script universel tournant sur tous les modèles supportant officiellement ou officieusement ce langage.

L'idée générale va être d'effectuer des écritures et lectures de pixels.

Les fonctions de lecture/écriture des pixels différant hélas d'un constructeur à un autre, il nous faut déjà de quoi permettre au script de détecter la plateforme sur laquelle il tourne :
Code: Select all
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


Cette pièce de précision te retournera d'un simple get_pf() un identifiant couvrant tout l'éventail des solutions
Python
disponibles à ce jour pour calculatrices, et à interpréter de la façon suivante :
  • -1:
    inconnue
    (ordinateur ?...)
  • 0:
    NumWorks
  • 1:
    Casio Graph 90+E / fx-CG50
    ou
    Graph 35+E II / fx-9750/9860GIII
  • 2:
    TI-83 Premium CE
    ou
    TI-84 Plus CE
  • 3:
    HP Prime
  • 4:
    Casio Graph 35+E/USB / 75/85/95 / fx-9750/9860GII / fx-9860G
    avec
  • 5:
    TI-Nspire
    +
    (nécessite
    Ndless
    )
  • 6:
    TI-Nspire
    + en mode
    MicroPython
    (nécessite
    Ndless
    )
  • 7:
    TI-Nspire
    + en mode de compatibilité
    Python
    (nécessite
    Ndless
    )
  • 8:
    NumWorks
    + en mode
    MicroPython
    (nécessite
    Omega
    )
  • 9:
    NumWorks
    + en mode de compatibilité
    Python
    (nécessite
    Omega
    )
  • 10:
    Casio Graph 90+E / fx-CG10/20/50
    + en mode de compatibilité
    Python
  • 11:
    Casio Graph 35+E II / fx-9750/9860GIII
    + en mode de compatibilité
    Python
  • 12:
    HP Prime
    en mode
    CAS

Maintenant que nous connaissons donc la plateforme, reste à récupérer les fonctions d'accès aux pixels.

Nous avons donc vu qu'il n'y avait pas de fonction pour lire un pixel, mais nous avons vu plus haut que le module
hpprime
nous permettait via sa fonction
eval()
d'accéder à l'environnement
HPPPL
complet. Il nous suffit donc de fabriquer la fonction de la façon suivante :
Code: Select all
def get_pixel(x, y):
      return int(hpprime.eval("get_pixel(" + str(x) + "," + str(y) + ")"))


Voici en conséquence de quoi récupérer automatiquement les fonctions de lecture et écriture des pixels sur l'ensemble des plateformes
Python
:
Code: Select all
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
    def sp(x, y, c):
      hpprime.pixon(0, x, y, c)
    def gp(x, y):
      return int(hpprime.eval("get_pixel(" + str(x) + "," + str(y) + ")"))
  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

Voilà, d'un simple gp, sp = get_pixel_functions(get_pf()) nous obtenons les fonctions de lecture et écriture des pixels, sur tous les modèles où elles existent.

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, 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 = gp(x, y)
    sp(x, y, invert_color(c0))
    c = gp(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, comme gp(-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 = gp(x, y)
  except:
    pass
  if c != None:
    if c == bad_pixel:
      sp(x, y, invert_color(c))
      c = gp(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 = gp(-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


L'appel scr_size(), nous indique alors que nous avons accès à la fois en lecture et écriture à
320×240
pixels à compter du pixel de coordonnées (0, 0).

C'est-à-dire qu'en
Python
sur
HP Prime
nous avons le privilège de contrôler intégralement l'écran ! :bj:


Nous aurions certes pu nous en rendre compte beaucoup plus rapidement, mais l'avantage de cette méthode c'est que nous avons en même temps les résultats des solutions concurrentes.
  1. 320×240=76800
    pixels en écriture :
    HP Prime
  2. 384×192=73728
    pixels en écriture :
    Casio Graph 90+E
  3. 320×222=71040
    pixels en écriture :
    NumWorks
  4. 318×212=67416
    pixels en écriture :
    TI-Nspire CX II
  5. 321×210=67410
    pixels en écriture sur
    321×241=77361
    pixels en lecture :
    TI-83 Premium CE Edition Python
  6. 128×64=8192
    pixels en écriture :
    Casio Graph 35+E II
  1. 320×240=76800
    pixels en écriture :
    HP Prime
  2. 384×192=73728
    pixels en écriture :
    Casio Graph 90+E
  3. 320×222=71040
    pixels en écriture :
    NumWorks

    TI-Nspire CX

    NumWorks N0110
  4. 318×212=67416
    pixels en écriture :
    TI-Nspire CX II
  5. 321×210=67410
    pixels en écriture sur
    321×241=77361
    pixels en lecture :
    TI-83 Premium CE Edition Python
  6. 128×64=8192
    pixels en écriture :
    Casio Graph 35+E II
  1. 320×240=76800
    pixels en écriture :
    HP Prime
  2. 384×192=73728
    pixels en écriture :
    Casio Graph 90+E
  3. 320×222=71040
    pixels en écriture :
    NumWorks
  4. 318×212=67416
    pixels en écriture :
    TI-Nspire CX II
  5. 321×210=67410
    pixels en écriture sur
    321×241=77361
    pixels en lecture :
    TI-83 Premium CE Edition Python / TI-84 Plus CE Python Edition
  6. 128×64=8192
    pixels en écriture :
    Casio Graph 35+E II
  7. 0×0=0
    pixels en lecture :
    TI-83 Premium CE + TI-Python
  1. 320×240=76800
    pixels en écriture :
    HP Prime
  2. 384×192=73728
    pixels en écriture :
    Casio Graph 90+E
  3. 320×222=71040
    pixels en écriture :
    NumWorks

    TI-Nspire CX / CX II

    NumWorks N0110
  4. 318×212=67416
    pixels en écriture :
    TI-Nspire CX II
  5. 321×210=67410
    pixels en écriture sur
    321×241=77361
    pixels en lecture :
    TI-83 Premium CE Edition Python / TI-84 Plus CE Python Edition
  6. 128×64=8192
    pixels en écriture :
    Casio Graph 35+E II
  7. 0×0=0
    pixels en lecture :
    TI-83 Premium CE + TI-Python

    TI-83 Premium CE + TI-Python

    Casio Graph 35/75+E / 35+E II / fx-9750GII/GIII / fx-9860G/GII/GIII
    (appli CasioPython)

    TI-Nspire




Maintenant que nous savons quelles coordonnées de pixels indiquer aux fonctions de tracé, intéressons-nous au paramètre de couleur.

Il y a 2 façons de coder les couleurs dans le contexte des pixels en
Python
:
  • soit avec une liste ou un tuple (r, g, b) décrivant les valeurs de chaque composante primaire rouge-vert-bleu par un entier sur 8 bits
    (de 0 à 255)
  • soit par un nombre entier qui sera directement la valeur fournie au contrôleur écran

Dans la plupart des solutions
Python
il s'agit de listes ou tuples (rouge, vert, bleu) avec chaque valeur codée sur 8 bits et pouvant donc prendre les valeurs entières de 0 à 255.

Ce n'est pas ce qui a été retenu sur
HP Prime
, le paramètre de couleur est un unique nombre entier, reste à connaître les capacités du contrôleur écran.

Les modules graphiques concurrents à avoir fait ce choix de codage de couleur sont peu nombreux :
  • graphic
    (
    NumWorks
    +
    KhiCAS
    -
    TI-Nspire CX
    +
    KhiCAS
    )
  • nsp
    (
    TI-Nspire
    +
    micropython
    )

Pour en savoir davantage, rajoutons aux scripts précédents une fonction pour tester le codage utilisé, par simple vérification du type de retour d'une lecture de pixel. Dans le cas d'un retour de type entier, tentons en passant de détecter le nombre de bits gérés par le contrôleur écran, en écrivant des valeurs de pixels de plus en plus grandes et vérifiant à chaque fois si le pixel concerné a bien pris la valeur en question.
Code: Select all
def get_color_mode():
  c = gp(0, 0)
  try:
    c[2]
    return 0
  except:
    b, v = 0, 1
    dv = 1
    x, y = 0, sy0
    sp(x, y, v + dv)
    while gp(x, y) >= v:
      b += 1
      v *= 2
      sp(x, y, v + dv)
    return b

Un appel color_mode = get_color_mode() pourra donc renvoyer par exemple :
  • 0 :
    pour un codage des couleurs par des tuples
    (r,g,b)
  • 15 :
    pour un codage des couleurs sur des entiers de 15 bits
  • 16 :
    pour un codage des couleurs sur des entiers de 16 bits
  • 24 :
    pour un codage des couleurs sur des entiers de 24 bits
  • ...
Et fantastique, sur
HP Prime
on envoie donc directement au contrôleur écran une valeur codée sur 24 bits, ce qui en théorie permet 224=16777216 couleurs différentes ! :o

Vérifions cela, pour un script universel prévoyons une fonction de conversion de couleur :
Code: Select all
def fixcolor(c, bits=16):
  try:
    if not color_mode:
      return c
    r, g, b = c[0], c[1], c[2]
  except:
    if color_mode == bits:
      return c
    if bits == 16:
      br, bg, bb = 5, 6, 5
    else:
      br, bg, bb = 8, 8, 8
    r, g, b = c & (2**br - 1) * 2**(8 - br), c & ((2**bg - 1) * 2**br) // 2**br * 2**(8 - bg), c & ((2**bb - 1) * 2**(br + bg)) // 2**(br + bg) * 2**(8 - bb)
  if not color_mode:
    return (r, g, b)
  else:
    if color_mode == 16:
      br, bg, bb = 5, 6, 5
    else:
      br, bg, bb = 8, 8, 8
    r, g, b = r // 2**(8 - br), g // 2**(8 - bg) * 2**br, b // 2 **(8 - bb) * 2**(br + bg)
    c = r + g - (r & g)
    return c + b - (c & b)


Voici des fonctions intermédiaires pour tracer des lignes verticales ou horizontales :
Code: Select all
def draw_vline(x, y1, y2, c):
  for j in range(y2 - y1 + 1):
    sp(x, y1 + j, c)

def draw_hline(y, x1, x2, c):
  for j in range(x2 - x1 + 1):
    sp(x1 + j, y, c)


Et voici enfin de quoi tracer une mire :
Code: Select all
#o: 0=horizontal, 1=vertical
#s: 0=no_shadow, 1=shadow left/up, -1=shadow right/down
def mire(s=1, o=0, w=sw, h=sh, y0=sy0):
  if o:
    l1, l2, f, i1, i2 = h, w, draw_hline, y0, 0
  else:
    l1, l2, f, i1, i2 = w, h, draw_vline, 0, y0
  n = 8
  for m in range(l1):
    v = 255
    if s != 0:
      v =  v * (s*m % l1) // (l1 - 1)
    for j in range(n):
      f(m + i1, j * l2 // n + i2, (j + 1) * l2 // n - 1 + i2, fixcolor(color8(j, v)))

def color8(j, v):
  c = [0, 0, 0]
  for b in range(3):
    if j & 2**b:
      c[b] = v
  return c


12882
Effectivement l'affichage des scripts
Python
est fabuleux, un dégradé jusqu'au noir dans chaque teinte ne présentant aucune saccade.


L'ensemble de la concurrence
Python
couleur présente des saccades dans le dégradé, qui plus est moins marquées mais 2 fois plus nombreuses dans les teintes tirant sur le vert.

C'est-à-dire que bien que même lorsque le paramètre de couleur spécifié est un tuple de 24 bits, le contrôleur écran ne tient compte que de 16 bits, ne permettant alors que 216=65536 couleurs différentes.
Plus précisément il y a 5 bits pour le rouge, 6 bits pour le vert et 5 bits pour le bleu.

En passant, le bleu étant ci-contre affiché en haut, les bits des plus faibles au plus forts codent donc dans l'ordre les composantes bleu, puis vert, puis rouge.

12795128261283612857


La concurrence
Python
monochrome pour sa part n'affiche jusqu'à présent qu'en noir et blanc, le codage couleur utilisé étant alors sur 1 bit.



Poursuivons maintenant notre exploration des fonctions de tracé par pixels du module
hpprime
. Nous avons donc également un bel éventail de fonctions de tracé :
  • circle(numero_calque, x, y, rayon, couleur) pour tracer un cercle
    (non rempli donc)
  • arc(numero_calque, x, y, rayon, couleur, angle1, angle2) pour tracer un arc de cercle
    (avec les angles en degrés comme maintenant précisé correctement dans l'aide sur cette nouvelle bêta)
  • line(numero_calque, x1, y1, x2, y2, couleur) pour tracer une ligne
  • rect(numero_calque, x1, y1, largeur, hauteur, couleur) pour tracer un rectangle
    (non rempli)
  • fillrect(numero_calque, x1, y1, largeur, hauteur, couleur1, couleur 2) pour remplir un rectangle
  • textout(numero_calque, x, y, texte, couleur) pour écrire une chaîne de caractères

Avec cette version nous disposons donc également d'un deuxième module de tracée par pixels,
graphic
, issu pour sa part du développement de
Xcas
.

La présence de fonctions
show()
et
show_screen()
suggère un fonctionnement en
double buffering
, mais en pratique non : les affichages sont immédiats, et l'appel à ces fonctions semble inutile.

En terme de primitives graphiques, cette bibliothèque semble a priori comparable :
  • clear_screen(couleur) pour remplir l'écran de la couleur indiquée
  • draw_arc(x, y, rayon_x, rayon_y, angle1, angle2, couleur) pour tracer un arc d'ellipse
    (angles en degrés)
  • draw_circle(x, y, rayon, couleur) pour tracer un arc de cercle
  • draw_filled_arc(x, y, rayon_x, rayon_y, angle1, angle2, couleur) pour remplir un secteur d'ellipse
    (angles en degrés)
  • draw_filled_circle(x, y, rayon, couleur) pour remplir un cercle
  • draw_filled_polygon([[x1, y1], [x2, y2], ..., [xn, yn]], couleur) pour remplir un polygone
  • draw_filled_rectangle(x, y, largeur, hauteur, couleur) ou fill_rectangle(x, y, largeur, hauteur, couleur) pour remplir un rectangle
  • draw_line(x1, y1, x2, y2, couleur) pour tracer une ligne
  • draw_pixel(x, y, couleur) ou set_pixel(x, y, couleur) pour allumer un pixel
  • draw_polygon([[x1, y1], [x2, y2], ..., [xn, yn]], couleur) pour tracer un polygone
  • draw_rectangle(x, y, largeur, hauteur, couleur) pour tracer un rectangle
  • draw_string(x, y, texte, couleur1, couleur2) pour écrire une chaîne de caractères
Tu as même une fonction get_pixel(x, y) pour remplacer les appels à rallonge int(hpprime.eval("get_pixel(" + str(x) + "," + str(y) + ")")) vus plus haut.

À y regarder,
graphic
est une bibliothèque graphique beaucoup plus étendue que
hpprime
, avec la gestion des ellipses et les nombreuses possibilités de remplissage ne nécessitant ici qu'un unique appel de fonction ! :bj:
C'est vraiment juste dommage pour le
double buffering
non fonctionnel.


Intéressons-nous maintenant aux performances. Pour illustrer l'importance d'avoir une bonne bibliothèque graphique ainsi que du
double buffering
, voici un petit script de démo animant des tracés de lignes.
Il est compatible avec l'interface
polycalc.py
déjà mise en avant à notre concours de rentrée 2020, et permettant à un script de s'exécuter sur l'ensemble des calculatrices graphiques
Python
.
Code: Select all
from polycalc import *

screen_w, screen_h, my_draw_line, my_fill_rect, my_show_screen, test_esc_key = get_infos(("w", "h", "dl", "fr", "sh", "ek"))

def demog(n=64, front_color=(255, 0, 255)):
  n_max = 256
  n = min(n_max, n)
  dx = n_max // n
  dy = dx

  def get_dir(x, y, d):
    if(x >= screen_w - 1 and y <= 0):
      d = [0, dy]
    elif(x >= screen_w - 1 and y >= screen_h - 1):
      d = [-dx, 0]
    elif(x <= 0 and y >= screen_h - 1):
      d = [0, -dy]
    elif(x <= 0 and y <= 0):
      d = [dx, 0]
    return d

  x1, y1 = 0, 0
  x2, y2 = screen_w - 1, 0
  d1 = [dx, 0]
  d2 = [0, dy]
  colors = [ tuple([(255 - front_color[j]) * (n - 1 - i) // (n - 1) + front_color[j] for j in range(3)]) for i in range(n)]
  l = [[0,0,0,0] for k in range(n)]

  my_fill_rect(0, 0, screen_w, screen_h, (255, 255, 255))

  while not test_esc_key():
    x1 += d1[0]
    y1 += d1[1]
    x2 += d2[0]
    y2 += d2[1]
    l.append((x1, y1, x2, y2))
    for k in range(n):
      c = l[k]
      my_draw_line(c[0], c[1], c[2], c[3], colors[k])
    l.pop(0)
    my_show_screen()
    d1 = get_dir(x1, y1, d1)
    d2 = get_dir(x2, y2, d2)


Attention, pour des raisons de limitation de durée sur la plateforme
gfycat
, les deux prochaines vidéos sont accélérées d'un facteur de
1,26
dans leur version intégrée, et
20
si jouées de façon indépendante.

Commençons par les
Casio Graph 90+E
et compatibles. Ici nous avons du
double buffering
mais la bibliothèque de tracé
casioplot
est rudimentaire, ne fournissant rien d'autre que de quoi allumer un pixel.

Les lignes doivent donc être tracées pixel par pixel par une fonction de remplacement que voici :
Code: Select all
def poly_draw_line(x1, y1, x2, y2, c):
        m, a1, b1, a2, b2 = 0, int(x1), int(y1), int(x2), int(y2)
        if (x2 - x1) ** 2 < (y2 - y1) ** 2:
          m, a1, a2, b1, b2 = 1, b1, b2, a1, a2
        if min(a1, a2) != a1: a1, b1, a2, b2 = a2, b2, a1, b1
        for k in range(a2 - a1 + 1):
          a, b = a1 + k, int(b1 + (b2 - b1) * k / ((a2 - a1) or 1))
          poly_set_pixel((a, b)[m], (b, a)[m] + screen_y0, c)

Cela se paie très cher en performances, l'animation met plus d'un quart d'heure à boucler,
17min50
.

Les
TI-83 Premium CE Edition Python
n'ont pour leur part pas de
double buffering
. Cela déclenche ici des clignotements intempestifs, les états intermédiaires de l'animation avec les effacements de lignes devenant visibles. Le matériel est également très inférieur.

Toutefois leur bibliothèque
ti_graphics
est extrêmement complète ce qui leur permet ici de compenser et même faire mieux que la solution précédente en terme de performances. L'animation boucle en
12min36
, comme quoi ça compte. ;)

Dans sa version intégrée la prochaine vidéo est à vitesse réelle. Si ouverte de façon indépendante, elle sera accélérée d'un facteur de
8
.

Les
NumWorks N0110
et compatibles n'ont pas non plus de
double buffering
, et souffrent d'une bibliothèque graphique
kandinsky
extrêmement pauvre, presque autant que celle de
Casio
. Tout ce que
kandinsky
a en plus, c'est de quoi tracer des rectangles ce qui ne nous aidera pas ici.

En conséquence une animation encore bien lente bouclant en
5min14
, avec des clignotements inesthétiques.

À compter de maintenant toutes les vidéos sont à vitesse réelle, aussi bien dans leur version intégrée que si ouvertes indépendamment.

Les
NumWorks
peuvent toutefois être améliorées par installation du
firmware
tiers
Omega
. Dans ce cas la bibliothèque
kandinsky
se voit rajoutée une fonction de tracé de lignes, qui change complètement la donne. L'animation ne met plus que
7,28s
à boucler.

Sur
NumWorks N0110
on peut alors également installer l'application
KhiCAS
qui dispose de son propre interpréteur
Micropython
avec sa propre bibliothèque
graphics
. Mêmes avantages ici.
9,08s
.

graphic
dispose d'une fonction
show_screen()
suggérant une possibilité de
double buffering
, mais cela ne semble pas du tout marcher en pratique.

Sur
TI-Nspire CX II
on a bien du
double buffering
ainsi que la très large bibliothèque graphique
ti_draw
. Seulement
27,8s
.

Mais il semble par contre y avoir ici de l'
anti-aliasing
à l'œuvre, ce qui parasite les nettoyages intermédiaires effectués par ce script.

Si on passe sous
KhiCAS
ici apparemment on a toujours le
double buffering
, mais le problème d'
anti-aliasing
disparaît et c'est même en prime légèrement plus rapide. Plus que
22,6s


Voici enfin la
HP Prime G1
de la rentrée 2013. Son excellente bibliothèque graphique
hpprime
donc couplée à son matériel honorable, nous donnent une animation parfaitement fluide et esthétique,
2,6s
! :bj:

Avec la
HP Prime G2
et son matériel très supérieur de la rentrée 2019, là nous quittons clairement l'attraction terrestre.
0,84s
! :#tritop#:

On peut également modifier le script de test pour appeler sur
HP Prime
non plus la bibliothèque
hpprime
, mais la bibliothèque
graphic
.

Les performances sont alors nettement supérieures, la
HP Prime G1
ne met plus que
1,32s
.

Et la
HP Prime G2
seulement
0,48s
.

Mais comme il n'y a ici pas de
double buffering
l'animation n'est pas jouée de façon propre, et
graphic
n'est donc à ce jour pas forcément un meilleur choix que
hpprime
en tant que module de tracé par pixels.

Classons donc les solutions graphiques
Python
concurrentes selon les critères suivants :
  1. module de tracé par pixels
  2. fonction de tracé de ligne
  3. fonctions de tracé de rectangles
  4. fonctions de tracé de cercles
  5. fonctions de tracé d'ellipses
  6. double buffering
  7. multiple buffering
TI
83PCE
+
Python
TI
83PCE
Python
TI
84+CE
Python
TI
Nspire
CX II
Casio
Graph
90+E
35+EII
Num
Works
HP
Prime
TI
83PCE
+
Python

tiers
TI-
Nspire
CX


Casio
Graph
35/75+E
35+EII

Num
Works

Num
Works


1
2
3
4
5
6
7
TOTAL
.
.
.
.
.
.
.
0





.
.
5





.
.
5






.
6

.
.
.
.

.
2

.

.
.
.
.
2







7
.
.
.
.
.
.
.
0

.
.
.
.


3






.
6
.
.
.
.
.
.
.
0



.
.
.
.
3





.
.
5


La
HP Prime
cumule ici encore tous les avantages : une bibliothèque graphique ambitieuse tournant sur un matériel correctement dimensionné. De formidables possibilités de tracés par pixels en conséquence avec des projets qui pourront aller bien au-delà de notre très modeste animation ! :favorite:

  1. 7
    points :
    HP Prime
  2. 6
    points :
    TI-Nspire CX II
  3. 5
    points :
    TI-83 Premium CE Edition Python
  4. 2
    points :
    NumWorks

    Casio Graph 90+E / 35+E II
  1. 7
    points :
    HP Prime
  2. 6
    points :
    TI-Nspire CX II

    TI-Nspire CX
  3. 5
    points :
    TI-83 Premium CE Edition Python

    NumWorks N0110
  4. 3
    points :
    NumWorks
  5. 2
    points :
    NumWorks

    Casio Graph 90+E / 35+E II
  1. 7
    points :
    HP Prime
  2. 6
    points :
    TI-Nspire CX II
  3. 5
    points :
    TI-83 Premium CE Edition Python / TI-84 Plus CE Python Edition
  4. 2
    points :
    NumWorks

    Casio Graph 90+E / 35+E II / fx-CG50 / fx-9750/9860GIII
  5. 0
    points :
    TI-83 Premium CE + TI-Python
  1. 7
    points :
    HP Prime
  2. 6
    points :
    TI-Nspire CX II

    TI-Nspire CX / CX II
  3. 5
    points :
    TI-83 Premium CE Edition Python / TI-84 Plus CE Python Edition

    TI-Nspire CX

    NumWorks N0110
  4. 3
    points :
    NumWorks

    TI-Nspire
  5. 2
    points :
    NumWorks

    Casio Graph 90+E / 35+E II / fx-CG50 / fx-9750/9860GIII
  6. 0
    point :
    TI-83 Premium CE + TI-Python

    TI-83 Premium CE + TI-Python

    Casio Graph 35/75+E / 35+E II / fx-9750GII/GIII / fx-9860G/GII/GIII
    (appli CasioPython)




Python : Tracé dans un repère - import hpprime + import matplotl

Go to top

Le module
hpprime
fournit également des fonctions de tracé dans un repère.

Pour référence,
hpprime
serait donc a priori l'équivalent chez la concurrence des modules :
  • matplotlib.pyplot
    (
    NumWorks
    -
    Casio Graph 35+E II / 90+E / fx-9750/9860GIII / fx-CG50
    )
  • ti_plotlib
    (
    TI-83 Premium CE / TI-84 Plus CE
    -
    TI-NSpire CX II
    -
    NumWorks
    +
    KhiCAS
    -
    TI-Nspire CX
    +
    KhiCAS
    )

Il s'agit de l'ensemble des fonctions de tracé vues plus haut mais suffixées d'un
_c
pour leur version repérée.

Les bornes de la fenêtre se règlent avec set_cartesian(xmin, ymin, xmax, ymax) et se récupèrent si besoin avec get_cartesian().

Pour le moment c'est assez préliminaire par rapport à la concurrence, dans le sens où il n'y a pas de fonction pour tracer des diagrammes
(nuage de points, histogramme, champs de vecteurs, etc.)
comme exigé au lycée français en Physique-Chimie.

On pourrait penser pour cela faire appel au module
matplotl
apporté par
Xcas
...

Mais en pratique nous n'arrivons à ce jour pas à obtenir le moindre tracé avec ce module, bien que n'oubliant pas d'appeler sa fonction
show()
et la commande pour geler l'écran hpprime.eval("wait()").




Python : Bilan modules

Go to top

Nous avons donc comparé plus haut l'offre de modules
Python
standard.

Pour comparer la richesse de diverses implémentations
Python
, on ne peut pas se baser sur le nombre de modules différents offerts. En effet pour les modules propriétaires, certaines implémentations regroupent les fonctionnalités en un minimum de modules, alors que d'autres les répartissent entre de nombreux modules différents.

Tentons une autre approche incluant cette fois-ci les modules propriétaires avec le script suivant, initialement conçu pour notre classement
QCC 2020
:
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)


Le script compte donc le nombre de fonctions offertes par le module donné ainsi que ses différents éléments, tout en évitant les doublons.

La
HP Prime
n'est pas en tête cette fois-ci, mais elle progresse vite. De
853
éléments dans la précédente version bêta, on passe aujourd'hui déjà à
1065
éléments grâce aux divers modules rajoutés, avec des conséquences au classement :
  1. 1915
    fonctions :
    TI-83 Premium CE Edition Python
  2. 1065
    fonctions :
    HP Prime
  3. 1017
    fonctions :
    TI-Nspire CX II
  4. 547
    fonctions :
    NumWorks
  5. 443
    fonctions :
    Casio Graph 90+E / 35+E II
  1. 1915
    fonctions :
    TI-83 Premium CE Edition Python
  2. 1387
    fonctions :
    NumWorks N0110
  3. 1284
    fonctions :
    TI-Nspire CX
  4. 1065
    fonctions :
    HP Prime
  5. 1017
    fonctions :
    TI-Nspire CX II
  6. 590
    fonctions :
    NumWorks
  7. 547
    fonctions :
    NumWorks
  8. 443
    fonctions :
    Casio Graph 90+E / 35+E II
  1. 2495
    fonctions :
    TI-83 Premium CE Edition Python / TI-84 Plus CE Python Edition
  2. 2160
    fonctions :
    TI-Nspire CX II
  3. 1065
    fonctions :
    HP Prime
  4. 547
    fonctions :
    NumWorks
  5. 443
    fonctions :
    Casio Graph 90+E / 35+E II / fx-CG50 / fx-9750/9860GIII
  6. 405
    fonctions :
    TI-83 Premium CE + TI-Python
  1. 2495
    fonctions :
    TI-83 Premium CE Edition Python / TI-84 Plus CE Python Edition
  2. 2160
    fonctions :
    TI-Nspire CX II
  3. 1387
    fonctions :
    NumWorks N0110
  4. 1284
    fonctions :
    TI-Nspire CX / CX II
  5. 1065
    fonctions :
    HP Prime
  6. 602
    fonctions :
    TI-83 Premium CE + TI-Python
  7. 590
    fonctions :
    NumWorks
  8. 547
    fonctions :
    NumWorks
  9. 464
    fonctions :
    Casio Graph 35/75+E / 35+E II / fx-9750GII/GIII / fx-9860G/GII/GIII
    (appli CasioPython)
  10. 429
    fonctions :
    TI-Nspire
  11. 405
    fonctions :
    TI-83 Premium CE + TI-Python




Python : Implémentation, nombres entiers et performances - import sys

Go to top

Un module
Python
très intéressant à explorer pour commencer à apprendre à se connaître, c'est le module standard
sys
.

Il est donc au menu de bas d'écran
Cmds
, et on peut noter que le contenu listé semble très exhaustif.

Histoire d'être sûr de ne rien rater, on peut obtenir la liste intégrale des différents éléments qu'il permet d'appeler via un simple dir(sys).

sys.platform == 'HP Prime' sera par exemple une astuce de test bien utile pour tes scripts en ayant besoin d'identifier la plateforme sur laquelle ils tournent, notamment pour tenir compte des dimensions de l'écran ou du comportement de la console
Python
.

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

Actuellement l'ensemble des solutions concurrentes implémentent
Python 3.4.0
, et la plupart utilisent
Micropython
.

Bon,
Micropython 1.9.4
sur
HP Prime
ce n'est certes pas une antiquité, mais nous sommes en 2021 et les mises à jour sorties en 2020-2021 pour solutions concurrentes sont déjà passées à plus récent.

Mais peut-être n'y a-t-il pas eu le temps de creuser ce point depuis la version alpha d'octobre 2019 qui intégrait déjà cette version.

  • Micropython 1.12.0
    :
    NumWorks
  • Micropython 1.11.0
    :
    TI-Nspire CX II
  • Micropython 1.9.4
    :
    HP Prime

    Casio Graph 90+E / 35+E II
  • TI-Python 3.1.0.58
    :
    TI-83 Premium CE Edition Python
  • Micropython 1.12.0
    :
    TI-Nspire CX
  • Micropython 1.12.0
    :
    NumWorks
  • Micropython 1.12.0
    :
    NumWorks N0110
  • Micropython 1.11.0
    :
    TI-Nspire CX II
  • Micropython 1.9.4
    :
    HP Prime

    Casio Graph 90+E / 35+E II
  • TI-Python 3.1.0.58
    :
    TI-83 Premium CE Edition Python
  • Micropython 1.12.0
    :
    NumWorks
  • Micropython 1.11.0
    :
    TI-Nspire CX II
  • Micropython 1.9.4
    :
    HP Prime

    Casio Graph 90+E / 35+E II / fx-CG50 / fx-9750/9860GIII
  • TI-Python 3.1.0.58
    :
    TI-83 Premium CE Edition Python / TI-84 Plus CE Python Edition
  • CircuitPython 3.0.0
    :
    TI-83 Premium CE + TI-Python
  • Micropython 1.12.0
    :
    TI-Nspire CX / CX II
  • Micropython 1.12.0
    :
    NumWorks
  • Micropython 1.12.0
    :
    NumWorks N0110
  • Micropython 1.11.0
    :
    TI-Nspire CX II
  • Micropython 1.9.4
    :
    HP Prime

    Casio Graph 90+E / 35+E II / fx-CG50 / fx-9750/9860GIII

    Casio Graph 35/75+E / 35+E II / fx-9750GII/GIII / fx-9860G/GII/GIII
    (appli CasioPython)
  • Micropython 1.4.6
    :
    TI-Nspire
  • TI-Python 3.1.0.58
    :
    TI-83 Premium CE Edition Python / TI-84 Plus CE Python Edition
  • CircuitPython 4.0.0
    :
    TI-83 Premium CE + TI-Python
  • CircuitPython 3.0.0
    :
    TI-83 Premium CE + TI-Python

Pour information
TI-Python
est un dérivé de
CircuitPython
, qui est lui-même un
Micropython
allégé.




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. En pratique 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 absolues supérieures qui sont alors gérées logiciellement en tant qu'entiers longs.

Comme la quasi totalité de la concurrence jusqu'à présent, nous avons sys.maxsize == 2147483647, soit sys.maxsize == 2**31 -1, valeur habituelle pour les plateformes 32 bits, 1 bit étant réservé pour le signe.

Les seules exceptions sont les
TI-Nspire CX II
qui pour on ne sait quelle raison ont sys.maxsize == 32767 soit sys.maxsize == 2**15 -1, caractéristique des plateformes 16 bits...

Quant à sys.byteorder, ici aussi la quasi totalité de la concurrence travaille en
little endian
.

À une exception près ici encore mais pas la même, les
Casio
travaillent en
big endian
.

Voyons donc les performances du
Python
dans le contexte des nombres entiers, afin de voir si les performances de la
HP Prime
sont à la hauteur de la réputation de son formidable matériel. 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


Malheureusement ici pas de module
time
, donc nous allons lancer une série de 15 isprimep(10000019) via une boucle, chronométrer à la main et faire la moyenne.

Donc en moyenne pour un appel de isprimep(10000019) :
  • la
    HP Prime G1
    répond en seulement
    0,449s
    , soit déjà légèrement plus vite qu'une
    TI-Nspire CX II
    ! :bj:
  • la
    HP Prime G2
    répond plus vite que son ombre, en
    0,171s
    ! :#tritop#:
Fantastique, les
HP Prime
mènent la course, et la
HP Prime G2
écrase littéralement toute concurrence, bravo ! :bj:

  1. 0,171s
    :
    HP Prime G2
    (32 bits : Cortex-A7/ARMv7 @
    528MHz
    Python)
  2. 0,449s
    :
    HP Prime G1
    (32 bits : ARM9/ARMv5 @
    400MHz
    Python)
  3. 0,451s
    :
    TI-Nspire CX II
    (32 bits : ARM9/ARMv5 @
    396MHz
    )
  4. 0,581s
    :
    NumWorks N0110
    (32 bits : Cortex-M7/ARMv7 @
    216MHz
    )
  5. 1,17s
    :
    NumWorks N0100
    (32 bits : Cortex-M4/ARMv7 @
    100MHz
    )
  6. 1,58s
    :
    Casio Graph 90+E
    (32 bits : SH4 @
    117,96MHz
    )
  7. 4,39s
    :
    Casio Graph 35+E II
    (32 bits : SH4 @
    58,98MHz
    )
  8. 4,42s
    :
    HP Prime G2
    (32 bits : Cortex-A7/ARMv7 @
    528MHz
    CAS)
  9. 9s
    :
    TI-83 Premium CE Edition Python
    (8 + 32 bits : eZ80 @
    48MHz
    + Cortex-M0+/ARMv6 @
    48MHz
    )
  10. 16,05s
    :
    HP Prime G1
    (32 bits : ARM9/ARMv5 @
    400MHz
    CAS)
  1. 0,171s
    :
    HP Prime G2
    (32 bits : Cortex-A7/ARMv7 @
    528MHz
    Python)
  2. 0,449s
    :
    HP Prime G1
    (32 bits : ARM9/ARMv5 @
    400MHz
    Python)
  3. 0,451s
    :
    TI-Nspire CX II
    (32 bits : ARM9/ARMv5 @
    396MHz
    )
  4. 0,794s
    :
    TI-Nspire CX
    (révisions A-V)
    (32 bits : ARM9/ARMv5 @
    132MHz
    - Ndless + KhiCAS Micropython)
  5. 0,581s
    :
    NumWorks N0110
    (32 bits : Cortex-M7/ARMv7 @
    216MHz
    )
  6. 0,715s
    :
    NumWorks N0110
    (Omega + KhiCAS Micropython)
  7. 1,17s
    :
    NumWorks N0100
    (32 bits : Cortex-M4/ARMv7 @
    100MHz
    )
  8. 1,18s
    :
    TI-Nspire CX CR4+
    (révisions W+)
    (32 bits : ARM9/ARMv5 @
    156MHz
    - Ndless + KhiCAS Micropython)
  9. 1,58s
    :
    Casio Graph 90+E
    (32 bits : SH4 @
    117,96MHz
    )
  10. 4,39s
    :
    Casio Graph 35+E II
    (32 bits : SH4 @
    58,98MHz
    )
  11. 4,42s
    :
    HP Prime G2
    (32 bits : Cortex-A7/ARMv7 @
    528MHz
    CAS)
  12. 9s
    :
    TI-83 Premium CE Edition Python
    (8 + 32 bits : eZ80 @
    48MHz
    + Cortex-M0+/ARMv6 @
    48MHz
    )
  13. 16,05s
    :
    HP Prime G1
    (32 bits : ARM9/ARMv5 @
    400MHz
    CAS)
  14. 36,26s
    :
    TI-Nspire CX
    (révisions A-V)
    (32 bits : ARM9/ARMv5 @
    132MHz
    - Ndless + KhiCAS compatibilité Python)
  15. 42,75s
    :
    NumWorks N0110
    (Omega + KhiCAS compatibilité Python)
  16. 53,24s
    :
    TI-Nspire CX CR4+
    (révisions W+)
    (32 bits : ARM9/ARMv5 @
    156MHz
    - Ndless + KhiCAS compatibilité Python
  1. 0,171s
    :
    HP Prime G2
    (32 bits : Cortex-A7/ARMv7 @
    528MHz
    Python)
  2. 0,449s
    :
    HP Prime G1
    (32 bits : ARM9/ARMv5 @
    400MHz
    Python)
  3. 0,451s
    :
    TI-Nspire CX II
    (32 bits : ARM9/ARMv5 @
    396MHz
    )
  4. 0,511s
    :
    TI-Nspire CX
    (révisions A-V)
    (32 bits : ARM9/ARMv5 @132MHz
    overclocké
    @
    222MHz
    Nover - Ndless + KhiCAS Micropython)
  5. 0,581s
    :
    NumWorks N0110
    (32 bits : Cortex-M7/ARMv7 @
    216MHz
    )
  6. 0,715s
    :
    NumWorks N0110
    (Omega + KhiCAS Micropython)
  7. 0,821s
    :
    TI-Nspire CX CR4+
    (révisions W+)
    (32 bits : ARM9/ARMv5 @156MHz
    overclocké
    @
    216MHz
    Nover - Ndless + KhiCAS Micropython)
  8. 1,17s
    :
    NumWorks N0100
    (32 bits : Cortex-M4/ARMv7 @
    100MHz
    )
  9. 1,58s
    :
    Casio Graph 90+E
    (32 bits : SH4 @
    117,96MHz
    )
  10. 4,39s
    :
    Casio Graph 35+E II
    (32 bits : SH4 @
    58,98MHz
    )
  11. 4,42s
    :
    HP Prime G2
    (32 bits : Cortex-A7/ARMv7 @
    528MHz
    CAS)
  12. 9s
    :
    TI-83 Premium CE Edition Python
    (8 + 32 bits : eZ80 @
    48MHz
    + Cortex-M0+/ARMv6 @
    48MHz
    )
  13. 16,05s
    :
    HP Prime G1
    (32 bits : ARM9/ARMv5 @
    400MHz
    CAS)
  14. 29,20s
    :
    TI-Nspire CX
    (révisions A-V)
    (32 bits : ARM9/ARMv5 @132MHz
    overclocké
    @
    222MHz
    Nover - Ndless + KhiCAS compatibilité Python)
  15. 42,75s
    :
    NumWorks N0110
    (Omega + KhiCAS compatibilité Python)
  16. 45,34s
    :
    TI-Nspire CX CR4+
    (révisions W+)
    (32 bits : ARM9/ARMv5 @156MHz
    overclocké
    @
    216MHz
    Nover - Ndless + KhiCAS compatibilité Python)
  1. 0,171s
    :
    HP Prime G2
    (32 bits : Cortex-A7/ARMv7 @
    528MHz
    Python)
  2. 0,449s
    :
    HP Prime G1
    (32 bits : ARM9/ARMv5 @
    400MHz
    Python)
  3. 0,451s
    :
    TI-Nspire CX II
    (32 bits : ARM9/ARMv5 @
    396MHz
    )
  4. 0,581s
    :
    NumWorks N0110
    (32 bits : Cortex-M7/ARMv7 @
    216MHz
    )
  5. 1,17s
    :
    NumWorks N0100
    (32 bits : Cortex-M4/ARMv7 @
    100MHz
    )
  6. 1,58s
    :
    Casio Graph 90+E / fx-CG50
    (32 bits : SH4 @
    117,96MHz
    )
  7. 4,39s
    :
    Casio Graph 35+E II / fx-9750/9860GIII
    (32 bits : SH4 @
    58,98MHz
    )
  8. 4,42s
    :
    HP Prime G2
    (32 bits : Cortex-A7/ARMv7 @
    528MHz
    CAS)
  9. 8,1s
    :
    TI-83 Premium CE
    +
    TI-Python
    (8 + 32 bits : eZ80 @
    48MHz
    + Cortex-M0+/ARMv6 @
    48MHz
    )
  10. 9s
    :
    TI-83 Premium CE Edition Python / TI-84 Plus CE Python Edition
    (8 + 32 bits : eZ80 @
    48MHz
    + Cortex-M0+/ARMv6 @
    48MHz
    )
  11. 16,05s
    :
    HP Prime G1
    (32 bits : ARM9/ARMv5 @
    400MHz
    CAS)
  1. 0,171s
    :
    HP Prime G2
    (32 bits : Cortex-A7/ARMv7 @
    528MHz
    Python)
  2. 0,307s
    :
    TI-Nspire CX II
    (32 bits : ARM9/ARMv5 @
    396MHz
    - Ndless + MicroPython)
  3. 0,323s
    :
    TI-Nspire CX II
    (32 bits : ARM9/ARMv5 @
    396MHz
    - Ndless + KhiCAS Micropython)
  4. 0,449s
    :
    HP Prime G1
    (32 bits : ARM9/ARMv5 @
    400MHz
    Python)
  5. 0,451s
    :
    TI-Nspire CX II
    (32 bits : ARM9/ARMv5 @
    396MHz
    )
  6. 0,58s
    :
    Casio Graph 35/75+E / 35/75/95 / fx-9750/9860GII
    (32 bits : SH4 @
    29,49MHz
    - CasioPython)
  7. 0,581s
    :
    NumWorks N0110
    (32 bits : Cortex-M7/ARMv7 @
    216MHz
    )
  8. 0,59s
    :
    Casio Graph 35+E II / fx-9750/9860GIII
    (32 bits : SH4 @
    58,98
    - CasioPython)
  9. 0,62s
    :
    TI-Nspire CX
    (révisions A-V)
    (32 bits : ARM9/ARMv5 @
    132MHz
    - Ndless + MicroPython)
  10. 0,67s
    :
    TI-Nspire
    (32 bits : ARM9/ARMv5 @
    120MHz
    - Ndless + MicroPython)
  11. 0,715s
    :
    NumWorks N0110
    (Omega + KhiCAS Micropython)
  12. 0,794s
    :
    TI-Nspire CX
    (révisions A-V)
    (32 bits : ARM9/ARMv5 @
    132MHz
    - Ndless + KhiCAS Micropython)
  13. 0,99s
    :
    TI-Nspire CX CR4+
    (révisions W+)
    (32 bits : ARM9/ARMv5 @
    156MHz
    - Ndless + MicroPython)
  14. 1,17s
    :
    NumWorks N0100
    (32 bits : Cortex-M4/ARMv7 @
    100MHz
    )
  15. 1,18s
    :
    TI-Nspire CX CR4+
    (révisions W+)
    (32 bits : ARM9/ARMv5 @
    156MHz
    - Ndless + KhiCAS Micropython)
  16. 1,58s
    :
    Casio Graph 90+E / fx-CG50
    (32 bits : SH4 @
    117,96MHz
    )
  17. 4,39s
    :
    Casio Graph 35+E II / fx-9750/9860GIII
    (32 bits : SH4 @
    58,98MHz
    )
  18. 4,42s
    :
    HP Prime G2
    (32 bits : Cortex-A7/ARMv7 @
    528MHz
    CAS)
  19. 5,24s
    :
    Casio Graph 35/75/85/95 / fx-9750/9860GII / fx-9860G
    (32 bits : SH3 @
    29,49MHz
    - CasioPython)
  20. 8,1s
    :
    TI-83 Premium CE
    +
    TI-Python
    (8 + 32 bits : eZ80 @
    48MHz
    + Cortex-M0+/ARMv6 @
    48MHz
    )
  21. 9s
    :
    TI-83 Premium CE Edition Python / TI-84 Plus CE Python Edition
    (8 + 32 bits : eZ80 @
    48MHz
    + Cortex-M0+/ARMv6 @
    48MHz
    )
  22. 11,26s
    :
    TI-83 Premium CE
    +
    TI-Python
    (8 + 32 bits : eZ80 @
    48MHz
    + Cortex-M0+/ARMv6 @
    48MHz
    CircuitPython)
  23. 11,62s
    :
    TI-Nspire CX II
    (32 bits : ARM9/ARMv5 @
    396MHz
    - Ndless + KhiCAS compatibilité Python)
  24. 16,05s
    :
    HP Prime G1
    (32 bits : ARM9/ARMv5 @
    400MHz
    CAS)
  25. 32,76s
    :
    Casio Graph 90+E / fx-CG50
    (32 bits : SH4 @
    117,96MHz
    - KhiCAS)
  26. 36,26s
    :
    TI-Nspire CX
    (révisions A-V)
    (32 bits : ARM9/ARMv5 @
    132MHz
    - Ndless + KhiCAS compatibilité Python)
  27. 42,75s
    :
    NumWorks N0110
    (Omega + KhiCAS compatibilité Python)
  28. 53,24s
    :
    TI-Nspire CX CR4+
    (révisions W+)
    (32 bits : ARM9/ARMv5 @
    156MHz
    - Ndless + KhiCAS compatibilité Python)
  29. 91,71s
    :
    Casio Graph 35+E II / fx-9750/9860GIII
    (32 bits : SH4 @
    58,98MHz
    - KhiCAS)
  30. 102,04s
    :
    Casio fx-CG10/20
    (32 bits : SH4 @
    58,98MHz
    - KhiCAS)
  1. 0,171s
    :
    HP Prime G2
    (32 bits : Cortex-A7/ARMv7 @
    528MHz
    Python)
  2. 0,206s
    :
    TI-Nspire CX II
    (32 bits : ARM9/ARMv5 @396MHz
    overclocké
    @
    468MHz
    NoverII - Ndless + MicroPython)
  3. 0,263s
    :
    TI-Nspire CX II
    (32 bits : ARM9/ARMv5 @396MHz
    overclocké
    @
    468MHz
    NoverII - Ndless + KhiCAS Micropython)
  4. 0,382
    :
    TI-Nspire CX II
    (32 bits : ARM9/ARMv5 @396MHz
    overclocké
    @
    468MHz
    NoverII)
  5. 0,42s
    :
    TI-Nspire CX
    (révisions A-V)
    (32 bits : ARM9/ARMv5 @132MHz
    overclocké
    @
    222MHz
    Nover - Ndless + MicroPython)
  6. 0,449s
    :
    HP Prime G1
    (32 bits : ARM9/ARMv5 @
    400MHz
    Python)
  7. 0,511s
    :
    TI-Nspire CX
    (révisions A-V)
    (32 bits : ARM9/ARMv5 @132MHz
    overclocké
    @
    222MHz
    Nover - Ndless + KhiCAS Micropython)
  8. 0,57s
    :
    TI-Nspire
    (32 bits : ARM9/ARMv5
    overclocké
    @120MHz @
    150MHz
    Nover - Ndless + MicroPython)
  9. 0,58s
    :
    Casio Graph 35/75+E / 35/75/95 / fx-9750/9860GII
    (32 bits : SH4 @29,49MHz
    overclocké
    @
    267,78MHz
    Ftune2 - CasioPython)
  10. 0,581s
    :
    NumWorks N0110
    (32 bits : Cortex-M7/ARMv7 @
    216MHz
    )
  11. 0,59s
    :
    Casio Graph 35+E II / fx-9750/9860GIII
    (32 bits : SH4 @58,98MHz
    overclocké
    @
    274,91MHz
    Ftune3 - CasioPython)
  12. 0,63s
    :
    TI-Nspire CX CR4+
    (révisions W+)
    (32 bits : ARM9/ARMv5 @156MHz
    overclocké
    @
    216MHz
    Nover - Ndless + MicroPython)
  13. 0,715s
    :
    NumWorks N0110
    (Omega + KhiCAS Micropython)
  14. 0,821s
    :
    TI-Nspire CX CR4+
    (révisions W+)
    (32 bits : ARM9/ARMv5 @156MHz
    overclocké
    @
    216MHz
    Nover - Ndless + KhiCAS Micropython)
  15. 0,86s
    :
    Casio Graph 35+E II / fx-9750/9860GIII
    (32 bits : SH4 @58,98MHz
    overclocké
    @
    274,91MHz
    Ftune3)
  16. 1,08s
    :
    Casio Graph 90+E / fx-CG50
    (32 bits : SH4 @117,96MHz
    overclocké
    @
    270,77MHz
    Ptune3)
  17. 1,17s
    :
    NumWorks N0100
    (32 bits : Cortex-M4/ARMv7 @
    100MHz
    )
  18. 1,688s
    :
    Casio Graph 35/75/85/95 / fx-9750/9860GII / fx-9860G
    (32 bits : SH3 @29,49MHz
    overclocké
    @
    117,96MHz
    Ftune - CasioPython)
  19. 4,42s
    :
    HP Prime G2
    (32 bits : Cortex-A7/ARMv7 @
    528MHz
    CAS)
  20. 8,1s
    :
    TI-83 Premium CE
    +
    TI-Python
    (8 + 32 bits : eZ80 @
    48MHz
    + Cortex-M0+/ARMv6 @
    48MHz
    )
  21. 9s
    :
    TI-83 Premium CE Edition Python / TI-84 Plus CE Python Edition
    (8 + 32 bits : eZ80 @
    48MHz
    + Cortex-M0+/ARMv6 @
    48MHz
    )
  22. 9.964s
    :
    TI-Nspire CX II
    (32 bits : ARM9/ARMv5 @396MHz
    overclocké
    @
    468MHz
    NoverII - Ndless + KhiCAS compatibilité Python)
  23. 11,26s
    :
    TI-83 Premium CE
    +
    TI-Python
    (8 + 32 bits : eZ80 @
    48MHz
    + Cortex-M0+/ARMv6 @
    48MHz
    CircuitPython)
  24. 16,05s
    :
    HP Prime G1
    (32 bits : ARM9/ARMv5 @
    400MHz
    CAS)
  25. 19,06s
    :
    Casio Graph 35+E II / fx-9750/9860GIII
    (32 bits : SH4 @58,98MHz
    overclocké
    @
    274,91MHz
    Ftune3 - KhiCAS)
  26. 22,77s
    :
    Casio Graph 90+E / fx-CG50
    (32 bits : SH4 @117,96MHz
    overclocké
    @
    270,77MHz
    Ptune3 - KhiCAS)
  27. 29,20s
    :
    TI-Nspire CX
    (révisions A-V)
    (32 bits : ARM9/ARMv5 @132MHz
    overclocké
    @
    222MHz
    Nover - Ndless + KhiCAS compatibilité Python)
  28. 30,85s
    :
    Casio fx-CG10/20
    (32 bits : SH4 @58,98MHz
    overclocké
    @
    267,78MHz
    Ptune2 - KhiCAS)
  29. 42,75s
    :
    NumWorks N0110
    (Omega + KhiCAS compatibilité Python)
  30. 53,24s
    :
    TI-Nspire CX CR4+
    (révisions W+)
    (32 bits : ARM9/ARMv5 @156MHz
    overclocké
    @
    216MHz
    Nover - Ndless + KhiCAS compatibilité Python)





Conclusion

Go to top

Clairement une mise à jour
HP Prime
colossale et historique, la plus importante mise à jour logicielle dans toute l'histoire de la calculatrice
HP Prime
, merci
Cyrille
et
Tim
! :favorite:

Énormément d'idées ont été mises en œuvre depuis deux ans et demi. Bien sûr pour les raisons que l'on sait le temps de développement a clairement manqué, beaucoup de nouveautés souffrant de
bugs
plus ou moins gênants ou encore de non conformité du comportement avec ce qu'indique l'aide en ligne. Mais c'est justement l'intérêt de cette ouverture des tests de validation au public.

Nous n'en retenons pas moins l'extraordinaire révolution du développement
HPPPL
! :bj:

Nous avons enfin le
Python
, certes qui arrive un peu tard, avec une interface encore légère et parfois problématique. Mais il ne s'agit pas moins d'une solution :
  • déjà très complète du point de vue de la quantité de fonctions intégrées
  • tout comme du point de vue de l'adéquation aux programmes scolaires
  • et extrêmement performante, anéantissant littéralement toute concurrence sur ce point ! :#tritop#:

N'oublions pas les incroyables possibilités d'interactions bidirectionnelles entre les différents langages et environnements
HPPPL / CAS / Python
de la calculatrice, un niveau d'intégration de loin jamais vu jusqu'à présent, du grand Art ! :#tritop#:

On pouvait jusqu'à présent reprocher de façon générale à la concurrence son manque d'intégration du
Python
. L'application
Python
arrivait comme un cheveu sur la soupe, tournant totalement dans son coin avec très peu d'interactions possibles avec le reste de l'environnement mathématique de la calculatrice quand ce n'était pas totalement impossible.

Le tout en parfaite contradiction avec l'esprit du logiciel de Mathématiques et de Sciences intégré de la calculatrice, puisque toutes les autres applications étaient interconnectées. Cela pouvait signifier que le constructeur avait décidé de rajouter le
Python
au dernier moment, sans prendre le temps de penser à son intégration.

Outre sa puissance et son caractère exhaustif, et même si l'on peut encore reprocher son interface à l'application
Python
, un point qui a clairement été pensé et travaillé à un niveau totalement inédit, c'est justement indiscutablement l'intégration du
Python
à l'environnement de la calculatrice et donc dans le processus de résolution de problèmes des élèves.

Si l'on ne devait retenir qu'une seule chose ce serait donc l'intégration du
Python
HP Prime
, clairement un exemple précurseur à suivre ! :D

On pouvait regretter dans la bêta précédente de gros défauts ou manques dans l'éditeur
Python
ainsi que dans sa console. Il reste encore du chemin à faire sur l'éditeur, mais concernant la console la
HP Prime
est en train de rattraper son retard sur la concurrence à une vitesse fulgurante ! :bj:

Par contre, si
Hewlett Packard
a encore envie de croire en la calculatrice
HP Prime
et de lui donner les moyens de réussir, il faudrait clairement des mises à jour plus fréquentes, même si elles seront alors bien sûr moins conséquentes prises individuellement.

Rester presque 3 ans sans évolution ne donne pas une bonne image du produit et ébranle la confiance des potentiels acheteurs. 2 ans et demi c'est long, c'est presque toute une scolarité au lycée... :#non#:




Téléchargements

Go to top


Source
:
https://www.hpmuseum.org/forum/thread-16821.html

TI-Nspire La démo Touhou Bad Apple maintenant sur TI-Nspire Ndless

New postby critor » 28 Apr 2021, 10:43

La
Touhou Bad Apple Demo
est un phénomène mondial depuis le début des années 2010 :
  • Tout commence en 1996 au Japon sur le microordinateur
    Nec PC-98
    avec
    Touhou Project
    , une série de jeux vidéo
    shoot 'em up
    extrêmes. En effet il s'agit d'un sous-genre particulièrement difficile, le
    manic shooter
    , où la globalité de l'écran est souvent littéralement tapissée de projectiles. La difficulté infernale n'empêche pas des qualités qui feront son énorme succès : un
    gameplay
    addictif, des visuels colorés, des personnages récurrents très typés
    mangas
    .
  • En 1998 sort le 4ème jeu de la série, , pour le moment toujours sur
    PC-98
    .
  • En 2007 la musique de fond de son 3ème niveau est remixée dans une version étendue par
    Masayoshi Minoshima
    , avec ajout de la voix de la chanteuse
    J-Pop Nomico
    .
  • En 2008,
    Nico Nico Douga
    publie un scénarimage d'une séquence animée mettant en jeu les personnages du monde
    Touhou
    et se voulant accompagner le remix.
En 2009 un groupe collaboratif conduit par
Anira
termine de mettre la chose en images. La séquence anime de façon extrêmement lisse des silhouettes en noir et blanc avec une esthétique
manga-magical-girl
. Le succès est immédiat et mondial.

Mais la séquence intéresse particulièrement la sphère des
demo makers
, la
Touhou Bad Apple Demo
était née. Les communautés de programmeurs rivalisent d'ingéniosité pour porter aussi fidèlement que possible la
Bad Apple Demo
sur nombre d'anciennes machines que l'on pensait incapables de jouer des vidéos.

L'affichage en noir et blanc rend en effet le défi hautement intéressant, permettant ici un bel éventail d'astuces techniques allégeant la complexité des algorithmes. Il n'y a que 2 couleurs, cela se prête a priori bien à une compression de chaque image en
RLE 1 bit
, mais en prime d'une image à la suivante il n'y a la plupart du temps qu'une large minorité de pixels qui changent de couleur, ce qui ouvre également la voie à des compressions au niveau de la vidéo.

C'est donc à qui combinera les meilleures astuces en fonction de la plateforme ciblée. On peut citer nombre d'exploits avec des portages :
  • pour microordinateurs remontant jusqu'au début des années 1980 :
    IBM 5150
    (1981)
    ,
    Commodore 64
    (1982)
    ,
    Atari STE
    (1985)
    , ...
  • pour consoles de jeux jusqu'à la fin des années 1970 :
    Atari 2600
    (1977)
    ,
    Vectrex
    (1982)
    ,
    Nintendo NES
    (1988)
    ,
    Sega Master System
    (1985)
    ,
    Sega Megadrive / Genesis
    (1988)
    , ...
Dans les communautés de calculatrices, nous n'avons pas échappé au phénomène. Et quoi de mieux à l'époque qu'une calculatrice graphique pour jouer une animation monochrome ? ;)
Nous ne retiendrons pour la suite que les démos
Bad Apple
effectivement
codées
pour les calculatrices sur lesquelles elles tournent.

C'est-à-dire que nous excluons d'autres façons de faire, comme :
  • les vidéos
    Bad Apple
    lues via un lecteur de vidéo
  • les
    homebrew
    Bad Apple
    jouées via un émulateur

C'est en
décembre 2013
que
fb39ca4
sort la première véritable démo
Bad Apple
du monde des calculatrices
Texas Instruments
, prenant la forme d'une application
.8xk
de
1,4 Mo
pour
TI-83 Plus
et
TI-84 Plus
monochromes.

Précisons qu'avec une telle taille, elle ne peut être installée que sur les modèles supérieurs offrant
1,5 Mo
de mémoire d'archive :
TI-83 Plus Silver Edition
,
TI-83 Plus.fr USB
,
TI-84 Plus Silver Edition
et
TI-84 Plus Pocket SE
.

Codée en langage assembleur
z80
, la démo jouée en plein écran
96×64
pixels impressionne de part sa fluidité et surtout inclut cette fois-ci enfin le son ! :favorite:

Le son est produit sur le port
mini-Jack 2.5
supprimé des modèles plus récents, et nécessite donc un adaptateur
mini-Jack 2.5
mâle ↔
mini-Jack 3.5
femelle.

À noter qu'il ne s'agit pas de la version originale mais, comme tu pourras vérifier sur la vidéo ci-dessous, d'un réarrangement instrumental
(style musique électronique MIDI)
adapté aux capacités de la machine et particulièrement au fait que nous n'avons maintenant quasiment plus de place en mémoire :

En 2015 c'est maintenant
ac100v
qui reprend le flambeau, mais cette fois-ci sur la scène
Casio
, avec ici encore une démo
Bad Apple
avec son et image ! :D

Elle prend la forme d'une application
.g1a
qui n'est pas compatible avec les dernières calculatrices de génération
USB Power Graphic 3
(
Graph 35+E II
et
fx-9750/9860GIII
)
, mais seulement avec les :
  • USB Power Graphic
    (processeur
    SH3
    -
    Graph 35+USB
    Graph 75/85/95
    fx-9750GII
    /
    fx-9860G/GII
    )
  • USB Power Graphic 2
    (processeur
    SH4
    -
    Graph 35+E/USB
    Graph 75/95
    fx-9750/9860GII
    )
L'application ne fait que 6 Ko mais va en fait chercher ses données dans 2 fichiers externes à transférer :
  • un fichier
    .vid
    de 535 Ko pour l'animation
  • et un fichier
    .aud
    de 770 Ko pour le son
Taille totale comparable de
1,27 Mo
ce qui occupe à nouveau une très grande partie de la mémoire de stockage.

L'écran est ici plus large que le format d'affichage de la démo, puisque faisant
128×64
pixels. La démo, ici codée en langage
C
, est en fait jouée en
85×64
pixels, laissant des bandes noires latérales n'ayant pas besoin d'être rafraichies, ce qui est justement une astuce d'optimisation.

Mais énorme surprise, ici nous avons droit à la piste audio originale grâce au même adaptateur ! :favorite:

La semaine dernière, nous sortait enfin la première démo
Bad Apple
sur calculatrice couleur, calculatrices graphiques à écran couleur ! :bj:

Il s'agissait ici d'une application
.g3a
dédiée à la
Casio Graph 90+E
ainsi qu'aux modèles internationaux ou plus anciens
fx-CG10/20/50
.

La démo est ici encore codée en langage
C
sur
64×56
pixels, puis affichée avec un grossissement de 4 sur
256×224
pixels, laissant donc ici une bande blanche à droite.

Cet exploit a remotivé et l'a poussé à enfin publier la démo
Bad Apple
320×240
pixels qu'il avait en développement pour calculatrice
NumWorks
sur la page des applications
Omega
.

En effet ici il y a nécessité d'installer le
firmware
tiers
Omega
, le seul à gérer l'ajout d'applications à ce jour, mais uniquement sur
NumWorks N0110
.

te porte aujourd'hui la démo
Bad Apple
pour les
TI-Nspire
utilisant le
jailbreak
Ndless
. L'écran étant au même format
320×240
pixels, il s'inspire du code
C
de .

Dommage par contre qu'il n'y ait pas le son ; il va falloir que nous rajoute ça : ;)


Téléchargements
:


-
Search
-
Social
-
Featured topics
Comparaisons des meilleurs prix pour acheter sa calculatrice !
Découvre les nouvelles fonctionnalités en Python de l'OS 5.2 pour les Nspire CX II
Découvre les nouvelles fonctionnalités en Python de l'OS 5.5 pour la 83PCE/84+C-T Python Edition
Omega, le fork étendant les capacités de ta NumWorks, même en mode examen !
1234
-
Donations / Premium
For more contests, prizes, reviews, helping us pay the server and domains...
Donate
Discover the the advantages of a donor account !
JoinRejoignez the donors and/or premium!les donateurs et/ou premium !


Partner and ad
Notre partenaire Jarrety Calculatrices à acheter chez Calcuso
-
Stats.
568 utilisateurs:
>545 invités
>17 membres
>6 robots
Record simultané (sur 6 mois):
6892 utilisateurs (le 07/06/2017)

-
Other interesting websites
Texas Instruments Education
Global | France
 (English / Français)
Banque de programmes TI
ticalc.org
 (English)
La communauté TI-82
tout82.free.fr
 (Français)