Extraire la partie décimal d'un float/double sans cast

Bonjour à tous,

je suis toujours en train de coder une lib mathématique en C++ pour apprendre et pratiquer le langage, mais il se trouve que pour certaines fonctions (ceil, floor, around) j'ai besoin d'extraire la partie décimale du nombre, logiquement j'ai penser à un code comme celui ci :

1
2
3
4
5
6

float extract_decimal(float x)
{
    int   integer_part = static_cast<int>(x);
    float decimal_part = x - integer_part;
    return decimal_part;
}

mais il inclue un cast ce qui n'est pas très mal en soit mais ce serait mieux sans, ainsi est ma question :

Est-il possible d'écrire cette fonction sans cast ?

Je vous remercie d'avance de vos réponses et vous souhaite une bonne journée

je suis sur d'avoir déjà lu qu'il fallait éviter les cast sinon effectivement je rajoute les const et j'implémente ça. Merci de ta réponse

La valeur d'un float peut dépasser largement le maximum possible pour un int, donc cette solution n'est pas véritablement correcte AMHA.

du coup il vaudrait mieux un long int ?

Salut,

Même problème, la capacité d'un long int et même d'un long long int est largement insuffisante. Pour rappel, si le flottant est représenté suivant la norme IEEE 754 en simple précision, le maximum représentable est de l'ordre de $10^{38}$.

ah merde mince, du coup il y a pas une autre solution ?

Le truc, c'est que les plus grands flottants sont en fait des entiers (la précision ne permet pas d'avoir de décimales). Du coup, avec un branchement, tu peux éliminer ce cas là : si le flottant est grand, il n'y a rien à convertir. La glibc fait d'ailleurs quelque chose de similaire pour floor.

Mais oui je me disais bien que j'avais déjà trouvé une solution (en me brossant les dents), la partie décimale d'un nombre réel est le résultat du modulo de 1

par contre j'ai essayé sur python ça fait un truc bizarre

1
2
3
4
5
6
7
8

>>> x = 5.2
>>> type(x)
<class 'float'>
>>> y = x % 1
>>> type(y)
<class 'float'>
>>> print(y)
0.20000000000000018

juste d'où viennent les 1,8*10^-16 qui se sont rajouté ?

Sinon je me demandais à quoi servais fmod() mais je crois que j'ai trouvé, je ne savais pas que le modulo ne marchais pas avec les float et les double

Erreur d'arrondi. 5,2 n'est pas représentable de manière exacte ni dans un float, ni dans un double. Teste ça :

1

print(str.format('{:.50}',5.2))

ok d'accord

sinon il faut que je trouve comment coder fmod sans cast mais je trouve pas

je dois être fatigué vu la simplicité de la solution qui réside en une simple boucle

1
2
3
4
5
6
7

float math::fmod(float numer, float denom)
{
    while (numer > denom)
    numer -= denom;

    return numer;
}

Bon, ce n'est pas ce qui se fait de plus efficace non plus…

Je le sais bien mais à défaut d'autre chose c'est bien. (sinon si tu as quelque chose de plus efficace je suis preneur, enfin avec des explications parce que je déteste copier un code que je ne comprends pas)

Cela prendra surtout un temps infini si le nombre représenté est trop important (edit : bon, faut voir en Python vu qu'il utilise GMP derrière). En effet, vu la représentation des flottants, passez un certain stade, seuls les chiffres significatifs sont conservés.

 1
 2
 3
 4
 5
 6
 7
 8
 9
10

#include <float.h>
#include <stdio.h>


int
main(void)
{
    printf("%d\n", FLOAT_MAX == FLOAT_MAX - 1);
    return 0;
}

1

1

La même chose vaut en C++.

Édit : @Aabu : tu peux préciser ta pensée, je ne comprends pas bien ce que tu veux dire ?

Édit : @Aabu : tu peux préciser ta pensée, je ne comprends pas bien ce que tu veux dire ?

Quelle pensée ? Je disais juste que 5,2 n'est pas un flottant, et donc le réel est arrondi lorsqu'il est stocké. On peut le voir en affichant assez de décimales (ici en Python) :

1
2

>>> print(str.format('{:.21}',5.2)) # affiche un nombre avec 21 décimales
5.20000000000000017753

Cela explique que la partie fractionnaire donnée par Python (ou d'autres langages) traîne des décimales inattendues.

Ok merci je vais le coder mais juste sa veux dire quoi template<typename T> ?

PS: si vous voulez aller voir, le code est sur github

Du coup j'ai compris pour les template, donc je peux transformer ce code

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19

int math::abs(int const x)
{
    if (x == 0)
    return 0;
    else if (x > 0)
    return x;
    else
    return -x;
}

float math::abs(float const x)
{
    if (x == 0)
    return 0;
    else if (x > 0)
    return x;
    else
    return -x;
}

en celui là:

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20

template<typename T>
T math::abs(T const x)
{
    if (x == 0)
    return 0;
    else if (x > 0)
    return x;
    else
    return -x;
}

int math::abs(int const x)
{
    return math::abs<int>(x);
}

float math::abs(float const x)
{
    return math::abs<float>(x);
}

mais du coup je me pose une autre question qui est "est-ce que je peux limiter les types que ma template T peux avoir ?" (je veux pas que l'on essaye d'avoir la valeur absolue d'une string)