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