π
<-
Chat plein-écran
[^]

News 2024

News 2023
Juin (2)
Avril (1)
Mars (2)

News 2022
Juin (4)
Mai (4)
Avril (4)
Mars (3)

News 2021
Août (5)
Juin (1)
Mai (3)
Avril (12)
Mars (4)

News 2020
Août (1)
Juin (2)
Mai (2)
Avril (7)
Mars (4)

News 2019
Août (1)
Juin (1)
Mai (3)
Avril (7)
Mars (10)

News 2018
Août (3)
Juin (3)
Mai (8)
Avril (13)
Mars (5)

News 2017
Août (1)
Mai (10)
Avril (3)
Mars (4)

News 2016
Août (12)
Juin (8)
Mai (12)
Avril (7)
Mars (9)

News 2015
Août (11)
Juin (6)
Mai (10)
Avril (2)
Mars (6)

News 2014
Octobre (12)
Août (4)
Juin (13)
Mai (14)
Avril (12)
Mars (15)

News 2013
Octobre (30)
Août (14)
Juin (27)
Mai (12)
Avril (29)
Mars (19)
Janvier (27)

News 2012
Octobre (37)
Août (40)
Juillet (27)
Juin (19)
Mai (35)
Avril (34)
Mars (42)
Janvier (46)

News 2011
Octobre (22)
Août (23)
Juillet (14)
Juin (29)
Mai (44)
Avril (24)
Mars (27)

News 2010
Août (6)
Juillet (10)
Juin (4)
Mai (1)
Avril (2)
Mars (1)

News 2009
Juin (1)

Déjoue les pièges du mode examen TI-Nspire CX II

Nouveau messagede critor » 10 Mai 2022, 23:57

13680Ce mercredi 11 mai 2022, c'est la première grande activation nationale du mode examen des calulatrices en France que nous attendions depuis plus de 7 ans.

Mais attention si tu es équipé(e) d'une TI-Nspire CX II. Pour activer le mode examen, beaucoup de tutos te disent d'allumer la calculatrice tout en maintenant la touche :nses: enfoncée. C'est clairement de loin la pire méthode d'activation du mode examen tous modèles confondus, et un véritable piège dans lequel tu ne dois surtout pas tomber ! :#non#:

D'une part, lorsque tu appelles le mode examen de cette façon, tu te vois présenter une boîte de dialogue. Cette boîte de dialogue liste une série de limitations des fonctionnalités de la calculatrice. Si ta calculatrice est à jour il y en a très exactement 13, dont 11 cochées par défaut :


Une très grave erreur est de valider cette boîte de dialogue avec ses options par défaut, soit sans faire exprès, soit parce que tu auras suivi un tuto-vidéo mal conçu comme il en existe, hélas même parmi les plus populaires. :mj:

Tu récupères alors une calculatrices avec toute une série de fonctionnalités inutilisables alors que tu les as payées en optant pour ce modèle, et que la réglementation française du mode examen ne demande pas de bloquer de fonctionnalités mais uniquement le contenu mémoire préexistant.
Comme indiqué dans les bons tutos, la bonne manipulation de cette boîte de dialogue est d'y taper
ctrl
A
pour décocher l'ensemble des limitations de fonctionnalités.

Attention toutefois car il y a ici aussi un piège comme si cela ne suffisait pas.

Si ta calculatrice ne fait pas tourner la dernière version mais la version précédente 5.3.0, par exemple parce que tu auras voulu conserver l'accès à Ndless, le raccourci
ctrl
A
commencera par tout cocher ce qui n'est surtout pas ce que tu veux.

Vérifie donc bien visuellement ; si tu es dans ce cas-là il te faudra taper
ctrl
A
deux fois de suite.

Mais attends, car ce n'est même pas le pire jusqu'à présent. En effet, par défaut cette boîte de dialogue :
  • sur les TI-Nspire CX II CAS, TI-Nspire CX II-T CAS et TI-Nspire CX II-C CAS, désactive le CAS (moteur de calcul exact et formel)
  • sur TI-Nspire CX II-T, désactive le moteur de calcul exact (le moteur de calcul formel n'étant de toutes façons pas inclus sur ce modèle)

Si tu valides en l'état, tu obtiens alors une calculatrice très lourdement bridée n'étant même plus capable de faire du calcul formel ou même exact

La réactivation de cette fonctionnalité sur cette interface avant de valider est certes possible, mais c'est une opération lourde pour laquelle nous ne connaissons pas de raccourci, nécessitant de dérouler une liste déroulante pour en changer la sélection, et surtout de ne pas commettre l'erreur de valider la fenêtre au cours de la procédure.

13699Et bien il y a beaucoup plus simple. Si ta calculatrice est à jour en version 5.3.0 ou supérieure, tu disposes d'une nouvelle interface d'activation du mode examen, appelable en allumant la calculatrice avec la touche
tab
enfoncée.

L'interface te demande alors un code d'activation à 8 chiffres, et pour la France c'est extrêmement simple. En effet pour obtenir un maximum de fonctionnalités en mode examen, il te suffit de saisir au choix :
  • 0000-0000 (unité d'angle en degrés par défaut)
  • 0000-0001 (unité d'angle en radians par défaut, préférable pour les épreuves de Mathématiques)
La différence entre ces deux codes est juste l'unité d'angle par défaut ; il restera toujours possible par la suite une fois en mode examen de changer d'unité à tout moment.

Une nouvelle procédure d'activation du mode examen beaucoup plus facile, enfin une solution aux énormes problèmes précédents ! :bj:
En effet ces codes n'activent aucune limitation de fonctionnalité. Tu les retrouveras donc en intégralité, ainsi que le moteur de calcul exact et le moteur de calcul formel CAS si présent, comme te le confirmera l'écran intermédiaire avant validation ! :bj:

Les bons tutos sont disponibles ci-dessous et te seront accessibles jusqu'avant ton épreuve sur smartphone, ou encore sur l'ordi/tablette du surveillant pour les plus sympa d'entre eux.

Liens :
Lien vers le sujet sur le forum: Déjoue les pièges du mode examen TI-Nspire CX II (Commentaires: 0)

Déjoue les pièges du mode examen TI-Nspire CX

Nouveau messagede critor » 10 Mai 2022, 21:37

13676Ce mercredi 11 mai 2022, c'est la première grande activation nationale du mode examen des calulatrices en France que nous attendions depuis plus de 7 ans.

Mais attention si tu es équipé(e) d'une TI-Nspire CX (CAS) ou TI-Nspire (CAS) monochrome, car son mode examen est un véritable piège, l'un des pires tous modèles confondus ! :#non#:

Lorsque tu appelles le mode examen en allumant la calculatrice tout en maintenant la touche :nses: enfoncée, tu te vois présenter une boîte de dialogue.

Cette boîte de dialogue liste une série de limitations des fonctionnalités de la calculatrice. Si ta calculatrice est à jour il y en a très exactement 12, dont 11 cochées par défaut :


Une très grave erreur est de valider cette boîte de dialogue avec ses options par défaut, soit sans faire exprès, soit parce que tu auras suivi un tuto-vidéo mal conçu comme il en existe, hélas même parmi les plus populaires. :mj:

Tu récupères alors une calculatrices lourdement bridée avec toute une série de fonctionnalités inutilisables, alors que tu les as payées en optant pour ce modèle haut de gamme, et que la réglementation française du mode examen ne demande pas de bloquer de fonctionnalités mais uniquement le contenu mémoire préexistant.

Te voilà donc fortement désavantagé(e) par rapport à d'autres candidats et bel et bien piégé(e), car la configuration du mode examen est alors impossible à modifier sans désactiver ce dernier, opération que l'on sait être extrêmement contraignante et en pratique impossible en salle d'examen ! :'(

Comme indiqué dans les bons tutos, la bonne façon de faire est de taper :nsct: :nsa: sur la boîte de dialogue en question pour décocher l'ensemble des limitations de fonctionnalités :


Attention toutefois car il y a ici aussi un piège comme si cela ne suffisait pas.

Si ta calculatrice ne fait pas tourner la dernière version 4.5.5 mais la précédente version 4.5.4, par exemple parce que tu auras voulu conserver l'accès à Ndless, le raccourci :nsct: :nsa: commencera par tout cocher ce qui n'est surtout pas ce que tu veux.

Vérifie donc bien visuellement ; si tu es dans ce cas-là il te faudra taper :nsct: :nsa: deux fois de suite.


Les bons tutos sont disponibles ci-dessous et te seront accessibles jusqu'avant ton épreuve sur smartphone, ou encore sur l'ordi/tablette du surveillant pour les plus sympa d'entre eux.

Liens :
Lien vers le sujet sur le forum: Déjoue les pièges du mode examen TI-Nspire CX (Commentaires: 0)

Mise à jour KhiCAS avec graphes 3D TI-Nspire CX NumWorks

Messagede Admin » 04 Mai 2022, 09:59

15494Les modèles haut de gamme TI-Nspire, HP Prime et Casio fx-CP400 sont tous capables de te réprésenter graphiquement en 3D des fonctions à 2 variables.

Problème, si tu as acheté un modèle moins onéreux de milieu de gamme, cette fonctionnalité n'était pas intégrée. C'est notamment un des derniers manques majeurs de la calculatrice NumWorks selon notre comparatif de rentrée 2021.

Il t'était parfois possible de rajouter cette fonctionnalité via un programme ou une application, mais cela t'était alors inaccessible en mode examen.

Mais c'est sans compter sur KhiCAS. Conçu par Bernard Parisse, enseignant-chercheur à l'Université de Grenoble, KhiCAS est la déclinaison sur calculatrices du logiciel de Mathématiques intégré Xcas. Disponible pour calculatrices NumWorks N0110, TI-Nspire CX, Casio Graph 35+E II et Graph 90+E, KhiCAS te donne donc accès à une interface unifiée ainsi qu'à des fonctionnalités haut de gamme peu importe la marque ou le modèle de ta calculatrice ! :bj:

12024Ce formidable environnement de Mathématiques et de sciences t'apporte bien des choses. Nous pouvons citer dans tous les cas :
  • la reprise du moteur de calcul formel GIAC développé pour Xcas par le même auteur.
  • la possibilité de programmer dans 2 langages :
    • le langage Xcas historique
    • le langage Xcas avec une couche de compatibilité syntaxique Python

Dans ses éditions pour TI-Nspire CX et NumWorks N0110, KhiCAS apporte pas mal de fonctionnalités. Une amélioration très significative des capacités de ta NumWorks N0110 et TI-Nspire CX numérique de milieu de gamme, mais également une amélioration loin d'être vide de ta TI-Nspire CX CAS de haut de gamme. Nous pouvons citer :
  • possibilité de composer et convertir ses unités
  • une bibliothèque de constantes physiques
  • plusieurs applications elles-même intégrées, dont entre autres :
    • tableur / feuille de calcul
    • tableau périodique des éléments
    • calcul financier
  • 2 langages de programmation supplémentaires :
    • Python via un interpréteur Micropython
    • Javascript via un interpréteur QuickJS

L'environnement Python sur ces modèles est extrêmement riche, bien davantage que les solutions Python intégrées par les constructeurs. On peut citer nombre de bibliothèques :
  • cas et xcas pour appeler le moteur de calcul formel GIAC directement depuis tes scripts Python
  • cmath pour traiter directement tes calculs sur les nombres complexes en Python
  • linalg pour l'algèbre linéaire
  • arit pour l'arithmétique
  • ulab.scipy pour le calcul scientifique
  • ulab.numpy pour le calcul matriciel et vectoriel
  • plusieurs bibliothèque de tracés :
    • turtle pour les tracés relatifs à la Scratch, avec en prime les méthodes de remplissage de formes et la possibilité de faire défiler l'affichage obtenu
    • matplotlib pour les tracés dans un repère
    • graphic pour les tracés par pixels, accompagnée de casioplot pour la compatibilité avec les scripts graphiques Casio et kandinsky pour la compatibilité avec les scripts graphiques NumWorks
  • et bien d'autres : gc, math, micropython, nsp, pylab, random, sys, time, ubinascii, ucollections, uctypes, uerrno, uhashlib, uheapq, uio, ujson, ure, ustruct, uzlib

KhiCAS n'apportant pas des données mais des fonctionnalités, son usage en situation d'examen est parfaitement légitime selon les spécifications officielles du mode examen.

Cela ne contente bien évidemment pas les constructeurs, mais plusieurs contournements légitimes du mode examen ont été codés en conséquence dans le cadre de KhiCAS sans l'accord des constructeurs en question. Ils sont soigneusement surveillés afin de ne permettre aucune fraude, du moins en France. Nous pouvons citer :
  • Sur NumWorks N0110, l'installation de l'application KhiCAS nécessite elle-même l'installation d'un firmware tiers (Khi, Omega ou Upsilon). Ces firmwares tiers te permettront justement de conserver l'accès à KhiCAS en mode examen.
  • Sur les TI-Nspire CX, KhiCAS nécessite l'installation du jailbreak Ndless. Il te sera alors possible d'activer le mode examen directement depuis KhiCAS. Seule différence avec l'activation officielle du mode examen, dans ce cas Ndless et KhiCAS seront conservés et utilisables en mode examen.
    Attention toutefois, cette astuce ne fonctionne pas à ce jour sur les derniers modèles TI-Nspire CX II

15495Et bien justement, grosse nouveauté de la dernière version stable de KhiCAS, nous disposons maintenant des fonctions plot3d() et graphe3d() pour tracer des représentations graphiques 3D de fonctions à 2 variables ! :bj:

La fonction attend 3 paramètres avec dans l'ordre l'expression et les noms de ses deux variables. Voici par exemple ci-contre le résultat de l'appel plot3d(x*x*y,x,y).

Sur TI-Nspire c'était certes déjà disponible officiellement, mais on peut apprécier l'affichage sur fond sombre visuellement moins fatigant, ainsi que les nombreuses touches clavier permettant de contrôler la vue (certes les touches fléchées pour les rotations selon 2 axes,
+
et
-
pour le zoom, mais également l'ensemble des touches numériques pour encore plus de possibilités de déplacements)
.


La commande est utilisable directement si ton environnement KhiCAS est réglé en langage Xcas, y compris avec la compatibilité syntaxique Python. Si tu as réglé ton environnement KhiCAS sur l'interpréteur Micropyton, il te faudra passer par les fonctions d'évaluation du module cas ou xcas à importer, fonctions te permettant d'appeler le moteur GIAC de Xcas. Tu peux utiliser au choix une des commandes suivantes :
Code: Tout sélectionner
cas.caseval("plot3d(x*x*y,x,y)")
cas.eval_expr("plot3d(x*x*y,x,y)")
xcas.caseval("plot3d(x*x*y,x,y)")
xcas.eval_expr("plot3d(x*x*y,x,y)")


15496Par contre sur NumWorks N0110 c'est indiscutablement une amélioration des fonctionnalités de ta calculatrice et donc de sa valeur ! :bj:

Téléchargement / installation :
Lien vers le sujet sur le forum: Mise à jour KhiCAS avec graphes 3D TI-Nspire CX NumWorks (Commentaires: 0)

Réétiquette & connecte clavier + souris USB à ta TI-Nspire

Nouveau messagede critor » 25 Avr 2022, 10:14

Les calculatrices graphiques TI-83 Premium CE, TI-84 Plus CE et TI-Nspire sont de formidables machines. Ce sont les seules calculatrice graphiques permettant à ce jour la connexion fonctionnelle de périphériques de saisie USB HID, une exclusivité de la gamme Texas Instruments ! :favorite:

13805Pour être plus exact, nous pouvons évoquer la HP Prime G2 dont la mise à jour 2.1.14575 de mai 2021 active enfin le support générique des périphériques USB.

Sauf qu'en pratique aucun pilote n'est inclus et donc rien ne peut fonctionner en dehors des périphériques officiels HP StreamSmart (interfaces pour capteurs de mesures physiques). Cette dernière mise à jour développée dans l'urgence des examens juste avant la cession de la branche a de plus le défaut d'être hautement instable, plantant très facilement sur des opérations officielles avec une fréquence jamais vue jusqu'alors.

Rajoutons que Hewlett Packard s'est séparé définitivement de sa branche calculatrices pour la rentrée 2021, commettant l'erreur monumentale de vendre le tout à Moravia, une obscure société tchèque.

Rappelons que Moravia avait également racheté la branche calculatrices de Sharp en 2015, et n'en a strictement rien fait depuis maintenant 7 ans, continuant à vendre les mêmes produits sans plus jamais investir dans la moindre évolution logicielle ou matérielle. Les calculatrices Sharp accumulant en conséquence un retard de plus en plus abyssal par rapport à la concurrence, forcément leur popularité s'est effondrée depuis et elles ont de plus en plus disparu des rayons de nos boutiques physiques ou virtuelles.

Moravia ne semblant pas se donner davantage de mal ici, n'ayant notamment toujours pas fait l'effort depuis un an de nous sortir une mise à jour corrigeant l'instabilité, et n'ayant donc visiblement aucun scrupule à vendre à prix d'or un produit défectueux, nous doutons fortement qu'ils s'amusent à court ou même moyen terme à achever le support générique des périphériques USB ébauché chez HP juste avant la fin.

12277Les périphériques USB peuvent donc être connectés directement à ta calculatrice TI l'aide d'un simple adaptateur mini-USB.

Il t'est ensuite possible par exemple de connecter un clavier USB Qwerty à ta TI-83 Premium CE ou TI-84 Plus CE pour une saisie beaucoup plus rapide en situation semi-nomade (en classe ou chez toi par exemple), et même comme déjà expliqué pour encore plus d'efficacité d'en profiter pour réétiqueter le clavier en question :
134621346313464

Aujourd'hui parlons TI-Nspire. Le support des périphériques USB HID est :
  • directement intégré aux derniers modèles TI-Nspire CX II
  • peut être activé sur les anciens modèles TI-Nspire via le programme Ndless HIDn

La même chose est donc possible, et nous te partageons donc d'une part aujourd'hui la feuillet de réétiquetage de clavier pour TI-Nspire dont nous venons tout juste de finaliser une première version. Pour rappel, feuillet à imprimer sur papier autocollant transparent (dans les options d'impression choisir un type de papier brillant épais si disponible, ou sinon à défaut brillant tout court).
1548115482

1548415483Encore mieux que ça, contrairement aux TI-83 Premium CE ou TI-84 Plus CE, les TI-Nspire gèrent également les souris USB pour encore plus de confort ! :bj:

Mais comment faire pour profiter à la fois des clavier et souris USB alors que ta TI-Nspire ne dispose que d'un unique port mini-USB ?

Le plus simple est de te procurer un hub mini-USB, que tu pourras alors directement connecter à l'aide du câble fourni à l'achat et destiné à relier deux calculatrices entre elles.

15486Et voici maintenant enfin ta nouvelle station d'accueil TI-Nspire pour travailler en situation semi-nomade à la maison ou en classe ! :bj:
Attention toutefois, en France la réglementation des examens interdit l'usage de tout module externe avec ta calculatrice, peu importe qu'il nécessite un câble ou soit directement enfichable.

Le but de cette interdiction était initialement d'empêcher l'échange de données entre candidats :
  • par connexion et échange de cartes mémoire (c'était possible sur d'anciens modèles Casio et HP, capacité qui a totalement disparu dans le cadre du renouvellement de l'ensemble de la gamme pour le mode examen à l'approche de 2015)
  • par connexion de modules de communication sans fil (des solutions infrarouge ont existé dans le temps, même si de nos jours cela se ferait plutôt en bluetooth ou WiFi)

Donc même si clavier et souris USB ne sont absolument pas les appareils de triche ciblés par cette interdiction, malheureusement ils tombent sous le coup de cette interdiction générique et ce confort d'utilisation te sera ainsi hélas interdit en examen. :'(

Téléchargements :
Lien vers le sujet sur le forum: Réétiquette & connecte clavier + souris USB à ta TI-Nspire (Commentaires: 0)

nQuake 1.03 accéléré + gérant dernières TI-Nspire CX

Nouveau messagede critor » 20 Avr 2022, 09:19

Nous te parlons régulièrement sur nos calculatrices de jeux Doom-like, du nom du mythique jeu fps de 1993 par id Software avec affichage 3D (technique du raycasting étendu).

Si sur calculatrices il s'est souvent agi de créations de fans dans loin d'égaler l'original, signalons les TI-Nspire avec leur formidable processeur 32 bits ARM9 (architecture ARMv5) qui sont les premières calculatrices à avoir bénéficié d'un véritable portage, nDoom par Mrakoplatz pour les TI-Nspire monochromes dès 2011, puis moi-même dès 2012 pour les TI-Nspire CX. C'est-à-dire qu'il s'agit d'une recompilation intégrale à partir du code source du jeu. Tu pouvais donc ici retrouver l'intégralité du jeu original ainsi que de ses extensions et évolutions compatibles (Ultimate Doom, Final Doom, Plutonia Experiment, TNT Evilution, Doom II, ...)
Le code source de nDoom vient tout juste d'être repris cette année pour créer CGDoom, un portage compatible Casio Graph 90+E et fx-CG10/20/50.

Rappelons que sur les TI-Nspire la couche logicielle très lourde de l'environnement écrase littéralement les performances des programmes en langage interprété (Basic ou Python), que pour ce genre de projet il faut pouvoir exécuter du code machine et donc disposer du jailbreak Ndless, que malheureusement Texas Instruments a toujours farouchement combatte le jailbreak Ndless et que l'équipe de développement de ce dernier semble avoir baissé les bras, Ndless n'est plus adapté pour les dernières mises à jour de rentrée 2021 (TI-Nspire CX 4.5.5 et TI-Nspire CX II 5.3.1) qui bien évidemment interdisent le retour à une version inférieure. :'(

5937Mais id Software n'a pas sorti que Doom dans ce style. Avant Doom il y a eu Wolfenstein 3D en 1992, et après Doom il y a eu Quake en 1996.

Quake a lui aussi bénéficié d'un portage pour TI-Nspire par Ralf Willenbacher alias rwill en 2015.

Par rapport à Doom, Quake apporte plusieurs évolutions significatives au moteur :
  • D'une part le moteur permet d'afficher l'ensemble des éléments en 3D. C'est-à-dire que les ennemis et items ne sont plus de simples sprites te présentant toujours la même face pour les items, ou un nombre limité de faces pour les ennemis.
  • D'autre part, tu peux désormais sauter et même dans certaines conditions voler. c'est-à-dire que la 3ème dimension passe d'une décoration à un véritable élément de jeu.

rwill nous ayant hélas quitté pour un temps, dans le cadre des dernières mises à jour de Ndless Vogtinator s'était chargé de patcher nQuake pour le rendre compatible avec les révisions majeures du matériel TI-Nspire CX sorties depuis :
  • les TI-Nspire CX CR4+ (assemblées à partir d'octobre 2015) qui retournaient la géométrie du buffer l'écran, ce dernier passant de 320×240 pixels à 240×320 pixels
  • les TI-Nspire CX II (assemblées depuis novembre 2018)
Toutefois, il s'agissait d'un patch très rapide s'appuyant sur le mode de compatibilité alors introduit dans Ndless, un mode qui interceptait et corrigeait les affichages. L'activation de ce mode t'était indiquée par une fenêtre popup au lancement de nQuake, et dans ce cas les performances n'étaient pas au rendez-vous.

15453Et bien bonne nouvelle, rwill est de retour cette année ! :D

Il vient de prendre le temps de nous signer une mise à jour nQuake de qualité, la version 1.03 :
  • gérant désormais directement les dernières révisions matérielles TI-Nspire, et n'utilisant donc plus le mode de compatibilité Ndless :bj:
  • et en prime nettement plus performante :bj:

Regarde un peu ces performances que nous avons mesurées, sans aucun overclocking :
modèle
fréquence
processeur
ancien nQuake
par Vogtinator
nouveau nQuake
par rwill
TI-Nspire CX
132 MHz
7.8 fps
10 fps (+28,21%)
TI-Nspire CX CR4+
156 MHz
9.8 fps
10 fps (+2,04%)
TI-Nspire CX II
396 MHz
20.8 fps
26 fps (+25%)


Avec des performances aussi fantastiques, sur les dernières TI-Nspire CX II nous sommes désormais à vitesse réelle, zyeute un peu ça : :#tritop#:

Téléchargements :

Source : viewtopic.php?f=20&t=25548
Lien vers le sujet sur le forum: nQuake 1.03 accéléré + gérant dernières TI-Nspire CX (Commentaires: 0)

KhiCAS NumWorks Nspire CX: Python-turtle encore plus parfait

Nouveau messagede critor » 19 Avr 2022, 11:25

15120Pour accompagner en douceur la transition du Scratch au Python en Seconde, la plupart des solutions Python sur calculatrices graphiques offrent turtle, une bibliothèque permettant du tracé relatif comme en Scratch. On peut citer :
  • la NumWorks dont l'application Python intègre directement turtle
  • les Casio Graph 35+E II et Graph 90+E dont l'application Python intègre directement turtle
  • les TI-Nspire CX II sur lesquelles on peut rajouter la bibliothèque officielle turtle (anciennement ce_turtl) à l'environnement Python
  • les TI-83 Premium CE Edition Python (France), TI-84 Plus CE-T Python Edition (Europe) et TI-84 Plus CE Python (Amérique du Nord), sur lesquelles on peut rajouter une bibliothèque turtle officielle
  • et KhiCAS

11302Aujourd'hui penchons-nous à nouveau sur le turtle de KhiCAS. Conçu par Bernard Parisse, enseignant-chercheur à l'Université de Grenoble, KhiCAS est la déclinaison sur calculatrices du logiciel de Mathématiques intégré Xcas. Disponible pour calculatrices NumWorks N0110, TI-Nspire CX, Casio Graph 35+E II et Graph 90+E, KhiCAS te donne donc accès à une interface unifiée ainsi qu'à des fonctionnalités haut de gamme peu importe la marque ou le modèle de ta calculatrice ! :bj:

12024Ce formidable environnement de Mathématiques et de sciences t'apporte bien des choses. Nous pouvons citer dans tous les cas :
  • la reprise du moteur de calcul formel GIAC développé pour Xcas par le même auteur.
  • la possibilité de programmer dans 2 langages :
    • le langage Xcas historique
    • le langage Xcas avec une couche de compatibilité syntaxique Python

Dans ses éditions pour TI-Nspire CX et NumWorks N0110, KhiCAS apporte pas mal de compléments :
  • possibilité de composer et convertir ses unités
  • une bibliothèque de constantes physiques
  • plusieurs applications elles-même intégrées, dont entre autres :
    • tableur / feuille de calcul
    • tableau périodique des éléments
    • calcul financier
  • 2 langages de programmation supplémentaires :
    • Python via un interpréteur Micropython
    • Javascript via un interpréteur QuickJS

L'environnement Python sur ces modèles est extrêmement riche, bien davantage que les solutions Python intégrées par les constructeurs. On peut citer nombre de bibliothèques :
  • cas et xcas pour appeler le moteur de calcul formel GIAC directement depuis tes scripts Python
  • cmath pour traiter directement tes calculs sur les nombres complexes en Python
  • linalg pour l'algèbre linéaire
  • arit pour l'arithmétique
  • ulab.scipy pour le calcul scientifique
  • ulab.numpy pour le calcul matriciel et vectoriel
  • plusieurs bibliothèque de tracés :
    • turtle pour les tracés relatifs à la Scratch
    • matplotlib pour les tracés dans un repère
    • graphic pour les tracés par pixels, accompagnée de casioplot pour la compatibilité avec les scripts graphiques Casio et kandinsky pour la compatibilité avec les scripts graphiques NumWorks
  • et bien d'autres : gc, math, micropython, nsp, pylab, random, sys, time, ubinascii, ucollections, uctypes, uerrno, uhashlib, uheapq, uio, ujson, ure, ustruct, uzlib

Un fantastique avantage du turtle KhiCAS, exclusif à ce jour, c'est qu'une fois que ton script Python-turtle a terminé de s'exécuter, il t'est possible d'en faire défiler l'affichage avec les flèches du clavier ! :bj:

La dernière mise à jour alpha de KhiCAS améliore encore plus la fiabilité de la bibliothèque turtle. Elle est disponible à ce jour :
  • uniquement en version alpha pour TI-Nspire CX
  • uniquement en version alpha pour NumWorks N0110
Découvrons ensemble les nouveautés.








A) Tests de conformité comparatifs (toutes solutions turtle)

Go to top

Tentons pour le moment un autodiagnostic plus général des différences entres les ancienne et nouvelle bibliothèques turtle de KhiCAS, c'est-à-dire la vérification de tout ce qui peut différer du standard.

Voici des scripts en ce sens, une amélioration majeure de ceux développés dans le code de notre test de rentrée QCC 2021 :
Code: Tout sélectionner
_turtle_errors = 0

def _turtle_error(k):
  global _turtle_errors
  _turtle_errors |= 1 << k

# import turtle
try:
  import turtle
  if not "forward" in dir(turtle):
    turtle = turtle.Turtle()
except ImportError: #TI-83 Premium CE
  from ce_turtl import turtle
  _turtle_error(0)
try:
  turtle.clear()
except:
  turtle.reset()

# can turtle be patched ?
_fix_turtle = True
try:
  def _fixcolor(c): return c
  turtle._fixcolor = _fixcolor
except:
  _fix_turtle = False

# test color() + pencolor() + fillcolor()
if not "pencolor" in dir(turtle):
  pencolor = turtle.color
  _turtle_error(1)
else:
  pencolor = turtle.pencolor
if not "color" in dir(turtle):
  _turtle_error(2)
if not "fillcolor" in dir(turtle):
  _turtle_error(12)

if not "clear" in dir(turtle):
  _turtle_error(13)
if not "reset" in dir(turtle):
  _turtle_error(14)
if not "heading" in dir(turtle):
  _turtle_error(11)

# test color argument types
_color_types = 0
try:
  pencolor([0, 0, 0])
  _color_types |= 1 << 0
except: _turtle_error(4)
try:
  pencolor((0, 0, 0))
  _color_types |= 1 << 1
except: _turtle_error(5)
try:
  pencolor(0, 0, 0)
  _color_types |= 1 << 2
except: _turtle_error(6)
try:
  pencolor("black")
  _color_types |= 1 << 3
except: _turtle_error(7)

# test colormode()
if not "colormode" in dir(turtle):
  _turtle_error(3)

# test color strings
_colors_fix={
  "blue":(0,0,1),
  "green":(0,1,0),
  "red":(1,0,0),
  "cyan":(0,1,1),
  "yellow":(1,1,0),
  "magenta":(1,0,1),
  "white":(1,1,1),
  "orange":(1,0.65,0),
  "purple":(0.66,0,0.66),
  "brown":(0.75,0.25,0.25),
  "pink":(1,0.75,0.8),
  "grey":(0.66,0.66,0.66),
  "black":(0,0,0),
}
for c in tuple(_colors_fix.keys()):
  try:
    pencolor(c)
    _colors_fix.pop(c)
  except: pass
if len(_colors_fix):
  if _color_types & 1 << 3:
    _turtle_error(8)

# test circle(,)
try: turtle.circle(0,0)
except:
  _turtle_error(9)

#test towards
try: turtle.towards
except:
  _turtle_error(15)

# test for unfixable missing functions
_missing_fct=["write","pensize","dot"]
for f in tuple(_missing_fct):
  try:
    eval("turtle."+f)
    _missing_fct.remove(f)
  except: pass
if len(_missing_fct):
    _turtle_error(16)

_missing_alias=[
  ["backward","back","bk"],
  ["forward","fd"],
  ["right","rt"],
  ["left","lt"],
  ["position","pos"],
  ["goto","setpos","setposition"],
  ["setheading","seth"],
  ["pendown","pd","down"],
  ["penup","pu","up"],
  ["pensize","width"],
  ["showturtle","st"],
  ["hideturtle","ht"],
]
for aliases in tuple(_missing_alias):
  validf = None
  for f in tuple(aliases):
    try:
      eval("turtle."+f)
      validf = f
      aliases.remove(f)
      break
    except: pass
  for f in tuple(aliases):
    try:
      eval("turtle."+f)
      aliases.remove(f)
    except: pass
  if not len(aliases):
    _missing_alias.remove(aliases)
  else:
    aliases.insert(0, validf)
if len(_missing_alias):
    _turtle_error(17)

try:
  turtle.position()
except:
  try:
    turtle.pos()
  except:
    _turtle_error(10)
Code: Tout sélectionner
from ttl_chk import *
from ttl_chk import _fix_turtle, _turtle_errors, _colors_fix, _missing_fct, _missing_alias

def turtle_diags():
  print("Type: " + str(type(turtle)))
  print("Patchable: " + (_fix_turtle and "yes" or "no"))
  errors_msg = (
    "No <import turtle>",
    "No pencolor()",
    "No color()",
    "No colormode()",
    "No color as list",
    "No color as tuple",
    "No color as args",
    "No color as string",
    "Missing colors strings: ",
    "No circle(,angle)",
    "Can't get position()",
    "No heading()",
    "No fill",
    "No clear()",
    "No reset()",
    "No towards()",
    "Other missing: ",
    "Missing aliases: ",
  )
  errors = 0
  for k in range(len(errors_msg)):
    if _turtle_errors & 1 << k:
      errors += 1
      msg = "Err " + str(k) + ": " + errors_msg[k]
      if k == 8:
        msg += str(len(_colors_fix)) + " " + str(tuple(_colors_fix.keys()))
      if k == 16:
        msg += str(len(_missing_fct)) + " " + " ".join(_missing_fct)
      if k == 17:
        l = []
        for v in _missing_alias:
          l.extend(v[1:])
        msg += str(len(l)) + " " + " ".join(l)
      print(msg)
  print(str(errors) + " error" + ((errors > 1) and "s" or ""))

turtle_diags()


Voici ce que nous racontent les scripts sur les différentes solutions turtle :

TI-83PCE/84+CE
turtle


TI-Nspire CX II
turtle

Casio
Graph 90E


KhiCAS
NumWorks
TI-Nspire CX II CX

TI-83PCE/84+CE
ce_turtl


NumWorks
Casio
Graph 35+E II



Aucune erreur n'est détectée automatiquement autmatiquement par nos scripts avec KhiCAS, chose exceptionnelle si l'on compare aux solutions officielles, et signe d'un soin absolument minutieux ! :bj:

Mais ça, c'est pour les problèmes détectables par des vérifications automatisées. Voyons maintenant d'éventuels écarts visuels sur quelques exemples de scripts.

Afin de pouvoir comparer équitablement avec les solutions officielles visiblement parfois bien moins conformes au standard turtle tout en conservant une unique version de chaque script utilisable sur l'ensemble des solutions, voici un script qu'il suffira d'importer à la place de chaque bibliothèque turtle et qui, lorsque celle-ci sera modifiable, corrigera la plupart des erreurs détectées : :bj:
Code: Tout sélectionner
from ttl_chk import *
from ttl_chk import _color_types, _turtle_errors, _colors_fix, _missing_fct, _missing_alias

_fix_turtle = True

def nop(*argv): return None
idty = lambda c: c

try: # can turtle be patched ?
  turtle._fixcolorlist = idty
  turtle._fixcolorval = idty
  turtle._fixcolorstring = idty
  turtle._fixcolorargs = idty
  turtle._fixcolor = lambda c: turtle._fixcolorlist(turtle._fixcolorval(turtle._fixcolorstring(turtle._fixcolorargs(c))))
except:
  _fix_turtle = False

if _fix_turtle:

  # fix color() + pencolor()
  if _turtle_errors & 0x1000:
    turtle.fillcolor, turtle.begin_fill, turtle.end_fill = idty, nop, nop
  if _turtle_errors & 2:
    def _pencolor_(*argv):
      if len(argv): turtle.color(argv)
      else: return turtle.color()[0]
    turtle.pencolor = _pencolor_
  if _turtle_errors & 4:
    def _color_(*argv):
      if len(argv) == 2:
        turtle.pencolor(argv[0])
        turtle.fillcolor(argv[1])
      elif len(argv):
        turtle.pencolor(argv)
      else:
        return (turtle.pencolor(), turtle.fillcolor())
    turtle.color = _color_

  _fix_color = _color_types & 0b11 != 0b11 or not "colormode" in dir(turtle)

  # fix list/tuple color argument
  if _color_types & 0b11 == 0b10:
    def _fixcolorlist(c): return type(c) is list and tuple(c) or c
    turtle._fixcolorlist = _fixcolorlist
  if _color_types & 0b11 == 0b01:
    def _fixcolorlist(c): return type(c) is list and list(c) or c
    turtle._fixcolorlist = _fixcolorlist
  if not _color_types & 4:
    def _fixcolorargs(*argv):
      return len(argv) != 1 and argv or argv[0]

  if _fix_color:
    turtle._color = turtle.color
    turtle._pencolor = turtle.pencolor
    turtle._fillcolor = turtle.fillcolor
    if _color_types & 0b11:
      def _color(*argv):
        n = len(argv)
        if not(n): return turtle._color()
        elif n==2: turtle._color(argv[0], argv[1])
        else: turtle._color(n > 1 and argv or argv[0])
      def _pencolor(*argv):
        if not(len(argv)): return turtle._pencolor()
        turtle._pencolor(turtle._fixcolor(len(argv) > 1 and argv or argv[0]))
      def _fillcolor(*argv):
        if not(len(argv)): return turtle._fillcolor()
        turtle._fillcolor(turtle._fixcolor(len(argv) > 1 and argv or argv[0]))
    else:
      def _color(*argv):
        n = len(argv)
        if not(n): return turtle._color()
        c = turtle._fixcolor(n == 3 and argv or argv[0])
        turtle._color(c[0], c[1], c[2])
      def _pencolor(*argv):
        if not(len(argv)): return turtle._pencolor()
        c = turtle._fixcolor(len(argv)>1 and argv or argv[0])
        turtle._pencolor(c[0], c[1], c[2])
      def _fillcolor(*argv):
        if not(len(argv)): return turtle._fillcolor()
        c = turtle._fixcolor(len(argv)>1 and argv or argv[0])
        turtle._fillcolor(c[0], c[1], c[2])
    turtle.color = _color
    turtle.pencolor = _pencolor
    turtle.fillcolor = _fillcolor

  # fix colormode()
  if _turtle_errors & 8:
    # test color mode
    try:
      turtle.pencolor([255, 0, 0])
      _color_mode = 255
    except: _color_mode = 1.0
    turtle._color_mode = _color_mode
    def _colormode(*argv):
      if not(len(argv)): return turtle._color_mode
      if int(argv[0]) in (1, 255):
        turtle._color_mode = int(argv[0]) == 255 and 255 or 1.0
    turtle.colormode = _colormode
    if _color_mode == 255:
      turtle._fixcolorval = lambda c: int(turtle._color_mode) == 1 and type(c) in (list, tuple) and [int(c[k] * 255) for k in range(3)] or c
    else:
      turtle._fixcolorval = lambda c: turtle._color_mode == 255 and type(c) in (list, tuple) and [c[k] / 255 for k in range(3)] or c

  # fix color strings
  if len(_colors_fix):
    def _fixcolorstring(c):
      if type(c) is str and c in _colors_fix:
        c = _colors_fix[c]
        if turtle.colormode() == 255:
          c = [int(c[k] * 255) for k in range(3)]
      return c
    turtle._fixcolorstring = _fixcolorstring

  # fix circle(,)
  if _turtle_errors & 0x200:
    turtle._circle = turtle.circle
    def _circle(r, a=360): turtle._circle(r)
    turtle.circle = _circle

  if len(_missing_fct):
    for f in _missing_fct:
      exec("turtle."+f+"=nop")

  if len(_missing_alias):
    for aliases in _missing_alias:
      validf = aliases[0]
      for f in aliases[1:]:
        exec(validf and "turtle."+f+"=turtle."+validf or "turtle."+f+"=nop")

  # fix clear()
  if _turtle_errors & 0x2000:
    turtle.clear = turtle.reset

  # fix reset()
  if _turtle_errors & 0x4000:
    turtle.reset = turtle.clear

  # fix towards()
  if _turtle_errors & 0x8000:
    from math import atan2, pi
    def _towards(x, y):
      x0, y0 = turtle.pos()
      return atan2(y - y0, x - x0) * 180 / pi
    turtle.towards = _towards




B) 4 exemples comparatifs améliorés

Go to top

Maintenant que nous avons de quoi faire tourner une unique version de chaque script sur l'ensemble des machines, poursuivons donc l'exploration de l'ensemble des solutions turtle avec quelques exemples de script.

Nous allons en profiter pour nous en donner à cœur joie avec les formidables fonctions de remplissage rajoutées dans l'avant-dernière version de KhiCAS, sur le thème de #LesMathématiquesSontBelles.

C'est donc l'occasion de voir si il y avait d'autres problèmes qui n'ont pas pu être détectés automatiquement, et si ils sont toujours présents dans la dernière version.

Plusieurs des exemples qui vont suivre sont inspirés de publications de Bert Wikkerink pour TI-Nspire CX II et très librement et fortement adaptés pour être fonctionnels dans le contexte du heap Python bien plus restreint des TI-83 Premium CE et compatibles.

Commençons par quelques exemples sur lesquels la dernière version de KhiCAS progresse :

Exemple B1 : Le défilé automobile

Go to top

Nous t'emmenons maintenant au défilé avec les logos de plusieurs grands constructeurs... automobiles :
Code: Tout sélectionner
from ttl_fix import *

def rpoly(c, n):
  for k in range(n):
    turtle.forward(c)
    turtle.left(360 / n)

def audi(r):
  ir = 2 * r // 13
  turtle.penup()
  turtle.left(90)
  turtle.forward(r//2 - 2*ir)
  turtle.right(90)
  turtle.forward(-ir)
  turtle.pendown()
  turtle.pensize(3)
  for i in range(4):
    turtle.penup()
    turtle.forward(3 * ir)
    turtle.pendown()
    turtle.circle(2 * ir)

def mercedez_benz(r):
  ir = r // 2
  turtle.penup()
  turtle.forward(ir)
  turtle.left(90)
  turtle.forward(ir)
  turtle.pendown()
  turtle.pensize(2)
  x, y = turtle.pos()
  turtle.setheading(210)
  for i in range(3):
    turtle.goto(x,y)
    turtle.forward(ir)
    turtle.left(120)
  turtle.setheading(0)
  turtle.circle(-ir)

def citroen(r):
  x,y=turtle.pos()
  turtle.setheading(0)
  turtle.color((255,0,0), (255,0,0))
  turtle.begin_fill()
  rpoly(r, 4)
  turtle.end_fill()
  turtle.fillcolor((255,255,255))
  for i in range(2):
    turtle.setheading(45)
    turtle.begin_fill()
    for k in range(2):
      turtle.forward(.71 * r)
      turtle.left(k and 172 or -90)
    for k in range(2):
      turtle.forward(5 * r / 6)
      turtle.left(106)
    turtle.end_fill()
    y += r / 3
    turtle.penup()
    turtle.goto(x,y)
    turtle.pendown()

def mitsubichi(r):
  ir = r // 3
  turtle.penup()
  turtle.left(90)
  turtle.forward(ir)
  turtle.right(90)
  turtle.forward(r // 2)
  turtle.pendown()
  for i in range(3):
    turtle.setheading(60 + 120*i)
    turtle.color((255,0,0), (255,0,0))
    turtle.begin_fill()
    for k in range(4):
      turtle.forward(ir)
      turtle.left((k%2) and 120 or 60)
    turtle.end_fill()

def jeep(r):
  a=54
  ir = r/0.47552825814758/4 #sin(radians(a))/cos(radians(a))
  a=ir/0.85
  d=0.93*ir
  turtle.penup()
  turtle.forward(r//2)
  turtle.right(90)
  turtle.forward(ir - r)
  turtle.pendown()
  x, y = turtle.pos()
  turtle.setheading(234)
  turtle.forward(ir)
  turtle.left(126)
  turtle.fillcolor((180,180,180))
  turtle.begin_fill()
  rpoly(a, 5)
  turtle.end_fill()
  for i in range(5):
    col = i < 3 and (0,0,0) or (255,255,255)
    for j in range(2):
      turn =  j and turtle.left or turtle.right
      turtle.goto(x,y)
      turtle.setheading(90 + 72*i)
      turtle.fillcolor(col)
      turtle.begin_fill()
      turtle.forward(d)
      turn(172)
      turtle.forward(0.85*d)
      turn(44)
      turtle.forward(0.2*d)
      turtle.end_fill()
      col = [255 - col[k] for k in range(3)]

turtle.speed(0)
turtle.colormode(255)

r = 92
for iy in range(2):
  for ix in range(3):
    i = iy*3+ix
    if i < 5:
      y, x = (2*iy - 1) * r//2 - 48, (ix - 1)*r - 50
      turtle.penup()
      turtle.goto(x, y)
      turtle.setheading(0)
      turtle.pensize(1)
      turtle.pencolor((0,0,0))
      turtle.pendown()
      (mercedez_benz,jeep,mitsubichi,citroen,audi)[i](r)

try: turtle.show() #TI-83 Premium CE
except: pass


TI-83PCE/84+CE
turtle

TI-Nspire CX II
turtle

Casio
Graph 90+E

nouveau
KhiCAS
NumWorks
TI-Nspire CX II CX

TI-83PCE/84+CE
ce_turtl

NumWorks
Casio
Graph 35+E II

ancien
KhiCAS
NumWorks
TI-Nspire CX II CX


Amélioration fantastique, KhiCAS rattrape le gros retard qu'il avait ici par rapport à la concurrence, et trace maintenant correctement les différents logos des constructeurs ! :bj:

Exemple B2 : Les flocons de Koch

Go to top

Encore une fois si tu es dans le Sud de la France, tu n'a pas dû voir de neige depuis des années... Faison donc neiger dans ta calculatrice maintenant, faisons neiger des flocons de Koch :
Code: Tout sélectionner
from ttl_fix import *

def rotate_list(l):
  l[1:],l[0] = l[0:-1],l[-1]

def koch(n, l):
  if n<=0:
    turtle.forward(l)
  else:
    koch(n - 1, l / 3)
    turtle.left(60)
    koch(n - 1, l / 3)
    turtle.right(120)
    koch(n - 1, l / 3)
    turtle.left(60)
    koch(n - 1, l / 3)

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

turtle.speed(0)
turtle.colormode(255)

c = [127, 255, 0]
l = 80
for j in range(2):
  for i in range(3):
    n = j and 3 + i or 2 - i
    s = 5 - n
    turtle.penup()
    turtle.goto(i*117-157, j*95-25)
    turtle.pencolor(tuple(c))
    turtle.pensize(s)
    turtle.setheading(0)
    turtle.pendown()
    flock(n, l)
    n += 1
    rotate_list(c)

try: turtle.show() #TI-83 Premium CE
except: pass


TI-83PCE/84+CE
turtle

TI-Nspire CX II
turtle

Casio
Graph 90+E

nouveau
KhiCAS
NumWorks
TI-Nspire CX II CX

TI-83PCE/84+CE
ce_turtl

NumWorks
Casio
Graph 35+E II

ancien
KhiCAS
NumWorks
TI-Nspire CX II CX


Beau progrès ici aussi, le flocon en haut à droite est enfin tracé de la bonne couleur comme chez la concurrence.

Exemple B3 : La linea

Go to top

Code: Tout sélectionner
try: #TI-83 Premium CE
  from ti_system import disp_clr
  disp_clr()
except: pass
from ttl_fix import *

def spiral(k,a,l):
  x0, y0 = turtle.pos()
  h0 = turtle.heading()
  while True:
    for s in l:
      turtle.forward(s*k)
      turtle.left(180-a)
    x, y = turtle.pos()
    if abs(x - x0) + abs(y - y0) + abs(turtle.heading() - h0) <= 1:
      break

turtle.speed(0)
turtle.pensize(1)
turtle.colormode(255)
turtle.color((0,0,0),(255,255,0))

try:
  for i in range(-1, 2, 2):
    turtle.penup()
    turtle.goto(80*i - ((i > 0) and 40 or 50), 0)
    turtle.pendown()
    try: turtle.begin_fill()
    except: pass
    spiral((i > 0) and 9 or 30, (i > 0) and 90 or 36, (i > 0) and (1,2,3,4,5,6,7,8,9) or (1,2,3))
    try: turtle.end_fill()
    except: pass
except MemoryError as e: print(e)

try: turtle.show() #TI-83 Premium CE
except: pass


TI-83PCE/84+CE
turtle

TI-Nspire CX II
turtle

Casio
Graph 90+E

nouveau
KhiCAS
NumWorks
TI-Nspire CX II CX

TI-83PCE/84+CE
ce_turtl

NumWorks
Casio
Graph 35+E II

ancien
KhiCAS
NumWorks
TI-Nspire CX II CX


Belle amélioration ici aussi, KhiCAS remplit enfin correctement la forme de droite magré sa complexité !

Exemple B4 : Pavage d'une lagogne

Go to top

Partons maintenant à la pêche avec un script très hautement impressionnant par rapport aux contraintes de heap des TI-83 Premium CE et compatibles ; ici nous sommes vraiment sur le fil de la limite des possibilités concernant ces modèles.

Voici donc une lagogne littéralement pavée de poissons :
Code: Tout sélectionner
from math import sqrt
from ttl_fix import *

turtle.speed(0)
turtle.pensize(1)
turtle.colormode(255)
turtle.pencolor((0,0,0))

a=16

try:
  j = 0
  while -5 < j < 4:
    col = ((0,0,255),(255,0,0),(255,180,0))[j%3]
    i = 0
    while -2 + (j % 2) < i < 2:
      for c in range(3):
        turtle.penup()
        turtle.goto(sqrt(3)*3*a*(i*2-(j%2)), 3*a*j)
        turtle.setheading(-30 + 120*c)
        turtle.pendown()
        turtle.fillcolor(col)
        turtle.begin_fill()
        for k in range(-17, 18):
          l = a*sqrt(7)
          tf = ((1,141.787), (0,l), (1,-100.893), (0,a), (1,120), (0,a/2), [1,-120], [0,-a], [0,a], [1,120], (0,a/2), (1,60), (0,a), (1,-120), (0,a), (1,100.893), (0,l), [1,-40.893])[abs(k)]
          if k==6 or k==9 or k==17: tf[1] -= 180
          elif k==7 or k==8: tf[1] *= -1
          (turtle.forward, turtle.left)[tf[0]](tf[1])
        turtle.end_fill()
        turtle.forward(6*a)
        turtle.backward(5*a)
        turtle.penup()
        turtle.right(90)
        l = a*sqrt(3)/6
        for k in range(2):
          turtle.forward(l)
          turtle.pencolor((255,255,255))
          turtle.dot(a//4)
          turtle.pencolor((0,0,0))
          turtle.dot(a//8)
          turtle.backward(l)
          turtle.left(180)
      i = -i + (i <= 0)
    j = -j - (j >= 0)
except Exception as e: print(e)

try: turtle.show() #TI-83 Premium CE
except: pass


TI-83PCE/84+CE
turtle

TI-Nspire CX II
turtle

Casio
Graph 90+E

nouveau
KhiCAS
NumWorks
TI-Nspire CX II CX

TI-83PCE/84+CE
ce_turtl

NumWorks
Casio
Graph 35+E II

ancien
KhiCAS
NumWorks
TI-Nspire CX II CX


Formidable ici aussi, les poissons se comportent enfin correctement sous KhiCAS pour réaliser la pavage !
Petits détails toutefois non spécifiques à cet exemple, lorsque l'on fait défiler le tracé obtenu :
  • les affichages effectués sur la barre de titre/état en haut d'écran (18 premières lignes de pixels) ne sont pas nettoyés correctement lors des rafraichissements
  • les formes ne sont bizarrement pas remplies correctement dans une bande correspondant aux 42 premières lignes de pixels

Exemple B4 : ♫ Le tournesol, le tournesol, ... ♫

Go to top

15452Terminons enfin avec un exemple absolument bluffant de réalisme pour du turtle, nous allons faire pousser un tournesol devant toi :
Code: Tout sélectionner
from math import pi, sin, cos, sqrt
from ttl_fix import *

def spiral():
  phi = (1+sqrt(5))/2
  a  =0
  r = 0
  dr = 0.15
  turtle.penup()
  for i in range(300):
    turtle.forward(r)
    turtle.pencolor((0,0,0))
    try: turtle.dot(3)
    except: pass
    turtle.pencolor((205,133,63))
    try: turtle.dot(2)
    except: pass
    turtle.goto(0,0)
    turtle.setheading(0)
    a+=360/phi
    turtle.right(a)
    if a>=360:
      r+=dr
      a-=360   

def feuille(core,a):
    try: turtle.begin_fill()
    except: pass
    turtle.right(a/2)
    turtle.forward(core)
    turtle.left(a)
    turtle.forward(core)
    turtle.left(180-a)
    turtle.forward(core)
    turtle.left(a)
    turtle.forward(core)
    try: turtle.end_fill()
    except: pass

turtle.speed(0)
turtle.colormode(255)
turtle.pencolor((30,144,255))
try: turtle.dot(320)
except: pass

d=25
core=40
turtle.pencolor((160,82,45))
try: turtle.dot(40)
except: pass

c=((255,215,0),(255,255,0))

for i in range(2):
  turtle.color(c[0], c[i])
  for h in range(10*i,370,20):
    r=h * pi / 180
    x=d*cos(r)
    y=d*sin(r)
    turtle.penup()
    turtle.goto(x,y)
    turtle.pendown()
    turtle.setheading(h)
    feuille(core,32)

spiral()

try: turtle.show() #TI-83 Premium CE
except: pass


TI-83PCE/84+CE
turtle

TI-Nspire CX II
turtle

Casio
Graph 90+E

nouveau
KhiCAS
NumWorks
TI-Nspire CX II CX

TI-83PCE/84+CE
ce_turtl

NumWorks
Casio
Graph 35+E II

ancien
KhiCAS
NumWorks
TI-Nspire CX II CX


Excellent, les graines dans le cœur sont enfin délimitées correctement sous KhiCAS ! :bj:





C) 13 autres exemples comparatifs

Go to top




Exemple C1 : La dalle aux ammonites

Go to top

C'est donc parti pour quelques exemples afin d'approfondir les améliorations de la nouvelle bibliothèque turtle pour TI-83 Premium CE Edition Python et compatibles, ainsi que les points forts et faibles par rapport aux autres modèles de calculatrices.

Précisons que les problèmes récurrents ne seront pas systématiquement réévoqués sur chaque exemple.

Un petit peu au Nord de Digne-les-bains en rive droite de la Bléone se trouve la dalle aux ammonites. Comme il est strictement interdit d'en prélever, voici de quoi en reproduire une sur ta calculatrice :
Code: Tout sélectionner
from ttl_fix import *
from math import pi

turtle.speed(0)
turtle.pencolor((0,0,0))
turtle.pendown()
turtle.pensize(1)

turtle.goto(0,-8)
x,y = turtle.pos()
turtle.left(115)
for i in range(132):
  turtle.forward(10)
  try:
    h = turtle.towards(x,y)
    turtle.setheading(h)
  except: pass
  d=10*pi
  turtle.forward(d)
  turtle.backward(d)
  turtle.right(90)

try: turtle.show() #TI-83 Premium CE
except: pass


TI-83PCE/84+CE
turtle

TI-Nspire CX II
turtle

Casio
Graph 90+E

KhiCAS
NumWorks
TI-Nspire CX II CX

TI-83PCE/84+CE
ce_turtl

NumWorks
Casio
Graph 35+E II


Exemple C2 : L'escargot de lumière

Go to top

Si tu es dans le Sud de la France tu sais qu'il ne pleut pas souvent (par contre, quand il pleut... il pleut !). Alors voici pour toi un escargot bariolé :
Code: Tout sélectionner
from math import exp
from ttl_fix import *

turtle.speed(0)
turtle.pensize(1)
turtle.colormode(1.0)

turtle.penup()
turtle.goto(0, -20)
turtle.pendown()
turtle.right(90)
for i in range(20):
  c = [exp(-.5 * ((i - k) / 12)**2) for k in (6, 18, 30)]
  cb = [v/2 for v in c]
  turtle.color(cb, c)
  try: turtle.begin_fill()
  except: pass
  turtle.circle(27 + i)
  try: turtle.end_fill()
  except: pass
  turtle.right(10)

try: turtle.show() #TI-83 Premium CE
except: pass


TI-83PCE/84+CE
turtle

TI-Nspire CX II
turtle

Casio
Graph 90+E

KhiCAS
NumWorks
TI-Nspire CX II CX

TI-83PCE/84+CE
ce_turtl

NumWorks
Casio
Graph 35+E II


Exemple C3 : Le triangle de Penrose

Go to top

Tu n'as jamais touché à un triangle de Penrose ? Et bien voici de quoi en afficher le plan dans ta calculatrice, tu n'auras plus qu'à l'imprimer en 3D, si tu arrives à comprendre où est le devant et l'arrière : ;)
Code: Tout sélectionner
from math import sqrt
from ttl_fix import *

def hook(a, c):
  turtle.penup()
  turtle.goto(0,-15)
  turtle.setheading(a)
  turtle.forward((l - 4*b) / sqrt(3))
  turtle.right(150)
  turtle.pendown()
  lf = ((turtle.left, 60),[turtle.forward,b],(turtle.left,120),(turtle.forward,l-b),[turtle.right,120],[turtle.forward,l-3*b])
  try:
    turtle.fillcolor(c)
    turtle.begin_fill()
  except: pass
  for k in range(-len(lf) + 1, len(lf)):
    tf = lf[abs(k)]
    if k == 1: tf[1] = l
    elif k == 4: tf[0] = turtle.left
    elif k == 5: tf[1] = b
    tf[0](tf[1])
  try: turtle.end_fill()
  except: pass
 
turtle.speed(0)
turtle.pensize(2)
turtle.colormode(255)

l=180
b=23

for i in range(112):
  turtle.pencolor(232 - int(i * 23 / 11), 249 - int(i * 29 / 55), 255)
  turtle.penup()
  turtle.goto(-192, 111 - 2*i)
  turtle.pendown()
  turtle.forward(384)

turtle.pencolor((0,0,0))
turtle.pensize(1)

hook(330, (255,255,0))
hook(90, (0,0,255))
hook(210, (255,0,0))

try: turtle.show() #TI-83 Premium CE
except: pass


TI-83PCE/84+CE
turtle

TI-Nspire CX II
turtle

Casio
Graph 90+E

KhiCAS
NumWorks
TI-Nspire CX II CX

TI-83PCE/84+CE
ce_turtl

NumWorks
Casio
Graph 35+E II


Exemple C4 : La courtepointe de Mamie

Go to top

Voici maintenant la courtepointe brodée avec amour et soin par Mamie :
Code: Tout sélectionner
from ttl_fix import *

def rotate_list(l):
  l[1:],l[0] = l[0:-1],l[-1]

def poly_reg_a(l, a):
  h0 = turtle.heading()
  while True:
    turtle.forward(l)
    turtle.left(a)
    if abs(h0 - turtle.heading()) < .1:
      break

turtle.hideturtle()
turtle.speed(0)
turtle.pensize(1)
turtle.colormode(255)

c = [191, 127, 0]
cf = [127, 255, 0]
i = 0
while i > -3:
  j = 0
  while j > -2:
    turtle.penup()
    turtle.goto((i - 1)*88, (j - 1)*85 + 28)
    turtle.pendown()
    turtle.color(c, cf)
    try: turtle.begin_fill()
    except: pass
    poly_reg_a(80, 140)
    try: turtle.end_fill()
    except: pass
    rotate_list(c)
    rotate_list(cf)
    j = -j + (j <= 0)
  i = -i + (i <= 0)

try: turtle.show() #TI-83 Premium CE
except: pass


TI-83PCE/84+CE
turtle

TI-Nspire CX II
turtle

Casio
Graph 90+E

KhiCAS
NumWorks
TI-Nspire CX II CX

TI-83PCE/84+CE
ce_turtl

NumWorks
Casio
Graph 35+E II


Exemple C5 : Les vitraux rhombiques

Go to top

Voici maintenant une belle rosace rhombique pour décorer le bâtiment de ton choix.

Nous utilisons ici la méthode .dot() permettant de remplir un disque de diamètre donné, afin de générer de quoi avoir une couleur de fond d'écran sur nos calculatrices, suffit-il juste de lui spécifier un diamètre suffisamment grand :
Code: Tout sélectionner
from ttl_fix import *

turtle.speed(0)
turtle.colormode(255)
turtle.pencolor((0,0,255))
turtle.dot(320)
turtle.pencolor((0,0,0))
turtle.pensize(2)
col = ((255,0,0),(255,255,0),(0,255,0),(255,255,255),(255,0,255))
a=60

for i in range(10):
  c = col[i%5]
  turtle.color(c, c)
  turtle.begin_fill()
  for j in range(5):
    turtle.forward(a)
    turtle.right(72)
  turtle.end_fill()
  turtle.right(36)

for i in range(10):
  c = [v//3 for v in col[i%5]]
  turtle.pencolor(c)
  for j in range(5):
    turtle.forward(a)
    turtle.right(72)
  turtle.right(36)

try: turtle.show() #TI-83 Premium CE
except: pass


TI-83PCE/84+CE
turtle

TI-Nspire CX II
turtle

Casio
Graph 90+E

KhiCAS
NumWorks
TI-Nspire CX II CX

TI-83PCE/84+CE
ce_turtl

NumWorks
Casio
Graph 35+E II


Par rapport au fond bleu, notons que c'est bel et bien KhiCAS qui adopte le comportement correct. Selon le standard turtle, la méthode .dot() attend en paramètre le diamètre du disque à tracer. Ce sont les modèles Texas Instruments qui le considèrent à tort comme un rayon et remplissent alors tout l'écran.

Exemple C6 : Les roses par 12

Go to top

Voici maintenant une rose, cette fois-ci sur un fond d'écran en dégradé radial. Nous utiliserons pour cela cette fois-ci une boucle de .dot() :
Code: Tout sélectionner
from math import pi, sin, cos, sqrt
from ttl_fix import *

def rpoly(c, n):
  a=360/n
  for k in range(n):
    turtle.forward(c)
    turtle.left(a)
def carre(c): rpoly(c, 4)

turtle.speed(0)
turtle.colormode(255)
turtle.penup()

r=80
alpha=(15 * pi / 180)

for i in range(320):
  c=int(255/320*i)
  turtle.pencolor(c,c,c)
  try: turtle.dot(320-i)
  except: pass

turtle.goto(20,-76)
turtle.color((255,255,255),(0,0,0))

for i in range(4):
  a=r*sin(alpha)*2
  d=a/sqrt(2)
  turtle.pendown()
  for i in range(12):
    turtle.right(15)
    try: turtle.begin_fill()
    except: pass
    carre(d)
    try: turtle.end_fill()
    except: pass
    turtle.left(45)
    turtle.penup()
    turtle.forward(a)
    turtle.pendown()
  turtle.penup()
  turtle.left(75)
  turtle.forward(d)
  turtle.right(60)
  r=r*cos(alpha)-a/2

try: turtle.show() #TI-83 Premium CE
except: pass


TI-83PCE/84+CE
turtle

TI-Nspire CX II
turtle

Casio
Graph 90+E

KhiCAS
NumWorks
TI-Nspire CX II CX

TI-83PCE/84+CE
ce_turtl

NumWorks
Casio
Graph 35+E II


Sur la taille du disque de fond d'écran et comme déjà dit, c'est ici encore KhiCAS qui fait comme il faut.

Exemple C7 : Les triangles de Sierpiński

Go to top

Revenons aux fractales et à la récursivité avec les triangles de Sierpiński. As-tu déjà réussi à les compter ? Et bien voici de quoi commencer sur ta calculatrice :
Code: Tout sélectionner
from ttl_fix import *

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

turtle.colormode(255)
turtle.speed(0)
turtle.pensize(1)

turtle.penup()
turtle.goto(-110, -95)
turtle.pendown()
turtle.pencolor((255,0,0))
sierp(6, 220)
turtle.penup()
turtle.forward(400)

try: turtle.show() #TI-83 Premium CE
except: pass


TI-83PCE/84+CE
turtle

TI-Nspire CX II
turtle

Casio
Graph 90+E

KhiCAS
NumWorks
TI-Nspire CX II CX

TI-83PCE/84+CE
ce_turtl

NumWorks
Casio
Graph 35+E II


Exemple C8 : Sous le soleil exactement

Go to top

Plaçons-nous maintenant sous le soleil exactement, profitant ainsi de toutes les couleurs de la lumière blanche :
Code: Tout sélectionner
from math import exp
from ttl_fix import *

def rpoly(c, n):
  a=360/n
  for k in range(n):
    turtle.forward(c)
    turtle.left(a)
def carre(c): rpoly(c, 4)

turtle.speed(0)
turtle.pensize(1)
turtle.colormode(1.0)

n = 36
for i in range(n):
  k=.4 + 4*i/255
  cp = [.7*exp(-.5 * ((n - i - k) / (n / 3))**2) for k in (6, 18, 30)]
  turtle.pencolor(cp)
  try:
    turtle.fillcolor((k,k,0))
    turtle.begin_fill()
  except: pass
  carre(60)
  try: turtle.end_fill()
  except: pass
  turtle.right(360 / n)

try: turtle.show() #TI-83 Premium CE
except: pass


TI-83PCE/84+CE
turtle

TI-Nspire CX II
turtle

Casio
Graph 90+E

KhiCAS
NumWorks
TI-Nspire CX II CX

TI-83PCE/84+CE
ce_turtl

NumWorks
Casio
Graph 35+E II


Exemple C9 : Le labyrinthe du Minotaure

Go to top

Explorons maintenant dans la labyrinthe du Minotaure :
Code: Tout sélectionner
from ttl_fix import *

turtle.speed(0)
turtle.colormode(255)
turtle.pendown()

turtle.right(48)
turtle.pencolor((0,0,0))
for i in range(98):
  turtle.forward(2*i)
  turtle.left(90.5)

try: turtle.show() #TI-83 Premium CE
except: pass


TI-83PCE/84+CE
turtle

TI-Nspire CX II
turtle

Casio
Graph 90+E

KhiCAS
NumWorks
TI-Nspire CX II CX

TI-83PCE/84+CE
ce_turtl

NumWorks
Casio
Graph 35+E II


Exemple C10 : Le carreau de carreaux

Go to top

Code: Tout sélectionner
from math import sqrt
from ttl_fix import *

def rotate_list(l):
  l[1:],l[0] = l[0:-1],l[-1]

def reg_poly(l, n):
  for i in range(n):
    turtle.forward(l)
    turtle.left(360/n)

def square(l):
  reg_poly(l, 4)

turtle.colormode(255)
turtle.pencolor(0,0,0)
turtle.speed(0)

turtle.pensize(3)
d=190
c=[0,255,127]
turtle.penup()
turtle.goto(-d/2,-d/2)
turtle.setheading(0)
turtle.pendown()
for i in range(8):
  try:
    turtle.fillcolor(tuple(c))
    turtle.begin_fill()
  except: pass
  square(d)
  try:
    turtle.end_fill()
  except: pass
  turtle.penup()
  turtle.forward(d/2)
  turtle.left(45)
  turtle.pendown()
  d/=sqrt(2)
  rotate_list(c)

try: turtle.show() #TI-83 Premium CE
except: pass


TI-83PCE/84+CE
turtle

TI-Nspire CX II
turtle

Casio
Graph 90+E

KhiCAS
NumWorks
TI-Nspire CX II CX

TI-83PCE/84+CE
ce_turtl

NumWorks
Casio
Graph 35+E II


Exemple C11 : Les étoiles jumelles

Go to top

Code: Tout sélectionner
try: # TI-83 Premium CE
  from ti_system import disp_clr
  disp_clr()
except: pass
from ttl_fix import *

def rpoly(c, n):
  a=360/n
  for k in range(n):
    turtle.forward(c)
    turtle.left(a)

def rosace(c, n1, a, n2):
  try: turtle.begin_fill()
  except: pass
  for i in range(n2):
    turtle.left(a)
    rpoly(c, n1)
  try: turtle.end_fill()
  except: pass

turtle.colormode(255)
turtle.pencolor((0,0,0))

try: turtle.dot(320)
except: pass
turtle.color((255,255,255),(255,255,0))
turtle.speed(0)
turtle.pensize(1)
try:
  for i in range(-1, 2, 2):
    turtle.penup()
    turtle.goto(80*i, 0)
    turtle.pendown()
    rosace((i > 0) and 21 or 30, (i > 0) and 12 or 8, 30, 12)
    turtle.pensize(2)
    turtle.pencolor((0,0,255))
except MemoryError as e: print(e)

try: turtle.show() #TI-83 Premium CE
except: pass


TI-83PCE/84+CE
turtle

TI-Nspire CX II
turtle

Casio
Graph 90+E

KhiCAS
NumWorks
TI-Nspire CX II CX

TI-83PCE/84+CE
ce_turtl

NumWorks
Casio
Graph 35+E II


Sur la taille du disque de fond d'écran, c'est à nouveau ici KhiCAS qui a raison et pas TI.

Exemple C12 : La toile de l'araignée

Go to top

Suivons maintenant le fil de l'araignée :
Code: Tout sélectionner
from ttl_fix import *

def spiral(a,b):
  turtle.pencolor((0,0,0))
  try: turtle.dot(320)
  except: pass
  turtle.pencolor((255,255,0))
  for i in range(189):
    for j in range(6):
      turtle.forward(i/a)
      turtle.left(23)
    turtle.left(b)
    try: turtle.dot(2)
    except: pass
   
turtle.speed(0)
turtle.colormode(255)
turtle.pensize(1)

a=17
b=194

spiral(a,b)

try: turtle.show() #TI-83 Premium CE
except: pass


TI-83PCE/84+CE
turtle

TI-Nspire CX II
turtle

Casio
Graph 90+E

KhiCAS
NumWorks
TI-Nspire CX II CX

TI-83PCE/84+CE
ce_turtl

NumWorks
Casio
Graph 35+E II





Conclusion

Go to top

Selon notre outil de tests, KhiCAS pour TI-Nspire CX et NumWorks N0110 est bien mieux conforme au standard Python-turtle que l'ensemble des solutions turtle officielles, et semble en conséquence bien mieux se comporter en pratique sur une majorité de nos exemples. nous semble offrir à ce jour la meilleure bibliothèque Python turtle toutes solutions confondues.

Les méthodes de remplissage, absentes des implémentations officielles de Casio et NumWorks t'ouvrent la porte à de formidables progrès.

Les progrès témoignent d'un soin minutieux apporté par Bernard Parisse, et vu que tout semble parfait maintenant il va nous falloir tenter d'inventer de nouveaux exemples piégeux... :P




Téléchargements

Go to top

Lien vers le sujet sur le forum: KhiCAS NumWorks Nspire CX: Python-turtle encore plus parfait (Commentaires: 7)

KhiCAS: Python-turtle étendu pour NumWorks & Nspire CX

Nouveau messagede critor » 12 Avr 2022, 19:37

15120Pour accompagner en douceur la transition du Scratch au Python en Seconde, la plupart des solutions Python sur calculatrices graphiques offrent turtle, une bibliothèque permettant du tracé relatif comme en Scratch. On peut citer :
  • la NumWorks dont l'application Python intègre directement turtle
  • les Casio Graph 35+E II et Graph 90+E dont l'application Python intègre directement turtle
  • les TI-Nspire CX II sur lesquelles on peut rajouter la bibliothèque officielle turtle (anciennement ce_turtl) à l'environnement Python
  • les TI-83 Premium CE Edition Python (France), TI-84 Plus CE-T Python Edition (Europe) et TI-84 Plus CE Python (Amérique du Nord), sur lesquelles on peut rajouter une bibliothèque turtle officielle
  • et KhiCAS

11302Aujourd'hui justement approfondissons ce dernier point, parlons du turtle de KhiCAS. Conçu par Bernard Parisse, enseignant-chercheur à l'Université de Grenoble, KhiCAS est la déclinaison sur calculatrices du logiciel de Mathématiques intégré Xcas. Disponible pour calculatrices NumWorks N0110, TI-Nspire CX, Casio Graph 35+E II et Graph 90+E, KhiCAS te donne donc accès à une interface unifiée ainsi qu'à des fonctionnalités haut de gamme peu importe la marque ou le modèle de ta calculatrice ! :bj:

12024Ce formidable environnement de Mathématiques et de sciences t'apporte bien des choses. Nous pouvons citer dans tous les cas :
  • la reprise du moteur de calcul formel GIAC développé pour Xcas par le même auteur.
  • la possibilité de programmer dans 2 langages :
    • le langage Xcas historique
    • le langage Xcas avec une couche de compatibilité syntaxique Python

Dans ses éditions pour TI-Nspire CX et NumWorks N0110, KhiCAS apporte pas mal de compléments :
  • possibilité de composer et convertir ses unités
  • une bibliothèque de constantes physiques
  • plusieurs applications elles-même intégrées, dont entre autres :
    • tableur / feuille de calcul
    • tableau périodique des éléments
    • calcul financier
  • 2 langages de programmation supplémentaires :
    • Python via un interpréteur Micropython
    • Javascript via un interpréteur QuickJS

L'environnement Python sur ces modèles est extrêmement riche, bien davantage que les solutions Python intégrées par les constructeurs. On peut citer nombre de bibliothèques :
  • cas et xcas pour appeler le moteur de calcul formel GIAC directement depuis tes scripts Python
  • cmath pour traiter directement tes calculs sur les nombres complexes en Python
  • linalg pour l'algèbre linéaire
  • arit pour l'arithmétique
  • ulab.scipy pour le calcul scientifique
  • ulab.numpy pour le calcul matriciel et vectoriel
  • plusieurs bibliothèque de tracés :
    • turtle pour les tracés relatifs à la Scratch
    • matplotlib pour les tracés dans un repère
    • graphic pour les tracés par pixels, accompagnée de casioplot pour la compatibilité avec les scripts graphiques Casio et kandinsky pour la compatibilité avec les scripts graphiques NumWorks
  • et bien d'autres : gc, math, micropython, nsp, pylab, random, sys, time, ubinascii, ucollections, uctypes, uerrno, uhashlib, uheapq, uio, ujson, ure, ustruct, uzlib

La dernière mise à jour de KhiCAS améliore justement les possibilités de la bibliothèque turtle. Elle est disponible à ce jour :
  • uniquement en version alpha pour TI-Nspire CX
  • en version stable pour NumWorks N0110
Découvrons ensemble les nouveautés.








A) Contenu bibliothèque

Go to top

Commençons donc par explorer le contenu de la bibliothèque turtle :
Code: Tout sélectionner
import turtle
l = dir(turtle)
l
len(l)


Effectivement il y a bien des nouveauté, nous passons de 66 à 69 éléments. Nous disposons de 3 nouvelles méthodes :
  • .clear() pour effacer l'affichage sans réinitialiser la position de la tortue
  • .pos(), un alias court de .position() que l'on avait déjà pour récupérer la position de la tortue
  • .towards(x, y) pour obtenir l'angle d'orientation permettant d'atteindre les coordonnées fournies

Cela peut certes te paraître peu, bien que .towards() permette déjà d'aborder facilement des scripts bien plus ambitieux comme nous verrons plus bas.

Mais ça c'est juste pour les méthodes rajoutées ; il va rester à voir si il y a eu des améliorations sur le fonctionnement des méthodes déjà présentes.




B) Tests de conformité comparatifs (toutes solutions turtle)

Go to top

Tentons pour le moment un autodiagnostic plus général des différences entres les ancienne et nouvelle bibliothèques turtle de KhiCAS, c'est-à-dire la vérification de tout ce qui peut différer du standard.

Voici des scripts en ce sens, une amélioration majeure de ceux développés dans le code de notre test de rentrée QCC 2021 :
Code: Tout sélectionner
_turtle_errors = 0

def _turtle_error(k):
  global _turtle_errors
  _turtle_errors |= 1 << k

# import turtle
try:
  import turtle
  if not "forward" in dir(turtle):
    turtle = turtle.Turtle()
except ImportError: #TI-83 Premium CE
  from ce_turtl import turtle
  _turtle_error(0)
try:
  turtle.clear()
except:
  turtle.reset()

# can turtle be patched ?
_fix_turtle = True
try:
  def _fixcolor(c): return c
  turtle._fixcolor = _fixcolor
except:
  _fix_turtle = False

# test color() + pencolor() + fillcolor()
if not "pencolor" in dir(turtle):
  pencolor = turtle.color
  _turtle_error(1)
else:
  pencolor = turtle.pencolor
if not "color" in dir(turtle):
  _turtle_error(2)
if not "fillcolor" in dir(turtle):
  _turtle_error(12)

if not "clear" in dir(turtle):
  _turtle_error(13)
if not "reset" in dir(turtle):
  _turtle_error(14)
if not "heading" in dir(turtle):
  _turtle_error(11)

# test color argument types
_color_types = 0
try:
  pencolor([0, 0, 0])
  _color_types |= 1 << 0
except: _turtle_error(4)
try:
  pencolor((0, 0, 0))
  _color_types |= 1 << 1
except: _turtle_error(5)
try:
  pencolor(0, 0, 0)
  _color_types |= 1 << 2
except: _turtle_error(6)
try:
  pencolor("black")
  _color_types |= 1 << 3
except: _turtle_error(7)

# test colormode()
if not "colormode" in dir(turtle):
  _turtle_error(3)

# test color strings
_colors_fix={
  "blue":(0,0,1),
  "green":(0,1,0),
  "red":(1,0,0),
  "cyan":(0,1,1),
  "yellow":(1,1,0),
  "magenta":(1,0,1),
  "white":(1,1,1),
  "orange":(1,0.65,0),
  "purple":(0.66,0,0.66),
  "brown":(0.75,0.25,0.25),
  "pink":(1,0.75,0.8),
  "grey":(0.66,0.66,0.66),
  "black":(0,0,0),
}
for c in tuple(_colors_fix.keys()):
  try:
    pencolor(c)
    _colors_fix.pop(c)
  except: pass
if len(_colors_fix):
  if _color_types & 1 << 3:
    _turtle_error(8)

# test circle(,)
try: turtle.circle(0,0)
except:
  _turtle_error(9)

#test towards
try: turtle.towards
except:
  _turtle_error(15)

# test for unfixable missing functions
_missing_fct=["write","pensize","dot"]
for f in tuple(_missing_fct):
  try:
    eval("turtle."+f)
    _missing_fct.remove(f)
  except: pass
if len(_missing_fct):
    _turtle_error(16)

_missing_alias=[
  ["backward","back","bk"],
  ["forward","fd"],
  ["right","rt"],
  ["left","lt"],
  ["position","pos"],
  ["goto","setpos","setposition"],
  ["setheading","seth"],
  ["pendown","pd","down"],
  ["penup","pu","up"],
  ["pensize","width"],
  ["showturtle","st"],
  ["hideturtle","ht"],
]
for aliases in tuple(_missing_alias):
  validf = None
  for f in tuple(aliases):
    try:
      eval("turtle."+f)
      validf = f
      aliases.remove(f)
      break
    except: pass
  for f in tuple(aliases):
    try:
      eval("turtle."+f)
      aliases.remove(f)
    except: pass
  if not len(aliases):
    _missing_alias.remove(aliases)
  else:
    aliases.insert(0, validf)
if len(_missing_alias):
    _turtle_error(17)

try:
  turtle.position()
except:
  try:
    turtle.pos()
  except:
    _turtle_error(10)
Code: Tout sélectionner
from ttl_chk import *
from ttl_chk import _fix_turtle, _turtle_errors, _colors_fix, _missing_fct, _missing_alias

def turtle_diags():
  print("Type: " + str(type(turtle)))
  print("Patchable: " + (_fix_turtle and "yes" or "no"))
  errors_msg = (
    "No <import turtle>",
    "No pencolor()",
    "No color()",
    "No colormode()",
    "No color as list",
    "No color as tuple",
    "No color as args",
    "No color as string",
    "Missing colors strings: ",
    "No circle(,angle)",
    "Can't get position()",
    "No heading()",
    "No fill",
    "No clear()",
    "No reset()",
    "No towards()",
    "Other missing: ",
    "Missing aliases: ",
  )
  errors = 0
  for k in range(len(errors_msg)):
    if _turtle_errors & 1 << k:
      errors += 1
      msg = "Err " + str(k) + ": " + errors_msg[k]
      if k == 8:
        msg += str(len(_colors_fix)) + " " + str(tuple(_colors_fix.keys()))
      if k == 16:
        msg += str(len(_missing_fct)) + " " + " ".join(_missing_fct)
      if k == 17:
        l = []
        for v in _missing_alias:
          l.extend(v[1:])
        msg += str(len(l)) + " " + " ".join(l)
      print(msg)
  print(str(errors) + " error" + ((errors > 1) and "s" or ""))

turtle_diags()


Voici ce que nous racontent les scripts sur les différentes solutions turtle :

TI-83PCE/84+CE
turtle


TI-Nspire CX II
turtle

Casio
Graph 90E


nouveau
KhiCAS
NumWorks
TI-Nspire CX II CX

TI-83PCE/84+CE
ce_turtl


NumWorks
Casio
Graph 35+E II


ancien
KhiCAS
NumWorks
TI-Nspire CX II CX


On confirme donc avec la nouvelle version KhiCAS l'ajout des 3 méthodes jusqu'alors manquantes.

Mais surtout il n'y a donc dans l'état actuel des scripts plus aucune erreur détectée automatiquement, chose exceptionnelle si l'on compare aux solutions officielles, et signe d'un soin minutieux !

Mais ça, c'est pour les problèmes détectables par des vérifications automatisées. Voyons maintenant d'éventuels écarts visuels sur quelques exemples de scripts.

Afin de pouvoir comparer équitablement avec les solutions officielles visiblement parfois bien moins conformes au standard turtle tout en conservant une unique version de chaque script utilisable sur l'ensemble des solutions, voici un script qu'il suffira d'importer à la place de chaque bibliothèque turtle et qui, lorsque celle-ci sera modifiable, corrigera la plupart des erreurs détectées : :bj:
Code: Tout sélectionner
from ttl_chk import *
from ttl_chk import _color_types, _turtle_errors, _colors_fix, _missing_fct, _missing_alias

_fix_turtle = True

def nop(*argv): return None
idty = lambda c: c

try: # can turtle be patched ?
  turtle._fixcolorlist = idty
  turtle._fixcolorval = idty
  turtle._fixcolorstring = idty
  turtle._fixcolorargs = idty
  turtle._fixcolor = lambda c: turtle._fixcolorlist(turtle._fixcolorval(turtle._fixcolorstring(turtle._fixcolorargs(c))))
except:
  _fix_turtle = False

if _fix_turtle:

  # fix color() + pencolor()
  if _turtle_errors & 0x1000:
    turtle.fillcolor, turtle.begin_fill, turtle.end_fill = idty, nop, nop
  if _turtle_errors & 2:
    def _pencolor_(*argv):
      if len(argv): turtle.color(argv)
      else: return turtle.color()[0]
    turtle.pencolor = _pencolor_
  if _turtle_errors & 4:
    def _color_(*argv):
      if len(argv) == 2:
        turtle.pencolor(argv[0])
        turtle.fillcolor(argv[1])
      elif len(argv):
        turtle.pencolor(argv)
      else:
        return (turtle.pencolor(), turtle.fillcolor())
    turtle.color = _color_

  _fix_color = _color_types & 0b11 != 0b11 or not "colormode" in dir(turtle)

  # fix list/tuple color argument
  if _color_types & 0b11 == 0b10:
    def _fixcolorlist(c): return type(c) is list and tuple(c) or c
    turtle._fixcolorlist = _fixcolorlist
  if _color_types & 0b11 == 0b01:
    def _fixcolorlist(c): return type(c) is list and list(c) or c
    turtle._fixcolorlist = _fixcolorlist
  if not _color_types & 4:
    def _fixcolorargs(*argv):
      return len(argv) != 1 and argv or argv[0]

  if _fix_color:
    turtle._color = turtle.color
    turtle._pencolor = turtle.pencolor
    turtle._fillcolor = turtle.fillcolor
    if _color_types & 0b11:
      def _color(*argv):
        n = len(argv)
        if not(n): return turtle._color()
        elif n==2: turtle._color(argv[0], argv[1])
        else: turtle._color(n > 1 and argv or argv[0])
      def _pencolor(*argv):
        if not(len(argv)): return turtle._pencolor()
        turtle._pencolor(turtle._fixcolor(len(argv) > 1 and argv or argv[0]))
      def _fillcolor(*argv):
        if not(len(argv)): return turtle._fillcolor()
        turtle._fillcolor(turtle._fixcolor(len(argv) > 1 and argv or argv[0]))
    else:
      def _color(*argv):
        n = len(argv)
        if not(n): return turtle._color()
        c = turtle._fixcolor(n == 3 and argv or argv[0])
        turtle._color(c[0], c[1], c[2])
      def _pencolor(*argv):
        if not(len(argv)): return turtle._pencolor()
        c = turtle._fixcolor(len(argv)>1 and argv or argv[0])
        turtle._pencolor(c[0], c[1], c[2])
      def _fillcolor(*argv):
        if not(len(argv)): return turtle._fillcolor()
        c = turtle._fixcolor(len(argv)>1 and argv or argv[0])
        turtle._fillcolor(c[0], c[1], c[2])
    turtle.color = _color
    turtle.pencolor = _pencolor
    turtle.fillcolor = _fillcolor

  # fix colormode()
  if _turtle_errors & 8:
    # test color mode
    try:
      turtle.pencolor([255, 0, 0])
      _color_mode = 255
    except: _color_mode = 1.0
    turtle._color_mode = _color_mode
    def _colormode(*argv):
      if not(len(argv)): return turtle._color_mode
      if int(argv[0]) in (1, 255):
        turtle._color_mode = int(argv[0]) == 255 and 255 or 1.0
    turtle.colormode = _colormode
    if _color_mode == 255:
      turtle._fixcolorval = lambda c: int(turtle._color_mode) == 1 and type(c) in (list, tuple) and [int(c[k] * 255) for k in range(3)] or c
    else:
      turtle._fixcolorval = lambda c: turtle._color_mode == 255 and type(c) in (list, tuple) and [c[k] / 255 for k in range(3)] or c

  # fix color strings
  if len(_colors_fix):
    def _fixcolorstring(c):
      if type(c) is str and c in _colors_fix:
        c = _colors_fix[c]
        if turtle.colormode() == 255:
          c = [int(c[k] * 255) for k in range(3)]
      return c
    turtle._fixcolorstring = _fixcolorstring

  # fix circle(,)
  if _turtle_errors & 0x200:
    turtle._circle = turtle.circle
    def _circle(r, a=360): turtle._circle(r)
    turtle.circle = _circle

  if len(_missing_fct):
    for f in _missing_fct:
      exec("turtle."+f+"=nop")

  if len(_missing_alias):
    for aliases in _missing_alias:
      validf = aliases[0]
      for f in aliases[1:]:
        exec(validf and "turtle."+f+"=turtle."+validf or "turtle."+f+"=nop")

  # fix clear()
  if _turtle_errors & 0x2000:
    turtle.clear = turtle.reset

  # fix reset()
  if _turtle_errors & 0x4000:
    turtle.reset = turtle.clear

  # fix towards()
  if _turtle_errors & 0x8000:
    from math import atan2, pi
    def _towards(x, y):
      x0, y0 = turtle.pos()
      return atan2(y - y0, x - x0) * 180 / pi
    turtle.towards = _towards




C) 17 exemples comparatifs (toutes solutions turtle)

Go to top

Maintenant que nous avons de quoi faire tourner une unique version de chaque script sur l'ensemble des machines, poursuivons donc l'exploration de l'ensemble des solutions turtle avec quelques exemples de script.

Nous allons en profiter pour nous en donner à cœur joie avec les formidables fonctions de remplissage rajoutées dans l'avant-dernière version de KhiCAS, sur le thème de #LesMathématiquesSontBelles.

C'est donc l'occasion de voir si il y avait d'autres problèmes qui n'ont pas pu être détectés automatiquement, et si ils sont toujours présents dans la dernière version.

Plusieurs des exemples qui vont suivre sont inspirés de publications de Bert Wikkerink pour TI-Nspire CX II et très librement et fortement adaptés pour être fonctionnels dans le contexte du heap Python bien plus restreint des TI-83 Premium CE et compatibles.


Exemple n°1 : La dalle aux ammonites

Go to top

C'est donc parti pour quelques exemples afin d'approfondir les améliorations de la nouvelle bibliothèque turtle pour TI-83 Premium CE Edition Python et compatibles, ainsi que les points forts et faibles par rapport aux autres modèles de calculatrices.

Précisons que les problèmes récurrents ne seront pas systématiquement réévoqués sur chaque exemple.

Un petit peu au Nord de Digne-les-bains en rive droite de la Bléone se trouve la dalle aux ammonites. Comme il est strictement interdit d'en prélever, voici de quoi en reproduire une sur ta calculatrice :
Code: Tout sélectionner
from ttl_fix import *
from math import pi

turtle.speed(0)
turtle.pencolor((0,0,0))
turtle.pendown()
turtle.pensize(1)

turtle.goto(0,-8)
x,y = turtle.pos()
turtle.left(115)
for i in range(132):
  turtle.forward(10)
  try:
    h = turtle.towards(x,y)
    turtle.setheading(h)
  except: pass
  d=10*pi
  turtle.forward(d)
  turtle.backward(d)
  turtle.right(90)

try: turtle.show() #TI-83 Premium CE
except: pass


TI-83PCE/84+CE
turtle

TI-Nspire CX II
turtle

Casio
Graph 90+E

nouveau
KhiCAS
NumWorks
TI-Nspire CX II CX

TI-83PCE/84+CE
ce_turtl

NumWorks
Casio
Graph 35+E II

ancien
KhiCAS
NumWorks
TI-Nspire CX II CX


KhiCAS ainsi que le turtle officiel de la NumWorks avaient un tracé incorrect ici, car la méthode .towards() était absente de leur implémentation de turtle. Et malheureusement, la bibliothèque turtle n'est dans ces deux cas pas altérable à l'exécution ce qui empêchait notre script de corriger.

Concernant KhiCAS ce manque est maintenant comblé, et visiblement parfaitement fonctionnel !

Exemple n°2 : Le défilé automobile

Go to top

Nous t'emmenons maintenant au défilé avec les logos de plusieurs grands constructeurs... automobiles :
Code: Tout sélectionner
from ttl_fix import *

def rpoly(c, n):
  for k in range(n):
    turtle.forward(c)
    turtle.left(360 / n)

def audi(r):
  ir = 2 * r // 13
  turtle.penup()
  turtle.left(90)
  turtle.forward(r//2 - 2*ir)
  turtle.right(90)
  turtle.forward(-ir)
  turtle.pendown()
  turtle.pensize(3)
  for i in range(4):
    turtle.penup()
    turtle.forward(3 * ir)
    turtle.pendown()
    turtle.circle(2 * ir)

def mercedez_benz(r):
  ir = r // 2
  turtle.penup()
  turtle.forward(ir)
  turtle.left(90)
  turtle.forward(ir)
  turtle.pendown()
  turtle.pensize(2)
  x, y = turtle.pos()
  turtle.setheading(210)
  for i in range(3):
    turtle.goto(x,y)
    turtle.forward(ir)
    turtle.left(120)
  turtle.setheading(0)
  turtle.circle(-ir)

def citroen(r):
  x,y=turtle.pos()
  turtle.setheading(0)
  turtle.color((255,0,0), (255,0,0))
  turtle.begin_fill()
  rpoly(r, 4)
  turtle.end_fill()
  turtle.fillcolor((255,255,255))
  for i in range(2):
    turtle.setheading(45)
    turtle.begin_fill()
    for k in range(2):
      turtle.forward(.71 * r)
      turtle.left(k and 172 or -90)
    for k in range(2):
      turtle.forward(5 * r / 6)
      turtle.left(106)
    turtle.end_fill()
    y += r / 3
    turtle.penup()
    turtle.goto(x,y)
    turtle.pendown()

def mitsubichi(r):
  ir = r // 3
  turtle.penup()
  turtle.left(90)
  turtle.forward(ir)
  turtle.right(90)
  turtle.forward(r // 2)
  turtle.pendown()
  for i in range(3):
    turtle.setheading(60 + 120*i)
    turtle.color((255,0,0), (255,0,0))
    turtle.begin_fill()
    for k in range(4):
      turtle.forward(ir)
      turtle.left((k%2) and 120 or 60)
    turtle.end_fill()

def jeep(r):
  a=54
  ir = r/0.47552825814758/4 #sin(radians(a))/cos(radians(a))
  a=ir/0.85
  d=0.93*ir
  turtle.penup()
  turtle.forward(r//2)
  turtle.right(90)
  turtle.forward(ir - r)
  turtle.pendown()
  x, y = turtle.pos()
  turtle.setheading(234)
  turtle.forward(ir)
  turtle.left(126)
  turtle.fillcolor((180,180,180))
  turtle.begin_fill()
  rpoly(a, 5)
  turtle.end_fill()
  for i in range(5):
    col = i < 3 and (0,0,0) or (255,255,255)
    for j in range(2):
      turn =  j and turtle.left or turtle.right
      turtle.goto(x,y)
      turtle.setheading(90 + 72*i)
      turtle.fillcolor(col)
      turtle.begin_fill()
      turtle.forward(d)
      turn(172)
      turtle.forward(0.85*d)
      turn(44)
      turtle.forward(0.2*d)
      turtle.end_fill()
      col = [255 - col[k] for k in range(3)]

turtle.speed(0)
turtle.colormode(255)

r = 92
for iy in range(2):
  for ix in range(3):
    i = iy*3+ix
    if i < 5:
      y, x = (2*iy - 1) * r//2 - 48, (ix - 1)*r - 50
      turtle.penup()
      turtle.goto(x, y)
      turtle.setheading(0)
      turtle.pensize(1)
      turtle.pencolor((0,0,0))
      turtle.pendown()
      (mercedez_benz,jeep,mitsubichi,citroen,audi)[i](r)

try: turtle.show() #TI-83 Premium CE
except: pass


TI-83PCE/84+CE
turtle

TI-Nspire CX II
turtle

Casio
Graph 90+E

nouveau
KhiCAS
NumWorks
TI-Nspire CX II CX

TI-83PCE/84+CE
ce_turtl

NumWorks
Casio
Graph 35+E II

ancien
KhiCAS
NumWorks
TI-Nspire CX II CX


Sur cet exemple, KhiCAS reste l'une des solutions turtle qui s'en tire hélas le moins bien.

Toutefois on peut remarquer une petite amélioration depuis la dernière fois ; la couleur de remplissage passé en 2ème paramètre de la méthode .color(,) n'est plus ignorée et est maintenant gérée correctement.

Exemple n°3 : L'escargot de lumière

Go to top

Si tu es dans le Sud de la France tu sais qu'il ne pleut pas souvent (par contre, quand il pleut... il pleut !). Alors voici pour toi un escargot bariolé :
Code: Tout sélectionner
from math import exp
from ttl_fix import *

turtle.speed(0)
turtle.pensize(1)
turtle.colormode(1.0)

turtle.penup()
turtle.goto(0, -20)
turtle.pendown()
turtle.right(90)
for i in range(20):
  c = [exp(-.5 * ((i - k) / 12)**2) for k in (6, 18, 30)]
  cb = [v/2 for v in c]
  turtle.color(cb, c)
  try: turtle.begin_fill()
  except: pass
  turtle.circle(27 + i)
  try: turtle.end_fill()
  except: pass
  turtle.right(10)

try: turtle.show() #TI-83 Premium CE
except: pass


TI-83PCE/84+CE
turtle

TI-Nspire CX II
turtle

Casio
Graph 90+E

nouveau
KhiCAS
NumWorks
TI-Nspire CX II CX

TI-83PCE/84+CE
ce_turtl

NumWorks
Casio
Graph 35+E II

ancien
KhiCAS
NumWorks
TI-Nspire CX II CX


Ici pour la même raison, KhiCAS se range maintenant avec les meilleures solutions turtle !

Exemple n°4 : Les flocons de Koch

Go to top

Encore une fois si tu es dans le Sud de la France, tu n'a pas dû voir de neige depuis des années... Faison donc neiger dans ta calculatrice maintenant, faisons neiger des flocons de Koch :
Code: Tout sélectionner
from ttl_fix import *

def rotate_list(l):
  l[1:],l[0] = l[0:-1],l[-1]

def koch(n, l):
  if n<=0:
    turtle.forward(l)
  else:
    koch(n - 1, l / 3)
    turtle.left(60)
    koch(n - 1, l / 3)
    turtle.right(120)
    koch(n - 1, l / 3)
    turtle.left(60)
    koch(n - 1, l / 3)

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

turtle.speed(0)
turtle.colormode(255)

c = [127, 255, 0]
l = 80
for j in range(2):
  for i in range(3):
    n = j and 3 + i or 2 - i
    s = 5 - n
    turtle.penup()
    turtle.goto(i*117-157, j*95-25)
    turtle.pencolor(tuple(c))
    turtle.pensize(s)
    turtle.setheading(0)
    turtle.pendown()
    flock(n, l)
    n += 1
    rotate_list(c)

try: turtle.show() #TI-83 Premium CE
except: pass


TI-83PCE/84+CE
turtle

TI-Nspire CX II
turtle

Casio
Graph 90+E

KhiCAS
NumWorks
TI-Nspire CX II CX

TI-83PCE/84+CE
ce_turtl

NumWorks
Casio
Graph 35+E II


Ici par contre, toujours le problème de mauvaise couleur pour le dernier flocon tracé avec KhiCAS.

Mais cela reste malgré tout mieux que d'autres solutions officielles.

Exemple n°5 : La linea

Go to top

Code: Tout sélectionner
try: #TI-83 Premium CE
  from ti_system import disp_clr
  disp_clr()
except: pass
from ttl_fix import *

def spiral(k,a,l):
  x0, y0 = turtle.pos()
  h0 = turtle.heading()
  while True:
    for s in l:
      turtle.forward(s*k)
      turtle.left(180-a)
    x, y = turtle.pos()
    if abs(x - x0) + abs(y - y0) + abs(turtle.heading() - h0) <= 1:
      break

turtle.speed(0)
turtle.pensize(1)
turtle.colormode(255)
turtle.color((0,0,0),(255,255,0))

try:
  for i in range(-1, 2, 2):
    turtle.penup()
    turtle.goto(80*i - ((i > 0) and 40 or 50), 0)
    turtle.pendown()
    try: turtle.begin_fill()
    except: pass
    spiral((i > 0) and 9 or 30, (i > 0) and 90 or 36, (i > 0) and (1,2,3,4,5,6,7,8,9) or (1,2,3))
    try: turtle.end_fill()
    except: pass
except MemoryError as e: print(e)

try: turtle.show() #TI-83 Premium CE
except: pass


TI-83PCE/84+CE
turtle

TI-Nspire CX II
turtle

Casio
Graph 90+E

nouveau
KhiCAS
NumWorks
TI-Nspire CX II CX

TI-83PCE/84+CE
ce_turtl

NumWorks
Casio
Graph 35+E II

ancien
KhiCAS
NumWorks
TI-Nspire CX II CX


Certes cette fois-ci KhiCAS remplit la forme de gauche de la bonne couleur, mais ne remplit bizarrement plus correctement celle de droite...

Exemple n°6 : Pavage d'une lagogne

Go to top

Partons maintenant à la pêche avec un script très hautement impressionnant par rapport aux contraintes de heap des TI-83 Premium CE et compatibles ; ici nous sommes vraiment sur le fil de la limite des possibilités concernant ces modèles.

Voici donc une lagogne littéralement pavée de poissons :
Code: Tout sélectionner
from math import sqrt
from ttl_fix import *

turtle.speed(0)
turtle.pensize(1)
turtle.colormode(255)
turtle.pencolor((0,0,0))

a=16

try:
  j = 0
  while -5 < j < 4:
    col = ((0,0,255),(255,0,0),(255,180,0))[j%3]
    i = 0
    while -2 + (j % 2) < i < 2:
      for c in range(3):
        turtle.penup()
        turtle.goto(sqrt(3)*3*a*(i*2-(j%2)), 3*a*j)
        turtle.setheading(-30 + 120*c)
        turtle.pendown()
        turtle.fillcolor(col)
        turtle.begin_fill()
        for k in range(-17, 18):
          l = a*sqrt(7)
          tf = ((1,141.787), (0,l), (1,-100.893), (0,a), (1,120), (0,a/2), [1,-120], [0,-a], [0,a], [1,120], (0,a/2), (1,60), (0,a), (1,-120), (0,a), (1,100.893), (0,l), [1,-40.893])[abs(k)]
          if k==6 or k==9 or k==17: tf[1] -= 180
          elif k==7 or k==8: tf[1] *= -1
          (turtle.forward, turtle.left)[tf[0]](tf[1])
        turtle.end_fill()
        turtle.forward(6*a)
        turtle.backward(5*a)
        turtle.penup()
        turtle.right(90)
        l = a*sqrt(3)/6
        for k in range(2):
          turtle.forward(l)
          turtle.pencolor((255,255,255))
          turtle.dot(a//4)
          turtle.pencolor((0,0,0))
          turtle.dot(a//8)
          turtle.backward(l)
          turtle.left(180)
      i = -i + (i <= 0)
    j = -j - (j >= 0)
except Exception as e: print(e)

try: turtle.show() #TI-83 Premium CE
except: pass


TI-83PCE/84+CE
turtle

TI-Nspire CX II
turtle

Casio
Graph 90+E

KhiCAS
NumWorks
TI-Nspire CX II CX

TI-83PCE/84+CE
ce_turtl

NumWorks
Casio
Graph 35+E II


Malheureusement pas d'amélioration ici, les poissons continuent à ne pas se comporter correctement sous KhiCAS.

Exemple n°7 : Le triangle de Penrose

Go to top

Tu n'as jamais touché à un triangle de Penrose ? Et bien voici de quoi en afficher le plan dans ta calculatrice, tu n'auras plus qu'à l'imprimer en 3D, si tu arrives à comprendre où est le devant et l'arrière : ;)
Code: Tout sélectionner
from math import sqrt
from ttl_fix import *

def hook(a, c):
  turtle.penup()
  turtle.goto(0,-15)
  turtle.setheading(a)
  turtle.forward((l - 4*b) / sqrt(3))
  turtle.right(150)
  turtle.pendown()
  lf = ((turtle.left, 60),[turtle.forward,b],(turtle.left,120),(turtle.forward,l-b),[turtle.right,120],[turtle.forward,l-3*b])
  try:
    turtle.fillcolor(c)
    turtle.begin_fill()
  except: pass
  for k in range(-len(lf) + 1, len(lf)):
    tf = lf[abs(k)]
    if k == 1: tf[1] = l
    elif k == 4: tf[0] = turtle.left
    elif k == 5: tf[1] = b
    tf[0](tf[1])
  try: turtle.end_fill()
  except: pass
 
turtle.speed(0)
turtle.pensize(2)
turtle.colormode(255)

l=180
b=23

for i in range(112):
  turtle.pencolor(232 - int(i * 23 / 11), 249 - int(i * 29 / 55), 255)
  turtle.penup()
  turtle.goto(-192, 111 - 2*i)
  turtle.pendown()
  turtle.forward(384)

turtle.pencolor((0,0,0))
turtle.pensize(1)

hook(330, (255,255,0))
hook(90, (0,0,255))
hook(210, (255,0,0))

try: turtle.show() #TI-83 Premium CE
except: pass


TI-83PCE/84+CE
turtle

TI-Nspire CX II
turtle

Casio
Graph 90+E

KhiCAS
NumWorks
TI-Nspire CX II CX

TI-83PCE/84+CE
ce_turtl

NumWorks
Casio
Graph 35+E II


Exemple n°8 : La courtepointe de Mamie

Go to top

Voici maintenant la courtepointe brodée avec amour et soin par Mamie :
Code: Tout sélectionner
from ttl_fix import *

def rotate_list(l):
  l[1:],l[0] = l[0:-1],l[-1]

def poly_reg_a(l, a):
  h0 = turtle.heading()
  while True:
    turtle.forward(l)
    turtle.left(a)
    if abs(h0 - turtle.heading()) < .1:
      break

turtle.hideturtle()
turtle.speed(0)
turtle.pensize(1)
turtle.colormode(255)

c = [191, 127, 0]
cf = [127, 255, 0]
i = 0
while i > -3:
  j = 0
  while j > -2:
    turtle.penup()
    turtle.goto((i - 1)*88, (j - 1)*85 + 28)
    turtle.pendown()
    turtle.color(c, cf)
    try: turtle.begin_fill()
    except: pass
    poly_reg_a(80, 140)
    try: turtle.end_fill()
    except: pass
    rotate_list(c)
    rotate_list(cf)
    j = -j + (j <= 0)
  i = -i + (i <= 0)

try: turtle.show() #TI-83 Premium CE
except: pass


TI-83PCE/84+CE
turtle

TI-Nspire CX II
turtle

Casio
Graph 90+E

nouveau
KhiCAS
NumWorks
TI-Nspire CX II CX

TI-83PCE/84+CE
ce_turtl

NumWorks
Casio
Graph 35+E II

ancien
KhiCAS
NumWorks
TI-Nspire CX II CX


C'est bon ici, KhiCAS choisit enfin des fils de la bonne couleur pour broder la courtepointe !

Exemple n°9 : Les vitraux rhombiques

Go to top

Voici maintenant une belle rosace rhombique pour décorer le bâtiment de ton choix.

Nous utilisons ici la méthode .dot() permettant de remplir un disque de diamètre donné, afin de générer de quoi avoir une couleur de fond d'écran sur nos calculatrices, suffit-il juste de lui spécifier un diamètre suffisamment grand :
Code: Tout sélectionner
from ttl_fix import *

turtle.speed(0)
turtle.colormode(255)
turtle.pencolor((0,0,255))
turtle.dot(320)
turtle.pencolor((0,0,0))
turtle.pensize(2)
col = ((255,0,0),(255,255,0),(0,255,0),(255,255,255),(255,0,255))
a=60

for i in range(10):
  c = col[i%5]
  turtle.color(c, c)
  turtle.begin_fill()
  for j in range(5):
    turtle.forward(a)
    turtle.right(72)
  turtle.end_fill()
  turtle.right(36)

for i in range(10):
  c = [v//3 for v in col[i%5]]
  turtle.pencolor(c)
  for j in range(5):
    turtle.forward(a)
    turtle.right(72)
  turtle.right(36)

try: turtle.show() #TI-83 Premium CE
except: pass


TI-83PCE/84+CE
turtle

TI-Nspire CX II
turtle

Casio
Graph 90+E

nouveau
KhiCAS
NumWorks
TI-Nspire CX II CX

TI-83PCE/84+CE
ce_turtl

NumWorks
Casio
Graph 35+E II

ancien
KhiCAS
NumWorks
TI-Nspire CX II CX


Bonne nouvelle ici encore, KhiCAS nous peint enfin les vitraux de la bonne couleur ! :bj:

Par rapport au fond bleu, notons que c'est cette nouvelle version de KhiCAS qui adopte le comportement correct. Selon le standard turtle, la méthode .dot() attend en paramètre le diamètre du disque à tracer. Ce sont les modèles Texas Instruments qui le considèrent à tort comme un rayon et remplissent alors tout l'écran.

Exemple n°10 : Les roses par 12

Go to top

Voici maintenant une rose, cette fois-ci sur un fond d'écran en dégradé radial. Nous utiliserons pour cela cette fois-ci une boucle de .dot() :
Code: Tout sélectionner
from math import pi, sin, cos, sqrt
from ttl_fix import *

def rpoly(c, n):
  a=360/n
  for k in range(n):
    turtle.forward(c)
    turtle.left(a)
def carre(c): rpoly(c, 4)

turtle.speed(0)
turtle.colormode(255)
turtle.penup()

r=80
alpha=(15 * pi / 180)

for i in range(320):
  c=int(255/320*i)
  turtle.pencolor(c,c,c)
  try: turtle.dot(320-i)
  except: pass

turtle.goto(20,-76)
turtle.color((255,255,255),(0,0,0))

for i in range(4):
  a=r*sin(alpha)*2
  d=a/sqrt(2)
  turtle.pendown()
  for i in range(12):
    turtle.right(15)
    try: turtle.begin_fill()
    except: pass
    carre(d)
    try: turtle.end_fill()
    except: pass
    turtle.left(45)
    turtle.penup()
    turtle.forward(a)
    turtle.pendown()
  turtle.penup()
  turtle.left(75)
  turtle.forward(d)
  turtle.right(60)
  r=r*cos(alpha)-a/2

try: turtle.show() #TI-83 Premium CE
except: pass


TI-83PCE/84+CE
turtle

TI-Nspire CX II
turtle

Casio
Graph 90+E

nouveau
KhiCAS
NumWorks
TI-Nspire CX II CX

TI-83PCE/84+CE
ce_turtl

NumWorks
Casio
Graph 35+E II

ancien
KhiCAS
NumWorks
TI-Nspire CX II CX


KhiCAS nous colorie enfin les pétales correctement !

Et sur la taille du disque de fond d'écran, c'est KhiCAS qui fait comme il faut.

Exemple n°11 : Les triangles de Sierpiński

Go to top

Revenons aux fractales et à la récursivité avec les triangles de Sierpiński. As-tu déjà réussi à les compter ? Et bien voici de quoi commencer sur ta calculatrice :
Code: Tout sélectionner
from ttl_fix import *

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

turtle.colormode(255)
turtle.speed(0)
turtle.pensize(1)

turtle.penup()
turtle.goto(-110, -95)
turtle.pendown()
turtle.pencolor((255,0,0))
sierp(6, 220)
turtle.penup()
turtle.forward(400)

try: turtle.show() #TI-83 Premium CE
except: pass


TI-83PCE/84+CE
turtle

TI-Nspire CX II
turtle

Casio
Graph 90+E

KhiCAS
NumWorks
TI-Nspire CX II CX

TI-83PCE/84+CE
ce_turtl

NumWorks
Casio
Graph 35+E II


Exemple n°12 : Sous le soleil exactement

Go to top

Plaçons-nous maintenant sous le soleil exactement, profitant ainsi de toutes les couleurs de la lumière blanche :
Code: Tout sélectionner
from math import exp
from ttl_fix import *

def rpoly(c, n):
  a=360/n
  for k in range(n):
    turtle.forward(c)
    turtle.left(a)
def carre(c): rpoly(c, 4)

turtle.speed(0)
turtle.pensize(1)
turtle.colormode(1.0)

n = 36
for i in range(n):
  k=.4 + 4*i/255
  cp = [.7*exp(-.5 * ((n - i - k) / (n / 3))**2) for k in (6, 18, 30)]
  turtle.pencolor(cp)
  try:
    turtle.fillcolor((k,k,0))
    turtle.begin_fill()
  except: pass
  carre(60)
  try: turtle.end_fill()
  except: pass
  turtle.right(360 / n)

try: turtle.show() #TI-83 Premium CE
except: pass


TI-83PCE/84+CE
turtle

TI-Nspire CX II
turtle

Casio
Graph 90+E

nouveau
KhiCAS
NumWorks
TI-Nspire CX II CX

TI-83PCE/84+CE
ce_turtl

NumWorks
Casio
Graph 35+E II

ancien
KhiCAS
NumWorks
TI-Nspire CX II CX


Du changement ici encore sur KhiCAS, notre soleil émet maintenant dans les bonnes longueurs d'onde !

Exemple n°13 : Le labyrinthe du Minotaure

Go to top

Explorons maintenant dans la labyrinthe du Minotaure :
Code: Tout sélectionner
from ttl_fix import *

turtle.speed(0)
turtle.colormode(255)
turtle.pendown()

turtle.right(48)
turtle.pencolor((0,0,0))
for i in range(98):
  turtle.forward(2*i)
  turtle.left(90.5)

try: turtle.show() #TI-83 Premium CE
except: pass


TI-83PCE/84+CE
turtle

TI-Nspire CX II
turtle

Casio
Graph 90+E

nouveau
KhiCAS
NumWorks
TI-Nspire CX II CX

TI-83PCE/84+CE
ce_turtl

NumWorks
Casio
Graph 35+E II

ancien
KhiCAS
NumWorks
TI-Nspire CX II CX


Ah c'est bon cette fois-ci, le labyrinthe se construit maintenant correctement sur KhiCAS Dédale et Minos seront contents. ;)

Exemple n°14 : Le carreau de carreaux

Go to top

Code: Tout sélectionner
from math import sqrt
from ttl_fix import *

def rotate_list(l):
  l[1:],l[0] = l[0:-1],l[-1]

def reg_poly(l, n):
  for i in range(n):
    turtle.forward(l)
    turtle.left(360/n)

def square(l):
  reg_poly(l, 4)

turtle.colormode(255)
turtle.pencolor(0,0,0)
turtle.speed(0)

turtle.pensize(3)
d=190
c=[0,255,127]
turtle.penup()
turtle.goto(-d/2,-d/2)
turtle.setheading(0)
turtle.pendown()
for i in range(8):
  try:
    turtle.fillcolor(tuple(c))
    turtle.begin_fill()
  except: pass
  square(d)
  try:
    turtle.end_fill()
  except: pass
  turtle.penup()
  turtle.forward(d/2)
  turtle.left(45)
  turtle.pendown()
  d/=sqrt(2)
  rotate_list(c)

try: turtle.show() #TI-83 Premium CE
except: pass


TI-83PCE/84+CE
turtle

TI-Nspire CX II
turtle

Casio
Graph 90+E

KhiCAS
NumWorks
TI-Nspire CX II CX

TI-83PCE/84+CE
ce_turtl

NumWorks
Casio
Graph 35+E II


Exemple n°15 : Les étoiles jumelles

Go to top

Code: Tout sélectionner
try: # TI-83 Premium CE
  from ti_system import disp_clr
  disp_clr()
except: pass
from ttl_fix import *

def rpoly(c, n):
  a=360/n
  for k in range(n):
    turtle.forward(c)
    turtle.left(a)

def rosace(c, n1, a, n2):
  try: turtle.begin_fill()
  except: pass
  for i in range(n2):
    turtle.left(a)
    rpoly(c, n1)
  try: turtle.end_fill()
  except: pass

turtle.colormode(255)
turtle.pencolor((0,0,0))

try: turtle.dot(320)
except: pass
turtle.color((255,255,255),(255,255,0))
turtle.speed(0)
turtle.pensize(1)
try:
  for i in range(-1, 2, 2):
    turtle.penup()
    turtle.goto(80*i, 0)
    turtle.pendown()
    rosace((i > 0) and 21 or 30, (i > 0) and 12 or 8, 30, 12)
    turtle.pensize(2)
    turtle.pencolor((0,0,255))
except MemoryError as e: print(e)

try: turtle.show() #TI-83 Premium CE
except: pass


TI-83PCE/84+CE
turtle

TI-Nspire CX II
turtle

Casio
Graph 90+E

nouveau
KhiCAS
NumWorks
TI-Nspire CX II CX

TI-83PCE/84+CE
ce_turtl

NumWorks
Casio
Graph 35+E II

ancien
KhiCAS
NumWorks
TI-Nspire CX II CX


Enfin ici aussi KhiCAS nous colorie les étoiles de la bonne couleur.

Sur la taille du disque de fond d'écran c'est ici aussi KhiCAS qui a raison et pas TI.

Exemple n°16 : La toile de l'araignée

Go to top

Suivons maintenant le fil de l'araignée :
Code: Tout sélectionner
from ttl_fix import *

def spiral(a,b):
  turtle.pencolor((0,0,0))
  try: turtle.dot(320)
  except: pass
  turtle.pencolor((255,255,0))
  for i in range(189):
    for j in range(6):
      turtle.forward(i/a)
      turtle.left(23)
    turtle.left(b)
    try: turtle.dot(2)
    except: pass
   
turtle.speed(0)
turtle.colormode(255)
turtle.pensize(1)

a=17
b=194

spiral(a,b)

try: turtle.show() #TI-83 Premium CE
except: pass


TI-83PCE/84+CE
turtle

TI-Nspire CX II
turtle

Casio
Graph 90+E

KhiCAS
NumWorks
TI-Nspire CX II CX

TI-83PCE/84+CE
ce_turtl

NumWorks
Casio
Graph 35+E II


Exemple n°17 : ♫ Le tournesol, le tournesol, ... ♫

Go to top

15443Terminons enfin avec un exemple absolument bluffant de réalisme pour du turtle, nous allons faire pousser un tournesol devant toi :
Code: Tout sélectionner
from math import pi, sin, cos, sqrt
from ttl_fix import *

def spiral():
  phi = (1+sqrt(5))/2
  a  =0
  r = 0
  dr = 0.15
  turtle.penup()
  for i in range(300):
    turtle.forward(r)
    turtle.pencolor((0,0,0))
    try: turtle.dot(3)
    except: pass
    turtle.pencolor((205,133,63))
    try: turtle.dot(2)
    except: pass
    turtle.goto(0,0)
    turtle.setheading(0)
    a+=360/phi
    turtle.right(a)
    if a>=360:
      r+=dr
      a-=360   

def feuille(core,a):
    try: turtle.begin_fill()
    except: pass
    turtle.right(a/2)
    turtle.forward(core)
    turtle.left(a)
    turtle.forward(core)
    turtle.left(180-a)
    turtle.forward(core)
    turtle.left(a)
    turtle.forward(core)
    try: turtle.end_fill()
    except: pass

turtle.speed(0)
turtle.colormode(255)
turtle.pencolor((30,144,255))
try: turtle.dot(320)
except: pass

d=25
core=40
turtle.pencolor((160,82,45))
try: turtle.dot(40)
except: pass

c=((255,215,0),(255,255,0))

for i in range(2):
  turtle.color(c[0], c[i])
  for h in range(10*i,370,20):
    r=h * pi / 180
    x=d*cos(r)
    y=d*sin(r)
    turtle.penup()
    turtle.goto(x,y)
    turtle.pendown()
    turtle.setheading(h)
    feuille(core,32)

spiral()

try: turtle.show() #TI-83 Premium CE
except: pass


TI-83PCE/84+CE
turtle

TI-Nspire CX II
turtle

Casio
Graph 90+E

nouveau
KhiCAS
NumWorks
TI-Nspire CX II CX

TI-83PCE/84+CE
ce_turtl

NumWorks
Casio
Graph 35+E II

ancien
KhiCAS
NumWorks
TI-Nspire CX II CX


Ah, enfin notre tournesol commence à ressembler à un tournesol sur KhiCAS.

Sur le disque de fond d'écran, rappelons que c'est KhiCAS qui a raison.

Par contre, on déplore encore la délimitation incorrecte des graines dans le cœur.




Conclusion

Go to top

Selon notre outil de tests, KhiCAS pour TI-Nspire CX et NumWorks N0110 est bien mieux conforme au standard Python-turtle que l'ensemble des solutions turtle officielles, et semble en conséquence bien mieux se comporter en pratique sur une majorité de nos exemples. nous semble offrir à ce jour la meilleure bibliothèque Python turtle toutes solutions confondues.

Les méthodes de remplissage, absentes des implémentations officielles de Casio et NumWorks t'ouvrent la porte à de formidables progrès.

Certes il y a encore quelques défauts et donc écarts par rapport au tracé obtenu avec la bibliothèque standard sur ordinateur, mais KhiCAS a l'avantage d'être régulièrement maintenu et de bénéficier de plusieurs mises à jour par an.

Les progrès sont déjà très significatifs par rapport à la version précédente, et nul doute qu'ils vont se poursuivre ! :bj:




Téléchargements

Go to top

Lien vers le sujet sur le forum: KhiCAS: Python-turtle étendu pour NumWorks & Nspire CX (Commentaires: 3)

Widget TI-Nspire de schémas de Physique (électricité, méca)

Nouveau messagede critor » 22 Mar 2022, 13:17

15131510Les HP 48SX de 1990 et HP 48GX de 1993 ne disposaient pas de mémoire Flash. Pour installer des applications il fallait acheter des cartes ROM à insérer dans l'un des deux ports présents au dos.

De formidables applications de qualité professionnelle furent sorties par des éditeurs tiers, notamment chez Sparcom avec sa gamme The Pocket Professionnal.

Intéressons-nous aujourd'hui à un des nombreux titres de cette gamme, Spice48.

Spice48 est un logiciel dédié à la gestion de circuits électriques. Il te permettait :
  • de construire ton circuit avec ses nœuds, fils et composants
  • de spécifier les valeurs nominale et/ou initiale de chaque composant
  • de visualiser le circuit
  • pour cela, de définir toi-même les coordonnées à l'écran des nœuds et composants ou bien d'opter pour le mode de calcul automatique des coordonnées
  • de générer l'équation différentielle du circuit
  • de résoudre cette équation et en conséquence de représenter graphiquement l'évolution au cours du temps des grandeurs de ton choix (tension entre deux bornes, intensité...)

Fort malheureusement, en 1993 HP tente une délocalisation du développement des calculatrices, de Corvallis (Oregon, Etats-Unis) à Singapour, délocalisation ratée qui aura fait perdre pas moins de 6 ans au constructeur (6 ans sans nouveauté sérieuse, dont 5 ans sans la moindre nouveauté alors qu'en face sortait la TI-92 dès 1995).

Mais ni Spice48 ni même les autres formidables applications professionnelles sur cartes ROM ne furent rééditées pour les modèles haut de gamme ultérieurs HP 49G, HP 50G et HP Prime, et la communauté n'a pas davantage créé de programme adaptant les fonctionnalités de Spice48. Un énorme regret surtout dans le contexte des capacités de la HP Prime avec son écran couleur tactile, ce modèle méritait vraiment des applications professionnelles qu'il n'a hélas jamais eu.

Outre Sparcom qui avait hélas disparu en 1998, il semble que les contacts avec ces éditeurs tiers aient été perdus entre temps, ou bien que ces derniers se soient désintéressés des calculatrices HP suite à un tel délai. À moins qu'il y ait eu aussi des considérations par rapport à la copie illégale d'applications payantes, les modèles ultérieurs abandonnant en effet les ports d'extension en l'échange de l'ajout de mémoire Flash, rendant donc la manipulation de copie entièrement logicielle et donc en théorie plus accessible et facile.

Personnellement ce manque était mon plus grand regret qui m'avait toujours empêché d'adhérer pleinement aux modèles HP successeurs.

13805La vente pour la rentrée 2021 de toute la branche HP Calculatrices à Moravia, une obscure société tchèque, ultime erreur du management de chez HP après 30 ans de récidives de bêtises monumentales qui resteront dans l'histoire comme exemple de tout ce qu'il ne faut pas faire (ou inversement tout ce qu'il faut faire pour arriver à se saborder alors qu'on est au sommet), termine d'enterrer les minces espoir qu'il nous restait encore concernant la HP Prime. Bien que majeure, l'ultime mise à jour HP Prime 2.1.14575 sortie par HP juste avant la vente au printemps 2021 est d'une finition très inférieure aux précédentes. Sortie en effet dans l'urgence d'un changement de réglementation des examens 2021 aux Pays-Bas, les nouveautés ajoutées au passage s'accompagnent de nombreux bugs et d'une grave instabilité du système déclenchant très régulièrement des redémarrages ou même l'écran bleu d'erreur fatale, contrairement aux versions précédentes. :'(

Nous ne pouvons que constater que depuis maintenant près d'un an, Moravia a été dans l'incapacité totale de corriger ces très graves problèmes alors que cela aurait dû être leur priorité numéro un, et en sommes donc réduits à considérer les HP Prime actuellement commercialisées comme des machines désormais défectueuses. :mj:

Regardons donc ailleurs, pas le choix.

Le logiciel intégré de Mathématiques TI-Nspire gère des documents de travail appelés classeurs, eux-mêmes constitués de pages, pouvant elles-mêmes accueillir chacune de 1 à 4 widgets.

15343Chaque widget pouvait alors être rempli au choix avec une des 9 applications intégrées, bien évidemment toutes liées dynamiquement entre elles au sein d'un même document (partageant les mêmes données : une modification effectuée dans une des applications étant automatiquement répercutée dans les autres, ce qui fait toute la puissance du logiciel TI-Nspire CX) :
  • Calculs
  • Graphiques
  • Géométrie
  • Tableur & Listes
  • Données & statistiques
  • Éditeur Mathématique
  • Vernier Dataquest™
  • Éditeur de programmes
  • Python
Depuis la mise à jour 4.4 de novembre 2016, les TI-Nspire CX te permettent enfin de rajouter tes propres applications appelées widgets. Il s'agit techniquement de classeurs à enregistrer dans le dossier /MyWidgets/ de la calculatrice, constitués d'une unique page, contenant un script codé dans le langage Lua. Plus exactement seule la première page de ces documents est prise en compte dans ce cadre.
Toutefois depuis maintenant plus de 5 ans, cette formidable possibilité n'avait pas été exploitée. Aucune application pouvant être qualifiée de professionnelle, quasiment rien en fait, juste quelques démos.

Et bien aujourd'hui est le grand jour. schoolstore.fi, le distributeur Texas Instruments en Finlande, vient de développer (en langage Lua) et sortir Physics Drawing.
Téléchargeable gratuitement et une fois installée correctement dans le dossier /MyWidgets/, l'application Physics Drawing devient alors rajoutable à tout moment dans les différents widgets et pages de tes documents.

De qualité professionnelle, Physics Drawing te permet comme son nom l'indique de rajouter des schémas de Physique à tes documents. Les schémas entièrement dynamiques restent donc éditables à tout moment, avec des éléments que tu positionnes et édite avec le pointeur. On apprécie l'aide en ligne multilingue sur chaque objet pointé.
Les menus eux aussi multilingues permettent de couvrir entre autres les domaines suivants de la Physique :
  • Circuits électriques (comme dans Spice48 donc, mais à ce jour ici sans les possibilités de résolution)
  • Systèmes mécaniques
  • Électromagnétisme
  • Ondes
  • Atomistique

Après près de 30 ans d'attente les schémas de circuits électriques (et bien plus encore) sont donc enfin de retour sur calculatrices ! :bj:

Si l'avenir des calculatrices HP désormais entre les mains du mauvais acteur peut nous paraître hélas aujourd'hui très fortement compromis, l'esprit HP 48 quant à lui n'est pas mort pouvu que tu acceptes de regarder ailleurs. ;)

Téléchargement : Physics Drawing

Source : https://tinspirewidgets.com/
Lien vers le sujet sur le forum: Widget TI-Nspire de schémas de Physique (électricité, méca) (Commentaires: 14)

-
Rechercher
-
Social TI-Planet
-
Sujets à la une
Comparaisons des meilleurs prix pour acheter sa calculatrice !
Aidez la communauté à documenter les révisions matérielles en listant vos calculatrices graphiques !
Phi NumWorks jailbreak
123
-
Faire un don / Premium
Pour plus de concours, de lots, de tests, nous aider à payer le serveur et les domaines...
Faire un don
Découvrez les avantages d'un compte donateur !
JoinRejoignez the donors and/or premium!les donateurs et/ou premium !


Partenaires et pub
Notre partenaire Jarrety Calculatrices à acheter chez Calcuso
-
Stats.
757 utilisateurs:
>746 invités
>6 membres
>5 robots
Record simultané (sur 6 mois):
6892 utilisateurs (le 07/06/2017)
-
Autres sites intéressants
Texas Instruments Education
Global | France
 (English / Français)
Banque de programmes TI
ticalc.org
 (English)
La communauté TI-82
tout82.free.fr
 (Français)