**************** ********** AUTOCALC 3.1 ********** **************** Note: la description qui fait suite donne des détails algorithmiques et mathématiques. Pour bien la comprendre, il faut avoir des bonnes bases de programmation, mais aussi mathématiques (niveaux première S et Terminale S conseillés). Une autre description (bien que moins complète) destinée à l'utilisateur non programmeur (élève ou professeur) est incluse au format HTML dans l'archive du programme. Toutefois, si vous avez des questions ou remarques, n'hésitez pas à m'écrire à andreanx@hotmail.com . Je répondrai avec plaisir dans les meilleurs délais. Xavier ANDREANI Sommaire : -------- 0) Nom du programme 1) Nom de l'auteur 2) Type de calculatrice 3) Description rapide 4) Langage utilisé 6) Problématique - Pourquoi ce programme? 7) Historique 8) Compatibilité - Pour quelle calculatrice? 9) Algorithme - Comment faire? 10) Nombres gérés - Qu'affiche AUTOCALC? 11) Principe - Comment ça marche? 12) Durée de recherche - Combien de temps ça prend? 13) Programmes utilisant le moteur AUTOCALC 14) La résolution des équations du 2nd degré 15) La résolution des systèmes d'équations linéaires 16) Utilisation du moteur - Comment faire à partie d'un programme 17) Techniques de programmation sur TI-8X 18) Différences d'algorithmes entre la version TI-82 Stats et la version TI-83+ 19) Astuce de mise en fraction d'un nombre 20) Economisons encore de la mémoire 21) Liste des fichiers à transférer et description 0) Nom du programme : AUTOCALC ---------------- 1) Nom de l'auteur : Xavier ANDREANI --------------- 2) Type de calculatrice : TI-76.fr (portage), TI-82Stats/82Stats.fr/83 (portage), TI-83+/84+ (machines de développement) -------------------- 3) Description rapide : ------------------ AUTOCALC est un moteur de calcul numérique exact, outil indispensable pour les maths au lycée. Il permet d'afficher un résultat sous forme exacte, au lieu d'une valeur approchée (ne rapportant aucun point au lycée). De nombreux types de résultats sont gérés: fractions, racines carrées, radians, logarithmes, exponentielles, nombres complexes... Plusieurs programmes utilisant AUTOCALC sont fournis: une calculatrice exacte, un programme de résolution du 2nd degré, un programme de résolution de systèmes d'équations linéaires. 4) Langage utilisé : --------------- Au départ j'ai réalisé AUTOCALC entièrement en TI-Basic. Puis, pour des raisons de rapidité, les sous-programmes les plus utilisés ont été remplacés par des versions assembleur fournis par des programmeurs tiers. Sur TI-76.fr/82Stats/83, c'est 1 sous-programme de l'algorithme qui est en assembleur. Sur TI-83+/84+, ce sont 2 sous-programmes de l'algorithme qui sont en assembleur, plus 1 programme indépendant de l'algorithme qui permet d'économiser de la mémoire en utilisant la mémoire d'archive. 6) Historique : ---------- J'ai commencé à développer AUTOCALC en septembre 2007. 7) Problématique : ------------- Les calculatrices TI-8X sont destinées à des élèves de niveau lycée. A un niveau lycée, le professeur de mathématiques attend de la part des élèves un résultat exact et non une valeur approchée. Par exemple, il faut écrire le résultat exact 3*Racine(2)/2 et non la valeur approchée 2,12 qui ne rapporterait aucun point. Or, par défaut les TI-8X ne gèrent (manuellement) que les fractions (exemple: 3/5). Elles ne savent pas afficher des nombres comme 3*Racine(2)/2 (Quatrième), 3*Pi/2 (Troisième), 5*ln(3/2), exp(3/2), 2+3i (Terminale). Même la TI-nSpire basique (non CAS) ne fait pas mieux! Si on oublie les possibilités de faire des graphiques, on pourrait donc se demander à quoi servent ces calculatrices en lycée... Le calcul exact est géré sur les modèles haut-de-gamme (TI-89/92/V200/nSpire CAS), mais aussi (et c'est plus grave) sur le modèle collège du concurrent Casio: la Casio Collège 2D. Cette calculatrice est capable d'afficher automatiquement des résultats sous les forme 2/3, 2*Racine(3)/3, 1/2+2*Racine(3)/3, 3*Racine(2)/2+2*Racine(3)/3. Et bon nombres d'élèves me disent au lycée qu'ils sont déçus de leur TI, que leur Casio collège faisait mieux. Certains commettent même l'erreur de choisir une Casio graphique, qui d'une part ne reprend pas le moteur de calcul de la Casio collège, et d'autre part a plein de défauts que je ne détaillerai pas ici. C'est donc dans ce but que j'ai développé AUTOCALC, afin de donner aux TI-82 Stats et TI-83+/84+ des possibilités de calculs exacts. Le but est que n'importe quel programme ayant un résultat à afficher (simple calcul, limite, solution d'une équation...) puisse faire appel à AUTOCALC qui lui renverra une chaîne de caractères présentant le résultat simplifié sous la forme appropriée, prêt à être affiché. 8) Compatibilité : ------------- Le programme est fourni en 3 versions: - une version dans le dossier "76.fr" qui est destinée à la TI-76.fr. - une version dans le dossier "82Stats - 83" qui est destinée aux TI-83, TI-82 Stats, Ti-82 Stats.fr (calculatrices 100% compatibles malgré le changement "commercial" du numéro de modèle). - une version dans le dossier "83p" qui est destinée aux TI-83+, TI-83+SE, TI-84+, TI-84+SE. En effet, ce sont les types de calculatrices principalement utilisées par les élèves au lycée (toutefois, je vois plus de TI-82 Stats, bien que conseillant régulièrement à mes élèves de prendre au moins la TI-83+ pour des études scientifiques). Le programme pourrait être aisément porté sur TI-85/86 (juste des instructions ou calculs à traduire - pas d'algorithmes à refaire; mais je ne rencontre aucun élève les utilisant). Une version TI-82 (parfois certains élèves l'ont récupérée de leur grand frère ou grande soeur) demanderait la gestion manuelle des nombres complexes, ou devrait alors être bridée. 9) Algorithme : ---------- A priori, 2 approches sont possibles. - (1) Soit le programme prend comme paramètre une chaîne de caractères décrivant le calcul. Il faut alors réaliser un analyseur syntaxique, qui permettra de faire diverses transformations sur cette chaîne de caractères afin de l'écrire plus simplement en respectant les priorités des opérations. Une structure arborescente pour représenter le calcul serait alors la bienvenue. - (2) Soit le programme prend comme paramètre le résultat du calcul, et par des algorithmes divers va essayer de transformer ce résultat afin de le décoder. Etant habitué aux langages de programmation de haut niveau, ne connaissant que peu de choses à l'assembleur, et tenant à pouvoir porter rapidement le programme sur TI-82 Stats, j'ai opté pour le TI-Basic. En tenant compte de la vitesse d'exécution du TI-Basic, la méthode (1) ne me semble pas être le bon choix. J'ai donc opté pour la méthode (2) afin que les résultats soient fournis dans un temps raisonnable pour un lycéen en situation d'examen. Toutefois, cette méthode ne présente pas que des avantages. La calculatrice gère les nombres sur un maximum de 13 chiffres. Or, à notre niveau, la plupart des résultats ont une partie décimale qui ne se termine jamais. Le résultat représenté sur 13 chiffres est donc une valeur approchée, avec une marge d'erreur (certes faible). Mais quand on commence à manipuler le nombre en question, les nouveaux résultats obtenus peuvent s'écarter d'avantage de la valeur exacte, et par exemple donner 1,0000001 au lieu de 1. Toute la difficulté de cette méthode (2) ne réside donc pas seulement dans la construction des algorithmes pour tester les nombres, mais surtout dans la gestion des marges d'erreur. Tout est dans la finesse: - si on se montre trop strict, la forme simplifiée ne sera pas trouvée car le test aura échoué à cause de la marge d'erreur... - si on se montre trop laxiste, on pourra avoir des erreurs du style 1731/551=Pi (=3,1415...) 10) Nombres gérés : ------------- AUTOCALC est capable d'afficher des résultats de calculs sous les formes suivantes. Les formes sont listées de la plus simple à la plus compliquée, dans l'ordre ou les teste le programme. Si un test réussit, on passe à l'affichage. Si le test échoue, on passe à la forme suivante. D'autres formes pourraient être gérées, (il suffit de modifier la boucle principale des tests) mais je cherche le meilleur compromis entre rapidité et efficacité: Le nouveau test est-il rapide? Nécessite-il une boucle de recherche?... Le rencontre-t-on souvent dans les exercices, ou est-ce un cas isolé? Je ne cherche pas forcément à afficher "tout-le-temps", mais "souvent" et dans un temps "raisonnable". Aussi j'ai tenté de gérer la plupart des formes que l'on rencontre régulièrement au lycée: - (1) nombre entier : 17, -11 ... Je vais pas renvoyer erreur "trop facile" quand même... ;) - (2) fraction : 2/3, -5/2 ... Même si la calculatrice le fait déjà, il le faut bien pour gérer les formes suivantes... - (3) fraction avec racine carrée: 2*Racine(3)/5 ... Quatrième - Troisième: On peut par exemple obtenir les valeurs remarquables de la table trigonométrique: cos(Pi/6)=Racine(3)/2, ou de tout angle déduisible sur le cercle trigonométrique: cos(3*Pi/4)=-Racine(2)/2 (Seconde, Première) On peut simplifier les racines carrées (question type au brevet): Racine(90==3*Racine(10) ... On peut aussi supprimer les racines au dénominateur: 1/Racine(2)=Racine(2)/2 - (4) fraction principale de Pi / racine carrée: 2*Pi/3, 2*Pi*Racine(3)/5 Seconde: Le résultat sans racine est mis automatiquement sous forme principale, exemple: 2007*Pi/12=-3*Pi/4 (question au BAC 2007) ... Les fonctions cosinus, sinus et tangente inverses, peuvent enfin servir à quelque chose en mode radians: Arccos(-1/2)=2*Pi/3 ... - (5) multiple / moitié / opposé de logarithme de fraction / Pi : ln(3/4), ln(3)/2, -ln(3), ln(2*Pi/3), -ln(3*Pi/4)/2 ... Terminale: ln(2)+ln(3)=ln(6), ln(Racine(3))=ln(3)/2, ln(5)-ln(6)=-ln(6/5), ln(9/4)=2*ln(3/2) ... - (6) exponentielle de fraction / racine carrée / Pi: e^(3/2), e^(-2*Pi/3), e^(Racine(2)), e^(3*Pi*Racine(2)/4) Terminale: (je n'ai pas encore trouvé d'algorithme simple pour gérer les coefficients: 2*e^(2), 3*e^(3) ... je cherche encore ...) - (7) somme d'une fraction et d'une fraction de racine carrée: 1+Racine(2), 1/2+Racine(3)/4 ... Exemples: Troisième: (1+Racine(2))²=3+2Racine(2) Seconde: on peut supprimer les sommes avec racines au dénominateur (règle du conjugué): 1/(1+Racine(5))=-1/4+Racine(5)/4 Première S: on peut trouverde nouveaux cosinus, sinus et tangentes qui ne sont pas dans le tableau des valeurs remarquables (règles d'addition, soustraction, et duplication) cos(Pi/5)=1/4+Racine(5)/4 ... - (8) racine d'une somme d'une fraction et d'une fraction de racine carrée: Racine(2/5+Racine(3/4)), Racine(Racine(2)) ... Première S: encore de nouveaux cosinus, sinus et tangentes! cos(Pi/8)=Racine(1/2+Racine(2)/4), cos(Pi/10)=Racine(5/8+Racine(5)/8) ... - (9) somme de deux fractions de racines carrées: Racine(2)/4+Racine(3)/5 ... C'est un cas particulier de la forme (8) qui peut se simplifier de cette manière dans certains cas. Première S: encore de nouveaux cosinus, sinus et tangentes! cos(Pi/12)=Racine(6)/4+Racine(2)/4 - (10) nombre complexe avec partie réelle, partie imaginaire, module et argument: 1+3i, 2*e^(i*Pi/3) ... Terminale S: Les parties réelle, imaginaire et module peuvent avoir toutes les formes citées précédemment. L'argument est cherché sous la forme d'une fraction de Pi (4). 11) Principe : -------- - pour tester la forme (3) par exemple, je mets le nombre au carré, et tente de le mettre en fraction (2). Si ça marche, il ne reste plus qu'à travailler le résultat. - pour tester la forme (4), je divise le nombre par Pi et tente de le mettre sous la forme (3). - les formes (5) et (6) utilisent la forme (4). Bref, jusqu'à présent, l'algorithme est assez rapide: une transformation calculatoire du résultat, un test de mise en fraction éventuellement avec des racines et des Pi, le calcul des différentes composantes du résultat et leur affichage. - les formes (7), (8) et (9) sont basées sur le même algorithme. Il s'agit donc de décrypter dans le résultat, la somme d'une fraction, et d'une fraction de racine carrée. Cette famille de nombres répond à des propriétés qu'illustre très bien le nombre d'or: 1/2+Racine(5)/2=1.618033989, (1/2+Racine(5)/2)²=2,618033989 On constate la même partie décimale. De façon générale, tout ou partie de la partie décimale du carré, et un multiple de tout ou partie de la partie décimale du résultat donné. Dans cet algorithme, je compare donc la partie décimale du résultat, à celle de son carré. Ce support est pour le moment expérimental. Même s'il donne d'excellents résultats en trigonométrie notamment, il a plusieurs défauts. Comme je travaille sur la partie décimale, je suis en plein dans la partie du nombre qui est soumise à la marge d'erreur. L'algorithme n'aime pas que une ou plusieurs des composantes de cette forme soit un nombre trop grand. D'autre part, si les fractions doivent être des nombres dont la partie décimale est finie: 1/2=0.5, 1/4=0.25, 1/8=0.125 ... L'algorithme est totalement incompatible avec des fractions donnant des parties décimales infinies: 1/3=0.3333333... Je cherche toujours si je peux encore améliorer cet algorithme, ou en inventer un autre... 12) Durée de recherche : ------------------ | TI-82 Stats | TI-83+ | TI-84+ ------------------------+---------------+---------------+------------- formes (1) à (4) | moins de 10s | non mesuré | moins de 5s formes (5) à (6) | moins de 15s | non mesuré | moins de 10s formes (7) à (9) | moins de 45s | non meuré | moins de 20s forme (10) | moins de 30s | non mesuré | moins de 15s Pour les formes (7) à (9), le temps de recherche est assez variable, la boucle étant "lourde". Pour la forme (10), j'ai considéré uniquement des complexes composés de formes (1) à (4) pour leurs parties réelle, imagine, module et argument. Comme il faut chercher 4 nombres réels pour 1 nombre complexe, cela explique que le temps soit 3 à 4 fois plus long. Les complexes plus compliqués, composés de formes (5) à (9) sont gérés, mais le temps est beaucoup plus variable. Un temps de recherche sensiblement plus long que les temps indiqués, indique normalement que le programme a "raté" le résultat. La forme attendue a échoué à cause d'un problème de marge d'erreur, et le programme est en train de chercher plus compliqué. Cela peut se terminer: - soit par l'affichage du nombre à virgule (si tout a échoué) - soit par l'affichage de choses inutiles (Racine(0+Racine(2)) le programme finissant par trouver la simplification, mais sous une forme plus compliquée - soit par l'affichage de bêtises: e^(345*Racine(33534534)/24324) - soit par une erreur de mémoire par excès d'imbrication de sous-programmes et de boucles Normalement, ces échecs sont très rares si l'on n'utilise que des nombres "raisonnables" donnant des résultats sous des formes gérées. 13) Programmes utilisant le moteur AUTOCALC : --------------------------------------- Plusieurs programmes sont fournis. Pour y accéder, il suffit de lancer AUTOCALC. Un menu est alors affiché, et permet de choisir: - une calculatrice, qui permet de taper des calculs en boucle, et appelle le moteur à chaque fois pour afficher le résultat. - un programme de résolution des équations du seconde degré. - un programme pour résoudre les systèmes d'équations linéaires D'autres programmes utilisant le moteur sont en projet: - un programme d'étude de fonction, calcul de limite / dérivée / tangente / asymptote (l'intérêt est là aussi d'afficher des résultats exacts, et dans la mesure du possible, d'éviter les erreurs... j'arrive à "tromper" la plupart des programmes présents sur Internet, en tapant des fonctions "modérément" compliquées... je suis conscient de la difficulté du problème!) Pour le moment, l'algorithme de recherche de limite en + ou - l'infini est prêt: il donne la limite, le sens de variation au voisinage, les asymptotes ou directions asymptotiques, et arrive à éviter les différents "pièges" que je lui ai posés jusqu'à présent (pas de limite, valeur interdite, oscillations...) En fait, il faut avoir des connaissances mathématiques "post-BAC", pour arriver à bien cerner les problèmes que l'on rencontre à l'occasion à ce niveau. Et il faut savoir, que nombre de professeurs dans leurs DS, et les QCM au BAC, présentent divers cas pour "tromper" la calculatrice. Mais il est toujours expérimental, et dépourvu d'une "belle" interface", et je n'ai pas jugé utile de l'inclure dans cette archive. J'en parlerai donc d'avantage une prochaine fois. - un programme de résolution d'équation (non commencé, je sais que ce ne sera pas facile) 14) La résolution des équations du 2nd degré : ---------------------------------------- Un autre programme comme il y en a tant, direz-vous? Oui, mais... Il ne fait pas seulement afficher la valeur approchée comme d'autres programmes... Grâce au moteur, il tente d'afficher la valeur exacte. Par exemple, x²-x-1=0 donne x=1/2+Racine(5)/2 et x=1/2-Racine(5)/2 Mais, j'avais dit que ce type de forme (7) était lourd à gérer, et pas toujours décryptable, si il y a des "/3" par exemple... Aussi en interne, le moteur est appellé 2 fois séparément: une fois pour décrypter -b/2a, et une fois pour Racine(Delta)/2a, ce qui contourne le problème. Il suffit alors de concaténer les chaînes à l'affichage. Dans certains cas particuliers (réponses très simples), les 2 résultats se simplifient ensemble. J'essaye de gérer en appellant le moteur avec le calcul complet uniquement dans ces cas (car dans les autres comme déjà dit, cela prendrait plus de temps ou ne trouverait pas le résultat). D'autres programmes encore, comprenant que la valeur approchée est quasi-inutile au lycée, tente d'afficher la forme (-b + Racine(Delta))/2a en remplaçant les lettres. Dans la plupart des cas, le résultat est acceptable, mais non simplifié pour la racine et la fraction. Les simplifications sont ici automatiques. Enfin, le type d'affichage décrit ci-dessus pour les autres programmes ne fonctionnent pas dans tous les cas... Il suffit de compliquer le polynôme avec b=Racine(2) par exemple, et on obtiendrait une valeur approchée, puisqu'il y a une racine à un endroit où on ne s'y attend pas... Aucun problème ici avec AUTOCALC, puisqu'il détecte automatiquement la forme sous laquelle il doit afficher. Exemple: x^2-Racine(2)x-1=0 donne x=Racine(2)/2+Racine(6)/2 et x=Racine(2)/2-Racine(6)/2 A priori, on peut donc taper des coefficients a, b, c non entiers: le résultat sera affiché correctement tant que les -b/2a et Racine(Delta)/2a restent des formes gérées. Donc le programme: - rappelle les formules et affiche le résultat sous forme exacte (dans la mesure du possible) - gère les cas Delta>0, Delta=0 (Première) mais aussi Delta<0 (Terminale S) - gère les cas où le Delta est complexe (post-BAC) notamment si il y a des nombres complexes dans a, b ou c (ce support là aussi est encore expérimental) - rappelle la formule de factorisation appropriée - rappelle la forme canonique, et en calcul les composantes (sous forme exacte si possible) - affiche le tableau de signe et variations si il n'y a pas de nombres complexes. 15) La résolution des systèmes d'équations linéaires : ------------------------------------------------ Un programme comme il y en a tant d'autres... A part que là aussi l'utilisation du moteur permet (en théorie) l'affichage de valeurs exactes en toute circonstance. Le programme permet: - le choix des inconnues (xyzt, abc...); l'utilisateur a juste à taper les inconnues qu'il utilise - le choix du nombre d'équations - d'afficher la solution si il y en a une, ou le système simplifié si il y a une infinité de solutions - d'afficher le système simplifié triangulé par le pivot de Gauss (en lycée, on dira simplifié par combinaison), ce qui donne une étape à recopier 16) Utilisation du moteur : --------------------- C'est le sous-programme Y1PRINTO qui prend le résultat qui est dans la dernière réponse (Ans), et renvoie en sortie une chaîne de caractères affichable. En sortie du sous-programme, cette chaîne est à la fois dans la dernière réponse (Ans) et dans la chaîne 0 (Str0). Ce sous-programme peut être appellé à partir d'un autre programme. Toutefois, il faut faire attention à ce qu'il n'écrase pas des variables que vous utilisez. Les variables écrasées sont la fin de l'alphabet, les dernières chaînes de caractères, les dernières listes. (il y avait au départ une sauvegarde et restauration de variables en sortie, mais je l'ai supprimée car elle ralentissait grandement la gestion des nombres complexes pour lesquels Y1PRINTOR se rappelle récursivement et est donc exécuté 4 fois) Si on devine que le résultat cherché est sous une forme non gérée par le programme, on peut taper le calcul par morceaux. Exemple: pour Pi/2-Pi/3-Racine(90), il faut lancer Pi/2-Pi/3 d'une part, et Racine(90) d'autre part. 17) Techniques de programmation sur TI-8X : ------------------------------------- - Concernant les menus dans les programmes, je les réalise manuellement dans le style de la TI-85: des rectangles en bas de l'écran correspondant aux touches F1 à F5. Je trouve d'ailleurs très dommage que la fonction "Menu" sur TI-82/83/84 nous affiche un horrible menu textuel squattant tout l'écran, alors que les TI-85/86 nous offrent par défaut un beau menu graphique discret en bas d'écran. - Mes sous-programmes commencent habituellement par Z ou Y afin d'être liste alphabéltiquement à la fin et ne pas gêner l'exécution d'autres programmes par l'utilisateur. - Afin d'économiser un peu de place en mémoire (mes programmes ne seront pas tous seuls sur la calculatrice, la TI-82 Stats ne dispose pas de mémoire d'achive, et on est limité en théorie à 32Ko, en pratique à un peu moins) j'ai pour habitude de ne pas fermer les parenthèses ou autres délimiteurs (guillemets, accolades) en fin de ligne, puisque cela ne dérange pas la calculatrice. Cela peut paraître ridicule d'économiser 1 à 2 caractères par ligne de code, mais quand on multiplie par le nombre de lignes de code sur une mémoire inférieure à 32Ko, cela fait une différence notable. Si j'économise 10% de mes 10Ko de programme, le 1Ko économisé n'est pas rien sur une mémoire de 32Ko. Il peut permettre de rentrer d'autres programmes, et surtout d'avoir la place pour les exécuter. - Concernant les textes affichés par les programmes, il est là encore dommage que les TI-82/83/84 ne gèrent pas par défaut les caractères en minuscules contrairement aux TI-85/86. Ces affichages de texte en majuscules sont agressifs, peu agréables à lire, et se font parfois même plus remarquer au premier coup d'oeil que le résultat (ce qui est un comble!). Il existe bien des programmes assembleurs pour afficher les minuscules sur TI-82 Stats, mais je n'en ai trouvé aucun qui soit destiné à être lancé à l'intérieur d'un autre programme. Il est possible d'écrire des minuscules sur TI-83+/84+ avec de l'assembleur, ou alors en tapant le programme à l'ordi avant de le transférer sur calculatrice. Mais là encore un autre problème se pose: le transfert entre calculatrices. La TI-82 Stats ne peut pas recevoir ces caractères spéciaux (erreur lors du transfert), et même si on bidouille pour forcer l'envoi, on se retrouve avec une série de caractères système incompréhensibles. Quand aux TI-83+, les anciennes versions du système d'exploitation refusent là aussi ces transferts (et ce ne sont pas tous les élèves qui sont capables de mettre à jour leur système). Il fallait donc trouver un compromis: j'ai choisi d'utiliser entre autres les variables statistiques que l'on accède avec le menu VARS, et qui sont écrit en minuscules. Cela me permet donc d'avoir une majorité de lettres en minuscules, qui sont transférables sur toutes les TI-83+ et TI-82 Stats. Actuellement, je peux afficher en minuscules les lettres: a, b, c, d, e, n, p, r, s, t, x, y (statistiques), u, v, w, (suites), i (complexes), l, m, o (caractères spéciaux y ressemblant dans le catalogue). - Lorsque je le juge nécessaire (si il y a une interface avec des menus), j'affiche en mode graphique avec de petits caractères. Cela nécessite donc une reconfiguration de la fenêtre graphique et la désactivation des axes. Pour faire propre, dans un premier temps, j'ai donc sauvegardé la configuration graphique dans GDB0 avant de la modifier et je la restaurais en fin de programme. Mais la plupart des élèves ont déjà pris de mauvaises habitudes, comme le réflexe d'interrompre un programme par un appui sur "ON" au lieu d'utiliser "proprement" le menu quitter. Après cela, ils ne peuvent plus tracer "correctement" de graphiques... J'ai pu constater que ces réflexes sont difficiles à éradiquer. Donc maintenant, je restaure la configuration graphique dès que je ne suis plus en mode graphique (entrée de valeur par Input par exemple), pour diminuer la fréquence de ces problèmes. Désormais (sauf oubli de ma part), seul l'appui sur "ON" pendant un affichage graphique causera le problème. - Habituellement, mes interfaces graphiques sont quittables en appuyant sur "MODE", puisqu'il y a écrit "Quit" sur cette touche. - Comment convertir un nombre en chaîne de caractères? Comme déjà dit, le programme travaille sur des nombres, et doit renvoyer une chaîne de caractères... Donc, il faut faire une conversion quelque part! Conversion qui se doit d'être très rapide, car elle va être appellée plein de fois pour chaque composante de la forme exacte. J'ai choisi de détourner l'usage de la fonction statistique de régression linéaire, qui enregistre une équation de droite. Je fourni donc des données statistiques "simplifiées", pour que l'équation soit "Y=le nombre". Il y a ensuite une fonction dans le catalogue qui transforme l'équation en chaîne, dont on "découpe" la partie utile. 18) Différences d'algorithmes entre la version TI-82 Stats et la version TI-83+ : --------------------------------------------------------------------------- Le programmme est donc initialement développé sur TI-83+/84+. Une comparaison des listings basic, montrera que le code TI-82 Stats, n'est pour la majorité des programmes qu'une recopie du code TI-83+ modifié pour des petits détails par des "rechercher/remplacer" que je vais expliquer. - Comme déjà expliqué, l'ensemble de l'algorithme est basé sur la mise sous forme de fraction ou fraction de racine carrée, d'une transformation du résultat. Ces 2 sous-programmes (fraction, et racine carrée) se doivent donc d'être rapides. - Pour la mise sous forme de fraction simplifiée, il est vrai que la calculatrice les fait par défaut avec la fonction "->Frac". Mais cette fonction ne correspond qu'à un affichage, et je n'ai trouvé aucun moyen en basic, de récupérer le numérateur et le dénominateur. Il faut donc coder un algorithme de calcul. Pour la TI-82 Stats, c'est le programme Z1FRCBAS. Pour la TI-83+, j'ai trouvé un programme assembleur qui prend un nombre, le met en fraction et récupère numérateur et dénominateur dans 2 variables en une fraction (c'est le cas de le dire ;) de seconde. Il s'agit du programme ZFRAC écrit par Matthew Young, renommé ici Z1FRCASM. Je ne sais pas comment il fonctionne: soit c'est un algorithme similaire écrit en assembleur, soit il utilise la fonction "->Frac", et arrive à accéder aux résultats intermédiaires. Je n'ai hélas trouvé aucun programme équivalent sur TI-82 Stats. Si vous en trouvez un, contactez-moi!... Merci :) - Pour la mise sous forme de racine carrée simplifié, j'avais à l'origine une version améliorée en basic d'un algorithme que j'avais inventé et codé sur ma "TI-85" pour mon brevet. A quelques détails d'optimisation prêt (notamment les bornes de la boucle, et le pas), il s'agit de l'algorithme auquel tout programmeur logique va penser. Sur les 2 calculatrices, cet algorithme basic a été remplacé par une version assembleur plus rapide. Sur TI-83+, c'est le programme ZSURDASM renommé Z1RACASM, là encore écrit par Matthew young. Sur TI-82 Stats, c'est le programme ZRAD1 renommé encore Z1RACASM, écrit par Devin Gardner. 19) Astuce de mise en fraction d'un nombre : -------------------------------------- Si vous tentez d'utiliser la fonction "->Frac" (que semble utiliser Z1FRCASM), vous remarquerez que pour les gros nombres à mettre sous une fraction a/b, elle fonctionne beaucoup mieux si a>b. Par exemple: 9998/3 ->Frac = 10000/3, mais 3/9998 ->Frac = 0,000300060012... Faudrait-il donc appeller l'algorithme 2 fois pour être sûr?... Non! Si j'ai un nombre inférieur à 1 à mettre en fraction, j'en prends simplement l'inverse avant de faire appel à Z1FRCBAS ou Z1FRCASM, puisque ce cas-là marche plus souvent. J'inverse alors à nouveau le nombre à la fin si nécessaire. 20) Economisons encore de la mémoire : -------------------------------- Le pack complet fait autour de 10Ko, soit plus du tiers de la mémoire exécutable de la calculatrice. Pour la TI-82 Stats, il n'y a rien à faire de plus que ce que j'ai déjà dit... Pour la TI-83+, il y a la mémoire flash dite mémoire d'archive... Ah, voilà une bonne piste de recherche... Mais hélas, les programmes en mémoire d'archive ne sont pas exécutables directement. Il y a bien dans le catalogue des fonctions Archive et Unarchive, mais leur appel à l'intérieur d'un programme TI-Basic provoque une erreur... Elles semblent être réservées à l'utilisation en ligne de commande. En cherchant un peu, on trouve des programmes assembleur pour achiver et désarchiver... Ah, on chauffe... Mais cela cause encore 2 petits problèmes: - En théorie, la mémoire de type flash (comme le bios des ordinateurs) ne peut être réécrite qu'un nombre fini de fois: autour de 100000. Sur ordinateur, comme on ne met (normalement) pas son bios à jour des milliers de fois, aucun danger... Sur calculatrice, il y a 12 programmes dans ce pack. Si on considère une scolarité scientifique complète de la Seconde à la Terminale, avec une utilisation d'AUTOCALC de plus en plus fréquente par jour (surtout en Première puis Terminale), plus toutes les autres manipulations que peut faire un élève, les 100000 écritures ne sont plus un fantasme... C'est une réalité! En pratique, on ne devrait pas atteindre ce nombre, mais la mémoire flash sera presque usée à la fin du lycée. - Autre problème, l'archivage ou le désarchivage d'un programme peut entraîner la défragmentation immédiate de la mémoire d'archive, ce qui prendra un moment... Ce serait stressant en examen de contempler le message "Defragmenting..." pendant 1 minute... En cherchant encore, j'ai trouvé mieux: un programme assembleur non pas qui désarchive et réarchive, mais copie temporairement un programme archivé en mémoire. C'est le programme RESOURCE de Johan Rydh, renommé ici ZRESOURC, et accompagné ici de ZRESRCES qui est une simple boucle pour copier une liste de programmes. Cette méthode évite l'usure de la mémoire flash, et les défragmentations intempestives. Le pack pour "TI-83+" intègre donc ce programme. Tous les programmes sont archivés sauf 3: - un lanceur AUTOCALC qui contient la liste des programmes d'archive à copier en mémoire, la fournir à ZRESRCES, et exécute le dernier - le programme ZRESRCES - le programme ZRESOURC Le tout n'occupe que 1Ko en mémoire exécutable. Pendant l'exécution, les sous-programmes sont copiés en mémoire exécutable sous le nom TEMP+numéro, et le tout passe à 10Ko. En fin de programme (si le programme est quitté proprement dans les menus), les programmes TEMPs sont effacés, et l'utilisateur dispose à nouveau de 10Ko supplémentaires pour enregistrer ou exécuter d'autres programmes. 21) Liste des fichiers à transférer et description ---------------------------------------------- TI-82 Stats | TI-83+ | Description ----------------+---------------+---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- | AUTOCALC.8xp | Lance le programme suivant après avoir recopié les programmes archivés en mémoire. AUTOCALC.83p | Y1AUTO.8xp | Affiche le menu pour choisir le programme à exécuter. Y1AUTOCA.83p | Y1AUTOCA.8xp | Exécute la calculatrice symbolique en boucle (Troisième à Terminale et au-delà). Y1POLYST.83p | Y1POLYST.8Xp | Résoud les équations du 2nd degré (Première, Terminale et au-delà). Y1PRINTO.83p | Y1PRINTO.8xp | La boucle principale du moteur d'affichage exact. Y1SYSTEM.83p | Y1SYSTEM.8xp | Résoud les systèmes d'équations linéaires. Z1EXP.83p | Z1EXP.8xp | Met un nommbre sous la forme (11). Z1FRAC.83p | Z1FRAC.8xp | Inverse le nombre s'il est plus petit que 1, appelle le programme suivant pour mettre en fraction, teste si le résultat est acceptable et l'enregistre dans les bonnes variables. Z1FRCBAS.83p | Z1FRCASM.8xp | Met un nombre sous forme de fraction simplifiée (Basic sur TI-82 Stats, assembleur sur TI-83+). Z1NUMSTR.83p | Z1NUMSTR.8xp | Convertit un nombre en chaîne de caractères. Z1RACASM.83p | Z1RACASM.8xp | Met un nombre sous forme de racine carrée simplifiée (assembleur). Z1RACFRA.83p | Z1RACFRA.8xp | Teste dans l'ordre si un nombre peut se mettre en fraction, fraction de racine, ou fraction de Pi. Z1RAX.83p | Z1RAX.8xp | Met un nombre sous la forme (7) (somme d'une fraction décimale, et d'une fraction décimale de racine) décrite plus haut. | ZRESOURC.8xp | Copie un programme archivé en mémoire exécutable. | ZRESRCES.8xp | Boucle appellant le programme précédent sur une liste de programmes. En utilisation normale, il faut tout transmettre et lancer AUTOCALC. Si il y a des besoins spécifiques, on ne peut transmettre qu'une partie des programmes. Il faut transmettre: - tous les programmes commençant par Z, plus Y1PRINTO, pour avoir le moteur de calculs exacts fonctionnel. - Y1AUTOCA si on veut en plus la calculatrice exacte. - Y1POLYST si on vaut en plus résoudre des équations du 2nd degré. - Y1SYSTEM si on veut en plus résoudre des systèmes d'équations linéaires. Sur Ti-82 Stats, cela suffit si on veut se passer du menu et économiser de la mémoire. Sur TI-83+, il faut encore envoyer AUTOCALC et Y1AUTO (copie en mémoire des programmes archivés qui lance automatiquement le menu principal). Si on veut économiser de la mémoire et ne pas transmettre le menu, il faut programmer un lanceur en s'inspirant d'AUTOCALC, qui va copier en mémoire les programmes nécessaires, et lancer le dernier: calculatrice (Y1AUTOCA), second degré (Y1POLYSTO), systèmes (Y1SYSTEM), et ou même directement le moteur (Y1PRINTO). Je reste à l'écoute de toute question ou remarque, Xavier ANDREANI andreanx@hotmail.com