• emacs lisp et (- 0.07 0.18) et aussi SBCL

    From kaliderus@21:1/5 to All on Sun Oct 24 18:50:01 2021
    Bonjour la liste,

    J'avais déjà remarqué ce phénomène, et voici ce que me donne le
    résultat mentionné en objet
    (- 0.07 0.18)
    dans emacs : -0.10999999999999999
    avec SBCL : -0.11000001

    Quelqu'un saurait-il me dire pourquoi ?
    Ce que je pourrai éventuellement comprendre avec des très grands
    nombres par exemple, ou des valeurs franchement exotiques, mais avec
    des valeurs qui doivent être réelles et qui ne dépassent pas la
    capacité mémoire de la machine, chaque implémentation devrait me
    semble-t-il donner le même résultat, et qui plus est exact...
    Je suis apprenti en common lisp.

    Merci à chacun.

    --- SoupGate-Win32 v1.05
    * Origin: fsxNet Usenet Gateway (21:1/5)
  • From =?utf-8?Q?=C3=89tienne?= Mollier@21:1/5 to All on Sun Oct 24 19:10:02 2021
    Bonjour,

    Basile Starynkevitch, on 2021-10-24:
    On 24/10/2021 18:44, kaliderus wrote:
    J'avais déjà remarqué ce phénomène, et voici ce que me donne le résultat mentionné en objet
    (- 0.07 0.18)
    dans emacs : -0.10999999999999999
    avec SBCL : -0.11000001
    […]
    Si j'ai bonne mémoire, la norme Common Lisp impose le calcul en bignums ou nombres à précision arbitrairement grande.

    Alors que GNU emacs utilise des flottants IEEE754.

    Le petit programme ci-dessous permet de voir ce qu'il se passe :

    #include <stdio.h>
    int main(int argc, char *argv[])
    {
    printf("double: %0.32f\n", (double)0.07 - (double)0.18);
    printf("float: %0.32f\n", (float)0.07 - (float)0.18);
    return (0);
    }

    Un fois compilé et exécuté, on retrouve les erreurs de précision
    issues des arrondis flottants mentionnés par Basile :

    double: -0.10999999999999998667732370449812
    float: -0.11000000685453414916992187500000

    Empiriquement, emacs ferait donc ses calculs en virgule
    flottante double précision, et SBCL en simple.

    Bonne journée, :)
    --
    Étienne Mollier <emollier@emlwks999.eu>
    Fingerprint: 8f91 b227 c7d6 f2b1 948c 8236 793c f67e 8f0d 11da
    Sent from /dev/pts/2, please excuse my verbosity.

    -----BEGIN PGP SIGNATURE-----

    iQIzBAABCgAdFiEEj5GyJ8fW8rGUjII2eTz2fo8NEdoFAmF1kpUACgkQeTz2fo8N EdpXcA//bYhrh6L19ym/JiWI5cAqHW08XnLW9O15ZGcubtl6ETkon08+DIiIaBWO HnVZfhJTc8VwM0GGF+PBkLuFRizn7ZROu/feViK6Y9m2BjTqZBGlSThC6aADmg0r m1IhC5M3aq/ffG5lS5r17HVjCPb+ro8rBv2JalpQNmYyNDYP3z/QGhjuiBXTxYdu gZpa3Zcvjx2A8ZuB5frZHAbh3JQed/upjjCXWwsvntwc77v/Lohz0I1vkJR00Co1 Urr0FYtaCTParlFsqLKPFODYJqceGaf/gbf9qhol4XeP1ZzvbRTISpLtY5T7Oe+5 9qrvvZ8IACGznOEfv9C0E1CVlRcadwAhiqs9hZPhmTqn3R0c1sb7jhOFXXtt0+75 nzjJYq4bNKClRYKoDv4cuvtmnzSzEMSVuNOCNgYUKT1L7u5/niTeZW5W7c0IK6b4 K0Alt58jxANT1zdSHow5odzRBItifmxuRsALOJrWaldsiYynIcnSG5MvBfLK/wfp R/Na1JKF01WuOslU1edIvF/+IAn4a8BYcjQSqWKC2Ov1NXprG3czXr3/nJ/AEyMH zjRs6MfklXGjM/+zn5gq5rub2W2P7rH7/a+bhJ5DuAOL/lGK7+NHdx0hzSrC4jsw c6sd5j1gp1XDYctpkeh4BtFPFJ/NCuk6in/nKQ7KxJhb5oDa52M=
    =kvgb
    -----END PGP SIGNATURE-----

    --- Sou
  • From Basile Starynkevitch@21:1/5 to kaliderus on Sun Oct 24 19:00:01 2021
    On 24/10/2021 18:44, kaliderus wrote:
    Bonjour la liste,

    J'avais déjà remarqué ce phénomène, et voici ce que me donne le résultat mentionné en objet
    (- 0.07 0.18)
    dans emacs : -0.10999999999999999
    avec SBCL : -0.11000001

    Quelqu'un saurait-il me dire pourquoi ?
    Ce que je pourrai éventuellement comprendre avec des très grands
    nombres par exemple, ou des valeurs franchement exotiques, mais avec
    des valeurs qui doivent être réelles et qui ne dépassent pas la
    capacité mémoire de la machine, chaque implémentation devrait me semble-t-il donner le même résultat, et qui plus est exact...
    Je suis apprenti en common lisp.

    Merci à chacun.


    Si j'ai bonne mémoire, la norme Common Lisp impose le calcul en bignums
    ou nombres à précision arbitrairement grande.

    Alors que GNU emacs utilise des flottants IEEE754.

    La lecture des codes sources respectifs devrait confirmer cette intuition.

    Et le livre de Christian Queinnec https://pages.lip6.fr/Christian.Queinnec/WWW/LiSP.html est une lecture conseillée.


    --
    Basile Starynkevitch <basile@starynkevitch.net>
    (only mine opinions / les opinions sont miennes uniquement)
    92340 Bourg-la-Reine, France
    web page: starynkevitch.net/Basile/

    --- SoupGate-Win32 v1.05
    * Origin: fsxNet Usenet Gateway (21:1/5)
  • From nicolas.patrois@gmail.com@21:1/5 to All on Sun Oct 24 19:00:02 2021
    Le 24/10/2021 18:44:28, kaliderus a écrit :

    J'avais déjà remarqué ce phénomène, et voici ce que me donne le résultat mentionné en objet
    (- 0.07 0.18)
    dans emacs : -0.10999999999999999
    avec SBCL : -0.11000001

    Quelqu'un saurait-il me dire pourquoi ?

    Et en Python 3 :
    0.07-0.18
    -0.10999999999999999

    On dirait que SBCL utilise une moins grande précision dans la représentation des flottants.
    Oui, le problème vient du fait que 0,07 n’est pas un nombre binaire à virgule (comme 1/3 n’est pas un nombre décimal).
    Donc il y a une approximation.

    nicolas patrois : pts noir asocial
    --
    RÉALISME

    M : Qu'est-ce qu'il nous faudrait pour qu'on nous considère comme des humains ? Un cerveau plus gros ?
    P : Non... Une carte bleue suffirait...

    --- SoupGate-Win32 v1.05
    * Origin: fsxNet Usenet Gateway (21:1/5)
  • From kaliderus@21:1/5 to All on Mon Oct 25 00:50:02 2021
    Si j'ai bonne mémoire, la norme Common Lisp impose le calcul en bignums
    ou nombres à précision arbitrairement grande.

    Alors que GNU emacs utilise des flottants IEEE754.

    J'imaginais ce genre de chose :-/
    Et donc si quelqu'un veut faire par exemple du bancaire derrière, ou
    juste avoir un calcul exact (ce qui est mon cas), que lui conseiller ? J'imagine utiliser une librairie adéquate (je n'ai pas encore
    chercher), ou existe-t-il une solution au niveau du langage ?

    https://pages.lip6.fr/Christian.Queinnec/WWW/LiSP.html est une lecture conseillée.

    Merci pour le lien !

    --- SoupGate-Win32 v1.05
    * Origin: fsxNet Usenet Gateway (21:1/5)
  • From Marc Chantreux@21:1/5 to All on Mon Oct 25 09:10:02 2021
    salut,

    Le Mon, Oct 25, 2021 at 08:14:04AM +0200, nicolas.patrois@gmail.com a écrit :
    Tu utilises un langage où les flottants sont des décimaux (ça doit
    bien exister) ou tu utilises Python avec le module decimal.

    Puisqu'on est dans les scheme/lisp: c'est le cas de chicken:

    dpkg -S $(realpath $(which csi ))

    chicken-bin: /usr/bin/csi

    <<. csi
    (display (- 0.07 .11))
    .

    CHICKEN
    (c) 2008-2020, The CHICKEN Team
    (c) 2000-2007, Felix L. Winkelmann
    Version 5.2.0 (rev 317468e4)
    linux-unix-gnu-x86-64 [ 64bit dload ptables ]
    -0.04

    mais pour faire des maths, j'ai une grosse préférence pour raku (https://raku.org/)
    * les fractions sont conservées sous la forme de fraction
    * les metaoperators simplifient vraiment le boulot

    a+
    --
    Marc Chantreux
    Direction du numérique
    Pôle de Calcul et Services Avancés à la Recherche (CESAR) http://annuaire.unistra.fr/p/20200

    --- SoupGate-Win32 v1.05
    * Origin: fsxNet Usenet Gateway (21:1/5)
  • From Basile Starynkevitch@21:1/5 to nicolas.patrois@gmail.com on Mon Oct 25 08:30:01 2021
    On 25/10/2021 08:14, nicolas.patrois@gmail.com wrote:
    Le 25/10/2021 00:42:11, kaliderus a écrit :

    J'imaginais ce genre de chose :-/
    Et donc si quelqu'un veut faire par exemple du bancaire derrière, ou
    juste avoir un calcul exact (ce qui est mon cas), que lui conseiller ?
    J'imagine utiliser une librairie adéquate (je n'ai pas encore
    chercher), ou existe-t-il une solution au niveau du langage ?
    Tu utilises un langage où les flottants sont des décimaux (ça doit bien exister) ou tu utilises Python avec le module decimal.


    Je n'y connais rien en informatique de gestion, mais j'aurais tendance à conseiller de représenter un montant en € par un nombre entier (sur 64
    bits, donc uint64_t en C) de centimes d'€.

    Il me semble que 2 puissance 63 centimes d'€ c'est bien plus que la
    masse monétaire mondiale.


    Les calculs sont alors justes, et on pourrait les prouver avec Frama-C
    (voir https://frama-c.com/ et prévoir d'annoter le code source avec des annotations en ACSL; bien sûr, ça a un coût humain) ou peut-être avec un greffon de GCC comme Bismon (voir https://github.com/bstarynk/bismon/ et
    le projet DECODER voir https://decoder-project.eu/ ...)


    On pourrait aussi générer le code avec des outils tels que RefPerSys
    (voir http://refpersys.org/ ...)


    N'hésitez pas à me contacter par courriel vers
    <basile@starynkevitch.net> et <basile.starynkevitch@cea.fr> pour avoir
    des détails et des contacts.

    Librement.

    --
    Basile Starynkevitch <basile@starynkevitch.net>
    (only mine opinions / les opinions sont miennes uniquement)
    92340 Bourg-la-Reine, France
    web page: starynkevitch.net/Basile/

    --- SoupGate-Win32 v1.05
    * Origin: fsxNet Usenet Gateway (21:1/5)
  • From nicolas.patrois@gmail.com@21:1/5 to All on Mon Oct 25 08:20:02 2021
    Le 25/10/2021 00:42:11, kaliderus a écrit :

    J'imaginais ce genre de chose :-/
    Et donc si quelqu'un veut faire par exemple du bancaire derrière, ou
    juste avoir un calcul exact (ce qui est mon cas), que lui conseiller ? J'imagine utiliser une librairie adéquate (je n'ai pas encore
    chercher), ou existe-t-il une solution au niveau du langage ?

    Tu utilises un langage où les flottants sont des décimaux (ça doit bien exister) ou tu utilises Python avec le module decimal.

    nicolas patrois : pts noir asocial
    --
    RÉALISME

    M : Qu'est-ce qu'il nous faudrait pour qu'on nous considère comme des humains ? Un cerveau plus gros ?
    P : Non... Une carte bleue suffirait...

    --- SoupGate-Win32 v1.05
    * Origin: fsxNet Usenet Gateway (21:1/5)
  • From Basile Starynkevitch@21:1/5 to Marc Chantreux on Mon Oct 25 09:20:02 2021
    On 25/10/2021 08:58, Marc Chantreux wrote:
    salut,

    Le Mon, Oct 25, 2021 at 08:14:04AM +0200, nicolas.patrois@gmail.com a écrit :
    Tu utilises un langage où les flottants sont des décimaux (ça doit
    bien exister) ou tu utilises Python avec le module decimal.
    Puisqu'on est dans les scheme/lisp: c'est le cas de chicken:

    dpkg -S $(realpath $(which csi ))

    chicken-bin: /usr/bin/csi

    <<. csi
    (display (- 0.07 .11))
    .

    CHICKEN
    (c) 2008-2020, The CHICKEN Team
    (c) 2000-2007, Felix L. Winkelmann
    Version 5.2.0 (rev 317468e4)
    linux-unix-gnu-x86-64 [ 64bit dload ptables ]
    -0.04

    mais pour faire des maths, j'ai une grosse préférence pour raku (https://raku.org/)
    * les fractions sont conservées sous la forme de fraction
    * les metaoperators simplifient vraiment le boulot


    Dans la veine Lispienne, j'aurais tendance à suggérer Bigloo.

    http://www-sop.inria.fr/mimosa/fp/Bigloo/


    C'est développé en France.... par Manuel Serrano et ses collègues.


    --
    Basile Starynkevitch <basile@starynkevitch.net>
    (only mine opinions / les opinions sont miennes uniquement)
    92340 Bourg-la-Reine, France
    web page: starynkevitch.net/Basile/

    --- SoupGate-Win32 v1.05
    * Origin: fsxNet Usenet Gateway (21:1/5)