Les membres ayant 30 points peuvent parler sur les canaux annonces, projets et hs du chat.
La shoutbox n'est pas chargée par défaut pour des raisons de performances. Cliquez pour charger.
Menu
Calculatrices
Graph 35 à 100
Graph 25+Pro/25+E/25+E II
Graph 35+USB/75(+E)/85/95 SD
Graph 100(+)
Classpad 300/330(+)
fx-CG 10/20 (Prizm)
Classpad 400(+E)
Graph 90+E
fx-92+ SC
Liens
¤ Transférer un programme sur
sa calculatrice

¤ Vous cherchez une fonction ?
Cours/E-activities >> Graph 35 à 100 >> Maths >> Calcul Limites
Calcul Limites
Version : B2 Taille : 3508 octets Ajouté le : 2019-02-15 21:28 Modifié le : 2023-03-15 20:47
Auteur et posteur :
ThebigbadboyHors ligneMaître du PuzzlePoints: 455 Défis: 16 Message
Planète Casio - Cours Casio de maths - Calcul Limites - TheBigBadBoy - Calculatrices
Nombre de visites sur cette page : 28120
Score au progrank : 43
Note actuelle : 9/10 noté 2 fois
Vous devez être connecté(e) pour noter (inscription).
7712 téléchargements | Soumettre un test

Ce programme est sous licence Creative Commons 2.0 BY


Description en français :

/!\ Les versions précédentes sont obsolètes ! Cette mise à jour est un programme réécrit de A À Z (plus dans Historique des versions) /!\

This description is available in English.

N'hésitez pas à envoyer des commentaires, questions, ou encore notes !

Le programme fonctionne parfaitement sur Casio Graph 35+E, Graph 75(+E), et Graph 90+E (Dites-moi si le programme fonctionne aussi sur des autres modèles !)


Le programme sert à calculer les limites de fonctions en ± ∞, en un réel - et calcule automatiquement toute asymptote horizontale, verticale ou oblique !
Les réponses obtenues peuvent être exprimées sous forme fractionnaire - avec ou non un facteur π (en appuyant sur F1). Par exemple lim (x→-∞)(arctg x) = -π/2.
N'hésitez pas à regarder le menu Help.

Utilisation (LISEZ-MOI)
Cliquer pour enrouler
Ce programme utilise les variables A~P & X, Y1, f1~f2, et le radiant.
Dans le menu du programme "LIMITES", entrez une nouvelle fonction afin de calculer sa limite. Si cette fonction est déjà présente dans Y1, appuyez sur (2) dans le menu . Vous pouvez donc utiliser des constantes dans vos fonctions qui ne sont pas utilisées par le programme, et les sous-appels à d'autres fonctions (graphiques) sont bien évidemment possibles.

Vous devrez toujours sélectionner les limites à calculer : à gauche et/ou à droite d'une abscisse; en + et/ou - ∞. Après la résolution de celle(s)-ci, il vous est possible d'exprimer la réponse obtenue sous forme fractionnaire, avec ou non un facteur π, en appuyant sur la touche (F1). Cela peut être 23/25 comme -2π/9. Utilisation du programme Number to Fraction. N'hésitez pas à en abuser, car une réponse "1.1" peut cacher la fraction "7π/20" !
Ce résultat fractionnaire n'est pas affiché automatiquement, car peut créer quelques pépins pour des valeurs entières.

Les limites en un réel se calculent quasi instantanément (et prend en compte les "sauts" possible de la fonction dus à la précision de calcul), et les asymptotes verticales sont détectées et affichées automatiquement.

Les limites en l'infini demandent plus de temps : environ 15~20 secondes pour les fonctions normales/classiques (par exemple sin log x) contre ~50 secondes (voire plus) pour des méchantes.
Le programme gère les erreurs math - dépassements arithmétiques ! Par exemple la limite de la fonction X^X^X donne une bonne réponse en + et -∞ (le dépassement arithmétique se faisant à X=10).


Fonctions non supportées (LISEZ-MOI)
Cliquer pour enrouler
Toutes les fonctions présentes dans le menu OPTN→CALC (excepté Int÷ et Rmdr) ne peuvent être utilisées pour une limite en ∞, ou une Erreur Syntaxe arrêtera le programme.
Ces fonctions sont donc : Solve, d/dx, d²/dx², ∫dx, SolveN, FMin, FMax, Σ, logab.

Les limites en un réel quant à elles fonctionnent avec absolument toutes les fonctions.

Malheureusement, quelques - très - rares limites ne sauraient être résolues correctement, ce qui est le cas par exemple de lim (x → +∞) (tan x). Le problème vient du fait que cette fonction effectue des sauts de trop grande ampleur en des abscisses fort rapprochées.
N'hésitez pas à me dire si vous trouvez une autre limite dans le même cas !


Algorithmes
Cliquer pour enrouler
- Limites en un réel :
Appelons R l'abscisse vers laquelle tend x, et f(x) la fonction sur laquelle porte la limite. On itère à partir de f(R-ln 0.97) - ln 0.97 ~= 0.03 - en divisant par 2 le logarithme chaque fois, jusqu'à ce que :
# cette division (ln/2) atteigne 1E-9
# les images de 2 itérations successives ont une différence inférieure à 1E-5 (la réponse à la limite sera donc un réel)
# la valeur absolue d'une image est supérieure à 1E20
# un saut a été détecté (=erreur de la calculatrice) : si la différence des images de 2 itérations décroît, puis que la nouvelle différence est plus grande d'un facteur 6/5 et enfin que la différence des images de la prochaine itération est strictement nulle, alors la boucle est arrêtée avec les infos d'avant ce saut (image et différence). Cela est utile par exemple pour la fonction "(1-cos x)/x²" (qui n'est pas la seule !) : f(1E-6) donne 0, alors que ~ 1/2 est attendu
Une fois sorti de la boucle, la dernière différence définit si le résultat de la limite est un réel (<0.1) ou un infini (>0.1).

- Limites en l'infini :
Ici on procède par étapes :
# on établit d'abord l'abscisse maximale de la fonction à ne pas dépasser (avant une Erreur Math).
# on calcule si la limite a un sens/existe (pas comme sin x) grâce à une série de FMax FMin sur 2 domaines : un réduit (typiquement de 34 à 35k), qui nous sert à délimiter les bornes des images, et l'autre à sa suite jusqu'à l'abscisse max du point précédant. Si un minimum ET un max sont plus importants (ou ont une image égale) (à une erreur près), alors on considère la limite comme inexistante (elle ne possède donc pas de réponse)
# on passe quelques calculs si au plus un extremum a été retrouvé (à une erreur près) à une plus grande abscisse - sinon, les 2 extrema du domaine plus grand sont moins importants que ceux du réduit. La résultat de la limite sera un réel
# les cas encore non traités sont : les fonctions (dé)croissantes tendant vers un réel, et les fonctions tendant vers un infini. Pour les différencier, définir un seuil sur la pente (ou différence entre 2 images) n'est vraiment pas l'idéal (voir log log log x et 1E9/x). On va donc utiliser cette différence pour définir un seuil au niveau des images : si la fonction "passe de l'autre côté" de celui-ci, alors elle tend vers un infini
# des étapes supplémentaires sont nécessaires pour calculer : le réel vers lequel tend la fonction (dont je passe les détails) / l'asymptote horizontale possible / l'asymptote oblique possible.
# pour le calcul des 2 asymptotes, on considère chacune leur équation (avec des arrondis uniquement pour l'oblique). En gros on regarde si la fonction reste du même côté, et si oui alors il y a bien asymptote.

- Affichage arrondi du résultat :
J'utilise une fonction spécifique pour arrondir les valeurs à 1E-4 et ne garder que les 4 premiers chiffres significatifs. Il faut juste savoir que les E11 servent uniquement à jouer avec la précision des résultats temporaires de la calculatrice. Vu qu'elle n'enregistre que 15 chiffres significatifs, le E11 permet de "supprimer" les décimales trop petites. Vous n'aurez pas plus de commentaires de ma part .
10^Intg log Abs (X+Not X)×(RndFix(X,3)×10^-Intg log Abs (X+Not X)+E11-E11


- Affichage fractionnaire du résultat :
J'utilise aussi mon autre programme dans celui-ci Number to Fraction, avec une plus grosse erreur permettant de trouver la majorité des fractions sans pour autant avoir la valeur exacte de la limite. Crée quelques rares pépins qu'on ne voudrait pas forcément, mais je ne trouve pas ça dérangeant car ça se voit tout de suite qu'il y a eu un souci, et c'est l'utilisateur qui a cliqué sur le bouton pour effectuer cet affichage. On peut donc espérer qu'il le fasse uniquement sur des valeurs décentes !

Améliorations possibles
Cliquez pour recouvrir
Le programme, bien qu'il réponde correctement à énormément de limites, a ses propres faiblesses. Des idées pouvant possiblement améliorer son fonctionnement (des plus importantes aux moindres) :
- Ne plus le baser sur du calcul, mais sur une analyse de chaîne de caractères. Devrait être une très grosse amélioration. +: tan x ne poserait plus de problème; -: très long et compliqué à faire, car le but de mon programme est de supporter toutes les fonctions disponibles sur Casio (y compris les opérateurs booléens, les fonctions quasi jamais utilisées etc).
- Remplacer les arrondis effectués (par quoi, je ne sais pas x)
- Changer les facteurs d'itération (des limites en un réel = 1/2; et des limites en l'infini tendant vers un réel = 2) et les seuils d'erreurs. Je ne pense pas que cela apporte tellement de changement, et en plus les 2 se complètent l'un l'autre - (si un doit être changé, alors l' autre aussi).

Très certainement plein d'autres choses, mais j'ai oublié, vu le temps que la version A m'a prise ...


Historique des versions
Cliquer pour enrouler
Versions obsolètes
Versions obsolètes
Beta 3.0 Toute première version "publiée".
Les limites en ± ∞ sont séparées, une en + ∞ et une en - ∞

A 1.0
Les limites en ± ∞ sont ensembles

A 1.1
Possibilité de calculer les asymptotes obliques

2.0 (4444 octets)
Possibilité de calculer une limite en un réel seulement à droite ou seulement à gauche (lorsque la fonction contient √ ou *√ )

3.0 (env. 3200 / 3584 octets)
Possibilité de calculer une limite en ± ∞ seulement en + ∞ ou seulement en - ∞ (lorsque la fonction contient √ ou *√ )
Possibilité de calculer les asymptotes obliques seulement en + ∞ ou seulement en - ∞ (lorsque la fonction contient √ ou *√ )
Possibilité de copier la fonction entrée en Y1 (première fonction dans le menu Graph de votre calculatrice) !
Optimisations.

3.1 (env. 3200 / 3588 octets)
Si on calculait une asymptote oblique sans écrire de √ ou de *√ on obtenait seulement le résultat en -∞ en 3.0, mais plus maintenant.

4.0 (4188 / 4544 octets)
Possibilité de contourner les erreurs math avec les fonctions exponentielles.

5.0 (3352 / 3684 octets)
Support des fonctions exponentielles (plus de "contournement") sauf pour les asymptotes obliques.
Plus facile d'utilisation.
Reconnaissance de limites impossibles (ex : lim (x → +∞ ) (sin x) ).

5.1 (3536 / 3880 octets)
Support des fonctions exponentielles dans le menu asymptotes obliques.
Correction de quelques bugs de la 5.0.

6.0 (4096 octets)
Un peu de réaménagement au niveau du rendu (maintenant, tous les menus donnent d'abord en x →-∞ puis x → +∞), et aussi au niveau du code.
Le menu Lim x → ±∞ est beaucoup plus précis pour les asymptotes horizontales qu'avant, ce qui permet d'exprimer enfin les résultats obtenus avec des π en appuyant sur [F1] à la fin du calcul (par ex Lim (x→+∞) (arctg x) = 0+π.(1/2) ). Sous forme a+π.(b/c), a varie de -9 à 9; b de -11 à 11; et c de -12 à 12.
N'utilise plus que la fonction graphique Y1 - plus de chaînes de caractères - et demande maintenant à chaque fois s'il faut calculer la limite à gauche, à droite ou les 2.
Bonne reconnaissance des asymptotes horizontales (Lim (x→+∞) (sin x / x) ne possède pas d'A.H mais tend bien vers 0).
Plus de problème des limites en un réel (par ex Lim (x→0) (e^(1/x)) n'a plus d'erreur math ).

6.1 (4144 octets)
Corrections de multiples erreurs de calculs de la 6.0.....

6.2 (4168 octets)
Version 6.1 corrigée (on ne savait pas calculer les asymptotes obliques dû à une erreur de calcul… ).
On n'obtient plus d'erreur argument quand on utilise la fonction d'affichage avec des π (le texte dépassait de l'écran).
Besoin d'un peu moins de précision dans la fonction d'affichage avec des π (sans augmenter le risque d'erreur).

6.3 (4148 octets)
L'unique changement de cette version est la diminution de précision lors du calcul de limites en réel pour éviter les erreurs (ou plutôt fausse réponse) de la calculatrice elle-même. Ex. : calculer la fonction f(x) = (1 - cos x) / (x^2) avec x = 1E-6. Et la calculatrice vous donnera comme réponse 0 au lieu d'une valeur proche de 1/2 (qu'il faudrait obtenir). Le problème vient donc bien de la calculatrice et non du programme (celui-ci ne savait d'ailleurs pas comment interpréter ce résultat...).


Version A (3664 octets)
On peut bien considérer ça plus comme un nouveau programme qu'une mise à jour. En effet celui-ci a été réécrit totalement, jouant avec de nouveaux algorithmes. Les anciennes versions (devenues dès lors obsolètes - et de loin - par rapport à ce nouveau programme) reflétaient mon grand manque d'expérience et ma naïveté. Les études allant avec cette "mise à jour", j'ai acquis assez de connaissance à mon impression pour faire un programme décent. Veuillez m'excuser pour les bourdes commises auparavant. Notez que cette version A utilise maintenant les String afin de gérer les erreur math des dépassements arithmétiques (voir mon tuto). Il y a besoin de 6000 octets libres - seulement en mode x→∞ - (3k dans RECURRENCE et 3k pour Mat Ans). Si ceci n'est pas possible, on peut laisser appuyer la touche lors du choix du signe de ∞, cela prendra des abscisses par défaut d'abscisses pour calculer la limite. Notez que cette méthode est tout de même déconseillée.
Pour les limites en ∞, prend environ 15 secondes de calcul pour les fonction "classiques" et 55 sec pour les méchantes. Donne automatiquement tout ce qu'il y a à savoir sur une limite : asymptote horizontale, verticale, oblique, et possibilité d'obtenir la réponse à ces limites sous forme de fractions avec - ou non - un facteur π (petite modification du programme Number to Fraction).
Bien évidemment les limites en un réel se font quasi instantanément, et supportent aussi les sauts causés par la précision des calculs de la calculatrice (comme la fonction (1-cos x)/x² qd x→0).
Pour donner une idée, log log log x, sin log x, sin x*e^x et 1E9/x qd x→∞ donnent tous les 4 une bonne réponse .
Utilise les variables A~P, Str 1~2, Y1, f1~f2, et le radiant.

Version B (3520 octets)
Du plus important au moindre changement :
  • Beaucoup plus facile d'utilisation ! L'utilisateur ne doit plus tapoter ou maintenir suivant si la calto a 6 ko de mémoire libre. Finies les crampes
  • N'a plus du tout besoin des 6 ko ! En effet les fonctions de récurrence ont été jetées par-dessus bord ! Tout simplement : pour détecter les dépassement il y a plus simple et beaucoup moins lourd.
  • Résultat grandement affiné pour les limites en ∞ tendant vers des réels.
  • Plus de changement de priorité des opérations (le seul problème était les multiplications implicites).
  • N'utilise plus de String !
  • Plus d'Erreur math (limites en ∞) lorsque l'abscisse maximale (avant dépassement arithmétique de la fonction) est ≤ 5, fallait la vouloir celle-ci...
  • Les limites en ∞ sont considérées sans réponse si l'abscisse maximale est < 1.
  • Utilise une variable en plus : X. Saviez-vous que jusqu'ici le programme ne changeait pas sa valeur ?


Version B2 (3396+112 octets)
Correction d'une petite gaffe de la précédente version pour les limites en ∞ qui ont un dépassement arithmétique très petit (<10).
Toute limite ∞ de fonctions non définies au dessus d'une abscisse = 1 sont considérées indéfinies. Dès lors vous pouvez sélectionner les 2 signes ∞ (par ex pour log x) sans vous soucier d'une Erreur math (qui survenait dans les précédentes versions).


Je tiens à remercier LePhenixNoir, Manolo, Sentaro21 pour leur aide sur ce topic
Et merci à Totoyo pour son cours de programmation qui m'a bien aidé

Faites absolument ce que vous voulez de ce prog, tant que vous mettez un lien vers cette page-ci ! Merci ! CC 2.0 BY

English description:

Feel free to send comments, questions, or notes!

The program works perfectly on Casio Graph 35+E, Graph 75(+E), and Graph 90+E (Let me know if the program works on other models too!)


The program is used to calculate the limits of functions in ± ∞, in a real - and automatically calculates any horizontal, vertical, or oblique asymptote!
The answers obtained can be expressed in fractional form - with or without a π factor (by pressing F1). For example lim (x→-∞)(arctg x) = -π/2.
Feel free to look at the Help menu

Usage (READ ME)
Click to roll
This program uses the variables A~P & X, Y1, f1~f2, and the radiant.
In the "LIMITS" program menu, enter a new function to calculate its limit. If this function is already present in Y1, press (2) in the menu . You can use constants in your functions that are not used by the program, and sub-calls to other (graphical) functions are of course possible.

You will always have to select the limits to be calculated: to the left and/or right of an abscissa; in + and/or - ∞. After solving these, you can express the answer obtained in fractional form, with or without a π factor, by pressing the (F1) key. This can be 23/25 as well as -2π/9. Using my Number to Fraction program. Feel free to abuse it, because an answer "1.1" can hide the fraction "7π/20"!
This fractional result is not displayed automatically, as it can create some glitches for integer values.

The limits in one real are computed almost instantaneously (and takes into account the possible "jumps" of the function due to the computation precision), and the vertical asymptotes are detected and displayed automatically.

Limits in infinity require more time: about 15~20 seconds for normal/classical functions (e.g. sin log x) versus ~50 seconds (or more) for nasty ones.
The program handles math errors - arithmetic overshoots! For example the limit of the function X^X^X gives a good answer in +and -∞ (the arithmetic overshoot being at X=10)
.

Unsupported functions (READ ME)
Click to wrap
All functions present in the OPTN→CALC menu (except Int÷ and Rmdr) cannot be used for a limit in ∞, or a Syntax Error will stop the program.
These functions are therefore: Solve, d/dx, d²/dx², ∫dx, SolveN, FMin, FMax, Σ, logab.

As for the limits in a real, they work with absolutely all functions.

Unfortunately, some - very - rare limits cannot be solved correctly, which is the case for example of lim (x → +∞) (tan x). The problem comes from the fact that this function makes jumps of too large a magnitude at very close abscissas.
Don't hesitate to tell me if you find another limit in the same case!


Algorithms
Click to wrap
- Limits in a real:
Let's call R the abscissa to which x tends, and f(x) the function to which the limit relates. We iterate from f(R-ln 0.97) - ln 0.97 ~= 0.03 - dividing the logarithm by 2 each time, until :
# this division (ln/2) reaches 1E-9
# the images of 2 successive iterations have a difference lower than 1E-5 (the answer to the limit will thus be a real)
# the absolute value of an image is greater than 1E20
# a jump has been detected (=error of the calculator) : if the difference of the images of 2 iterations decreases, then the new difference is bigger by a factor 6/5 and finally the difference of the images of the next iteration is strictly null, then the loop is stopped with the information of before this jump (image and difference). This is useful for example for the function "(1-cos x)/x²" (which is not the only one !) : f(1E-6) gives 0, while ~ 1/2 is expected
Once out of the loop, the last difference defines whether the result of the limit is a real (<0.1) or an infinity (>0.1).

- Limits in infinity :
Here we proceed by steps:
# we first establish the maximum abscissa of the function not to be exceeded (before a Math Error).
# we calculate if the limit has a sense/exists (not like sin x) thanks to a series of FMax FMin on 2 domains : one reduced (typically from 34 to 35k), which is used to delimit the limits of the images, and the other one following it until the max abscissa of the previous point. If a minimum AND a max are larger (or have an equal image) (within an error), then the boundary is considered non-existent (so it has no answer)
# we pass some calculations if at most one extremum has been found (to within one error) at a larger abscissa - otherwise, the 2 extrema of the larger domain are less important than those of the reduced one. The result of the limit will be a real
# the cases not yet treated are: (de)increasing functions tending to a real, and functions tending to infinity. To differentiate them, defining a threshold on the slope (or difference between 2 images) is really not ideal (see log log log x and 1E9/x). So we will use this difference to define a threshold at the level of the images: if the function "passes on the other side" of this one, then it tends towards an infinity
# additional steps are necessary to compute : the real towards which the function tends (I skip the details) / the possible horizontal asymptote / the possible oblique asymptote.
# for the calculation of the 2 asymptotes, we consider each one their equation (with rounding only for the oblique one). Basically we look if the function stays on the same side, and if yes then there is an asymptote.

- Displaying the rounded result :
I use a specific function to round the values to 1E-4 and keep only the first 4 significant figures. You just have to know that the E11 are only used to play with the precision of the temporary results of the calculator. Since it only stores 15 significant digits, the E11 is used to "remove" decimals that are too small. You won't get any more comments from me .
10^Intg log Abs (X+Not X)×(RndFix(X,3)×10^-Intg log Abs (X+Not X)+E11-E11

- Fractional result display:
I also use my other program in this one Number to Fraction, with a bigger error allowing the majority of fractions to be found without having the exact value of the limit. Creates some rare glitches that you wouldn't necessarily want, but I don't find it annoying because you can tell right away that there was a glitch, and it was the user who clicked the button to make this display. So we can hope that he only does it on decent values!

Possible improvements
Cliquez pour recouvrir
The program, although it responds well to many limitations, has its own weaknesses. Ideas that could possibly improve its functioning (from the most important to the least):
- No longer base it on calculation, but on string analysis. Should be a very big improvement. +: tan x would not be a problem anymore; -: very long and complicated to do, because the goal of my program is to support all functions available on Casio (including boolean operators, functions almost never used etc).
- Replace the rounding done (by what, I don't know x)
- Change the iteration factors (limits in a real = 1/2; and limits in infinity tending to a real = 2) and the error thresholds. I don't think this makes that much of a change, and besides the 2 complement each other - (if one needs to be changed, then so does the other).

Most likely a lot of other things, but I forgot, since version A took me so long ...


If you want to see the version history, sorry but you'll have to see the page in French!


Do absolutely anything you want with this prog, as long as you link to this page! Thank you! CC 2.0 BY


Note sur 10 Commentaire Date de notation
9Très ergonomique, et quasiment incollable au niveau lycée ; à défaut d'un oracle, un très bon outil de vérification des calculs. (Lephe')Le 12.01.2022 à 13:03
9Mérite sa note rien que pour le travail apporté. Suffisant pour le lycée, ça donne une bonne idée de l'objectif :) - TituyaLe 12.01.2022 à 19:29

Commentaires :

Pages: Précédente | 1, 2, 3, 4, 5, 6, 7, 8, 9 | Suivante

ThebigbadboyHors ligneMaître du PuzzlePoints: 455 Défis: 16 Message
Posté le 25-12-2021 à 14:16 | #
J'aimerais juste si possible avoir un retour à propos de cette fonctionnalité :
TheBigBadBoy a écrit :
Le programme gère les erreurs math - dépassements arithmétiques - mais a besoin pour cela de 6000 octets libres sur votre calto SEULEMENT POUR LES LIMITES EN ∞ (voir mon tuto pour savoir pourquoi). Si vous obtenez une erreur mémoire, maintenez le bouton lors du choix du signe de l'infini, et vous verrez apparaître à l'écran [###]. Faites attention à bien TAPOTER lors de cette sélection dans le cas contraire.


Je veux dire par là : est-ce bien compréhensible ? Devrais-je changer la manière dont c'est expliqué, voire même l'implémentation dans le programme ?

Et si jamais le cœur en dit à quelqu'un, n'hésitez absolument pas à donner votre avis (même bref), ou encore mieux : à publier une note !

Je n'ai encore eu aucun retour sur ce programme, voilà donc la raison de ce message
ThebigbadboyHors ligneMaître du PuzzlePoints: 455 Défis: 16 Message
Posté le 12-01-2022 à 10:24 | #
Je pense avoir trouvé une meilleure approche vis-à-vis du "tapoter si [...]".
Je trouve en effet cette approche assez compliquée, soit à reproduire soit à comprendre (c'est une supposition bien entendu, vu que je n'ai pas eu de message sur ceci).

Donc après ma session, quand j'aurai le temps, je changerai cela : ce choix sera complètement supprimé, et par défaut le prog utilisera les fonctions récursives (pour détecter les dépassements arithmétiques). Si jamais il n'y avait pas assez de mémoire (~6 ko), alors bam vous verrez l'erreur, relancerez le prog et celui-ci saura qu'il y a eu un problème. Il entamera alors son exécution sans ce calcul de dépassements arithmétiques, offrant une moins bonne précision/fiabilité.

En espérant avoir fait le bon choix

Peut-être que j'en profiterai pour au passage enlever la contrainte "Il vous faut aussi ajouter des parenthèses pour les multiplications sans opérateur explicite. Par exemple au lieu d'entrer sin 3x, entrez sin (3x)."....
Eh oui je fais partie de ces gens qui foncent la première fois sans lire la notice d'utilisation
LephenixnoirEn ligneAdministrateurPoints: 24228 Défis: 170 Message
Posté le 12-01-2022 à 10:26 | #
Cette partie était la seule que je ne trouvais vraiment pas claire.

Pourquoi ne pas simplement donner l'option ? Du genre après avoir tapé la fonction il y a une touche optionnelle pour alterner entre récursif ou pas. Et puis une page d'aide. Ça me paraît plus simple, et plus logique avec ton interface, que l'heuristique un peu compliquée consistant à relancer le programme (ou le tapotement)
ThebigbadboyHors ligneMaître du PuzzlePoints: 455 Défis: 16 Message
Posté le 12-01-2022 à 11:43 | #
C'est vrai que donner le choix est possible en ajoutant un écran, je trouvais ça peut-être un peu répétitif (avoir 4 écrans de choix avant de pouvoir calculer enfin la limite, ça peut être long et lassant).

La page d'aide d'ailleurs existe déjà, aussi bien dans le programme que sur les spoilers de la descriptions du prog

Je vais y réfléchir donc...
LephenixnoirEn ligneAdministrateurPoints: 24228 Défis: 170 Message
Posté le 12-01-2022 à 11:44 | #
Peut-être pas en ajoutant un écran, mais en ajoutant une touche optionnelle sur un écran existant ? Ne serait-ce que l'écran où on choisit entre réel/fini où il reste pas mal de place. Par défaut s'il y a de la mémoire il n'y aurait rien à faire parce que récursif serait par défaut (?)
ThebigbadboyHors ligneMaître du PuzzlePoints: 455 Défis: 16 Message
Posté le 12-01-2022 à 12:20 | #
Ah d'accord je crois avoir compris ce que tu dis !

Par exemple, lors du choix du calcul de la limite en +, -, ±∞, correspondant aux touches 1, 2 et 3, on pourrait appuyer sur 0 (avant de choisir la limite) pour faire comprendre qu'on a malheureusement plus de mémoire libre

Je suis quand même bête d'avoir pensé à laisser appuyer la touche sans avoir pensé à faire une action avant le choix de la limite...

Merci

Et en effet oui, le truc récursif est à privilégier, car cela permet de savoir où il est préférable d'arrêter l'étude de la fonction donnée. Si ce mode n'est pas utilisé, on est pas à l'abri d'une erreur math à cause de 10^X par exemple
LephenixnoirEn ligneAdministrateurPoints: 24228 Défis: 170 Message
Posté le 12-01-2022 à 13:02 | #
Oui c'est ce que j'imaginais en effet !

Dans l'ensemble ton programme est quand même vachement bien fait, en plus un seul programme, relativement petit, c'est très clean
ThebigbadboyHors ligneMaître du PuzzlePoints: 455 Défis: 16 Message
Posté le 12-01-2022 à 14:35 | #
Merci beaucoup !

Ça fait plaisir d'avoir eu une note \o/

Et j'accorde une attention très particulière pour ce qui est du poids du code : même si ce qui prend le plus de place c'est le texte (menu Help etc), je me suis amusé à changer les variables entre-elles afin, par exemple, de les réinitialiser d'un coup (0→A~B), ou encore le genre d'optimisation de ce défi-ci : Optimisation et implémentation de condition.

Bref ça m'a pris du temps, mais j'adore ça
ThebigbadboyHors ligneMaître du PuzzlePoints: 455 Défis: 16 Message
Posté le 16-01-2022 à 11:01 | #
Pffffffffffffffffffffffffffffffffffffff........ on m'a dit que vous aimiez les pavés

Bon alors j'ai une grosse nouvelle : j'ai enfin trouvé un moyen beaucoup plus simple de connaître l'abscisse où s'effectue le dépassement arithmétique (et en plus général un moyen de connaître si en une certaine abscisse la fonction existe) !

De ce côté-là c'est super méga giga ultra cool, car la contrainte des 6 ko s'efface complètement, tout en gardant un temps d'exécution très rapide

De l'autre côté, j'ai perdu pas ma de temps à trouver des techniques sûrement trop "exotiques". Faut complètement oublier la récursion... Mais bon, c'est vrai que ça m'a permis de faire connaissance avec d'autres fonction Basic Casio allons-nous dire...

Algos obsolètes de recherche de dépassement arithmétique
Cliquer pour enrouler
C'est uniquement des recherches que j'ai faites, et que je trouvais bête d'avoir trouver ça et ne pas les écrire quelque part (elles sont à éviter, souvenez-vous en):

La première : celle utilisée dans la version A de Calcul Limites. On utilise la récursion, une des rares fonctions Basic Casio à supporter les Erreurs math (avec SolveN() et les dessins Graph). Grosso modo on fait une opération sur la string de la fonction f(x), et on remplace toute occurrence de "x" par "(3^n)" si l'on veut trouver le dépassement arithmétique avec une précision d'un facteur 3 ("n" étant la variable de récurrence - dans catalogue : "n(récur)", eh oui il y a plusieurs n différents en Basic Casio...).
Cela change l'ordre des opérations, et normalement seules les multiplications implicites : sin 3x devient sin 3(3^n) correspondant à sin 3×(3^n).
Un défaut en plus et non des moindres est la place occupée par cette récursion : utilise environ 5 ko de mémoire tous les 100 points calculés (la moitié dans l'app "Récur" et l'autre dans Mat Ans). Autant dire que même si c'est rapide ça pique ! Si vous avez plus de questions sur cette méthode, voir ce ce très mauvais tuto (oui c'est le mien ).

2e méthode : utilisation de SolveN(). Cette fonction Basic Casio a comme avantage de ne pas utiliser de mémoire (à part une possible List Ans de max 10 éléments réels). Bon je commence à avoir marre d'écrire donc je fais vite
{0
SolveN(0×Y1,X,A÷3,A

Ce qu'il y a juste au-dessus vous devriez pouvoir le deviner : on initialise A à 9E99, fait le SolveN, et si la fonction n'existe pas entre A÷3 et A List Ans est inchangée et contient "0". On divise A par 3 et on recommence.
Bien que ça aille relativement vite pour passez de A=9E99 à 1E50, si le dépassement arithmétique s'effectue entre les 2 bornes alors il faudra littéralement 2 minutes montre en main avant d'avoir une réponse (qui aura changé List Ans). SolveN() ne comprend certainement pas ce qu'il s'y passe


Bref : la nouvelle méthode me vient d'une révélation
On utilise toujours SolveN(), mais on fixe la variable X pour la fonction qu'on donne à SolveN.
Ce qui donne par exemple SolveN(X²,A : SolveN essaiera de trouver une variable A possible, mais on ne l'utilise même pas.
Avec cette méthode, on n'a plus aucun n'ennuis de mémoire utilisée ni de temps de calcul ! YOUPIIIIII
J'en ai vraiment marre d'écrire là, donc si vous avez des questions hésitez pas et en lisant peut-être le spoiler vous saurez trouver des réponses à vos questions

Je vais changer mon tuto, en mettant un lien vers ce message-ci.
ThebigbadboyHors ligneMaître du PuzzlePoints: 455 Défis: 16 Message
Posté le 16-01-2022 à 11:02 | #
Ah oui, et pour ceux qui se demandent : je commence à travailler sur la màj ce jeudi

Pages: Précédente | 1, 2, 3, 4, 5, 6, 7, 8, 9 | Suivante

Planète Casio v4.3 © créé par Neuronix et Muelsaco 2004 - 2024 | Il y a 80 connectés | Nous contacter | Qui sommes-nous ? | Licences et remerciements

Planète Casio est un site communautaire non affilié à Casio. Toute reproduction de Planète Casio, même partielle, est interdite.
Les programmes et autres publications présentes sur Planète Casio restent la propriété de leurs auteurs et peuvent être soumis à des licences ou copyrights.
CASIO est une marque déposée par CASIO Computer Co., Ltd