π
<-
Chat plein-écran
[^]

News 2020
July (3)
June (17)
May (38)
April (21)
March (17)

News 2019
August (10)
July (3)
June (4)
May (11)
April (7)
March (19)
January (14)

News 2018
August (5)
July (1)
June (9)
May (10)
April (2)
March (14)
January (12)

News 2017
August (10)
July (14)
June (14)
May (11)
April (9)
March (12)
January (11)

News 2016
October (10)
August (8)
July (4)
June (8)
May (14)
April (9)
March (13)
January (11)

News 2015
October (15)
August (11)
July (4)
June (7)
May (12)
April (6)
March (11)

News 2014
August (2)
July (4)
June (2)
May (5)
April (4)
March (5)

News 2013
August (6)
July (6)
June (8)
May (14)
April (24)
March (16)
January (10)

News 2012
October (11)
August (6)
July (7)
June (8)
May (16)
April (16)
March (6)

News 2011
August (4)
July (4)
June (11)
May (5)
April (2)
March (6)

News 2010
July (1)
June (1)
May (2)
April (1)

News 2009
August (2)
April (1)

Mémoire tas/heap + tailles modules TI-83 Premium CE 5.5

New postby critor » 03 May 2020, 16:26

12382Dans sa prochaine mise à jour
5.5
gratuite prévue pour
Mai 2020
,
Texas Instruments
va rajouter de formidables possibilités à ta
TI-83 Premium CE
:
  • mise à jour en
    5.5
    de l'application
    SciTools
  • mise à jour en
    5.5
    de l'application
    Periodic
  • mise à jour en
    5.5
    de l'application
    Python
    (
    TI-83 Premium CE Édition Python
    uniquement)

Cette dernière application apporte de nouveaux modules importables pour tes scripts
Python
:
  • time
    , certes déjà présent mais maintenant listé au menu et donc officiel; il ne risque plus de disparaitre :)
  • , avec diverses possibilités :
    • détection des simples pressions de touches clavier
      (sans validation donc)
      par l'utilisateur, avec même l'éventuel modificateur actif
      (
      2nde
      ou
      alpha
      )
      , et ça marche aussi avec un clavier
      USB
      ! :bj:
    • affichage dans la console à la ligne que tu veux :bj:
    • exportation de listes de nombres
      (entiers, flottants ou complexes)
      existant dans le contexte
      Python
      vers l'environnement de la calculatrice, pour traitement à l'aide d'autres applications :bj:
    • importation depuis le contexte
      Python
      de listes ou équation de régression existant dans l'environnement de la calculatrice :bj:
    • et donc plus généralement un début d'intégration du
      Python
      à l'environnement mathématique de la calculatrice, enfin l'application
      Python
      va pouvoir servir non plus seulement à coder un truc déconnecté dans un coin, mais à traiter des problèmes et tâches complexes dans leur globalité ! :bj:
  • , une bibliothèque graphique pour tracer dans un repère, conformément aux programmes de
    Physique-Chimie
    ,
    SNT
    et
    NSI
    , tout en permettant également nombre d'applications en
    Mathématiques
    ! :bj:
  • ti_hub
    , pour les projets d'objects connectés à l'aide de l'interface :)
  • ti_rover
    , pour les projets de robotique à l'aide du :)
  • ainsi qu'un mystérieux
    ti_graphics
    pour sa part non listé au menu, mais justement utilisé par

Avant de poursuivre notre exploration des modules, voyons un petit peu où nous en sommes aujourd'hui niveau mémoire.
Attention, nous ne disposons que d'une préversion. Il est donc parfaitement possible que plusieurs points abordés dans notre critique soient améliorés d'ici la sortie.

Les interpréteurs
MicroPython
ou similaires qui tournent sur ta calculatrice font appel à 3 types de mémoires avec les rôles suivants :
  • la mémoire de stockage qui accueille et conserve tes scripts
    Python
  • le
    stack (pile)
    qui, à l'exécution, accueille les références vers les objets
    Python
    créés
  • le
    heap (tas)
    qui, à l'exécution, accueille les valeurs de ces objets
    Python
En gros le
stack / pile
limite donc le nombre d'objets différents pouvant exister simultanément en mémoire, alors que le
heap / tas
limite la taille globale occupée par ces objets.
A moins d'avoir de gros besoins en terme de récursivité, le facteur limitant pour tes projets
Python
sur calculatrice est habituellement le
heap / tas
.




Sommaire :




1) mémoire de tas / heap et module gc

Go to top

L'appel
mem()
avec le script
mem.py
suivant permet d'estimer la capacité du tas
(heap)
Python
, et retournait jusqu'à présent près de 20K sur
TI-83 Premium CE Édition Python
:
Code: Select all
def sizeenv():
  s=0
  import __main__
  for o in dir(__main__):
    try:s+=size(eval(o))
    except:pass
  return s
def size(o):
  s,t=0,type(o)
  if t==str:s=49+len(o)
  if str(t)=="<class 'function'>":s=136
  if t==int:
    s=24
    while o:
      s+=4
      o>>=30
  if t==list:
    s+=64
    for so in o:s+=8+size(so)
  return s
def mem(v=1,r=1):
  try:
    l=[]
    try:
      l+=[r and 793+sizeenv()]
      if v*r:print(" ",l[0])
      l+=[0]
      l+=[""]
      l[2]+="x"
      while 1:
        try:l[2]+=l[2][l[1]:]
        except:
          if l[1]<len(l[2])-1:l[1]=len(l[2])-1
          else:raise(Exception)
    except:
      if v:print("+",size(l))
      try:l[0]+=size(l)
      except:pass
      try:l[0]+=mem(v,0)
      except:pass
      return l[0]
  except:return 0

Les formidables nouveautés de la version
5.5
semblent hélas avoir un coût important, à vide nous trouvons désormais à peine
17,5K
de libres avec la version
5.5
, un effondrement non négligeable de plus de 2,5K. :'(

La
TI-83 Premium CE Édition Python
fait partie des très rares calculatrices disposant du module
gc
, module qui va nous être bien pratique pour comprendre ce qui se passe. Retenons les appels suivants :
  • gc.mem_alloc() retourne l'espace occupé sur le tas
    (heap)
  • gc.mem_free() retourne l'espace libre sur le tas
    (heap)

Testons à vide à l'aide du petit script suivant :
Code: Select all
from gc import *
a, f = mem_alloc(), mem_free()
(a, f, a+f)

Nous découvrons donc que le tas
Python
de la
TI-83 Premium CE Édition Python
fait exactement
19,968K
; sa capacité totale n'a donc pas été réduite.

Mais, lorsque tu lances tes scripts
Python
plusieurs choses sont initialisées et consomment du tas avant même l'exécution de ta première ligne de code. Et c'est là qu'il y a une lourde différence :
  • avec la dernière version
    5.4
    : juste
    608o
    consommés pour pas moins de
    19,36Ko
    de libres
  • avec la prochaine version
    5.5
    : pas moins de
    2912o
    consommés pour juste
    17,056Ko
    de libres
Effectivement, on retrouve bien cette consommation supplémentaire de 2,5K sur le tas avant même que tu aies tapé la moindre ligne de
Python
.

En passant il est normal que l'on trouve ici à chaque fois un petit peu moins que l'espace libre trouvé avec
mem()
, puisqu'il y a ici l'importation obligatoire du module
gc
qui consomme également du tas.

D'où le classement en terme de capacité tas
(heap)
disponible pour tes scripts, avec la capacité totale précisée lorsque le module
gc
est disponible :
  1. 1,032942 Mo
    :
    Casio Graph 90+E
  2. 1,022145 / 1,024512 Mo
    :
    HP Prime G1
  3. 100,560 Ko
    :
    Casio Graph 35+E II
  4. 32,339 Ko
    :
    NumWorks
  5. 31,624 Ko
    :
    NumWorks
  6. 19,500 / 19,968 Ko
    :
    TI-83 Premium CE Édition Python
    (ancienne version)
  7. 17,359 / 19,968 Ko
    :
    TI-83 Premium CE Édition Python
    (nouvelle version)
  1. 2,049276 Mo
    :
    TI-Nspire
    (application MicroPython)
  2. 1,032942 Mo
    :
    Casio Graph 90+E / fx-CG50
  3. 1,022145 Mo
    :
    HP Prime G1
  4. 257,636 / 258,048 Ko
    :
    Casio Graph 35+E / 75+ / 35+ USB Power Graphic 2 / 75/95 USB Power Graphic 2 / fx-9750/9860GII USB Power Graphic 2
  5. 100,560 Ko
    :
    Casio Graph 35+E II / fx-9750/9860GIII
  6. 32,339 Ko
    :
    NumWorks
  7. 31,624 Ko
    :
    NumWorks
  8. 31,520 / 32,256 Ko
    :
    Casio Graph 35+E II / 85 / 35+ USB Power Graphic 1 / 75/95 USB Power Graphic 1 / fx-9750/9860GIII / fx-9750/9860GII USB Power Graphic 1 / fx-9860G
  9. 22,605 / 22,912 Ko
    :
    TI-83 Premium CE + TI-Python
  10. 19,500 / 19,968 Ko
    :
    TI-83 Premium CE + TI-Python
    +
    TI-83 Premium CE Édition Python
    (ancienne version)
  11. 17,359 / 19,968 Ko
    :
    TI-83 Premium CE Édition Python
    (nouvelle version)

La
TI-83 Premium CE Édition Python
était déjà la pire solution
Python
pour la capacité tas, et cela ne fait donc qu'empirer.

C'est probablement largement suffisant pour les petits
algo-musements
de quelques lignes qui seront traités en Mathématiques ou Physique-Chimie.

Le problème est ailleurs, ceux qui auront suffisamment accroché pour avoir envie d'aller plus loin risquent d'être rapidement déçus par leur calculatrice...
Ceux qui aborderont des projets
(
SNT
,
NSI
, ... ou même non scolaires)
risquent d'obtenir des erreurs de mémoire assez rapidement après le début du projet...

Car le
Python
ce n'est pas du
C
, les objets
Python
les plus élémentaires sont extrêmement gourmands en mémoire :
  • 64 octets rien que pour une liste vide
  • plus 8 octets pour chaque élément de liste supplémentaire, sans compter la taille de l'élément en question
  • 24 octets pour un entier nul
  • 28 octets pour un entier court non nul
  • 49 octets rien que pour une chaîne vide
  • plus 1 octet par caractère de chaîne supplémentaire
  • ...
Alors imagine la catastrophe quand pour des projets tu multiplies le nombre de ces objets au sein de listes... :#roll#:

Quand on pense à tout ce que nous avons pu souffrir sur
NumWorks
depuis la rentrée 2017 avec seulement 16K de tas disponible avant la mise à jour
13.2
faisant passer cela à 32K, nous sommes en effet assez pessimistes ici devant nos même pas
17.5K
de tas.

Il est possible que l'on ne puisse pas importer simultanément l'ensemble des modules.
Il risque de ne pas rester beaucoup de tas disponible pour coder une fois certains gros modules importés, et nous allons revenir là-dessus.
Cela remet au passage en question notre projet déjà évoqué de développer certains scripts de compatibilité, scripts qui ne feraient alors que réduire encore davantage le peu de mémoire tas utilisable pour tes scripts si tu dois les importer en plus des modules en question. :'(

Les erreurs de mémoire risquent donc d'arriver très rapidement. A cause de ce gros défaut, les scripts
Python
offerts en ligne risquent à notre avis d'être à terme plus nombreux et surtout beaucoup plus conséquents pour les solutions concurrentes que pour la
TI-83 Premium CE Édition Python
, et ce malgré toutes ses formidables possibilités. :'(

Le pire était que cela fait plus de 2 ans que nous communiquons régulièrement
(sans aucune malveillance)
sur ce grave défaut aujourd'hui corrigé de la
NumWorks
, et comprenons donc assez mal que la même erreur ait pu être reproduite ici.
A moins que ce ne soit en fait exprès pour pousser ceux qui veulent aller plus loin à un investissement dans les modèles haut de gamme
TI-Nspire CX II
?...




2) types de scripts et scripts préremplis

Go to top

Grande nouveauté de l'application
Python 5.5
, le menu de création de scripts te permet d'en choisir un type avec la touche
F3
.

Outre le type
Script vierge
par défaut, tu obtiens alors un script prérempli à compléter :
  • Calculs Mathématiques
    : importe
    math
  • Simulation Aléatoire
    : importe
    random
  • Tracer (x,y) et Texte
    : importe
    ti_plotlib
    + script de tracé de nuage de points avec les listes
    x
    et
    y
    à remplir
  • Partage de Données
    : importe
    ti_system
  • Projets STEM Hub
    : importe
    ti_system
    et
    time
  • Rover
    : importe
    time
    ,
    ti_system
    et
    ti_rover


Une belle initiative, voilà de quoi bien alléger tes saisies clavier lorsque tu commences un nouveau script ! :bj:




3) importations modules et consommation tas / heap

Go to top

Voyons enfin un petit peu ce que consomme l'importation de chaque module disponible sur le tas
(heap)
.

Il suffit d'appeler les fonctions du module
gc
vues plus haut, juste avant et après l'importation d'un module.

Voici un script en ce sens, volontairement minimaliste sans définition de fonction afin de minimiser les chances de déclencher en cours d'exécution un nettoyage mémoire qui fausserait les résultats :
Code: Select all
from gc import mem_free as mf

smod = input('Module : ')
mf1, mf2 = 0, 0
scmd = 'from ' + s + ' import *'
mf1 = mf()
exec(scmd)
mf2 = mf()
print(mf1 - mf2)

Voici donc les consommations de tas à l'importation des différents modules intégrés :
  • array
    : 96 o
  • builtins
    : 816 o
  • collections
    : 96 o
  • gc
    : 128 o
  • math
    : 336 o
  • random
    : 176 o
  • sys
    : 224 o
  • ti_graphics
    : 2,896 Ko
  • ti_hub
    : 224 o
  • ti_plotlib
    : 7,232 Ko
  • ti_rover
    : 4,848 Ko
  • ti_system
    : 176 o
  • time
    : 112 o

Nos craintes évoquées plus haut étaient donc apparemment bien fondées; plusieurs modules sont très gros avec plusieurs kilooctets consommés sur le tas:
ti_graphics
,
ti_rover
et
ti_plotlib
notamment, avec quasiment la moitié du tas initialement disponible pour ce dernier.

Quand tu vas donc coder tes scripts et surtout projets
Python
sur
TI-83 Premium CE Édition Python
, contrairement à ce que tu fais peut-être sur d'autres plateformes n'importe que le strict nécessaire.

Aussi si ton projet nécessite des affichages graphiques
(interfaces de menus, jeux, ...)
, évite à tous prix le module
ti_plotlib
sauf si tu as vraiment besoin de tracer des diagrammes
(nuages de points, histogrammes...)
. Préfère-lui plutôt le module
ti_graphics
beaucoup plus économe.
Plutôt que d'utiliser les coordonnées dans un repère orthogonal,
ti_graphics
te fera travailler en terme de pixels ce qui sera beaucoup plus précis; et nous allons t'en présenter les formidables possibilités très prochainement.
Alors justement, à très bientôt ;)




Conclusion

Go to top

Nous t'avions dit en introduction que les éventuels points négatifs pourraient très bien être améliorés d'ici la sortie, vu que nous ne disposons que d'une préversion.

Toutefois, dans le cas particulier du tas
(heap)
Python
traité aujourd'hui nous sommes assez pessimistes.

Rappelons en effet un petit peu l'architecture matérielle assez particulière de la
TI-83 Premium CE Édition Python
:
  • un cœur secondaire 32 bits
    Atmel SAMD21E18A-U
    dédié à l'exécution des scripts
    Python
  • un cœur principal
    eZ80
    qui est le seul à avoir accès à l'ensemble des autres composantes
    (
    Flash
    , contrôleur écran, cœur secondaire...)
Le cœur secondaire contient notamment :
  • un processeur 32 bits
    ARM Cortex-M0+
    cadencé à
    48 MHz
    et agissant donc ici en tant que coprocesseur pour l'exécution de tes scripts
    Python
  • une mémoire
    Flash
    de
    256 Kio
  • une mémoire
    SRAM
    de
    32 Kio
Commences-tu à comprendre le problème ? Le coprocesseur
Python
n'a accès qu'à
32Kio
de
RAM
,
RAM
qui sert pour différentes choses :
  • certes le tas
    (heap)
    Python
    de près de 20K mais pas que
  • également la pile
    (stack)
    Python
  • et aussi il ne faut pas l'oublier l'exécution du
    firmware
    CircuitPython
    modifié inclus dans la mémoire
    Flash
    et qui fournit l'interpréteur
    Python
Près de 17.5K d'espace disponible sur un tas de près de 20K lui-même pris sur une
RAM
de
32Kio
qui sert à bien d'autres choses; la marge d'amélioration nous semble a priori extrêmement limitée.

NumWorks
a mis deux ans et demi à le comprendre; si tant est que
Texas Instruments
comprenne également en quoi 17.5K de tas sont un inconvénient majeur même dans un contexte scolaire, nous craignons que les améliorations ne puissent concerner qu'une future révision matérielle ou même un futur modèle, sans doute encore lointain pour le milieu de gamme vu que la
TI-83 Premium CE Édition Python
a tout juste 1 an. :'(

Super Mario Bros, remake des 32 niveaux pour Oiram CE !

New postby critor » 03 May 2020, 22:37

12495Ta formidable
TI-83 Premium CE
dispose depuis janvier 2017 de
Oiram CE
, un superbe moteur de jeu
Mario-like
par .

Un moteur qui en plus de venir avec des niveaux par défaut a le gros avantage d'accepter les niveaux perso, et également celui de la disponibilité d'un éditeur de niveaux pour
Windows / Mac
.

Nous nous attardons aujourd'hui sur un pack de niveaux perso absolument remarquable par . Ce dernier s'est en effet lancé le défi de recréer les niveaux du
Super Mario Bros
, le jeu vidéo sorti en 1985 pour console de jeux
Nintendo NES
.

Bien des difficultés en perspective, puisque
Oiram CE
s'inspire non pas du
gameplay
de
Super Mario Bros
, mais de celui de
Super Mario Bros 3
. Or ces deux jeux ont beaucoup de différences, déjà sans rentrer dans les détails rien qu'au niveau des blocs et ennemis.

Pour résumer il s'agit donc de reproduire aussi fidèlement que possible
Super Mario Bros
avec les 241
sprites
Super Mario Bros 3
illustrées ci-contre.

Ce n'était pas assez pour décourager qui nous signe ainsi
Super Mario Bros Remake
. Ce pack de 32 niveaux perso reproduit les 32 niveaux répartis entre les 8 mondes sur
Super Mario Bros
.

Nous allons te montrer de suite de quoi ça a l'air, et traiter des différences.

1er des 8 mondes du Royaume Champignon. Au menu :
  • 1er niveau sur la terre ferme
  • 2ème niveau sous-terrain
  • 3ème niveau de plateformes dans une forêt de champignons géants
  • 4ème niveau avec le château

Ici nous renonçons aux éléments de fond d'écran, arbres, collines et nuages, bien que
Oiram CE
dispose pourtant de
sprites
qui auraient permis de les imiter. Pas de variation de couleur pour les briques sous-terraines, le
sprite
de brique sombre n'existant pas dans
Oiram CE
. Le mât de fin de niveau n'ayant lui non plus aucune existence dans
Oiram CE
est ici remplacé par un empilement de pièces. Le mini-donjon décoratif qui lui fait suite en fin de niveau est par contre absent et ce sera toujours le cas.

On remarque ici un manque bien embêtant de
Oiram CE
dans le sens où c'est visuellement très gênant; il n'y a pas de
sprite
pour les pièces utilisant le fond noir, et elles sont donc affichées comme si elles étaient en plein jour à l'air libre. Là encore quelque chose qui n'existe pas dans
Oiram CE
, les ascenseurs continus à la
pater noster
d'Europe centrale, sont remplacés par des paires verticales de deux plateformes constituées de blocs qui tombent. La salle secrète de
warp zone
est bien présente mais non fonctionnelle puisque les
warp zones
ne sont hélas pas gérées par
Oiram CE
. Au lieu de te permettre de passer au choix aux mondes 2, 3 ou 4, elle te permettra juste de passer au niveau suivant exactement comme la fin normale du niveau. C'est quand même un beau clien d'oeil de l'avoir incluse, même non inopérante. ;)

On apprécie la belle reproduction extérieure du mini-donjon en début de niveau. Pas vraiment de
sprites
équivalents pour les champignons géants, fait comme il peut et c'est assez réussi. Dans le même style, on renonce ici aux plateformes mobiles. Celles qui se déplacent verticalement sont là encore remplacées par des paires verticales de deux plateformes de blocs qui tombent. Celles qui se déplacent horirontalement sont directement remplacées par des blocs qui tombent. Le château décoratif n'est pas illustré à la fin du niveau, et ce sera toujours le cas.

Et enfin le château. Il nous faut ici renoncer aux barres de feu remplacées par des canons, ainsi qu'au pont escamotable sur lequel déambule
Bowser
. Pas d'écran de fin
"but our princess is in another castle"
non plus.

2ème monde ici aquatique :
  • 1er niveau sur la terre ferme
  • 2ème niveau sous-marin
  • 3ème niveau en bord de mer
  • 4ème niveau avec le château
Oiram CE
ne gérant pas de découpage des packs en différents mondes, les niveaux y seront numérotés 5 à 8.

Belle reproduction extérieure du grand château cette fois-ci. Ici encore il a fallu renoncer aux éléments d'arrière plan comme les barrières.

Ici un manque de
Oiram CE
bien embêtant visuellement, les pièces placées sous l'eau n'utilisent pas le fond aquatique elles non plus. Outre les méduses, le niveau original présentait deux espèces de poissons : rouges et gris, ces derniers étant plus lents. Nous déplorons ici nos premiers ennemis manquants faute d'équivalent, tous les poissons étant donc rouges. Les algues rouges ici encore faute d'équivalent, sont remplacés par des éléments non fonctionnels de tuyaux rouges.


Pas d'équivalent non plus aux poissons sauteurs, ici remplacés par des fantômes.

3ème monde ici plongé dans la nuit et enneigé, avec :
  • 1er + 2ème niveaux sur la terre ferme
  • 3ème de plateformes en forêt de champignons géants
  • 4ème niveau avec le château
Les niveaux correspondants sont ici numérotés 9 à 12 dans
Oiram CE
.

Dans l'original, l'enneigement était suggéré par les éléments de fond d'écran, ne pouvant être reproduits ici puisque
Oiram CE
ne dispose pas de version enneignée des
sprites
d'arrière plan. Il existe bien par contre des blocs enneigés dans
Oiram CE
, mais ils ont le défaut d'être glissant ce qui n'aurait pas été conforme au
gameplay
original. Donc bref, pas de neige ici. Nous attendions également la première apparition des emblématiques
tortues frères marteaux
, mais hélas elles n'existent pas dans
Oiram CE
et se voient remplacées chacune par une tortue zombie accomagnée de deux tortues à épines.


Encore un élément mécanique difficile à remplacer ici, les espèces de monte-charge rudimentaires. On fait ce qu'on peut...

4ème monde où l'on retrouve l'organisation du 1er monde :
  • 1er niveau sur la terre ferme
  • 2ème niveau sous-terrain, pour la dernière fois
  • 3ème niveau de plateformes dans une forêt de champignons géants
  • 4ème niveau avec le château
Les niveaux équivalents seront ici numérotés 13 à 16 dans
Oiram CE
.

Autre défection parmi les ennemis, la tortue chevauchant son nuage pour lancer des oeufs de tortues à épines manque dans
Oiram CE
, tous comme les oeufs en question d'ailleurs. Ils se voient donc remplacés ici par une pluie directe de tortues à épines.

Ici encore un absent, les scarabés nous font défaut dans
Oiram CE
et sont remplacés par des tortues zombie. Les deux salles secrètres de
warp zone
sont là encore présentes mais non fonctionnelles, ne te permettant que de passer au niveau suivant au lieu de t'amener au choix aux mondes 5, 6, 7 ou 8.

Nouveau style de champignons géants sans
sprites
adaptées, fait avec ce qu'il peut et c'est assez réussi, l'effet est bien là. :)

Le château est ici difficile à reproduire car il est spécial. C'est un labyrinthe, dans le sens ou si l'on n'enchaîne pas les bonnes plateformes on est ramené en boucle au début du niveau, élément de
gameplay
non géré par
Oiram CE
. Tout juste t'a-t-il rajouté quelques blocs infranchissables pour te forcer à enchaîner les bonnes plateformes, là encore un clin d'oeil inutile et donc absolument indispensable. ;)

5ème monde qui reprend le découpage du 3ème monde mais cette fois-ci en plein jour :
  • 1er + 2ème niveaux sur la terre ferme
  • 3ème niveau de plateformes dans une forêt de champignons géants
  • 4ème niveau avec le château
Les niveaux correspondants sont ici numérotés 17 à 20 dans
Oiram CE
.




6ème monde qui reprend l'organisation des 3ème et 5ème mondes, plongé dans la nuit pour la dernière fois :
  • 1er + 2ème niveaux sur la terre ferme
  • 3ème niveau de plateformes dans une forêt de champignons géants, pour la dernière fois
  • 4ème niveau avec le château
Les niveaux correspondants seront numérotés 21 à 24 dans
Oiram CE
.



Franchement pas de
sprite
adaptée dans
Oiram CE
pour les couronnes de champignons blancs géants, on fait ce qu'on peut...

7ème monde qui reprend l'organisation du 2ème monde :
  • 1er niveau sur la terre ferme
  • 2ème niveau aquatique, pour la dernière fois
  • 3ème niveau en bord de mer, pour la dernière fois
  • 4ème niveau avec le château
Les niveaux correspondants sont numérotés 25 à 28 dans
Oiram CE
.




Ici encore il s'agit d'un château labyrinthe qui te ramène en boucle au début si tu n'enchaînes pas les bonnes plateformes, impossible à reproduire. y fait référence en te rajoutant des blocs infranchissables pour te forcer à enchaîner les bonnes plateformes comme dans l'original.

Et enfin 8ème monde avec une organisation inédite :
  • 1er + 2ème + 3ème niveaux sur la terre ferme
  • 4ème niveau avec le château
Les niveaux correspondants sont ici numérotés 29 à 32.



fait comme il peut pour reproduire les remparts en arrière plan.

Ici encore un château-labyrinthe mais d'une autre façon. Tu dois trouver cette fois-ci le bon enchaînement de tuyaux qui t'amènera à
Bowser
, tout mauvais tuyau te ramenant en début de niveau. Dans l'original si tu avançais sans rentrer dans aucun tuyau, le château bouclait et te ramenait également au début, élément de
gameplay
impossible à reproduire ici; tu devras choisir obligatoirement un tuyau avant le mur rajouté pour t'empêcher d'aller plus loin. Dommage que
Peach
ne t'attende pas à la fin. ;)


Bref un superbe pack de niveaux et avec 32 niveaux le plus grand jamais créé pour
Oiram CE
! :)

Dans la limite des nombreuses contraintes imposées par
Oiram CE
te signe quand même une reproduction extrêmement fidèle de
Super Mario Bros
, une reproduction méticuleuse au bloc près, et tout élément ne pouvant être reproduit a été pensé et adapté avec talent toujours dans le respect du jeu original ! :D

Félicitations , nous n'osons pas imaginer combien de temps tu as pu passer là-dessus ! :bj:

Au nom de tous les confinés, merci en tous cas pour ce superbe cadeau qui nous va droit au cœur en ces temps si difficiles, de quoi bien nous occuper cette semaine ! :favorite:

Attention, pour fonctionner correctement,
Oiram CE
a besoin des bibliothèques C téléchargeables ci-dessous. Mais rien de bien compliqué, il suffit juste de récupérer et transférer leur fichier. :)


Téléchargements
:

Crédits images
:
cartes
Super Mario Bros

Exploration module Python ti_graphics TI-83 Premium CE 5.5

New postby critor » 04 May 2020, 10:58

12382Dans sa prochaine mise à jour
5.5
gratuite prévue pour
Mai 2020
,
Texas Instruments
va rajouter de formidables possibilités à ta
TI-83 Premium CE
:
  • mise à jour en
    5.5
    de l'application
    SciTools
  • mise à jour en
    5.5
    de l'application
    Periodic
  • mise à jour en
    5.5
    de l'application
    Python
    (
    TI-83 Premium CE Édition Python
    uniquement)

Cette dernière application apporte de nouveaux modules importables pour tes scripts
Python
:
  • time
    , certes déjà présent mais maintenant listé au menu et donc officiel; il ne risque plus de disparaitre :)
  • , avec diverses possibilités :
    • détection des simples pressions de touches clavier
      (sans validation donc)
      par l'utilisateur, avec même l'éventuel modificateur actif
      (
      2nde
      ou
      alpha
      )
      , et ça marche aussi avec un clavier
      USB
      ! :bj:
    • affichage dans la console à la ligne que tu veux :bj:
    • exportation de listes de nombres
      (entiers, flottants ou complexes)
      existant dans le contexte
      Python
      vers l'environnement de la calculatrice, pour traitement à l'aide d'autres applications :bj:
    • importation depuis le contexte
      Python
      de listes ou équation de régression existant dans l'environnement de la calculatrice :bj:
    • et donc plus généralement un début d'intégration du
      Python
      à l'environnement mathématique de la calculatrice, enfin l'application
      Python
      va pouvoir servir non plus seulement à coder un truc déconnecté dans un coin, mais à traiter des problèmes et tâches complexes dans leur globalité ! :bj:
  • , une bibliothèque graphique pour tracer dans un repère, conformément aux programmes de
    Physique-Chimie
    ,
    SNT
    et
    NSI
    , tout en permettant également nombre d'applications en
    Mathématiques
    ! :bj:
  • ti_hub
    , pour les projets d'objects connectés à l'aide de l'interface :)
  • ti_rover
    , pour les projets de robotique à l'aide du :)
  • ainsi qu'un mystérieux
    ti_graphics
    pour sa part non listé au menu, mais justement utilisé par
Après donc une exploration des possibilités du module
ti_plotlib
, nous te proposons aujourd'hui l'exploration du module secret
ti_graphics
.



Sommaire :




1) exploration ti_graphics

Go to top

ti_graphics
n'étant pas listée et étant donc non documentée, commençons donc par en explorer le contenu secret à l'aide du script suivant :
Code: Select all
def getplatform():
  id=-1
  try:
    import sys
    try:
      if sys.platform=='nspire':id=0
      if sys.platform.startswith('TI-Python') or sys.platform=='Atmel SAMD21':id=4
    except:id=3
  except:
    try:
      import kandinsky
      id=1
    except:
      try:
        if chr(256)==chr(0):id=5+(not ("HP" in version()))
      except:
        id=2
  return id

platform=getplatform()
#lines shown on screen
#plines=[29,12,  7, 9,11,0,0]
plines=[29,16,  7, 9,11,0,0]
#max chars per line
#(error or CR if exceeded)
pcols =[53,99,509,32,32,0,0]

nlines=plines[platform]
ncols=pcols[platform]
curline=0

def mprint(*ls):
  global curline
  st=""
  for s in ls:
    if not(isinstance(s,str)):
      s=str(s)
    st=st+s
  stlines=1+int(len(st)/ncols)
  if curline+stlines>=nlines:
    input("Input to continue:")
    curline=0
  print(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):
  s=str(obj)
  return s.startswith("<") and s.find(" ")>=0 and not s.startswith("<module")

def explmod(pitm,pitmsl=[],reset=True):
  global curline
  if(reset):
    curline=0
    pitmsl=[sstr(pitm)]
  hd="."*(len(pitmsl)-1)
  spath=".".join(pitmsl)
  c,c2=0,0
  spitm=str(pitm)
  for itms in sorted(dir(pitm)):
    c,c2=c+1,c2+1
    try:
      itm=eval(spath+"."+itms)
      mprint(hd+itms+"="+str(itm))
      if isExplorable(itm) and itm!=pitm:
        pitmsl2=pitmsl.copy()
        pitmsl2.append(itms)
        c2=c2+explmod(itm,pitmsl2,False)[1]
    except:
      mprint(hd+itms)
  if c>0 and reset:
    mprint(hd+"Total: "+str(c)+" 1st level item(s)")
    if c2>0 and c2!=c:
      mprint(hd+"       "+str(c2)+" item(s)")
  return [c,c2]


Pas mal de choses a première vue, nous découvrons déjà 30 éléments accessibles rien qu'au premier niveau, et jusqu'à 45 en comptant les sous-éléments. :bj:

Une première lecture des noms de différentes fonctions, comme
getPixel()
et
setPixel()
nous permet de deviner de quoi il s'agit.
ti_graphics
est un module
Python
permettant de dessiner sur l'écran de ta
TI-83 Premium CE Edition Python
, non pas en donnant des coordonnées approximatives dans un repère mais en accédant directement les pixels de l'écran ! :D
Pour te donner un point de repère, nous pouvons donc a priori le rapprocher des modules
casioplot
sur
Casio Graph 90/35+E II
ou
kandinsky
sur
NumWorks
.


Nous allons bien évidemment te tester et documenter tout ça sans tarder, mais en attendant cela nous permet déjà de mettre à jour notre petit classement des
Pythonettes
: ;)
Casio Graph
35+E II
90+E
NumWorks
TI-83PCE
Ed. Python
builtins
array
collections
cmath
gc
math
matplotlib
matplotlib.pyplot
micropython
os
random
sys
time
turtle
uerrno
84-175
.
.
.
.
25
.
.
.
.
8
.
.
.
.
97-440
3-13
.
13-17
9-13
42-46
.
.
10-14
.
.
17-63
.
.
25-29
88-188
.
.
12
.
41
3
11
6
.
9
.
3
38
.
92-189
2-4
2
.
7
28
.
.
.
.
8
15-42
4
.
.
spécifique
casioplot:6prime:3-7ion:48
kandinsky:6
ti_graphics:30-45
ti_hub:?
ti_plotlib:49-56
ti_system:12
ti_rover:?
Modules
4
9
11
13
Eléments
123-214
219-642
265-365
249-397

Classement en terme d'éventail de modules :
  1. 13
    modules :
    TI-83 Premium CE Edition Python
  2. 11
    modules :
    NumWorks
  3. 9
    modules :
    HP Prime
    (version alpha)
  4. 4
    modules :
    Casio Graph 90+E / 35+E II

Classement en terme de richesse des modules :
  1. 219-642
    éléments :
    HP Prime
    (version alpha)
  2. 249-397
    éléments :
    TI-83 Premium CE Edition Python
  3. 265-365
    éléments :
    NumWorks
  4. 123-214
    éléments :
    Casio Graph 90+E / 35+E II
Casio Graph
35+E II
90+E
CasioPython
Casio Graph
35+E II
35+E/USB
75/85/95
MicroPython
TI-Nspire
TI-Python
builtins
array
collections
cmath
gc
math
matplotlib
matplotlib.pyplot
micropython
os
random
sys
time
turtle
uerrno
84-175
.
.
.
.
25
.
.
.
.
8
.
.
69
.
91-204
2-4
.
12
7
41
.
.
6
.
8
12
.
.
24
93-218
2-4
.
12
7
41
.
.
3
.
.
15-45
.
.
.
92-189
2-4
2
.
7
28
.
.
.
.
8
15-42
4
.
.
93-191
2-4
2
12
7
41
.
.
6
15
8
15-45
8-10
.
.
spécifique
casioplot:6
matplotl:25
nsp:3-10board:22
storage:7-21
Modules
6
9
8
9
13
Eléments
217-308
203-318
176-340
158-284
238-384

Classement en terme d'éventail de modules :
  1. 13
    modules :
    TI-83 Premium CE + TI-Python
    (firmware tiers)

    TI-83 Premium CE Edition Python
  2. 11
    modules :
    NumWorks
  3. 9
    modules :
    HP Prime
    (version alpha)
    +
    Casio Graph 75/85/95 / 35+E/USB / 35+E II / fx-9750GII/GIII / fx-9860G/GII/GIII
    (appli CasioPython)
  4. 8
    modules :
    TI-Nspire
    (appli MicroPython)
    +
    TI-83 Premium CE + TI-Python
  5. 6
    modules :
    Casio Graph 90+E / 35+E II / fx-CG50 / fx-9750/9860GIII

Classement en terme de richesse des modules :
  1. 219-642
    éléments :
    HP Prime
    (version alpha)
  2. 249-397
    éléments :
    TI-83 Premium CE Edition Python
  3. 265-365
    éléments :
    NumWorks
  4. 238-384
    éléments :
    TI-83 Premium CE + TI-Python
    (firmware tiers)
  5. 217-308
    éléments :
    Casio Graph 90+E / 35+E II / fx-CG50 / fx-9750/9860GIII
  6. 203-318
    éléments :
    Casio Graph 75/85/95 / 35+E/USB / 35+E II / fx-9750GII/GIII / fx-9860G/GII/GIII
    (appli CasioPython)
  7. 176-340
    éléments :
    TI-Nspire
    (appli MicroPython)
  8. 158-284
    éléments :
    TI-83 Premium CE + TI-Python




2) zone graphique contrôlable

Go to top

Explorons maintenant notre environnement graphique. Pour cela nous allons utiliser quelques premières fonctions élémentaires, commençons déjà par en préciser les spécifications :
  • getPixel(x, y)
  • setPixel(x, y, c)
Quelles sont donc les dimensions de la zone graphique que nous contrôlons ?
Petite astuce pour la détecter automatiquement sans intervention humaine, on peut remarquer que
getPixel()
renvoie
(0,0,0)
lorsque l'on interroge un pixel hors écran.

Un simple boucle de tests suffit alors, avec un éventuel changement de couleur préalable pour les quelques pixels de l'écran qui seraient déjà noirs.

Mettons à jours notre classe de compatibilité écrans
polyscr
en ce sens :
Code: Select all
class polyscr:
  w, h = 0, 0
  # get_pixel(x, y)
  # set_pixel(x, y, color(r8, g8, b8))
  show_screen = lambda self: None
  need_show_screen = False
  # color mode :
  # 0: (R8, G8, B8)
  # 1: int RGB-565
  color_mode = 0

  def color(self, r, g=0, b=0):
    if isinstance(r, tuple) or isinstance(r,list):
      r, g, b = r[0], r[1], r[2]
    return self.color_mode == 0 and (r,g,b) or r<<11 | g<<5 | b

  def __init__(self):

    try: # TI-Nspire Ndless
      from nsp import Texture as myscr
      self.w, self.h = 320, 240
      myscr = myscr(self.w, self.h, None)
      self.get_pixel = myscr.getPx
      self.set_pixel = myscr.setPx
      self.show_screen = myscr.display
      self.need_show_screen = True
      self.color_mode = 1

    except:

      try: # TI-83/84 CE
        import ti_graphics as myscr
        self.get_pixel = myscr.getPixel
        self.set_pixel = myscr.setPixel

      except ImportError:

        try: # Casio USB Power Graphic 3
          import casioplot as myscr
          self.show_screen = myscr.show_screen
          self.need_show_screen = True

        except ImportError: # NumWorks
          import kandinsky as myscr

        self.get_pixel = myscr.get_pixel
        self.set_pixel = myscr.set_pixel

    # detect readable pixel array
    if self.w <= 0:

      def _can_get_pixel(x, y):
        c = self.get_pixel(x, y)
        if c == self.color(0, 0, 0):
          self.set_pixel(x, y, self.color(255,0,0))
          c = self.get_pixel(x, y)
        return c is not None and c != self.color(0, 0, 0)

      self.w, self.h, dw, dh = 0, 0, 1, 1
      while dw or dh:
        if not _can_get_pixel(self.w - (dw == 0),self.h - (dh == 0)):
          if _can_get_pixel(self.w,self.h-1): dh = 0
          elif _can_get_pixel(self.w-1,self.h): dw = 0
          else: dw, dh = 0, 0
        self.w += dw;  self.h += dh


Appelons ensuite le code suivant pour obtenir la réponse :
Code: Select all
scr = polyscr()
print('can get {}x{} pixels at (0,0)'.format(scr.w, scr.h))

Mais c'est fantastique, nous bénéficierions donc apparemment un contrôle plein écran
320×240
pixels ! :bj:

Sauf que... non, fausse joie. :'(

On se rend vite compte que même si
Texas Instruments
nous autorise contrairement à la concurrence à lire tous les pixels de l'écran, ceux utilisés pour l'affichage de la barre d'état en haut d'écran ne peuvent apparemment pas être réécrits :
Code: Select all
from ti_system import *
import ti_graphics as scr

for k in range(240):
  sct.setPixel(k, k, (0, 0, 0))
disp_wait()


Complétons donc l'initialisation de notre classe
polyscr
avec une boucle de tests supplémentaire pour gérer ce cas particulier :
Code: Select all
class polyscr:
  w, h, w0, h0, x0, y0 = 0, 0, 0, 0, 0, 0
  # get_pixel(x, y)
  # set_pixel(x, y, color(r8, g8, b8))
  show_screen = lambda self: None
  need_show_screen = False
  # color mode :
  # 0: (R8, G8, B8)
  # 1: int RGB-565
  color_mode = 0

  def color(self, r, g=0, b=0):
    if isinstance(r, tuple) or isinstance(r,list):
      r, g, b = r[0], r[1], r[2]
    return self.color_mode == 0 and (r,g,b) or r<<11 | g<<5 | b

  def __init__(self):

    try: # TI-Nspire Ndless
      from nsp import Texture as myscr
      self.w, self.h = 320, 240
      myscr = myscr(self.w, self.h, None)
      self.get_pixel = myscr.getPx
      self.set_pixel = myscr.setPx
      self.show_screen = myscr.display
      self.need_show_screen = True
      self.color_mode = 1

    except:

      try: # TI-83/84 CE
        import ti_graphics as myscr
        self.get_pixel = myscr.getPixel
        self.set_pixel = myscr.setPixel

      except ImportError:

        try: # Casio USB Power Graphic 3
          import casioplot as myscr
          self.show_screen = myscr.show_screen
          self.need_show_screen = True

        except ImportError: # NumWorks
          import kandinsky as myscr

        self.get_pixel = myscr.get_pixel
        self.set_pixel = myscr.set_pixel

    # detect readable pixel array
    if self.w <= 0:

      def _can_get_pixel(x, y):
        c = self.get_pixel(x, y)
        if c == self.color(0, 0, 0):
          self.set_pixel(x, y, self.color(255,0,0))
          c = self.get_pixel(x, y)
        return c is not None and c != self.color(0, 0, 0)

      self.w, self.h, dw, dh = 0, 0, 1, 1
      while dw or dh:
        if not _can_get_pixel(self.w - (dw == 0),self.h - (dh == 0)):
          if _can_get_pixel(self.w,self.h-1): dh = 0
          elif _can_get_pixel(self.w-1,self.h): dw = 0
          else: dw, dh = 0, 0
        self.w += dw;  self.h += dh

    # detect writable pixel array
    # remove top status bar

    def _can_set_pixel(x, y):

      def _invert_color(r, g=0, b=0):
        if isinstance(r, tuple) or isinstance(r,list):
          r, g, b = r[0], r[1], r[2]
        return self.color(~r & 0xFF, ~g & 0xFF, ~b & 0xFF)

      c = self.get_pixel(x, y)
      self.set_pixel(x, y, _invert_color(c))
      return c != self.get_pixel(x, y)

    self.w0, self.h0 = self.w, self.h
    while not _can_set_pixel(0, self.y0):
      self.y0 += 1; self.h0 -= 1


Appelons enfin le code suivant pour obtenir toutes les informations écran :
Code: Select all
scr = polyscr()
print('can get {}x{} pixels at (0,0)'.format(scr.w, scr.h))
print('can set {}x{} pixels at ({},{})'.format(scr.w0, scr.h0, scr.x0, scr.y0))

Voilà, nous bénéficions en réalité d'un accès total à seulement
320×210
pixels, les écritures sur les 30 premières lignes de l'écran étant ignorées.

A noter que l'origine restant tout en haut à gauche de l'écran, les valeurs de paramètres
y
à utiliser pour tes scripts adressant les pixels démarreront obligatoirement à 30.

Puisque notre classe
polyscr
cible la compatibilité, profitons-en pour comparer avec les modèles concurrents :


Dans la version alpha qui a fuité pour
HP Prime
avec l'application
Python
, il y a bien une fonction prime.pixon(x, y, c) pour allumer les pixels.
Mais à la différence, rien pour tester l'état d'un pixel.

Procédons donc autrement en tentant de tracer un rectangle aussi grand que possible à l'aide du code suivant :
Code: Select all
import prime as scr

def rect(x, y, w, h, c=(0,0,0)):
  for k in range(w):
    scr.pixon(x+k, y, c)
    scr.pixon(x+k, y+h-1, c)
  for k in range(h):
    scr.pixon(x, y+k, c)
    scr.pixon(x+w-1, y+k, c)

L'appel rect(0, 0, 320, 240, 255<<16) nous affiche bien un rectangle au complet et nous confirme donc que nous contrôlons ici la totalité des 320×240 pixels de l'écran.

D'où le classement en terme de zones graphiques dédiées au
Python
:
  1. 320×240 = 76800
    pixels :
    HP Prime
  2. 384×192 = 73728
    pixels :
    Casio Graph 90+E
  3. 320×222 = 71040
    pixels :
    NumWorks
  4. 320×210 = 67200
    pixels :
    TI-83 Premium CE Edition Python
  5. 128×64 = 8192
    pixels :
    Casio Graph 35+E II
  1. 320×240 = 76800
    pixels :
    HP Prime
    +
    TI-Nspire
    (appli MicroPython)
  2. 384×192 = 73728
    pixels :
    Casio Graph 90+E / fx-CG50
  3. 320×222 = 71040
    pixels :
    NumWorks
  4. 320×210 = 67200
    pixels :
    TI-83 Premium CE Edition Python
  5. 128×64 = 8192
    pixels :
    Casio Graph 35+E II / fx-9750/9860GIII




3) profondeur de couleurs

Go to top

Comme vu plus haut avec les fonctions
getPixel()
et
setPixel()
et comme l'on peut encore le remarquer à quelques couleurs remarquables définies dans
ti_graphics
, les couleurs sont spécifiées en coordonnées RGB-888
(Rouge, Green/Vert, Bleu, avec 8 bits par canal autorisant donc des entiers de 0 à 28-1=255)
.

Mais couleurs spécifiées et affichées sont deux choses différentes. Pour mieux t'illustrer les possibilités
Python
de ton écran graphique en terme de couleurs, nous allons t'afficher un dégradé avec toutes les couleurs et tous les éclairages. :D

Pour cela nous travaillerons en coordonnées HSV/TSV
(Hue/teinte, Saturation, Valeur)
, bien plus naturelles et donc intuitives pour l'oeil humain que les coordonnées RGB :
  • teinte
    qui sera ici codée par un nombre flottant de 0 à 2 est en gros ce que tu appelles naturellement couleur.
  • saturation
    , un flottant de 0 à 1 indique de façon inverse la quantité de blanc.
  • valeur
    , ici encore un flottant de 0 à 1 indique de façon inverse la quantité de noir.
Les coordonnées ainsi précisées seront alors converties en coordonnées RGB compatibles avec la calculatrice.

Bricolons-nous donc quelques petites fonctions pour ça :
Code: Select all
from polyscr import *

scr = polyscr()

def hsv2c(h,s,v):
  c=v*s
  x,m,k=c*(1-abs((h%(2/3))*3-1)),v-c,(h*3)//1
  return (round(255*(m+x*(k%3==1)+c*(k%5==0))),round(255*(m+c*(k==1 or k==2)+x*(k%3==0))),round(255*(m+x*(k%3==2)+c*(k==3 or k==4))))

def grad(x,y,w,h):
  for i in range(w):
    for j in range(h):
      c=hsv2c(2*j/(h-1),i>=w//2 and 1 or i/(w//2-1),i<w//2 and 1 or (w-1-i)/((w-w//2)-1))
      scr.set_pixel(x+i,y+j,c)


L'appel suivant nous produit alors l'affichage ci-contre :
Code: Select all
grad(scr.x0, scr.y0, scr.w0, scr.h0)

Fantastique, non ? Quand tu penses que dans le langage
TI-Basic
historique tu n'avais droit qu'à 15 couleurs, mais comment as-tu pu survivre avec ça ? :p

Déjà pour information, on peut mesurer précisément le temps d'affichage à l'aide du script suivant. L'appel timer(grad, scr.x0, scr.y0, scr.w0, scr.h0) nous renvoie alors
25min 24,283s
.
Code: Select all
from time import monotonic

def timer(f, *par):
  start=monotonic()
  f(*par)
  return monotonic()-start


Or, remarquons un petit truc fort intéressant, une exclusivité à ce jour par rapport à la concurrence. Le module
ti_graphics
fournit d'origine une fonction de conversion de coordonnées
HSV
en coordonnées
RGB
,
hsv_to_rgb(h, s, v)
. :o
Ce qui veut dire que tu n'as pas à t'embêter à la coder et peux donc ainsi économiser de la mémoire, et qu'elle est peut-être déjà optimisée. ;)

Empressons-nous de tester. Modifions déjà notre bibliothèque de compatibilité pour permettre l'accès à ce genre de fonction spécifique :
Code: Select all
class polyscr:
  w, h, w0, h0, x0, y0 = 0, 0, 0, 0, 0, 0
  myscr = None
  # get_pixel(x, y)
  # set_pixel(x, y, color(r8, g8, b8))
  show_screen = lambda self: None
  need_show_screen = False
  # color mode :
  # 0: (R8, G8, B8)
  # 1: int RGB-565
  color_mode = 0

  def color(self, r, g=0, b=0):
    if isinstance(r, tuple) or isinstance(r,list):
      r, g, b = r[0], r[1], r[2]
    return self.color_mode == 0 and (r,g,b) or r<<11 | g<<5 | b

  def __init__(self):

    try: # TI-Nspire Ndless
      from nsp import Texture as myscr
      self.w, self.h = 320, 240
      myscr = myscr(self.w, self.h, None)
      self.get_pixel = myscr.getPx
      self.set_pixel = myscr.setPx
      self.show_screen = myscr.display
      self.need_show_screen = True
      self.color_mode = 1

    except:

      try: # TI-83/84 CE
        import ti_graphics as myscr
        self.get_pixel = myscr.getPixel
        self.set_pixel = myscr.setPixel

      except ImportError:

        try: # Casio USB Power Graphic 3
          import casioplot as myscr
          self.show_screen = myscr.show_screen
          self.need_show_screen = True

        except ImportError: # NumWorks
          import kandinsky as myscr

        self.get_pixel = myscr.get_pixel
        self.set_pixel = myscr.set_pixel

    self.myscr = myscr

    # detect readable pixel array
    if self.w <= 0:

      def _can_get_pixel(x, y):
        c = self.get_pixel(x, y)
        if c == self.color(0, 0, 0):
          self.set_pixel(x, y, self.color(255,0,0))
          c = self.get_pixel(x, y)
        return c is not None and c != self.color(0, 0, 0)

      self.w, self.h, dw, dh = 0, 0, 1, 1
      while dw or dh:
        if not _can_get_pixel(self.w - (dw == 0),self.h - (dh == 0)):
          if _can_get_pixel(self.w,self.h-1): dh = 0
          elif _can_get_pixel(self.w-1,self.h): dw = 0
          else: dw, dh = 0, 0
        self.w += dw;  self.h += dh

    # detect writable pixel array
    # remove top status bar

    def _can_set_pixel(x, y):

      def _invert_color(r, g=0, b=0):
        if isinstance(r, tuple) or isinstance(r,list):
          r, g, b = r[0], r[1], r[2]
        return self.color(~r & 0xFF, ~g & 0xFF, ~b & 0xFF)

      c = self.get_pixel(x, y)
      self.set_pixel(x, y, _invert_color(c))
      return c != self.get_pixel(x, y)

    self.w0, self.h0 = self.w, self.h
    while not _can_set_pixel(0, self.y0):
      self.y0 += 1; self.h0 -= 1


Modifions maintenant le script de tracer du dégradé :
Code: Select all
from polyscr import *

scr = polyscr()

def grad(x,y,w,h):
  for i in range(w):
    for j in range(h):
      c=scr.myscr.hsv_to_rgb(360*j/(h-1),i>=w//2 and 1 or i/(w//2-1),i<w//2 and 1 or (w-1-i)/((w-w//2)-1))
      scr.set_pixel(x+i,y+j,c)


Ce n'est pas la révolution mais c'est quand même significatif, l'appel timer(grad, scr.x0, scr.y0, scr.w0, scr.h0) ne mesure plus que
24min 33,282s
. On gagne 1 minute, soit environ 4%. :)

Bon, revenons-en enfin à cet affichage de dégradé. Si tu regardes bien, tu remarqueras que les lignes tirant sur le vert donnent 2 fois plus de teintes intermédiaires et donc un dégradé bien plus continu, bien moins saccadé.

C'est-à-dire que même si les coordonnées sont spécifiées en RGB-888, le matériel utilise pour sa part du RGB-565 :
  • 25=32 teintes de rouge
  • 26=64 teintes de vert
  • 25=32 teintes de bleu

Passons maintenant à la
HP Prime
. La version alpha avec
Python
publiée par erreur n'étant pas très stable, nous utiliserons un code dédié mais équivalent :
Code: Select all
import prime as scr

def grad(x,y,w,h):
  for i in range(w):
    for j in range(h):
      _h = 2*j/(h-1)
      _s = i>=w//2 and 1 or i/(w//2-1)
      _v = i<w//2 and 1 or (w-1-i)/((w-w//2)-1)
      _c=_v*_s
      _x,_m,_k=_c*(1-abs((_h%(2/3))*3-1)),_v-_c,(_h*3)//1
      scr.pixon(x+i,y+j,round(255*(_m+_x*(_k%3==1)+_c*(_k%5==0)))*2**16 + round(255*(_m+_c*(_k==1 or _k==2)+_x*(_k%3==0)))*2**8 + round(255*(_m+_x*(_k%3==2)+_c*(_k==3 or _k==4))))

12489On pourrait croire à la capture d'écran ci-contre présentant des saccades régulières dans l'ensemble des teintes que l'on aurait affaire à du RGB-666, ce qui n'est pas très logique.
En réalité, c'est le protocole utilisé pour les captures d'écran qui fait perdre des informations couleur, et il faut donc se référer à la photo ci-contre.
Sur la photo donc aucune saccade mais un dégradé des plus lisses, c'est ici du RGB-888 :
  • 28=256 teintes de rouge
  • 28=256 teintes de vert
  • 28=256 teintes de bleu

Ici encore, il serait bien de pouvoir détecter cela automatiquement sans intervention humaine.

Et bien c'est possible si on se rend compte que les valeurs effectivement réglées pour les pixels diffèrent parfois de celles spécifiées. ;)

Modifions encore une fois notre classe
polyscr
avec un test de ces différences :
Code: Select all
class polyscr:
  w, h, w0, h0, x0, y0 = 0, 0, 0, 0, 0, 0
  col_bits = [8, 8, 8]
  myscr = None
  # get_pixel(x, y)
  # set_pixel(x, y, color(r8, g8, b8))
  show_screen = lambda self: None
  need_show_screen = False
  # color mode :
  # 0: (R8, G8, B8)
  # 1: int RGB-565
  color_mode = 0
  has_color = True

  def color(self, r, g=0, b=0):
    if isinstance(r, tuple) or isinstance(r,list):
      r, g, b = r[0], r[1], r[2]
    return self.color_mode == 0 and (r,g,b) or r<<(self.col_bits[0]+self.col_bits[1]) | g<<self.col_bits[0] | b

  def __init__(self):

    try: # TI-Nspire Ndless
      from nsp import Texture as myscr
      self.w, self.h = 320, 240
      myscr = myscr(self.w, self.h, None)
      self.get_pixel = myscr.getPx
      self.set_pixel = myscr.setPx
      self.show_screen = myscr.display
      self.need_show_screen = True
      self.color_mode = 1
      self.col_bits = (5, 6, 5)

    except:

      try: # TI-83/84 CE
        import ti_graphics as myscr
        self.get_pixel = myscr.getPixel
        self.set_pixel = myscr.setPixel

      except ImportError:

        try: # Casio USB Power Graphic 3
          import casioplot as myscr
          self.show_screen = myscr.show_screen
          self.need_show_screen = True

        except ImportError: # NumWorks
          import kandinsky as myscr

        self.get_pixel = myscr.get_pixel
        self.set_pixel = myscr.set_pixel

    self.myscr = myscr

    # detect readable pixel array
    if self.w <= 0:

      def _can_get_pixel(x, y):
        c = self.get_pixel(x, y)
        if c == self.color(0, 0, 0):
          self.set_pixel(x, y, self.color(255,0,0))
          c = self.get_pixel(x, y)
        return c is not None and c != self.color(0, 0, 0)

      self.w, self.h, dw, dh = 0, 0, 1, 1
      while dw or dh:
        if not _can_get_pixel(self.w - (dw == 0),self.h - (dh == 0)):
          if _can_get_pixel(self.w,self.h-1): dh = 0
          elif _can_get_pixel(self.w-1,self.h): dw = 0
          else: dw, dh = 0, 0
        self.w += dw;  self.h += dh

    # detect writable pixel array
    # remove top status bar

    def _can_set_pixel(x, y):

      def _invert_color(r, g=0, b=0):
        if isinstance(r, tuple) or isinstance(r,list):
          r, g, b = r[0], r[1], r[2]
        return self.color(~r & 0xFF, ~g & 0xFF, ~b & 0xFF)

      c = self.get_pixel(x, y)
      self.set_pixel(x, y, _invert_color(c))
      return c != self.get_pixel(x, y)

    self.w0, self.h0 = self.w, self.h
    while not _can_set_pixel(0, self.y0):
      self.y0 += 1; self.h0 -= 1

    if not self.color_mode:

      # test color screen
      self.set_pixel(self.x0, self.y0, (0, 127, 255))
      col = self.get_pixel(self.x0, self.y0)
      self.has_color = col[0] != col[1] or col[1] != col[2]

      # detect color channel bits
      self.set_pixel(self.x0, self.y0, (255, 255, 255))
      col = list(self.get_pixel(self.x0, self.y0))
      for k in range(3):
        while col[k]<255:
          col[k] += 2 ** (8 - self.col_bits[k])
          self.col_bits[k] -= 1


Appelons enfin le code suivant pour obtenir l'intégralité des informations écran, et les comparer aux solutions concurrentes :
Code: Select all
scr = polyscr()
print('can get {}x{} pixels at (0,0)'.format(scr.w, scr.h))
print('can set {}x{} pixels at ({},{})'.format(scr.w0, scr.h0, scr.x0, scr.y0))
print(scr.has_color and 'color' or 'monochrome')
if scr.has_color: print('internal : RGB{}{}{}'.format(scr.col_bits[0], scr.col_bits[1], scr.col_bits[2]))

Voilà, nous obtenons bien comme prévu du
RGB565
pour le format utilisé en interne pour les pixels

Testons également la concurrence en lançant le même code :


Au classement selon les meilleurs rendus de couleurs, nous avons donc :
  1. 24
    bits /
    16777216
    couleurs:
    HP Prime
    (version alpha)
  2. 16
    bits /
    65536
    couleurs:
    TI-83 Premium CE Edition Python
    +
    Casio Graph 90+E
    +
    NumWorks
  3. 1
    bit /
    2
    couleurs:
    Casio Graph 35+E II
  1. 24
    bits /
    16777216
    couleurs:
    HP Prime
    (version alpha)
  2. 16
    bits /
    65536
    couleurs:
    TI-83 Premium CE Edition Python
    +
    Casio Graph 90+E / fx-CG50
    +
    NumWorks
    +
    TI-Nspire CX
  3. 1
    bit /
    2
    couleurs:
    Casio Graph 35+E II / fx-9750/9860GIII
    +
    TI-Nspire




4) allumage de pixels et performances

Go to top

Tentons maintenant de déterminer les performances graphiques, soit la vitesse d'allumage des pixels.

Reprenons déjà le script permettant de chronométrer l'exécution d'une fonction :
Code: Select all
from time import monotonic

def timer(f, *par):
  start=monotonic()
  f(*par)
  return monotonic()-start


Faisons maintenant un script allumant un par un tous les pixels de l'écran, et afin de mieux pouvoir mesurer et comparer les performances graphiques nous minimiserons les calculs en ne faisant pas appel à notre classe de compatibilité, mais en appelant directement les fonctions graphiques :
Code: Select all
from ti_graphics import *

def rectf(x, y, w, h, c=(0, 0, 0)):
  for i in range(h):
    for k in range(w):
      setPixel(x+j, y+i, c)


L'appel timer(rectf, 0, 30, 320, 210, (255, 0, 0))) nous retourne
1390.487s
soit
23min10.487s
pour l'allumage donc de
320×210
pixels.

Voici maintenant la version
NumWorks
:
Code: Select all
from kandinsky import *

def rectf(x, y, w, h, c=(0, 0, 0)):
  for i in range(h):
    for k in range(w):
      set_pixel(x+j, y+i, c)

L'appel timer(rectf, 0, 30, 320, 222, (255, 0, 0))) pour chronométrer l'allumage de
320×222
pixels nous donne :
  • 1.541s sur
    NumWorks N0110
    munie du
    firmware officiel
    Epsilon
  • 1.145s sur
    NumWorks N0110
    munie du
  • 1.605s sur
    NumWorks N0100
    munie du
    firmware officiel
    Epsilon
  • 1.623s sur
    NumWorks N0100
    munie du

Passons maintenant sur
Casio
. Ici hélas pas de module
timer
, donc il va falloir chronométrer à la main, bien évidemment avec une montre
Casio
. Autre différence, les affichages sont à la différence effectués ici sur un calque invisible et ne passent à l'écran que lorsqu'on le demande. Afin donc de tester dans des conditions aussi équivalentes que possibles, nous demanderons un affichage écran après chaque traitement de pixel.
Code: Select all
from casioplot import *

def rectf(x, y, w, h, c=(0, 0, 0)):
  for i in range(h):
    for k in range(w):
      set_pixel(x+j, y+i, c)
      show_screen()

12491La montre
Casio
nous retourne :
  • 1.64s pour l'appel rectf(0, 0, 128, 64, (0, 0, 0) sur
    Graph 35+E II
  • 9.93s pour l'appel rectf(0, 0, 384, 192, (255, 0, 0) sur
    Graph 90+E

De façon similaire pour
TI-Nspire Ndless
:
Code: Select all
import nsp.Texture as scr

scr = scr(320, 240, None)

def rectf(x, y, w, h, c=0):
  for i in range(h):
    for k in range(w):
      scr.setPx(x+j, y+i, c)
      scr.display()

Nous n'avons malheureusement pas de montre
Texas Instruments
, espérons donc que la montre
Casio
ne trichera pas trop. ;)
  • 10min36.74s pour l'appel rectf(0, 0, 320, 240, 31) sur
    TI-Nspire CX CR4+
  • 21min15.42s pour l'appel rectf(0, 0, 320, 240, 31) sur
    TI-Nspire CX CR3-
  • 4min49.5s pour l'appel rectf(0, 0, 320, 240, 0) sur
    TI-Nspire

Enfin sur
HP Prime G1
:
Code: Select all
from prime import *

def rectf(x, y, w, h, c=0):
  for i in range(h):
    for k in range(w):
      pixon(x+j, y+i, c)

La machine nous remplit tout l'écran en seulement 0.49s ! :bj:


Bien évidemment, tous ces écrans ont des définitions différentes. Pour le classement ramenons cela en terme de vitesse d'affichage :
  1. 156735
    pixels/s:
    HP Prime G1
    (version alpha)
  2. 62044
    pixels/s:
    NumWorks N0110
  3. 46100
    pixels/s:
    NumWorks N0110
  4. 44262
    pixels/s:
    NumWorks N0100
  5. 43771
    pixels/s:
    NumWorks N0100
  6. 7425
    pixels/s :
    Casio Graph 90+E
  7. 4995
    pixels/s :
    Casio Graph 35+E II
  8. 48
    pixels/s :
    TI-83 Premium CE Edition Python
  1. 156735
    pixels/s:
    HP Prime G1
    (version alpha)
  2. 62044
    pixels/s:
    NumWorks N0110
  3. 46100
    pixels/s:
    NumWorks N0110
  4. 44262
    pixels/s:
    NumWorks N0100
  5. 43771
    pixels/s:
    NumWorks N0100
  6. 7425
    pixels/s :
    Casio Graph 90+E / fx-CG50
  7. 4995
    pixels/s :
    Casio Graph 35+E II / fx-9750/9860GIII
  8. 265
    pixels/s:
    TI-Nspire
  9. 121
    pixels/s:
    TI-Nspire CX CR4+
  10. 60
    pixels/s:
    TI-Nspire CX CR3-
  11. 48
    pixels/s :
    TI-83 Premium CE Edition Python

En terme de boucle d'allumages individuels de pixels, la
TI-83 Premium CE Edition Python
ne serait donc apparemment pas très performante.
Mais attends un petit peu avant de partir, nous sommes très loin d'avoir dit notre dernier mot, nous allons approfondir cela de suite dans les deux prochaines parties.



5) écriture texte et performances

Go to top

Nous avions été assez déçus des instructions d'affichage de texte présentes dans les modules
ti_plotlib
et :
  • impossibilité de positionner le texte comme on voulait verticalement, nous ne pouvions que choisir une des 11 à 12 bandes horizontales de 17 pixels de hauteur, numérotées de haut en bas, même dans le contexte de
    ti_plotlib
    pourtant censé travailler dans un repère :(
  • impossibilité de positionner le texte comme on voulait horizontalement, nous ne pouvion que choisir entre l'aligner à gauche, au centre ou à droite :'(
  • et en prime effet de bord sur l'affichage avec effacement de la partie droite non utilisée de la bande ou même de toute la bande :mj:

ti_graphics
dispose lui aussi d'une instruction d'affichage similaire drawString('texte', x, y).
Mais ici rien à voir avec les précédentes,
(x, y)
sont les coordonnées comptées cette fois-ci au pixel près à partir du coin en haut à gauche, et le tout ne produit aucun effet de bord ! :bj:

Si si, tu pourras bien afficher tes textes en toute liberté ! :D
Code: Select all
from ti_system import *
import ti_graphics as scr

tw = 10
s = 'Thank you TI'
xmin, xmax, ymin, ymax = 0, 319, 30, 239
x, y, dx, dy = xmin, ymin, 1, 9

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

C'est le cas de le dire,
merci TI
! ;)


Et puis, ce n'est pas tout. Le test de la partie précédente nous a donc donné une vitesse de traitement calamiteuse de moins d'une 50aine de pixels à la seconde.

Et pourtant, aucun problème ici avec la fonction
drawString()
, l'affichage pourtant conséquent en nombre de pixels prenant moins d'une paire de secondes ! :D

Que se passe-t-il donc ? Sans doute que c'est ici qu'il faut tenir comtpe de l'architecture matérielle très spéciale de la
TI-83 Premium CE
, avec :
  • un cœur secondaire
    Atmel SAMD21E18A-U
    intégrant un
    ARM Cortex-M0+
    cadencé à
    48 MHz
    , coprocesseur 32-bits dédié à l'exécution des scripts
    Python
  • un cœur principal
    eZ80
    qui à la différence dispose d'un accès direct à l'ensemble des autres composantes matérielles
    (
    Flash
    , contrôleur écran, cœur secondaire...)
Et justement, on peut donc imaginer que chaque appel à
setPixel()
dans le test précédent génère un événement de mise à jour écran qui doit repasser par le processeur principal avant d'atteindre ce dernier, d'où une certaine latence pour une boucle travaillant de façon individuelle sur des pixels.
Alors qu'ici chaque appel à
drawString()
allume d'un coup plein de pixels que l'on peut supposer à la différence partager un seul et unique événément de mise à jour.

Un comparatif s'appuyant sur une boucle d'allumage de pixels n'est donc pas représentatif des performances graphiques moyennes de la
TI-83 Premium CE Edition Python
puisque c'est pour elle le pire des cas, et donc non pertinent. Mais en même temps, quand les modules graphiques de la concurrence sont à la différence très minimalistes, nous ne voyons pas d'autre fonction commune et identique à utiliser pour construire un test de performances...




6) fonctions de tracé de formes géométriques

Go to top

Abordons maintenant les autres fonctions de tracer de
ti_graphics
.

Les modules équivalents chez la concurrence sont assez minimalistes, te fournissant juste de quoi choisir la couleur, allumer/éteindre des pixels, et afficher du texte. Tu devais te fabriquer tes autres fonctions graphiques
(lignes, rectangles, cercles, etc...)
.
Et bien ici tu es gâté,
ti_graphics
est très riche. ;)
Mais c'est aussi surtout un moyen de répondre au problème découvert plus haut, à savoir que la
TI-83 Premium CE Edition Python
est très lente pour les boucles appelant des
setPixel()
. Coder toi-même ces mêmes fonctions en utilisant
setPixel()
faute de mieux eut été désastreux. :bj:


Commençons déjà par de la configuration. Déjà, on eut effacer l'écran à l'aide de la fonction
cls()
. Son comportement semble identique à celui des fonctions
ti_plotlib.cls()
et
ti_system.disp_clr()
.

La fonction cursor(c=1) permet d'activer ou désactiver l'affichage du curseur de texte, comme le permettait déjà la fonction ti_system.cursor(c).
A la différence ici que les effets des valeurs sont inversés :
  • 0: curseur affiché
  • 1: curseur masqué
Autre différence également; contrairement à
ti_system.cursor()
la fonction
cursor()
admet un comportement par défaut : si appelée sans paramètre elle masque le curseur.

On peut maintenant choisir la couleur du stylo avec setColor(r, g, b), appel équivalent à ti_plotlib.color(r, g, b).
D'ailleurs si l'on importe les deux modules
ti_graphics
et , on peut appeler n'importe laquel de ces deux fonctions pour obtenir le même effet, et ce simultanément dans les deux contextes graphiques. Sans doute que ces deux fonctions partagent le même code.

On peut également régler la plume du stylo, avec setPen(taille, type), un appel donc similaire à ti_plotlib.pen('taille', 'type').
A la différence près que
setPen()
n'accepte pas d'arguments sous forme de chaînes de caractères, uniquement des entiers. On peut donc supposer que est définie pour faire appel à
setPen()
de la façon suivante :
Code: Select all
def setPen(taille, type):
  _strtest(taille)
  _strtest(type)
  if taille == 'thin': taille = 0
  elif taille == 'medium': taille = 1
  elif taille == 'thick': taille = 2
  else: _excpt('Invalid pen size.')
  if type == 'solid': type = 0
  elif type == 'dot': type = 1
  elif type == 'dash': type = 2
  else: _excpt('Invalid pen style.')
  gr.pen(taille, type)

Mais ici, pas d'erreur avec des paramètres supérieurs à 2...

Nous allons voir de suite ce que ça donne. Commençons par la fonction drawLine(x1, y1, x2, y2) :
Code: Select all
from ti_system import *
import ti_graphics as scr

tw, th = 8, 15
xmin, xmax, ymin, ymax = tw, 319, 30+th, 239

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

scr.cls()
for i in range(nty):
  scr.drawString(str(i), xmin-tw, ly[i*2])
  for j in range(nta):
    scr.drawString(str(j), lx[j*2], ymin-th)
    scr.setPen(j, i)
    scr.drawLine(lx[j*2], ly[i*2], lx[j*2 + 1], ly[i*2])
disp_wait()

Ci-contre l'affichage obtenu, ainsi que pour comparaison celui du test similaire dans le contexte de la fonction
ti_plotlib.pen()
.

Ce qui nous permet de terminer la documentation de
pen()
:
  • setPen(0, 0) = ti_plotlib.pen('thin', 'solid')
  • setPen(1, 1) = ti_plotlib.pen('medium', 'dot')
  • setPen(2, 2) = ti_plotlib.pen('thick', 'dash')
Quant à l'appel setPen(3, 3), il permet donc d'accéder à deux réglages secrets non offerts via
ti_plotlib
: :D
  • une taille de stylo encore plus grande que
    'thick'
  • un tracé en pointillés qui enchaîne non pas des tirets mais des petits points
Des valeurs supérieures à 3 donnent quant à elles la même chose que la valeur 2.

Testons maintenant de façon similaire les fonctions drawPolyLine([(x1,y1), (x2,y2), ..., (xn,yn)]) et fillPolyLine([(x1,y1), (x2,y2), ..., (xn,yn)]) :
Code: Select all
from ti_system import *
import ti_graphics as scr

tw, th = 8, 15
xmin, xmax, ymin, ymax = tw, 319, 30+th, 239

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

scr.cls()
for i in range(nty):
  scr.drawString(str(i), xmin-tw, ly[i*2])
  for j in range(nta):
    scr.drawString(str(j), lx[j*2], ymin-th)
    scr.setPen(j, i)
    scr.setColor((255,0,0))
    scr.fillPolygon([(lx[j*2], ly[i*2]), (lx[j*2 + 1], ly[i*2]), (lx[j*2], ly[i*2+1]), (lx[j*2 + 1], ly[i*2+1])])
    scr.setColor((0,0,0))
    scr.drawPolyLine([(lx[j*2], ly[i*2]), (lx[j*2 + 1], ly[i*2]), (lx[j*2], ly[i*2+1]), (lx[j*2 + 1], ly[i*2+1])])
disp_wait()

La fonction
drawPolyLine()
permet donc de tracer une ligne brisée. Elle serait donc équivalente au code suivant :
Code: Select all
def drawPolyLine(l):
  for k in range(len(l) - 1):
    drawLine(l[k][0], l[k][1], l[k+1][0], l[k+1][1])

La fonction
fillPolygon()
permet quant à elle de colorier le polygone obtenu en fermant cette ligne brisée.
Et comme tu vois c'est remarquable, elle marche même avec des polygones croisés ! :)

Passons maintenant à drawRect(x, y, w, h) et fillRect(x, y, w, h) :
Code: Select all
from ti_system import *
import ti_graphics as scr

tw, th = 8, 15
xmin, xmax, ymin, ymax = tw, 319, 30+th, 239

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

scr.cls()
for i in range(nty):
  scr.drawString(str(i), xmin-tw, ly[i*2])
  for j in range(nta):
    scr.drawString(str(j), lx[j*2], ymin-th)
    scr.setPen(j, i)
    scr.setColor((255,0,0))
    scr.fillRect(lx[j*2], ly[i*2], lx[j*2+1]-lx[j*2], ly[i*2+1]-ly[i*2])
    scr.setColor((0,0,0))
    scr.drawRect(lx[j*2], ly[i*2], lx[j*2+1]-lx[j*2], ly[i*2+1]-ly[i*2])
disp_wait()

drawRect(x, y, w, h) permet donc de tracer un rectangle :
  • de dimensions
    w
    et
    h
    données en pixels
  • aux côtés parallèles aux bors de l'écran
  • et en utilisant le point de coordonnées
    (x, y)
    comme sommet supérieur gauche
La fonction
fillRect()
quant à elle permet de colorier le rectangle en question.

Voici maintenant du lourd avec drawArc(x, y, w, h, t1, t2) et fillArc(x, y, w, h, t1, t2) :
Code: Select all
from ti_system import *
import ti_graphics as scr

tw, th = 8, 15
xmin, xmax, ymin, ymax = tw, 319, 30+th, 239

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

scr.cls()
for i in range(nty):
  scr.drawString(str(i), xmin-tw, ly[i*2])
  for j in range(nta):
    scr.drawString(str(j), lx[j*2], ymin-th)
    scr.setPen(j, i)
    scr.setColor((255,0,0))
    scr.fillArc(lx[j*2], ly[i*2], lx[j*2+1]-lx[j*2], ly[i*2+1]-ly[i*2], 0, 3150)
    scr.setColor((0,0,0))
    scr.drawArc(lx[j*2], ly[i*2], lx[j*2+1]-lx[j*2], ly[i*2+1]-ly[i*2], 0, 3150)
disp_wait()

La fonction drawArc(x, y, dx, dy, t1, t2) permet donc de tracer un arc d'une ellipse elle-même inscrite dans un rectangle :
  • de dimensions
    w
    et
    h
    données en pixels
  • aux côtés parallèles aux bors de l'écran
  • et en utilisant le point de coordonnées
    (x, y)
    comme sommet supérieur gauche
t1
et
t2
sont les angles au centre orientés délimitant l'arc en question, exprimés en dixièmes de degrés.

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

Petite curiosité, nous avons une fonction fillCircle(x, y, r) permettant de préciser des éléments caractéristiques différents plus naturels dans le cas particulier d'un disque. La fonction serait donc équivalente au code suivant :
Code: Select all
def fillCircle(x, y, r):
  fillArc(x-r, y-r, 2*r, 2*r, 0, 3600)

Ce qui est curieux ? Et bien qu'il n'y ait apparemment pas de fonction similaire drawCircle(x, y, r) pour le tracé d'un cercle, obligeant dans ce cas à utiliser une logique complètement différente.
Code: Select all
from ti_system import *
import ti_graphics as scr

tw, th = 8, 15
xmin, xmax, ymin, ymax = tw, 319, 30+th, 239

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

scr.cls()
for i in range(nty):
  scr.drawString(str(i), xmin-tw, ly[i*2])
  for j in range(nta):
    scr.drawString(str(j), lx[j*2], ymin-th)
    scr.setPen(j, i)
    scr.setColor((255,0,0))
    scr.fillCircle(lx[j*2]+(ly[i*2+1]-ly[i*2])/2, (ly[i*2]+ly[i*2+1])/2, (ly[i*2+1]-ly[i*2])/2)
    scr.setColor((0,0,0))
    scr.drawArc(lx[j*2], ly[i*2], ly[i*2+1]-ly[i*2], ly[i*2+1]-ly[i*2], 0, 3600)
disp_wait()




7) fonctions dédiées aux images

Go to top


Enorme surprise,
ti_graphics
dispose apparemment de pas moins de 3 fonctions dédiées à l'affichage d'images, et donc entre autres de
sprites
pour tes interfaces de menus et jeux ! :bj:
C'est sans doute un moyen une fois encore de répondre au problème de performances des boucles d'allumage de pixels que tu aurais utilisées par défaut

Mais ces fonctions dédiées n'en restent pas moins un formidable avantage sur la concurrence, ces boucles d'allumage n'étant sur la plupart des modèles pas assez rapides pour permettre d'animer ou déplacer un
sprite
de façon fluide dans le contexte par exemple d'un jeu.


Comme ces fonctions ne sont pas au menu il nous faut donc arriver à deviner ce qu'elles attendent comme arguments.

L'appel pushImage(x, y, w, h) semble définir une image de dimensions
w×h
qui pourra être affichée avec comme coin supérieur gauche le pixel de coordonnées
(x,y)
.
La fonction
popImage()
quant à elle en déclenche ensuite l'affichage, effectivement très rapide même si par défaut cela nous affiche ici n'importe quoi.

Par exemple ci-contre, le résultat du code suivant :
Code: Select all
from ti_system import *
import ti_graphics as scr

scr.pushImage(50, 50, 269, 170)
scr.popImage()
disp_wait()


drawImage(?, ?, ?) doit pour sa part servir à dessiner l'image en question avant affichage, mais nous n'avons pas réussi à en comprendre le fonctionnement.

Si l'on se réfère à notre test précédent ayant mis en évidence que nous disposions de près de 17.5K de mémoire de tas
(heap)
il semble impensable que cette fonction puisse accepter des données d'image brutes, que ce soit sous forme de liste ou de chaîne de caractères. 320×240 pixels codés sur 16 bits nécessiteraient en effet pas moins de 153.6 Ko, qui déclencheront ici une erreur de mémoire.

Nous avons deux hypothèses :
  • Soit la fonction attend une liste ou une chaîne de données compressées par exemple en RLE, et peut-être que
    TI
    a prévu un outil générant automatiquement à partir d'une image fournie la liste ou chaîne compressée à coller dans ton script. Mais en tous cas cet outil ne nous as pas été passé.
  • Soit la fonction attend le nom d'une ressource image à aller chercher en externe dans les variables du système de la calculatrice. En fouillant l'application
    Python
    à l'éditeur hexadécimal nous avons effectivement trouvé un indice en ce sens, avec un
    'imgname'
    qui est bien présent en clair dans le code même nous n'avons trouvé pour le moment aucun menu l'affichant.

En tous cas, faire appel aux variables images préchargées dans le calculatrice avec par exemple scr.drawImage('Image1', 50, 50) semble ne rien donner.

On pouvait quand même s'en douter, vu que ces images ont une taille fixe prévue pour un affichage en plein écran :
  • 265×165 pixels pour les images 16 couleurs
    Pic0
    à
    Pic9
  • 133×83 pixels pour les images d'arrière plan
    Image0
    à
    Image9
    (agrandies d'un facteur 2 pour l'affichage)
C'est donc en total contradiction avec les quelques arguments devinés pour le moment.

Peut-être donc plutôt que
drawImage()
va chercher des
AppVars (variables d'applications)
qui contiendraient des images dédiées au
Python
et qu'un futur
TI-Connect CE 5.5
effectuera la conversion à la volée lorsque l'on lui fournira des images. Ce serait l'hypothèse la plus plausible, mais en tous cas on ne nous l'a pas passé.




8) ti_graphics et autres fonctions

Go to top

ti_graphics
comporte également quelques autres fonctions privées ou issues d'autres modules.

Déjà, il inclut le module
sys
que tu n'auras donc pas à importer simultanément.

Il inclut également une fonction
sleep()
équivalente à
time.sleep()
, autre économie de mémoire pour tes importations.

La fonction privée _write('') semble être équivalente avec ti_plotlib._write('').

Sauf qu'ici elle est accompagnée d'une fonction _read(n). Attention, si on lui demande de lire plus de données qu'il y en a, on ne sait où en passant, la calculatrice rentre dans une boucle d'attente infinie qu'il est apparemment impossible d'interrompre autrement que par un
reset
.

Egalement quelques autres mystères à découvrir et qui peut-être nous permettront des choses bien pratiques : _grcmd(''), _grcif('') et _handshake(?).




Conclusion

Go to top

Texas Instruments
nous signe donc ici un module
ti_graphics
de dessin sur écran extrêmement complet, face à une concurrence à ce jour très minimaliste sur ce sujet. :)

Il y a clairement eu un travail très conséquent là-dessus, c'est un module conçu à partir de zéro et taillé sur-mesure pour te donner le meilleur avec le matériel choisi pour ta
TI-83 Premium CE Edition Python
. :bj:

Pixels, textes, formes géométriques diverses et images, chaque fonction te permet ici d'exploiter l'intégralité des capacités matérielles.
ti_graphics
te permet de réaliser avec de bien meilleurs performances tout ce que tu pouvais déjà faire avec le langage historique
TI-Basic
et même davantage, notamment au niveau des ellipses, couleurs et images ! :favorite:

De quoi initier de formidables créations
(interfaces de menus, jeux, ...)
pour tes projets, aussi bien scolaires
(SNT, NSI, ...)
que non scolaires ! :D

Merci
TI
!
:favorite:

Vidéoconf modules Python ti_hub + ti_rover 83 Premium CE 5.5

New postby critor » 05 May 2020, 11:19

12382Dans sa prochaine mise à jour
5.5
gratuite prévue pour
Mai 2020
,
Texas Instruments
va rajouter de formidables possibilités à ta
TI-83 Premium CE
:
  • mise à jour en
    5.5
    de l'application
    SciTools
  • mise à jour en
    5.5
    de l'application
    Periodic
  • mise à jour en
    5.5
    de l'application
    Python
    (
    TI-83 Premium CE Édition Python
    uniquement)

Cette dernière application apporte de nouveaux modules importables pour tes scripts
Python
:
  • time
    , certes déjà présent mais maintenant listé au menu et donc officiel; il ne risque plus de disparaitre :)
  • , avec diverses possibilités :
    • détection des simples pressions de touches clavier
      (sans validation donc)
      par l'utilisateur, avec même l'éventuel modificateur actif
      (
      2nde
      ou
      alpha
      )
      , et ça marche aussi avec un clavier
      USB
      ! :bj:
    • affichage dans la console à la ligne que tu veux :bj:
    • exportation de listes de nombres
      (entiers, flottants ou complexes)
      existant dans le contexte
      Python
      vers l'environnement de la calculatrice, pour traitement à l'aide d'autres applications :bj:
    • importation depuis le contexte
      Python
      de listes ou équation de régression existant dans l'environnement de la calculatrice :bj:
    • et donc plus généralement un début d'intégration du
      Python
      à l'environnement mathématique de la calculatrice, enfin l'application
      Python
      va pouvoir servir non plus seulement à coder un truc déconnecté dans un coin, mais à traiter des problèmes et tâches complexes dans leur globalité ! :bj:
  • , une bibliothèque graphique pour tracer dans un repère othogonal, conformément aux programmes de
    Mathématiques
    et
    Physique-Chimie
  • pour tracer directement sur l'écran au pixel près
  • ti_hub
    , pour les projets d'objects connectés à l'aide de l'interface :)
  • ti_rover
    , pour les projets de robotique à l'aide du :)
Nous t'avions donc déjà exploré les possibilités des modules
ti_system
,
ti_plotlib
et
ti_graphics
.

Envie de découvrir les formidables possibilités des nouveaux modules
Python
ti_hub
et
ti_rover
couplés aux périphériques
TI-Innovator Hub
et
TI-Innovator Rover
? ;)

Texas Instruments
t'invite ce
mercredi 6 mai 2020
à
18h30
pour une vidéoconférence précisément dédiée à ces nouveaux modules
Python
. :D

Au cours de cette formation en ligne d'
1h30
te seront présentés plusieurs projets réalisables en classe, particulièrement dans le contexte de l'enseignement
SNT
niveau
2nde
.

125029679Notons que ton hôte
Jean Baptiste Civet
, professeur de Mathématiques sur Marseille et formateur
T3
pour
Texas Instruments
, est justement coauteur des cahiers d'activités dédiés à ta
TI-83 Premium CE Edition Python
disponibles chez
Eyrolles
:

Inscription
:
https://tiedtech.webex.com/mw3300/myweb ... &service=6

Module Python turtle rajoutable TI-83 Premium CE 5.5 !

New postby critor » 05 May 2020, 14:34

12382Dans sa prochaine mise à jour
5.5
gratuite prévue pour
Mai 2020
,
Texas Instruments
va rajouter de formidables possibilités à ta
TI-83 Premium CE
:
  • mise à jour en
    5.5
    de l'application
    SciTools
  • mise à jour en
    5.5
    de l'application
    Periodic
  • mise à jour en
    5.5
    de l'application
    Python
    (
    TI-83 Premium CE Édition Python
    uniquement)

Cette dernière application apporte de nouveaux modules importables pour tes scripts
Python
:
  • time
    , certes déjà présent mais maintenant listé au menu et donc officiel; il ne risque plus de disparaitre :)
  • , avec diverses possibilités :
    • détection des simples pressions de touches clavier
      (sans validation donc)
      par l'utilisateur, avec même l'éventuel modificateur actif
      (
      2nde
      ou
      alpha
      )
      , et ça marche aussi avec un clavier
      USB
      ! :bj:
    • affichage dans la console à la ligne que tu veux :bj:
    • exportation de listes de nombres
      (entiers, flottants ou complexes)
      existant dans le contexte
      Python
      vers l'environnement de la calculatrice, pour traitement à l'aide d'autres applications :bj:
    • importation depuis le contexte
      Python
      de listes ou équation de régression existant dans l'environnement de la calculatrice :bj:
    • et donc plus généralement un début d'intégration du
      Python
      à l'environnement mathématique de la calculatrice, enfin l'application
      Python
      va pouvoir servir non plus seulement à coder un truc déconnecté dans un coin, mais à traiter des problèmes et tâches complexes dans leur globalité ! :bj:
  • , une bibliothèque graphique pour tracer dans un repère othogonal, conformément aux programmes de
    Mathématiques
    et
    Physique-Chimie
    , comparable à
    matplotl
    chez
    Casio
    ou encore
    matplotlib.pyplot
  • pour contrôler directement les pixels de l'écran, comparable à
    kandinsky
    chez
    NumWorks
    ou encore
    casioplot
  • ti_hub
    , pour les projets d'objects connectés à l'aide de l'interface :)
  • ti_rover
    , pour les projets de robotique à l'aide du :)
Nous t'avions donc déjà exploré les possibilités des modules
ti_system
,
ti_plotlib
et
ti_graphics
.

A priori donc pas de module
turtle
. Trouvais-tu donc les possibilités graphiques décevantes ? ;)

Et bien si, crois-le ou pas mais la formidable mise à jour
5.5
n'en a pas terminé de te révéler sa pléthore de secrets. :D
Texas Instruments
nous a bien concocté en secret un module comparable à
turtle
ici appelé
ce_turtl
! :bj:

Décidément, c'est bien une mise à jour historique que
Texas Instruments
est en train de te préparer. La plus grande mise à jour depuis le lancement de la
TI-83 Premium CE
à la rentrée 2015 ? ;)

Non non tu ne rêves pas. Nous ne t'en avions pas parlé jusqu'à présent car la solution retenue est étrangement similaire à celle de
Casio
. C'est-à-dire que le module
ce_turtle
n'est pas intégré à la mise à jour
5.5
et voilà donc pourquoi tu n'as pu en noter aucune trace jusqu'à présent. Il prend en fait la forme d'un fichier externe de variable d'application
ce_turtle.8xv
qu'il faut à ce jour rajouter manuellement.

Toutefois
ce_turtle
semble nous réserver quelques surprises, puisqu'une fois rajouté au contenu de la calculatrice ses icônes et types dans l'explorateur de
TI-Connect CE
diffèrent de ceux utilisés pour les scripts
Python
, un objet donc a priori fort intéressant... :roll:

Effectivement grosse surprise, la calculatrice ne liste pas
ce_turtl
avec les autres scripts
Python
transférés, mais avec les autres modules intégrés importables ! :o

Cela voudrait-il dire que
Texas Instruments
a codé un moyen de rajouter ses propres modules ? :#roll#:

Outre ce détail, en quoi
ce_turtl
diffère-t-il d'un script
Python
normal ?

Et bien à partir de l'entrée précédente tu as ici accès à un menu par onglets documentant ses différentes fonctions et en facilitant l'accès ! :D

Peut-être y a-t-il d'autres avantages à utiliser un module rajouté plutôt qu'un script
Python
normal comme
Casio
, comme la disponibilité en mode examen. Ne disposant pas à ce jour du fichier
ce_turtle.8xv
nous ne pouvons pas tester, mais ne manquerons pas de t'en informer aussitôt que possible. :)

Maintenant pour l'utilisation, l'importation du module
ce_turtle
apporte apparemment un objet
turtle
.

Il est donc a priori possible de construire du code compatible avec différents modèles à l'aide des lignes suivantes :
Code: Select all
try:
  from ce_turtl import turtle
except:
  import turtle


Terminons justement avec quelques exemples pour commencer à découvrir la compatibilité. Nous utiliserons une fonction annexe
mypencolor()
pour le réglage de la couleur de crayon, afin de contourner une divergence déjà évoquée chez
NumWorks
.

Voici les
flocons de Koch
:
Graph
35+E II
Graph
90+E
TI-83 Premium CE
Edition Python
Num
Works
ordi
Code: Select all
try:
  from ce_turtl import turtle
except:
  import turtle

def mypencolor(t):
  cmax=255
  try:
    turtle.pencolor((2, 2, 2))
  except:
    cmax=1
  if cmax==1 and max(t)>1:
    t=tuple(u/255 for u in t)
  elif cmax==255 and any(isinstance(u, float) for u in t):
    t=tuple(int(255*u) for u in t)
  turtle.pencolor(t)
 
def koch(n, l):
  if n<=0:
    turtle.forward(l)
  else:
    koch(n-1, l/3)
    turtle.left(60)
    koch(n-1, l/3)
    turtle.right(120)
    koch(n-1, l/3)
    turtle.left(60)
    koch(n-1, l/3)

def flock(n, l):
  koch(n, l)
  turtle.right(120)
  koch(n, l)
  turtle.right(120)
  koch(n, l)

l=80

turtle.penup()
turtle.forward(5)
turtle.left(90)
turtle.forward(45)
turtle.right(150)
turtle.pendown()
turtle.pensize(3)
mypencolor((0, 0, 255))
flock(2, l)

turtle.penup()
turtle.left(30)
turtle.backward(45)
turtle.right(90)
turtle.backward(105)
turtle.right(90)
turtle.forward(5)
turtle.left(30)
turtle.pendown()
turtle.pensize(5)
mypencolor((0, 255, 0))
flock(1, l)

turtle.penup()
turtle.left(30)
turtle.forward(22)
turtle.left(30)
turtle.pendown()
turtle.pensize(3)
mypencolor((255, 0, 0))
flock(0, l)

turtle.penup()
turtle.left(30)
turtle.forward(14)
turtle.left(90)
turtle.forward(205)
turtle.left(120)
turtle.pendown()
turtle.pensize(1)
mypencolor((0, 0, 0))
flock(3, l)

turtle.penup()
turtle.left(30)
turtle.forward(13)
turtle.pendown()
turtle.left(30)
mypencolor((255, 127, 0))
flock(4, l)

turtle.penup()
turtle.forward(150)

On note en passant également une divergence chez
Casio
, la fonction
turtle.pensize()
ne semblant pas être gérée correctement.

Et maintenant les
triangles de Sierpiński
:
Graph
35+E II
Graph
90+E
TI-83 Premium CE
Edition Python
Num
Works
ordi
Code: Select all
try:
  from ce_turtl import turtle
except:
  import turtle

def mypencolor(t):
  cmax=255
  try:
    turtle.pencolor((2, 2, 2))
  except:
    cmax=1
  if cmax==1 and max(t)>1:
    t=tuple(u/255 for u in t)
  elif cmax==255 and any(isinstance(u, float) for u in t):
    t=tuple(int(255*u) for u in t)
  turtle.pencolor(t)

def sierp(n, l):
    if n == 0:
        for i in range (0, 3):
            turtle.fd(l)
            turtle.left(120)
    if n > 0:
        sierp(n-1, l/2)
        turtle.fd(l/2)
        sierp(n-1, l/2)
        turtle.bk(l/2)
        turtle.left(60)
        turtle.fd(l/2)
        turtle.right(60)
        sierp(n-1, l/2)
        turtle.left(60)
        turtle.bk(l/2)
        turtle.right(60)

turtle.penup()
turtle.backward(109)
turtle.left(90)
turtle.backward(100)
turtle.right(90)
turtle.pendown()
mypencolor((255, 0, 0))
sierp(6, 217)
turtle.penup()
turtle.forward(400)

Merci
Texas Instruments
pour cette belle surprise des modules
Python
rajoutables à laquelle nous ne nous attendions absolument pas. :D

Le module
ce_turtl
hautement pertinent et a priori bénéficiant d'une certaine compatibilité avec le
turtle
standard, offrira donc très bientôt de quoi réinvestir en Seconde les acquis du langage
Scratch
du collège pour une transition en douceur vers le
Python
! :bj:

Mais au-delà de cela, la solution technique retenue est des plus intéressantes. Cela voudrait-il dire qu'il serait à l'avenir possible pour des entités tierces de fournir des modules d'extension
Python
pour la
TI-83 Premium CE Edition Python
; avec peut-être validation par le constructeur via une signature électronique si le mode examen entre dans l'équation ?... ;)

Autres diagrammes Python via modules ajoutables 83PCE 5.5

New postby critor » 06 May 2020, 07:21

12382Dans sa prochaine mise à jour
5.5
gratuite prévue pour
Mai 2020
,
Texas Instruments
va rajouter de formidables possibilités à ta
TI-83 Premium CE
:
  • mise à jour en
    5.5
    de l'application
    SciTools
  • mise à jour en
    5.5
    de l'application
    Periodic
  • mise à jour en
    5.5
    de l'application
    Python
    (
    TI-83 Premium CE Édition Python
    uniquement)

Python 5.5
offre de nouveaux modules intégrés pour tes scripts
Python
:
  • time
    , certes déjà présent mais maintenant listé au menu et donc officiel
  • , avec diverses possibilités :
    • détection des simples pressions de touches clavier
      (sans validation donc)
      par l'utilisateur, avec même l'éventuel modificateur actif
      (
      2nde
      ou
      alpha
      )
      , et ça marche aussi avec un clavier
      USB
      !
    • affichage dans la console à la ligne que tu veux
    • exportation de listes de nombres
      (entiers, flottants ou complexes)
      existant dans le contexte
      Python
      vers l'environnement de la calculatrice, pour traitement à l'aide d'autres applications
    • importation depuis le contexte
      Python
      de listes ou équation de régression existant dans l'environnement de la calculatrice
    • et donc plus généralement un début d'intégration du
      Python
      à l'environnement mathématique de la calculatrice, enfin l'application
      Python
      va pouvoir servir non plus seulement à coder un truc déconnecté dans un coin, mais à traiter des problèmes et tâches complexes dans leur globalité !
  • , une bibliothèque graphique pour tracer dans un repère othogonal, conformément aux programmes de
    Mathématiques
    et
    Physique-Chimie
    , comparable à
    matplotl
    chez
    Casio
    ou encore
    matplotlib.pyplot
    , et gérant ici les diagrammes suivants :
    • nuage de points
    • diagramme en ligne brisée
    • droite de régression linéaire
  • pour contrôler directement les pixels de l'écran, comparable à
    kandinsky
    chez
    NumWorks
    ou encore
    casioplot
  • ti_hub
    , pour les projets d'objects connectés à l'aide de l'interface
  • ti_rover
    , pour les projets de robotique à l'aide du
Mais ce n'est pas tout car
Python 5.5
gère également la possibilité inédite de rajouter des modules
Python
optionnels :

Nuage de points, diagramme en ligne brisée et droite de régression linéaire. Etais-tu déçu(e) par le peu de types de diagrammes différents traçables via le module
Python
ti_plotlib
intégré ? ;)

Et bien non
Texas Instruments
n'a rien oublié; en fait les autres types de diagrammes offerts chez toute ou partie de la concurrence et bien d'autres seront bel et bien disponibles. :bj:

C'est juste qu'ils sont apportés par 3 autres modules
Python
optionnels dont il faut à ce jour rajouter les fichiers manuellement, d'où leur absence jusqu'à présent.

Comme chez
Casio
, le module optionnel
ce_box
te permettra de tracer des boîtes de Tukey, plus connues sous les noms de diagrammes en boîte ou à moustaches. :bj:
On apprécie ici la légende automatique précisant les valeurs des différents paramètres statistiques illustrés. :)
Code: Select all
from ce_box import *
data = [3,2,3,3,1,5,4,3,1,5,2,1,4,3,3,0,1,3,3,1,2,4,2,4,0,0,2,2,3,2]
Ex1 = box(data)
Ex1.title('Exercice 4-1')
Ex1.show()


Le module optionnel
ce_chart
pour sa part te permettra de tracer des histogrammes comme chez
Casio
et
NumWorks
. :D
On noce ici l'affichage automatique des étiquettes de valeurs ainsi que le choix automatique des couleurs. :)
Code: Select all
from ce_chart import *

data = [('A', 6), ('B', 10), ('C', 26), ('D', 8), ('F', 3)]
cht = chart(data)
cht.title('Midterm Grades')
cht.show()


Mais ce n'est pas tout car comme son nom l'indique
ce_chart
ne sert pas qu'aux histogrammes, loin de là. ;)

Il est également capable de représenter des graphes de fonctions; plus besoin donc de t'embêter à les approcher à l'aide de diagrammes en ligne brisée. :bj:
Code: Select all
from ce_chart import *
plt.cls()
plt.window(-6, 6, -4, 4)
plt.axes('on')
f1 = lambda x: -x**2 + 3
f2 = lambda x: 1.5*x + 1
draw_fx(-6, 6, f1, 'r')
draw_fx(-6, 6, f2, 'b')
plt.show_plot()


Et bien évidemment d'autres représentations associées aux fonctions sont alors disponibles, comme l'aire entre deux courbes approchée via la méthode des rectangles. :D

Enfin autre possibilité avec le module optionnel
ce_quivr
, dédié aux diagrammes utilisant des vecteurs que l'on utilise en Physique-Chimie, vecteurs vitesse notamment. :bj:
Code: Select all
import ti_plotlib as plt
from ce_quivr import *

fx = lambda x: x**3 - 4*x**2 + 3*x - 2
dx = lambda x: 3*x**2 - 8*x + 3
d2x = lambda x: 6*x - 8

def motion(min, max, n):
  dt = (max-min) / n
  t = min
  for i in range(n):
    quiver(t, fx(t), t+dt, fx(t+dt), 1, 'blk', 'line')
    if i % 7 == 0:
      quiver(t, fx(t), 0, dx(t), .4, 'r', 'vector')
      quiver(t, fx(t), 0, d2x(t), .4, 'b')
    t += dt

plt.window(-.25, 4, -5, 7)
plt.cls()
plt.title('Motion in one Dimension')
plt.color(0, 0, 0)
plt.axes('on')
plt.labels('Time', '   X Position     ', 7, 3)
motion(0, 4, 49)
plt.show_plot()

Décidément, la charge de travail accomplie par
Texas Instruments
avec le
Python
de la mise à jour
5.5
pour ta
TI-83 Premium CE Edition Python
est des plus impressionnantes. :D

Aussi bien par la quantité de nouvelles fonctionnalités apportées, que par leur haute qualité systématique à chaque fois... :bj:
Le travail de conception fut apparemment méticuleux, puisque de façon régulière hautement pertinent aussi bien comme déjà vu du point de vue de l'adéquation au matériel de la calculatrice, qu'en terme de programmes scolaires, et notamment de spécificités du programme scolaire français. :bj:

A combien d'enseignants experts
Python
TI
a-t-il fait appel et depuis combien de mois années travaillent-ils là-dessus ?... :p

Chess, jeu d'échecs 2 joueurs pour ta TI-83 Premium CE

New postby critor » 07 May 2020, 08:25

12506
Chess
, est un jeu d'échecs par pour ta
TI-83 Premium CE
.

C'est un programme en langage machine
(assembleur)
, exploitant ainsi les possibilités maximales de cette dernière, notamment un affichage plein écran ainsi qu'une excellente fluidité des animations visuelles lorsque tu sélectionnes et déplaces tes pièces. :bj:

L'implémentation des règles est assez fidèle, avec même le coup spécial du
roque entre le roi et une tour
. :)
Par contre, l'autre déplacement spécial de la
prise en passant
ne semble pas géré.

La touche
alpha
te permet même de changer le thème de l'échiquer. :)

Notons qu'il s'agit ici d'une édition 2 joueurs. Mais en attendant ta remise en liberté lundi, tu peux toujours en profiter pour redécouvrir le plaisir de jouer contre un formidable adversaire : toi-même. :D

Et si tu préfères, nous te relions également ci-dessous une autre édition te permettant de choisir d'affronter l'IA, ou même de faire s'affronter 2 IA. :bj:

Merci pour cette belle contribution à la ludothèque de la
TI-83 Premium CE
, fort utile en ce moment. ;)


Téléchargements
:


Falldown, ou comment tomber plus bas sur TI-83 Premium CE

New postby critor » 08 May 2020, 14:41

12508
FallDown
, est un jeu de réflexes par
Iambian
pour ta
TI-83 Premium CE
.

Il s'agit d'un programme compilé en langage machine à partir d'un code source hybride faisant appel à deux langages,
C
et assembleur. Il peut ainsi exploiter au maximum les possibilités de ta calculatrice, notamment un affichage plein écran ainsi qu'une excellente fluidité du défilement de l'affichage, et le code source est inclus et donc librement consultable. :bj:

Tu dois donc accompagner une bille dans sa chute, et ce le plus bas possible. Tu peux la diriger latéralement afin de l'aider à franchir les différentes plateformes qui te barrent le chemin. Tu devras réagir rapidement, afin d'éviter à tout prix que ta bille s'écrase sur le haut de l'écran. Le jeu se compliquera avec ton avancement, avec un resserrement progressif des plateformes dont l'issue sera forcément fatale; à partir d'un moment les plateformes seront tellement serrées que ta bille n'aura même plus suffisamment de place pour se glisser entre elles. Mais tu as alors la possibilité de recommencer en choisissant une vitesse de départ supérieure, ce qui sera valorisant au niveau de ton score et te permettra donc peut-être de battre ton dernier record. :)

Merci
Iambian
pour cette contribution remarquable à l'histoire de la
TI-83 Premium CE
. ;)


Téléchargements
:


-
Search
-
Featured topics
L'OS 5.5 de la TI-83 Premium CE / 84 Plus CE supprime l'assembleur - la plupart des jeux et certains programme ne fonctionneront plus
Omega, le fork étendant les capacités de ta NumWorks, même en mode examen !
Découvre les nouvelles fonctionnalités en Python de l'OS 5.5 pour la 83PCE/84+C-T Python Edition
Comparaisons des meilleurs prix pour acheter sa calculatrice !
1234
-
Donations / Premium
For more contests, prizes, reviews, helping us pay the server and domains...

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.
512 utilisateurs:
>501 invités
>5 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)