_control87, _controlfp, __control87_2
obtient et définit le mot de commande à virgule flottante.un plus version sécurisée d' _controlfp est disponible ; consultez _controlfp_s.
unsigned int _control87(
unsigned int new,
unsigned int mask
);
unsigned int _controlfp(
unsigned int new,
unsigned int mask
);
int __control87_2(
unsigned int new,
unsigned int mask,
unsigned int* x86_cw,
unsigned int* sse2_cw
);
Paramètres
new
Nouvelles valeurs de bits de contrôle-Word.mask
Masquez pour que les nouveaux éléments de contrôle-Word définissent.x86_cw
Rempli avec le mot de commande pour l'unité de la virgule flottante x87.Passez 0 (NULL) définir uniquement le mot de la commande SSE2.sse2_cw
mot de commande pour l'unité à virgule flottante de SSE.Passez 0 (NULL) définir uniquement le mot de la commande x87.
Valeur de retour
pour _control87 et _controlfp, les bits en valeur retournée indiquent l'état du contrôle à virgule flottante.Pour une définition complète des bits retourné par _control87, consultez. FLOAT.H.
Pour __control87_2, la valeur de retour est 1, qui indique le succès.
Notes
la fonction d' _control87obtient et définit le mot de commande à virgule flottante.Le mot de commande à virgule flottante permet au programme de modifier la précision, l'arrondi, et les modes de l'infini dans le package mathématiques à virgule flottante.Vous pouvez également masquer ou démasquer des exceptions de virgule flottante à l'aide de _control87.Si la valeur de mask est égale à 0, _control87obtient le mot de commande à virgule flottante.si mask est différent de zéro, une nouvelle valeur pour le mot de commande est définie : Pour tout bits qui est activé (égale à 1) dans mask, le bit correspondant dans new est utilisé pour mettre à jour le mot de commande.en d'autres termes, fpcntrl = ((fpcntrl & ~mask) | (new & mask)) où fpcntrl est le mot de commande à virgule flottante.
[!REMARQUE]
Les bibliothèques Runtime masquent les exceptions de virgule flottante par défaut.
_controlfpest une version plateforme-indépendante et portable d' _control87.Il est presque identique à la fonction d' _control87sur les plateformes Intel (x86) et est prise en charge par MIPS et les ALPHAS plateformes.Pour vous assurer que votre code à virgule flottante est portable à MIPS ou à l'ALPHA, utilisez _controlfp.Si vous ciblez des plateformes x86, utilisez _control87ou _controlfp.
La différence entre _control87et _controlfpest la façon dont ces valeurs de traiter DENORMAL de deux fonctions.Pour les plateformes Intel (x86), _control87peut définir et effacer le masque d'exception d'OPÉRANDE de DENORMAL.Les ALPHAS plateformes ne prennent pas en charge cette exception, et _controlfpne modifie pas le masque d'exception d'OPÉRANDE de DENORMAL.L'exemple suivant illustre la différence :
_control87( _EM_INVALID, _MCW_EM );
// DENORMAL is unmasked by this call
_controlfp( _EM_INVALID, _MCW_EM );
// DENORMAL exception mask remains unchanged
Les valeurs possibles pour la constante de masque (mask) et de nouvelles valeurs de contrôle (new) sont répertoriées dans le tableau suivant de valeurs hexadécimales.Utilisez des constantes portables répertoriées ci-dessous (_MCW_EM, _EM_INVALID, etc.) comme arguments à ces fonctions, plutôt qu'en fournissant des valeurs hexadécimales explicitement.
Les ALPHAS plateformes prennent en charge les valeurs d'entrée et de sortie de DENORMAL dans le logiciel.Le comportement par défaut de Windows NT sur ces plateformes est de purger les valeurs d'entrée et de sortie de DENORMAL à zéro._controlfp fournit un nouveau masque pour conserver et purger les valeurs de l'entrée et la sortie DENORMAL.
Les plateformes Intel (x86) prennent en charge les valeurs d'entrée et de sortie de DENORMAL au niveau matériel.le comportement est de conserver des valeurs de DENORMAL._control87 ne fournit pas de masque pour modifier ce comportement.L'exemple suivant illustre cette différence :
_controlfp(_DN_SAVE, _MCW_DN);
// Denormal values preserved by software on ALPHA. NOP on x86.
_controlfp(_DN_FLUSH, _MCW_DN);
// Denormal values flushed to zero by hardware on ALPHA and x86
// processors with SSE2 support. Ignored on other x86 platforms.
_control87 et _controlfp affectent les mots de commande pour le x87 et le SSE2, le cas échéant.la fonction __control87_2 permet les unités de la virgule flottante x87 et SSE2 à contrôler ensemble ou séparément.Si vous souhaitez assigner les deux unités, passez les adresses de deux entiers à x86_cw et à sse2_cw.Si vous souhaitez affecter uniquement une unité, passez une adresse pour ce paramètre mais passez 0 (NULL) pour l'autre.Si 0 est passée pour un de ces paramètres, la fonction n'a aucun effet sur cette unité de virgule flottante.Cette fonctionnalité peut être utile dans les situations où une partie de code utilise une unité de la virgule flottante x87 et une autre partie de code utilise une unité de la virgule flottante SSE2.Si vous utilisez __control87_2 dans une partie d'un programme et définissez des valeurs différentes pour les mots de commande de virgule flottante, et utilisez ensuite _control87 ou _controlfp pour manipuler davantage le mot de commande, alors _control87 et _controlfp ne puissent pas retourner un mot de commande unique pour représenter l'état des deux unités de virgule flottante.Dans ce cas, ces fonctions définissent la balise d' EM_AMBIGUOUS en valeur entière retournée pour indiquer qu'il existe une incohérence entre les deux mots de commande.Il s'agit d'un avertissement indiquant que le mot de commande retourné ne peut pas représenter l'état des deux mots de commande de virgule flottante exactement.
sur l'architecture de x64 , modifier la précision de virgule flottante n'est pas pris en charge.Si le masque de contrôle de précision est utilisé sur cette plateforme, une assertion et gestionnaire de paramètre non valide est appelée, comme décrit dans Validation des paramètres.
[!REMARQUE]
__control87_2 n'est pas pris en charge sur l'architecture de x64 .si vous utilisez __control87_2 et compilez votre programme pour l'architecture de x64 , le compilateur génère une erreur.
Ces fonctions sont déconseillées lors de la compilation avec /clr (Compilation pour le Common Language Runtime) ou /clr:pure car le common langage runtime prend en charge uniquement la précision de virgule flottante par défaut.
valeurs hexadécimales
Pour le masque d' _MCW_EM , désactiver le masque définit l'exception, qui permet l'exception matériels ; définir le masque masque l'exception.Notez que si _EM_UNDERFLOW ou _EM_OVERFLOW se produit, aucune exception de matériel n'est levée jusqu'à ce que l'instruction à virgule flottante suivante ne soit exécutée.Pour générer une exception de matériel immédiatement après _EM_UNDERFLOW ou _EM_OVERFLOW, appelez l'instruction de FWAIT MASM.
Masque |
Valeur hexadécimal |
Constante |
Valeur hexadécimal |
|---|---|---|---|
_MCW_DN (contrôle " Denormal ") |
0x03000000 |
_DN_SAVE _DN_FLUSH |
0x00000000 0x01000000 |
_MCW_EM (masque d'exception d'interruption) |
0x0008001F |
_EM_INVALID _EM_DENORMAL _EM_ZERODIVIDE _EM_OVERFLOW _EM_UNDERFLOW _EM_INEXACT |
0x00000010 0x00080000 0x00000008 0x00000004 0x00000002 0x00000001 |
_MCW_IC (contrôle de l'infini) |
0x00040000 |
_IC_AFFINE _IC_PROJECTIVE |
0x00040000 0x00000000 |
_MCW_RC (contrôle d'arrondi) |
0x00000300 |
_RC_CHOP _RC_UP _RC_DOWN _RC_NEAR |
0x00000300 0x00000200 0x00000100 0x00000000 |
_MCW_PC (contrôle de précision) |
0x00030000 |
_PC_24 (24 bits) _PC_53 (53 bits) _PC_64 (64 bits) |
0x00020000 0x00010000 0x00000000 |
Configuration requise
routine |
en-tête requis |
|---|---|
_control87, _controlfp, _control87_2 |
<float.h> |
Pour plus d'informations de compatibilité, consultez compatibilité dans l'introduction.
Exemple
// crt_cntrl87.c
// processor: x86
// This program uses __control87_2 to output the x87 control
// word, set the precision to 24 bits, and reset the status to
// the default.
//
#include <stdio.h>
#include <float.h>
#pragma fenv_access (on)
int main( void )
{
double a = 0.1;
unsigned int control_word_x87;
// Show original x87 control word and do calculation.
control_word_x87 = __control87_2(0, 0,
&control_word_x87, 0);
printf( "Original: 0x%.4x\n", control_word_x87 );
printf( "%1.1f * %1.1f = %.15e\n", a, a, a * a );
// Set precision to 24 bits and recalculate.
control_word_x87 = __control87_2(_PC_24, MCW_PC,
&control_word_x87, 0);
printf( "24-bit: 0x%.4x\n", control_word_x87 );
printf( "%1.1f * %1.1f = %.15e\n", a, a, a * a );
// Restore default precision-control bits and recalculate.
control_word_x87 = __control87_2( _CW_DEFAULT, MCW_PC,
&control_word_x87, 0 );
printf( "Default: 0x%.4x\n", control_word_x87 );
printf( "%1.1f * %1.1f = %.15e\n", a, a, a * a );
}
Sortie
Original: 0x0001
0.1 * 0.1 = 1.000000000000000e-002
24-bit: 0x0001
0.1 * 0.1 = 9.999999776482582e-003
Default: 0x0001
0.1 * 0.1 = 1.000000000000000e-002
Équivalent .NET Framework
Non applicable. Pour appeler la fonction C standard, utilisez PInvoke. Pour plus d'informations, consultez l' exemples d'appel de code non managé.