std:: fmod, std:: fmodf, std:: fmodl

Le reste en virgule flottante de l'opération de division x / y calculé par cette fonction est exactement la valeur x - iquot * y , où iquot est x / y avec sa partie fractionnaire tronquée.

La valeur retournée a le même signe que x et est inférieure à y en magnitude.

Paramètres

Valeur de retour

En cas de succès, retourne le reste en virgule flottante de la division x / y tel que défini ci-dessus.

Si une erreur de domaine se produit, une valeur définie par l'implémentation est retournée (NaN là où supporté).

Si une erreur de plage se produit en raison d'un dépassement inférieur, le résultat correct (après arrondi) est retourné.

Gestion des erreurs

Les erreurs sont signalées comme spécifié dans math_errhandling .

Une erreur de domaine peut survenir si y est nul.

Si l'implémentation prend en charge l'arithmétique à virgule flottante IEEE (IEC 60559),

• Si x est ±0 et y n'est pas zéro, ±0 est retourné.
• Si x est ±∞ et y n'est pas NaN, NaN est retourné et FE_INVALID est déclenché.
• Si y est ±0 et x n'est pas NaN, NaN est retourné et FE_INVALID est déclenché.
• Si y est ±∞ et x est fini, x est retourné.
• Si l'un des arguments est NaN, NaN est retourné.

Notes

POSIX exige qu'une erreur de domaine se produise si x est infini ou si y est zéro.

std::fmod , mais pas std::remainder , est utile pour effectuer un enroulement silencieux des types à virgule flottante vers les types entiers non signés : ( 0.0 <= ( y = std :: fmod ( std:: rint ( x ) , 65536.0 ) ) ? y : 65536.0 + y ) est dans l'intervalle [ - 0.0 , 65535.0 ] , ce qui correspond à unsigned short , mais std:: remainder ( std:: rint ( x ) , 65536.0 est dans l'intervalle [ - 32767.0 , + 32768.0 ] , ce qui est en dehors de l'intervalle de signed short .

La version double de std::fmod se comporte comme si elle était implémentée comme suit :

double fmod(double x, double y)
{
#pragma STDC FENV_ACCESS ON
    double result = std::remainder(std::fabs(x), y = std::fabs(y));
    if (std::signbit(result))
        result += y;
    return std::copysign(result, x);
}

L'expression x - std:: trunc ( x / y ) * y peut ne pas être égale à std :: fmod ( x, y ) , lorsque l'arrondi de x / y pour initialiser l'argument de std::trunc perd trop de précision (exemple : x = 30.508474576271183309 , y = 6.1016949152542370172 ).

Les surcharges supplémentaires ne sont pas tenues d'être fournies exactement comme (A) . Elles doivent seulement être suffisantes pour garantir que pour leur premier argument num1 et second argument num2 :

Exemple

#include <cfenv>
#include <cmath>
#include <iostream>
// #pragma STDC FENV_ACCESS ON
int main()
{
    std::cout << "fmod(+5.1, +3.0) = " << std::fmod(5.1, 3) << '\n'
              << "fmod(-5.1, +3.0) = " << std::fmod(-5.1, 3) << '\n'
              << "fmod(+5.1, -3.0) = " << std::fmod(5.1, -3) << '\n'
              << "fmod(-5.1, -3.0) = " << std::fmod(-5.1, -3) << '\n';
    // valeurs spéciales
    std::cout << "fmod(+0.0, 1.0) = " << std::fmod(0, 1) << '\n'
              << "fmod(-0.0, 1.0) = " << std::fmod(-0.0, 1) << '\n'
              << "fmod(5.1, Inf) = " << std::fmod(5.1, INFINITY) << '\n';
    // gestion des erreurs
    std::feclearexcept(FE_ALL_EXCEPT);
    std::cout << "fmod(+5.1, 0) = " << std::fmod(5.1, 0) << '\n';
    if (std::fetestexcept(FE_INVALID))
        std::cout << "    FE_INVALID déclenchée\n";
}

fmod(+5.1, +3.0) = 2.1
fmod(-5.1, +3.0) = -2.1
fmod(+5.1, -3.0) = 2.1
fmod(-5.1, -3.0) = -2.1
fmod(+0.0, 1.0) = 0
fmod(-0.0, 1.0) = -0
fmod(5.1, Inf) = 5.1
fmod(+5.1, 0) = -nan
    FE_INVALID déclenchée

Voir aussi