fenv(3) Library Functions Manual fenv(3) NOME feclearexcept, fegetexceptflag, feraiseexcept, fesetexceptflag, fetestexcept, fegetenv, fegetround, feholdexcept, fesetround, fesetenv, feupdateenv, feenableexcept, fedisableexcept, fegetexcept - tratamento de excecao e arredondamento de ponto flutuante BIBLIOTECA Biblioteca matematica (libm, -lm) SINOPSE #include int feclearexcept(int excepts); int fegetexceptflag(fexcept_t *flagp, int excepts); int feraiseexcept(int excepts); int fesetexceptflag(const fexcept_t *flagp, int excepts); int fetestexcept(int excepts); int fegetround(void); int fesetround(int rounding_mode); int fegetenv(fenv_t *envp); int feholdexcept(fenv_t *envp); int fesetenv(const fenv_t *envp); int feupdateenv(const fenv_t *envp); DESCRICAO Estas onze funcoes foram definidas no C99, e descrevem o tratamento de arredondamento e excecoes de ponto flutuante (estouro de representacao, divisao por zero, etc.). Excecoes A excecao divide-by-zero ocorre quando uma operacao sobre numeros finitos produz infinito como resposta exata. A excecao overflow ocorre quando um resultado tem de ser representado como um numero de ponto flutuante, mas tem valor absoluto (muito) maior que o maior numero de ponto flutuante (finito) que e representavel. A excecao underflow ocorre quando um resultado tem de ser representado como um numero de ponto flutuante, mas tem valor absoluto menor que o menor numero de ponto flutuante positivo normalizado (e perderia muita precisao se representado como um numero desnormalizado). A excecao inexact ocorre quando o resultado arredondado de uma operacao nao e igual ao resultado de precisao infinita. Ela pode ocorrer quando quer que overflow ou underflow ocorram. A excecao invalid ocorre quando nao ha resultado bem definido para uma operacao, como para 0/0 ou infinito - infinito ou sqrt(-1). Tratamento de Excecoes Excecoes sao representadas de duas formas: como um unico bit (excecao presente/ausente), e esses bits correspondem em alguma forma definida pela implementacao com posicoes de bit em um inteiro, e tambem como uma estrutura opaca que pode conter mais informacao sobre a excecao (talvez o endereco de codigo onde ela ocorreu). Cada uma das macros FE_DIVBYZERO, FE_INEXACT, FE_INVALID, FE_OVERFLOW, FE_UNDERFLOW e definida quando a implementacao suporta tratamento da excecao correspondente, e, se sim, entao define o(s) bit(s) correspondente(s), de forma que se possa chamar funcoes de tratamento de excecoes, por exemplo, usando o argumento inteiro FE_OVERFLOW|FE_UNDERFLOW. Outras excecoes podem ser suportadas. A macro FE_ALL_EXCEPT e o OR bit a bit de todos os bits correspondendo a excecoes suportadas. A funcao feclearexcept() desabilita as excecoes suportadas representadas pelos bits no seu argumento. A funcao fegetexceptflag() armazena uma representacao do estado dos indicadores de excecao representados pelo argumento excepts no objeto opaco *flagp. A funcao feraiseexcept() dispara as excecoes suportadas representadas pelos bits em excepts. A funcao fesetexceptflag() define o estado completo para as excecoes representadas por excepts para o valor *flagp. Esse valor deve ter sido obtido por uma chamada anterior a fegetexceptflag() com um ultimo argumento que contivesse todos os bits em excepts. A funcao fetestexcept() retorna uma palavra na qual os bits definidos sao os definidos no argumento excepts e para os quais a excecao correspondente esta atualmente habilitada. Modo de arredondamento O modo de arredondamento determina como o resultado de operacoes de ponto flutuante e tratado quando o resultado nao pode ser representado exatamente no significando. Varios modos de arredondamento podem ser fornecidos: arredondar para o mais proximo (o padrao), arredondar para cima (em direcao ao infinito positivo), arredondar para baixo (em direcao ao infinito negativo) e arredondar para zero. Cada uma das macros FE_TONEAREST, FE_UPWARD, FE_DOWNWARD e FE_TOWARDZERO e definida quando a implementacao suporta obter e definir a direcao de arredondamento correspondente. A funcao fegetround() retorna a macro correspondente ao modo de arredondamento atual. A funcao fesetround() define o modo de arredondamento como especificado por seu argumento e retorna zero quando for bem sucedida. C99 e POSIX.1-2008 especificam um identificador, FLT_ROUNDS, definido em , que indica o comportamento de arredondamento definido pela implementacao para adicao de ponto flutuante. Este identificador tem um dos seguintes valores: -1 O modo de arredondamento nao e determinavel. 0 O arredondamento e para 0. 1 O arredondamento e para o numero mais proximo. 2 O arredondamento e em direcao ao infinito positivo. 3 O arredondamento e em direcao ao infinito negativo. Outros valores representam modos de arredondamento nao padronizados e dependentes da maquina. O valor de FLT_ROUNDS deve refletir o modo de arredondamento atual definido por fesetround() (mas veja BUGS). Ambiente de Ponto Flutuante O ambiente de ponto flutuante inteiro, incluindo modos de controle e indicadores de estado, pode ser tratado como um objeto opaco, de tipo fenv_t. O ambiente padrao e denotado por FE_DFL_ENV (de tipo const fenv_t *). Essa e a definicao do ambiente ao inicio do programa e e definida por ISO C como tendo arredondamento para o mais proximo, todas as excecoes desabilitadas e um modo 'non-stop' (continuar nas excecoes). A funcao fegetenv() salva o ambiente de ponto flutuante atual no objeto *envp. A funcao feholdexcept() faz o mesmo, entao zera todos indicadores de excecao, e define um modo 'non-stop' (continuar nas excecoes), se disponivel. Ela retorna zero quando bem sucedida. A funcao fesetenv() restaura o ambiente de ponto flutuante do objeto *envp. Esse objeto deve ser reconhecidamente valido, por exemplo, o resultado de uma chamada a fegetenv() ou feholdexcept() ou igual a FE_DFL_ENV. Essa chamada nao dispara excecoes. A funcao feupdateenv() instala o ambiente de ponto flutuante representado pelo objeto *envp, exceto que as excecoes que estao atualmente disparadas nao sao desabilitadas. Depois de chamar essa funcao, as excecoes disparadas serao o OR bit a bit daquelas previamente definidas com aquelas em *envp. Como antes, o objeto *envp deve ser reconhecido como sendo valido. VALOR DE RETORNO Essas funcoes retornam zero em caso de sucesso e diferente de zero se ocorrer um erro. ATRIBUTOS Para uma explicacao dos termos usados nesta secao, consulte attributes(7). +--------------------------------------------+---------------+---------+ |Interface | Atributo | Valor | +--------------------------------------------+---------------+---------+ |feclearexcept(), fegetexceptflag(), | Thread safety | MT-Safe | |feraiseexcept(), fesetexceptflag(), | | | |fetestexcept(), fegetround(), fesetround(), | | | |fegetenv(), feholdexcept(), fesetenv(), | | | |feupdateenv(), feenableexcept(), | | | |fedisableexcept(), fegetexcept() | | | +--------------------------------------------+---------------+---------+ PADROES C11, POSIX.1-2008, IEC 60559 (IEC 559:1989), ANSI/IEEE 854. HISTORICO C99, POSIX.1-2001. glibc 2.1. NOTAS Notas sobre glibc Se possivel, a Biblioteca C GNU define a macro FE_NOMASK_ENV a qual representa um ambiente em que toda excecao disparada causa a ocorrencia de uma captura. Voce pode testar por essa macro usando #ifdef. Ela so e definida se _GNU_SOURCE estiver definida. O padrao C99 nao define uma forma de definir bits individuais na mascara de ponto flutuante, por exemplo, para capturar quando de indicadores especificos. glibc 2.2 suportara as funcoes feenableexcept() e fedisableexcept() para definir capturas de ponto flutuante individuais, e fegetexcept() para obter o estado. #define _GNU_SOURCE /* Veja feature_test_macros(7) */ #include int feenableexcept(int excepts); int fedisableexcept(int excepts); int fegetexcept(void); As funcoes feenableexcept() e fedisableexcept() habilitam (desabilitam) capturas para cada uma das excecoes representadas por excepts e retornam o conjunto anterior de excecoes habilitadas quando bem sucedida, e -1 caso contrario. A funcao fegetexcept() retorna o conjunto de todas as excecoes atualmente habilitadas. BUGS C99 especifica que o valor de FLT_ROUNDS deve refletir alteracoes no modo de arredondamento atual, conforme definido por fesetround(). Atualmente, isso nao ocorre: FLT_ROUNDS sempre tem o valor 1. VEJA TAMBEM math_error(7) TRADUCAO A traducao para portugues brasileiro desta pagina man foi criada por Marcelo M. de Abreu , Andre Luiz Fassone e Rafael Fontenelle . Esta traducao e uma documentacao livre; leia a Licenca Publica Geral GNU Versao 3 ou posterior para as condicoes de direitos autorais. Nenhuma responsabilidade e aceita. Se voce encontrar algum erro na traducao desta pagina de manual, envie um e-mail para a lista de discussao de tradutores . Linux man-pages 6.9.1 2 maio 2024 fenv(3)