Forum TI-Planet.org

• 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

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

• 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

• USBOpen(vid, pid) pour connecter le périphérique USB
• USBSend({...}) pour envoyer des données au périphérique
• USBReceive() pour lire des données depuis le périphérique

En pratique, nous n'avons hélas pas réussi à confirmer le bon fonctionnement de ces fonctions dans cette version bêta.

Un USBOpen(#0D28h,#0204h) n'arrive pas à connecter une carte micro:bit v2. Ayant constaté plusieurs erreurs dans l'aide en ligne de cette version bêta, nous avons également tenté USBOpen(#0204h,#0D28h) sans plus de succès.

Nous n'avons pas réussi à retrouver le câble micro-USB direct venant avec la HP Prime, mais nous avons pas moins de 2 connectiques micro-USB qui permettent avec succès de faire détecter la micro:bit v2 à un smartphone OTG, cette dernière se comportant comme une clé USB. Donc ni la connectique ni la micro:bit v2 ne semblent fautifs.

Nous avons également tenté avec une calculatrice Casio Graph 90+E, un clavier USB filaire et pas moins de 3 souris USB filaires. Échec dans tous les cas...

Suspectant un problème d'alimentation nous avons également rechargé la HP Prime G2 à fond, sans changement.

Après, notre HP Prime G2 n'est pas un modèle de production mais un modèle de développement, possiblement non pleinement fonctionnel sur l'USB, ou mal détecté/géré par cette version bêta...

Nous allons tenter d'élargir les tests, et en cas de succès nous ne manquerons pas de t'en reparler.

• la vue

  Symb

  avec l'éditeur de script
• la vue

  Num

  avec la console

Symb

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.

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 !

• 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]

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

🧰

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;

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

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 !

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

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 !

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 sur cette version bêta les angles précisés en degrés contrairement à ce qu'indique l'écran d'aide)
• 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 tracer un rectangle plein
• textout(numero_calque, x, y, texte, couleur) pour tracer une chaîne de caractères

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)

C'est bien évidemment très bien d'avoir prévu cela.

Toutefois c'est ici encore très 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.

Mais on ne peut pas tout avoir, n'est-ce pas ?

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)

• déjà très complète du point de vue de la quantité de fonctions intégrées
• tout comme du point de vue de l'adéquation aux programmes scolaires
• et extrêmement performante, anéantissant littéralement toute concurrence sur ce point !

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

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

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

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

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

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

• logiciel de connectivité pour Windows 32 bits 64 bits
• logiciel d'émulation pour Windows 32 bits 64 bits
• mise à jour pour HP Prime G1 G2