home *** CD-ROM | disk | FTP | other *** search
/ QuickTime 2.0 Developer Kit / QuickTime 2.0 Developer Kit.iso / mac / MAC / Programming Stuff / Interfaces / PInterfaces / fp.p < prev    next >
Encoding:
Text File  |  1994-11-11  |  18.4 KB  |  464 lines  |  [TEXT/MPS ]
  1. {
  2.      File:        FP.p
  3.  
  4.      Copyright:    © 1984-1994 by Apple Computer, Inc.
  5.                  All rights reserved.
  6.  
  7.      Version:    Universal Pascal, Oct 14, 1994 
  8.     
  9.     Note:        The following file was hand converted from fp.h
  10.                 See fp.h for more information and comments.
  11. }
  12.  
  13.  
  14. {$IFC UNDEFINED UsingIncludes}
  15. {$SETC UsingIncludes := 0}
  16. {$ENDC}
  17.  
  18. {$IFC NOT UsingIncludes}
  19.  UNIT fp;
  20.  INTERFACE
  21. {$ENDC}
  22.  
  23. {$IFC UNDEFINED __FP__}
  24. {$SETC __FP__ := 1}
  25.  
  26. {$I+}
  27. {$SETC fpIncludes := UsingIncludes}
  28. {$SETC UsingIncludes := 1}
  29.  
  30. {$IFC UNDEFINED __TYPES__}
  31. {$I Types.p}
  32. {$ENDC}
  33.  
  34. CONST
  35.     DOUBLE_SIZE                    = 8;
  36.  
  37. {$IFC GENERATINGPOWERPC }
  38.     LONG_DOUBLE_SIZE            = 16;
  39.     DECIMAL_DIG                    = 17;  { does not exist for double-double }
  40. {$ELSEC}
  41.     DECIMAL_DIG                    = 21;
  42. {$IFC GENERATING68881}
  43.     LONG_DOUBLE_SIZE            = 12;
  44. {$ELSEC}
  45.     LONG_DOUBLE_SIZE            = 10;
  46. {$ENDC}
  47. {$ENDC}
  48.  
  49. (*******************************************************************************
  50. *                            Trigonometric functions                           *
  51. *******************************************************************************)
  52.  
  53.  
  54. FUNCTION cos(x: double_t): double_t; C;
  55. FUNCTION sin(x: double_t): double_t; C;
  56. FUNCTION tan(x: double_t): double_t; C;
  57.  
  58. FUNCTION acos(x: double_t): double_t; C;    {  argument to acos is in [0,pi]          }
  59. FUNCTION asin(x: double_t): double_t; C;    {  argument to asin is in [-pi/2,pi/2]    }
  60. FUNCTION atan(x: double_t): double_t; C;    {  argument to atan is in [-pi/2,pi/2]    }
  61.  
  62. {    atan2 computes the arc tangent of y/x in [-pi,pi] using the sign of
  63.       both arguments to determine the quadrant of the computed value.         }
  64. FUNCTION atan2(y: double_t; x: double_t): double_t; C;
  65.  
  66.  
  67. (*******************************************************************************
  68. *                              Hyperbolic functions                            *
  69. *******************************************************************************)
  70.  
  71. FUNCTION cosh(x: double_t): double_t; C;
  72. FUNCTION sinh(x: double_t): double_t; C;
  73. FUNCTION tanh(x: double_t): double_t; C;
  74. FUNCTION acosh(x: double_t): double_t; C;
  75. FUNCTION asinh(x: double_t): double_t; C;
  76. FUNCTION atanh(x: double_t): double_t; C;
  77.  
  78. (*******************************************************************************
  79. *                              Exponential functions                           *
  80. *******************************************************************************)
  81.  
  82. FUNCTION exp(x: double_t): double_t; C;
  83.  
  84. {    expm1 computes the base e exponential of the argument minus 1,
  85.       i. e., exp(x) - 1.  For small enough arguments, expm1 is expected
  86.       to be more accurate than the straight forward computation of exp(x) - 1.}
  87. FUNCTION expm1(x: double_t): double_t; C;
  88.  
  89. {      exp2 computes the base 2 exponential.                                 }
  90. FUNCTION exp2(x: double_t): double_t; C;
  91. FUNCTION frexp(x: double_t; VAR exponent: LONGINT): double_t; C;
  92. FUNCTION ldexp(x: double_t; n: LONGINT): double_t; C;
  93. FUNCTION log(x: double_t): double_t; C;
  94.  
  95. {      log2 computes the base 2 logarithm.                                   }
  96. FUNCTION log2(x: double_t): double_t; C;
  97.  
  98. {    log1p computes the base e logorithm of 1 plus the argument,
  99.       i. e., log (1 x).  For small enough arguments, log1p is expected
  100.       to be more accurate than the straightforward computation of log (1+x).  }
  101. FUNCTION log1p(x: double_t): double_t; C;
  102. FUNCTION log10(x: double_t): double_t; C;
  103.  
  104. {    logb extracts the exponent of its argument, as a signed integral
  105.       value. A subnormal argument is treated as though it were first
  106.       normalized. Thus
  107.  
  108.       1 <= x  2^( - Logb ( x ) ) < 2                                         }
  109. FUNCTION logb(x: double_t): double_t; C;
  110. FUNCTION modf(x: Double; VAR iptr: Double): Double; C;
  111. FUNCTION modff(x: Single; VAR iptrf: Single): Single; C;
  112.  
  113. {    scalb computes x  2^n efficently.  This is not normally done by
  114.       computing 2^n explicitly.                                               }
  115. FUNCTION scalb(x: double_t; n: LONGINT): double_t; C;
  116.  
  117. (*******************************************************************************
  118. *                     Power and absolute value functions                       *
  119. *******************************************************************************)
  120.  
  121. FUNCTION fabs(x: double_t): double_t; C;
  122.  
  123. {    hypot computes the square root of the sum of the squares of its
  124.       arguments, without undue overflow or underflow.                         }
  125. FUNCTION hypot(x: double_t; y: double_t): double_t; C;
  126. FUNCTION pow(x: double_t; y: double_t): double_t; C;
  127. FUNCTION sqrt(x: double_t): double_t; C;
  128.  
  129. (*******************************************************************************
  130. *                        Gamma and Error functions                             *
  131. *******************************************************************************)
  132.  
  133. FUNCTION erf(x: double_t): double_t; C;
  134. FUNCTION erfc(x: double_t): double_t; C;    {   complementary error function   }
  135.  
  136. FUNCTION gamma(x: double_t): double_t; C;
  137.  
  138. {    lgamma computes the base-e logarithm of the absolute value of
  139.       gamma of its argument x, for x > 0.                                     }
  140. FUNCTION lgamma(x: double_t): double_t; C;
  141.  
  142. (*******************************************************************************
  143. *                        Nearest integer functions                             *
  144. *******************************************************************************)
  145.  
  146. FUNCTION ceil(x: double_t): double_t; C;
  147. FUNCTION floor(x: double_t): double_t; C;
  148.  
  149. {    the rint function rounds its argument to an integral value in floating
  150.       point format, honoring the current rounding direction.                  }
  151. FUNCTION rint(x: double_t): double_t; C;
  152.  
  153. {    nearbyint differs from rint only in that it does not raise the
  154.       inexact exception. It is the nearbyint function recommended by the
  155.       IEEE floating-point standard 854.                                       }
  156. FUNCTION nearbyint(x: double_t): double_t; C;
  157.  
  158. {    the function rinttol rounds its argument to the nearest long using
  159.       the current rounding direction.
  160.       >>Note that if the rounded value is outside the range of long, then
  161.       the result is undefined.                                                }
  162. FUNCTION rinttol(x: double_t): LONGINT; C;
  163.  
  164. {    the round function rounds the argument to the nearest integral value
  165.       in double format similar to the Fortran "anint" function.  That is:
  166.       add half to the magnitude and chop.                                     }
  167. FUNCTION round(x: double_t): double_t; C;
  168.  
  169. {    roundtol is similar to the Fortran function nint or to the Pascal round
  170.       >>Note that if the rounded value is outside the range of long, then
  171.       the result is undefined.                                                }
  172. FUNCTION roundtol(round: double_t): LONGINT; C;
  173.  
  174. {    trunc computes the integral value, in floating format, nearest to
  175.       but no larger in magnitude than its argument.                           }
  176. FUNCTION trunc(x: double_t): double_t; C;
  177.  
  178. (*******************************************************************************
  179. *                            Remainder functions                               *
  180. *******************************************************************************)
  181.  
  182. FUNCTION fmod(x: double_t; y: double_t): double_t; C;
  183.  
  184. {    the following two functions compute the remainder.  remainder is required
  185.       by the IEEE 754 floating point standard. The second form correponds to the
  186.       SANE remainder; it stores into 'quotient' the 7 low-order bits of the
  187.       integer quotient x/y, such that -127 <= quotient <= 127.                }
  188. FUNCTION remainder(x: double_t; y: double_t): double_t; C;
  189. FUNCTION remquo(x: double_t; y: double_t; VAR quo: LONGINT): double_t; C;
  190.  
  191.  
  192. (*******************************************************************************
  193. *                             Auxiliary functions                              *
  194. *******************************************************************************)
  195.  
  196. FUNCTION copysign(x: double_t; y: double_t): double_t; C;
  197. FUNCTION nan(tagp: ConstCStringPtr): Double; C;
  198. FUNCTION nanf(tagp: ConstCStringPtr): Single; C;
  199.  
  200. FUNCTION nextafterd(x: Double; y: Double): Double; C;
  201. FUNCTION nextafterf(x: Single; y: Single): Single; C;
  202.  
  203. (*******************************************************************************
  204. *                      Max, Min and Positive Difference                        *
  205. *******************************************************************************)
  206.  
  207. {     These extension functions correspond to the standard functions, dim
  208.       max and min.
  209.  
  210.       The fdim function determines the 'positive difference' between its
  211.       arguments: ( x - y, if x > y ), ( +0, if x <= y ).  If one argument is
  212.       NaN, then fdim returns that NaN.  if both arguments are NaNs, then fdim
  213.       returns the first argument.                                             }
  214. FUNCTION fdim(x: double_t; y: double_t): double_t; C;
  215.  
  216. {    max and min return the maximum and minimum of their two arguments,
  217.       respectively.  They correspond to the max and min functions in FORTRAN.
  218.       NaN arguments are treated as missing data.  If one argument is NaN and
  219.       the other is a number, then the number is returned.  If both are NaNs
  220.       then the first argument is returned.                                    }
  221. FUNCTION fmax(x: double_t; y: double_t): double_t; C;
  222. FUNCTION fmin(x: double_t; y: double_t): double_t; C;
  223.  
  224. (*******************************************************************************
  225. *                              Inquiry functions                               *
  226. *******************************************************************************)
  227.  
  228. CONST
  229.     FP_SNAN     = 0;        {      signaling NaN                         }
  230.     FP_QNAN     = 1;        {      quiet NaN                             }
  231.     FP_INFINITE = 2;        {      + or - infinity                       }
  232.     FP_ZERO        = 3;        {      + or - zero                           }
  233.     FP_NORMAL    = 4;        {      all normal numbers                    }
  234.     FP_SUBNORMA = 5;        {      denormal numbers                      }
  235.  
  236.  
  237. FUNCTION __fpclassifyd(x: Double): LONGINT; C;
  238. FUNCTION __fpclassifyf(x: Single): LONGINT; C;
  239.  
  240. FUNCTION __isnormald(x: Double) : LONGINT; C;
  241. FUNCTION __isnormalf(x: Single): LONGINT; C;
  242.  
  243. FUNCTION __isfinited(x: Double): LONGINT; C;
  244. FUNCTION __isfinitef(x: Single): LONGINT; C;
  245.  
  246. FUNCTION __isnand(x: Double): LONGINT; C;
  247. FUNCTION __isnanf(x: Single): LONGINT; C;
  248.  
  249. FUNCTION __signbitd(x: Double): LONGINT; C;
  250. FUNCTION __signbitf(x: Single): LONGINT; C;
  251.  
  252. FUNCTION __inf: Double;
  253.  
  254.  
  255. (*******************************************************************************
  256. *                              Non NCEG extensions                             *
  257. *******************************************************************************)
  258.  
  259.  
  260. {$IFC UNDEFINED __NOEXTENSIONS__ }
  261.  
  262. (*******************************************************************************
  263. *                              Financial functions                             *
  264. *******************************************************************************)
  265.  
  266. {     compound computes the compound interest factor "(1 + rate) ^ periods"
  267.       more accurately than the straightforward computation with the Power
  268.       function.  This is SANE's compound function.                            }
  269. FUNCTION compound(rate: double_t; periods: double_t): double_t; C;
  270.  
  271. {    The function annuity computes the present value factor for an annuity 
  272.       "( 1 - ( 1 + rate ) ^ ( - periods ) ) / rate" more accurately than the
  273.       straightforward computation with the Power function. This is SANE's 
  274.       annuity function.                                                       }
  275. FUNCTION annuity(rate: double_t; periods: double_t): double_t; C;
  276.  
  277. (*******************************************************************************
  278. *                              Random function                                 *
  279. *******************************************************************************)
  280.  
  281. FUNCTION randomx(VAR x: double_t): double_t; C;
  282.  
  283.  
  284. (*******************************************************************************
  285. *                              Relational operator                             *
  286. *******************************************************************************)
  287.  
  288. TYPE
  289.     relop = INTEGER;        {      relational operator      }
  290.  
  291. CONST
  292.     GREATERTHAN                    = 0;
  293.     LESSTHAN                    = 1;
  294.     EQUALTO                        = 2;
  295.     UNORDERED                    = 3;
  296.  
  297.  
  298. FUNCTION relation(x: double_t; y: double_t): relop; C;
  299.  
  300.  
  301.  
  302. (*******************************************************************************
  303. *                         Binary to decimal conversions                        *
  304. *******************************************************************************)
  305.  
  306. CONST
  307. {$IFC GENERATINGPOWERPC }
  308.     SIGDIGLEN                    = 36;                    { significant decimal digits }
  309. {$ELSEC}
  310.     SIGDIGLEN                    = 20;                    { significant decimal digits }
  311. {$ENDC}
  312.     DECSTROUTLEN                = 80;                    { max length for dec2str output }
  313.  
  314. TYPE
  315.     DecimalKind = (FloatDecimal,FixedDecimal);
  316.  
  317. {     The decimal record type provides an intermediate unpacked form for
  318.       programmers who wish to do their own parsing of numeric input or
  319.       formatting of numeric output.                                         }
  320.     
  321.     {$ALIGN MAC68K}
  322.     Decimal = RECORD
  323.         sgn:     0..1;            { sign 0 for +, 1 for -  }
  324.         exp:     INTEGER;
  325.         sig:     STRING[SIGDIGLEN];
  326.     END;
  327.     {$ALIGN RESET}
  328.  
  329. {    Each conversion to a decimal string is controlled by a decform
  330.       structure.  The style is either FLOATDECIMAL or FIXEDDECIMAL defined
  331.       above.  The value of digits is the number of significant digits for
  332.       FLOATDECIMAL.  The value of digits for FIXEDDECIMAL is the number of
  333.       digits to the right of the decimal point.                               }
  334.       
  335.     {$ALIGN MAC68K}
  336.     Decform = RECORD
  337.         style:     DecimalKind;
  338.         digits: INTEGER;
  339.     END;
  340.     {$ALIGN RESET}
  341.     
  342. {    Each conversion to a decimal record d via the function call num2dec is 
  343.       controlled by a decform record f (defined earlier), to a double_t x.    }
  344. PROCEDURE num2dec({CONST}VAR f: Decform; x: double_t; VAR d: decimal); C;
  345.  
  346.  
  347. { dec2num converts a decimal record d to a double_t value.          }
  348. FUNCTION dec2num({CONST}VAR d: Decimal): double_t; C;
  349.  
  350. {    The MathLib formatter dec2str is controlled by a decform f.  Input d is
  351.       a decimal record.                                                       }
  352. PROCEDURE dec2str({CONST}VAR f: Decform; {CONST}VAR d: Decimal; s: CStringPtr); C;
  353.  
  354. {    The function str2dec is the MathLib scanner.                            }
  355. PROCEDURE str2dec(s: ConstCStringPtr; VAR ix: INTEGER; VAR d: Decimal; VAR vp: INTEGER); C;
  356.  
  357. {$IFC GENERATING68K }
  358. {    dec2d is similar to dec2num except a double is returned on 68k platforms }
  359. FUNCTION dec2d({CONST}VAR d: Decimal): Double; C;
  360. {$ENDC}
  361.  
  362. {    dec2f is similar to dec2num except a float is returned.                 }
  363. FUNCTION dec2f({CONST}VAR d: Decimal): Single; C;
  364.  
  365. {    dec2s is similar to dec2num except a short is returned.                 }
  366. FUNCTION dec2s({CONST}VAR d: Decimal): INTEGER; C;
  367.  
  368. {    dec2l is similar to dec2num except a long is returned.                  }
  369. FUNCTION dec2l({CONST}VAR d: Decimal): LONGINT; C;
  370.  
  371.  
  372. {$ENDC} {__NOEXTENSIONS__}
  373.  
  374. (*******************************************************************************
  375. *                         PowerPC-only Function Prototypes                     *
  376. *******************************************************************************)
  377.  
  378. {$IFC GENERATINGPOWERPC }
  379. FUNCTION cosl(x: LongDouble): LongDouble; C;
  380. FUNCTION sinl(x: LongDouble): LongDouble; C;
  381. FUNCTION tanl(x: LongDouble): LongDouble; C;
  382.  
  383. FUNCTION acosl(x: LongDouble): LongDouble; C;
  384. FUNCTION asinl(x: LongDouble): LongDouble; C;
  385. FUNCTION atanl(x: LongDouble): LongDouble; C;
  386. FUNCTION atan2l(y: LongDouble; x: LongDouble): LongDouble; C;
  387.  
  388. FUNCTION coshl(x: LongDouble): LongDouble; C;
  389. FUNCTION sinhl(x: LongDouble): LongDouble; C;
  390. FUNCTION tanhl(x: LongDouble): LongDouble; C;
  391.  
  392. FUNCTION acoshl(x: LongDouble): LongDouble; C;
  393. FUNCTION asinhl(x: LongDouble): LongDouble; C;
  394. FUNCTION atanhl(x: LongDouble): LongDouble; C;
  395.  
  396. FUNCTION expl(x: LongDouble): LongDouble; C;
  397. FUNCTION expm1l(x: LongDouble): LongDouble; C;
  398. FUNCTION exp2l(x: LongDouble): LongDouble; C;
  399.  
  400. FUNCTION frexpl(x: LongDouble; VAR exponent: LONGINT): LongDouble; C;
  401. FUNCTION ldexpl(x: LongDouble; n: LONGINT): LongDouble; C;
  402.  
  403. FUNCTION logl(x: LongDouble): LongDouble; C;
  404. FUNCTION log1pl(x: LongDouble): LongDouble; C;
  405. FUNCTION log10l(x: LongDouble): LongDouble; C;
  406. FUNCTION log2l(x: LongDouble): LongDouble; C;
  407.  
  408. FUNCTION logbl(x: LongDouble): LongDouble; C;
  409. FUNCTION scalbl(x: LongDouble; n: LONGINT): LongDouble; C;
  410.  
  411. FUNCTION fabsl(x: LongDouble): LongDouble; C;
  412. FUNCTION hypotl(x: LongDouble; y: LongDouble): LongDouble; C;
  413. FUNCTION powl(x: LongDouble; y: LongDouble): LongDouble; C;
  414. FUNCTION sqrtl(x: LongDouble): LongDouble; C;
  415.  
  416. FUNCTION erfl(x: LongDouble): LongDouble; C;
  417. FUNCTION erfcl(x: LongDouble): LongDouble; C;
  418. FUNCTION gammal(x: LongDouble): LongDouble; C;
  419. FUNCTION lgammal(x: LongDouble): LongDouble; C;
  420.  
  421. FUNCTION ceill(x: LongDouble): LongDouble; C;
  422. FUNCTION floorl(x: LongDouble): LongDouble; C;
  423. FUNCTION rintl(x: LongDouble): LongDouble; C;
  424. FUNCTION nearbyintl(x: LongDouble): LongDouble; C;
  425. FUNCTION rinttoll(x: LongDouble): LONGINT; C;
  426. FUNCTION roundl(x: LongDouble): LongDouble; C;
  427. FUNCTION roundtoll(round: LongDouble): LONGINT; C;
  428. FUNCTION truncl(x: LongDouble): LongDouble; C;
  429. FUNCTION remainderl(x: LongDouble; y: LongDouble): LongDouble; C;
  430. FUNCTION remquol(x: LongDouble; y: LongDouble; VAR quo: LONGINT): LongDouble; C;
  431. FUNCTION copysignl(x: LongDouble; y: LongDouble): LongDouble; C;
  432. FUNCTION fdiml(x: LongDouble; y: LongDouble): LongDouble; C;
  433. FUNCTION fmaxl(x: LongDouble; y: LongDouble): LongDouble; C;
  434. FUNCTION fminl(x: LongDouble; y: LongDouble): LongDouble; C;
  435.  
  436. FUNCTION modfl(x: LongDouble; VAR iptrl: LongDouble): LongDouble; C;
  437. FUNCTION nanl(tagp: ConstCStringPtr): LongDouble; C;
  438. FUNCTION nextafterl(x: LongDouble; y: LongDouble): LongDouble; C;
  439. FUNCTION __fpclassify(x: LongDouble): LONGINT; C;
  440. FUNCTION __isnormal(x: LongDouble): LONGINT; C;
  441. FUNCTION __isfinite(x: LongDouble): LONGINT; C;
  442. FUNCTION __isnan(x: LongDouble): LONGINT; C;
  443. FUNCTION __signbit(x: LongDouble): LONGINT; C;
  444.  
  445. {$IFC UNDEFINED __NOEXTENSIONS__ }
  446. FUNCTION relationl(x: LongDouble; y: LongDouble): relop; C;
  447. PROCEDURE x80told(x80: extended80; VAR x: LongDouble); C;
  448. PROCEDURE ldtox80(x: LongDouble; VAR x80: extended80); C;
  449. PROCEDURE num2decl({CONST}VAR f: Decform; x: LongDouble; VAR d: Decimal); C;
  450. FUNCTION dec2numl({CONST}VAR d: Decimal): LongDouble; C;
  451. {$ENDC} { __NOEXTENSIONS__ }
  452.  
  453. {$ENDC} { GENERATINGPOWERPC }
  454.  
  455.  
  456.  
  457. {$SETC UsingIncludes := fpIncludes}
  458.  
  459. {$ENDC} {__FP__}
  460.  
  461. {$IFC NOT UsingIncludes}
  462.  END.
  463. {$ENDC}
  464.