Namespaces
Variants

std:: remainder, std:: remainderf, std:: remainderl

From cppreference.net
C++
Numerics library
Common mathematical functions
Nearest integer floating point operations
(C++11)
(C++11)
(C++11) (C++11) (C++11)
Floating point manipulation functions
(C++11) (C++11)
(C++11)
(C++11)
Classification and comparison
(C++11)
(C++11)
(C++11)
(C++11)
(C++11)
(C++11)
Types
(C++11)
(C++11)
(C++11)
Macro constants
Défini dans l'en-tête <cmath>
(1)
float remainder ( float x, float y ) ;

double remainder ( double x, double y ) ;

long double remainder ( long double x, long double y ) ;
(jusqu'à C++23)
constexpr /*floating-point-type*/

remainder ( /*floating-point-type*/ x,

/*floating-point-type*/ y ) ;
(depuis C++23)
float remainderf ( float x, float y ) ;
(2) (depuis C++11)
(constexpr depuis C++23)
long double remainderl ( long double x, long double y ) ;
(3) (depuis C++11)
(constexpr depuis C++23)
Surcharge SIMD (depuis C++26)
Défini dans l'en-tête <simd>
template < class V0, class V1 >

constexpr /*math-common-simd-t*/ < V0, V1 >

remainder ( const V0 & v_x, const V1 & v_y ) ;
(S) (depuis C++26)
Défini dans l'en-tête <cmath>
template < class Integer >
double remainder ( Integer x, Integer y ) ;
(A) (constexpr depuis C++23)
1-3) Calcule le reste IEEE de l'opération de division en virgule flottante x / y . La bibliothèque fournit des surcharges de std::remainder pour tous les types en virgule flottante non qualifiés cv comme type des paramètres. (depuis C++23)
S) La surcharge SIMD effectue un std::remainder élément par élément sur v_x et v_y .
(Voir math-common-simd-t pour sa définition.)
(depuis C++26)
A) Des surcharges supplémentaires sont fournies pour tous les types entiers, qui sont traités comme double .
(depuis C++11)

Le reste en virgule flottante IEEE de l'opération de division x / y calculé par cette fonction est exactement la valeur x - quo * y , où la valeur quo est la valeur intégrale la plus proche de la valeur exacte x / y . Lorsque |quo - x / y| = ½ , la valeur quo est choisie paire.

Contrairement à std::fmod , la valeur retournée n'est pas garantie d'avoir le même signe que x .

Si la valeur retournée est zéro, elle aura le même signe que x .

Table des matières

Paramètres

x, y - valeurs à virgule flottante ou entières

Valeur de retour

En cas de succès, retourne le reste en virgule flottante IEEE 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 est retourné.

Si y est nul, mais que l'erreur de domaine ne se produit pas, zéro 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),

  • Le mode d'arrondi actuel n'a aucun effet.
  • FE_INEXACT n'est jamais déclenchée, le résultat est toujours exact.
  • Si x est ±∞ et y n'est pas NaN, NaN est retourné et FE_INVALID est déclenchée.
  • Si y est ±0 et x n'est pas NaN, NaN est retourné et FE_INVALID est déclenchée.
  • 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 .

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 :

  • Si num1 ou num2 a le type long double , alors std :: remainder ( num1, num2 ) a le même effet que std :: remainder ( static_cast < long double > ( num1 ) ,
    static_cast < long double > ( num2 ) )     .
  • Sinon, si num1 et/ou num2 a le type double ou un type entier, alors std :: remainder ( num1, num2 ) a le même effet que std :: remainder ( static_cast < double > ( num1 ) ,
    static_cast < double > ( num2 ) )     .
  • Sinon, si num1 ou num2 a le type float , alors std :: remainder ( num1, num2 ) a le même effet que std :: remainder ( static_cast < float > ( num1 ) ,
    static_cast < float > ( num2 ) )     .
(jusqu'en C++23)

Si num1 et num2 ont des types arithmétiques, alors std :: remainder ( num1, num2 ) a le même effet que std :: remainder ( static_cast < /*common-floating-point-type*/ > ( num1 ) ,
static_cast < /*common-floating-point-type*/ > ( num2 ) ) , où /*common-floating-point-type*/ est le type à virgule flottante ayant le plus grand rang de conversion en virgule flottante et la plus grande sous-catégorie de conversion en virgule flottante entre les types de num1 et num2 , les arguments de type entier sont considérés comme ayant le même rang de conversion en virgule flottante que double .

Si aucun tel type à virgule flottante avec le plus grand rang et la plus grande sous-catégorie n'existe, alors la résolution de surcharge ne résulte pas en un candidat utilisable parmi les surcharges fournies.

(depuis C++23)

Exemple

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

Sortie possible : 

remainder(+5.1, +3.0) = -0.9
remainder(-5.1, +3.0) = 0.9
remainder(+5.1, -3.0) = -0.9
remainder(-5.1, -3.0) = 0.9
remainder(-0.0, 1.0) = -0
remainder(5.1, Inf) = 5.1
remainder(+5.1, 0) = -nan
    FE_INVALID levée

Voir aussi

(C++11)
calcule le quotient et le reste de la division entière
(fonction)
(C++11) (C++11)
reste de l'opération de division en virgule flottante
(fonction)
(C++11) (C++11) (C++11)
reste signé ainsi que les trois derniers bits de l'opération de division
(fonction)
Documentation C pour remainder