[critor]

Quelle Calculatrice programmable Choisir 2020
(index des épisodes)

Episode 3 - Python et pile (stack)

Dans l'épisode précédent nous avons donc vu quelles calculatrices étaient programmables en langage Python parmi celles conformes ou se prétendant conformes pour les examens 2021 et au-delà.

Les interpréteurs MicroPython ou similaires qu'elles font tourner font appel à 3 types de mémoires avec les rôles suivants :

• la mémoire de stockage qui accueille et conserve tes scripts
• le stack (pile) qui, à l'exécution, accueille les références vers les objets créés
• le heap (tas) qui, à l'exécution, accueille le contenu de ces objets

En gros le stack limite donc le nombre d'objets différents pouvant exister simultanément en mémoire, alors que le heap limite la taille globale occupée par le contenu de ces objets.

Hors besoins très spécifiques ce n'est habituellement pas le facteur le plus limitant dans les projets pour qui sait optimiser son code, mais aujoud'hui nous allons commencer par nous intéresser au stack.

A ce jour nous ne savons pas mesurer exactement la capacité du stack. Mais par contre nous pouvons en déclencher une consommation massive, afin de pouvoir comparer et voir quels modèles s'en sortent le mieux.

Une situation très simple qui peut être grand consommatrice de stack c'est la récursivité, soit les fonctions qui se rappellent elles-mêmes. Notre protocole de test aujourd'hui va consister à lancer test(compte_r) à partir du script suivant :

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

compte_r(n) est donc ici notre fonction récursive qui compte récursivement de 1 à n.

test(f) quant à elle va donc tester des appels f(n) avec n de plus en plus grand, jusqu'à déclenchement d'une erreur qui sera précisée.

Commençons donc avec les Casio Graph 35+E II et Graph 90+E et leur application Python officielle.

Le paramètre d'appel doit monter jusqu'à 82 pour permettre comme indiqué l'épuisement du stack.

Restons chez Casio mais cette fois-ci avec l'application tierce CasioPython. Elle est compatible avec différents modèles monochromes :

• Graph 75+E
• Graph 35+E via une installation du système Graph 75+E
• Graph 35+E II

Sur les deux premiers nous obtenons une valeur limite extraordinaire de 5362.

Par contre un bug de CasioPython hélas toujours pas corrigé depuis l'année dernière lui fait prendre la Graph 35+E II pour un ancien modèle et réduire sa consommation mémoire, pour une valeur limite quand même relativement impressionnante de 655.

Il est à noter ici que le stack n'est a priori pas forcément épuisé, car la raison de l'erreur est différente. Ici c'est en effet la limite de récursivité configurée qui a été franchie.

Certes en Python on peut consulter cette limite via sys.getrecursionlimit() et même l'ajuster dynamiquement via sys.setrecursionlimit().

Mais ici l'application CasioPython utilise une implémentation MicroPython, ce qui fait que le module sys n'inclut pas ces accesseurs.

Passons maintenant aux TI-83 Premium CE Edition Python et TI-84 Plus CE-T Python Edition. Il y a visiblement du mieux par rapport à l'année dernière !

Texas Instruments a en effet repoussé la limite de 23 à 28 via ses dernières mises à jour 5.5.1 et 5.5.5 !

L'ancienne TI-83 Premium CE permet également la programmation Python si munies du module externe TI-Python, module interdit aux examens français mais parfaitement utilisable en classe ainsi qu'aux évaluations si l'enseignant le permet.

Le firmware TI-Python officiel nous permet ici d'aller jusqu'à 20 limite des niveaux de récursion et non du stack ici encore.

Le firmware tiers fourni par Lionel Debroux, bien que proposant nombre d'améliorations, a le défaut de baisser cette valeur limite à 15.

Ici il ne s'agit pas d'une implementation MicroPython mais propriétaire TI-Python, en réalité construite à partir de l'implémentation libre CircuitPython. En tous cas cela ne change rien, le module sys n'a pas ce qu'il faut pour nous permettre d'explorer plus loin via cette méthode.

Sur NumWorks ici aussi il y a eu du nouveau depuis l'année dernière, le constructeur ayant annoncé avoir quadruplé la taille du stack lors de la mise à jour intermédiaire 13.1.0.

Effectivement nous avons ici une progression formidable de la valeur limite, de 33 à 128 !

Mais nous n'en avons pas encore terminé avec les NumWorks. Il est possible de leur installer très facilement un firmware tiers, Omega, qui leur rajoute plein de fonctionnalités y compris en mode examen !

Sur la dernière édition matérielle NumWorks N0110, Omega permet notamment l'ajout d'applications. Plusieurs sont disponibles dont l'application de mathématiques intégrée KhiCAS par Bernard Parisse, enseignant chercheur à l'Université de Grenoble, une version adaptée aux plateformes nomades qui s'inspire de son propre logiciel de Mathématiques intégré Xcas, et en reprend notamment le moteur de calcul formel GIAC.

Et bien Bernard est justement en train de te préparer une mise à jour majeure de KhiCAS pour l'année scolaire 2020-2021, déjà accessible en version de test. Au menu des nouveautés une sous-application tableur / feuille de calculs, ainsi que l'intégration d'un véritable interpréteur MicroPython !

Donc pour information, dans le mode interpréteur Python de KhiCAS, la limite est impactée mais très légèrement, passant à 126. Un bien maigre prix à payer par rapport à tous les avantages !

Pour les TI-Nspire CX II, nous ne disposons hélas pas encore de préversion de la mise à jour qui devrait sortir mi-septembre 2020 et rajouter la programmation Python.

Pour les anciens modèles TI-Nspire CX et TI-Nspire monochromes par contre, si non encore mis à jour en version 4.5.1 ou supérieure, il est possible d'installer le jailbreak Ndless qui autorise à son tour par la suite l'installation d'applications tierces.

Attention toutefois, contrairement aux applications Omega pour NumWorks, les applications Ndless ont le gros défaut de ne pas rester disponibles en mode examen !

Une fois Ndless installé, on peut par exemple rajouter l'application MicroPython, pour une limite ici de 130.

Mais pour les seules anciennes TI-Nspire CX, ce n'est pas tout. Bernard Parisse est également en train de préparer ici la même mise à jour majeure de l'application KhiCAS que pour NumWorks, avec feuille de calcul / tableur et véritable interpréteur MicroPython intégrés, également disponible en version de test !

Ici la valeur limite monte même à 155 !

Une mise à jour HP Prime rajoutant une application Python est dans les tuyaux. Aucune date de sortie connue à ce jour, mais une version intégrant cette fonctionnalité a été publiée par erreur en octobre 2019.

Cela a sûrement été corrigé depuis, mais cette vieille version est en pratique très instable, les fonctionnalités Python se payant bien cher... Nous te déconseillons fortement de l'installer dans le contexte d'évaluations.

Nous ne pourrons pas la classer en l'état, mais rien n'empêche d'en parler et de te donner un avant-goût de ce qui t'attend.

Donc ici, la limite est de 77.

Résumé donc des capacités des différents modèles autour du stack Python, avec :

• en haut les possibilités hors mode examen ou à venir dans de prochaines mises à jour lorsque connues (HP Prime, mais nous ignorons quand...)
• en bas les capacités de la machine en mode examen sur les versions actuellement à notre disposition

[critor]

Quelle Calculatrice programmable Choisir 2020
(index des épisodes)

Episode 4 - Python et tas (heap)

Les interpréteurs MicroPython ou similaires qu'elles font tourner font appel à 3 types de mémoires avec les rôles suivants :

• la mémoire de stockage qui accueille et conserve tes scripts
• le stack (pile) qui, à l'exécution, accueille les références vers les objets créés
• le heap (tas) qui, à l'exécution, accueille le contenu de ces objets

En gros le stack limite donc le nombre d'objets différents pouvant exister simultanément en mémoire, alors que le heap limite la taille globale occupée par le contenu de ces objets.

Dans l'épisode précédent nous avons comparé les tailles de stack offertes par les calculatrices programmables en langage Python.

Aujourd'hui nous allons nous intéresser au heap. Cet espace est extrêmement important et surtout sur les plateformes nomades, car contrairement à d'autres langages les objets Python les plus simples ont le défaut d'être assez gros. Ce sera le plus souvent le heap le facteur le plus limitant pour tes projets.

Le temps de construire ensemble notre protocole de tests, commençons par les TI-83 Premium CE Edition Python et TI-84 Plus CE-T Edition Python. Elles sont hautement intéressantes pour comprendre ce qui se passe, puisque disposant du module Python gc. Le module gc nous offre en effet plusieurs fonctions bien utiles ici :

• 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

Les TI-83 Premium CE Edition Python et TI-84 Plus CE-T Edition Python disposent donc d'un heap avec exactement 19,968 Ko de capacité.
Mais lorsque l'on accède à l'environnement Python, nombre de choses sont initialisées et ce heap n'est pas vide. Les dernières versions respectives 5.5.1 et 5.5.5 ne nous offrent plus que 17,104 Ko de libres sur le heap, alors que la version 5.4 de l'année dernière culminait à 19,408 Ko.

Précisions que cet espace libre a de plus ici été amputé de par notre importation du module gc. Ce module n'étant hélas disponible que sur une minorité de Pythonnettes il va nous falloir procéder autrement, surtout si l'on souhaite obtenir des mesures comparables.

Donnons quelques éléments de taille en mémoire d'objets Python usuels, du moins sur les plateformes 32 bits que sont nos calculatrices :

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

Voici une fonction qui retourne la taille d'un objet selon ces règles :

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

Une piste consiste alors à tenter de remplir le heap jusqu'à déclenchement d'une erreur, et retourner alors l'espace maximal que l'on a réussi à consommer. Voici justement une fonction en ce sens :

Code: Select all

def mem(v=1):
  try:
    l=[]
    try:
      l.append(0)
      l.append(0)
      l.append("")
      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)
      except:
        pass
      return l[0]
  except:
    return 0

L'appel mem(0) semble marcher comme souhaité, retournant une valeur qui peut comme prévu légèrement dépasser les 17,104 Ko trouvés plus haut.

Mais voilà autre petit problème, le résultat n'est pas toujours le même, dépendant en effet de l'état du heap lors de l'appel. Rien que sur les résultats ci-contre, nous avons une marge d'erreur de 1 à 2%.

C'est beaucoup, en tous cas suffisamment pour inverser injustement des modèles au classement. Or cette année, nous tenons à être aussi précis que possible comme tu as pu le voir dès notre 1^er épisode, afin justement de produire un classement aussi équitable que possible.

Certes, on pourrait nettoyer ça avant chaque appel avec gc.collect(), mais ce ne serait pas juste puisque nous n'aurons pas cette possibilité sur nombre de modèles concurrents. Il nous faut donc trouver autre chose.

L'absence du module gc et donc de gc.collect() ne signifie absolument pas que le heap ne sera jamais nettoyé. C'est juste que nous ne contrôlons pas le moment où il le sera.

Et bien voici l'élément final du protocole de test que nous te proposons, avec une boucle répétant des appels mem(0), ce qui devrait finir par déclencher des nettoyages du heap, et te signalant à chaque fois que la valeur retournée bat ainsi un nouveau record :

Code: Select all

def testmem():
  m = 0
  while 1:
    t = mem(0)
    if t > m:
      m = t
      input(str(m))

testmem() signale au départ rapidement plusieurs nouveaux records d'occupation mémoire. Battre chaque nouveau record est de plus en plus difficile, et les nouveaux affichages nécessitent de plus en plus de temps. Nous arrêtons le test lorsque le dernier record n'aura pas pu être battu malgré 5 minutes écoulées depuis son affichage.

Nous aurions donc 17,233 Ko disponibles sur le heap.

Mais ici encore lorsque nous réalisons notre appel, le heap a déjà été entâmé par l'importation de notre script de test.

Pas grave, il nous suffit tout simplement d'utiliser le module gc pour connaître la consommation heap de notre script.

736 octets donc, qu'il nous suffira d'ajouter à toutes les valeurs obtenues dans ce qui suit.

Nous avons donc ici sur TI-83 Premium CE Edition Python et TI-84 Plus CE-T Edition Python 17,233+0,736= 17,969 Ko. Et entre nous, ce n'est franchement pas beaucoup.

Prenons maintenant l'ancienne TI-83 Premium CE munie du module externe TI-Python interdit aux examens français, mais restant utilisable en classe ainsi qu'aux évaluations si l'enseignant le permet.

Ce n'est pas la panacée mais c'est quand même sensiblement mieux, avec 19,496+0,736= 20,232 Ko.

Conscient du problème de sous-dimensionnement de ce heap, Lionel Debroux a développé un firmware tiers pour le module externe TI-Python.

Si tu l'installes tu bénéficieras donc d'un espace heap disponible nettement amélioré, avec 22,158+0,736= 22,894 Ko.

C'est donc au-delà de la capacité heap de 19,968 Ko trouvée plus haut pour le firmware officiel, mais c'est normal puisque l'on se rend compte que Lionel a en effet passé la capacité heap à 22,912 Ko.

Arrive maintenant la NumWorks. Depuis l'année dernière, nous passons de la version 12.2 à 14.4. Enormément de choses ont été apportées par les mises à jour intermédiaires.

Et justement, le heap qui était à 15,557+0,736= 16,293 Ko utilisables pour tes scripts, double à 31,485+0,736= 32,221 Ko !

Mais la chose ne s'arrête pas là. Il est possible très facilement sur ta NumWorks d'installer un firmware tiers, Omega. Basé sur le firmware officiel dont il suit les évolutions, il lui rajoute plein de fonctionnalités utiles et légitimes qui auront le gros avantage de rester disponible en mode examen !

Sur la dernière édition matérielle NumWorks N0110, Omega permet notamment l'ajout d'applications. Plusieurs sont disponibles dont l'application de mathématiques intégrée KhiCAS par Bernard Parisse, enseignant chercheur à l'Université de Grenoble, une version adaptée aux plateformes nomades qui s'inspire de son propre logiciel de Mathématiques intégré Xcas, et en reprend notamment le moteur de calcul formel GIAC.

Et bien Bernard est justement en train de te préparer une mise à jour majeure de KhiCAS pour l'année scolaire 2020-2021, déjà accessible en version de test. Au menu des nouveautés une sous-application tableur / feuille de calculs, ainsi que l'intégration d'un véritable interpréteur MicroPython !

Et grosse surprise puisque nous bondissons ici à 39,747+0,736= 40,483 Ko de heap disponible, Bernard ayant en effet eu la bonne idée de passer la capacité heap à 40 Ko !

Mais ce n'est pas tout, KhiCAS est notamment la seule solution Python sur calculatrices à te permettre de choisir toi-même la taille du heap, par défaut donc de 40 Ko, et ce librement entre 16 Ko et 64 Ko, une formidable option pour estimer la consommation heap de tes projets !

Passons donc ça à 64 Ko, et effectivement nous obtenons maintenant un espace heap disponible de 63,660+0,736= 64,396 Ko !

La Casio Graph 35+E II nous crève maintenant le plafond avec pas moins de 99,490+0,736= 100,226 Ko de heap disponible dans son application Python officielle !

Il existe aussi une application Python tierce pour les Casio Graph monochromes, CasioPython. Elle est compatible avec les modèles suivants, mais hélas bloquée par le mode examen :

• Graph 75+E
• Graph 35+E via une installation du système Graph 75+E
• Graph 35+E II

Sur les deux premiers nous nous envolons à pas moins de 257,026+0,736= 257,762 Ko !

En effet selon le module gc, la capacité heap a ici été réglée à 258,048 Ko.

Hélas, un bug toujours pas corrigé depuis l'année dernière fait que CasioPython reconnaît bêtement la Graph 35+E II comme un ancien modèle, n'y réservant alors qu'une capacité heap de 32,256 Ko.

Nous n'obtenons alors qu'un espace heap libre de 31,163+0,736= 31,899 Ko, ici donc sans aucun intérêt par rapport à l'application Python officielle.

La Casio Graph 90+E nous met maintenant en orbite avec un formidable 1031,713+0,736= 1032,449 Ko soit 1,032 Mo, de quoi développer de fantastiques projets !

Pour les TI-Nspire CX II, nous ne disposons hélas pas à ce jour de préversion de la mise à jour qui devrait sortir mi-septembre 2020 et rajouter la programmation Python.

Pour les anciens modèles TI-Nspire CX et TI-Nspire monochromes par contre, si non encore mis à jour en version 4.5.1 ou supérieure, il est possible de leur installer le jailbreak Ndless qui autorise à son tour par la suite l'installation d'applications tierces.

Attention toutefois, contrairement aux applications Omega pour NumWorks, Ndless fait hélas le choix de s'effacer totalement devant le mode examen !

Les applications Ndless seront donc inutilisables, y compris donc les applications parfaitement légitimes comme MicroPython apportant des fonctionnalités disponibles en mode examen sur d'autres modèles.

Une fois Ndless installé, on peut par exemple rajouter l'application MicroPython qui nous fait littéralement quitter l'attraction terrestre avec pas moins de 2080,065+0,736= 2080,801 Ko soit 2,081 Mo !

En creusant un petit peu grâce au module gc ici disponible, nous découvrons que la capacité heap est de 2,049 Mo.

Mais pour les seules anciennes TI-Nspire CX, ce n'est pas tout. Bernard Parisse est également en train de préparer ici la même mise à jour majeure de l'application KhiCAS que pour NumWorks, avec feuille de calcul / tableur et véritable interpréteur MicroPython intégrés, également disponible en version de test !

Nous sommes ici en retrait même si cela reste parfaitement honorable, avec 1023,812+0,736= 1024,548 Ko soit 1,025 Mo.

En effet la capacité heap n'est ici que de 1,025 Mo selon le module gc.

Une mise à jour HP Prime rajoutant une application Python est dans les tuyaux. Aucune date de sortie communiquée à ce jour, mais une version intégrant cette fonctionnalité a été publiée par erreur en octobre 2019.

Cela a sûrement été corrigé depuis, mais cette vieille version est en pratique très instable. Nous te déconseillons fortement de l'installer dans le contexte d'évaluations.

Nous ne pourrons en l'état la retenir au classement, surtout que nous n'avons aucune garantie qu'elle sorte en 2020-2021, mais nous testons quand même lorsque possible afin de pouvoir t'estimer ce que vaudra la mise à jour en question.

Donc ici encore nous bénéficions d'un heap correctement dimensionné, avec 1017,692+0,736= 1018,428 Ko soit 1,018 Mo de disponibles sur le heap.

Le module gc nous apprend en effet que HP a réglé la capacité de son heap ici encore à 1,025 Mo, exactement comme Bernard.

Résumé de nos mesures, avec donc l'espace heap Python disponible à vide pour chacun des modèles :

• en bas ne tient compte que des seules capacités d'origine officielles de la machine en mode examen sur les versions actuellement à notre disposition
• en haut tient compte de toutes les possibilités évoquées pour d'autres situations (installation d'applications, mises à jour à venir, contexte hors mode examen...)

[critor]

Pour la sortie de la TI-83 Premium CE Edition Python à la rentrée 2019, Texas Instruments avait procédé à une refonte complète de l'emballage.

Cela n'était d'ailleurs pas une spécificité de ce modèle, les nouvelles TI-Nspire CX II-T et TI-Nspire CX II-T CAS sorties également pour la rentrée 2019 bénéficiaient elles aussi d'un nouvel emballage similaire.

Mais le nouvel emballage ne concerne finalement pas que les nouveaux modèles, les anciens modèles encore commercialisés en bénéficient eux aussi !

Cela date à notre avis de l'année dernière mais c'est davantage visible cette année, le renouvellement dans les rayons de boutiques du stock des anciens modèles dont elles étaient déjà approvisionnées, ayant bien évidemment pris davantage de temps que pour les nouveaux modèles de la rentrée 2019.

Voici par exemple ci-contre la TI-82 Advanced qui se refait une beauté. Pour la France cela concerne également les TI-89 Titanium et TI-Collège Plus.

Nous bénéficions maintenant au verso d'un tableau comparatif enfin à jour avec tous les nouveaux modèles de rentrée 2019, mentionnant entre autres les possibilités de programmation Python.

Attention donc à ne pas confondre TI-82 Advanced et TI-83 Premium CE Edition Python, ce n'est pas pareil...

[Admin]

Lors de sa sortie à la rentrée 2017, la calculatrice NumWorks se commercialisait exclusivement en ligne, dans la boutique du constructeur ainsi que sur Amazon, à 79,99€ frais de port inclus !

Depuis la disponibilité en ligne s'est élargie. On compte aujourd'hui en prime dans le même ordre de prix :

• fnac.com également à 79,99€ port inclus :
  https://www.fnac.com/Calculatrice-graphique-Python-NumWorks/a14790195/w-4
• le distributeur scolaire européen Calcuso dont nous t'avions déjà parlé, qui lance son site français pour cette rentrée 2020 et fait un effort à seulement 79,95€ :
  https://www.calcuso.com/fr/numworks-fr.html

Comme déjà annoncé nous avons également le distributeur scolaire historique de Texas Instruments, Jarrety, qui passe à la concurrence Casio et NumWorks pour cette rentrée 2020, mais bizarrement par son intermédiaire c'est beaucoup plus cher, pas moins de 89,89€, certes toujours port inclus :
https://jarrety.fr/lycee/65-numworks.html

Quant aux boutiques physiques, nous avions déjà vu la calculatrice NumWorks en librairie Gibert Joseph, mais comme ce dernier beaucoup plus chère que si achetée en ligne chez NumWorks / Amazon / fnac avec le port inclus, alors que paradoxalement pour les boutiques physiques il te faudra d'une façon ou d'une autre payer ton déplacement et éventuellement ton stationnement.

Et bien les lignes continuent à bouger. Pour cette rentrée 2020 la calculatrice NumWorks est disponible dans les boutiques physiques fnac et ici à la différence à seulement 79,99€ comme chez le constructeur !

Tu auras donc ici l'immense privilège de pouvoir sans surcoût te délecter de ta calculatrice NumWorks le jour-même de ton achat, sans avoir donc à te bloquer une ou plusieurs journées pour ne pas rater le passage du livreur !

Mais attention dépêche-toi, selon nos informations il n'y en aura pas pour tout-le-monde...

Soit l'offre rencontre un succès fou, soit l'enseigne a été bien timide sur le stock en question...

A la fnac Montpellier par exemple, la NumWorks s'affichait effectivement bien en rayon à la fin du mois de juin à côté de la concurrence, et là en cette première quinzaine de mois d'août il n'y a plus que des TI et Casio...

Crédits photo : https://twitter.com/petitesouris_78/sta ... 0100448259

[Admin]

Bomb Run est un jeu initialement sorti sur calculatrices Casio.

Aux commandes de ton avion tu es bientôt à court de carburant. Tu amorces donc ta descente finale pour te rendre compte une fois passé sous la couche de nuages que tu es... en plein centre ville avec plein de gratte-ciels ! Comment faire pour te poser sans dommages ?

Pas le choix, les vies de tes passagers sont entre tes mains, pour éviter les gratte-ciels et te poser il va donc te falloir raser les immeubles à coups de bombes larguées via la touche

EXE

.

Non non, rien à voir avec New York et 2001, car c'est en 1997 que Tom Lynn partagea sa création dans la communauté Casio anglophone. La compatibilité affichée concernait les modèles fx-9750G, fx-9850G et fx-9950G avec leur écran de 128x64 pixels, plus connus par la suite en France sous les noms de Graph 35, Graph 60 et Graph 65.

En 2006, CrimsonCasio nous sort une version modifiée dénommée Bombrun sur jeuxcasio.com, cette fois-ci donc dans la communauté francophone.

Pas la moindre mention de l'auteur original, mais la comparaison des codes source ne laisse strictement aucun doute :

version 1996 par Tom Lynn	version 2006 par CrimsonCasio
Programme BOMBRUN : Code: Select all ViewWindow 1,127,0,1,63,0 For 1→A To 31 2+Int 12Ran#→C For 1→B To C Text 62-4C+4B,4A,"⸋" Next Next 1→A~B -1→C 0→J~K Lbl 0 Text 4B,4A," " Isz A If A>31 Then 1→A Isz B B≥15=>Goto 1 IfEnd PxlTest 4B+2,4A+1 If Ans Then "OOH-THAT HAD TO HURT!" Stop IfEnd Text 4B,4A,">" GetKey Ans=>Ans→K If C<0 And K=31 Then 4A→D B→C 0→K IfEnd Prog "BRDROP" J≠31=>Goto 0 Lbl 1 "WOW! I'M IMPRESSED!"	Programme BOMBRUN : Code: Select all Prog "XBITMAP" For 1→A To 31 2+Int 12Ran#→C For 1→B To C Text 62-4C+4B,4A,"⸋" Next Next 1→A~B -1→C 0→J~K Lbl 0 Green Text 4B,4A," " Isz A If A>31 Then 1→A Isz B B≥15=>Goto 1 IfEnd PxlTest 4B+2,4A+1 If Ans Then "OOH CA A TOUCHE" Stop IfEnd Green Text 4B,4A,">" GetKey Ans=>Ans→K If C<0 And K=31 Then 4A→D B→C 0→K IfEnd Prog "BRDROP" J≠31=>Goto 0 Lbl 1 "WOW! IMPRESSIONNANT!" Stop Jeuxcasio.com
Sous-programme BRDROP : Code: Select all C≥0=>Text 4C+1,D," " Text 4B,4A,">" GetKey Ans→K If C=15 Or C<0 Then -1→C 0→K For 1→X To 20 GetKey Ans=>Ans→K Next Return IfEnd Isz C PxlTest 4C+3,D If Ans Then For 4C+2→C To 56 Step 6 Text C,D," " Next Text 56,D," " -1→C Isz J Else Text 4C,D,"." IfEnd	Sous-programme BRDROP : Code: Select all C≥0=>Text 4C+1,D," " Text 4B,4A,">" GetKey Ans→K If C=15 Or C<0 Then -1→C 0→K For 1→X To 20 GetKey Ans=>Ans→K Next Return IfEnd Isz C PxlTest 4C+3,D If Ans Then For 4C+2→C To 56 Step 6 Text C,D," " Next Text 56,D," " -1→C Isz J Else Red Text 4C,D,"." IfEnd
	Sous-programme XBITMAP : Code: Select all ViewWindow 1,127,1,1,63,0 CoordOff GridOff LabelOff BG-None F-Line 1,1,127,1 F-Line 127,1,127,63 F-Line 127,63,1,63 F-Line 1,63,1,1

Aucune intention de jeter la pierre, il s'agit juste de rendre à César Tom ce qui lui appartient.

La nouvelle version de CrimsonCasio avait l'avantage :

• d'être disponible au nouveau format .g1r compatible avec la Graph 85 de l'époque ainsi qu'avec l'ensemble des Casio Graph monochromes sorties depuis (Graph 25+E/Pro, Graph 35+E/USB, Graph 75/85/95).
• d'afficher des messages en français
• d'offrir un affichage couleur sur les modèles le supportant à l'époque (Graph 60/65/80 avec leur écran 128×64 pixels sur 2 bits, c'est-à-dire 4 couleurs)

A noter qu'en l'état, le programme ne fonctionne pas correctement avec l'écran très supérieur des modèles couleur plus récents Graph 90+E et fx-CG10/20/50.

Aujourd'hui Florian Allard alias Afyu redonne vie à cette référence vidéoludique pour nombre de lycéens des années 2000-2010. Tu vas pouvoir à nouveau jouer à Bombrun en couleurs sur ta calculatrice... mais à condition cette fois-ci de passer chez NumWorks !

Florian a en effet réécrit l'intégralité du code en Python et adapté les appels graphiques pour la bibliothèque kandinsky !

Téléchargement / test en ligne / installation : BOMBRUN (pour NumWorks)

Téléchargement : BOMBRUN (pour Casio Graph)


Références :

• Bomb Run par Tom Lynn (sur sa page personnelle)
• Bombrun par CrimsonCasio (chez jeuxcasio.com)