mathsoftlib.c

vxworks source code, used for develop vxworks system.

/* mathSoftLib.c - high-level floating-point emulation library */

/* Copyright 1984-1995 Wind River Systems, Inc. */
#include "copyright_wrs.h"

/*
modification history
--------------------
01p,04sep98,yh   fixed mathSoftCeil for spr#22152.
01o,21nov95,gbj  switched to ansi-style function declarations
01n,07jul95,rcs  changed LOG2E back to correct value.
01m,03feb95,rhp  doc: warn that sw f/p is not available for all archs
01l,12jan95,rhp  doc: correct config macro to call mathSoftInit() (SPR#3733).
01k,14jul94,dvs  fixed argument order and doc for mathSoftAtan2/mathSoftAtan2f 
		 (SPR# 2580)
01j,21nov92,jdi	 documentation cleanup.
01i,13nov92,jcf	 made logMsg calls indirect to reduce coupling.
01h,13oct92,jdi	 doc, and NOMANUAL for mathSoftSincos() and mathSoftSincosf(). 
01g,30jul92,kdl	 changed to ANSI single precision names (e.g. sinf -> sinf).
01f,26jul92,gae  fixed number of parameters to logMsg().
01e,04jul92,jcf  ansi clean up.
01d,03jul92,smb  removed include of vxTypes.h.
01c,26may92,rrr  the tree shuffle
01b,04oct91,rrr  passed through the ansification filter
		  -changed VOID to void
		  -changed copyright notice
01a,28jan91,kdl	 original version, based on library written by S. Huddleston.
*/

/*
DESCRIPTION
This library provides software emulation of various high-level
floating-point operations.  This emulation is generally for use in systems
that lack a floating-point coprocessor.

WARNING
Software floating point is not supported for all architectures.  See
the architecture-specific appendices of the
.I VxWorks Programmer's Guide.

INCLUDE FILES: math.h

SEE ALSO: mathHardLib, mathALib,
.I VxWorks Programmer's Guide
architecture-specific appendices

INTERNAL
Authors:
Major portions by Scott Huddleston, Computer Research Lab, Tektronix.
  Copyright 1990, Tektronix Inc.

Cube-root function (cbrt) written by K.C. Ng, UC Berkeley.
  Copyright 1985, Regents of the University of California.

Hyperbolic trig functions (cosh, sinh, tanh) written by Fred Fish.

*/

#include "vxWorks.h"
#include "math.h"
#include "logLib.h"
#include "private/funcBindP.h"

/* make sure PI is defined */
#ifndef PI
#define PI      3.14159265358979323846264338327950
#endif

/* constant PI in single precision */
static float PI_SINGLE = PI;

#define INF_HiShort		0x7ff0
#define INF_HiShort_SINGLE	0x7f80

/* tests for NaN (Not a Number) and INF (infinity) */
#define isNaN(z)	(((*(short*)&z) & 0x7fff) > INF_HiShort)
#define isINF(z)	(((*(short*)&z) & 0x7fff) == INF_HiShort)
#define isINFNaN(z)	(((*(short*)&z) & 0x7fff) >= INF_HiShort)

#define isNaN_SINGLE(z)		(((*(short*)&z) & 0x7fff) > INF_HiShort_SINGLE)
#define isINF_SINGLE(z)		(((*(short*)&z) & 0x7fff) == INF_HiShort_SINGLE)
#define isINFNaN_SINGLE(z)	(((*(short*)&z) & 0x7fff) >= INF_HiShort_SINGLE)

#define LOGE_MAXDOUBLE  7.09782712893383970e+02
#define LOGE_MINDOUBLE  -7.09089565712824080e+02
#define TANH_MAXARG	16
#define LOG2E		1.4426950408889634074	/* Log to base 2 of e */





/* Externals */

extern double	mathSoftAtan ();	/* functions in mathSoftALib.s */
extern double	mathSoftCos ();
extern double	mathSoftExp ();
extern double	mathSoftFloor ();
extern double	mathSoftInfinity ();
extern double	mathSoftLog ();
extern double	mathSoftLog10 ();
extern double	mathSoftRealtoint ();
extern double	mathSoftSin ();
extern double	mathSoftSqrt ();
extern double	mathSoftTan ();

extern float	mathSoftAtanf ();
extern float	mathSoftCosf ();
extern float	mathSoftExpf ();
extern float	mathSoftFloorf ();
extern float	mathSoftInfinityf ();
extern float	mathSoftLogf ();
extern float	mathSoftLog10f ();
extern float	mathSoftRealtointf ();
extern float	mathSoftSinf ();
extern float	mathSoftSqrtf ();
extern float	mathSoftTanf ();


extern DBLFUNCPTR	mathAcosFunc;	/* double-precision function ptrs */
extern DBLFUNCPTR	mathAsinFunc;
extern DBLFUNCPTR	mathAtanFunc;
extern DBLFUNCPTR	mathAtan2Func;
extern DBLFUNCPTR	mathCbrtFunc;
extern DBLFUNCPTR	mathCeilFunc;
extern DBLFUNCPTR	mathCosFunc;
extern DBLFUNCPTR	mathCoshFunc;
extern DBLFUNCPTR	mathExpFunc;
extern DBLFUNCPTR	mathFabsFunc;
extern DBLFUNCPTR	mathFloorFunc;
extern DBLFUNCPTR	mathFmodFunc;
extern DBLFUNCPTR	mathHypotFunc;
extern DBLFUNCPTR	mathInfinityFunc;
extern FUNCPTR		mathIrintFunc;
extern FUNCPTR		mathIroundFunc;
extern DBLFUNCPTR	mathLogFunc;
extern DBLFUNCPTR	mathLog2Func;
extern DBLFUNCPTR	mathLog10Func;
extern DBLFUNCPTR	mathPowFunc;
extern DBLFUNCPTR	mathRoundFunc;
extern DBLFUNCPTR	mathSinFunc;
extern VOIDFUNCPTR	mathSincosFunc;
extern DBLFUNCPTR	mathSinhFunc;
extern DBLFUNCPTR	mathSqrtFunc;
extern DBLFUNCPTR	mathTanFunc;
extern DBLFUNCPTR	mathTanhFunc;
extern DBLFUNCPTR	mathTruncFunc;

extern FLTFUNCPTR	mathAcosfFunc;	/* single-precision function ptrs */
extern FLTFUNCPTR	mathAsinfFunc;
extern FLTFUNCPTR	mathAtanfFunc;
extern FLTFUNCPTR	mathAtan2fFunc;
extern FLTFUNCPTR	mathCbrtfFunc;
extern FLTFUNCPTR	mathCeilfFunc;
extern FLTFUNCPTR	mathCosfFunc;
extern FLTFUNCPTR	mathCoshfFunc;
extern FLTFUNCPTR	mathExpfFunc;
extern FLTFUNCPTR	mathFabsfFunc;
extern FLTFUNCPTR	mathFmodfFunc;
extern FLTFUNCPTR	mathFloorfFunc;
extern FLTFUNCPTR	mathHypotfFunc;
extern FLTFUNCPTR	mathInfinityfFunc;
extern FUNCPTR		mathIrintfFunc;
extern FUNCPTR		mathIroundfFunc;
extern FLTFUNCPTR	mathLogfFunc;
extern FLTFUNCPTR	mathLog2fFunc;
extern FLTFUNCPTR	mathLog10fFunc;
extern FLTFUNCPTR	mathPowfFunc;
extern FLTFUNCPTR	mathRoundfFunc;
extern FLTFUNCPTR	mathSinfFunc;
extern VOIDFUNCPTR	mathSincosfFunc;
extern FLTFUNCPTR	mathSinhfFunc;
extern FLTFUNCPTR	mathSqrtfFunc;
extern FLTFUNCPTR	mathTanfFunc;
extern FLTFUNCPTR	mathTanhfFunc;
extern FLTFUNCPTR	mathTruncfFunc;


/* Locals */

LOCAL char	*errMsgString = "ERROR - %s function not supported\n";

/* Forward references */

LOCAL double 	mathSoftAcos (double dblParam);
LOCAL double 	mathSoftAsin (double dblParam);
LOCAL double 	mathSoftAtan2 (double dblY, double dblX);
LOCAL double 	mathSoftCbrt (double x);
LOCAL double 	mathSoftCeil (double dblParam);
LOCAL double 	mathSoftCosh (double dblParam);
LOCAL double 	mathSoftFabs (double dblParam);
LOCAL double 	mathSoftHypot (double dblX, double dblY);
LOCAL double 	mathSoftLog2 (double dblParam);
LOCAL double 	mathSoftPow (double dblX, double dblY);
LOCAL double 	mathSoftSinh (double dblParam);
LOCAL void 	mathSoftSincos (double dblParam, double *pSinResult, 
				double *pCosResult);
LOCAL double 	mathSoftTanh (double dblParam);

LOCAL float 	mathSoftAcosf (float fltParam);
LOCAL float 	mathSoftAsinf (float fltParam);
LOCAL float 	mathSoftAtan2f (float fltY, float fltX);
LOCAL float 	mathSoftCbrtf (float x);
LOCAL float 	mathSoftCeilf (float fltParam);
LOCAL float 	mathSoftFabsf (float fltParam);
LOCAL float 	mathSoftHypotf (float fltX, float fltY);
LOCAL float	mathSoftLog2f (float fltParam);
LOCAL float 	mathSoftPowf (float fltX, float fltY);
LOCAL void 	mathSoftSincosf (float fltParam, float *pSinResult, 
				 float *pCosResult);


                      				/* unsupported */
LOCAL void 	mathSoftFmod (double dblParam, double dblDivisor);
                      				/* unsupported */
LOCAL void 	mathSoftIrint (double dblParam);
                      				/* unsupported */
LOCAL void 	mathSoftIround (double dblParam);
                      				/* unsupported */
LOCAL void 	mathSoftRound (double dblParam);
                      				/* unsupported */
LOCAL void 	mathSoftTrunc (double dblParam);
                      				/* unsupported */
LOCAL void 	mathSoftCoshf (float fltParam);
                      				/* unsupported */
LOCAL void 	mathSoftFmodf (float fltParam, float fltDivisor);
                      				/* unsupported */
LOCAL void 	mathSoftIrintf (float fltParam);
                      				/* unsupported */
LOCAL void 	mathSoftIroundf (float fltParam);
                      				/* unsupported */
LOCAL void 	mathSoftRoundf (float fltParam);
                      				/* unsupported */
LOCAL void 	mathSoftSinhf (float fltParam);
                      				/* unsupported */
LOCAL void 	mathSoftTanhf (float fltParam);
                      				/* unsupported */
LOCAL void 	mathSoftTruncf (float fltParam);

/******************************************************************************
*
* mathSoftInit - initialize software floating-point math support
*
* This routine places the addresses of the emulated high-level math
* functions (trigonometric functions, etc.) in a set of global variables.
* This allows the standard math functions (e.g., sin(), pow()) to have a
* single entry point but be dispatched to the hardware or software support
* routines, as specified.
*
* This routine is called from usrConfig.c if INCLUDE_SW_FP is defined.
* This definition causes the linker to include the floating-point
* emulation library.
*
* If the system is to use some combination of emulated as well as hardware
* coprocessor floating points, then this routine should be called before calling
* mathHardInit().
*
* RETURNS: N/A
*
* SEE ALSO: mathHardInit()
*
*/

void mathSoftInit ()
    {

    /* Load software routine addresses into global variables
     * defined in mathALib.s.
     */

    /* Double-precision routines */

    mathAcosFunc     = mathSoftAcos;
    mathAsinFunc     = mathSoftAsin;
    mathAtanFunc     = mathSoftAtan;
    mathAtan2Func    = mathSoftAtan2;
    mathCbrtFunc     = mathSoftCbrt;
    mathCeilFunc     = mathSoftCeil;
    mathCosFunc      = mathSoftCos;
    mathCoshFunc     = mathSoftCosh;
    mathExpFunc      = mathSoftExp;
    mathFabsFunc     = mathSoftFabs;
    mathFmodFunc     = (DBLFUNCPTR) mathSoftFmod;	/* unsupported */
    mathFloorFunc    = mathSoftFloor;
    mathHypotFunc    = mathSoftHypot;
    mathInfinityFunc = mathSoftInfinity;
    mathIrintFunc    = (FUNCPTR) mathSoftIrint;		/* unsupported */
    mathIroundFunc   = (FUNCPTR) mathSoftIround;	/* unsupported */
    mathLogFunc      = mathSoftLog;
    mathLog2Func     = mathSoftLog2;
    mathLog10Func    = mathSoftLog10;
    mathPowFunc      = mathSoftPow;
    mathRoundFunc    = (DBLFUNCPTR) mathSoftRound;	/* unsupported */
    mathSinFunc      = mathSoftSin;
    mathSincosFunc   = mathSoftSincos;
    mathSinhFunc     = mathSoftSinh;
    mathSqrtFunc     = mathSoftSqrt;
    mathTanFunc      = mathSoftTan;
    mathTanhFunc     = mathSoftTanh;
    mathTruncFunc    = (DBLFUNCPTR) mathSoftTrunc;	/* unsupported */

    /* Single-precision routines */

    mathAcosfFunc     = (FLTFUNCPTR)mathSoftAcosf;
    mathAsinfFunc     = (FLTFUNCPTR)mathSoftAsinf;
    mathAtanfFunc     = mathSoftAtanf;
    mathAtan2fFunc    = (FLTFUNCPTR)mathSoftAtan2f;
    mathCbrtfFunc     = (FLTFUNCPTR)mathSoftCbrtf;
    mathCeilfFunc     = (FLTFUNCPTR)mathSoftCeilf;
    mathCosfFunc      = mathSoftCosf;
    mathCoshfFunc     = (FLTFUNCPTR) mathSoftCoshf;	/* unsupported */
    mathExpfFunc      = mathSoftExpf;
    mathFabsfFunc     = (FLTFUNCPTR)mathSoftFabsf;
    mathFmodfFunc     = (FLTFUNCPTR) mathSoftFmodf;	/* unsupported */
    mathFloorfFunc    = mathSoftFloorf;
    mathHypotfFunc    = (FLTFUNCPTR)mathSoftHypotf;
    mathInfinityfFunc = mathSoftInfinityf;
    mathIrintfFunc    = (FUNCPTR) mathSoftIrintf;	/* unsupported */
    mathIroundfFunc   = (FUNCPTR) mathSoftIroundf;	/* unsupported */
    mathLogfFunc      = mathSoftLogf;
    mathLog2fFunc     = (FLTFUNCPTR)mathSoftLog2f;
    mathLog10fFunc    = mathSoftLog10f;
    mathPowfFunc      = (FLTFUNCPTR)mathSoftPowf;
    mathRoundfFunc    = (FLTFUNCPTR) mathSoftRoundf;	/* unsupported */
    mathSinfFunc      = mathSoftSinf;
    mathSincosfFunc   = (VOIDFUNCPTR)mathSoftSincosf;
    mathSinhfFunc     = (FLTFUNCPTR) mathSoftSinhf;	/* unsupported */
    mathSqrtfFunc     = mathSoftSqrtf;
    mathTanfFunc      = mathSoftTanf;
    mathTanhfFunc     = (FLTFUNCPTR) mathSoftTanhf;	/* unsupported */
    mathTruncfFunc    = (FLTFUNCPTR) mathSoftTruncf;	/* unsupported */

    }

/******************************************************************************
*
* mathSoftFabs - software floating point absolute value
*
* This routine takes the input double-precision floating point
* parameter and returns the absolute value.
*
* RETURNS: double-precision absolute value.
*/

LOCAL double mathSoftFabs
    (
    double	dblParam
    )
    {

    return ((dblParam < 0.0) ? -dblParam : dblParam);
    }

/******************************************************************************
*
* mathSoftCeil - software floating point ceiling
*
* This routine takes the input double-precision floating point
* parameter and returns (in double-precision floating point format)
* the integer immediately greater than the input parameter.
*
* RETURNS: double-precision representation of next largest integer.
*/

LOCAL double mathSoftCeil 
    (
    double	dblParam
    )
    {
    if (dblParam <= 0.0 && dblParam > -1.0)
	return 0.0;
    else
	return (-floor (-dblParam));
    }

/******************************************************************************
*
* mathSoftPow - software floating point power function
*
* This routine takes two input double-precision floating point
* parameters, <dblX> and <dblY>, and returns the double-precision
* value of <dblX> to the <dblY> power.
*
* INTERNAL
* The US Software emulation library has a special function for taking
* a floating point number to an integer power.  This routine therefore
* checks to see if the <dblY> parameter is an integer, and uses the
* US Software function (XTOI) if it is.
*
* RETURNS: double-precision value of <dblX> to <dblY> power.
*/

LOCAL double mathSoftPow 
    (
    double	dblX,
    double	dblY 
    )
    {

    if (isNaN(dblY))
	return (dblY);			/* dblY = NaN --> NaN */

    if (dblX == 1.0)
	return (1.0);			/* dblX = 1 --> 1 */

    if (dblY == floor (dblY))		/* int dblY --> XTOI(dblX,dblY) */
	return (mathSoftRealtoint (dblX,(long int) dblY));

    return (exp (dblY * log(dblX)));
    }

/******************************************************************************
*
* mathSoftAsin - software floating point arc sine
*
* This routine takes the input double-precision floating point
* parameter and returns the arc sine.
*
* RETURNS: double-precision arc sine value.
*/

LOCAL double mathSoftAsin 
    (
    double	dblParam 
    )
    {

    return (atan (dblParam / sqrt (1.0 - dblParam * dblParam)));
    }

/******************************************************************************
*
* mathSoftAcos - software floating point arc cosine
*
* This routine takes the input double-precision floating point
* parameter and returns the arc cosine.
*
* RETURNS: double-precision arc cosine value.
*/

LOCAL double mathSoftAcos 
    (
    double	dblParam 
    )
    {
    double 	result;

    result = atan (sqrt (1.0 - dblParam * dblParam) / dblParam);