Limite de la calculatrice

PrOf
PrOf
dans Pédagogie, enseignement, orientation
Bonjour à tous,

Je souhaiterais faire comprendre aux élèves qu'il faut se méfier de la calculatrice et leur faire prendre conscience de ses limites.
En ce moment, nous travaillons sur les écritures fractionnaires.
Je cherche pour cela deux fractions à priori égales qui, lorsqu'on effectue les divisions à la calculatrice, donnent les même résultats.
Mais lorsque on effectue la différence de ces deux résultats, on obtient un nombre non nul, ce qui me permettrait de leur montrer qu'à priori les fractions étaient égales mais qu'en réalité ce n'est pas le cas.
D'où la méfiance vis à vis de l'outil.

Y'aurait-il des personnes qui connaîtraient des fractions qui se prêteraient à ce genre d' "activité" ?

Je vous remercie pour votre aide,
PrOf.

Réponses

  • sebsheep
    sebsheep
    En général, les calculatrices travaillent avec 15 chiffres significatifs maximum. Il suffit de trouver 2 fractions qui diffèrent de 10^(-17) (histoire d'être sûr) pour avoir un bug. Et là, même en faisant la soustraction des deux, on trouve 0.
  • sebsheep
    sebsheep
    A moins que la calto ne fasse un peu de calcul formel représente les fractions de façon exacte et qu'au lieu de calculer une approximation de a/b puis de c/d et enfin fasse la différence des deux, elle calcule (ad-cb)/bd.
  • Professeur Rectangle
    Professeur Rectangle
    Une calculatrice, même sans faire de calcul formel, peut faire du calcul exact sur les rationnels.

    La question c'est la représentation des nombres sur la calculatrice. S'ils sont représentés sous forme de nombres flottants, on peut trouver des exemples, mais si la calculatrice utilise une représentation exacte des nombres rationnels, elle ne fera jamais d'erreur.
  • sebsheep
    sebsheep
    jamais d'erreur, jamais d'erreur c'est vite dit ! Il y a toujours le problème du "dépassement de capacité" ; je n'ai jamais trouvé de calculatrice qui réponde correctement à (10^20 +1) - 10^20.
  • soland
    soland
    30476
  • Professeur Rectangle
    Professeur Rectangle
    jamais d'erreur, jamais d'erreur c'est vite dit ! Il y a toujours le problème du "dépassement de capacité" ; je n'ai jamais trouvé de calculatrice qui réponde correctement à (10^20 +1) - 10^20.

    En représentant les rationnels par des couples d'entiers (numérateurs/dénominateurs) il faut vraiment de très très grands nombres pour dépasser la capacité de la machine.
    Pour représenter 10^20 sous forme d'entier, il faut à minima 68 bits (car $\log_2(10^{20})\approx 66,4 $). C'est un peut plus que ce qui se fait d'habitude (64 bits) mais c'est tout à fait faisable sur une machine qui calcule avec de grands entiers.

    Python (utilisé par exemple en ISN en terminale), le résultat est exact.
    Certes, Python tourne sur un ordinateur, mais il existe probablement des calculatrices qui y arrivent aussi.
  • sebsheep
    sebsheep
    La gestion de grands entiers est assez lourde (même si on reste avec des "petits" nombres, il faut tester à chaque opération si on ne dépasse pas pour pouvoir agrandir la structure le cas échéant), à l'heure actuelle je pense qu'aucune calculette ne l'implémente (ou alors c'est très récent et je serai ravi qu'on me montre un contre exemple :p ).

    Le fait que python l'implémente nativement et de façon transparente (sans action spécifique de l'utilisateur) rend ce langage très souple, mais il faut voir que ce n'est pas la norme (C++, java, php, javascript, fortran, matlab, ocaml ...). Je ne connais que 3 langages qui permettent cela : python, ruby et haskell.
  • Professeur Rectangle
    Professeur Rectangle
    Il y a des exemples plus simple :
    1) faire une division qui ne tombe pas juste
    2) remultiplier par le dénominateur

    Par exemple, avec une précision de 28 chiffres après la virgule en base 10, j'ai :
    (1/7+1)*7 = 8.000000000000000000000000001

    Pour les calculs sur ordinateurs en base 2 (avec des flottants 64 bits), en prenant des nombres à virgule au hasard, on trouve des erreurs :
    3.11+1.5 = 4.609999999999999
    L'erreur vient de l'arrondi lors de la conversion de la base 10 à la base 2.
  • Guego
    Guego
    Il suffit de simuler des choses sensibles aux erreurs d'arrondis. Il y a quelques temps, j'avais vu (je ne sais plus où) une suite dont on peut montrer qu'elle converge vers $1$, alors que sur n'importe quelle calculatrice, elle va avoir tendance à converger vers $2$ (à cause des erreurs d'arrondis)

    Un peu dans le même genre : je prends la suite $(u_n)$ définie par $u_0 = 0.73$ et $u_{n+1} = 4u_n(1-u_n)$. Je demande à maple (pour qui on peut régler la précision de calcul) de calculer $u_{1000}$ :
    En faisant les calculs avec $10$ chiffres significatifs : 
    > print(u[1000]);
0.4000570080
    Avec $20$ chiffres significatifs : 
    > print(u[1000]);
0.035681811441585541085
    Avec $30$ chiffres significatifs : 
    > print(u[1000]);
0.860718525904952022452369617592
    Avec $40$ chiffres significatifs : 
    > print(u[1000]);
0.9993539732179854841737208062879646081320
    Avec $50$ chiffres significatifs : 
    > print(u[1000]);
0.72101346615364967581684915711328714514792700705368

    J'imagine que si on le programme sur les calculatrices des élèves, on va avoir autant de résultats que de modèles différents de calculatrices dans la classe.
  • Rosalie
    Rosalie
    Bonjour.
    Il est un peu dommage de s'échiner à calculer la différence des deux fractions pour montrer qu'elles ne sont pas égales. Les produits en croix et la détermination du chiffre des unités de chacun d'entre eux s'avère être une méthode plus élégante.
    Cordialement.
  • nicolas.patrois
    nicolas.patrois
    $\frac{1}{\sqrt{x+1}-\sqrt{x}}$ si $x$ est assez grand donne un résultat amusant alors que c’est égal à $\sqrt{x+1}+\sqrt{x}$.
    Algebraic symbols are used when you do not know what you are talking about.
            -- Schnoebelen, Philippe
  • Professeur Rectangle
    Professeur Rectangle
    Le fait que python l'implémente nativement et de
    façon transparente (sans action spécifique de
    l'utilisateur) rend ce langage très souple, mais
    il faut voir que ce n'est pas la norme (C++, java,
    php, javascript, fortran, matlab, ocaml ...). Je
    ne connais que 3 langages qui permettent cela :
    python, ruby et haskell.
    Certes, mais ces langages implémentent les grands entiers via une bibliothèque.
    On peut aussi ajouter Mathematica et Maple à la liste Python, Ruby et Haskell.

    La vraie raison pour laquelle il y a des erreurs de calculs, c'est parce que ces erreurs permettent d'aller plus vite, d'utiliser moins d'espace en mémoire. Ce n'est pas une limitation intrinsèque de la machine, mais un choix de représentation des nombres.
    C'est un peu comme un être humain qui déciderait de faire des arrondis pour se simplifier les calculs. Il pourrait tout aussi bien choisir de ne pas faire d'approximation.

    J'ai un élève qui a l'une des toutes dernières TI. J'ai eu l'impression qu'elle savait faire du calcul rationnel, mais je n'ai pas réellement vérifié.
  • Aleg
    Aleg
    Bonjour,

    A propos des inconvénients des calculs numériques menés sur calculatrice ou ordinateur, je vous joins, à titre d'exemple, l'énoncé d'un de mes td d'algo (en Python) que je fais en BTS SIO (il s'agit d'un fichier pdf obtenu à partir de Beamer, que je projette sur écran en salle info).
    td3.pdf 130.5K
  • Guego
    Guego
    J'ai retrouvé la suite dont je parlais dans mon précédent message (les valeurs sont un peu différentes) :
    $u_0 = 2$, $u_1=-4$ et $u_{n+2} = 111 - \dfrac{1130}{u_{n+1}} + \dfrac{3000}{u_{n+1}u_n}$
    On peut montrer que $u_n = \dfrac{4\times5^{n+1}-3\times6^{n+1}}{4\times5^{n}-3\times6^{n}}$, ce qui permet de voir que $u_n$ converge vers $6$ lorsque $n$ tend vers $+\infty$.
    Pourtant, simulation sur un tableur :
    30478
  • Aleg
    Aleg
    Oui, Guego, c'est la suite de Muller (voir exo 8 de mon td) !
  • PrOf
    PrOf
    Merci pour vos réponses :)

    @ Soland : ca marche en effet, mais comment as-tu fait pour les trouver ? Il y a une méthode ?

    @ Rosalie : si Je leur faire effectuer la soustraction, c'est parce qu'ils n'ont pas encore vu le produit en croix.
    A toute chose il y a une explication raisonnable :)
  • sebsheep
    sebsheep
    Ce qui est surprenant c'est que sur les 15 premiers termes, on a l'impression que le tableur calcule bien et qu'il va effectivement faire converger la suite vers 6... et trois itérations plus loin, on a déjà explosé !
  • hal0
    hal0
    Voilà une excellente motivation pour apprendre à programmer l'arithmétique multiprécision. De l'algorithmique, de la vraie. :)
  • Gilles old
    Gilles old
    Quelle belle trouvaille cette suite de Muller, merci !
  • tonton golden
    tonton golden
    Bonjour PrOf,

    Une méthode possible pour obtenir des fractions très proches.
    Une suite récurrente du type u ( 0 ) à choisir et u ( n + 1 ) = ( 1 / 2 ) ( u ( n ) + 2 / u ( n ) ).
    Cette suite " classique " converge vers racine carrée de 2 très vite pourvu que u ( 0 ) > 0.
    Exemple 1 : u ( 0 ) = 14 / 10 . Au bout de quelques termes u ( n ) est un rationnel très proche de racine carrée de 2.
    Exemple 2 : u ( 0 ) = 15 / 10 . Au bout de quelques termes u ( n ) est un rationnel très proche de racine carrée de 2.
    Les deux termes de rang 3 devraient faire l'affaire pour ton problème.

    Autre question pour les élèves si la racine carrée est connue :
    u ( 3 ) est-il égal à racine carrée de 2 ?
    Passage au carré, produit en croix, utilisation du chiffre des unités suffisent pour conclure que non.

    Cordialement.
Connectez-vous ou Inscrivez-vous pour répondre.

Bonjour!

Pour participer au forum, cliquer sur l'un des boutons :

Connexion S'inscrire

Catégories

In this Discussion

Qui est en ligne 4

Amadou +3 Invités