mi32/math.h

Go to the documentation of this file.

/**
 * \file math.h <mi32/math.h>
 * \brief Math functions and prototypes, also includes standard C math hdr.
 *
 * \if NODOC
 * $Id: math.h_v 1.4 2006/07/27 14:53:10 scowan Exp $
 *
 * $Log: math.h_v $
 * Revision 1.4  2006/07/27 14:53:10  scowan
 * Include cmath.
 *
 * Revision 1.3  2006/03/10 15:48:12  mju
 * Not allowed asm on win64.
 *
 * Revision 1.2  2005/09/08 21:25:03  mju
 * Don't declare legacy round macro if no_deprecated.
 *
 * Revision 1.1  2005/07/15 16:24:42  mju
 * Initial revision
 *
 * \endif
**/

#ifndef  INC_MI32_MATH_H
#define  INC_MI32_MATH_H

#ifndef  INC_MI32_STDDEFNS_H
#include <mi32/stddefns.h>
#endif

#ifndef  INC_MATH_H
#include <math.h>
#define  INC_MATH_H
#endif

#ifndef  INC_CMATH
#include <cmath>     // Definitions for std::abs() for floating point types.
#define  INC_CMATH
#endif

#ifdef MISYSTEMDLL
   #define LIBEXPORT MI_DLLEXPORT
#else
   #define LIBEXPORT MI_DLLIMPORT
#endif


//!\addtogroup math Math Functions
//!@{

#if defined(__cplusplus)
extern "C" {
#endif

#ifndef GENERATING_DOXYGEN_OUTPUT

#if defined(WIN32)
   #if __STDC__ && _MSC_VER >= 1200
   #define hypot     _hypot
   #endif

#elif !defined(LINUX)
   double hypot (double, double);         // Define this for everywhere else except Win32.  In Win32 it is a DLL import
#endif

#endif   // GENERATING_DOXYGEN_OUTPUT

//! Returns the IEEE representation of Not A Number.
LIBEXPORT double IEEE_NaN (void);

//! Returns the IEEE representation of Infinity.
LIBEXPORT double IEEE_Infinity (void);

#if defined(__cplusplus)
}
#endif

#if defined(WIN32) && defined(__cplusplus) && !defined(WIN64)

// On Intel, avoid the _ftol() call implied by the cast to integer.
// ftol() is slow because of the way it casts.  It first has to switch
// the conversion mode of the processor from round to truncate, which
// cuases all pipelines to stall.  Then it converts the number and switches
// back to rounding mode.  That's a lot of work to truncate a number when
// the default would have been to do What We Wanted (W3)
// Accounts for Intel rounding .5 values to nearest -even- integer, corrects for up to +/- 1000000

//! Fast round of value to nearest integer, with X.5 values rounded up.
//! This function is approximately 3X faster than using static_cast<INT32>(x+.5) on Intel.
//! Accuracy limitations:
//! Values in the range from -1000000 to +1000000 at exactly .5 will be handled correctly.
//! Values outside that range may not always be rounded up.  In addition, values in the
//! range of -1000 to 1000 which are within 1E-10 of .5 may not be correctly rounded down.
//! The FAST_... functions should not be used if exact accuracy is required.
inline INT32 FAST_ROUND (double x) {
   static const double d = 1E-10;
   INT32 result;
   __asm fld x
   __asm fadd d
   __asm fistp result
   return result;
   }

//! Fast return of smallest integer greater than or equal to specified value.
//! This function is at least 5X faster than using static_cast<INT32>(ceil(x)) on Intel.
//! Accuracy limitations:
//! Values in the range from -1000000 to +1000000 at exactly .0 will be handled correctly.
//! Values outside that range may not always be correct.  In addition, values in the
//! range of -1000 to 1000 which are within 1E-10 of .0 may not be correctly rounded.
//! The FAST_... functions should not be used if exact accuracy is required.
inline INT32 FAST_CEIL (double x) {
   static const double d = .4999999999;
   INT32 result;
   __asm fld x
   __asm fadd d
   __asm fistp result
   return result;
   }

//! Fast return of largest integer less than or equal to specified value.
//! This function is at least 5X faster than using static_cast<INT32>(floor(x)) on Intel.
//! Accuracy limitations:
//! Values in the range from -1000000 to +1000000 at exactly .0 will be handled correctly.
//! Values outside that range may not always be correct.  In addition, values in the
//! range of -1000 to 1000 which are within 1E-10 of .0 may not be correctly rounded.
//! The FAST_... functions should not be used if exact accuracy is required.
inline INT32 FAST_FLOOR (double x) {
   static const double d = -.4999999999;
   INT32 result;
   __asm fld x
   __asm fadd d
   __asm fistp result
   return result;
   }

//! Fast return of largest integer less than or equal to specified value.
//! This function is at approximately 3X faster than using static_cast<INT32>(x) on Intel.
//! If values are known to always be positive (or negative) it will be faster to
//! use the FAST_FLOOR (or FAST_CEIL) function as appropriate.
//! Accuracy limitations:
//! Values in the range from -1000000 to +1000000 at exactly .0 will be handled correctly.
//! Values outside that range may not always be correct.  In addition, values in the
//! range of -1000 to 1000 which are within 1E-10 of .0 may not be correctly rounded.
//! The FAST_... functions should not be used if exact accuracy is required.
inline INT32 FAST_TRUNCATE (double x) {
   static const double d = .4999999999;
   INT32 result;
   if (x < 0) {
      __asm fld x
      __asm fadd d
      __asm fistp result
      }
   else {
      __asm fld x
      __asm fsub d
      __asm fistp result
      }
   return result;
   }


#else

#define  FAST_ROUND(d)     static_cast<INT32>(floor((d)+.5))
#define  FAST_CEIL(d)      static_cast<INT32>(ceil(d))
#define  FAST_FLOOR(d)     static_cast<INT32>(floor(d))
#define  FAST_TRUNCATE(d)  static_cast<INT32>(d)

#endif

#ifndef  NO_DEPRECATED
//! \deprecated Replaced by FAST_ROUND
#define  ROUND FAST_ROUND
#ifdef WIN32
#pragma deprecated("ROUND")
#endif
#endif

//----------------------------------------------------------------------------
//    Macros for determine special floating-point values                
//----------------------------------------------------------------------------

/*
 * Determination of IEEE NaN:  On most systems, the high word is
 * 0x7FF8 or 0xFFF8 (high bit is sign)
 * The 3 systems that don't seem to conform to this rule are:
 *    HPUX:  High word is 0x7FF4
 *    SGI:   High word is 0x7FFF
 */

#if defined(BYTEORDER_HiLo)
   #if defined(SGI)
      #define IsNaN(x) ( (x) != (x) )
   #elif defined(HP_APOLLO)
      #define IsNaN(x) ( ( ( (UINT16*)&(x) )[0] & 0x7FFF) == 0x7FF4)
   #else
      #if defined(__cplusplus)
         inline bool IsNaN (double x) {return ((reinterpret_cast<UINT16*>(&x)[0] & 0x7FF8) == 0x7FF8);}
      #else 
         #define IsNaN(x) ( ( ( (UINT16*)&(x) )[0] & 0x7FF8) == 0x7FF8)
      #endif
   #endif
#else
   #if defined(__cplusplus)
      inline bool IsNaN (const double& x) {return ((reinterpret_cast<const UINT16*>(&x)[3] & 0x7FF8) == 0x7FF8);}
   #else 
      #define IsNaN(x) ( ( ( (UINT16*)&(x) )[3] & 0x7FF8) == 0x7FF8)
   #endif
#endif


#ifdef BYTEORDER_HiLo
   #if defined(__cplusplus)
      inline bool IsInfPos (double x) {return ((reinterpret_cast<UINT16*>(&x)[0] & 0x7FFF) == 0x7FF0);}
   #else 
      #define IsInfPos(x) ( ( ( (UINT16*)&(x) )[0] & 0x7FFF) == 0x7FF0)
   #endif
#else
   #if defined(__cplusplus)
      inline bool IsInfPos (double x) {return ((reinterpret_cast<UINT16*>(&x)[3] & 0x7FFF) == 0x7FF0);}
   #else 
      #define IsInfPos(x) ( ( ( (UINT16*)&(x) )[3] & 0x7FFF) == 0x7FF0)
   #endif
#endif


#ifndef  NO_DEPRECATED

#ifndef NAN
// If already defined, assume it's a better defn
#define NAN IEEE_NaN()
#endif

#define IND IEEE_NaN()
#define INF IEEE_Infinity()
#define NINF (-IEEE_Infinity())

#ifdef WIN32
#pragma deprecated("NAN")
#pragma deprecated("IND")
#pragma deprecated("INF")
#pragma deprecated("NINF")
#endif

#endif   // NO_DEPRECATED


//! Convert IEEE floating point to VAX floating point
void ConvIEEEToVAX (
   double ieee_value,         //!< IEEE floating point value
   UINT8 *vax_value        //!< Pointer to 8 byte UINT8 array for VAX floating point value
   );

//! Convert VAX floating point to IEEE floating point
//!
//! @return: IEEE floating point value
double ConvVAXToIEEE (
   const UINT8 *vax_value        //!< Pointer to 8 byte UINT8 array for VAX floating point value
   );

//!@}

#undef LIBEXPORT

#endif   // INC_MI32_MATH_H

---