fpmacros.c 6.5 KB

123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172737475767778798081828384858687888990919293949596979899100101102103104105106107108109110111112113114115116117118119120121122123124125126127128129130131132133134135136137138139140141142143144145146147148149150151152153154155156157158159160161162163164165166167168169170171172173174175176177178179180181182183184185186187188189190191192193194195196197198199200201202203204205206207208209210211212213214215216217218219220221222223224225226227228229230231232233234235236237238239
  1. /***********************************************************************
  2. ** File: fpmacros.c
  3. **
  4. ** Contains: C source code for implementations of floating-point
  5. ** functions which involve float format numbers, as
  6. ** defined in header <fp.h>. In particular, this file
  7. ** contains implementations of functions
  8. ** __fpclassify(d,f), __isnormal(d,f), __isfinite(d,f),
  9. ** __isnan(d,f), and __signbit(d,f). This file targets
  10. ** PowerPC platforms.
  11. **
  12. ** Written by: Robert A. Murley, Ali Sazegari
  13. **
  14. ** Copyright: c 2001 by Apple Computer, Inc., all rights reserved
  15. **
  16. ** Change History (most recent first):
  17. **
  18. ** 07 Jul 01 ram First created from fpfloatfunc.c, fp.c,
  19. ** classify.c and sign.c in MathLib v3 Mac OS9.
  20. **
  21. ***********************************************************************/
  22. #include "fp_private.h"
  23. #define SIGN_MASK 0x80000000
  24. #define NSIGN_MASK 0x7fffffff
  25. #define FEXP_MASK 0x7f800000
  26. #define FFRAC_MASK 0x007fffff
  27. /***********************************************************************
  28. long int __fpclassifyf(float x) returns the classification code of the
  29. argument x, as defined in <fp.h>.
  30. Exceptions: INVALID signaled if x is a signaling NaN; in this case,
  31. the FP_QNAN code is returned.
  32. Calls: none
  33. ***********************************************************************/
  34. long int __fpclassifyf ( float x )
  35. {
  36. unsigned long int iexp;
  37. union {
  38. unsigned long int lval;
  39. float fval;
  40. } z;
  41. z.fval = x;
  42. iexp = z.lval & FEXP_MASK; /* isolate float exponent */
  43. if (iexp == FEXP_MASK) { /* NaN or INF case */
  44. if ((z.lval & 0x007fffff) == 0)
  45. return (long int) FP_INFINITE;
  46. else if ((z.lval & 0x00400000) != 0)
  47. return (long int) FP_QNAN;
  48. else
  49. return (long int) FP_SNAN;
  50. }
  51. if (iexp != 0) /* normal float */
  52. return (long int) FP_NORMAL;
  53. if (x == 0.0)
  54. return (long int) FP_ZERO; /* zero */
  55. else
  56. return (long int) FP_SUBNORMAL; /* must be subnormal */
  57. }
  58. /***********************************************************************
  59. Function __fpclassify,
  60. Implementation of classify of a double number for the PowerPC.
  61. Exceptions: INVALID signaled if x is a signaling NaN; in this case,
  62. the FP_QNAN code is returned.
  63. Calls: none
  64. ***********************************************************************/
  65. long int __fpclassify ( double arg )
  66. {
  67. register unsigned long int exponent;
  68. union
  69. {
  70. dHexParts hex;
  71. double dbl;
  72. } x;
  73. x.dbl = arg;
  74. exponent = x.hex.high & dExpMask;
  75. if ( exponent == dExpMask )
  76. {
  77. if ( ( ( x.hex.high & dHighMan ) | x.hex.low ) == 0 )
  78. return (long int) FP_INFINITE;
  79. else
  80. return ( x.hex.high & 0x00080000 ) ? FP_QNAN : FP_SNAN;
  81. }
  82. else if ( exponent != 0)
  83. return (long int) FP_NORMAL;
  84. else {
  85. if ( arg == 0.0 )
  86. return (long int) FP_ZERO;
  87. else
  88. return (long int) FP_SUBNORMAL;
  89. }
  90. }
  91. /***********************************************************************
  92. long int __isnormalf(float x) returns nonzero if and only if x is a
  93. normalized float number and zero otherwise.
  94. Exceptions: INVALID is raised if x is a signaling NaN; in this case,
  95. zero is returned.
  96. Calls: none
  97. ***********************************************************************/
  98. long int __isnormalf ( float x )
  99. {
  100. unsigned long int iexp;
  101. union {
  102. unsigned long int lval;
  103. float fval;
  104. } z;
  105. z.fval = x;
  106. iexp = z.lval & FEXP_MASK; /* isolate float exponent */
  107. return ((iexp != FEXP_MASK) && (iexp != 0));
  108. }
  109. long int __isnorma ( double x )
  110. {
  111. return ( __fpclassify ( x ) == FP_NORMAL );
  112. }
  113. /***********************************************************************
  114. long int __isfinitef(float x) returns nonzero if and only if x is a
  115. finite (normal, subnormal, or zero) float number and zero otherwise.
  116. Exceptions: INVALID is raised if x is a signaling NaN; in this case,
  117. zero is returned.
  118. Calls: none
  119. ***********************************************************************/
  120. long int __isfinitef ( float x )
  121. {
  122. union {
  123. unsigned long int lval;
  124. float fval;
  125. } z;
  126. z.fval = x;
  127. return ((z.lval & FEXP_MASK) != FEXP_MASK);
  128. }
  129. long int __isfinite ( double x )
  130. {
  131. return ( __fpclassify ( x ) >= FP_ZERO );
  132. }
  133. /***********************************************************************
  134. long int __isnanf(float x) returns nonzero if and only if x is a
  135. NaN and zero otherwise.
  136. Exceptions: INVALID is raised if x is a signaling NaN; in this case,
  137. nonzero is returned.
  138. Calls: none
  139. ***********************************************************************/
  140. long int __isnanf ( float x )
  141. {
  142. union {
  143. unsigned long int lval;
  144. float fval;
  145. } z;
  146. z.fval = x;
  147. return (((z.lval&FEXP_MASK) == FEXP_MASK) && ((z.lval&FFRAC_MASK) != 0));
  148. }
  149. long int __isnan ( double x )
  150. {
  151. long int class = __fpclassify(x);
  152. return ( ( class == FP_SNAN ) || ( class == FP_QNAN ) );
  153. }
  154. /***********************************************************************
  155. long int __signbitf(float x) returns nonzero if and only if the sign
  156. bit of x is set and zero otherwise.
  157. Exceptions: INVALID is raised if x is a signaling NaN.
  158. Calls: none
  159. ***********************************************************************/
  160. long int __signbitf ( float x )
  161. {
  162. union {
  163. unsigned long int lval;
  164. float fval;
  165. } z;
  166. z.fval = x;
  167. return ((z.lval & SIGN_MASK) != 0);
  168. }
  169. /***********************************************************************
  170. Function sign of a double.
  171. Implementation of sign bit for the PowerPC.
  172. Calls: none
  173. ***********************************************************************/
  174. long int __signbit ( double arg )
  175. {
  176. union
  177. {
  178. dHexParts hex;
  179. double dbl;
  180. } x;
  181. long int sign;
  182. x.dbl = arg;
  183. sign = ( ( x.hex.high & dSgnMask ) == dSgnMask ) ? 1 : 0;
  184. return sign;
  185. }