Quand on pense que c'est... - Page 1

Mathematica, logiciel de calcul formel à 3 185€, qui est derrière ce magnifique résultat

Ça ne s'affiche pas ici, c'est censé montrer quoi ?

Tu as reporté le bug ?

Zerosquare (./2) :
Ça ne s'affiche pas ici, c'est censé montrer quoi ?

1+ceil((0.8-.1)/0.1) = 9

alors que 0.8-0.1 ça fait 0.7, que si tu divises ça par 0.1 c'est comme le multiplier par 10, ça fait 7 et t'ajoutes 1 ça fait 8, pas 9...

Wat ? Et tu sais pourquoi ça donne ce résultat ?

les calculs en binaires ne doivent pas donner un résultat exact (mais légèrement au-dessus de 8)

)/(1/10))A priori 1+ceil((8/10-1/10 fonctionne correctement, donc c'est bien un classique problème de valeur approchée de nombre binaires en virgule flottante.
Utiliser la virgule flottante avec un logiciel de calcul formel, ça me parait quand même antinomique.

(mal lu le post d'Uther, en fait il a déjà répondu)

Probablement un truc du genre : "s'il y a un nombre avec une virgule, alors l'évaluation se fait en mode approché" (c'est assez idiot).

Zerosquare (./7) :
EDIT : râh, cross. Ou alors il y a un réglage qui fait que le soft travaille en mode approché.

Bah comme sur TI : 0.1 force l'utilisation de la virgule flottante (contrairement à 1/10)

Je ne connais pas le logiciel, mais suivant le niveau de technicité des utilisateurs et le besoin de performance, ça me parait pas forcément idiot pour que les nombres à virgules soient considérés comme valeur approchées et de devoir utiliser des fractions pour avoir des résultats formels. A condition que ça soit bien documenté.

(j'ai édité, j'avais mal lu, Uther répond à la question. Et on arrive tous à la même conclusion probable ^^)

Faut utiliser un logiciel plus performant

Quoique en y réfléchissant, l'erreur est probablement pire que je pensais au premier abord. Il serai compréhensible que 0.7 / 0.1 retourne un résultat du style 6.9999999 qui soit tronqué à 6. Mais là le résultat du ceil est 8 donc l'erreur est difficilement explicable.
edit : confondu ceil et floor

Par sûr que le résultat du Ceil soit faux.
Dans Alternative Representations, dans le bas de la page, on voit ça : 1+ceiling((0.8-0.1)/0.1) = 2+IntegerPart[0.7/0.1]
Ca serait marrant de voir d'où sort ce 2 magique.

(oui, je sais que c'est un problème de conversion binaire, mais ça n’excuse rien du tout. La fonction ceil est formellement définie. Il n'y a pas d’ambiguïté. Tout autre résultat est formellement inacceptable...sans parler de la façon dont il présente le résultat comme étant LE résultat ! Xcas n'a pas ce problème : http://www.xcasenligne.fr/giac_online/demoGiacPhp.php ).

Maxima, Qalculate!, KAlgebra et SAGE donnent tous le résultat correct 8 (testé avec Cantor).
(Pour Maxima et KAlgebra, il faut écrire ceiling à la place de ceil.)

Et que dit zs ?

En revanche, Yacas…

[16:15] <Kevin_Kofler> !yacas 1+Ceil((0.8-.1)/0.1)[16:15] <tigcc_bot> > 9;

L'explication est simple :
Est-ce que (0.8-.1)/0.1 est un entier ? Non, ça fait 7,0000000000000009.

PpHd (./14) :
(oui, je sais que c'est un problème de conversion binaire, mais ça n’excuse rien du tout. La fonction ceil est formellement définie. Il n'y a pas d’ambiguïté. Tout autre résultat est formellement inacceptable...sans parler de la façon dont il présente le résultat comme étant LE résultat ! Xcas n'a pas ce problème : http://www.xcasenligne.fr/giac_online/demoGiacPhp.php ).

Pour moi le résultat bien que mathématiquement aberrant, est techniquement correct si Mathematica a bien documenté que les calculs en virgule flottante sont fait en valeur approchés et non formels.
la fonction ceil() fait bien l'opération spécifiée, c'est visiblement la valeur qu'elle a en entrée qui n'est pas celle que tu attends a cause de l’imprécision des calculs en virgule flottante.

Uther (./19) :
Pour moi le résultat est correct si Mathematica a documenté que les calculs en virgule flottante sont approchés et non formels. Ceil fait bien l'opération spécifiée, c'est la valeur qu'elle a en entrée qui n'est pas celle que tu attends a cause de l’imprécision des calculs en virgule flottante.

Le résultat qu'il donne est 9 = nine =1 brique + 8 brique, et non pas le flottant 9,0. C'est donc totalement faux. Ne lui cherche pas d'excuse. On n'est plus dans les années 70.

Uther
Si c'est documenté, ce n'est pas un bug, c'est un choix de conception discutable (et à mon avis pas judicieux, c'est plus sûr de ne faire de la virgule flottante que quand l'utilisateur l'a explicité demandé).
Pareil pour le fait d'afficher différemment 9.0 au lieu de 9 pour un flottant : c'est ce que fait AMS, mais c'est peut-être pas le choix qu'a fait Mathematica.

Après, je ne dis pas ça pour toi (), mais Mathematica est censé être utilisé par des gens qui savent que si un logiciel affiche "truc", ça n'en fait pas forcément LE résultat, ne serait-ce que parce que le logiciel peut avoir ses limites ou avoir été mal configuré.

(enfin bon, PpHd nous fait un remake de sa discussion-troll avec Kevin sur AMS vs le système de calcul formel des HP, une dizaine d'années plus tard ^^)

https://reference.wolfram.com/language/tutorial/ExactAndApproximateResults.html

Dès qu'il y a un point, c'est un calcul approché qui est réalisé.

Mais est-ce que ça fonctionne en sens inverse, à savoir "si le résultat est approché, il est forcément affiché avec un point" ?
(ça a l'air tiré par les cheveux, mais on ne sait jamais)

Zerosquare (./21) :
Si c'est documenté, ce n'est pas un bug, c'est un choix de conception discutable (et à mon avis pas judicieux, c'est plus sûr de ne faire de la virgule flottante que quand l'utilisateur l'a explicité demandé).

Un choix de conception n'est pas incompatible d'être aussi un bug.

Pareil pour le fait d'afficher différemment 9.0 au lieu de 9 pour un flottant : c'est ce que fait AMS, mais c'est peut-être pas le choix qu'a fait Mathematica.

Là c'est grave comme choix si c'est le cas. (mais je ne crois pas que ça le soit).

mais Mathematica est censé être utilisé par des gens qui savent que si un logiciel affiche "truc", ça n'en fait pas forcément LE résultat

Oh que Non !

PpHd (./24) :

Zerosquare (./21) :
Si c'est documenté, ce n'est pas un bug, c'est un choix de conception discutable (et à mon avis pas judicieux, c'est plus sûr de ne faire de la virgule flottante que quand l'utilisateur l'a explicité demandé).

Un choix de conception n'est pas incompatible d'être aussi un bug.

On a pas la même définition de bug, alors. Si tu classes comme "bug" tout ce qui est contraire à l'intuition d'un utilisateur, ton bug-tracker doit être pris d'assaut (note que je n'ai pas dit que ce ne sont pas des problèmes).

PpHd (./24) :

mais Mathematica est censé être utilisé par des gens qui savent que si un logiciel affiche "truc", ça n'en fait pas forcément LE résultat

Oh que Non !

J'ai écrit "censé", je ne suis pas Nil et je sais bien que c'est très imparfaitement vérifié en réalité
Mais indépendamment du comportement critiquable de Mathematica sur ce point, quelqu'un qui achète un soft spécialisé comme ça et qui se plante à cause d'un truc qui est dans la doc (qu'il n'a pas lue), il peut aussi s'en prendre à lui-même. Attendre d'un soft qu'il te donne LE résultat et lui faire une confiance totale sans creuser, c'est une attitude dangereuse (et les bons profs l'expliquent aux étudiants).

Zerosquare (./25) :
Si tu classes comme "bug" tout ce qui est contraire à l'intuition d'un utilisateur, ton bug-tracker doit être pris d'assaut

Et pourtant non.

Mais indépendamment du comportement critiquable de Mathematica sur ce point, quelqu'un qui achète un soft spécialisé comme ça et qui se plante à cause d'un truc qui est dans la doc (qu'il n'a pas lue), il peut aussi s'en prendre à lui-même. Attendre d'un soft qu'il te donne LE résultat et lui faire une confiance totale sans creuser, c'est une attitude dangereuse (et les bons profs l'expliquent aux étudiants).

Tu devrais voir la page et la présentation du résultat... Ensuite pour être parfaitement juste, c'est de "wolfram alpha" qui utilise mathematica, et pas mathemica, dont on parle.

PpHd (./26) :
Et pourtant non.

Quelle argumentation

PpHd (./26) :
Tu devrais voir la page et la présentation du résultat...

Elle s'affiche pas ici.

En attendant, tu leur as signalé le problème ?

Zerosquare (./27) :
En attendant, tu leur as signalé le problème ?

Oui

PpHd (./20) :
Le résultat qu'il donne est 9 = nine =1 brique + 8 brique, et non pas le flottant 9,0. C'est donc totalement faux. Ne lui cherche pas d'excuse. On n'est plus dans les années 70.

A priori c'est correct si on part du principe que ceil(7,0000000000000009) fait bien exactement 8.
On pourrait éventuellement dire que ça fait 8.0 pour signaler que le résultat provient d'une valeur approchée. Mais si on fait un ceil, c'est généralement parce que l'on veut retomber sur des valeurs exactes et au final ça ne changerait pas l’écart.
Bref en mathematica comme en programmation, les flottants c'est le bordel, et mieux vaux ne pas les utiliser à mois d'y être contraint et de savoir exactement ce que l'on fait.

Zerosquare (./21) :
c'est un choix de conception discutable (et à mon avis pas judicieux, c'est plus sûr de ne faire de la virgule flottante que quand l'utilisateur l'a explicité demandé).

Je ne connais pas le profil de l'utilisateur moyen de cet outil, mais le choix est en effet certainement mauvais.
Même parmi mes collègues développeurs, la majorité comprend très mal voire pas du tout le fonctionnement des nombre flottants binaires. Alors si le profil des utilisateurs est plutôt orienté mathématique il y a fort a parier qu'il ne comprendront pas ce qui se passe.

Tiens, j'aurais plutôt dit que les "matheux" seraient plus susceptibles de comprendre les flottants et les problèmes associés que les "dévs" : quand on creuse, c'est quelque chose de beaucoup plus proche des mathématiques "pures" que de l'info appliquée. Mais je ne sais pas si ceux qui ont un cursus "matheux" sont familiarisés à ces questions (en 2016, avec des ordinateurs partout, on pourrait l'espérer, mais...)