Forum TI-Planet.org

• la dernière mise à jour 2.1.14433 hélas très mineure remontait à Janvier 2020
• et la dernière mise à jour majeure 2.1.14181 remontait à Novembre 2018

• USBOpen(vid, pid) pour établir une connexion avec le périphérique USB correspondant
• USBSend({...}) pour envoyer des données au périphérique
• USBReceive() pour lire des données depuis le périphérique
• USBOpen() qui permet maintenant de lister les identifiants vid/pid du ou des appareils USB branchés sur ta calculatrice, fort pratique pour écarter une erreur d'identifiant en cas d'échec de la connexion

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

• le mode numérique avec l'écran de calcul accessible via

  ⌂Home

  et les diverses applications accessibles via

  Apps

  , le tout développé par HP, agrémenté de diverses interfaces graphiques et offrant pléthore de fonctions avec des noms en majuscules
• le mode CAS avec l'écran de calculs

  CAS

  offrant pour sa part un moteur de calcul formel (le moteur GIAC développé pour le logiciel Xcas par Bernard Parisse enseignant-chercheur à l'Université de Grenoble), accompagné ici d'interfaces spécifiques en mode texte et offrant des fonctions avec des noms en minuscules

Si tu souhaitais obtenir des résultats exacts, plusieurs possibilités s'offraient à toi :

• soit utiliser l'écran de calcul

  CAS

  avec ce qu'il impliquait, soit interfaces en texte, noms de fonctions différents et en minuscules
• soit rester sur l'écran ⌂Home mais y spécifier un appel au moteur CAS sous la forme CAS.eval(...), rapidement lourd si tu devais le faire pour chaque calcul
• soit encore sur l'écran ⌂Home spécifier tes calculs au sein d'un appel QPI(...) plus rapide à saisir, recherchant alors un résultat exact approchant sous les formes
  $mathjax$\pm a\sqrt{\frac{b}{c}}$mathjax$
  (QRac) ou
  $mathjax$\pm a\sqrt{\frac{b}{c}}\pi$mathjax$
  (QPi) pas toujours pertinentes
  
  
• soit encore sur l'écran ⌂Home sélectionner un résultat numérique puis taper

  ab/c

  , mais cela ne faisait que rechercher une forme
  $mathjax$\frac{a}{b}$mathjax$
  proche du résultat en question et ne fournissait qu'encore plus rarement des résultats pertinents

ab/c

ab/c

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

Attention toutefois, actuellement il ne semble pas activé par défaut. Il te faut accéder aux paramètres via

Shift

⌂

, et cocher Intelligent Math sur la 2^ème page.

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

Les formes gérées sont un peu plus larges qu'avec la fonction QPI(), elles semblent s'étendre cette fois-ci au QPiRac, c'est-à-dire à tout ce qui appartient aux 2 familles de nombres suivantes :

• QPi : multiples rationnels de π -
  $mathjax$\pm\frac{a\pi}{b}$mathjax$
  (pour les angles en radians notamment)
• binômes de rationnels et/ou radicaux -
  $mathjax$\frac{\pm a\sqrt{b} \pm c\sqrt{d}}{f}$mathjax$
  (ce qui couvre un large ensemble allant des fractions du collège aux racines de polynômes du 2^nd degré au lycée en passant par nombre de valeurs remarquables en trigonométrie)

Bref, activer Intelligent Math c'est comme si une fonction QPI(...) beaucoup plus évoluée était automatiquement appliquée à chacun de tes résultats.

Accessoirement si tu préfères obtenir des résultats en écriture décimale puis éventuellement les mettre en écriture exacte, la touche

ab/c

gère désormais elle aussi les formes QPi et QRac, activables à l'écran de configuration.

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

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

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

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

• durée suffisante (4 heures)
• contenu mémoire préexistant masqué ou effacé
• et en prime préciser des fonctionnalités à verrouiller via le bouton tactile Configuration en bas d'écran :
  
  • Apps utilisateur
  • CAS
  • Remarques et programmes
  • Nouv. remarques et programmes

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

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

• Intelligent Math
• a b/c Key options

• la mise sous forme exacte via la touche

  ab/c

• la mise sous forme exacte via la fonction QPI(...)

• Apps utilisateur
• CAS
• Intelligent Math
• Remarques et programmes
• Nouv. remarques et programmes
• a b/c Key options (coché par défaut)

• une nouvelle option permet de désactiver les fonctions CAS d'arithmétique ifactor(), idivis(), igcd() et lcm()
• Do1VStats désactive désormais également les fonctions CAS de médiane, quartile et moyenne
• Stat2Vars désactive désormais également les fonctions de régression du mode CAS
• le même réglage unique désactive désormais les fonctions comb(), perm(), min() et max() aussi bien en mode numérique que CAS

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

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

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

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

• de cartésiennes à polaires avec la fonction polar_coordinates()
• de polaires à cartésiennes avec la fonction rectangular_coordinates()

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

• la vue

  Symb

  avec l'éditeur de script
• la vue

  Num

  avec la console

Help

On

Shift

On

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

Elle retourne en pixels les dimensions du rectangle occupé par l'affichage de la chaîne de caractères fournie selon la taille de police spécifiée (de 1 pour la plus petite à 7 pour la plus grande, ou sinon 0 pour tout simplement la taille courante). De quoi positionner parfaitement tes affichages en un minimum de lignes !

Code: Select all

Export demo(txt,fcol,bcol)
Begin
  X:=0;
  Y:=0;
  FOR F FROM 1 TO 7 DO
    L1:=TEXTSIZE(txt,F);
    TEXTOUT_P(txt,G0,X,0,F,fcol,L1[1],bcol);
    TEXTOUT_P(txt,G0,0,Y,F,fcol,L1[1],bcol);
    Y:=Y+L1[2];
    X:=X+L1[1];
  END;
  WAIT();
End;

Code: Select all

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

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

Code: Select all

EXPORT POLY2(a,b,c)
BEGIN
LOCAL d,ex;
ex:="("+a+")*x^2"+"+("+b+")*x+"+c;
d:=b^2-4*a*c;
RETURN CONCAT({CAS.expr(ex)},(−b+{1,−1}*√(d))/(2*a));
END;

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

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

Code: Select all

EXPORT POLY22(...l)
BEGIN
  LOCAL a,b,c,d,n,ex;
  {'a','b','c'}:={1,0,0};
  n:=SIZE(l);
  IF n>=1 THEN
    a:=l[1];
    IF n>=2 THEN
      b:=l[2];
      IF n>=3 THEN
        c:=l[3];
      END;
    END;
  END;
  ex:="("+a+")*x^2"+"+("+b+")*x+"+c;
  d:=b^2-4*a*c;
  RETURN CONCAT({CAS.expr(ex)},(−b+{1,−1}*√(d))/(2*a));
END;

Code: Select all

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

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

Code: Select all

CONST C1=6;
EXPORT CONST C2=7;

Code: Select all

EXPORT test2d()
BEGIN
  PRINT("");
  PRINT("Hello 2D");
  PRINT2D(quote(5^2));
  PRINT2D('5^2');
  PRINT2D('√5');
  PRINT2D('√2022/19');
END;

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

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

Nouveau menu de bas d'écran Plus qui nous révèle plein de choses. Les fichiers .hpprgm peuvent maintenant comporter plusieurs onglets dont tu définis le nom et le type à la création, et entre lesquels tu peux basculer par la suite. Les types d'onglets proposés sont :

• PPL Program pour donc du code HPPPL comportant éventuellement des blocs en langage Python ou Xcas
• Cas Program pour donc du code Xcas
• Python Program pour du code Python
• Binary asset pour des données brutes
• Jpg image pour une image JPEG
• Png image pour une image PNG

Données brutes et images peuvent ensuite être lues / écrites via la fonction Resource(nom_onglet).

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

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

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

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

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

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

Code: Select all

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

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

Normalement, toutes les implémentations utilisant ce standard sont censées donner les mêmes résultats, ce qui est un gros avantage pour développer du code Python multi-plateformes. Sur la bêta précédente, bizarrement, ce n'était pas toujours le cas avec la HP Prime G2. Par exemple le calcul round(3/7,6) donnait :

• 0,428571 sur HP Prime G1 ainsi que toutes les calculatrices Python concurrentes évoquées jusqu'à présent
• 0,4285709999999999 sur la seule HP Prime G2

C'est maintenant corrigé.

Code: Select all

try:
  from time import *
except:
  pass

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

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

• la HP Prime G1 termine en seulement 0,258s, presque aussi vite qu'une TI-Nspire CX II !
• la HP Prime G2 répond plus vite que tu ne relâches la touche, 0,087s !

Les HP Prime sont vraiment extraordinaires en calcul flottant Python et la HP Prime G2 écrase même toute concurrence de sa toute puissance, même en dopant cette dernière à l'overclocking !

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

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

Code: Select all

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

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

Code: Select all

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

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

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

Code: Select all

#python heaptest_python
from gc import mem_alloc,mem_free
a,f=mem_alloc(),mem_free()
print("allocated heap: "+str(f+a))
print("free heap: "+str(f))
#end

Export heaptest_ppl(v)
Begin
  PRINT("allocating heap: "+v);
  PRINT("");
  PYTHON({heaptest_python,v});
End;

Shift

🧰

Shift

Plot

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

Code: Select all

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

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

Code: Select all

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

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

print(test(compte_r))
#end

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

Shift

Plot

• builtins
• array
• cmath
• gc
• math
• micropython
• sys
• ucollections
• uerrno
• uhashlib
• uio
• urandom
• ure
• ustruct
• utimeq

• linalg, un module destiné à remplacer le standard numpy.linalg
• matplotl, un module destiné à remplacer le module standard de tracé dans un repère, matplotlib.pyplot

Légende :

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

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

• arit pour faire de l'arithmétique
• graphic, un module de tracé par pixels
• cas pour appeler le moteur CAS

• les flottants
• et les entiers

• les nombres saisis avec le préfixe # de base binaire, octale, décimale ou hexadécimale
• les résultats de certaines fonctions comme par exemple RGB(,,)

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

C'est maintenant corrigé.

Code: Select all

cas.caseval("int(ln(x),x)")
cas.xcas("int(ln(x),x)")
cas.eval_expr("int(ln(x),x)")

1. Python appelable en dehors de son environnement
2. Python peut lire/écrire des variables hors de son environnement
3. Python peut lire/écrire toute variable hors de son environnement
4. Python peut évaluer des expressions hors de son environnement
5. Python peut évaluer toute expression hors de son environnement

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

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

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

• elle est non bloquante, heureusement
• elle ne te renvoie pas une touche mais l'état global du clavier, c'est-à-dire que tu peux tester en un seul appel des appuis simultanés sur plusieurs touches
• elle permet même de tester les touches

  Shift

  ,

  ALPHA

  et

  On

Vars

Apps

Symb

↑

Help

Esc

Plot

←

→

View

⌂

Num

↓

Menu

CAS

Vars

🧰

□/□

xtθn

ab/c

⌫

x^y

SIN

COS

TAN

LN

LOG

x²

+/-

()

,

Enter

EEX

7

8

9

÷

ALPHA

4

5

6

×

Shift

1

2

3

-

On

0

.

_

+

1. possible d'identifier la touche pressée
2. les touches modificateurs sont identifiables (controle, shift, alpha, 2nde)
3. la touche on/off est identifiable
4. le test est non bloquant
5. possible d'identifier plusieurs touches pressées simultanément
6. possible d'identifier plusieurs touches pressées simultanément en un seul appel de la fonction de test

On

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

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

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

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

• kandinsky (NumWorks)
• ti_graphics (TI-83 Premium CE / TI-84 Plus CE)
• ti_draw (TI-Nspire CX II)
• casioplot (Casio Graph 35+E II / 90+E / fx-9750/9860GIII / fx-CG50)
• graphic (NumWorks + KhiCAS - TI-Nspire CX + KhiCAS)
• nsp (TI-Nspire + micropython)

• G0 : pour un affichage direct sur écran
• G1 à G9 : 9 calques hors écran, permettant non plus du double buffering mais du multiple buffering

• blit(numero_calque_1, x, y, numero_calque_2) pour copier un calque G0 à G9 sur un autre aux coordonnées indiquées
• strblit(numero_calque_1, x, y, largeur, hauteur, numero_calque_2), comme le précédent mais permet en prime au passage de redimensionner la copie (agrandissement, réduction, ...)
• strblit(numero_calque_1, x1, y1, largeur1, hauteur1, numero_calque_2, x2, y2, largeur2, hauteur2), comme le précédent mais permet de ne copier qu'une partie du calque
• dimgrob(numer_calque, largeur, hauteur, couleur) pour redimensionner les calques G1 à G9 (non valide pour l'écran G0)
• grobw(numer_calque) récupérer les dimensions d'un calque G0 à G9

Code: Select all

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

• -1: inconnue (ordinateur ?...)
• 0: NumWorks
• 1: Casio Graph 90+E / fx-CG50 ou Graph 35+E II / fx-9750/9860GIII
• 2: TI-83 Premium CE ou TI-84 Plus CE
• 3: HP Prime
• 4: Casio Graph 35+E/USB / 75/85/95 / fx-9750/9860GII / fx-9860G avec CasioPython
• 5: TI-Nspire + MicroPython (nécessite Ndless)
• 6: TI-Nspire + KhiCAS en mode MicroPython (nécessite Ndless)
• 7: TI-Nspire + KhiCAS en mode de compatibilité Python (nécessite Ndless)
• 8: NumWorks + KhiCAS en mode MicroPython (nécessite Omega)
• 9: NumWorks + KhiCAS en mode de compatibilité Python (nécessite Omega)
• 10: Casio Graph 90+E / fx-CG10/20/50 + KhiCAS en mode de compatibilité Python
• 11: Casio Graph 35+E II / fx-9750/9860GIII + KhiCAS en mode de compatibilité Python
• 12: HP Prime en mode CAS

Code: Select all

def get_pixel(x, y):
      return int(hpprime.eval("get_pixel(" + str(x) + "," + str(y) + ")"))

Code: Select all

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

Code: Select all

def invert_color(c):
  try:
    ci = [0, 0, 0]
    for k in range(3):
      ci[k] = 255 - c[k]
  except:
    ci = ~(c&0xffffff) & 0xffffff
  return ci

def is_pixel_writable(x, y, bad_pixel):
  if is_pixel_readable(x, y, bad_pixel):
    c0 = gp(x, y)
    sp(x, y, invert_color(c0))
    c = gp(x, y)
    return c != c0

Code: Select all

def is_pixel_readable(x, y, bad_pixel):
  c = None
  try:
    c = gp(x, y)
  except:
    pass
  if c != None:
    if c == bad_pixel:
      sp(x, y, invert_color(c))
      c = gp(x, y)
  return c != bad_pixel

Code: Select all

def scr_test(x0, y0, dx0, dy0, test):
  bad_pixel = None
  try:
    bad_pixel = gp(-2, -2)
  except:
    pass
  x, y, dx, dy = x0, y0, dx0, dy0
  while not test(x, y, bad_pixel):
    x += dx
    y += dy
  if test(x, y - dy, bad_pixel): y = y0
  elif test(x - dx, y, bad_pixel): x = x0
  x0, y0 = x, y
  x += dx
  y += dy
  while(dx or dy):
    if not test(x - ((dx == 0) and dx0),y - ((dy == 0) and dy0), bad_pixel):
      if test(x - ((dx == 0) and dx0), y - ((dy == 0) and dy0) - dy0, bad_pixel): dy = 0
      elif test(x - ((dx == 0) and dx0) - dx0, y - ((dy == 0) and dy0), bad_pixel): dx = 0
      else: dx, dy = 0, 0
    x += dx
    y += dy
  return x0, y0, (x - x0) // dx0, (y - y0) // dy0

def scr_size():
  xrd0, yrd0, xrd, yrd = scr_test(0, 0, -1, -1, is_pixel_readable)
  xra0, yra0, xra, yra = scr_test(1, 1, 1, 1, is_pixel_readable)
  xr0, yr0 = xrd0 - xrd + 1, yrd0 - yrd + 1
  xr, yr = xra + xrd, yra + yrd
  xw0, yw0, xw, yw = scr_test(xr0, yr0, 1, 1, is_pixel_writable)
  print("at (" + str(xr0) + "," + str(yr0) + "): " + str(xr) + "x" + str(yr) + " readable pixels")
  print("at (" + str(xw0) + "," + str(yw0) + "): " + str(xw) + "x" + str(yw) + " writable pixels")
  return xr0, yr0, xr, yr, xw0, yw0, xw, yw

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

• soit avec une liste ou un tuple (r, g, b) décrivant les valeurs de chaque composante primaire rouge-vert-bleu par un entier sur 8 bits (de 0 à 255)
• soit par un nombre entier qui sera directement la valeur fournie au contrôleur écran

• graphic (NumWorks + KhiCAS - TI-Nspire CX + KhiCAS)
• nsp (TI-Nspire + micropython)

Code: Select all

def get_color_mode():
  c = gp(0, 0)
  try:
    c[2]
    return 0
  except:
    b, v = 0, 1
    dv = 1
    x, y = 0, sy0
    sp(x, y, v + dv)
    while gp(x, y) >= v:
      b += 1
      v *= 2
      sp(x, y, v + dv)
    return b

• 0 : pour un codage des couleurs par des tuples (r,g,b)
• 15 : pour un codage des couleurs sur des entiers de 15 bits
• 16 : pour un codage des couleurs sur des entiers de 16 bits
• 24 : pour un codage des couleurs sur des entiers de 24 bits
• ...

Code: Select all

def fixcolor(c, bits=16):
  try:
    if not color_mode:
      return c
    r, g, b = c[0], c[1], c[2]
  except:
    if color_mode == bits:
      return c
    if bits == 16:
      br, bg, bb = 5, 6, 5
    else:
      br, bg, bb = 8, 8, 8
    r, g, b = c & (2**br - 1) * 2**(8 - br), c & ((2**bg - 1) * 2**br) // 2**br * 2**(8 - bg), c & ((2**bb - 1) * 2**(br + bg)) // 2**(br + bg) * 2**(8 - bb)
  if not color_mode:
    return (r, g, b)
  else:
    if color_mode == 16:
      br, bg, bb = 5, 6, 5
    else:
      br, bg, bb = 8, 8, 8
    r, g, b = r // 2**(8 - br), g // 2**(8 - bg) * 2**br, b // 2 **(8 - bb) * 2**(br + bg)
    c = r + g - (r & g)
    return c + b - (c & b)

Code: Select all

def draw_vline(x, y1, y2, c):
  for j in range(y2 - y1 + 1):
    sp(x, y1 + j, c)

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

Code: Select all

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

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

• circle(numero_calque, x, y, rayon, couleur) pour tracer un cercle (non rempli donc)
• arc(numero_calque, x, y, rayon, couleur, angle1, angle2) pour tracer un arc de cercle (avec les angles en degrés comme maintenant précisé correctement dans l'aide sur cette nouvelle bêta)
• line(numero_calque, x1, y1, x2, y2, couleur) pour tracer une ligne
• rect(numero_calque, x1, y1, largeur, hauteur, couleur) pour tracer un rectangle (non rempli)
• fillrect(numero_calque, x1, y1, largeur, hauteur, couleur1, couleur 2) pour remplir un rectangle
• textout(numero_calque, x, y, texte, couleur) pour écrire une chaîne de caractères

• clear_screen(couleur) pour remplir l'écran de la couleur indiquée
• draw_arc(x, y, rayon_x, rayon_y, angle1, angle2, couleur) pour tracer un arc d'ellipse (angles en degrés)
• draw_circle(x, y, rayon, couleur) pour tracer un arc de cercle
• draw_filled_arc(x, y, rayon_x, rayon_y, angle1, angle2, couleur) pour remplir un secteur d'ellipse (angles en degrés)
• draw_filled_circle(x, y, rayon, couleur) pour remplir un cercle
• draw_filled_polygon([[x1, y1], [x2, y2], ..., [xn, yn]], couleur) pour remplir un polygone
• draw_filled_rectangle(x, y, largeur, hauteur, couleur) ou fill_rectangle(x, y, largeur, hauteur, couleur) pour remplir un rectangle
• draw_line(x1, y1, x2, y2, couleur) pour tracer une ligne
• draw_pixel(x, y, couleur) ou set_pixel(x, y, couleur) pour allumer un pixel
• draw_polygon([[x1, y1], [x2, y2], ..., [xn, yn]], couleur) pour tracer un polygone
• draw_rectangle(x, y, largeur, hauteur, couleur) pour tracer un rectangle
• draw_string(x, y, texte, couleur1, couleur2) pour écrire une chaîne de caractères

Tu as même une fonction get_pixel(x, y) pour remplacer les appels à rallonge int(hpprime.eval("get_pixel(" + str(x) + "," + str(y) + ")")) vus plus haut.

À y regarder, graphic est une bibliothèque graphique beaucoup plus étendue que hpprime, avec la gestion des ellipses et les nombreuses possibilités de remplissage ne nécessitant ici qu'un unique appel de fonction !

C'est vraiment juste dommage pour le double buffering non fonctionnel.

Code: Select all

from polycalc import *

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

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

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

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

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

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

Code: Select all

def poly_draw_line(x1, y1, x2, y2, c):
        m, a1, b1, a2, b2 = 0, int(x1), int(y1), int(x2), int(y2)
        if (x2 - x1) ** 2 < (y2 - y1) ** 2:
          m, a1, a2, b1, b2 = 1, b1, b2, a1, a2
        if min(a1, a2) != a1: a1, b1, a2, b2 = a2, b2, a1, b1
        for k in range(a2 - a1 + 1):
          a, b = a1 + k, int(b1 + (b2 - b1) * k / ((a2 - a1) or 1))
          poly_set_pixel((a, b)[m], (b, a)[m] + screen_y0, c)

1. module de tracé par pixels
2. fonction de tracé de ligne
3. fonctions de tracé de rectangles
4. fonctions de tracé de cercles
5. fonctions de tracé d'ellipses
6. double buffering
7. multiple buffering

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

• matplotlib.pyplot (NumWorks - Casio Graph 35+E II / 90+E / fx-9750/9860GIII / fx-CG50)
• ti_plotlib (TI-83 Premium CE / TI-84 Plus CE - TI-NSpire CX II - NumWorks + KhiCAS - TI-Nspire CX + KhiCAS)

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

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

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

Code: Select all

from autopfrm import *

pf = get_pf()
sh_inf = shell_infos(pf)

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

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

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

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

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

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

Code: Select all

try:from time import monotonic
except:pass

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

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

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

• la HP Prime G1 répond en seulement 0,449s, soit déjà légèrement plus vite qu'une TI-Nspire CX II !
• la HP Prime G2 répond plus vite que son ombre, en 0,171s !

Fantastique, les HP Prime mènent la course, et la HP Prime G2 écrase littéralement toute concurrence, bravo !