Exportar (0) Imprimir
Expandir todo
div
EOF
Expandir Minimizar
Este artículo proviene de un motor de traducción automática. Mueva el puntero sobre las frases del artículo para ver el texto original. Más información.
Traducción
Original

_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
);

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.

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.

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 Nota

La máscara de las bibliotecas en tiempo de ejecución todas las excepciones de punto flotante de forma predeterminada.

_controlfp es 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.

NotaNota

__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

rutina

Encabezado necesario

_control87 , _controlfp, _control87_2

<float.h>

Para obtener más información de compatibilidad, vea compatibilidad en la Introducción.

// 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 );
}

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

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.

Adiciones de comunidad

AGREGAR
Mostrar:
© 2015 Microsoft