![[BACK]](/cvsweb/icons/back.gif){kind=icon}
Return to md-fpp.h CVS log ![[TXT]](/cvsweb/icons/text.gif){kind=icon}
![[DIR]](/cvsweb/icons/dir.gif){kind=icon}
Up to [Previous NeXT emulator] / previous_trunk / src / cpu|
Return to md-fpp.h CVS log | Up to [Previous NeXT emulator] / previous_trunk / src / cpu |
1.1 ! root 1: /* ! 2: * UAE - The Un*x Amiga Emulator ! 3: * ! 4: * MC68881 emulation ! 5: * ! 6: * Conversion routines for hosts knowing floating point format. ! 7: * ! 8: * Copyright 1996 Herman ten Brugge ! 9: * Modified 2005 Peter Keunecke ! 10: */ ! 11: ! 12: #ifndef FPP_H ! 13: #define FPP_H ! 14: ! 15: #define __USE_ISOC9X /* We might be able to pick up a NaN */ ! 16: ! 17: #include <math.h> ! 18: #include <float.h> ! 19: #include <fenv.h> ! 20: ! 21: //#pragma STDC FENV_ACCESS on ! 22: ! 23: #define USE_HOST_ROUNDING ! 24: ! 25: #define FPCR_ROUNDING_MODE 0x00000030 ! 26: #define FPCR_ROUND_NEAR 0x00000000 ! 27: #define FPCR_ROUND_ZERO 0x00000010 ! 28: #define FPCR_ROUND_MINF 0x00000020 ! 29: #define FPCR_ROUND_PINF 0x00000030 ! 30: ! 31: #define FPCR_ROUNDING_PRECISION 0x000000c0 ! 32: #define FPCR_PRECISION_SINGLE 0x00000040 ! 33: #define FPCR_PRECISION_DOUBLE 0x00000080 ! 34: #define FPCR_PRECISION_EXTENDED 0x00000000 ! 35: ! 36: extern uae_u32 fpp_get_fpsr (void); ! 37: extern void fpsr_set_exception(uae_u32 exception); ! 38: ! 39: static int fp_rnd_prec = 80; ! 40: ! 41: /* Functions for setting host/library modes and getting status */ ! 42: STATIC_INLINE void init_fp_mode(void) { ! 43: ! 44: } ! 45: STATIC_INLINE void set_fp_mode(uae_u32 mode_control) ! 46: { ! 47: switch(mode_control & FPCR_ROUNDING_PRECISION) { ! 48: case FPCR_PRECISION_EXTENDED: // X ! 49: fp_rnd_prec = 80; ! 50: break; ! 51: case FPCR_PRECISION_SINGLE: // S ! 52: fp_rnd_prec = 32; ! 53: break; ! 54: case FPCR_PRECISION_DOUBLE: // D ! 55: default: // undefined ! 56: fp_rnd_prec = 64; ! 57: break; ! 58: } ! 59: #ifdef USE_HOST_ROUNDING ! 60: switch(mode_control & FPCR_ROUNDING_MODE) { ! 61: case FPCR_ROUND_NEAR: // to neareset ! 62: fesetround(FE_TONEAREST); ! 63: break; ! 64: case FPCR_ROUND_ZERO: // to zero ! 65: fesetround(FE_TOWARDZERO); ! 66: break; ! 67: case FPCR_ROUND_MINF: // to minus ! 68: fesetround(FE_DOWNWARD); ! 69: break; ! 70: case FPCR_ROUND_PINF: // to plus ! 71: fesetround(FE_UPWARD); ! 72: break; ! 73: } ! 74: return; ! 75: #endif ! 76: } ! 77: STATIC_INLINE void get_fp_status(uae_u32 *status) ! 78: { ! 79: int exp_flags = fetestexcept(FE_ALL_EXCEPT); ! 80: if (exp_flags) { ! 81: if (exp_flags & FE_INEXACT) ! 82: *status |= 0x0200; ! 83: if (exp_flags & FE_DIVBYZERO) ! 84: *status |= 0x0400; ! 85: if (exp_flags & FE_UNDERFLOW) ! 86: *status |= 0x0800; ! 87: if (exp_flags & FE_OVERFLOW) ! 88: *status |= 0x1000; ! 89: if (exp_flags & FE_INVALID) ! 90: *status |= 0x2000; ! 91: } ! 92: /* FIXME: how to detect SNAN? */ ! 93: } ! 94: STATIC_INLINE void clear_fp_status(void) ! 95: { ! 96: feclearexcept (FE_ALL_EXCEPT); ! 97: } ! 98: ! 99: /* Helper functions */ ! 100: STATIC_INLINE const char *fp_print(fptype *fx) ! 101: { ! 102: static char fs[32]; ! 103: bool n, d; ! 104: ! 105: n = signbit(*fx) ? 1 : 0; ! 106: d = isnormal(*fx) ? 0 : 1; ! 107: ! 108: if (isinf(*fx)) { ! 109: sprintf(fs, "%c%s", n?'-':'+', "inf"); ! 110: } else if (isnan(*fx)) { ! 111: sprintf(fs, "%c%s", n?'-':'+', "nan"); ! 112: } else { ! 113: if (n) ! 114: *fx *= -1.0; ! 115: #ifdef USE_LONG_DOUBLE ! 116: sprintf(fs, "%c%#.16Le%s%s", n?'-':'+', *fx, "", d?"D":""); ! 117: #else ! 118: sprintf(fs, "%c%#.16e%s%s", n?'-':'+', *fx, "", d?"D":""); ! 119: #endif ! 120: } ! 121: ! 122: return fs; ! 123: } ! 124: ! 125: /* Functions for detecting float type */ ! 126: STATIC_INLINE bool fp_is_snan(fptype *fp) ! 127: { ! 128: return 0; /* FIXME: how to detect SNAN */ ! 129: } ! 130: STATIC_INLINE void fp_unset_snan(fptype *fp) ! 131: { ! 132: /* FIXME: how to unset SNAN */ ! 133: } ! 134: STATIC_INLINE bool fp_is_nan (fptype *fp) ! 135: { ! 136: return isnan(*fp) != 0; ! 137: } ! 138: STATIC_INLINE bool fp_is_infinity (fptype *fp) ! 139: { ! 140: return isinf(*fp) != 0; ! 141: } ! 142: STATIC_INLINE bool fp_is_zero(fptype *fp) ! 143: { ! 144: return (*fp == 0.0); ! 145: } ! 146: STATIC_INLINE bool fp_is_neg(fptype *fp) ! 147: { ! 148: return signbit(*fp) != 0; ! 149: } ! 150: STATIC_INLINE bool fp_is_denormal(fptype *fp) ! 151: { ! 152: return false; ! 153: //return (isnormal(*fp) == 0); /* FIXME: how to differ denormal/unnormal? */ ! 154: } ! 155: STATIC_INLINE bool fp_is_unnormal(fptype *fp) ! 156: { ! 157: return false; ! 158: //return (isnormal(*fp) == 0); /* FIXME: how to differ denormal/unnormal? */ ! 159: } ! 160: ! 161: /* Function for normalizing unnormals FIXME: how to do this with native floats? */ ! 162: STATIC_INLINE void fp_normalize(fptype *fp) ! 163: { ! 164: } ! 165: ! 166: /* Functions for converting between float formats */ ! 167: /* FIXME: how to preserve/fix denormals and unnormals? */ ! 168: ! 169: STATIC_INLINE void to_single(fptype *fp, uae_u32 wrd1) ! 170: { ! 171: union { ! 172: float f; ! 173: uae_u32 u; ! 174: } val; ! 175: ! 176: val.u = wrd1; ! 177: *fp = (fptype) val.f; ! 178: } ! 179: STATIC_INLINE uae_u32 from_single(fptype *fp) ! 180: { ! 181: union { ! 182: float f; ! 183: uae_u32 u; ! 184: } val; ! 185: ! 186: val.f = (float) *fp; ! 187: return val.u; ! 188: } ! 189: ! 190: STATIC_INLINE void to_double(fptype *fp, uae_u32 wrd1, uae_u32 wrd2) ! 191: { ! 192: union { ! 193: double d; ! 194: uae_u32 u[2]; ! 195: } val; ! 196: ! 197: #ifdef WORDS_BIGENDIAN ! 198: val.u[0] = wrd1; ! 199: val.u[1] = wrd2; ! 200: #else ! 201: val.u[1] = wrd1; ! 202: val.u[0] = wrd2; ! 203: #endif ! 204: *fp = (fptype) val.d; ! 205: } ! 206: STATIC_INLINE void from_double(fptype *fp, uae_u32 *wrd1, uae_u32 *wrd2) ! 207: { ! 208: union { ! 209: double d; ! 210: uae_u32 u[2]; ! 211: } val; ! 212: ! 213: val.d = (double) *fp; ! 214: #ifdef WORDS_BIGENDIAN ! 215: *wrd1 = val.u[0]; ! 216: *wrd2 = val.u[1]; ! 217: #else ! 218: *wrd1 = val.u[1]; ! 219: *wrd2 = val.u[0]; ! 220: #endif ! 221: } ! 222: #ifdef USE_LONG_DOUBLE ! 223: STATIC_INLINE void to_exten(fptype *fp, uae_u32 wrd1, uae_u32 wrd2, uae_u32 wrd3) ! 224: { ! 225: union { ! 226: long double ld; ! 227: uae_u32 u[3]; ! 228: } val; ! 229: ! 230: #if WORDS_BIGENDIAN ! 231: val.u[0] = (wrd1 & 0xffff0000) | ((wrd2 & 0xffff0000) >> 16); ! 232: val.u[1] = (wrd2 & 0x0000ffff) | ((wrd3 & 0xffff0000) >> 16); ! 233: val.u[2] = (wrd3 & 0x0000ffff) << 16; ! 234: #else ! 235: val.u[0] = wrd3; ! 236: val.u[1] = wrd2; ! 237: val.u[2] = wrd1 >> 16; ! 238: #endif ! 239: *fp = val.ld; ! 240: } ! 241: STATIC_INLINE void from_exten(fptype *fp, uae_u32 *wrd1, uae_u32 *wrd2, uae_u32 *wrd3) ! 242: { ! 243: union { ! 244: long double ld; ! 245: uae_u32 u[3]; ! 246: } val; ! 247: ! 248: val.ld = *fp; ! 249: #if WORDS_BIGENDIAN ! 250: *wrd1 = val.u[0] & 0xffff0000; ! 251: *wrd2 = ((val.u[0] & 0x0000ffff) << 16) | ((val.u[1] & 0xffff0000) >> 16); ! 252: *wrd3 = ((val.u[1] & 0x0000ffff) << 16) | ((val.u[2] & 0xffff0000) >> 16); ! 253: #else ! 254: *wrd3 = val.u[0]; ! 255: *wrd2 = val.u[1]; ! 256: *wrd1 = val.u[2] << 16; ! 257: #endif ! 258: } ! 259: #else // if !USE_LONG_DOUBLE ! 260: static const double twoto32 = 4294967296.0; ! 261: STATIC_INLINE void to_exten(fptype *fp, uae_u32 wrd1, uae_u32 wrd2, uae_u32 wrd3) ! 262: { ! 263: double frac; ! 264: if ((wrd1 & 0x7fff0000) == 0 && wrd2 == 0 && wrd3 == 0) { ! 265: *fp = (wrd1 & 0x80000000) ? -0.0 : +0.0; ! 266: return; ! 267: } ! 268: frac = ((double)wrd2 + ((double)wrd3 / twoto32)) / 2147483648.0; ! 269: if (wrd1 & 0x80000000) ! 270: frac = -frac; ! 271: *fp = ldexp (frac, ((wrd1 >> 16) & 0x7fff) - 16383); ! 272: } ! 273: STATIC_INLINE void from_exten(fptype *fp, uae_u32 *wrd1, uae_u32 *wrd2, uae_u32 *wrd3) ! 274: { ! 275: int expon; ! 276: double frac; ! 277: fptype v; ! 278: ! 279: v = *fp; ! 280: if (v == 0.0) { ! 281: *wrd1 = signbit(v) ? 0x80000000 : 0; ! 282: *wrd2 = 0; ! 283: *wrd3 = 0; ! 284: return; ! 285: } ! 286: if (v < 0) { ! 287: *wrd1 = 0x80000000; ! 288: v = -v; ! 289: } else { ! 290: *wrd1 = 0; ! 291: } ! 292: frac = frexp (v, &expon); ! 293: frac += 0.5 / (twoto32 * twoto32); ! 294: if (frac >= 1.0) { ! 295: frac /= 2.0; ! 296: expon++; ! 297: } ! 298: *wrd1 |= (((expon + 16383 - 1) & 0x7fff) << 16); ! 299: *wrd2 = (uae_u32) (frac * twoto32); ! 300: *wrd3 = (uae_u32) ((frac * twoto32 - *wrd2) * twoto32); ! 301: } ! 302: #endif // !USE_LONG_DOUBLE ! 303: STATIC_INLINE void to_exten_fmovem(fptype *fp, uae_u32 wrd1, uae_u32 wrd2, uae_u32 wrd3) ! 304: { ! 305: to_exten(fp, wrd1, wrd2, wrd3); ! 306: } ! 307: STATIC_INLINE void from_exten_fmovem(fptype *fp, uae_u32 *wrd1, uae_u32 *wrd2, uae_u32 *wrd3) ! 308: { ! 309: from_exten(fp, wrd1, wrd2, wrd3); ! 310: } ! 311: ! 312: STATIC_INLINE void to_pack (fptype *fp, uae_u32 *wrd) ! 313: { ! 314: char *cp; ! 315: char str[100]; ! 316: ! 317: if (((wrd[0] >> 16) & 0x7fff) == 0x7fff) { ! 318: // infinity has extended exponent and all 0 packed fraction ! 319: // nans are copies bit by bit ! 320: to_exten(fp, wrd[0], wrd[1], wrd[2]); ! 321: return; ! 322: } ! 323: if (!(wrd[0] & 0xf) && !wrd[1] && !wrd[2]) { ! 324: // exponent is not cared about, if mantissa is zero ! 325: wrd[0] &= 0x80000000; ! 326: to_exten(fp, wrd[0], wrd[1], wrd[2]); ! 327: return; ! 328: } ! 329: ! 330: cp = str; ! 331: if (wrd[0] & 0x80000000) ! 332: *cp++ = '-'; ! 333: *cp++ = (wrd[0] & 0xf) + '0'; ! 334: *cp++ = '.'; ! 335: *cp++ = ((wrd[1] >> 28) & 0xf) + '0'; ! 336: *cp++ = ((wrd[1] >> 24) & 0xf) + '0'; ! 337: *cp++ = ((wrd[1] >> 20) & 0xf) + '0'; ! 338: *cp++ = ((wrd[1] >> 16) & 0xf) + '0'; ! 339: *cp++ = ((wrd[1] >> 12) & 0xf) + '0'; ! 340: *cp++ = ((wrd[1] >> 8) & 0xf) + '0'; ! 341: *cp++ = ((wrd[1] >> 4) & 0xf) + '0'; ! 342: *cp++ = ((wrd[1] >> 0) & 0xf) + '0'; ! 343: *cp++ = ((wrd[2] >> 28) & 0xf) + '0'; ! 344: *cp++ = ((wrd[2] >> 24) & 0xf) + '0'; ! 345: *cp++ = ((wrd[2] >> 20) & 0xf) + '0'; ! 346: *cp++ = ((wrd[2] >> 16) & 0xf) + '0'; ! 347: *cp++ = ((wrd[2] >> 12) & 0xf) + '0'; ! 348: *cp++ = ((wrd[2] >> 8) & 0xf) + '0'; ! 349: *cp++ = ((wrd[2] >> 4) & 0xf) + '0'; ! 350: *cp++ = ((wrd[2] >> 0) & 0xf) + '0'; ! 351: *cp++ = 'E'; ! 352: if (wrd[0] & 0x40000000) ! 353: *cp++ = '-'; ! 354: *cp++ = ((wrd[0] >> 24) & 0xf) + '0'; ! 355: *cp++ = ((wrd[0] >> 20) & 0xf) + '0'; ! 356: *cp++ = ((wrd[0] >> 16) & 0xf) + '0'; ! 357: *cp = 0; ! 358: ! 359: #ifdef USE_LONG_DOUBLE ! 360: sscanf (str, "%Le", fp); ! 361: #else ! 362: sscanf (str, "%le", fp); ! 363: #endif ! 364: } ! 365: STATIC_INLINE void from_pack (fptype *fp, uae_u32 *wrd, int kfactor) ! 366: { ! 367: int i, j, t; ! 368: int exp; ! 369: int ndigits; ! 370: char *cp, *strp; ! 371: char str[100]; ! 372: ! 373: if (fp_is_nan (fp)) { ! 374: // copy bit by bit, handle signaling nan ! 375: from_exten(fp, &wrd[0], &wrd[1], &wrd[2]); ! 376: return; ! 377: } ! 378: if (fp_is_infinity (fp)) { ! 379: // extended exponent and all 0 packed fraction ! 380: from_exten(fp, &wrd[0], &wrd[1], &wrd[2]); ! 381: wrd[1] = wrd[2] = 0; ! 382: return; ! 383: } ! 384: ! 385: wrd[0] = wrd[1] = wrd[2] = 0; ! 386: ! 387: #ifdef USE_LONG_DOUBLE ! 388: sprintf (str, "%#.17Le", *fp); ! 389: #else ! 390: sprintf (str, "%#.17e", *fp); ! 391: #endif ! 392: ! 393: // get exponent ! 394: cp = str; ! 395: while (*cp != 'e') { ! 396: if (*cp == 0) ! 397: return; ! 398: cp++; ! 399: } ! 400: cp++; ! 401: if (*cp == '+') ! 402: cp++; ! 403: exp = atoi (cp); ! 404: ! 405: // remove trailing zeros ! 406: cp = str; ! 407: while (*cp != 'e') ! 408: cp++; ! 409: cp[0] = 0; ! 410: cp--; ! 411: while (cp > str && *cp == '0') { ! 412: *cp = 0; ! 413: cp--; ! 414: } ! 415: ! 416: cp = str; ! 417: // get sign ! 418: if (*cp == '-') { ! 419: cp++; ! 420: wrd[0] = 0x80000000; ! 421: } else if (*cp == '+') { ! 422: cp++; ! 423: } ! 424: strp = cp; ! 425: ! 426: if (kfactor <= 0) { ! 427: ndigits = abs (exp) + (-kfactor) + 1; ! 428: } else { ! 429: if (kfactor > 17) { ! 430: kfactor = 17; ! 431: fpsr_set_exception(0x00002000); // OPERR ! 432: } ! 433: ndigits = kfactor; ! 434: } ! 435: ! 436: if (ndigits < 0) ! 437: ndigits = 0; ! 438: if (ndigits > 16) ! 439: ndigits = 16; ! 440: ! 441: // remove decimal point ! 442: strp[1] = strp[0]; ! 443: strp++; ! 444: // add trailing zeros ! 445: i = strlen (strp); ! 446: cp = strp + i; ! 447: while (i < ndigits) { ! 448: *cp++ = '0'; ! 449: i++; ! 450: } ! 451: i = ndigits + 1; ! 452: while (i < 17) { ! 453: strp[i] = 0; ! 454: i++; ! 455: } ! 456: *cp = 0; ! 457: i = ndigits - 1; ! 458: // need to round? ! 459: if (i >= 0 && strp[i + 1] >= '5') { ! 460: while (i >= 0) { ! 461: strp[i]++; ! 462: if (strp[i] <= '9') ! 463: break; ! 464: if (i == 0) { ! 465: strp[i] = '1'; ! 466: exp++; ! 467: } else { ! 468: strp[i] = '0'; ! 469: } ! 470: i--; ! 471: } ! 472: } ! 473: strp[ndigits] = 0; ! 474: ! 475: // store first digit of mantissa ! 476: cp = strp; ! 477: wrd[0] |= *cp++ - '0'; ! 478: ! 479: // store rest of mantissa ! 480: for (j = 1; j < 3; j++) { ! 481: for (i = 0; i < 8; i++) { ! 482: wrd[j] <<= 4; ! 483: if (*cp >= '0' && *cp <= '9') ! 484: wrd[j] |= *cp++ - '0'; ! 485: } ! 486: } ! 487: ! 488: // exponent ! 489: if (exp < 0) { ! 490: wrd[0] |= 0x40000000; ! 491: exp = -exp; ! 492: } ! 493: if (exp > 9999) // ?? ! 494: exp = 9999; ! 495: if (exp > 999) { ! 496: int d = exp / 1000; ! 497: wrd[0] |= d << 12; ! 498: exp -= d * 1000; ! 499: fpsr_set_exception(0x00002000); // OPERR ! 500: } ! 501: i = 100; ! 502: t = 0; ! 503: while (i >= 1) { ! 504: int d = exp / i; ! 505: t <<= 4; ! 506: t |= d; ! 507: exp -= d * i; ! 508: i /= 10; ! 509: } ! 510: wrd[0] |= t << 16; ! 511: } ! 512: ! 513: #ifndef USE_HOST_ROUNDING ! 514: #ifdef USE_LONG_DOUBLE ! 515: #define fp_round_to_minus_infinity(x) floorl(x) ! 516: #define fp_round_to_plus_infinity(x) ceill(x) ! 517: #define fp_round_to_zero(x) ((x) >= 0.0 ? floorl(x) : ceill(x)) ! 518: #define fp_round_to_nearest(x) roundl(x) ! 519: #else // if !USE_LONG_DOUBLE ! 520: #define fp_round_to_minus_infinity(x) floor(x) ! 521: #define fp_round_to_plus_infinity(x) ceil(x) ! 522: #define fp_round_to_zero(x) ((x) >= 0.0 ? floor(x) : ceil(x)) ! 523: #define fp_round_to_nearest(x) round(x) ! 524: #endif // !USE_LONG_DOUBLE ! 525: #endif // USE_HOST_ROUNDING ! 526: ! 527: STATIC_INLINE uae_s64 to_int(fptype *src, int size) ! 528: { ! 529: static fptype fxsizes[6] = ! 530: { ! 531: -128.0, 127.0, ! 532: -32768.0, 32767.0, ! 533: -2147483648.0, 2147483647.0 ! 534: }; ! 535: ! 536: if (*src < fxsizes[size * 2 + 0]) ! 537: *src = fxsizes[size * 2 + 0]; ! 538: if (*src > fxsizes[size * 2 + 1]) ! 539: *src = fxsizes[size * 2 + 1]; ! 540: #ifdef USE_HOST_ROUNDING ! 541: #ifdef USE_LONG_DOUBLE ! 542: return lrintl(*src); ! 543: #else ! 544: return lrint(*src); ! 545: #endif ! 546: #else ! 547: switch (regs.fpcr & FPCR_ROUNDING_MODE) ! 548: { ! 549: case FPCR_ROUND_ZERO: ! 550: return fp_round_to_zero (*src); ! 551: case FPCR_ROUND_MINF: ! 552: return fp_round_to_minus_infinity (*src); ! 553: case FPCR_ROUND_NEAR: ! 554: return fp_round_to_nearest (*src); ! 555: case FPCR_ROUND_PINF: ! 556: return fp_round_to_plus_infinity (*src); ! 557: default: ! 558: return (int) *src; ! 559: } ! 560: #endif ! 561: } ! 562: STATIC_INLINE fptype from_int(uae_s32 src) ! 563: { ! 564: return (fptype) src; ! 565: } ! 566: ! 567: /* Functions for returning exception state data */ ! 568: /* (almost impossible to emulate using native floats) */ ! 569: STATIC_INLINE fptype fp_get_internal_overflow(void) ! 570: { ! 571: return 0.0; ! 572: } ! 573: STATIC_INLINE fptype fp_get_internal_underflow(void) ! 574: { ! 575: return 0.0; ! 576: } ! 577: STATIC_INLINE fptype fp_get_internal(void) ! 578: { ! 579: return 0.0; ! 580: } ! 581: STATIC_INLINE fptype fp_get_internal_round(void) ! 582: { ! 583: return 0.0; ! 584: } ! 585: STATIC_INLINE fptype fp_get_internal_round_all(void) ! 586: { ! 587: return 0.0; ! 588: } ! 589: STATIC_INLINE fptype fp_get_internal_round_exten(void) ! 590: { ! 591: return 0.0; ! 592: } ! 593: STATIC_INLINE uae_u32 fp_get_internal_grs(void) ! 594: { ! 595: return 0.0; ! 596: } ! 597: ! 598: /* Function for denormalizing */ ! 599: STATIC_INLINE void fp_denormalize(fptype *fp, int esign) ! 600: { ! 601: // do nothing ! 602: } ! 603: ! 604: /* Functions for rounding */ ! 605: ! 606: // round to float with extended precision exponent ! 607: STATIC_INLINE void fp_round32(fptype *fp) ! 608: { ! 609: int expon; ! 610: float mant; ! 611: #ifdef USE_LONG_DOUBLE ! 612: mant = (float)(frexpl(*fp, &expon) * 2.0); ! 613: *fp = ldexpl((fptype)mant, expon - 1); ! 614: #else ! 615: mant = (float)(frexp(*fp, &expon) * 2.0); ! 616: *fp = ldexp((fptype)mant, expon - 1); ! 617: #endif ! 618: } ! 619: ! 620: // round to double with extended precision exponent ! 621: STATIC_INLINE void fp_round64(fptype *fp) ! 622: { ! 623: int expon; ! 624: double mant; ! 625: #ifdef USE_LONG_DOUBLE ! 626: mant = (double)(frexpl(*fp, &expon) * 2.0); ! 627: *fp = ldexpl((fptype)mant, expon - 1); ! 628: #else ! 629: mant = (double)(frexp(*fp, &expon) * 2.0); ! 630: *fp = ldexp((fptype)mant, expon - 1); ! 631: #endif ! 632: } ! 633: ! 634: // round to float ! 635: STATIC_INLINE void fp_round_single(fptype *fp) ! 636: { ! 637: *fp = (float) *fp; ! 638: } ! 639: ! 640: // round to double ! 641: STATIC_INLINE void fp_round_double(fptype *fp) ! 642: { ! 643: *fp = (double) *fp; ! 644: } ! 645: ! 646: // round to selected precision ! 647: STATIC_INLINE void fp_round(fptype *fp) ! 648: { ! 649: switch(fp_rnd_prec) { ! 650: case 32: ! 651: *fp = (float) *fp; ! 652: break; ! 653: case 64: ! 654: *fp = (double) *fp; ! 655: break; ! 656: default: ! 657: break; ! 658: } ! 659: } ! 660: ! 661: ! 662: /* Arithmetic functions */ ! 663: ! 664: #ifdef USE_LONG_DOUBLE ! 665: ! 666: STATIC_INLINE void fp_move(fptype *a, fptype *b) ! 667: { ! 668: *a = *b; ! 669: fp_round(a); ! 670: } ! 671: STATIC_INLINE void fp_move_single(fptype *a, fptype *b) ! 672: { ! 673: *a = *b; ! 674: fp_round_single(a); ! 675: } ! 676: STATIC_INLINE void fp_move_double(fptype *a, fptype *b) ! 677: { ! 678: *a = *b; ! 679: fp_round_double(a); ! 680: } ! 681: STATIC_INLINE void fp_int(fptype *a, fptype *b) ! 682: { ! 683: #ifdef USE_HOST_ROUNDING ! 684: *a = rintl(*b); ! 685: #else ! 686: switch (regs.fpcr & FPCR_ROUNDING_MODE) ! 687: { ! 688: case FPCR_ROUND_NEAR: ! 689: *a = fp_round_to_nearest(*b); ! 690: break; ! 691: case FPCR_ROUND_ZERO: ! 692: *a = fp_round_to_zero(*b); ! 693: break; ! 694: case FPCR_ROUND_MINF: ! 695: *a = fp_round_to_minus_infinity(*b); ! 696: break; ! 697: case FPCR_ROUND_PINF: ! 698: *a = fp_round_to_plus_infinity(*b); ! 699: break; ! 700: default: /* never reached */ ! 701: break; ! 702: } ! 703: #endif ! 704: fp_round(a); ! 705: } ! 706: STATIC_INLINE void fp_sinh(fptype *a, fptype *b) ! 707: { ! 708: *a = sinhl(*b); ! 709: fp_round(a); ! 710: } ! 711: STATIC_INLINE void fp_intrz(fptype *a, fptype *b) ! 712: { ! 713: #ifdef USE_HOST_ROUNDING ! 714: *a = truncl(*b); ! 715: #else ! 716: *a = fp_round_to_zero (*b); ! 717: #endif ! 718: fp_round(a); ! 719: } ! 720: STATIC_INLINE void fp_sqrt(fptype *a, fptype *b) ! 721: { ! 722: *a = sqrtl(*b); ! 723: fp_round(a); ! 724: } ! 725: STATIC_INLINE void fp_sqrt_single(fptype *a, fptype *b) ! 726: { ! 727: *a = sqrtl(*b); ! 728: fp_round_single(a); ! 729: } ! 730: STATIC_INLINE void fp_sqrt_double(fptype *a, fptype *b) ! 731: { ! 732: *a = sqrtl(*b); ! 733: fp_round_double(a); ! 734: } ! 735: STATIC_INLINE void fp_lognp1(fptype *a, fptype *b) ! 736: { ! 737: *a = log1pl(*b); ! 738: fp_round(a); ! 739: } ! 740: STATIC_INLINE void fp_etoxm1(fptype *a, fptype *b) ! 741: { ! 742: *a = expm1l(*b); ! 743: fp_round(a); ! 744: } ! 745: STATIC_INLINE void fp_tanh(fptype *a, fptype *b) ! 746: { ! 747: *a = tanhl(*b); ! 748: fp_round(a); ! 749: } ! 750: STATIC_INLINE void fp_atan(fptype *a, fptype *b) ! 751: { ! 752: *a = atanl(*b); ! 753: fp_round(a); ! 754: } ! 755: STATIC_INLINE void fp_asin(fptype *a, fptype *b) ! 756: { ! 757: *a = asinl(*b); ! 758: fp_round(a); ! 759: } ! 760: STATIC_INLINE void fp_atanh(fptype *a, fptype *b) ! 761: { ! 762: *a = atanhl(*b); ! 763: fp_round(a); ! 764: } ! 765: STATIC_INLINE void fp_sin(fptype *a, fptype *b) ! 766: { ! 767: *a = sinl(*b); ! 768: fp_round(a); ! 769: } ! 770: STATIC_INLINE void fp_tan(fptype *a, fptype *b) ! 771: { ! 772: *a = tanl(*b); ! 773: fp_round(a); ! 774: } ! 775: STATIC_INLINE void fp_etox(fptype *a, fptype *b) ! 776: { ! 777: *a = expl(*b); ! 778: fp_round(a); ! 779: } ! 780: STATIC_INLINE void fp_twotox(fptype *a, fptype *b) ! 781: { ! 782: *a = powl(2.0, *b); ! 783: fp_round(a); ! 784: } ! 785: STATIC_INLINE void fp_tentox(fptype *a, fptype *b) ! 786: { ! 787: *a = powl(10.0, *b); ! 788: fp_round(a); ! 789: } ! 790: STATIC_INLINE void fp_logn(fptype *a, fptype *b) ! 791: { ! 792: *a = logl(*b); ! 793: fp_round(a); ! 794: } ! 795: STATIC_INLINE void fp_log10(fptype *a, fptype *b) ! 796: { ! 797: *a = log10l(*b); ! 798: fp_round(a); ! 799: } ! 800: STATIC_INLINE void fp_log2(fptype *a, fptype *b) ! 801: { ! 802: *a = log2l(*b); ! 803: fp_round(a); ! 804: } ! 805: STATIC_INLINE void fp_abs(fptype *a, fptype *b) ! 806: { ! 807: *a = fabsl(*b); ! 808: fp_round(a); ! 809: } ! 810: STATIC_INLINE void fp_abs_single(fptype *a, fptype *b) ! 811: { ! 812: *a = fabsl(*b); ! 813: fp_round_single(a); ! 814: } ! 815: STATIC_INLINE void fp_abs_double(fptype *a, fptype *b) ! 816: { ! 817: *a = fabsl(*b); ! 818: fp_round_double(a); ! 819: } ! 820: STATIC_INLINE void fp_cosh(fptype *a, fptype *b) ! 821: { ! 822: *a = coshl(*b); ! 823: fp_round(a); ! 824: } ! 825: STATIC_INLINE void fp_neg(fptype *a, fptype *b) ! 826: { ! 827: *a = -(*b); ! 828: fp_round(a); ! 829: } ! 830: STATIC_INLINE void fp_neg_single(fptype *a, fptype *b) ! 831: { ! 832: *a = -(*b); ! 833: fp_round_single(a); ! 834: } ! 835: STATIC_INLINE void fp_neg_double(fptype *a, fptype *b) ! 836: { ! 837: *a = -(*b); ! 838: fp_round_double(a); ! 839: } ! 840: STATIC_INLINE void fp_acos(fptype *a, fptype *b) ! 841: { ! 842: *a = acosl(*b); ! 843: fp_round(a); ! 844: } ! 845: STATIC_INLINE void fp_cos(fptype *a, fptype *b) ! 846: { ! 847: *a = cosl(*b); ! 848: fp_round(a); ! 849: } ! 850: STATIC_INLINE void fp_getexp(fptype *a, fptype *b) ! 851: { ! 852: int expon; ! 853: frexpl(*b, &expon); ! 854: *a = (long double) (expon - 1); ! 855: fp_round(a); ! 856: } ! 857: STATIC_INLINE void fp_getman(fptype *a, fptype *b) ! 858: { ! 859: int expon; ! 860: *a = frexpl(*b, &expon) * 2.0; ! 861: fp_round(a); ! 862: } ! 863: STATIC_INLINE void fp_div(fptype *a, fptype *b) ! 864: { ! 865: *a /= *b; ! 866: fp_round(a); ! 867: } ! 868: STATIC_INLINE void fp_div_single(fptype *a, fptype *b) ! 869: { ! 870: *a /= *b; ! 871: fp_round_single(a); ! 872: } ! 873: STATIC_INLINE void fp_div_double(fptype *a, fptype *b) ! 874: { ! 875: *a /= *b; ! 876: fp_round_double(a); ! 877: } ! 878: STATIC_INLINE void fp_mod(fptype *a, fptype *b, uae_u64 *q, uae_s8 *s) ! 879: { ! 880: fptype quot; ! 881: #ifdef USE_HOST_ROUNDING ! 882: quot = truncl(*a / *b); ! 883: #else ! 884: quot = fp_round_to_zero(*a / *b); ! 885: #endif ! 886: if (quot < 0.0) { ! 887: *s = 1; ! 888: quot = -quot; ! 889: } else { ! 890: *s = 0; ! 891: } ! 892: *q = (uae_u64)quot; ! 893: *a = fmodl(*a, *b); ! 894: fp_round(a); ! 895: } ! 896: STATIC_INLINE void fp_add(fptype *a, fptype *b) ! 897: { ! 898: *a += *b; ! 899: fp_round(a); ! 900: } ! 901: STATIC_INLINE void fp_add_single(fptype *a, fptype *b) ! 902: { ! 903: *a += *b; ! 904: fp_round_single(a); ! 905: } ! 906: STATIC_INLINE void fp_add_double(fptype *a, fptype *b) ! 907: { ! 908: *a += *b; ! 909: fp_round_double(a); ! 910: } ! 911: STATIC_INLINE void fp_mul(fptype *a, fptype *b) ! 912: { ! 913: *a *= *b; ! 914: fp_round(a); ! 915: } ! 916: STATIC_INLINE void fp_mul_single(fptype *a, fptype *b) ! 917: { ! 918: *a *= *b; ! 919: fp_round_single(a); ! 920: } ! 921: STATIC_INLINE void fp_mul_double(fptype *a, fptype *b) ! 922: { ! 923: *a *= *b; ! 924: fp_round_double(a); ! 925: } ! 926: STATIC_INLINE void fp_sgldiv(fptype *a, fptype *b) ! 927: { ! 928: fptype z; ! 929: float mant; ! 930: int expon; ! 931: z = *a / *b; ! 932: ! 933: mant = (float)(frexpl(z, &expon) * 2.0); ! 934: *a = ldexpl((fptype)mant, expon - 1); ! 935: } ! 936: STATIC_INLINE void fp_rem(fptype *a, fptype *b, uae_u64 *q, uae_s8 *s) ! 937: { ! 938: fptype quot; ! 939: #ifdef USE_HOST_ROUNDING ! 940: quot = roundl(*a / *b); ! 941: #else ! 942: quot = fp_round_to_nearest(*a / *b); ! 943: #endif ! 944: if (quot < 0.0) { ! 945: *s = 1; ! 946: quot = -quot; ! 947: } else { ! 948: *s = 0; ! 949: } ! 950: *q = (uae_u64)quot; ! 951: *a = remainderl(*a, *b); ! 952: fp_round(a); ! 953: } ! 954: STATIC_INLINE void fp_scale(fptype *a, fptype *b) ! 955: { ! 956: *a = ldexpl(*a, (int) *b); ! 957: fp_round(a); ! 958: } ! 959: STATIC_INLINE void fp_sglmul(fptype *a, fptype *b) ! 960: { ! 961: fptype z; ! 962: float mant; ! 963: int expon; ! 964: /* FIXME: truncate mantissa of a and b to single precision */ ! 965: z = *a * (*b); ! 966: ! 967: mant = (float)(frexpl(z, &expon) * 2.0); ! 968: *a = ldexpl((fptype)mant, expon - 1); ! 969: } ! 970: STATIC_INLINE void fp_sub(fptype *a, fptype *b) ! 971: { ! 972: *a -= *b; ! 973: fp_round(a); ! 974: } ! 975: STATIC_INLINE void fp_sub_single(fptype *a, fptype *b) ! 976: { ! 977: *a -= *b; ! 978: fp_round_single(a); ! 979: } ! 980: STATIC_INLINE void fp_sub_double(fptype *a, fptype *b) ! 981: { ! 982: *a -= *b; ! 983: fp_round_double(a); ! 984: } ! 985: STATIC_INLINE void fp_cmp(fptype *a, fptype *b) ! 986: { ! 987: *a = (*a - *b); /* FIXME: comparing is different from subtraction */ ! 988: } ! 989: STATIC_INLINE void fp_tst(fptype *a, fptype *b) ! 990: { ! 991: *a = *b; /* FIXME: test b */ ! 992: } ! 993: ! 994: #else // if !USE_LONG_DOUBLE ! 995: ! 996: STATIC_INLINE void fp_move(fptype *a, fptype *b) ! 997: { ! 998: *a = *b; ! 999: fp_round(a); ! 1000: } ! 1001: STATIC_INLINE void fp_move_single(fptype *a, fptype *b) ! 1002: { ! 1003: *a = *b; ! 1004: fp_round_single(a); ! 1005: } ! 1006: STATIC_INLINE void fp_move_double(fptype *a, fptype *b) ! 1007: { ! 1008: *a = *b; ! 1009: fp_round_double(a); ! 1010: } ! 1011: STATIC_INLINE void fp_int(fptype *a, fptype *b) ! 1012: { ! 1013: #ifdef USE_HOST_ROUNDING ! 1014: *a = rint(*b); ! 1015: #else ! 1016: switch (regs.fpcr & FPCR_ROUNDING_MODE) ! 1017: { ! 1018: case FPCR_ROUND_NEAR: ! 1019: *a = fp_round_to_nearest(*b); ! 1020: break; ! 1021: case FPCR_ROUND_ZERO: ! 1022: *a = fp_round_to_zero(*b); ! 1023: break; ! 1024: case FPCR_ROUND_MINF: ! 1025: *a = fp_round_to_minus_infinity(*b); ! 1026: break; ! 1027: case FPCR_ROUND_PINF: ! 1028: *a = fp_round_to_plus_infinity(*b); ! 1029: break; ! 1030: default: /* never reached */ ! 1031: break; ! 1032: } ! 1033: #endif ! 1034: fp_round(a); ! 1035: } ! 1036: STATIC_INLINE void fp_sinh(fptype *a, fptype *b) ! 1037: { ! 1038: *a = sinh(*b); ! 1039: fp_round(a); ! 1040: } ! 1041: STATIC_INLINE void fp_intrz(fptype *a, fptype *b) ! 1042: { ! 1043: #ifdef USE_HOST_ROUNDING ! 1044: *a = trunc(*b); ! 1045: #else ! 1046: *a = fp_round_to_zero (*b); ! 1047: #endif ! 1048: fp_round(a); ! 1049: } ! 1050: STATIC_INLINE void fp_sqrt(fptype *a, fptype *b) ! 1051: { ! 1052: *a = sqrt(*b); ! 1053: fp_round(a); ! 1054: } ! 1055: STATIC_INLINE void fp_sqrt_single(fptype *a, fptype *b) ! 1056: { ! 1057: *a = sqrt(*b); ! 1058: fp_round_single(a); ! 1059: } ! 1060: STATIC_INLINE void fp_sqrt_double(fptype *a, fptype *b) ! 1061: { ! 1062: *a = sqrt(*b); ! 1063: fp_round_double(a); ! 1064: } ! 1065: STATIC_INLINE void fp_lognp1(fptype *a, fptype *b) ! 1066: { ! 1067: *a = log1p(*b); ! 1068: fp_round(a); ! 1069: } ! 1070: STATIC_INLINE void fp_etoxm1(fptype *a, fptype *b) ! 1071: { ! 1072: *a = expm1(*b); ! 1073: fp_round(a); ! 1074: } ! 1075: STATIC_INLINE void fp_tanh(fptype *a, fptype *b) ! 1076: { ! 1077: *a = tanh(*b); ! 1078: fp_round(a); ! 1079: } ! 1080: STATIC_INLINE void fp_atan(fptype *a, fptype *b) ! 1081: { ! 1082: *a = atan(*b); ! 1083: fp_round(a); ! 1084: } ! 1085: STATIC_INLINE void fp_asin(fptype *a, fptype *b) ! 1086: { ! 1087: *a = asin(*b); ! 1088: fp_round(a); ! 1089: } ! 1090: STATIC_INLINE void fp_atanh(fptype *a, fptype *b) ! 1091: { ! 1092: *a = atanh(*b); ! 1093: fp_round(a); ! 1094: } ! 1095: STATIC_INLINE void fp_sin(fptype *a, fptype *b) ! 1096: { ! 1097: *a = sin(*b); ! 1098: fp_round(a); ! 1099: } ! 1100: STATIC_INLINE void fp_tan(fptype *a, fptype *b) ! 1101: { ! 1102: *a = tan(*b); ! 1103: fp_round(a); ! 1104: } ! 1105: STATIC_INLINE void fp_etox(fptype *a, fptype *b) ! 1106: { ! 1107: *a = exp(*b); ! 1108: fp_round(a); ! 1109: } ! 1110: STATIC_INLINE void fp_twotox(fptype *a, fptype *b) ! 1111: { ! 1112: *a = pow(2.0, *b); ! 1113: fp_round(a); ! 1114: } ! 1115: STATIC_INLINE void fp_tentox(fptype *a, fptype *b) ! 1116: { ! 1117: *a = pow(10.0, *b); ! 1118: fp_round(a); ! 1119: } ! 1120: STATIC_INLINE void fp_logn(fptype *a, fptype *b) ! 1121: { ! 1122: *a = log(*b); ! 1123: fp_round(a); ! 1124: } ! 1125: STATIC_INLINE void fp_log10(fptype *a, fptype *b) ! 1126: { ! 1127: *a = log10(*b); ! 1128: fp_round(a); ! 1129: } ! 1130: STATIC_INLINE void fp_log2(fptype *a, fptype *b) ! 1131: { ! 1132: *a = log2(*b); ! 1133: fp_round(a); ! 1134: } ! 1135: STATIC_INLINE void fp_abs(fptype *a, fptype *b) ! 1136: { ! 1137: *a = fabs(*b); ! 1138: fp_round(a); ! 1139: } ! 1140: STATIC_INLINE void fp_abs_single(fptype *a, fptype *b) ! 1141: { ! 1142: *a = fabs(*b); ! 1143: fp_round_single(a); ! 1144: } ! 1145: STATIC_INLINE void fp_abs_double(fptype *a, fptype *b) ! 1146: { ! 1147: *a = fabs(*b); ! 1148: fp_round_double(a); ! 1149: } ! 1150: STATIC_INLINE void fp_cosh(fptype *a, fptype *b) ! 1151: { ! 1152: *a = cosh(*b); ! 1153: fp_round(a); ! 1154: } ! 1155: STATIC_INLINE void fp_neg(fptype *a, fptype *b) ! 1156: { ! 1157: *a = -(*b); ! 1158: fp_round(a); ! 1159: } ! 1160: STATIC_INLINE void fp_neg_single(fptype *a, fptype *b) ! 1161: { ! 1162: *a = -(*b); ! 1163: fp_round_single(a); ! 1164: } ! 1165: STATIC_INLINE void fp_neg_double(fptype *a, fptype *b) ! 1166: { ! 1167: *a = -(*b); ! 1168: fp_round_double(a); ! 1169: } ! 1170: STATIC_INLINE void fp_acos(fptype *a, fptype *b) ! 1171: { ! 1172: *a = acos(*b); ! 1173: fp_round(a); ! 1174: } ! 1175: STATIC_INLINE void fp_cos(fptype *a, fptype *b) ! 1176: { ! 1177: *a = cos(*b); ! 1178: fp_round(a); ! 1179: } ! 1180: STATIC_INLINE void fp_getexp(fptype *a, fptype *b) ! 1181: { ! 1182: int expon; ! 1183: frexp(*b, &expon); ! 1184: *a = (long double) (expon - 1); ! 1185: fp_round(a); ! 1186: } ! 1187: STATIC_INLINE void fp_getman(fptype *a, fptype *b) ! 1188: { ! 1189: int expon; ! 1190: *a = frexp(*b, &expon) * 2.0; ! 1191: fp_round(a); ! 1192: } ! 1193: STATIC_INLINE void fp_div(fptype *a, fptype *b) ! 1194: { ! 1195: *a /= *b; ! 1196: fp_round(a); ! 1197: } ! 1198: STATIC_INLINE void fp_div_single(fptype *a, fptype *b) ! 1199: { ! 1200: *a /= *b; ! 1201: fp_round_single(a); ! 1202: } ! 1203: STATIC_INLINE void fp_div_double(fptype *a, fptype *b) ! 1204: { ! 1205: *a /= *b; ! 1206: fp_round_double(a); ! 1207: } ! 1208: STATIC_INLINE void fp_mod(fptype *a, fptype *b, uae_u64 *q, uae_s8 *s) ! 1209: { ! 1210: fptype quot; ! 1211: #ifdef USE_HOST_ROUNDING ! 1212: quot = trunc(*a / *b); ! 1213: #else ! 1214: quot = fp_round_to_zero(*a / *b); ! 1215: #endif ! 1216: if (quot < 0.0) { ! 1217: *s = 1; ! 1218: quot = -quot; ! 1219: } else { ! 1220: *s = 0; ! 1221: } ! 1222: *q = (uae_u64)quot; ! 1223: *a = fmod(*a, *b); ! 1224: fp_round(a); ! 1225: } ! 1226: STATIC_INLINE void fp_add(fptype *a, fptype *b) ! 1227: { ! 1228: *a += *b; ! 1229: fp_round(a); ! 1230: } ! 1231: STATIC_INLINE void fp_add_single(fptype *a, fptype *b) ! 1232: { ! 1233: *a += *b; ! 1234: fp_round_single(a); ! 1235: } ! 1236: STATIC_INLINE void fp_add_double(fptype *a, fptype *b) ! 1237: { ! 1238: *a += *b; ! 1239: fp_round_double(a); ! 1240: } ! 1241: STATIC_INLINE void fp_mul(fptype *a, fptype *b) ! 1242: { ! 1243: *a *= *b; ! 1244: fp_round(a); ! 1245: } ! 1246: STATIC_INLINE void fp_mul_single(fptype *a, fptype *b) ! 1247: { ! 1248: *a *= *b; ! 1249: fp_round_single(a); ! 1250: } ! 1251: STATIC_INLINE void fp_mul_double(fptype *a, fptype *b) ! 1252: { ! 1253: *a *= *b; ! 1254: fp_round_double(a); ! 1255: } ! 1256: STATIC_INLINE void fp_sgldiv(fptype *a, fptype *b) ! 1257: { ! 1258: fptype z; ! 1259: float mant; ! 1260: int expon; ! 1261: z = *a / *b; ! 1262: ! 1263: mant = (float)(frexp(z, &expon) * 2.0); ! 1264: *a = ldexp((fptype)mant, expon - 1); ! 1265: } ! 1266: STATIC_INLINE void fp_rem(fptype *a, fptype *b, uae_u64 *q, uae_s8 *s) ! 1267: { ! 1268: fptype quot; ! 1269: #ifdef USE_HOST_ROUNDING ! 1270: quot = round(*a / *b); ! 1271: #else ! 1272: quot = fp_round_to_nearest(*a / *b); ! 1273: #endif ! 1274: if (quot < 0.0) { ! 1275: *s = 1; ! 1276: quot = -quot; ! 1277: } else { ! 1278: *s = 0; ! 1279: } ! 1280: *q = (uae_u64)quot; ! 1281: *a = remainder(*a, *b); ! 1282: fp_round(a); ! 1283: } ! 1284: STATIC_INLINE void fp_scale(fptype *a, fptype *b) ! 1285: { ! 1286: *a = ldexp(*a, (int) *b); ! 1287: fp_round(a); ! 1288: } ! 1289: STATIC_INLINE void fp_sglmul(fptype *a, fptype *b) ! 1290: { ! 1291: fptype z; ! 1292: float mant; ! 1293: int expon; ! 1294: /* FIXME: truncate mantissa of a and b to single precision */ ! 1295: z = *a * (*b); ! 1296: ! 1297: mant = (float)(frexp(z, &expon) * 2.0); ! 1298: *a = ldexp((fptype)mant, expon - 1); ! 1299: } ! 1300: STATIC_INLINE void fp_sub(fptype *a, fptype *b) ! 1301: { ! 1302: *a -= *b; ! 1303: fp_round(a); ! 1304: } ! 1305: STATIC_INLINE void fp_sub_single(fptype *a, fptype *b) ! 1306: { ! 1307: *a -= *b; ! 1308: fp_round_single(a); ! 1309: } ! 1310: STATIC_INLINE void fp_sub_double(fptype *a, fptype *b) ! 1311: { ! 1312: *a -= *b; ! 1313: fp_round_double(a); ! 1314: } ! 1315: STATIC_INLINE void fp_cmp(fptype *a, fptype *b) ! 1316: { ! 1317: *a = (*a - *b); /* FIXME: comparing is different from subtraction */ ! 1318: } ! 1319: STATIC_INLINE void fp_tst(fptype *a, fptype *b) ! 1320: { ! 1321: *a = *b; /* FIXME: test b */ ! 1322: } ! 1323: ! 1324: #endif // !USE_LONG_DOUBLE ! 1325: ! 1326: #endif
This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.