Namespaces
Variants

std:: fdim, std:: fdimf, std:: fdiml

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 fdim ( float x, float y ) ;

double fdim ( double x, double y ) ;

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

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

/*floating-point-type*/ y ) ;
(depuis C++23)
float fdimf ( float x, float y ) ;
(2) (depuis C++11)
(constexpr depuis C++23)
long double fdiml ( 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 >

fdim ( const V0 & v_x, const V1 & v_y ) ;
(S) (depuis C++26)
Défini dans l'en-tête <cmath>
template < class Integer >
double fdim ( Integer x, Integer y ) ;
(A) (constexpr depuis C++23)
1-3) Renvoie la différence positive entre x et y , c'est-à-dire, si x > y , renvoie x - y , sinon (c'est-à-dire si x <= y ) renvoie + 0 . La bibliothèque fournit des surcharges de std::fdim pour tous les types à virgule flottante non qualifiés cv comme type des paramètres. (depuis C++23)
S) La surcharge SIMD effectue un std::fdim é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)

Table des matières

Paramètres

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

Valeur de retour

En cas de succès, retourne la différence positive entre x et y .

Si une erreur de plage due à un dépassement de capacité se produit, +HUGE_VAL , +HUGE_VALF , ou +HUGE_VALL est renvoyé.

Si une erreur de plage due à un dépassement inférieur se produit, la valeur correcte (après arrondi) est retournée.

Gestion des erreurs

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

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

  • Si l'un des arguments est NaN, NaN est retourné.

Notes

Équivalent à std:: fmax ( x - y, 0 ) , sauf pour les exigences de gestion des NaN.

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 :: fdim ( num1, num2 ) a le même effet que std :: fdim ( 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 :: fdim ( num1, num2 ) a le même effet que std :: fdim ( static_cast < double > ( num1 ) ,
    static_cast < double > ( num2 ) )     .
  • Sinon, si num1 ou num2 a le type float , alors std :: fdim ( num1, num2 ) a le même effet que std :: fdim ( static_cast < float > ( num1 ) ,
    static_cast < float > ( num2 ) )     .
(jusqu'en C++23)

Si num1 et num2 ont des types arithmétiques, alors std :: fdim ( num1, num2 ) a le même effet que std :: fdim ( 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 <cerrno>
#include <cfenv>
#include <cmath>
#include <cstring>
#include <iostream>
#ifndef __GNUC__
#pragma STDC FENV_ACCESS ON
#endif
int main()
{
    std::cout << "fdim(4, 1) = " << std::fdim(4, 1) << '\n'
              << "fdim(1, 4) = " << std::fdim(1, 4) << '\n'
              << "fdim(4,-1) = " << std::fdim(4, -1) << '\n'
              << "fdim(1,-4) = " << std::fdim(1, -4) << '\n';
    // gestion des erreurs
    errno = 0;
    std::feclearexcept(FE_ALL_EXCEPT);
    std::cout << "fdim(1e308, -1e308) = " << std::fdim(1e308, -1e308) << '\n';
    if (errno == ERANGE)
        std::cout << "    errno == ERANGE: " << std::strerror(errno) << '\n';
    if (std::fetestexcept(FE_OVERFLOW))
        std::cout << "    FE_OVERFLOW déclenchée\n";
}

Sortie : 

fdim(4, 1) = 3
fdim(1, 4) = 0
fdim(4,-1) = 5
fdim(1,-4) = 5
fdim(1e308, -1e308) = inf
    errno == ERANGE: Résultat numérique hors limites
    FE_OVERFLOW déclenchée

Voir aussi

(C++11)
calcule la valeur absolue d'une valeur entière ( |x| )
(fonction)
(C++11) (C++11) (C++11)
plus grande de deux valeurs à virgule flottante
(fonction)
documentation C pour fdim