Compartilhar via

_control87, _controlfp, __control87_2

  • Artigo

Obtém e define a palavra de controle de ponto flutuante.Uma versão mais segura do _controlfp está disponível. see _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
    Novos valores de bit da palavra de controle.

  • mask
    Máscara de bits de nova palavra de controle definir.

  • x86_cw
    Preenchido com a palavra de controle para o 87 x unidade de ponto flutuante.Passar 0 (NULL) para definir somente a palavra de controle do SSE2.

  • sse2_cw
    Controlar o word para a unidade de ponto flutuante SSE.Passar 0 (NULL) para definir somente a palavra de controle de 87 x.

Valor de retorno

Para _control87 e _controlfp, os bits no valor retornado indicam o estado de controle de ponto flutuante.Para obter uma definição completa dos bits retornado por _control87, consulte FLOAT.H.

Para __control87_2, o valor de retorno é 1, indicando sucesso.

Comentários

O _control87 função obtém e define a palavra de controle de ponto flutuante.A palavra de ponto flutuante de controle permite que o programa alterar a precisão, arredondamento e modos de infinito no pacote de matemática de ponto flutuante.Você também pode mascarar ou unmask exceções de ponto flutuante usando _control87.Se o valor de mask é igual a 0, _control87 obtém a palavra de controle de ponto flutuante.Se mask é diferente de zero, um novo valor para a palavra do controle é definido: para qualquer bit que em (igual a 1) mask, o bit correspondente em new é usado para atualizar a palavra de controle.In other words, fpcntrl= ((fpcntrl& ~mask) | (new & mask)) onde fpcntrl é a palavra de controle de ponto flutuante.  

ObservaçãoObservação

As bibliotecas de tempo de execução mask todas as exceções de ponto flutuante por padrão.

_controlfp é uma versão independente de plataforma, portátil do _control87.É quase idêntica do _control87 funcione em plataformas Intel (x86) e é suportado pelo MIPS e ALPHA plataformas.Para garantir que seu código de ponto flutuante é portátil, MIPS ou ALPHA, use _controlfp.Se você estiver direcionando x86 plataformas, use _control87 ou _controlfp.

A diferença entre _control87 e _controlfp é a maneira que os valores DENORMAL de tratar essas duas funções.Para plataformas Intel (x86), _control87 pode definir e limpar a máscara de exceção OPERANDO DESNORMALIZADO.ALFA plataformas não suportam essa exceção, e _controlfp não modifica a máscara de exceção OPERANDO DESNORMALIZADO.O exemplo a seguir demonstra a diferença:

_control87( _EM_INVALID, _MCW_EM ); 
// DENORMAL is unmasked by this call
_controlfp( _EM_INVALID, _MCW_EM ); 
// DENORMAL exception mask remains unchanged

Os valores possíveis para a constante de máscara (mask) e os novos valores de controle (new) são mostrados na tabela a seguir de valores hexadecimais.Use as constantes portátil listadas abaixo (_MCW_EM, _EM_INVALID, e assim por diante) como argumentos para essas funções, em vez de fornecer o hexadecimal valores explicitamente.

ALFA plataformas oferecem suporte à entrada da DENORMAL e valores no software de saída.O comportamento padrão de Windows NT nessas plataformas é liberar o DENORMAL de entrada e saída de valores como zero._controlfpFornece uma nova máscara para preservar e liberar a entrada e saída de valores DENORMAL.

Plataformas Intel (x86) oferecem suporte a entrada de denormal e saída de valores no hardware.O comportamento é preservar os valores DENORMAL._control87não fornece uma máscara para alterar esse comportamento.O exemplo a seguir demonstra essa diferença:

_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.

Ambos _control87 e _controlfp afetam as palavras de controle para o 87 x e o SSE2, se presente.A função __control87_2 permite que tanto o 87 x como unidades de ponto flutuantes SSE2 seja controlado juntos ou separadamente.Se você deseja afetar ambas as unidades, passe nos endereços dos dois inteiros para x86_cw e sse2_cw.Se você quiser apenas afetam uma unidade, passar em um endereço para esse parâmetro, mas passar em 0 (nulo) para o outro.Se 0 for passado para um desses parâmetros, a função não tem efeito sobre esse flutuante de unidade de ponto.Essa funcionalidade pode ser útil em situações em que parte do código usa o 87 x unidade de ponto flutuante e outra parte do código usa a unidade de ponto flutuante SSE2.Se você usar __control87_2 em uma parte de um programa e definir valores diferentes para o ponto flutuante palavras de controle e, em seguida, usar _control87 ou _controlfp para manipular os ainda mais a palavra de controle, em seguida, _control87 e _controlfp talvez não consiga retornar uma palavra de controle único para representar o estado de ambos os flutuantes aponte unidades.Nesse caso, essas funções definir o EM_AMBIGUOUS sinalizador no valor de número inteiro retornado para indicar que há uma inconsistência entre as palavras de controle.Este é um aviso de que a palavra de controle retornadas pode não representar o estado de ponto flutuante de ambos os controlar com precisão de palavras.

Sobre o x64 arquitetura, alterando a flutuação precision ponto não é suportado.Se a máscara de controle de precisão é usada nessa plataforma, uma declaração e o manipulador de parâmetro inválido é invocado, conforme descrito em Validação de parâmetro.

ObservaçãoObservação

__control87_2não é compatível com o x64 arquitetura.Se você usar __control87_2 e compilar seu programa para o x64 arquitetura, o compilador gerará um erro.

Essas funções são preteridas durante a compilação com /CLR (common Language Runtime Compilation) ou /clr:pure como o common language runtime oferece suporte apenas a precisão de ponto flutuante do padrão.

Valores hexadecimais

Para o _MCW_EM a máscara, limpando a máscara define a exceção, o que permite que a exceção de hardware; Configurando a máscara oculta a exceção.Observe que, se um _EM_UNDERFLOW ou _EM_OVERFLOW ocorre, nenhuma exceção de hardware é lançada até que a próxima instrução de ponto flutuante é executada.Para gerar uma exceção de hardware imediatamente após a _EM_UNDERFLOW ou _EM_OVERFLOW, chamar a instrução FWAIT MASM.

Máscara

Valor hex

Constante

Valor hex

_MCW_DN(Desnormalizado de controle)

0x03000000

_DN_SAVE

_DN_FLUSH

0x00000000

0x01000000

_MCW_EM(Máscara de exceção de interrupção)

0x0008001F

_EM_INVALID

_EM_DENORMAL

_EM_ZERODIVIDE

_EM_OVERFLOW

_EM_UNDERFLOW

_EM_INEXACT

0x00000010

0x00080000

0x00000008

0x00000004

0x00000002

0x00000001

_MCW_IC(Controle de infinito)

0x00040000

_IC_AFFINE

_IC_PROJECTIVE

0x00040000

0x00000000

_MCW_RC(Controle de arredondamento)

0x00000300

_RC_CHOP

_RC_UP

_RC_DOWN

_RC_NEAR

0x00000300

0x00000200

0x00000100

0x00000000

_MCW_PC(Controle de precisão)

0x00030000

_PC_24(24 bits)

_PC_53(53 bits)

_PC_64(64 bits)

0x00020000

0x00010000

0x00000000

Requisitos

Rotina

Cabeçalho necessário

_control87, _controlfp, _control87_2

<float.h>

Para obter mais informações de compatibilidade, consulte compatibilidade na introdução.

Exemplo

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

Saída

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

Equivalência do .NET Framework

Não aplicável. Para chamar a função c padrão, use PInvoke. Para obter mais informações, consulte Exemplos de invocação de plataforma.

Consulte também

Referência

Suporte de ponto flutuante

_clear87, _clearfp

_status87, _statusfp, _statusfp2