home *** CD-ROM | disk | FTP | other *** search
/ RISC DISC 2 / RISC_DISC_2.iso / pd_share / program / code / sdls / DLLLib / h / math < prev    next >
Encoding:
Text File  |  1994-03-07  |  6.6 KB  |  168 lines
  1. #pragma force_top_level
  2. #pragma include_only_once
  3.  
  4. /* math.h: ANSI 'C' (X3J11 Oct 88) library header, section 4.5 */
  5. /* Copyright (C) Codemist Ltd. */
  6. /* Copyright (C) Acorn Computers Ltd. 1991 */
  7. /* version 0.02 */
  8.  
  9. #ifndef __math_h
  10. #define __math_h
  11.  
  12. #ifndef HUGE_VAL
  13.   #define HUGE_VAL __huge_val
  14.  
  15.   #ifdef __cplusplus
  16.     #define HUGE __huge_val
  17.     extern "C" {
  18.   #endif
  19.  
  20.   #ifdef _DLL
  21.     extern const double *_dll_huge_val(void);
  22.     #define __huge_val (*_dll_huge_val())
  23.   #else
  24.     extern const double __huge_val;
  25.   #endif
  26.  
  27.   #ifdef __cplusplus
  28.     }
  29.   #endif
  30.  
  31. #endif
  32.  
  33. #pragma no_side_effects
  34.  
  35. #ifdef __cplusplus
  36. extern "C" {
  37. #endif
  38. extern double acos(double /*x*/);
  39.    /* computes the principal value of the arc cosine of x */
  40.    /* a domain error occurs for arguments not in the range -1 to 1 */
  41.    /* Returns: the arc cosine in the range 0 to Pi. */
  42. extern double asin(double /*x*/);
  43.    /* computes the principal value of the arc sine of x */
  44.    /* a domain error occurs for arguments not in the range -1 to 1 */
  45.    /* and -HUGE_VAL is returned. */
  46.    /* Returns: the arc sine in the range -Pi/2 to Pi/2. */
  47. extern double atan(double /*x*/);
  48.    /* computes the principal value of the arc tangent of x */
  49.    /* Returns: the arc tangent in the range -Pi/2 to Pi/2. */
  50. extern double atan2(double /*x*/, double /*y*/);
  51.    /* computes the principal value of the arc tangent of y/x, using the */
  52.    /* signs of both arguments to determine the quadrant of the return value */
  53.    /* a domain error occurs if both args are zero, and -HUGE_VAL returned. */
  54.    /* Returns: the arc tangent of y/x, in the range -Pi to Pi. */
  55.  
  56. extern double __d_atan(double);
  57. #define atan(x) __d_atan(x)
  58.  
  59. extern double cos(double /*x*/);
  60.    /* computes the cosine of x (measured in radians). A large magnitude */
  61.    /* argument may yield a result with little or no significance */
  62.    /* Returns: the cosine value. */
  63. extern double sin(double /*x*/);
  64.    /* computes the sine of x (measured in radians). A large magnitude */
  65.    /* argument may yield a result with little or no significance */
  66.    /* Returns: the sine value. */
  67.  
  68. extern double __d_sin(double);
  69. extern double __d_cos(double);
  70. #define sin(x) __d_sin(x)
  71. #define cos(x) __d_cos(x)
  72.  
  73. extern double tan(double /*x*/);
  74.    /* computes the tangent of x (measured in radians). A large magnitude */
  75.    /* argument may yield a result with little or no significance */
  76.    /* Returns: the tangent value. */
  77.    /*          if range error; returns HUGE_VAL. */
  78.  
  79. extern double cosh(double /*x*/);
  80.    /* computes the hyperbolic cosine of x. A range error occurs if the */
  81.    /* magnitude of x is too large. */
  82.    /* Returns: the hyperbolic cosine value. */
  83.    /*          if range error; returns HUGE_VAL. */
  84. extern double sinh(double /*x*/);
  85.    /* computes the hyperbolic sine of x. A range error occurs if the */
  86.    /* magnitude of x is too large. */
  87.    /* Returns: the hyperbolic sine value. */
  88.    /*          if range error; returns -HUGE_VAL or HUGE_VAL depending */
  89.    /*          on the sign of the argument */
  90. extern double tanh(double /*x*/);
  91.    /* computes the hyperbolic tangent of x. */
  92.    /* Returns: the hyperbolic tangent value. */
  93.  
  94. extern double exp(double /*x*/);
  95.    /* computes the exponential function of x. A range error occurs if the */
  96.    /* magnitude of x is too large. */
  97.    /* Returns: the exponential value. */
  98.    /*          if underflow range error; 0 is returned. */
  99.    /*          if overflow range error; HUGE_VAL is returned. */
  100. extern double frexp(double /*value*/, int * /*exp*/);
  101.    /* breaks a floating-point number into a normalised fraction and an */
  102.    /* integral power of 2. It stores the integer in the int object pointed */
  103.    /* to by exp. */
  104.    /* Returns: the value x, such that x is a double with magnitude in the */
  105.    /* interval 0.5 to 1.0 or zero, and value equals x times 2 raised to the */
  106.    /* power *exp. If value is zero, both parts of the result are zero. */
  107. extern double ldexp(double /*x*/, int /*exp*/);
  108.    /* multiplies a floating-point number by an integral power of 2. */
  109.    /* A range error may occur. */
  110.    /* Returns: the value of x times 2 raised to the power of exp. */
  111.    /*          if range error; HUGE_VAL is returned. */
  112. extern double log(double /*x*/);
  113.    /* computes the natural logarithm of x. A domain error occurs if the */
  114.    /* argument is negative, and -HUGE_VAL is returned. A range error occurs */
  115.    /* if the argument is zero. */
  116.    /* Returns: the natural logarithm. */
  117.    /*          if range error; -HUGE_VAL is returned. */
  118. extern double log10(double /*x*/);
  119.    /* computes the base-ten logarithm of x. A domain error occurs if the */
  120.    /* argument is negative. A range error occurs if the argument is zero. */
  121.    /* Returns: the base-ten logarithm. */
  122. extern double modf(double /*value*/, double * /*iptr*/);
  123.    /* breaks the argument value into integral and fraction parts, each of */
  124.    /* which has the same sign as the argument. It stores the integral part */
  125.    /* as a double in the object pointed to by iptr. */
  126.    /* Returns: the signed fractional part of value. */
  127.  
  128. extern double pow(double /*x*/, double /*y*/);
  129.    /* computes x raised to the power of y. A domain error occurs if x is */
  130.    /* zero and y is less than or equal to zero, or if x is negative and y */
  131.    /* is not an integer, and -HUGE_VAL returned. A range error may occur. */
  132.    /* Returns: the value of x raised to the power of y. */
  133.    /*          if underflow range error; 0 is returned. */
  134.    /*          if overflow range error; HUGE_VAL is returned. */
  135. extern double sqrt(double /*x*/);
  136.    /* computes the non-negative square root of x. A domain error occurs */
  137.    /* if the argument is negative, and -HUGE_VAL returned. */
  138.    /* Returns: the value of the square root. */
  139.  
  140. extern double ceil(double /*x*/);
  141.    /* computes the smallest integer not less than x. */
  142.    /* Returns: the smallest integer not less than x, expressed as a double. */
  143. extern double fabs(double /*x*/);
  144.    /* computes the absolute value of the floating-point number x. */
  145.    /* Returns: the absolute value of x. */
  146. extern double floor(double /*d*/);
  147.    /* computes the largest integer not greater than x. */
  148.    /* Returns: the largest integer not greater than x, expressed as a double */
  149. extern double fmod(double /*x*/, double /*y*/);
  150.    /* computes the floating-point remainder of x/y. */
  151.    /* Returns: the value x - i * y, for some integer i such that, if y is */
  152.    /*          nonzero, the result has the same sign as x and magnitude */
  153.    /*          less than the magnitude of y. If y is zero, a domain error */
  154.    /*          occurs and -HUGE_VAL is returned. */
  155.  
  156. extern double __d_abs(double);
  157. #define fabs(x) __d_abs(x)
  158.  
  159. #ifdef __cplusplus
  160. }
  161. #endif
  162.  
  163. #pragma side_effects
  164.  
  165. #endif
  166.  
  167. /* end of math.h */
  168.