_control87, _controlfp, __control87_2
obtiene y establece la palabra de control flotante.Una versión más segura de _controlfp está disponible; vea _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
);
Parámetros
new
nuevos valores de bit de la CONTROL-palabra.mask
Máscara para nuevos bits de la CONTROL-palabra el conjunto.x86_cw
Completo con la palabra de control de la unidad de punto flotante x87.Paso en 0 (NULL) para establecer únicamente la palabra de control SSE2.sse2_cw
Palabra de Control de la unidad flotante de SSE.Paso en 0 (NULL) para establecer únicamente la palabra de control x87.
Valor devuelto
Para _control87 y _controlfp, los bits del valor devuelto indican el estado de control flotante.Para ver una definición completa de los bits devueltos por _control87, vea FLOAT.H.
Para __control87_2, el valor devuelto es 1, que indica éxito.
Comentarios
la función de _control87obtiene y establece la palabra de control flotante.La palabra de control flotante permite que el programa cambie la precisión, el redondeo, y los modos de infinito en el paquete de software matemáticos flotante.También puede máscara o desenmascarar excepciones de punto flotante mediante _control87.Si el valor de mask es igual a 0, _control87obtiene la palabra de control flotante.Si mask es distinto de cero, un nuevo valor para la palabra de control se establece: Para cualquier bit que está activado (utilizan el igual a 1) en mask, el bit correspondiente en new para actualizar la palabra de control.es decir fpcntrl = ((fpcntrl & ~mask) | (new & mask)) donde es la palabra fpcntrl de control flotante.
[!NOTA]
La máscara de las bibliotecas en tiempo de ejecución todas las excepciones de punto flotante de forma predeterminada.
_controlfpes una plataforma-independiente, versión portable de _control87.Es casi idéntica a la función de _control87en plataformas Intel (x86) y es compatible con MIPS y plataformas Alpha.Para asegurarse de que el código flotante sea portable a MIPS o a la ALFA, utilice _controlfp.Si usa como destino plataformas x86, utilice _control87o _controlfp.
La diferencia entre _control87y _controlfpes la manera estos valores de una llamada DENORMAL de dos funciones.Para plataformas Intel (x86), _control87establecer y borrar la máscara de la excepción de OPERANDO de DENORMAL.Las plataformas Alpha no admiten esta excepción, y _controlfpno modifica la máscara de la excepción de OPERANDO de DENORMAL.El ejemplo siguiente muestra la diferencia:
_control87( _EM_INVALID, _MCW_EM );
// DENORMAL is unmasked by this call
_controlfp( _EM_INVALID, _MCW_EM );
// DENORMAL exception mask remains unchanged
Los valores posibles por la constante de máscara (mask) y nuevos valores de control (new) se muestran en la tabla siguiente de valores hexadecimales.Utilice constantes portables enumeradas abajo (_MCW_EM, _EM_INVALID, etc.) como argumentos a estas funciones, en lugar de proporcionar los valores hexadecimales explícitamente.
Las plataformas Alpha admiten los valores de entrada y salida de DENORMAL en software.El comportamiento predeterminado de windows NT en estas plataformas es vaciar los valores de entrada y salida de DENORMAL a cero._controlfp proporciona una nueva máscara para mantener y para vaciar los valores de entrada y salida DENORMAL.
Plataformas Intel (x86) admiten los valores de entrada y salida de DENORMAL en hardware.El comportamiento es conservar los valores de DENORMAL._control87 no proporciona una máscara para cambiar este comportamiento.El ejemplo siguiente se muestra esta diferencia:
_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 y _controlfp afectan a las palabras de control para el x87 y el SSE2, si existe.La función __control87_2 permite unidades de punto flotante x87 y SSE2 que se controlarán conjuntamente o por separado.Si desea afectar a ambas unidades, pase las direcciones de dos enteros a x86_cw y a sse2_cw.Si solo desea afectar a una unidad, pase una dirección para ese parámetro pero paso en 0 (NULL) para la otra.Si 0 se pasa para uno de estos parámetros, la función no tiene ningún efecto en esa unidad de punto flotante.Esta funcionalidad podría ser útil en situaciones donde la parte del código utiliza la unidad de punto flotante x87 y otra parte del código utiliza la unidad de punto flotante SSE2.Si utiliza __control87_2 en una parte de un programa y establezca valores diferentes para las palabras de control de punto flotante, y utilice _control87 o _controlfp manipular aún más la palabra de control, se _control87 y _controlfp no puedan devolver una sola palabra de control para representar el estado de ambas unidades de punto flotante.En este caso, estas funciones establecen el indicador de EM_AMBIGUOUS en el valor entero devuelto para indicar que hay una inconsistencia entre las dos palabras de control.Esta advertencia que word de control devuelta no represente el estado de ambas palabras de control de punto flotante exactamente.
En la arquitectura de x64 , cambiar la precisión de punto flotante no se admite.Si la máscara de control de precisión se utiliza en esa plataforma, invoque una aserción y el controlador no válido de parámetro, tal y como se describe en Validación de parámetros.
[!NOTA]
__control87_2 no se admite en la arquitectura de x64 .Si utiliza __control87_2 y compila el programa para la arquitectura de x64 , el compilador genera un error.
Se han dejado de utilizar estas funciones al compilar con /clr (Compilación de Common Language Runtime) o /clr:pure porque Common Language Runtime admite únicamente la precisión flotante predeterminada.
valores hexadecimales
Para la máscara de _MCW_EM , borrar la máscara establece la excepción, que permite la excepción de hardware; establecer la máscara oculta la excepción.Tenga en cuenta que si _EM_UNDERFLOW o _EM_OVERFLOW aparece, no se produce ninguna excepción de hardware hasta que se ejecute la instrucción de coma flotante siguiente.Para generar una excepción de hardware inmediatamente después de _EM_UNDERFLOW o de _EM_OVERFLOW, llame a la instrucción de FWAIT MASM.
Máscara |
valor hexadecimal |
Constante |
valor hexadecimal |
|---|---|---|---|
_MCW_DN (control de Denormal) |
0x03000000 |
_DN_SAVE _DN_FLUSH |
0x00000000 0x01000000 |
_MCW_EM (máscara de excepción de la interrupción) |
0x0008001F |
_EM_INVALID _EM_DENORMAL _EM_ZERODIVIDE _EM_OVERFLOW _EM_UNDERFLOW _EM_INEXACT |
0x00000010 0x00080000 0x00000008 0x00000004 0x00000002 0x00000001 |
_MCW_IC (control de Infinity) |
0x00040000 |
_IC_AFFINE _IC_PROJECTIVE |
0x00040000 0x00000000 |
_MCW_RC (que redondea el control) |
0x00000300 |
_RC_CHOP _RC_UP _RC_DOWN _RC_NEAR |
0x00000300 0x00000200 0x00000100 0x00000000 |
_MCW_PC (control de Precisión) |
0x00030000 |
_PC_24 (24 bits) _PC_53 (53 bits) _PC_64 (64 bits) |
0x00020000 0x00010000 0x00000000 |
Requisitos
rutina |
Encabezado necesario |
|---|---|
_control87, _controlfp, _control87_2 |
<float.h> |
Para obtener más información de compatibilidad, vea compatibilidad en la Introducción.
Ejemplo
// 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 );
}
Output
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
Equivalente en .NET Framework
No es aplicable Para llamar a la función estándar de C, utilice PInvoke. Para obtener más información, vea La invocación de plataforma ejemplos.