|
0
|
1 /******************************************************************\
|
|
|
2 * *
|
|
|
3 * <math-68881.h> last modified: 23 May 1992. *
|
|
|
4 * *
|
|
|
5 * Copyright (C) 1989 by Matthew Self. *
|
|
|
6 * You may freely distribute verbatim copies of this software *
|
|
|
7 * provided that this copyright notice is retained in all copies. *
|
|
|
8 * You may distribute modifications to this software under the *
|
|
|
9 * conditions above if you also clearly note such modifications *
|
|
|
10 * with their author and date. *
|
|
|
11 * *
|
|
|
12 * Note: errno is not set to EDOM when domain errors occur for *
|
|
|
13 * most of these functions. Rather, it is assumed that the *
|
|
|
14 * 68881's OPERR exception will be enabled and handled *
|
|
|
15 * appropriately by the operating system. Similarly, overflow *
|
|
|
16 * and underflow do not set errno to ERANGE. *
|
|
|
17 * *
|
|
|
18 * Send bugs to Matthew Self (self@bayes.arc.nasa.gov). *
|
|
|
19 * *
|
|
|
20 \******************************************************************/
|
|
|
21
|
|
|
22 /* This file is NOT a part of GCC, just distributed with it. */
|
|
|
23
|
|
|
24 /* If you find this in GCC,
|
|
|
25 please send bug reports to bug-gcc@prep.ai.mit.edu. */
|
|
|
26
|
|
|
27 /* Changed by Richard Stallman:
|
|
|
28 May 1993, add conditional to prevent multiple inclusion.
|
|
|
29 % inserted before a #.
|
|
|
30 New function `hypot' added.
|
|
|
31 Nans written in hex to avoid 0rnan.
|
|
|
32 May 1992, use %! for fpcr register. Break lines before function names.
|
|
|
33 December 1989, add parens around `&' in pow.
|
|
|
34 November 1990, added alternate definition of HUGE_VAL for Sun. */
|
|
|
35
|
|
|
36 /* Changed by Jim Wilson:
|
|
|
37 September 1993, Use #undef before HUGE_VAL instead of #ifdef/#endif. */
|
|
|
38
|
|
|
39 /* Changed by Ian Lance Taylor:
|
|
|
40 September 1994, use extern inline instead of static inline. */
|
|
|
41
|
|
|
42 #ifndef __math_68881
|
|
|
43 #define __math_68881
|
|
|
44
|
|
|
45 #include <errno.h>
|
|
|
46
|
|
|
47 #undef HUGE_VAL
|
|
|
48 #ifdef __sun__
|
|
|
49 /* The Sun assembler fails to handle the hex constant in the usual defn. */
|
|
|
50 #define HUGE_VAL \
|
|
|
51 ({ \
|
|
|
52 static union { int i[2]; double d; } u = { {0x7ff00000, 0} }; \
|
|
|
53 u.d; \
|
|
|
54 })
|
|
|
55 #else
|
|
|
56 #define HUGE_VAL \
|
|
|
57 ({ \
|
|
|
58 double huge_val; \
|
|
|
59 \
|
|
|
60 __asm ("fmove%.d #0x7ff0000000000000,%0" /* Infinity */ \
|
|
|
61 : "=f" (huge_val) \
|
|
|
62 : /* no inputs */); \
|
|
|
63 huge_val; \
|
|
|
64 })
|
|
|
65 #endif
|
|
|
66
|
|
|
67 __inline extern double
|
|
|
68 sin (double x)
|
|
|
69 {
|
|
|
70 double value;
|
|
|
71
|
|
|
72 __asm ("fsin%.x %1,%0"
|
|
|
73 : "=f" (value)
|
|
|
74 : "f" (x));
|
|
|
75 return value;
|
|
|
76 }
|
|
|
77
|
|
|
78 __inline extern double
|
|
|
79 cos (double x)
|
|
|
80 {
|
|
|
81 double value;
|
|
|
82
|
|
|
83 __asm ("fcos%.x %1,%0"
|
|
|
84 : "=f" (value)
|
|
|
85 : "f" (x));
|
|
|
86 return value;
|
|
|
87 }
|
|
|
88
|
|
|
89 __inline extern double
|
|
|
90 tan (double x)
|
|
|
91 {
|
|
|
92 double value;
|
|
|
93
|
|
|
94 __asm ("ftan%.x %1,%0"
|
|
|
95 : "=f" (value)
|
|
|
96 : "f" (x));
|
|
|
97 return value;
|
|
|
98 }
|
|
|
99
|
|
|
100 __inline extern double
|
|
|
101 asin (double x)
|
|
|
102 {
|
|
|
103 double value;
|
|
|
104
|
|
|
105 __asm ("fasin%.x %1,%0"
|
|
|
106 : "=f" (value)
|
|
|
107 : "f" (x));
|
|
|
108 return value;
|
|
|
109 }
|
|
|
110
|
|
|
111 __inline extern double
|
|
|
112 acos (double x)
|
|
|
113 {
|
|
|
114 double value;
|
|
|
115
|
|
|
116 __asm ("facos%.x %1,%0"
|
|
|
117 : "=f" (value)
|
|
|
118 : "f" (x));
|
|
|
119 return value;
|
|
|
120 }
|
|
|
121
|
|
|
122 __inline extern double
|
|
|
123 atan (double x)
|
|
|
124 {
|
|
|
125 double value;
|
|
|
126
|
|
|
127 __asm ("fatan%.x %1,%0"
|
|
|
128 : "=f" (value)
|
|
|
129 : "f" (x));
|
|
|
130 return value;
|
|
|
131 }
|
|
|
132
|
|
|
133 __inline extern double
|
|
|
134 atan2 (double y, double x)
|
|
|
135 {
|
|
|
136 double pi, pi_over_2;
|
|
|
137
|
|
|
138 __asm ("fmovecr%.x #0,%0" /* extended precision pi */
|
|
|
139 : "=f" (pi)
|
|
|
140 : /* no inputs */ );
|
|
|
141 __asm ("fscale%.b #-1,%0" /* no loss of accuracy */
|
|
|
142 : "=f" (pi_over_2)
|
|
|
143 : "0" (pi));
|
|
|
144 if (x > 0)
|
|
|
145 {
|
|
|
146 if (y > 0)
|
|
|
147 {
|
|
|
148 if (x > y)
|
|
|
149 return atan (y / x);
|
|
|
150 else
|
|
|
151 return pi_over_2 - atan (x / y);
|
|
|
152 }
|
|
|
153 else
|
|
|
154 {
|
|
|
155 if (x > -y)
|
|
|
156 return atan (y / x);
|
|
|
157 else
|
|
|
158 return - pi_over_2 - atan (x / y);
|
|
|
159 }
|
|
|
160 }
|
|
|
161 else
|
|
|
162 {
|
|
|
163 if (y < 0)
|
|
|
164 {
|
|
|
165 if (-x > -y)
|
|
|
166 return - pi + atan (y / x);
|
|
|
167 else
|
|
|
168 return - pi_over_2 - atan (x / y);
|
|
|
169 }
|
|
|
170 else
|
|
|
171 {
|
|
|
172 if (-x > y)
|
|
|
173 return pi + atan (y / x);
|
|
|
174 else if (y > 0)
|
|
|
175 return pi_over_2 - atan (x / y);
|
|
|
176 else
|
|
|
177 {
|
|
|
178 double value;
|
|
|
179
|
|
|
180 errno = EDOM;
|
|
|
181 __asm ("fmove%.d #0x7fffffffffffffff,%0" /* quiet NaN */
|
|
|
182 : "=f" (value)
|
|
|
183 : /* no inputs */);
|
|
|
184 return value;
|
|
|
185 }
|
|
|
186 }
|
|
|
187 }
|
|
|
188 }
|
|
|
189
|
|
|
190 __inline extern double
|
|
|
191 sinh (double x)
|
|
|
192 {
|
|
|
193 double value;
|
|
|
194
|
|
|
195 __asm ("fsinh%.x %1,%0"
|
|
|
196 : "=f" (value)
|
|
|
197 : "f" (x));
|
|
|
198 return value;
|
|
|
199 }
|
|
|
200
|
|
|
201 __inline extern double
|
|
|
202 cosh (double x)
|
|
|
203 {
|
|
|
204 double value;
|
|
|
205
|
|
|
206 __asm ("fcosh%.x %1,%0"
|
|
|
207 : "=f" (value)
|
|
|
208 : "f" (x));
|
|
|
209 return value;
|
|
|
210 }
|
|
|
211
|
|
|
212 __inline extern double
|
|
|
213 tanh (double x)
|
|
|
214 {
|
|
|
215 double value;
|
|
|
216
|
|
|
217 __asm ("ftanh%.x %1,%0"
|
|
|
218 : "=f" (value)
|
|
|
219 : "f" (x));
|
|
|
220 return value;
|
|
|
221 }
|
|
|
222
|
|
|
223 __inline extern double
|
|
|
224 atanh (double x)
|
|
|
225 {
|
|
|
226 double value;
|
|
|
227
|
|
|
228 __asm ("fatanh%.x %1,%0"
|
|
|
229 : "=f" (value)
|
|
|
230 : "f" (x));
|
|
|
231 return value;
|
|
|
232 }
|
|
|
233
|
|
|
234 __inline extern double
|
|
|
235 exp (double x)
|
|
|
236 {
|
|
|
237 double value;
|
|
|
238
|
|
|
239 __asm ("fetox%.x %1,%0"
|
|
|
240 : "=f" (value)
|
|
|
241 : "f" (x));
|
|
|
242 return value;
|
|
|
243 }
|
|
|
244
|
|
|
245 __inline extern double
|
|
|
246 expm1 (double x)
|
|
|
247 {
|
|
|
248 double value;
|
|
|
249
|
|
|
250 __asm ("fetoxm1%.x %1,%0"
|
|
|
251 : "=f" (value)
|
|
|
252 : "f" (x));
|
|
|
253 return value;
|
|
|
254 }
|
|
|
255
|
|
|
256 __inline extern double
|
|
|
257 log (double x)
|
|
|
258 {
|
|
|
259 double value;
|
|
|
260
|
|
|
261 __asm ("flogn%.x %1,%0"
|
|
|
262 : "=f" (value)
|
|
|
263 : "f" (x));
|
|
|
264 return value;
|
|
|
265 }
|
|
|
266
|
|
|
267 __inline extern double
|
|
|
268 log1p (double x)
|
|
|
269 {
|
|
|
270 double value;
|
|
|
271
|
|
|
272 __asm ("flognp1%.x %1,%0"
|
|
|
273 : "=f" (value)
|
|
|
274 : "f" (x));
|
|
|
275 return value;
|
|
|
276 }
|
|
|
277
|
|
|
278 __inline extern double
|
|
|
279 log10 (double x)
|
|
|
280 {
|
|
|
281 double value;
|
|
|
282
|
|
|
283 __asm ("flog10%.x %1,%0"
|
|
|
284 : "=f" (value)
|
|
|
285 : "f" (x));
|
|
|
286 return value;
|
|
|
287 }
|
|
|
288
|
|
|
289 __inline extern double
|
|
|
290 sqrt (double x)
|
|
|
291 {
|
|
|
292 double value;
|
|
|
293
|
|
|
294 __asm ("fsqrt%.x %1,%0"
|
|
|
295 : "=f" (value)
|
|
|
296 : "f" (x));
|
|
|
297 return value;
|
|
|
298 }
|
|
|
299
|
|
|
300 __inline extern double
|
|
|
301 hypot (double x, double y)
|
|
|
302 {
|
|
|
303 return sqrt (x*x + y*y);
|
|
|
304 }
|
|
|
305
|
|
|
306 __inline extern double
|
|
|
307 pow (double x, double y)
|
|
|
308 {
|
|
|
309 if (x > 0)
|
|
|
310 return exp (y * log (x));
|
|
|
311 else if (x == 0)
|
|
|
312 {
|
|
|
313 if (y > 0)
|
|
|
314 return 0.0;
|
|
|
315 else
|
|
|
316 {
|
|
|
317 double value;
|
|
|
318
|
|
|
319 errno = EDOM;
|
|
|
320 __asm ("fmove%.d #0x7fffffffffffffff,%0" /* quiet NaN */
|
|
|
321 : "=f" (value)
|
|
|
322 : /* no inputs */);
|
|
|
323 return value;
|
|
|
324 }
|
|
|
325 }
|
|
|
326 else
|
|
|
327 {
|
|
|
328 double temp;
|
|
|
329
|
|
|
330 __asm ("fintrz%.x %1,%0"
|
|
|
331 : "=f" (temp) /* integer-valued float */
|
|
|
332 : "f" (y));
|
|
|
333 if (y == temp)
|
|
|
334 {
|
|
|
335 int i = (int) y;
|
|
|
336
|
|
|
337 if ((i & 1) == 0) /* even */
|
|
|
338 return exp (y * log (-x));
|
|
|
339 else
|
|
|
340 return - exp (y * log (-x));
|
|
|
341 }
|
|
|
342 else
|
|
|
343 {
|
|
|
344 double value;
|
|
|
345
|
|
|
346 errno = EDOM;
|
|
|
347 __asm ("fmove%.d #0x7fffffffffffffff,%0" /* quiet NaN */
|
|
|
348 : "=f" (value)
|
|
|
349 : /* no inputs */);
|
|
|
350 return value;
|
|
|
351 }
|
|
|
352 }
|
|
|
353 }
|
|
|
354
|
|
|
355 __inline extern double
|
|
|
356 fabs (double x)
|
|
|
357 {
|
|
|
358 double value;
|
|
|
359
|
|
|
360 __asm ("fabs%.x %1,%0"
|
|
|
361 : "=f" (value)
|
|
|
362 : "f" (x));
|
|
|
363 return value;
|
|
|
364 }
|
|
|
365
|
|
|
366 __inline extern double
|
|
|
367 ceil (double x)
|
|
|
368 {
|
|
|
369 int rounding_mode, round_up;
|
|
|
370 double value;
|
|
|
371
|
|
|
372 __asm volatile ("fmove%.l %!,%0"
|
|
|
373 : "=dm" (rounding_mode)
|
|
|
374 : /* no inputs */ );
|
|
|
375 round_up = rounding_mode | 0x30;
|
|
|
376 __asm volatile ("fmove%.l %0,%!"
|
|
|
377 : /* no outputs */
|
|
|
378 : "dmi" (round_up));
|
|
|
379 __asm volatile ("fint%.x %1,%0"
|
|
|
380 : "=f" (value)
|
|
|
381 : "f" (x));
|
|
|
382 __asm volatile ("fmove%.l %0,%!"
|
|
|
383 : /* no outputs */
|
|
|
384 : "dmi" (rounding_mode));
|
|
|
385 return value;
|
|
|
386 }
|
|
|
387
|
|
|
388 __inline extern double
|
|
|
389 floor (double x)
|
|
|
390 {
|
|
|
391 int rounding_mode, round_down;
|
|
|
392 double value;
|
|
|
393
|
|
|
394 __asm volatile ("fmove%.l %!,%0"
|
|
|
395 : "=dm" (rounding_mode)
|
|
|
396 : /* no inputs */ );
|
|
|
397 round_down = (rounding_mode & ~0x10)
|
|
|
398 | 0x20;
|
|
|
399 __asm volatile ("fmove%.l %0,%!"
|
|
|
400 : /* no outputs */
|
|
|
401 : "dmi" (round_down));
|
|
|
402 __asm volatile ("fint%.x %1,%0"
|
|
|
403 : "=f" (value)
|
|
|
404 : "f" (x));
|
|
|
405 __asm volatile ("fmove%.l %0,%!"
|
|
|
406 : /* no outputs */
|
|
|
407 : "dmi" (rounding_mode));
|
|
|
408 return value;
|
|
|
409 }
|
|
|
410
|
|
|
411 __inline extern double
|
|
|
412 rint (double x)
|
|
|
413 {
|
|
|
414 int rounding_mode, round_nearest;
|
|
|
415 double value;
|
|
|
416
|
|
|
417 __asm volatile ("fmove%.l %!,%0"
|
|
|
418 : "=dm" (rounding_mode)
|
|
|
419 : /* no inputs */ );
|
|
|
420 round_nearest = rounding_mode & ~0x30;
|
|
|
421 __asm volatile ("fmove%.l %0,%!"
|
|
|
422 : /* no outputs */
|
|
|
423 : "dmi" (round_nearest));
|
|
|
424 __asm volatile ("fint%.x %1,%0"
|
|
|
425 : "=f" (value)
|
|
|
426 : "f" (x));
|
|
|
427 __asm volatile ("fmove%.l %0,%!"
|
|
|
428 : /* no outputs */
|
|
|
429 : "dmi" (rounding_mode));
|
|
|
430 return value;
|
|
|
431 }
|
|
|
432
|
|
|
433 __inline extern double
|
|
|
434 fmod (double x, double y)
|
|
|
435 {
|
|
|
436 double value;
|
|
|
437
|
|
|
438 __asm ("fmod%.x %2,%0"
|
|
|
439 : "=f" (value)
|
|
|
440 : "0" (x),
|
|
|
441 "f" (y));
|
|
|
442 return value;
|
|
|
443 }
|
|
|
444
|
|
|
445 __inline extern double
|
|
|
446 drem (double x, double y)
|
|
|
447 {
|
|
|
448 double value;
|
|
|
449
|
|
|
450 __asm ("frem%.x %2,%0"
|
|
|
451 : "=f" (value)
|
|
|
452 : "0" (x),
|
|
|
453 "f" (y));
|
|
|
454 return value;
|
|
|
455 }
|
|
|
456
|
|
|
457 __inline extern double
|
|
|
458 scalb (double x, int n)
|
|
|
459 {
|
|
|
460 double value;
|
|
|
461
|
|
|
462 __asm ("fscale%.l %2,%0"
|
|
|
463 : "=f" (value)
|
|
|
464 : "0" (x),
|
|
|
465 "dmi" (n));
|
|
|
466 return value;
|
|
|
467 }
|
|
|
468
|
|
|
469 __inline extern double
|
|
|
470 logb (double x)
|
|
|
471 {
|
|
|
472 double exponent;
|
|
|
473
|
|
|
474 __asm ("fgetexp%.x %1,%0"
|
|
|
475 : "=f" (exponent)
|
|
|
476 : "f" (x));
|
|
|
477 return exponent;
|
|
|
478 }
|
|
|
479
|
|
|
480 __inline extern double
|
|
|
481 ldexp (double x, int n)
|
|
|
482 {
|
|
|
483 double value;
|
|
|
484
|
|
|
485 __asm ("fscale%.l %2,%0"
|
|
|
486 : "=f" (value)
|
|
|
487 : "0" (x),
|
|
|
488 "dmi" (n));
|
|
|
489 return value;
|
|
|
490 }
|
|
|
491
|
|
|
492 __inline extern double
|
|
|
493 frexp (double x, int *exp)
|
|
|
494 {
|
|
|
495 double float_exponent;
|
|
|
496 int int_exponent;
|
|
|
497 double mantissa;
|
|
|
498
|
|
|
499 __asm ("fgetexp%.x %1,%0"
|
|
|
500 : "=f" (float_exponent) /* integer-valued float */
|
|
|
501 : "f" (x));
|
|
|
502 int_exponent = (int) float_exponent;
|
|
|
503 __asm ("fgetman%.x %1,%0"
|
|
|
504 : "=f" (mantissa) /* 1.0 <= mantissa < 2.0 */
|
|
|
505 : "f" (x));
|
|
|
506 if (mantissa != 0)
|
|
|
507 {
|
|
|
508 __asm ("fscale%.b #-1,%0"
|
|
|
509 : "=f" (mantissa) /* mantissa /= 2.0 */
|
|
|
510 : "0" (mantissa));
|
|
|
511 int_exponent += 1;
|
|
|
512 }
|
|
|
513 *exp = int_exponent;
|
|
|
514 return mantissa;
|
|
|
515 }
|
|
|
516
|
|
|
517 __inline extern double
|
|
|
518 modf (double x, double *ip)
|
|
|
519 {
|
|
|
520 double temp;
|
|
|
521
|
|
|
522 __asm ("fintrz%.x %1,%0"
|
|
|
523 : "=f" (temp) /* integer-valued float */
|
|
|
524 : "f" (x));
|
|
|
525 *ip = temp;
|
|
|
526 return x - temp;
|
|
|
527 }
|
|
|
528
|
|
|
529 #endif /* not __math_68881 */
|
