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

Donc à la fin sa fait ça

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11

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

Je vais chipoter mais ça manque d'assertion pour la pré-condition : abs(INT_MIN), c'est pas défini .

Je comprends pas ce que tu veux dire, peux-tu développer ou me passer une page de doc qui expliquerait cela ?

Ok j'ai compris, il faut que je lève une exception si x vaut INT_MIN ?

@Aabu : je parlais de ce message.

Si j'ai bien compris, ça veut simplement dire qu'un float trop grand devient trop imprécis, et qu'à une certaine limite, c'est forcément un nombre entier.

Pour illustrer :

1
2

float n = 1'000'000'000.123;
std::cout << std::fixed << n << std::endl;

1
2

$ clang++ -std=c++14 main.cpp && ./a.out
1000000000.000000

Donc ici, $ floor(n) = n $ .

Aah ! Ok, voilà qui est plus clair.
Merci pour cet éclaircissement.

Ok merci pour ces informations.

Edit : j'ai quand même une question, est-ce que ce cas ou -INT_MIN ne loge pas dans INT_MAX existe avec d'autres types (peut-être tous) ?

Reedit : D'après cette page de cppreference cela ne concerne que les entiers donc mon assert est comme ça

1

assert((is_integer<T>) ? x > numeric_limits<T>::min() : true)

Comme je n'ai plus de questions et que le sujet s'écarte fortement du problème d'origine je vais le mettre comme résolu et marqué les réponses qui mon aidées.

Merci à tous de vos réponses j’aurais beaucoup appris sur ce sujet

Edit : j'ai quand même une question, est-ce que ce cas ou -INT_MIN ne loge pas dans INT_MAX existe avec d'autres types (peut-être tous) ?

La norme n'offre aucune garantie sur la représentation des entiers signés, et donc sur les relations entre les bornes positives et négatives.

Mais à moins d'être sur une architecture ésotérique, les entiers signés sont représentés en complément à deux, ce qui signifie effectivement que - *_MIN n'est pas représentable.

Attention également aux exemples de cppreference, lorsqu'il est indiqué « possible output » cela signifie que le point en question dépend de l'implémentation.

Je retire ce que j'ai dit, j'ai un problème. Ma lib compile sans problème par contre mon code de test m'envoye des erreurs de référence indéfinie

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15

# ludovic at Tardis in ~workspace/C++/Math-library/test on git:master x [14:35:07]
$ make
[ 50%] Linking CXX executable bin/test_math
CMakeFiles/test_math.dir/src/main.cpp.o: dans la fonction « main »:
main.cpp:(.text+0x16): référence indéfinie vers « std::enable_if<std::is_arithmetic<int>::value, int>::type math::abs<int>(int) »
main.cpp:(.text+0x47): référence indéfinie vers « std::enable_if<std::is_arithmetic<double>::value, double>::type math::abs<double>(double) »
main.cpp:(.text+0x68): référence indéfinie vers « std::enable_if<std::is_arithmetic<int>::value, int>::type math::abs<int>(int) »
../lib/libmath.so: référence indéfinie vers « std::enable_if<std::is_arithmetic<float>::value, float>::type math::abs<float>(float) »
collect2: erreur : ld a retourné 1 code d'état d'exécution
CMakeFiles/test_math.dir/build.make:94 : la recette pour la cible « bin/test_math » a échouée
make[2]: *** [bin/test_math] Erreur 1
CMakeFiles/Makefile2:67 : la recette pour la cible « CMakeFiles/test_math.dir/all » a échouée
make[1]: *** [CMakeFiles/test_math.dir/all] Erreur 2
Makefile:83 : la recette pour la cible « all » a échouée
make: *** [all] Erreur 2

voici mon main pour le test, le reste du code est sur github

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

#include <iostream>
#include <limits>
#include <libmath/math.h>

using std::cout;
using std::cin;
using std::cerr;
using std::endl;


int main()
{
    int i = std::numeric_limits<int>::min();

    cout << math::abs(-2) << endl;
    cout << math::abs(-2.3434) << endl;
    cout << math::abs(i) << endl;

    return 0;
}

C'est bon ça marche, cette fois je met le sujet en résolu pour de bon, une fois de plus merci à tous ceux qui y ont participé.

HS: J'ai jeté un coup d’œil à ton GitHub, et il y a un truc que je comprends pas trop : si c'est juste pour t'entraîner, pourquoi t'ennuyer à tout écrire en Anglais ? Car il y a tout de même pas mal de fautes dérangeantes (bon après tu me diras que c'est pour entraîner ton Anglais).

Ensuite, je suis de loin pas expert avec Git, mais si c'est un projet perso, tu n'est pas forcément obligé de commiter chaque petit changement (surtout si au final c'est pour se retrouver avec des messages comme "yolo" ou "pardon j'ai sauvegardé après avoir indexé" ). Essaie de rassembler les différentes modifications qui ont un lien commun, et si besoin commite avec un message de plusieurs lignes (une ligne courte qui résume, une ligne vide, un pavé qui détail le commit).

D'ailleurs, pense à ajouter l'option -a quand tu commites pour indexer automatiquement tous les fichiers suivis, comme ça tu n'as même plus besoin de faire git add. Et si au pire tu foires un commit, tu peux le "refaire" avec l'option --amend (vu que tu es le seul collaborateur, c'est pas très grave).

Voilou, c'était les conseils du soir sur Git.

@Guigz12 il y a effectivement une erreur mais je pense que c'est juste un oubli de la part d'Olybri.

En fait ce résultat avec 12 et 3 s'explique au fait que la dernière boucle a cette condition d'arrêt num > den et qu'il manque juste un égal, du coup sur cette exemple comme 12 est multiple de 3 à la dernière itération on à 3 > 3 ce qui est faux et donc arrête la boucle avant de retourner 3. Sinon merci de l'avoir remarqué et signalé.

J'avais pas pris en compte la condition d'arrêt de la première boucle… Pour effectivement 12 ça marche.

Du coup c'est plus subtil que ça mais ce n'est quand même pas juste mathématiquement. Contre-exemple : 140 % 7 = 0 mais avec cette fonction on obtient après la premiere boucle num = 40 et donc comme résultat 1.

Pour faire la division euclidienne c'est à peu près la même fonction.

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

template<typename T>
T mod(T num, T den)
{
    unsigned reste{};
    while(num > 10)
    {
        unsigned a{};
        unsigned b{};
        //calcule le digit le plus à gauche du dividande
        while(num / pow(10, ++a) > 10);
        while(num / pow(10, a) - ++b > 1);

        //mis a jour du reste
        reste = reste * 10 + b

        //suppression du digit le plus à gauche
        num -= pow(10, a) * b;

        //calcul du nouveau reste (on ne calcule pas le quotien mais il suffit de compter le nombre de tours de boucle)
        while(reste > den)
            reste -= den
    }
    return reste;
}

D'après la division euclidienne on retrouve bien le modulo. Je pense que ça répond au problème. Désolé si j'ai fait des erreurs de syntaxe, je n'ai jamais fait de C++.

Pour les lignes 13-14, effectivement, c'est une erreur. En fait il suffirait de modifier l'opérateur de comparaison et avoir num >= den.

Cependant, je n'ai pas assez réfléchi et en fait, les lignes 4-11 sont stupides, car elles ne fonctionnent qu'avec den = 1 ou den = 10 etc… Donc cette fonction-là n'a pas trop d'intérêt (si ce n'est pour être réécrite en fonction floor). Sur le coup, je vois pas comment corriger le truc.

Je crois que tu as dû oublier un truc. Tu fais des opérations sur num mais après tu ne l'utilises plus. Du coup ça ne fonctionne pas (testé avec 2345 par 6). Je suis pas assez expert en maths pour voir comment coder la chose.

Oui je suis allé un peu vite.

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31

template<typename T>
T mod(T num, T den)
{
    unsigned reste{};
    while(num >= 10)
    {
        unsigned a{};
        unsigned b{};
        //calcule le digit le plus à gauche du dividande
        while(num / pow(10, ++a) > 10);
        while(num / pow(10, a) - ++b > 1);

        //mis a jour du reste
        reste = reste * 10 + b

        //calcul du nouveau reste (on ne calcule pas le quotien mais il suffit de compter le nombre de tours de boucle)
        while(reste > den)
            reste -= den

        //suppression du digit le plus à gauche
        num -= pow(10, a) * b;
    }
    //mis a jour du reste
    reste = reste * 10 + num

    //calcul du nouveau reste
    while(reste > den)
        reste -= den

    return reste;
}

C'est pas très beau mais vous avez compris l'idée.