fex_set_handling man page on Solaris

Man page or keyword search:  
man Server   20652 pages
apropos Keyword Search (all sections)
Output format
Solaris logo
[printable version]

fex_set_handling(3M)	Mathematical Library Functions	  fex_set_handling(3M)

NAME
       fex_set_handling,  fex_get_handling,  fex_getexcepthandler,  fex_setex‐
       cepthandler - control floating point exception handling modes

SYNOPSIS
       c99 [ flag... ] file... -lm [ library... ]
       #include <fenv.h>

       int fex_set_handling(int ex, int mode, void(*handler);

       int fex_get_handling(int ex);

       void fex_getexcepthandler(fex_handler_t *buf, int ex);

       void fex_setexcepthandler(const fex_handler_t *buf, int ex);

DESCRIPTION
       These functions provide control of floating  point  exception  handling
       modes.  For each function, the ex argument specifies one or more excep‐
       tions indicated by a bitwise-OR of any of the following values  defined
       in <fenv.h>:

       FEX_INEXACT

       FEX_UNDERFLOW

       FEX_OVERFLOW

       FEX_DIVBYZERO	       division by zero

       FEX_INV_ZDZ	       0/0 invalid operation

       FEX_INV_IDI	       infinity/infinity invalid operation

       FEX_INV_ISI	       infinity-infinity invalid operation

       FEX_INV_ZMI	       0*infinity invalid operation

       FEX_INV_SQRT	       square root of negative operand

       FEX_INV_SNAN	       signaling NaN

       FEX_INV_INT	       invalid integer conversion

       FEX_INV_CMP	       invalid comparison

       For convenience, the following combinations of values are also defined:

       FEX_NONE		       no exceptions

       FEX_INVALID	       all invalid operation exceptions

       FEX_COMMON	       overflow,  division by zero, and invalid opera‐
			       tion

       FEX_ALL		       all exceptions

       The fex_set_handling() function establishes the specified mode for han‐
       dling  the  floating  point  exceptions identified by ex.  The selected
       mode determines the action to be taken when one of the indicated excep‐
       tions occurs.  It must be one of the following values:

       FEX_NOHANDLER	       Trap but do not otherwise handle the exception,
			       evoking instead whatever ambient behavior would
			       normally	 be  in	 effect.   This is the default
			       behavior when the exception's trap is  enabled.
			       The handler parameter is ignored.

       FEX_NONSTOP	       Provide	the  IEEE  754	default result for the
			       operation that caused the  exception,  set  the
			       exception's  flag, and continue execution. This
			       is the default behavior	when  the  exception's
			       trap  is	 disabled.   The  handler parameter is
			       ignored.

       FEX_ABORT	       Call  abort(3C).	 The  handler	parameter   is
			       ignored.

       FEX_SIGNAL	       Invoke  the  function *handler with the parame‐
			       ters normally  supplied	to  a  signal  handler
			       installed with sigfpe(3C).

       FEX_CUSTOM	       Invoke  the  function  *handler as described in
			       the next paragraph.

       In FEX_CUSTOM mode, when a floating point exception occurs, the handler
       function is invoked as though its prototype were:

       #include <fenv.h>
       void handler(int ex, fex_info_t *info);

       On  entry,  ex  is  the value (of the first twelve listed above) corre‐
       sponding to the exception that occurred, info->op indicates the	opera‐
       tion  that  caused  the	exception, info->op1 and info->op2 contain the
       values of the operands, info->res contains the default untrapped result
       value,  and info->flags reflects the exception flags that the operation
       would have set had it not been trapped.	If the	handler	 returns,  the
       value  contained	 in info->res on exit is substituted for the result of
       the operation, the flags indicated by info->flags are set,  and	execu‐
       tion  resumes  at  the point where the exception occurred.  The handler
       might modify info->res and info->flags to  supply  any  desired	result
       value and flags.	 Alternatively, if the exception is underflow or over‐
       flow, the hander might set

	      info->res.type = fex_nodata;

       which causes the exponent-adjusted result specified by IEEE 754	to  be
       substituted.   If the handler does not modify info->res or info->flags,
       the effect is the same as if the exception had not been trapped.

       Although the default untrapped result of an  exceptional	 operation  is
       always  available  to  a FEX_CUSTOM handler, in some cases, one or both
       operands may not be.  In these cases, the handler may be	 invoked  with
       info->op1.type  ==  fex_nodata or info->op2.type == fex_nodata to indi‐
       cate that the respective data structures do  not	 contain  valid	 data.
       (For example, info->op2.type == fex_nodata if the exceptional operation
       is a unary operation.)  Before accessing the operand values,  a	custom
       handler should always examine the type field of the operand data struc‐
       tures to ensure that they contain valid data in the appropriate format.

       The fex_get_handling() function returns the current handling  mode  for
       the  exception  specified  by ex, which must be one of the first twelve
       exceptions listed above.

       The fex_getexcepthandler() function saves the  current  handling	 modes
       and  associated	data  for  the	exceptions specified by ex in the data
       structure pointed to by buf.  The  type	fex_handler_t  is  defined  in
       <fenv.h>.

       The  fex_setexcepthandler()  function  restores	the handling modes and
       associated data for the exceptions specified by ex from the data struc‐
       ture  pointed  to  by buf.  This data structure must have been set by a
       previous call to fex_getexcepthandler(). Otherwise the  effect  on  the
       indicated modes is undefined.

RETURN VALUES
       The  fex_set_handling()	function  returns  a  non-zero	value  if  the
       requested exception handling mode is established. Otherwise, it returns
       0.

EXAMPLES
       The  following  example	demonstrates how to substitute a predetermined
       value for the result of a 0/0 invalid operation.

       #include <math.h>
       #include <fenv.h>

       double k;

       void presub(int ex, fex_info_t *info) {
	    info->res.type = fex_double;
	    info->res.val.d = k;
       }

       int main() {
	    double x, w;
	    int i;
	    fex_handler_t buf;
       /*
	* save current 0/0 handler
	*/
	    (void) fex_getexcepthandler(&buf, FEX_INV_ZDZ);
       /*
	* set up presubstitution handler for 0/0
	*/
	    (void) fex_set_handling(FEX_INV_ZDZ, FEX_CUSTOM, presub);
       /*
	*  compute (k*x)/sin(x) for k=2.0, x=0.5, 0.4, ..., 0.1, 0.0
	*/
	    k = 2.0;
	    (void) printf("Evaluating f(x) = (k*x)/sin(x)\n\n");
	    for (i = 5; i >= 0; i--) {
		    x = (double) i * 0.1;
		    w = (k * x) / sin(x);
		    (void) printf("\tx=%3.3f\t f(x) = % 1.20e\n", x, w);
	    }
       /*
	* restore old 0/0 handler
	*/
	    (void) fex_setexcepthandler(&buf, FEX_INV_ZDZ);
	    return 0;
       }

       The output from the preceding program reads:

       Evaluating f(x) = (k*x)/sin(x)

	    x=0.500  f(x) =  2.08582964293348816000e+00
	    x=0.400  f(x) =  2.05434596443822626000e+00
	    x=0.300  f(x) =  2.03031801709447368000e+00
	    x=0.200  f(x) =  2.01339581906893761000e+00
	    x=0.100  f(x) =  2.00333722632695554000e+00
	    x=0.000  f(x) =  2.00000000000000000000e+00

       When x = 0, f(x) is computed as 0/0 and an invalid operation  exception
       occurs.	In this example, the value 2.0 is substituted for the result.

ATTRIBUTES
       See attributes(5) for descriptions of the following attributes:

       ┌─────────────────────────────┬─────────────────────────────┐
       │      ATTRIBUTE TYPE	     │	    ATTRIBUTE VALUE	   │
       │Availability		     │SUNWlibms, SUNWlmxs	   │
       │Interface Stability	     │Stable			   │
       │MT-Level		     │MT-Safe (see Notes)	   │
       └─────────────────────────────┴─────────────────────────────┘

SEE ALSO
       sigfpe(3C),     feclearexcept(3M),    fegetenv(3M),    fex_set_log(3M),
       attributes(5)

       Numerical Computation Guide

NOTES
       In a multithreaded application, the preceding functions	affect	excep‐
       tion handling modes only for the calling thread.

       The  functions  described  on this page automatically install and dein‐
       stall SIGFPE handlers and set and clear the trap enable	mode  bits  in
       the  floating point status register as needed.  If a program uses these
       functions and attempts to install a SIGFPE handler or control the  trap
       enable mode bits independently, the resulting behavior is not defined.

       All traps are disabled before a handler installed in FEX_CUSTOM mode is
       invoked.	 When the SIGFPE signal is blocked, as it is when such a  han‐
       dler  is	 invoked, the floating point environment, exception flags, and
       retrospective  diagnostic  functions  described	in  feclearexcept(3M),
       fegetenv(3M),  and  fex_set_log(3M)  do not re-enable traps.  Thus, the
       handler itself always runs in FEX_NONSTOP mode with logging  of	retro‐
       spective diagnostics disabled.  Attempting to change these modes within
       the handler may not produce the expected results.

SunOS 5.10			  12 Jul 2006		  fex_set_handling(3M)
[top]

List of man pages available for Solaris

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]
Tweet
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