fenv.h man page on Scientific

Printed from http://www.polarhome.com/service/man/?qf=fenv.h&af=0&tf=2&of=Scientific

<fenv.h>(0P)		   POSIX Programmer's Manual		  <fenv.h>(0P)

       fenv.h - floating-point environment

       #include <fenv.h>

       The <fenv.h> header shall define the following data types through type‐

       fenv_t Represents the entire floating-point environment. The  floating-
	      point environment refers collectively to any floating-point sta‐
	      tus flags and control modes supported by the implementation.

	      Represents the floating-point status flags collectively, includ‐
	      ing  any	status the implementation associates with the flags. A
	      floating-point status flag is a system variable whose  value  is
	      set  (but	 never	cleared)  when	a  floating-point exception is
	      raised, which occurs as a side effect of	exceptional  floating-
	      point  arithmetic	 to provide auxiliary information. A floating-
	      point control mode is a system variable whose value may  be  set
	      by  the user to affect the subsequent behavior of floating-point

       The <fenv.h> header shall define the following constants if and only if
       the  implementation  supports  the floating-point exception by means of
       the  floating-point   functions	 feclearexcept(),   fegetexceptflag(),
       feraiseexcept(), fesetexceptflag(), and fetestexcept(). Each expands to
       an integer constant expression with values such that  bitwise-inclusive
       ORs of all combinations of the constants result in distinct values.


       The  <fenv.h> header shall define the following constant, which is sim‐
       ply the bitwise-inclusive OR of all floating-point exception  constants
       defined above:


       The <fenv.h> header shall define the following constants if and only if
       the implementation supports getting and setting the represented	round‐
       ing  direction by means of the fegetround() and fesetround() functions.
       Each expands to an integer constant expression whose  values  are  dis‐
       tinct non-negative vales.


       The  <fenv.h>  header shall define the following constant, which repre‐
       sents  the  default  floating-point  environment	 (that	is,  the   one
       installed  at  program startup) and has type pointer to const-qualified
       fenv_t. It can be used as an  argument  to  the	functions  within  the
       <fenv.h> header that manage the floating-point environment.


       The following shall be declared as functions and may also be defined as
       macros. Function prototypes shall be provided.

	      int  feclearexcept(int);
	      int  fegetexceptflag(fexcept_t *, int);
	      int  feraiseexcept(int);
	      int  fesetexceptflag(const fexcept_t *, int);
	      int  fetestexcept(int);
	      int  fegetround(void);
	      int  fesetround(int);
	      int  fegetenv(fenv_t *);
	      int  feholdexcept(fenv_t *);
	      int  fesetenv(const fenv_t *);
	      int  feupdateenv(const fenv_t *);

       The FENV_ACCESS pragma provides a means to  inform  the	implementation
       when an application might access the floating-point environment to test
       floating-point status flags or  run  under  non-default	floating-point
       control	modes. The pragma shall occur either outside external declara‐
       tions or preceding all explicit declarations and	 statements  inside  a
       compound	 statement.  When  outside  external  declarations, the pragma
       takes effect from its occurrence until another  FENV_ACCESS  pragma  is
       encountered,  or	 until	the end of the translation unit. When inside a
       compound statement, the pragma takes effect from its  occurrence	 until
       another	FENV_ACCESS  pragma  is encountered (including within a nested
       compound statement), or until the end of the compound statement; at the
       end of a compound statement the state for the pragma is restored to its
       condition just before the compound statement. If this pragma is used in
       any other context, the behavior is undefined. If part of an application
       tests floating-point status flags, sets floating-point  control	modes,
       or  runs	 under	non-default mode settings, but was translated with the
       state for the FENV_ACCESS pragma off, the behavior  is  undefined.  The
       default	state  (on  or	off) for the pragma is implementation-defined.
       (When execution passes from a part of the application  translated  with
       FENV_ACCESS  off to a part translated with FENV_ACCESS on, the state of
       the floating-point status flags is unspecified and  the	floating-point
       control modes have their default settings.)

       The following sections are informative.

       This  header is designed to support the floating-point exception status
       flags   and   directed-rounding	 control   modes   required   by   the
       IEC 60559:1989  standard, and other similar floating-point state infor‐
       mation.	Also it is designed to facilitate code portability  among  all

       Certain	application programming conventions support the intended model
       of use for the floating-point environment:

	* A function call does not alter its caller's  floating-point  control
	  modes, clear its caller's floating-point status flags, nor depend on
	  the state of its caller's floating-point  status  flags  unless  the
	  function is so documented.

	* A function call is assumed to require default floating-point control
	  modes, unless its documentation promises otherwise.

	* A function call is assumed to have the potential for raising	float‐
	  ing-point exceptions, unless its documentation promises otherwise.

       With these conventions, an application can safely assume default float‐
       ing-point control modes (or be unaware of them).	 The  responsibilities
       associated  with	 accessing  the floating-point environment fall on the
       application that does so explicitly.

       Even though the rounding direction macros may expand to constants  cor‐
       responding to the values of FLT_ROUNDS, they are not required to do so.

       For example:

	      #include <fenv.h>
	      void f(double x)
		  void g(double);
		  void h(double);
		  /* ... */
		  g(x + 1);
		  h(x + 1);
		  /* ... */

       If  the	function g() might depend on status flags set as a side effect
       of the first x+1, or if the second x+1 might depend  on	control	 modes
       set  as a side effect of the call to function g(), then the application
       shall contain an appropriately placed invocation as follows:

	      #pragma STDC FENV_ACCESS ON

   The fexcept_t Type
       fexcept_t does not have to be an	 integer  type.	 Its  values  must  be
       obtained by a call to fegetexceptflag(), and cannot be created by logi‐
       cal operations from the exception macros. An implementation might  sim‐
       ply implement fexcept_t as an int and use the representations reflected
       by the exception macros, but is not required to; other  representations
       might  contain extra information about the exceptions.  fexcept_t might
       be a struct with a member for  each  exception  (that  might  hold  the
       address	of  the	 first	or last floating-point instruction that caused
       that exception). The ISO/IEC 9899:1999 standard makes no	 claims	 about
       the internals of an fexcept_t, and so the user cannot inspect it.

   Exception and Rounding Macros
       Macros  corresponding  to unsupported modes and rounding directions are
       not defined by the implementation and must not be defined by the appli‐
       cation. An application might use #ifdef to test for this.


       The  System Interfaces volume of IEEE Std 1003.1-2001, feclearexcept(),
       fegetenv(), fegetexceptflag(), fegetround(), feholdexcept(), feraiseex‐
       cept(),	fesetenv(),  fesetexceptflag(),	 fesetround(), fetestexcept(),

       Portions of this text are reprinted and reproduced in  electronic  form
       from IEEE Std 1003.1, 2003 Edition, Standard for Information Technology
       -- Portable Operating System Interface (POSIX),	The  Open  Group  Base
       Specifications  Issue  6,  Copyright  (C) 2001-2003 by the Institute of
       Electrical and Electronics Engineers, Inc and The Open  Group.  In  the
       event of any discrepancy between this version and the original IEEE and
       The Open Group Standard, the original IEEE and The Open Group  Standard
       is  the	referee document. The original Standard can be obtained online
       at http://www.opengroup.org/unix/online.html .

IEEE/The Open Group		     2003			  <fenv.h>(0P)

List of man pages available for Scientific

Copyright (c) for man pages and the logo by the respective OS vendor.

For those who want to learn more, the polarhome community provides shell access and support.

[legal] [privacy] [GNU] [policy] [cookies] [netiquette] [sponsors] [FAQ]
Polarhome, production since 1999.
Member of Polarhome portal.
Based on Fawad Halim's script.
Vote for polarhome
Free Shell Accounts :: the biggest list on the net