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).

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 !

- 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 !

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).

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)

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!

- 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!