π
<-
Chat plein-écran
[^]

TI-z80 Stage pré-rentrée 2021 Python 83 Premium CE : liste sessions

New postby critor » 23 Aug 2021, 12:46

Enseignant de Mathématiques ou Sciences en lycée ? Les
vendredi 27
,
lundi 30
et
mardi 31 août 2021
,
Texas Instruments
t'invite à un stage de pré-rentrée en ligne entièrement gratuit. :D

Sur ces 3 jours, un choix formidable de pas moins de 12 sessions d'1 heure te sera proposé.

Note bien que tu jouis d'une totale liberté ; tu n'as aucune obligation de participer à l'intégralité des 12 sessions, tu pourras t'inscrire pour les sessions de ton choix, même 1 seule si tu veux ! :bj:

Le stage est dédié à la programmation
Python
sur
TI-83 Premium CE
, de quoi bien se mettre en jambe pour la rentrée. ;)

13073967713087Les sessions seront animées par nul autre que
Jérôme Lenoir
, enseignant bivalent de Mathématiques et Physique-Chimie en lycée professionnel.

Un fin connaisseur de la programmation
Python
sur
TI-83 Premium CE
, auteur de divers ouvrages d'activités à ce sujet, et qui saura sans nul doute répondre à tes diverses interrogations ! :bj:

Afin de te proposer une sélection de sessions la plus conforme possible à tes attentes,
Texas Instruments
t'avait proposé quelque chose d'inédit. Depuis début Juillet, tu avais la possibilité de voter pour les sessions que tu préférais parmi une 20aine de propositions.

Aujourd'hui,
Texas Instruments
nous révèle donc le calendrier des 12 sessions retenues pour cette rentrée 2021 :
  • Vendredi 27 août :

    • 8h00 :
      Présentation de la TI-83 Premium CE Édition Python et de l'écosystème, mise à jour, premiers pas avec l'application Python
    • 9h30 :
      Découverte des bibliothèques Python : raccourcis & utilisation
    • 13h00 :
      Utiliser les représentations graphiques via Python en mathématiques
    • 14h30 :
      Premiers exemples de scripts Python en mathématiques
  • Lundi 30 août :

    • 8h00 :
      Premiers exemples de scripts Python en physique-chimie
    • 9h30 :
      Les cartes à microcontrôleur (1/2) : fonctionnement du TI-Innovator Hub couplé à la TI-83 Premium CE
    • 13h00 :
      Les cartes à microcontrôleur (2/2) : fonctionnement de la BBC Micro bit couplé à la TI-83 Premium CE
    • 14h30 :
      Créer un scénario pédagogique de mathématiques incluant la programmation en Python dans la voie générale & technologique
  • Mardi 31 août :

    • 8h00 :
      Créer un scénario pédagogique de mathématiques incluant la programmation en Python dans la voie professionnelle
    • 9h30 :
      Hybrider une séquence intégrant algorithmique et programmation
    • 13h00 :
      Différencier son enseignement à l'aide de l'algorithmique et de la programmation
    • 14h30 :
      Échange avec les délégués pédagogiques TI
Les inscriptions sont dès maintenant ouvertes sur le lien ci-dessous.

Lien
:
inscription

Divers QCC 2021 Universel épisode 9: Performances Python

New postby critor » 23 Aug 2021, 10:02

Quelle Calculatrice Choisir 2021 édition Universelle

Épisode 9 - Performances Python

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

Nous en profitons de plus pour te réaliser le travail titanesque d'étendre les tests aux modèles plus anciens :
  • toutes les calculatrices graphiques
    Texas Instruments
    (depuis la première
    TI-81
    de 1990)
  • les calculatrices graphiques
    Casio
    de la génération
    Icon Menu Power Graphic
    (depuis 1996)
Ce qui donne pas moins de
163
modèles différents testés sous toutes leurs coutures, 10 ans de tests et découvertes à portée de clic ! :D

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

Contrairement aux langages constructeurs/historiques,
Python
distingue les nombres entiers des nombres flottants. Nous effectuerons 2 tests et chronométrerons leur durée :
  • un test de calcul en virgule flottante
  • un test de calcul sur des entiers

Dans un premier temps, nous allons évaluer les performances de calcul en virgule flottante. Voici la transcription en
Python
d'un algorithme de seuil sur une suite numérique, niveau Première :
Code: Select all
try:
  from time import *
except:
  pass

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

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

Nous appellerons seuil(0.008).

  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,99s
    :
    TI-83 Premium CE Edition Python
    (8 + 32 bits : eZ80 @
    48MHz
    + Cortex-M0+/ARMv6 @
    48MHz
    )
  10. 4,01s
    :
    TI-82 Advanced Edition Python
    (8 + 32 bits : eZ80 @
    48MHz
    + Cortex-M0+/ARMv6 @
    48MHz
    )
  11. 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
    (Delta / 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,99s
    :
    TI-83 Premium CE Edition Python
    (8 + 32 bits : eZ80 @
    48MHz
    + Cortex-M0+/ARMv6 @
    48MHz
    )
  13. 4,01s
    :
    TI-82 Advanced Edition Python
    (8 + 32 bits : eZ80 @
    48MHz
    + Cortex-M0+/ARMv6 @
    48MHz
    )
  14. 5,45s
    :
    TI-Nspire CX
    (révisions A-V)
    (32 bits : ARM9/ARMv5 @
    132MHz
    - Ndless + KhiCAS compatibilité Python)
  15. 6,69s
    :
    NumWorks N0110
    (Delta / Omega + KhiCAS compatibilité Python)
  16. 7,63s
    :
    TI-Nspire CX CR4+
    (révisions W+)
    (32 bits : ARM9/ARMv5 @
    156MHz
    - Ndless + KhiCAS compatibilité Python
  17. 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
    (Delta / 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,99s
    :
    TI-83 Premium CE Edition Python
    (8 + 32 bits : eZ80 @
    48MHz
    + Cortex-M0+/ARMv6 @
    48MHz
    )
  13. 4,01s
    :
    TI-82 Advanced Edition Python
    (8 + 32 bits : eZ80 @
    48MHz
    + Cortex-M0+/ARMv6 @
    48MHz
    )
  14. 4,13s
    :
    TI-Nspire CX
    (révisions A-V)
    (32 bits : ARM9/ARMv5 @132MHz
    overclocké
    @
    222MHz
    Nover - Ndless + KhiCAS compatibilité Python)
  15. 6,69s
    :
    NumWorks N0110
    (Delta / Omega + KhiCAS compatibilité Python)
  16. 7,19s
    :
    TI-Nspire CX CR4+
    (révisions W+)
    (32 bits : ARM9/ARMv5 @156MHz
    overclocké
    @
    216MHz
    Nover - Ndless + KhiCAS compatibilité Python)
  17. 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,99s
    :
    TI-83 Premium CE Edition Python / TI-84 Plus CE Python Edition
    (8 + 32 bits : eZ80 @
    48MHz
    + Cortex-M0+/ARMv6 @
    48MHz
    )
  11. 4,01s
    :
    TI-82 Advanced Edition Python
    (8 + 32 bits : eZ80 @
    48MHz
    + Cortex-M0+/ARMv6 @
    48MHz
    )
  12. 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
    (Delta / 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,99s
    :
    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,01s
    :
    TI-82 Advanced Edition Python
  23. 4,4s
    :
    TI-83 Premium CE
    +
    TI-Python
    (8 + 32 bits : eZ80 @
    48MHz
    + Cortex-M0+/ARMv6 @
    48MHz
    CircuitPython)
  24. 5,29s
    :
    Casio Graph 35/75/85/95 / fx-9750/9860GII / fx-9860G
    (32 bits : SH3 @
    29,49MHz
    - CasioPython)
  25. 5,45s
    :
    TI-Nspire CX
    (révisions A-V)
    (32 bits : ARM9/ARMv5 @
    132MHz
    - Ndless + KhiCAS compatibilité Python)
  26. 5,48s
    :
    Casio Graph 90+E / fx-CG50
    (32 bits : SH4 @
    117,96MHz
    - KhiCAS)
  27. 6,69s
    :
    NumWorks N0110
    (Delta / Omega + KhiCAS compatibilité Python)
  28. 9,21s
    :
    Casio Graph 35+E II / fx-9750/9860GIII
    (32 bits : SH4 @
    58,98MHz
    )
  29. 13,93s
    :
    Casio Graph 35+E II / fx-9750/9860GIII
    (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)
  31. 15,05s
    :
    Casio fx-CG10/20
    (32 bits : SH4 @
    58,98MHz
    - KhiCAS)
  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
    (Delta / 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,99s
    :
    TI-83 Premium CE Edition Python / TI-84 Plus CE Python Edition
    (8 + 32 bits : eZ80 @
    48MHz
    + Cortex-M0+/ARMv6 @
    48MHz
    )
  27. 4,01s
    :
    TI-82 Advanced Edition Python
  28. 4,13s
    :
    TI-Nspire CX
    (révisions A-V)
    (32 bits : ARM9/ARMv5 @132MHz
    overclocké
    @
    222MHz
    Nover - Ndless + KhiCAS compatibilité Python)
  29. 4,4s
    :
    TI-83 Premium CE
    +
    TI-Python
    (8 + 32 bits : eZ80 @
    48MHz
    + Cortex-M0+/ARMv6 @
    48MHz
    CircuitPython)
  30. 6,69s
    :
    NumWorks N0110
    (Delta / Omega + KhiCAS compatibilité Python)
  31. 7,19s
    :
    TI-Nspire CX CR4+
    (révisions W+)
    (32 bits : ARM9/ARMv5 @156MHz
    overclocké
    @
    216MHz
    Nover - Ndless + KhiCAS compatibilité Python)

Passons maintenant aux entiers avec un test de primalité, que voici en
Python
:
Code: 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

Nous appellerons ici isprimep(10000019).

  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. 8,91s
    :
    TI-83 Premium CE Edition Python
    (8 + 32 bits : eZ80 @
    48MHz
    + Cortex-M0+/ARMv6 @
    48MHz
    )
  10. 9,22s
    :
    TI-82 Advanced Edition Python
    (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,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
    (Delta / 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. 8,91s
    :
    TI-83 Premium CE Edition Python
    (8 + 32 bits : eZ80 @
    48MHz
    + Cortex-M0+/ARMv6 @
    48MHz
    )
  13. 9,22s
    :
    TI-82 Advanced Edition Python
    (8 + 32 bits : eZ80 @
    48MHz
    + Cortex-M0+/ARMv6 @
    48MHz
    )
  14. 16,05s
    :
    HP Prime G1
    (32 bits : ARM9/ARMv5 @
    400MHz
    CAS)
  15. 36,26s
    :
    TI-Nspire CX
    (révisions A-V)
    (32 bits : ARM9/ARMv5 @
    132MHz
    - Ndless + KhiCAS compatibilité Python)
  16. 42,75s
    :
    NumWorks N0110
    (Delta / Omega + KhiCAS compatibilité Python)
  17. 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
    (Delta / 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. 8,91s
    :
    TI-83 Premium CE Edition Python
    (8 + 32 bits : eZ80 @
    48MHz
    + Cortex-M0+/ARMv6 @
    48MHz
    )
  13. 9,22s
    :
    TI-82 Advanced Edition Python
    (8 + 32 bits : eZ80 @
    48MHz
    + Cortex-M0+/ARMv6 @
    48MHz
    )
  14. 16,05s
    :
    HP Prime G1
    (32 bits : ARM9/ARMv5 @
    400MHz
    CAS)
  15. 29,20s
    :
    TI-Nspire CX
    (révisions A-V)
    (32 bits : ARM9/ARMv5 @132MHz
    overclocké
    @
    222MHz
    Nover - Ndless + KhiCAS compatibilité Python)
  16. 42,75s
    :
    NumWorks N0110
    (Delta / Omega + KhiCAS compatibilité Python)
  17. 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. 8,91s
    :
    TI-83 Premium CE Edition Python / TI-84 Plus CE Python Edition
    (8 + 32 bits : eZ80 @
    48MHz
    + Cortex-M0+/ARMv6 @
    48MHz
    )
  11. 9,22s
    :
    TI-82 Advanced Edition Python
    (8 + 32 bits : eZ80 @
    48MHz
    + Cortex-M0+/ARMv6 @
    48MHz
    )
  12. 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,581s
    :
    NumWorks N0110
    (32 bits : Cortex-M7/ARMv7 @
    216MHz
    )
  7. 0,62s
    :
    TI-Nspire CX
    (révisions A-V)
    (32 bits : ARM9/ARMv5 @
    132MHz
    - Ndless + MicroPython)
  8. 0,67s
    :
    TI-Nspire
    (32 bits : ARM9/ARMv5 @
    120MHz
    - Ndless + MicroPython)
  9. 0,715s
    :
    NumWorks N0110
    (Delta / Omega + KhiCAS Micropython)
  10. 0,794s
    :
    TI-Nspire CX
    (révisions A-V)
    (32 bits : ARM9/ARMv5 @
    132MHz
    - Ndless + KhiCAS Micropython)
  11. 0,99s
    :
    TI-Nspire CX CR4+
    (révisions W+)
    (32 bits : ARM9/ARMv5 @
    156MHz
    - Ndless + MicroPython)
  12. 1,17s
    :
    NumWorks N0100
    (32 bits : Cortex-M4/ARMv7 @
    100MHz
    )
  13. 1,18s
    :
    TI-Nspire CX CR4+
    (révisions W+)
    (32 bits : ARM9/ARMv5 @
    156MHz
    - Ndless + KhiCAS Micropython)
  14. 1,58s
    :
    Casio Graph 90+E / fx-CG50
    (32 bits : SH4 @
    117,96MHz
    )
  15. 3,04s
    :
    Casio Graph 35+E II / fx-9750/9860GIII
    (32 bits : SH4 @
    58,98
    - CasioPython)
  16. 4,39s
    :
    Casio Graph 35+E II / fx-9750/9860GIII
    (32 bits : SH4 @
    58,98MHz
    )
  17. 4,42s
    :
    HP Prime G2
    (32 bits : Cortex-A7/ARMv7 @
    528MHz
    CAS)
  18. 4,89s
    :
    Casio Graph 35/75+E / 35/75/95 / fx-9750/9860GII
    (32 bits : SH4 @
    29,49MHz
    - CasioPython)
  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. 8,91s
    :
    TI-83 Premium CE Edition Python / TI-84 Plus CE Python Edition
    (8 + 32 bits : eZ80 @
    48MHz
    + Cortex-M0+/ARMv6 @
    48MHz
    )
  22. 9,22s
    :
    TI-82 Advanced Edition Python
    (8 + 32 bits : eZ80 @
    48MHz
    + Cortex-M0+/ARMv6 @
    48MHz
    )
  23. 11,26s
    :
    TI-83 Premium CE
    +
    TI-Python
    (8 + 32 bits : eZ80 @
    48MHz
    + Cortex-M0+/ARMv6 @
    48MHz
    CircuitPython)
  24. 11,62s
    :
    TI-Nspire CX II
    (32 bits : ARM9/ARMv5 @
    396MHz
    - Ndless + KhiCAS compatibilité Python)
  25. 16,05s
    :
    HP Prime G1
    (32 bits : ARM9/ARMv5 @
    400MHz
    CAS)
  26. 32,76s
    :
    Casio Graph 90+E / fx-CG50
    (32 bits : SH4 @
    117,96MHz
    - KhiCAS)
  27. 36,26s
    :
    TI-Nspire CX
    (révisions A-V)
    (32 bits : ARM9/ARMv5 @
    132MHz
    - Ndless + KhiCAS compatibilité Python)
  28. 42,75s
    :
    NumWorks N0110
    (Delta / Omega + KhiCAS compatibilité Python)
  29. 53,24s
    :
    TI-Nspire CX CR4+
    (révisions W+)
    (32 bits : ARM9/ARMv5 @
    156MHz
    - Ndless + KhiCAS compatibilité Python)
  30. 91,71s
    :
    Casio Graph 35+E II / fx-9750/9860GIII
    (32 bits : SH4 @
    58,98MHz
    - KhiCAS)
  31. 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
    (Delta / 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. 8,91s
    :
    TI-83 Premium CE Edition Python / TI-84 Plus CE Python Edition
    (8 + 32 bits : eZ80 @
    48MHz
    + Cortex-M0+/ARMv6 @
    48MHz
    )
  22. 9,22s
    :
    TI-82 Advanced Edition Python
    (8 + 32 bits : eZ80 @
    48MHz
    + Cortex-M0+/ARMv6 @
    48MHz
    )
  23. 9.964s
    :
    TI-Nspire CX II
    (32 bits : ARM9/ARMv5 @396MHz
    overclocké
    @
    468MHz
    NoverII - Ndless + KhiCAS compatibilité Python)
  24. 11,26s
    :
    TI-83 Premium CE
    +
    TI-Python
    (8 + 32 bits : eZ80 @
    48MHz
    + Cortex-M0+/ARMv6 @
    48MHz
    CircuitPython)
  25. 16,05s
    :
    HP Prime G1
    (32 bits : ARM9/ARMv5 @
    400MHz
    CAS)
  26. 19,06s
    :
    Casio Graph 35+E II / fx-9750/9860GIII
    (32 bits : SH4 @58,98MHz
    overclocké
    @
    274,91MHz
    Ftune3 - KhiCAS)
  27. 22,77s
    :
    Casio Graph 90+E / fx-CG50
    (32 bits : SH4 @117,96MHz
    overclocké
    @
    270,77MHz
    Ptune3 - KhiCAS)
  28. 29,20s
    :
    TI-Nspire CX
    (révisions A-V)
    (32 bits : ARM9/ARMv5 @132MHz
    overclocké
    @
    222MHz
    Nover - Ndless + KhiCAS compatibilité Python)
  29. 30,85s
    :
    Casio fx-CG10/20
    (32 bits : SH4 @58,98MHz
    overclocké
    @
    267,78MHz
    Ptune2 - KhiCAS)
  30. 42,75s
    :
    NumWorks N0110
    (Delta / Omega + KhiCAS compatibilité Python)
  31. 53,24s
    :
    TI-Nspire CX CR4+
    (révisions W+)
    (32 bits : ARM9/ARMv5 @156MHz
    overclocké
    @
    216MHz
    Nover - Ndless + KhiCAS compatibilité Python)

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

Divers CCC 2021 épisode 8: NumWorks, TI-Nspire CX, HP Prime

New postby critor » 22 Aug 2021, 09:45

Combien Consomme ma Calculatrice 2021

Épisode 8 - NumWorks, TI-Nspire CX, HP Prime

index des épisodes

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

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

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

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

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

Ici il s'agit donc d'une mesure ponctuelle que nous relèverons une fois stabilisée sous 3 situations :
  • Calculatrice éteinte
  • Calculatrice allumée mais inoccupée
  • Calculatrice en train d'effectuer un calcul suffisamment long
    Nous choisissons en mode degrés :
    $mathjax$\sum{\sqrt[3]{e^{sin\left(Arctan\left(x\right)\right)}}}$mathjax$
Ne pouvant effectuer de moyenne avec cet appareil, nous n'activerons pas le mode examen.

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

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

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

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

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

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

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

Dans notre base de données
QCC
, les
HP Prime
sont scindées en 3 suite à des changements matériels d'importance, susceptibles d'influer sur la consommation :
  • HP Prime G1
    révision
    A
  • HP Prime G1
    révision
    C
    (mode
    USB
    hôte pour la gestion des périphériques
    USB
    )
  • HP Prime G2
    révision
    D
    (nouveau processeur passant de
    400 MHz
    à
    528 MHz
    )

Nous effectuons donc les mesures sur une calculatrice de chaque :
HP Prime G1-A
éclairage
minimal
éclairage
maximal
éteinte
1.800 mA
inoccupée
72.400 mA
100.600 mA
calcul
111.000 mA
140.000 mA

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

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

En 10 ans de
TI-Nspire CX
nous avons ici aussi eu droit à plusieurs évolutions matérielles significatives. Notre base de données
QCC
scinde ces modèles en 4 :
  • TI-Nspire CX
    révisions
    ≤N
  • TI-Nspire CX
    révisions
    O-V
    (remplacement de la batterie à câble par une nouvelle batterie type
    Samsung
    )
  • TI-Nspire CX
    révisions
    W+
    (accélération du processeur de
    132 MHz
    à
    156 MHz
    + nouvel écran)
  • TI-Nspire CX II
    (nouveau processeur passant de
    156 MHz
    à
    396 MHz
    )

Nous effectuons ici les mesures sur plusieurs calculatrices de chaque, et retenons la moyenne :
TI-Nspire CX rév.≤N
éclairage
minimal
éclairage
maximal
éteinte
35.000 mA
inoccupée
50.775 mA
92.550 mA
calcul
57.350 mA
99.350 mA

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

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

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

Et enfin, terminons avec les
NumWorks
. Nous les scindons en 2 :
  • NumWorks N0100
  • NumWorks N0110
    (nouveau processeur passant de
    100 MHz
    à
    216 MHz
    )

Elles sont très embêtantes, dans le sens où il nous faut ici les démonter pour déconnecter la batterie. Mais le pire c'est sur la
N0100
:
  • la batterie doit être déconnectée alors que la calculatrice est déjà allumée et alimentée en
    USB
    , sinon la machine démarre en mode de récupération avec l'écran éteint
  • de plus, au remontage, il suffit de serrer les vis d'une fraction de millimètre de trop pour fendre le boîtier tellement il est fragile :mj:

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

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

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

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

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

Rapidement, parmi les modèles monochromes actuels sur piles :
  • le meilleur semble être les
    Casio Graph 25/35+E II
    :bj:
  • et le pire la
    TI-82 Advanced
Bien que les valeurs mesurées soient très proches, la différence se fera de plus en plus sentir avec le temps.

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

Décidément, quelque soit le groupe de modèles comparés, les produits
Casio
semblent être les plus économiques et écologiques, félicitations ! :bj:
C'est peut-être lié au label que
Casio
décerne en interne chaque année à ses produits les plus performants en terme de critères écologiques, dont les calculatrices
Graph 35+E II
en 2019 et
fx-9860GIII
en 2020.

Casio CCC 2021 épisode 7: Casio fx-CP400+E

New postby critor » 21 Aug 2021, 20:59

Combien Consomme ma Calculatrice 2021

Épisode 7 - Casio fx-CP400+E

index des épisodes

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

Voici la suite de l'événement dans l'événement, le
CCC 2021
, pour
Combien Consomme ma Calculatrice
.

49544973Mais pourquoi donc cette série ? Le
mardi 31 mars 2015
, suite à une annonce sur
leboncoin
, nous avions réussi à te récupérer une
Casio Graph 75+E
, avant même l'annonce officielle de ce nouveau modèle. Les nouveautés comportaient un mode examen dont le bon fonctionnement était indiqué par le clignotement d'une diode examen. L'emballage annonçait une conformité à une nouvelle réglementation des examens à compter de 2018, alors non encore publiée. Le Bulletin Officiel avec les derniers textes officiels paraissant chaque jeudi matin il nous fallait faire vite. Nous t'avions donc testé la
Graph 75+E
tout notre mercredi après-midi, et finalisé la publication pour 2 heures du matin. Et nous avions bien fait, quelques heures plus tard la première circulaire relative au mode examen allait effectivement être publiée.

Une mention dans le guide de prise en main nous avait toutefois grandement surpris :
Casio wrote:
  • La mise en place d'un jeu de piles neuves est recommandée avant d'utiliser le Mode Examen.
  • La LED clignote lorsque la calculatrice est en mode Examen, de sorte que davantage d'énergie est utilisée. Veillez à quitter le mode Examen dès que possible une fois la session d'examen terminée.

Une pauvre petite diode allumée par intermittence, est-ce vraiment censé augmenter aussi significativement la consommation de la calculatrice ? Nous traiterons donc ici entre autres de la surconsommation induite par l'activation du mode examen.

Nous terminons aujourd'hui avec le dernier modèle à piles
AAA
, la
Casio fx-CP400+E
.

1451414513Niveau protocole, nous allons effectuer les mesures à l'aide d'une
TI-Nspire CX II
. Nous allons mesurer l'intensité, et utiliserons pour cela un capteur d'intensité
Vernier
. Muni d'une prise
BT-A
(le standard historique de téléphonie analogique chez
British Telecom
)
, il nous faut une interface pour le connecter à notre calculatrice, comme par exemple le
Vernier EasyLink
.

14515Problème suivant, un ampèremètre cela se branche en série. Comment faire donc pour couper le circuit de chaque calculatrice testée afin d'y intercaler le capteur d'intensité, tout en permettant à cette dernière de continuer à fonctionner ?

Nous allons utiliser un éliminateur de piles
AAA
modifié à cette fin. Une fausse pile
AAA
permet d'ouvrir le circuit, et il suffit alors de connecter en série à ses bornes un réceptacle pour la 4ème pile
AAA
alors manquante, ainsi que le capteur d'intensité.

Le gros avantage est donc qu'il n'y a aucune soudure ou modification à effectuer sur les calculatrices testées.

1451714518Et voilà donc à quoi ressemble le montage final.

Nous configurons la
TI-Nspire CX II
pour effectuer :
  • 50 mesures par seconde
  • pendant une durée de 29 secondes
    (car plusieurs modèles passent en mode économie d'énergie après 30 secondes d'inutilisation)
Nous retiendrons la valeur moyenne.
14516Comme pour les autres modèles, les mesures seront effectuées avec des piles neuves identiques d'au moins
1,60V
de tension à vide.

Nous allons effectuer les mesures sous différentes conditions :
  • Calculatrice éteinte
    (hors mode examen + en mode examen)
  • Calculatrice allumée mais inoccupée
    (hors mode examen + en mode examen)
  • Calculatrice en train d'effectuer un calcul suffisamment long
    (hors mode examen + en mode examen)

    Nous choisissons en mode degrés :
    $mathjax$\sum{\sqrt[3]{e^{sin\left(Arctan\left(x\right)\right)}}}$mathjax$

De plus, lorsque possible nous effectuerons les mesures sous différents réglages de la luminosité de l'écran :
  • maximal
  • par défaut
  • minimal
  • en économie d'énergie

Éteinte, la
Casio fx-CP400+E
tire
0,112 mA
.

Une fois le mode examen activé, la diode examen s'allume toutes les 2 secondes comme illustré sur le diagramme ci-contre. Cela fait monter l'intensité moyenne mesurée à
1,217 mA
.

Plusieurs niveaux d'éclairage de l'écran peuvent être obtenus très facilement, la plupart via l'application
Système
. Nous retiendrons :
  • luminosité maximale avec un réglage de l'éclairage à
    13/13
  • luminosité par défaut intermédiaire avec le bouton
    reset
    au dos, ou encore par un réglage à
    7/13
  • luminosité minimale avec un réglage à
    1/13
  • mode économie d'énergie après 30 secondes d'inutilisation, baissant l'éclairage à un niveau compté en interne comme un réglage à
    0/13
    , inaccessible via le menu

Voici dans ce même ordre, les intensités relevées en fonctionnement sous chacune de ces configurations :


Casio fx-CP400+E
hors
mode examen
en
mode examen
éclairage
écran
éteinte
0,112 mA
1,217 mA
(+987,69%)
inoccupée
24,240 mA
16,432 mA
10,900 mA
4,707 mA
24,623 mA
(+1,58%)

16,690 mA
(+1,57%)

11,120 mA
(+2,02%)

4,783 mA
(+1,62%)
maximal
par défaut
minimal
économique
calcul
42,651 mA
34,361 mA
28,730 mA
42,933 mA
(+0,66%)

34,989 mA
(+1,83%)

29,010 mA
(+0,98%)
maximal
par défaut
minimal

Comme sur certains modèles à écran couleur, nous n'avons pas moyen de rerégler la luminosité par défaut, nous retenons pour les comparaisons les mesures effectuées sous la luminosité maximale.

Par rapport à la concurrence sur piles et à son grand écran couleur tactile éclairé, avec la
fx-CP400+E
Casio
nous signe une fois de plus un modèle relativement économe en énergie ! :bj:

Tableau comparatif :
Accès
QCC 2021 Universel
Link to topic: CCC 2021 épisode 7: Casio fx-CP400+E (Comments: 0)

Casio CCC 2021 épisode 6: Casio Graph 90+E

New postby critor » 21 Aug 2021, 18:36

Combien Consomme ma Calculatrice 2021

Épisode 6 - Casio Graph 90+E

index des épisodes

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

Voici la suite de l'événement dans l'événement, le
CCC 2021
, pour
Combien Consomme ma Calculatrice
.

Nous nous intéressons pour le moment à la consommation des seuls modèles à piles
AAA
.

49544973Mais pourquoi donc cette série ? Le
mardi 31 mars 2015
, suite à une annonce sur
leboncoin
, nous avions réussi à te récupérer une
Casio Graph 75+E
, avant même l'annonce officielle de ce nouveau modèle. Les nouveautés comportaient un mode examen dont le bon fonctionnement était indiqué par le clignotement d'une diode examen. L'emballage annonçait une conformité à une nouvelle réglementation des examens à compter de 2018, alors non encore publiée. Le Bulletin Officiel avec les derniers textes officiels paraissant chaque jeudi matin il nous fallait faire vite. Nous t'avions donc testé la
Graph 75+E
tout notre mercredi après-midi, et finalisé la publication pour 2 heures du matin. Et nous avions bien fait, quelques heures plus tard la première circulaire relative au mode examen allait effectivement être publiée.

Une mention dans le guide de prise en main nous avait toutefois grandement surpris :
Casio wrote:
  • La mise en place d'un jeu de piles neuves est recommandée avant d'utiliser le Mode Examen.
  • La LED clignote lorsque la calculatrice est en mode Examen, de sorte que davantage d'énergie est utilisée. Veillez à quitter le mode Examen dès que possible une fois la session d'examen terminée.

Une pauvre petite diode allumée par intermittence, est-ce vraiment censé augmenter aussi significativement la consommation de la calculatrice ? Nous traiterons donc ici entre autres de la surconsommation induite par l'activation du mode examen.

Nous nous sommes déjà occupés des
Casio Graph
monochromes
,
TI-Nspire
monochromes
,
TI-82 Advanced
monochrome
,
TI-82 Advanced Edition Python
,
Lexibook GC3000FR
et
Esquisse GCEXFR
.

Voici aujourd'hui ce que consomme la
Casio Graph 90+E
.

1451414513Niveau protocole, nous allons effectuer les mesures à l'aide d'une
TI-Nspire CX II
. Nous allons mesurer l'intensité, et utiliserons pour cela un capteur d'intensité
Vernier
. Muni d'une prise
BT-A
(le standard historique de téléphonie analogique chez
British Telecom
)
, il nous faut une interface pour le connecter à notre calculatrice, comme par exemple le
Vernier EasyLink
.

14515Problème suivant, un ampèremètre cela se branche en série. Comment faire donc pour couper le circuit de chaque calculatrice testée afin d'y intercaler le capteur d'intensité, tout en permettant à cette dernière de continuer à fonctionner ?

Nous allons utiliser un éliminateur de piles
AAA
modifié à cette fin. Une fausse pile
AAA
permet d'ouvrir le circuit, et il suffit alors de connecter en série à ses bornes un réceptacle pour la 4ème pile
AAA
alors manquante, ainsi que le capteur d'intensité.

Le gros avantage est donc qu'il n'y a aucune soudure ou modification à effectuer sur les calculatrices testées.

1451714518Et voilà donc à quoi ressemble le montage final.

Nous configurons la
TI-Nspire CX II
pour effectuer :
  • 50 mesures par seconde
  • pendant une durée de 29 secondes
    (car plusieurs modèles passent en mode économie d'énergie après 30 secondes d'inutilisation)
Nous retiendrons la valeur moyenne.
14516Comme pour les autres modèles, les mesures seront effectuées avec des piles neuves identiques d'au moins
1,60V
de tension à vide.

Nous allons effectuer les mesures sous différentes conditions :
  • Calculatrice éteinte
    (hors mode examen + en mode examen)
  • Calculatrice allumée mais inoccupée
    (hors mode examen + en mode examen)
  • Calculatrice en train d'effectuer un calcul suffisamment long
    (hors mode examen + en mode examen)

    Nous choisissons en mode degrés :
    $mathjax$\sum{\sqrt[3]{e^{sin\left(Arctan\left(x\right)\right)}}}$mathjax$

De plus, lorsque possible nous effectuerons les mesures sous différents réglages de la luminosité de l'écran :
  • maximal
  • par défaut
  • minimal
  • en économie d'énergie

Éteinte, la
Casio Graph 90+E
tire
0,747 mA
.

Une fois le mode examen activé, la diode examen s'allume toutes les 2 secondes. Sur le diagramme ci-contre, ce comportement n'est pas aussi net que pour d'autres modèles. La calculatrice réaliserait-elle également d'autres choses en mode examen ? Dans tous les cas cela fait monter l'intensité moyenne mesurée à
1,310 mA
.

Plusieurs niveaux d'éclairage de l'écran peuvent être obtenus très facilement, la plupart via l'application
Système
. Nous retiendrons :
  • luminosité maximale avec un réglage de l'éclairage à
    5/5
  • luminosité par défaut intermédiaire avec le bouton
    reset
    au dos, ou encore par un réglage à
    3/5
  • luminosité minimale avec un réglage à
    1/5
  • mode économie d'énergie après 30 secondes d'inutilisation :
    • hors mode examen cela baisse encore l'éclairage de l'écran à un niveau compté comme un réglage à
      0/5
      , inaccessible via le menu
    • en mode examen toutefois, cela ne baisse l'éclairage qu'à un niveau de
      1/5

Voici dans ce même ordre, les intensités relevées en fonctionnement sous chacune de ces configurations :


Casio Graph 90+E
hors
mode examen
en
mode examen
éclairage
écran
éteinte
0,747 mA
1,310 mA
(+75,40%)
inoccupée
10,667 mA
7,215 mA
5,518 mA
4,740 mA
11,312 mA
(+6,05%)

7,876 mA
(+9,16%)

5,986 mA
(+8,49%)

5,986 mA
(+26,29%)
maximal
par défaut
minimal
économique
calcul
27,792 mA
24,239 mA
22,296 mA
28,035 mA
(+0,88%)

24,421 mA
(+0,75%)

22,296 mA
(+0,84%)
maximal
par défaut
minimal

Comme sur certains modèles à écran couleur, nous n'avons pas moyen de rerégler la luminosité par défaut, nous retenons pour les comparaisons les mesures effectuées sous la luminosité maximale.

La
Casio Graph 90+E
couleur est absolument fantastique ! :D

Malgré son processeur beaucoup plus puissant comme nous avons vu, elle consomme finalement selon les situations de 2 à 10 fois moins que la
TI-82 Advanced Edition Python
que l'on aurait pourtant pu penser similaire ! :o

Certes, l'écran de la
Casio Graph 90+E
est l'un des moins lumineux toute concurrence confondue, mais comme nous avons également vu ce n'est de façon générale pas l'écran qui consomme le plus, mais le processeur.

Tableau comparatif :
Accès
QCC 2021 Universel
Link to topic: CCC 2021 épisode 6: Casio Graph 90+E (Comments: 0)

Divers QCC 2021 Universel épisode 8: écrans et profondeurs

New postby critor » 20 Aug 2021, 12:45

Quelle Calculatrice Choisir 2021 édition Universelle

Épisode 8 - Écrans et profondeurs

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

Nous en profitons de plus pour te réaliser le travail titanesque d'étendre les tests aux modèles plus anciens :
  • toutes les calculatrices graphiques
    Texas Instruments
    (depuis la première
    TI-81
    de 1990)
  • toutes les calculatrices graphiques
    Casio
    à technologie
    Flash
    (depuis 2003)
Ce qui donne pas moins de
136
modèles différents de calculatrices testés sous toutes leurs coutures, 10 ans de tests et découvertes à portée de clic ! :D

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

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

D'une part, voici les modèles à cristaux liquides bleus souffrant en conséquence d'une lisibilité assez pénible sans un excellent éclairage extérieur :
  • Esquisse GCEXFR
  • Lexibook GC3000FR
  • Casio Graph 25+E
1149712780

Et voici les modèles à cristaux liquides noirs, de bien meilleure lisibilité :
  • Casio Graph 25+E II
  • Casio Graph 35+E
  • Casio Graph 35+E II
  • Casio Graph 75+E
  • TI-82 Advanced
  • TI-84 Plus T
  • Casio fx-92+ Spéciale Collège
12588716611396

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

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

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

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

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


Un appel color_mode = get_color_mode() pourra donc renvoyer par exemple :
  • 0 :
    pour un codage des couleurs par des tuples
    (r,g,b)
  • 15 :
    pour un codage des couleurs sur des entiers de 15 bits
  • 16 :
    pour un codage des couleurs sur des entiers de 16 bits
  • 24 :
    pour un codage des couleurs sur des entiers de 24 bits
  • ...

Pour notre script universel il faudra bien choisir un codage plutôt qu'un autre, alors prévoyons une fonction de conversion :
Code: 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 de quoi tracer des lignes verticales et horizontales :
Code: Select all
def draw_vline(x, y1, y2, c):
  for j in range(y2 - y1 + 1):
    set_pixel(x, y1 + j, c)

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


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

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


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

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

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

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

12795Voici donc ci-contre l'affichage de l'appel associé mire(320,240,30). On peut noter que le vert ainsi que les couleurs composées de vert
(cyan, jaune et blanc)
ont un dégradé beaucoup moins saccadé, beaucoup plus fluide. En effet si tu regardes bien elles utilisent 2 fois plus de teintes intermédiaires, très exactement 64 teintes contre 32 pour les autres :
  • canal rouge sur
    5
    bits pour
    25= 32
    teintes
  • canal vert sur
    6
    bits pour
    26= 64
    teintes
  • canal bleu sur
    5
    bits pour
    25= 32
    teintes
Total donc
16
bits pour
216= 65536
couleurs affichables, et un contrôleur écran fonctionnant donc au format
RGB 565
.

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

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

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

12826Appelons donc mire(384,192). Même constat ici, nous notons 2 fois plus de teintes intermédiaires pour les dégradés de vert et de couleurs incluant du vert :
  • canal rouge sur
    5
    bits pour
    25= 32
    teintes
  • canal vert sur
    6
    bits pour
    26= 64
    teintes
  • canal bleu sur
    5
    bits pour
    25= 32
    teintes
Total donc
16
bits pour
216= 65536
couleurs affichables, et un contrôleur écran fonctionnant donc au format
RGB 565
.

Arrive maintenant la
NumWorks
.

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

12836Appelons mire(320,222). Encore pareil, 2 fois plus de teintes intermédiaires dans le vert :
  • canal rouge sur
    5
    bits pour
    25= 32
    teintes
  • canal vert sur
    6
    bits pour
    26= 64
    teintes
  • canal bleu sur
    5
    bits pour
    25= 32
    teintes
Total donc
16
bits pour
216= 65536
couleurs affichables, et un contrôleur écran fonctionnant donc au format
RGB 565
.

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

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

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

12857Appelons donc mire(318,212). Toujours 2 fois plus de teintes intermédiaires tirant sur le vert :
  • canal rouge sur
    5
    bits pour
    25= 32
    teintes
  • canal vert sur
    6
    bits pour
    26= 64
    teintes
  • canal bleu sur
    5
    bits pour
    25= 32
    teintes
Total donc
16
bits pour
216= 65536
couleurs affichables, et un contrôleur écran fonctionnant donc au format
RGB 565
.

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

Adaptons donc notre mire dans le langage de script
Lua
:
Code: Select all
o = false
s = 1

function on.charIn(c)
  print(c)
  olds, oldo = s, o
  if c == "−" or c == "-" then
    s = -1
  elseif c == "+" then
    s = 1
  elseif c == "0" then
    s = 0
  elseif c == "*" or c == "/" then
    o = not o
  end
  if s ~= olds or o ~= oldo then
    platform.window.invalidate()
  end
end

function on.resize(w, h)
  platform.window.invalidate()
end

function color8(j, v)
  l={0, 0, 0}
  for k = 1, #l do
    if math.floor(j / 2^(k - 1)) % 2 ~= 0 then
      l[k] = v
    end
  end
  return l
end

function on.paint(gc)
  pw = platform.window
  w, h = pw.width(), pw.height()
  if o then
    l1, l2 = h, w
    function f(gc, y, x1, x2, c)
      gc:setColorRGB(c[1], c[2], c[3])
      gc:drawRect(x1, y, x2, y)
    end
  else
    l1, l2 = w, h
    function f(gc, x, y1, y2, c)
      gc:setColorRGB(c[1], c[2], c[3])
      gc:drawRect(x, y1, x, y2)
    end
  end
  n = 8
  for m = 0, l1 - 1 do
    v = 255
    if s ~=0 then
      v = v * (s * m % l1) / (l1 - 1)
    end
    for j = 0, n - 1 do
      f(gc, m, j * l2 / n, (j + 1)*l2/n - 1, color8(j, v))
    end
  end
end

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

Sur
Casio fx-CP400+E
nous ne pouvons hélas pas te programmer de mire. :'(
En effet dans le langage interprété historique de la machine et seul langage qui nous est accessible, le paramètre de couleur des fonctions graphiques ne peut prendre que 7 valeurs différentes. :mj:

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

Toujours le même résultat avec 2 fois plus de teintes intermédiaires dans les tons de vert :
  • canal rouge sur
    5
    bits pour
    25= 32
    teintes
  • canal vert sur
    6
    bits pour
    26= 64
    teintes
  • canal bleu sur
    5
    bits pour
    25= 32
    teintes
Total donc
16
bits pour
216= 65536
couleurs affichables, et un contrôleur écran fonctionnant donc au format
RGB 565
.

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

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

Et enfin nous arrive la
HP Prime
.

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

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

Il ne fournit pas directement de quoi lire un pixel, mais par contre une fonction eval() permettant de faire appel au langage constructeur
HPPPL
où cette fonction existe. On peut alors se redéfinir une fonction
get_pixel()
en
Python
:
Code: Select all
def get_pixel(x, y):
      return int(eval("get_pixel(" + str(x) + "," + str(y) + ")"))


12882Ici c'est ainsi fantastique, l'appel mire(320,240) nous fournit des dégradés extrêmement fluides et ce peu importe la teinte ! :D
  • canal rouge sur
    8
    bits pour
    28= 256
    teintes
  • canal vert sur
    8
    bits pour
    28= 256
    teintes
  • canal bleu sur
    8
    bits pour
    28= 256
    teintes
Total donc
24
bits pour
224= 16777216
couleurs affichables, et un contrôleur écran fonctionnant donc au format
RGB 888
! :#tritop#:

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

-
Search
-
Social
-
Featured topics
Concours de rentrée 2021 - La Geste d'Alrys
Concours de rentrée 2021 - Synchro-donjon !
Comparaisons des meilleurs prix pour acheter sa calculatrice !
Remplace ton ancienne fx-92 Collège ou Graph 35 par la nouvelle Graph 35+E II programmable en Python ! Pour tout achat d'une nouvelle Graph 35 d'ici le 30 septembre 2021, Casio te rembourse 10€. En cas de retour de ta fx-92 Collège c'est 18€, et même ou 23€ si tu retournes ton ancienne Graph 35. Etiquette de retour fournie, pas de frais de port à payer, même les anciens modèles et machines non fonctionnelles sont acceptées. En partenariat avec les Restos du cœur.
Remplace ton ancienne fx-92 Collège ou Graph 35 par la Graph 90+E couleur. Pour tout achat, Casio te rembourse 10€ en cas de retour de ta fx-92 Collège, ou 15€ en cas de retour de ta Graph 35. Etiquette de retour fournie, pas de frais de port à payer, même les anciens modèles et machines non fonctionnelles sont acceptées. En partenariat avec les Restos du coeur.
10€ remboursés par Casio sur l'achat de ta calculatrice Graph 35 d'ici le 30 Septembre 2021
Reprise de ton ancienne fx-92 Collège à 5€ ou Graph 35 à 10€. Même non fonctionnelle ou ancien modèle. Etiquette de retour fournie, pas de frais de port à payer. En partenariat avec les Restos du coeur.
25€ remboursés par Casio sur l'achat de ta calculatrice fx-CP400 d'ici le 31 Octobre 2021
3€ remboursés par Casio sur l'achat de ta calculatrice fx-92 Collège d'ici le 30 Septembre 2021
Casio Graph 90+E ou Graph 35+E II avec couvercle personnalisé à gagner sur simple participation aux formations Casio de Septembre 2021.
Coque NumWorks édition limitée Septembre 2021 à gagner.
1234567891011
-
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.
653 utilisateurs:
>634 invités
>13 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)