![[BACK]](/cvsweb/icons/back.gif){kind=icon}
Return to math-68881.h CVS log ![[TXT]](/cvsweb/icons/text.gif){kind=icon}
![[DIR]](/cvsweb/icons/dir.gif){kind=icon}
Up to [Apple XNU] / GNUtools / cc|
Return to math-68881.h CVS log | Up to [Apple XNU] / GNUtools / cc |
1.1 root 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 ([email protected]). *
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 [email protected]. */
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: #ifndef __math_68881
40: #define __math_68881
41:
42: #include <errno.h>
43:
44: #undef HUGE_VAL
45: #ifdef __sun__
46: /* The Sun assembler fails to handle the hex constant in the usual defn. */
47: #define HUGE_VAL \
48: ({ \
49: static union { int i[2]; double d; } u = { {0x7ff00000, 0} }; \
50: u.d; \
51: })
52: #else
53: #define HUGE_VAL \
54: ({ \
55: double huge_val; \
56: \
57: __asm ("fmove%.d %#0x7ff0000000000000,%0" /* Infinity */ \
58: : "=f" (huge_val) \
59: : /* no inputs */); \
60: huge_val; \
61: })
62: #endif
63:
64: __inline static const double
65: sin (double x)
66: {
67: double value;
68:
69: __asm ("fsin%.x %1,%0"
70: : "=f" (value)
71: : "f" (x));
72: return value;
73: }
74:
75: __inline static const double
76: cos (double x)
77: {
78: double value;
79:
80: __asm ("fcos%.x %1,%0"
81: : "=f" (value)
82: : "f" (x));
83: return value;
84: }
85:
86: __inline static const double
87: tan (double x)
88: {
89: double value;
90:
91: __asm ("ftan%.x %1,%0"
92: : "=f" (value)
93: : "f" (x));
94: return value;
95: }
96:
97: __inline static const double
98: asin (double x)
99: {
100: double value;
101:
102: __asm ("fasin%.x %1,%0"
103: : "=f" (value)
104: : "f" (x));
105: return value;
106: }
107:
108: __inline static const double
109: acos (double x)
110: {
111: double value;
112:
113: __asm ("facos%.x %1,%0"
114: : "=f" (value)
115: : "f" (x));
116: return value;
117: }
118:
119: __inline static const double
120: atan (double x)
121: {
122: double value;
123:
124: __asm ("fatan%.x %1,%0"
125: : "=f" (value)
126: : "f" (x));
127: return value;
128: }
129:
130: __inline static const double
131: atan2 (double y, double x)
132: {
133: double pi, pi_over_2;
134:
135: __asm ("fmovecr%.x %#0,%0" /* extended precision pi */
136: : "=f" (pi)
137: : /* no inputs */ );
138: __asm ("fscale%.b %#-1,%0" /* no loss of accuracy */
139: : "=f" (pi_over_2)
140: : "0" (pi));
141: if (x > 0)
142: {
143: if (y > 0)
144: {
145: if (x > y)
146: return atan (y / x);
147: else
148: return pi_over_2 - atan (x / y);
149: }
150: else
151: {
152: if (x > -y)
153: return atan (y / x);
154: else
155: return - pi_over_2 - atan (x / y);
156: }
157: }
158: else
159: {
160: if (y < 0)
161: {
162: if (-x > -y)
163: return - pi + atan (y / x);
164: else
165: return - pi_over_2 - atan (x / y);
166: }
167: else
168: {
169: if (-x > y)
170: return pi + atan (y / x);
171: else if (y > 0)
172: return pi_over_2 - atan (x / y);
173: else
174: {
175: double value;
176:
177: errno = EDOM;
178: __asm ("fmove%.d %#0x7fffffffffffffff,%0" /* quiet NaN */
179: : "=f" (value)
180: : /* no inputs */);
181: return value;
182: }
183: }
184: }
185: }
186:
187: __inline static const double
188: sinh (double x)
189: {
190: double value;
191:
192: __asm ("fsinh%.x %1,%0"
193: : "=f" (value)
194: : "f" (x));
195: return value;
196: }
197:
198: __inline static const double
199: cosh (double x)
200: {
201: double value;
202:
203: __asm ("fcosh%.x %1,%0"
204: : "=f" (value)
205: : "f" (x));
206: return value;
207: }
208:
209: __inline static const double
210: tanh (double x)
211: {
212: double value;
213:
214: __asm ("ftanh%.x %1,%0"
215: : "=f" (value)
216: : "f" (x));
217: return value;
218: }
219:
220: __inline static const double
221: atanh (double x)
222: {
223: double value;
224:
225: __asm ("fatanh%.x %1,%0"
226: : "=f" (value)
227: : "f" (x));
228: return value;
229: }
230:
231: __inline static const double
232: exp (double x)
233: {
234: double value;
235:
236: __asm ("fetox%.x %1,%0"
237: : "=f" (value)
238: : "f" (x));
239: return value;
240: }
241:
242: __inline static const double
243: expm1 (double x)
244: {
245: double value;
246:
247: __asm ("fetoxm1%.x %1,%0"
248: : "=f" (value)
249: : "f" (x));
250: return value;
251: }
252:
253: __inline static const double
254: log (double x)
255: {
256: double value;
257:
258: __asm ("flogn%.x %1,%0"
259: : "=f" (value)
260: : "f" (x));
261: return value;
262: }
263:
264: __inline static const double
265: log1p (double x)
266: {
267: double value;
268:
269: __asm ("flognp1%.x %1,%0"
270: : "=f" (value)
271: : "f" (x));
272: return value;
273: }
274:
275: __inline static const double
276: log10 (double x)
277: {
278: double value;
279:
280: __asm ("flog10%.x %1,%0"
281: : "=f" (value)
282: : "f" (x));
283: return value;
284: }
285:
286: __inline static const double
287: sqrt (double x)
288: {
289: double value;
290:
291: __asm ("fsqrt%.x %1,%0"
292: : "=f" (value)
293: : "f" (x));
294: return value;
295: }
296:
297: __inline static const double
298: hypot (const double x, const double y)
299: {
300: return sqrt (x*x + y*y);
301: }
302:
303: __inline static const double
304: pow (const double x, const double y)
305: {
306: if (x > 0)
307: return exp (y * log (x));
308: else if (x == 0)
309: {
310: if (y > 0)
311: return 0.0;
312: else
313: {
314: double value;
315:
316: errno = EDOM;
317: __asm ("fmove%.d %#0x7fffffffffffffff,%0" /* quiet NaN */
318: : "=f" (value)
319: : /* no inputs */);
320: return value;
321: }
322: }
323: else
324: {
325: double temp;
326:
327: __asm ("fintrz%.x %1,%0"
328: : "=f" (temp) /* integer-valued float */
329: : "f" (y));
330: if (y == temp)
331: {
332: int i = (int) y;
333:
334: if ((i & 1) == 0) /* even */
335: return exp (y * log (-x));
336: else
337: return - exp (y * log (-x));
338: }
339: else
340: {
341: double value;
342:
343: errno = EDOM;
344: __asm ("fmove%.d %#0x7fffffffffffffff,%0" /* quiet NaN */
345: : "=f" (value)
346: : /* no inputs */);
347: return value;
348: }
349: }
350: }
351:
352: __inline static const double
353: fabs (double x)
354: {
355: double value;
356:
357: __asm ("fabs%.x %1,%0"
358: : "=f" (value)
359: : "f" (x));
360: return value;
361: }
362:
363: __inline static const double
364: ceil (double x)
365: {
366: int rounding_mode, round_up;
367: double value;
368:
369: __asm volatile ("fmove%.l %!,%0"
370: : "=dm" (rounding_mode)
371: : /* no inputs */ );
372: round_up = rounding_mode | 0x30;
373: __asm volatile ("fmove%.l %0,%!"
374: : /* no outputs */
375: : "dmi" (round_up));
376: __asm volatile ("fint%.x %1,%0"
377: : "=f" (value)
378: : "f" (x));
379: __asm volatile ("fmove%.l %0,%!"
380: : /* no outputs */
381: : "dmi" (rounding_mode));
382: return value;
383: }
384:
385: __inline static const double
386: floor (double x)
387: {
388: int rounding_mode, round_down;
389: double value;
390:
391: __asm volatile ("fmove%.l %!,%0"
392: : "=dm" (rounding_mode)
393: : /* no inputs */ );
394: round_down = (rounding_mode & ~0x10)
395: | 0x20;
396: __asm volatile ("fmove%.l %0,%!"
397: : /* no outputs */
398: : "dmi" (round_down));
399: __asm volatile ("fint%.x %1,%0"
400: : "=f" (value)
401: : "f" (x));
402: __asm volatile ("fmove%.l %0,%!"
403: : /* no outputs */
404: : "dmi" (rounding_mode));
405: return value;
406: }
407:
408: __inline static const double
409: rint (double x)
410: {
411: int rounding_mode, round_nearest;
412: double value;
413:
414: __asm volatile ("fmove%.l %!,%0"
415: : "=dm" (rounding_mode)
416: : /* no inputs */ );
417: round_nearest = rounding_mode & ~0x30;
418: __asm volatile ("fmove%.l %0,%!"
419: : /* no outputs */
420: : "dmi" (round_nearest));
421: __asm volatile ("fint%.x %1,%0"
422: : "=f" (value)
423: : "f" (x));
424: __asm volatile ("fmove%.l %0,%!"
425: : /* no outputs */
426: : "dmi" (rounding_mode));
427: return value;
428: }
429:
430: __inline static const double
431: fmod (double x, double y)
432: {
433: double value;
434:
435: __asm ("fmod%.x %2,%0"
436: : "=f" (value)
437: : "0" (x),
438: "f" (y));
439: return value;
440: }
441:
442: __inline static const double
443: drem (double x, double y)
444: {
445: double value;
446:
447: __asm ("frem%.x %2,%0"
448: : "=f" (value)
449: : "0" (x),
450: "f" (y));
451: return value;
452: }
453:
454: __inline static const double
455: scalb (double x, int n)
456: {
457: double value;
458:
459: __asm ("fscale%.l %2,%0"
460: : "=f" (value)
461: : "0" (x),
462: "dmi" (n));
463: return value;
464: }
465:
466: __inline static double
467: logb (double x)
468: {
469: double exponent;
470:
471: __asm ("fgetexp%.x %1,%0"
472: : "=f" (exponent)
473: : "f" (x));
474: return exponent;
475: }
476:
477: __inline static const double
478: ldexp (double x, int n)
479: {
480: double value;
481:
482: __asm ("fscale%.l %2,%0"
483: : "=f" (value)
484: : "0" (x),
485: "dmi" (n));
486: return value;
487: }
488:
489: __inline static double
490: frexp (double x, int *exp)
491: {
492: double float_exponent;
493: int int_exponent;
494: double mantissa;
495:
496: __asm ("fgetexp%.x %1,%0"
497: : "=f" (float_exponent) /* integer-valued float */
498: : "f" (x));
499: int_exponent = (int) float_exponent;
500: __asm ("fgetman%.x %1,%0"
501: : "=f" (mantissa) /* 1.0 <= mantissa < 2.0 */
502: : "f" (x));
503: if (mantissa != 0)
504: {
505: __asm ("fscale%.b %#-1,%0"
506: : "=f" (mantissa) /* mantissa /= 2.0 */
507: : "0" (mantissa));
508: int_exponent += 1;
509: }
510: *exp = int_exponent;
511: return mantissa;
512: }
513:
514: __inline static double
515: modf (double x, double *ip)
516: {
517: double temp;
518:
519: __asm ("fintrz%.x %1,%0"
520: : "=f" (temp) /* integer-valued float */
521: : "f" (x));
522: *ip = temp;
523: return x - temp;
524: }
525:
526: #endif /* not __math_68881 */
This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.