Namespaces
Variants

std:: copysign, std:: copysignf, std:: copysignl

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)
(C++11) (C++11)
copysign
(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 copysign ( float mag, float sgn ) ;

double copysign ( double mag, double sgn ) ;

long double copysign ( long double mag, long double sgn ) ;
(jusqu'à C++23)
constexpr /*floating-point-type*/

copysign ( /*floating-point-type*/ mag,

/*floating-point-type*/ sgn ) ;
(depuis C++23)
float copysignf ( float mag, float sgn ) ;
(2) (depuis C++11)
(constexpr depuis C++23)
long double copysignl ( long double mag, long double sgn ) ;
(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 >

copysign ( const V0 & v_mag, const V1 & v_sgn ) ;
(S) (depuis C++26)
Défini dans l'en-tête <cmath>
template < class Integer >
double copysign ( Integer mag, Integer sgn ) ;
(A) (constexpr depuis C++23)
1-3) Compose une valeur à virgule flottante avec la magnitude de mag et le signe de sgn . La bibliothèque fournit des surcharges de std::copysign 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::copysign élément par élément sur v_mag et v_sgn .
(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

mag, sgn - valeurs à virgule flottante ou entières

Valeur de retour

Si aucune erreur ne se produit, la valeur à virgule flottante avec la magnitude de mag et le signe de sgn est retournée.

Si mag est NaN, alors NaN avec le signe de sgn est retourné.

Si sgn est -0, le résultat est uniquement négatif si l'implémentation prend en charge le zéro signé de manière cohérente dans les opérations arithmétiques.

Gestion des erreurs

Cette fonction n'est sujette à aucune erreur spécifiée dans math_errhandling .

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

Notes

std::copysign est le seul moyen portable de manipuler le signe d'une valeur NaN (pour examiner le signe d'un NaN, std::signbit peut également être utilisé).

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

Si num1 et num2 ont des types arithmétiques, alors std :: copysign ( num1, num2 ) a le même effet que std :: copysign ( 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 <cmath>
#include <iostream>
int main()
{
    std::cout << std::showpos
              << "copysign(1.0,+2.0) = " << std::copysign(1.0, +2.0) << '\n'
              << "copysign(1.0,-2.0) = " << std::copysign(1.0, -2.0) << '\n'
              << "copysign(inf,-2.0) = " << std::copysign(INFINITY, -2.0) << '\n'
              << "copysign(NaN,-2.0) = " << std::copysign(NAN, -2.0) << '\n';
}

Sortie : 

copysign(1.0,+2.0) = +1
copysign(1.0,-2.0) = -1
copysign(inf,-2.0) = -inf
copysign(NaN,-2.0) = -nan

Voir aussi

(C++11) (C++11)
valeur absolue d'une valeur à virgule flottante ( |x| )
(fonction)
(C++11)
vérifie si le nombre donné est négatif
(fonction)
documentation C pour copysign