开通博客赚积分
发布资源赚积分
分类

源码开发语言/平台
当前位置：首页 > 源码/资料 > Windows编程 > 多媒体编程 > 查看源码
fp.h
资源名称：fullMPCcode.rar　[点击查看]
上传用户：xjjlds
上传日期：2015-12-05
资源大小：22823k
文件大小：41k
源码类别：

多媒体编程

开发平台：

Visual C++

fp.h：源码内容
  1. /*
  2.      File:       fp.h
  3.  
  4.      Contains:   FPCE Floating-Point Definitions and Declarations.
  5.  
  6.      Version:    Technology: MathLib v2
  7.                  Release:    QuickTime 6.0.2
  8.  
  9.      Copyright:  (c) 1987-2001 by Apple Computer, Inc., all rights reserved.
  10.  
  11.      Bugs?:      For bug reports, consult the following page on
  12.                  the World Wide Web:
  13.  
  14.                      http://developer.apple.com/bugreporter/
  15.  
  16. */
  17. #ifndef __FP__
  18. #define __FP__
  20. #ifndef __CONDITIONALMACROS__
  21. #include "ConditionalMacros.h"
  22. #endif
  24. #ifndef __MACTYPES__
  25. #include "MacTypes.h"
  26. #endif
  29. /********************************************************************************
  30. *                                                                               *
  31. *    A collection of numerical functions designed to facilitate a wide          *
  32. *    range of numerical programming as required by C9X.                         *
  33. *                                                                               *
  34. *    The <fp.h> declares many functions in support of numerical programming.    *
  35. *    It provides a superset of <math.h> and <SANE.h> functions.  Some           *
  36. *    functionality previously found in <SANE.h> and not in the FPCE <fp.h>      *
  37. *    can be found in this <fp.h> under the heading "__NOEXTENSIONS__".          *
  38. *                                                                               *
  39. *    All of these functions are IEEE 754 aware and treat exceptions, NaNs,      *
  40. *    positive and negative zero and infinity consistent with the floating-      *
  41. *    point standard.                                                            *
  42. *                                                                               *
  43. ********************************************************************************/
  47. #if PRAGMA_ONCE
  48. #pragma once
  49. #endif
  51. #ifdef __cplusplus
  52. extern "C" {
  53. #endif
  55. #if PRAGMA_IMPORT
  56. #pragma import on
  57. #endif
  59. #if PRAGMA_STRUCT_ALIGN
  60.     #pragma options align=mac68k
  61. #elif PRAGMA_STRUCT_PACKPUSH
  62.     #pragma pack(push, 2)
  63. #elif PRAGMA_STRUCT_PACK
  64.     #pragma pack(2)
  65. #endif
  67. /********************************************************************************
  68. *                                                                               *
  69. *                            Efficient types                                    *
  70. *                                                                               *
  71. *    float_t         Most efficient type at least as wide as float              *
  72. *    double_t        Most efficient type at least as wide as double             *
  73. *                                                                               *
  74. *      CPU            float_t(bits)                double_t(bits)               *
  75. *    --------        -----------------            -----------------             *
  76. *    PowerPC          float(32)                    double(64)                   *
  77. *    68K              long double(80/96)           long double(80/96)           *
  78. *    x86              long double(80)              long double(80)              *
  79. *                                                                               *
  80. ********************************************************************************/
  81. #if defined(__MWERKS__) && defined(__cmath__)
  82. /* these types were already defined in MSL's math.h */
  83. #else
  84. #if TARGET_CPU_PPC
  85. typedef float                           float_t;
  86. typedef double                          double_t;
  87. #elif TARGET_CPU_68K
  88. typedef long double                     float_t;
  89. typedef long double                     double_t;
  90. #elif TARGET_CPU_X86
  91. #if NeXT || TARGET_OS_MAC
  92. typedef double                          float_t;
  93. typedef double                          double_t;
  94. #else
  95. typedef long double                     float_t;
  96. typedef long double                     double_t;
  97. #endif  /* NeXT || TARGET_OS_MAC */
  99. #elif TARGET_CPU_MIPS
  100. typedef double                          float_t;
  101. typedef double                          double_t;
  102. #elif TARGET_CPU_ALPHA
  103. typedef double                          float_t;
  104. typedef double                          double_t;
  105. #elif TARGET_CPU_SPARC
  106. typedef double                          float_t;
  107. typedef double                          double_t;
  108. #else
  109. #error unsupported CPU
  110. #endif  /*  */
  112. /********************************************************************************
  113. *                                                                               *
  114. *                              Define some constants.                           *
  115. *                                                                               *
  116. *    HUGE_VAL            IEEE 754 value of infinity.                            *
  117. *    INFINITY            IEEE 754 value of infinity.                            *
  118. *    NAN                 A generic NaN (Not A Number).                          *
  119. *    DECIMAL_DIG         Satisfies the constraint that the conversion from      *
  120. *                        double to decimal and back is the identity function.   *
  121. *                                                                               *
  122. ********************************************************************************/
  123. #if TARGET_OS_MAC
  124.   #if TARGET_RT_MAC_MACHO
  125.     #define   HUGE_VAL                1e500 /* compatible with bsd math.h */
  126.   #else
  127.     #define   HUGE_VAL                __inf()
  128.   #endif
  129.   #define     INFINITY                __inf()
  130.   #define     NAN                     nan("255")
  131. #else
  132.   #define     NAN                     sqrt(-1)
  133. #endif
  135. #if TARGET_CPU_PPC
  136.     #define      DECIMAL_DIG              17 /* does not exist for double-double */
  137. #elif TARGET_CPU_68K
  138.     #define      DECIMAL_DIG              21
  139. #endif      
  140. #endif  /* __MWERKS__ && __cmath__ */
  141. #if TARGET_OS_MAC
  142. /* MSL already defines these */
  143. #if !defined(__MWERKS__) || !defined(__cmath__)
  144. /********************************************************************************
  145. *                                                                               *
  146. *                            Trigonometric functions                            *
  147. *                                                                               *
  148. *   acos        result is in [0,pi].                                            *
  149. *   asin        result is in [-pi/2,pi/2].                                      *
  150. *   atan        result is in [-pi/2,pi/2].                                      *
  151. *   atan2       Computes the arc tangent of y/x in [-pi,pi] using the sign of   *
  152. *               both arguments to determine the quadrant of the computed value. *
  153. *                                                                               *
  154. ********************************************************************************/
  155. EXTERN_API_C( double_t ) cos(double_t x);
  157. EXTERN_API_C( double_t ) sin(double_t x);
  159. EXTERN_API_C( double_t ) tan(double_t x);
  161. EXTERN_API_C( double_t ) acos(double_t x);
  163. EXTERN_API_C( double_t ) asin(double_t x);
  165. EXTERN_API_C( double_t ) atan(double_t x);
  167. EXTERN_API_C( double_t ) atan2(double_t y, double_t x);
  171. /********************************************************************************
  172. *                                                                               *
  173. *                              Hyperbolic functions                             *
  174. *                                                                               *
  175. ********************************************************************************/
  176. EXTERN_API_C( double_t ) cosh(double_t x);
  178. EXTERN_API_C( double_t ) sinh(double_t x);
  180. EXTERN_API_C( double_t ) tanh(double_t x);
  182. EXTERN_API_C( double_t ) acosh(double_t x);
  184. EXTERN_API_C( double_t ) asinh(double_t x);
  186. EXTERN_API_C( double_t ) atanh(double_t x);
  190. /********************************************************************************
  191. *                                                                               *
  192. *                              Exponential functions                            *
  193. *                                                                               *
  194. *   expm1       expm1(x) = exp(x) - 1.  But, for small enough arguments,        *
  195. *               expm1(x) is expected to be more accurate than exp(x) - 1.       *
  196. *   frexp       Breaks a floating-point number into a normalized fraction       *
  197. *               and an integral power of 2.  It stores the integer in the       *
  198. *               object pointed by *exponent.                                    *
  199. *   ldexp       Multiplies a floating-point number by an integer power of 2.    *
  200. *   log1p       log1p = log(1 + x). But, for small enough arguments,            *
  201. *               log1p is expected to be more accurate than log(1 + x).          *
  202. *   logb        Extracts the exponent of its argument, as a signed integral     *
  203. *               value. A subnormal argument is treated as though it were first  *
  204. *               normalized. Thus:                                               *
  205. *                                  1   <=   x * 2^(-logb(x))   <   2            *
  206. *   modf        Returns fractional part of x as function result and returns     *
  207. *               integral part of x via iptr. Note C9X uses double not double_t. *
  208. *   scalb       Computes x * 2^n efficently.  This is not normally done by      *
  209. *               computing 2^n explicitly.                                       *
  210. *                                                                               *
  211. ********************************************************************************/
  212. EXTERN_API_C( double_t ) exp(double_t x);
  214. EXTERN_API_C( double_t ) expm1(double_t x);
  216. EXTERN_API_C( double_t ) exp2(double_t x);
  218. EXTERN_API_C( double_t ) frexp(double_t x, int *exponent);
  220. EXTERN_API_C( double_t ) ldexp(double_t x, int n);
  222. EXTERN_API_C( double_t ) log(double_t x);
  224. EXTERN_API_C( double_t ) log2(double_t x);
  226. EXTERN_API_C( double_t ) log1p(double_t x);
  228. EXTERN_API_C( double_t ) log10(double_t x);
  230. EXTERN_API_C( double_t ) logb(double_t x);
  232. #if !TARGET_RT_MAC_MACHO
  233. EXTERN_API_C( long double ) modfl(long double x, long double *iptrl);
  235. #endif  /* !TARGET_RT_MAC_MACHO */
  237. EXTERN_API_C( double_t ) modf(double_t x, double_t *iptr);
  239. EXTERN_API_C( float ) modff(float x, float *iptrf);
  242. EXTERN_API_C( double_t ) scalb(double_t x, long n);
  244. /********************************************************************************
  245. *                                                                               *
  246. *                     Power and absolute value functions                        *
  247. *                                                                               *
  248. *   hypot       Computes the square root of the sum of the squares of its       *
  249. *               arguments, without undue overflow or underflow.                 *
  250. *   pow         Returns x raised to the power of y.  Result is more accurate    *
  251. *               than using exp(log(x)*y).                                       *
  252. *                                                                               *
  253. ********************************************************************************/
  254. EXTERN_API_C( double_t ) fabs(double_t x);
  256. EXTERN_API_C( double_t ) hypot(double_t x, double_t y);
  258. EXTERN_API_C( double_t ) pow(double_t x, double_t y);
  260. EXTERN_API_C( double_t ) sqrt(double_t x);
  264. /********************************************************************************
  265. *                                                                               *
  266. *                        Gamma and Error functions                              *
  267. *                                                                               *
  268. *   erf         The error function.                                             *
  269. *   erfc        Complementary error function.                                   *
  270. *   gamma       The gamma function.                                             *
  271. *   lgamma      Computes the base-e logarithm of the absolute value of          *
  272. *               gamma of its argument x, for x > 0.                             *
  273. *                                                                               *
  274. ********************************************************************************/
  275. EXTERN_API_C( double_t ) erf(double_t x);
  277. EXTERN_API_C( double_t ) erfc(double_t x);
  279. EXTERN_API_C( double_t ) gamma(double_t x);
  281. EXTERN_API_C( double_t ) lgamma(double_t x);
  285. /********************************************************************************
  286. *                                                                               *
  287. *                        Nearest integer functions                              *
  288. *                                                                               *
  289. *   rint        Rounds its argument to an integral value in floating point      *
  290. *               format, honoring the current rounding direction.                *
  291. *                                                                               *
  292. *   nearbyint   Differs from rint only in that it does not raise the inexact    *
  293. *               exception. It is the nearbyint function recommended by the      *
  294. *               IEEE floating-point standard 854.                               *
  295. *                                                                               *
  296. *   rinttol     Rounds its argument to the nearest long int using the current   *
  297. *               rounding direction.  NOTE: if the rounded value is outside      *
  298. *               the range of long int, then the result is undefined.            *
  299. *                                                                               *
  300. *   round       Rounds the argument to the nearest integral value in floating   *
  301. *               point format similar to the Fortran "anint" function. That is:  *
  302. *               add half to the magnitude and chop.                             *
  303. *                                                                               *
  304. *   roundtol    Similar to the Fortran function nint or to the Pascal round.    *
  305. *               NOTE: if the rounded value is outside the range of long int,    *
  306. *               then the result is undefined.                                   *
  307. *                                                                               *
  308. *   trunc       Computes the integral value, in floating format, nearest to     *
  309. *               but no larger in magnitude than its argument.   NOTE: on 68K    *
  310. *               compilers when using -elems881, trunc must return an int        *
  311. *                                                                               *
  312. ********************************************************************************/
  313. EXTERN_API_C( double_t ) ceil(double_t x);
  315. EXTERN_API_C( double_t ) floor(double_t x);
  317. EXTERN_API_C( double_t ) rint(double_t x);
  319. EXTERN_API_C( double_t ) nearbyint(double_t x);
  321. EXTERN_API_C( long ) rinttol(double_t x);
  323. EXTERN_API_C( double_t ) round(double_t x);
  325. EXTERN_API_C( long ) roundtol(double_t round);
  327. #if TARGET_RT_MAC_68881
  328. #if CALL_NOT_IN_CARBON
  329. EXTERN_API_C( int ) trunc(double_t x);
  331. #endif  /* CALL_NOT_IN_CARBON */
  333. #else
  334. EXTERN_API_C( double_t ) trunc(double_t x);
  336. #endif  /* TARGET_RT_MAC_68881 */
  339. /********************************************************************************
  340. *                                                                               *
  341. *                            Remainder functions                                *
  342. *                                                                               *
  343. *   remainder       IEEE 754 floating point standard for remainder.             *
  344. *   remquo          SANE remainder.  It stores into 'quotient' the 7 low-order  *
  345. *                   bits of the integer quotient x/y, such that:                *
  346. *                       -127 <= quotient <= 127.                                *
  347. *                                                                               *
  348. ********************************************************************************/
  349. EXTERN_API_C( double_t ) fmod(double_t x, double_t y);
  351. EXTERN_API_C( double_t ) remainder(double_t x, double_t y);
  353. EXTERN_API_C( double_t ) remquo(double_t x, double_t y, int *quo);
  357. /********************************************************************************
  358. *                                                                               *
  359. *                             Auxiliary functions                               *
  360. *                                                                               *
  361. *   copysign        Produces a value with the magnitude of its first argument   *
  362. *                   and sign of its second argument.  NOTE: the order of the    *
  363. *                   arguments matches the recommendation of the IEEE 754        *
  364. *                   floating point standard,  which is opposite from the SANE   *
  365. *                   copysign function.                                          *
  366. *                                                                               *
  367. *   nan             The call 'nan("n-char-sequence")' returns a quiet NaN       *
  368. *                   with content indicated through tagp in the selected         *
  369. *                   data type format.                                           *
  370. *                                                                               *
  371. *   nextafter       Computes the next representable value after 'x' in the      *
  372. *                   direction of 'y'.  if x == y, then y is returned.           *
  373. *                                                                               *
  374. ********************************************************************************/
  375. EXTERN_API_C( double_t ) copysign(double_t x, double_t y);
  377. #if !TARGET_RT_MAC_MACHO
  378. EXTERN_API_C( long double ) nanl(const char *tagp);
  380. #else
  381. #define nanl(tagp) ((long double)nan(tagp))
  382. #endif  /* !TARGET_RT_MAC_MACHO */
  384. EXTERN_API_C( double ) nan(const char *tagp);
  386. EXTERN_API_C( float ) nanf(const char *tagp);
  388. #if !TARGET_RT_MAC_MACHO
  389. EXTERN_API_C( long double ) nextafterl(long double x, long double y);
  391. #else
  392. #define nextafterl(x,y) ((long double)nextafter((double)x,(double)y))
  393. #endif  /* !TARGET_RT_MAC_MACHO */
  395. EXTERN_API_C( double ) nextafterd(double x, double y);
  397. EXTERN_API_C( float ) nextafterf(float x, float y);
  401. /********************************************************************************
  402. *                                                                               *
  403. *                              Inquiry macros                                   *
  404. *                                                                               *
  405. *   fpclassify      Returns one of the FP_* values.                             *
  406. *   isnormal        Non-zero if and only if the argument x is normalized.       *
  407. *   isfinite        Non-zero if and only if the argument x is finite.           *
  408. *   isnan           Non-zero if and only if the argument x is a NaN.            *
  409. *   signbit         Non-zero if and only if the sign of the argument x is       *
  410. *                   negative.  This includes, NaNs, infinities and zeros.       *
  411. *                                                                               *
  412. ********************************************************************************/
  413. enum {
  414.     FP_SNAN                     = 0,                            /*      signaling NaN                         */
  415.     FP_QNAN                     = 1,                            /*      quiet NaN                             */
  416.     FP_INFINITE                 = 2,                            /*      + or - infinity                       */
  417.     FP_ZERO                     = 3,                            /*      + or - zero                           */
  418.     FP_NORMAL                   = 4,                            /*      all normal numbers                    */
  419.     FP_SUBNORMAL                = 5                             /*      denormal numbers                      */
  420. };
  425. #if TARGET_RT_MAC_MACHO
  426. #define __fpclassify(x) __fpclassifyd((double)x)
  427. #define __isnormal(x)   __isnormald((double)x)
  428. #define __isfinite(x)   __isfinited((double)x)
  429. #define __isnan(x)      __isnand((double)x)
  430. #define __signbit(x)    __signbitd((double)x)
  431. #endif
  433. #define      fpclassify(x)    ( ( sizeof ( x ) == sizeof(long double) ) ?      
  434.                               __fpclassify  ( x ) :                            
  435.                                 ( sizeof ( x ) == sizeof(double) ) ?           
  436.                               __fpclassifyd ( x ) :                            
  437.                               __fpclassifyf ( x ) )
  438. #define      isnormal(x)      ( ( sizeof ( x ) == sizeof(long double) ) ?      
  439.                               __isnormal ( x ) :                               
  440.                                 ( sizeof ( x ) == sizeof(double) ) ?           
  441.                               __isnormald ( x ) :                              
  442.                               __isnormalf ( x ) )
  443. #define      isfinite(x)      ( ( sizeof ( x ) == sizeof(long double) ) ?      
  444.                               __isfinite ( x ) :                               
  445.                                 ( sizeof ( x ) == sizeof(double) ) ?           
  446.                               __isfinited ( x ) :                              
  447.                               __isfinitef ( x ) )
  448. #define      isnan(x)         ( ( sizeof ( x ) == sizeof(long double) ) ?      
  449.                               __isnan ( x ) :                                  
  450.                               ( sizeof ( x ) == sizeof(double) ) ?             
  451.                               __isnand ( x ) :                                 
  452.                               __isnanf ( x ) )
  453. #define      signbit(x)       ( ( sizeof ( x ) == sizeof(long double) ) ?      
  454.                               __signbit ( x ) :                                
  455.                               ( sizeof ( x ) == sizeof(double) ) ?             
  456.                               __signbitd ( x ) :                               
  457.                               __signbitf ( x ) )
  460. #if !TARGET_RT_MAC_MACHO
  461. EXTERN_API_C( long ) __fpclassify(long double x);
  463. #endif  /* !TARGET_RT_MAC_MACHO */
  465. EXTERN_API_C( long ) __fpclassifyd(double x);
  467. EXTERN_API_C( long ) __fpclassifyf(float x);
  469. #if !TARGET_RT_MAC_MACHO
  470. EXTERN_API_C( long ) __isnormal(long double x);
  472. #endif  /* !TARGET_RT_MAC_MACHO */
  474. EXTERN_API_C( long ) __isnormald(double x);
  476. EXTERN_API_C( long ) __isnormalf(float x);
  478. #if !TARGET_RT_MAC_MACHO
  479. EXTERN_API_C( long ) __isfinite(long double x);
  481. #endif  /* !TARGET_RT_MAC_MACHO */
  483. EXTERN_API_C( long ) __isfinited(double x);
  485. EXTERN_API_C( long ) __isfinitef(float x);
  487. #if !TARGET_RT_MAC_MACHO
  488. EXTERN_API_C( long ) __isnan(long double x);
  490. #endif  /* !TARGET_RT_MAC_MACHO */
  492. EXTERN_API_C( long ) __isnand(double x);
  494. EXTERN_API_C( long ) __isnanf(float x);
  496. #if !TARGET_RT_MAC_MACHO
  497. EXTERN_API_C( long ) __signbit(long double x);
  499. #endif  /* !TARGET_RT_MAC_MACHO */
  501. EXTERN_API_C( long ) __signbitd(double x);
  503. EXTERN_API_C( long ) __signbitf(float x);
  505. EXTERN_API_C( double_t ) __inf(void );
  509. /********************************************************************************
  510. *                                                                               *
  511. *                      Max, Min and Positive Difference                         *
  512. *                                                                               *
  513. *   fdim        Determines the 'positive difference' between its arguments:     *
  514. *               { x - y, if x > y }, { +0, if x <= y }.  If one argument is     *
  515. *               NaN, then fdim returns that NaN.  if both arguments are NaNs,   *
  516. *               then fdim returns the first argument.                           *
  517. *                                                                               *
  518. *   fmax        Returns the maximum of the two arguments.  Corresponds to the   *
  519. *               max function in FORTRAN.  NaN arguments are treated as missing  *
  520. *               data.  If one argument is NaN and the other is a number, then   *
  521. *               the number is returned.  If both are NaNs then the first        *
  522. *               argument is returned.                                           *
  523. *                                                                               *
  524. *   fmin        Returns the minimum of the two arguments.  Corresponds to the   *
  525. *               min function in FORTRAN.  NaN arguments are treated as missing  *
  526. *               data.  If one argument is NaN and the other is a number, then   *
  527. *               the number is returned.  If both are NaNs then the first        *
  528. *               argument is returned.                                           *
  529. *                                                                               *
  530. ********************************************************************************/
  531. EXTERN_API_C( double_t ) fdim(double_t x, double_t y);
  533. EXTERN_API_C( double_t ) fmax(double_t x, double_t y);
  535. EXTERN_API_C( double_t ) fmin(double_t x, double_t y);
  537. #endif /* !defined(__MWERKS__) || !defined(__cmath__) */
  539. /*******************************************************************************
  540. *                                Constants                                     *
  541. *******************************************************************************/
  542. extern const double_t pi;
  543. /********************************************************************************
  544. *                                                                               *
  545. *                              Non NCEG extensions                              *
  546. *                                                                               *
  547. ********************************************************************************/
  548. #ifndef __NOEXTENSIONS__
  549. /********************************************************************************
  550. *                                                                               *
  551. *                              Financial functions                              *
  552. *                                                                               *
  553. *   compound        Computes the compound interest factor "(1 + rate)^periods"  *
  554. *                   more accurately than the straightforward computation with   *
  555. *                   the Power function.  This is SANE's compound function.      *
  556. *                                                                               *
  557. *   annuity         Computes the present value factor for an annuity            *
  558. *                   "(1 - (1 + rate)^(-periods)) /rate" more accurately than    *
  559. *                   the straightforward computation with the Power function.    *
  560. *                   This is SANE's annuity function.                            *
  561. *                                                                               *
  562. ********************************************************************************/
  563. EXTERN_API_C( double_t ) compound(double_t rate, double_t periods);
  565. EXTERN_API_C( double_t ) annuity(double_t rate, double_t periods);
  569. /********************************************************************************
  570. *                                                                               *
  571. *                              Random function                                  *
  572. *                                                                               *
  573. *   randomx         A pseudorandom number generator.  It uses the iteration:    *
  574. *                               (7^5*x)mod(2^31-1)                              *
  575. *                                                                               *
  576. ********************************************************************************/
  577. EXTERN_API_C( double_t ) randomx(double_t *x);
  581. /*******************************************************************************
  582. *                              Relational operator                             *
  583. *******************************************************************************/
  584. /*      relational operator      */
  585. typedef short                           relop;
  586. enum {
  587.     GREATERTHAN                 = 0,
  588.     LESSTHAN                    = 1,
  589.     EQUALTO                     = 2,
  590.     UNORDERED                   = 3
  591. };
  593. #if !defined(__MWERKS__) || !defined(__cmath__)
  594. EXTERN_API_C( relop ) relation(double_t x, double_t y);
  596. #endif /* !defined(__MWERKS__) || !defined(__cmath__) */
  599. /********************************************************************************
  600. *                                                                               *
  601. *                         Binary to decimal conversions                         *
  602. *                                                                               *
  603. *   SIGDIGLEN   Significant decimal digits.                                     *
  604. *                                                                               *
  605. *   decimal     A record which provides an intermediate unpacked form for       *
  606. *               programmers who wish to do their own parsing of numeric input   *
  607. *               or formatting of numeric output.                                *
  608. *                                                                               *
  609. *   decform     Controls each conversion to a decimal string.  The style field  *
  610. *               is either FLOATDECIMAL or FIXEDDECIMAL. If FLOATDECIMAL, the    *
  611. *               value of the field digits is the number of significant digits.  *
  612. *               If FIXEDDECIMAL value of the field digits is the number of      *
  613. *               digits to the right of the decimal point.                       *
  614. *                                                                               *
  615. *   num2dec     Converts a double_t to a decimal record using a decform.        *
  616. *   dec2num     Converts a decimal record d to a double_t value.                *
  617. *   dec2str     Converts a decform and decimal to a string using a decform.     *
  618. *   str2dec     Converts a string to a decimal struct.                          *
  619. *   dec2d       Similar to dec2num except a double is returned (68k only).      *
  620. *   dec2f       Similar to dec2num except a float is returned.                  *
  621. *   dec2s       Similar to dec2num except a short is returned.                  *
  622. *   dec2l       Similar to dec2num except a long is returned.                   *
  623. *                                                                               *
  624. ********************************************************************************/
  625. #if TARGET_CPU_PPC
  626.     #define SIGDIGLEN      36  
  627. #elif TARGET_CPU_68K
  628.     #define SIGDIGLEN      20
  629. #elif TARGET_CPU_X86
  630.     #define SIGDIGLEN      20
  631. #endif
  632. #define      DECSTROUTLEN   80               /* max length for dec2str output */
  633. #define      FLOATDECIMAL   ((char)(0))
  634. #define      FIXEDDECIMAL   ((char)(1))
  635. struct decimal {
  636.     char                            sgn;                        /* sign 0 for +, 1 for - */
  637.     char                            unused;
  638.     short                           exp;                        /* decimal exponent */
  639.     struct {
  640.         unsigned char                   length;
  641.         unsigned char                   text[SIGDIGLEN];        /* significant digits */
  642.         unsigned char                   unused;
  643.     }                               sig;
  644. };
  645. typedef struct decimal decimal;
  647. struct decform {
  648.     char                            style;                      /*  FLOATDECIMAL or FIXEDDECIMAL */
  649.     char                            unused;
  650.     short                           digits;
  651. };
  652. typedef struct decform decform;
  653. EXTERN_API_C( void ) num2dec(const decform *f, double_t x, decimal *d);
  655. EXTERN_API_C( double_t ) dec2num(const decimal *d);
  657. EXTERN_API_C( void ) dec2str(const decform *f, const decimal *d, char *s);
  659. EXTERN_API_C( void ) str2dec(const char *s, short *ix, decimal *d, short *vp);
  661. #if TARGET_CPU_68K
  662. #if CALL_NOT_IN_CARBON
  663. EXTERN_API_C( double ) dec2d(const decimal *d);
  665. #endif  /* CALL_NOT_IN_CARBON */
  667. #endif  /* TARGET_CPU_68K */
  669. EXTERN_API_C( float ) dec2f(const decimal *d);
  671. EXTERN_API_C( short ) dec2s(const decimal *d);
  673. EXTERN_API_C( long ) dec2l(const decimal *d);
  678. /********************************************************************************
  679. *                                                                               *
  680. *                         68k-only Transfer Function Prototypes                 *
  681. *                                                                               *
  682. ********************************************************************************/
  683. #if TARGET_CPU_68K
  684. #if CALL_NOT_IN_CARBON
  685. EXTERN_API_C( void ) x96tox80(const extended96 *x, extended80 *x80);
  687. EXTERN_API_C( void ) x80tox96(const extended80 *x80, extended96 *x);
  689. #endif  /* CALL_NOT_IN_CARBON */
  691. #endif  /* TARGET_CPU_68K */
  693. #endif  /* !defined(__NOEXTENSIONS__) */
  695. /********************************************************************************
  696. *                                                                               *
  697. *                         PowerPC-only Function Prototypes                      *
  698. *                                                                               *
  699. ********************************************************************************/
  701. #if TARGET_CPU_PPC
  702. #if !TARGET_RT_MAC_MACHO
  703. #ifndef __MWERKS__  /* Metrowerks does not support double double */
  704. EXTERN_API_C( long double ) cosl(long double x);
  706. EXTERN_API_C( long double ) sinl(long double x);
  708. EXTERN_API_C( long double ) tanl(long double x);
  710. EXTERN_API_C( long double ) acosl(long double x);
  712. EXTERN_API_C( long double ) asinl(long double x);
  714. EXTERN_API_C( long double ) atanl(long double x);
  716. EXTERN_API_C( long double ) atan2l(long double y, long double x);
  718. EXTERN_API_C( long double ) coshl(long double x);
  720. EXTERN_API_C( long double ) sinhl(long double x);
  722. EXTERN_API_C( long double ) tanhl(long double x);
  724. EXTERN_API_C( long double ) acoshl(long double x);
  726. EXTERN_API_C( long double ) asinhl(long double x);
  728. EXTERN_API_C( long double ) atanhl(long double x);
  730. EXTERN_API_C( long double ) expl(long double x);
  732. EXTERN_API_C( long double ) expm1l(long double x);
  734. EXTERN_API_C( long double ) exp2l(long double x);
  736. EXTERN_API_C( long double ) frexpl(long double x, int *exponent);
  738. EXTERN_API_C( long double ) ldexpl(long double x, int n);
  740. EXTERN_API_C( long double ) logl(long double x);
  742. EXTERN_API_C( long double ) log1pl(long double x);
  744. EXTERN_API_C( long double ) log10l(long double x);
  746. EXTERN_API_C( long double ) log2l(long double x);
  748. EXTERN_API_C( long double ) logbl(long double x);
  750. EXTERN_API_C( long double ) scalbl(long double x, long n);
  752. EXTERN_API_C( long double ) fabsl(long double x);
  754. EXTERN_API_C( long double ) hypotl(long double x, long double y);
  756. EXTERN_API_C( long double ) powl(long double x, long double y);
  758. EXTERN_API_C( long double ) sqrtl(long double x);
  760. EXTERN_API_C( long double ) erfl(long double x);
  762. EXTERN_API_C( long double ) erfcl(long double x);
  764. EXTERN_API_C( long double ) gammal(long double x);
  766. EXTERN_API_C( long double ) lgammal(long double x);
  768. EXTERN_API_C( long double ) ceill(long double x);
  770. EXTERN_API_C( long double ) floorl(long double x);
  772. EXTERN_API_C( long double ) rintl(long double x);
  774. EXTERN_API_C( long double ) nearbyintl(long double x);
  776. EXTERN_API_C( long ) rinttoll(long double x);
  778. EXTERN_API_C( long double ) roundl(long double x);
  780. EXTERN_API_C( long ) roundtoll(long double round);
  782. EXTERN_API_C( long double ) truncl(long double x);
  784. EXTERN_API_C( long double ) remainderl(long double x, long double y);
  786. EXTERN_API_C( long double ) remquol(long double x, long double y, int *quo);
  788. EXTERN_API_C( long double ) copysignl(long double x, long double y);
  790. EXTERN_API_C( long double ) fdiml(long double x, long double y);
  792. EXTERN_API_C( long double ) fmaxl(long double x, long double y);
  794. EXTERN_API_C( long double ) fminl(long double x, long double y);
  796. #endif /* __MWERKS__ */
  797. #else
  798. #define cosl(x)          ((long double) cos((double_t)(x)))
  799. #define sinl(x)          ((long double) sin((double_t)(x)))
  800. #define tanl(x)          ((long double) tan((double_t)(x)))
  801. #define acosl(x)         ((long double) acos((double_t)(x)))
  802. #define asinl(x)         ((long double) asin((double_t)(x)))
  803. #define atanl(x)         ((long double) atan((double_t)(x)))
  804. #define atan2l(y,x)      ((long double) atan2((double_t)(y),(double_t)(x)))
  805. #define coshl(x)         ((long double) cosh((double_t)(x)))
  806. #define sinhl(x)         ((long double) sinh((double_t)(x)))
  807. #define tanhl(x)         ((long double) tanh((double_t)(x)))
  808. #define acoshl(x)        ((long double) acosh((double_t)(x)))
  809. #define asinhl(x)        ((long double) asinh((double_t)(x)))
  810. #define atanhl(x)        ((long double) atanh((double_t)(x)))
  811. #define expl(x)          ((long double) exp((double_t)(x)))
  812. #define expm1l(x)        ((long double) expm1((double_t)(x)))
  813. #define exp2l(x)         ((long double) exp2((double_t)(x)))
  814. #define frexpl(x,exp)    ((long double) frexp((double_t)(x),(exp)))
  815. #define ldexpl(x,n)      ((long double) ldexp((double_t)(x),(n)))
  816. #define logl(x)          ((long double) log((double_t)(x)))
  817. #define log1pl(x)        ((long double) log1p((double_t)(x)))
  818. #define log10l(x)        ((long double) log10((double_t)(x)))
  819. #define log2l(x)         ((long double) log2((double_t)(x)))
  820. #define logbl(x)         ((long double) logb((double_t)(x)))
  821. #define scalbl(x,n)      ((long double) scalb((double_t)(x),(n)))
  822. #define fabsl(x)         ((long double) fabs((double_t)(x)))
  823. #define hypotl(x,y)      ((long double) hypot((double_t)(x),(double_t)(y)))
  824. #define powl(x,y)        ((long double) pow((double_t)(x),(double_t)(y)))
  825. #define sqrtl(x)         ((long double) sqrt((double_t)(x)))
  826. #define erfl(x)          ((long double) erf((double_t)(x)))
  827. #define erfcl(x)         ((long double) erfc((double_t)(x)))
  828. #define gammal(x)        ((long double) gamma((double_t)(x)))
  829. #define lgammal(x)       ((long double) lgamma((double_t)(x)))
  830. #define ceill(x)         ((long double) ceil((double_t)(x)))
  831. #define floorl(x)        ((long double) floor((double_t)(x)))
  832. #define rintl(x)         ((long double) rint((double_t)(x)))
  833. #define nearbyintl(x)    ((long double) nearbyint((double_t)(x)))
  834. #define rinttoll(x)      (rinttol((double_t)(x)))
  835. #define roundl(x)        ((long double) round((double_t)(x)))
  836. #define roundtoll(x)     (roundtol((double_t)(x)))
  837. #define truncl(x)        ((long double) trunc((double_t)(x)))
  838. #define remainderl(x,y)  ((long double) remainder((double_t)(x),(double_t)(y)))
  839. #define remquol(x,y,quo) ((long double) remquo((double_t)(x),(double_t)(y),(quo)))
  840. #define copysignl(x,y)   ((long double) copysign((double_t)(x),(double_t)(y)))
  841. #define fdiml(x,y)       ((long double) fdim((double_t)(x),(double_t)(y)))
  842. #define fmaxl(x,y)       ((long double) fmax((double_t)(x),(double_t)(y)))
  843. #define fminl(x,y)       ((long double) fmin((double_t)(x),(double_t)(y)))
  844. #endif  /* !TARGET_RT_MAC_MACHO */
  846. #ifndef __NOEXTENSIONS__
  847. #if !TARGET_RT_MAC_MACHO
  848. EXTERN_API_C( relop ) relationl(long double x, long double y);
  850. EXTERN_API_C( void ) num2decl(const decform *f, long double x, decimal *d);
  852. EXTERN_API_C( long double ) dec2numl(const decimal *d);
  854. #else
  856.        #define relationl(x,y) (relation((double_t)x,(double_t)y))
  857.      #define num2decl(f,x,d) (num2dec(f,(double_t)x,d))
  858.      #define dec2numl(d) ((long double)dec2num(d))
  859.       
  860. #endif  /* !TARGET_RT_MAC_MACHO */
  862. #endif  /* !defined(__NOEXTENSIONS__) */
  864. #endif  /* TARGET_CPU_PPC */
  866. #endif  /* TARGET_OS_MAC */
  868. #ifndef __NOEXTENSIONS__
  869. #if !TARGET_RT_MAC_MACHO
  870. EXTERN_API_C( void ) x80told(const extended80 *x80, long double *x);
  872. EXTERN_API_C( void ) ldtox80(const long double *x, extended80 *x80);
  874. #else
  876.    #define x80told(x80,ld) (*(ld) = x80tod(x80))
  877.   #define ldtox80(ld,x80) do { double d = (double) *(ld); dtox80(&d, (x80)); } while (0)
  878.  
  879. #endif  /* !TARGET_RT_MAC_MACHO */
  881. /*    
  882.         MathLib v2 has two new transfer functions: x80tod and dtox80.  They can 
  883.         be used to directly transform 68k 80-bit extended data types to double
  884.         and back for PowerPC based machines without using the functions
  885.         x80told or ldtox80.  Double rounding may occur. 
  886.     */
  887. EXTERN_API_C( double ) x80tod(const extended80 *x80);
  889. EXTERN_API_C( void ) dtox80(const double *x, extended80 *x80);
  891. #endif  /* !defined(__NOEXTENSIONS__) */
  894. #if PRAGMA_STRUCT_ALIGN
  895.     #pragma options align=reset
  896. #elif PRAGMA_STRUCT_PACKPUSH
  897.     #pragma pack(pop)
  898. #elif PRAGMA_STRUCT_PACK
  899.     #pragma pack()
  900. #endif
  902. #ifdef PRAGMA_IMPORT_OFF
  903. #pragma import off
  904. #elif PRAGMA_IMPORT
  905. #pragma import reset
  906. #endif
  908. #ifdef __cplusplus
  909. }
  910. #endif
  912. #endif /* __FP__ */