UNIX ON-LINE Man Pages - Die Onlinehilfe

Die Syntax von Unixbefehlen wird in den entsprechenden Manpages dokumentiert. Hier können Sie diese Onlinehilfe für viele Standardbefehle abrufen.

Seiten auflisten, welche beginnen mit:
A   B   C   D   E   F   G   H   I   J   K   L   M   N   O   P   Q   R   S   T   U   V   W   X   Y   Z   ALPHA   NUM   ANDERE   ALLE
<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)
                  #pragma STDC FENV_ACCESS ON
                  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)

Scannen Sie den Barcode um die Webseite zu öffnen

Quelle: http://www.trinler.net/de/service/doc/linux/man.html?command=fenv.h
Gedruckt am: 15.12.2017 07:29 GMT+0100 (2017-12-15T07:29:57+01:00)