开通博客赚积分
发布资源赚积分
分类

源码开发语言/平台
当前位置：首页 > 源码/资料 > 多媒体 > 流媒体/Mpeg4/MP4 > 查看源码
ieeefloat.c
资源名称：NETVIDEO.rar　[点击查看]
上传用户：sun1608
上传日期：2007-02-02
资源大小：6116k
文件大小：29k
源码类别：

流媒体/Mpeg4/MP4

开发平台：

Visual C++

ieeefloat.c：源码内容
  1. /* Copyright (C) 1988-1991 Apple Computer, Inc.
  2.  * All Rights Reserved.
  3.  *
  4.  * Warranty Information
  5.  * Even though Apple has reviewed this software, Apple makes no warranty
  6.  * or representation, either express or implied, with respect to this
  7.  * software, its quality, accuracy, merchantability, or fitness for a 
  8.  * particular purpose.  As a result, this software is provided "as is,"
  9.  * and you, its user, are assuming the entire risk as to its quality
  10.  * and accuracy.
  11.  *
  12.  * This code may be used and freely distributed as long as it includes
  13.  * this copyright notice and the warranty information.
  14.  *
  15.  * Machine-independent I/O routines for IEEE floating-point numbers.
  16.  *
  17.  * NaN's and infinities are converted to HUGE_VAL or HUGE, which
  18.  * happens to be infinity on IEEE machines.  Unfortunately, it is
  19.  * impossible to preserve NaN's in a machine-independent way.
  20.  * Infinities are, however, preserved on IEEE machines.
  21.  *
  22.  * These routines have been tested on the following machines:
  23.  * Apple Macintosh, MPW 3.1 C compiler
  24.  * Apple Macintosh, THINK C compiler
  25.  * Silicon Graphics IRIS, MIPS compiler
  26.  * Cray X/MP and Y/MP
  27.  * Digital Equipment VAX
  28.  * Sequent Balance (Multiprocesor 386)
  29.  * NeXT
  30.  *
  31.  *
  32.  * Implemented by Malcolm Slaney and Ken Turkowski.
  33.  *
  34.  * Malcolm Slaney contributions during 1988-1990 include big- and little-
  35.  * endian file I/O, conversion to and from Motorola's extended 80-bit
  36.  * floating-point format, and conversions to and from IEEE single-
  37.  * precision floating-point format.
  38.  *
  39.  * In 1991, Ken Turkowski implemented the conversions to and from
  40.  * IEEE double-precision format, added more precision to the extended
  41.  * conversions, and accommodated conversions involving +/- infinity,
  42.  * NaN's, and denormalized numbers.
  43.  *
  44.  * $Id: ieeefloat.c,v 1.2 2001/06/01 22:26:00 wmay Exp $
  45.  *
  46.  * Revision 1.3  2000/02/21 23:05:05  markt
  47.  * some 64bit DEC Alpha patches
  48.  *
  49.  * Revision 1.2  2000/02/19 13:32:30  afaber
  50.  * Fixed many warning messages when compiling with MSVC
  51.  *
  52.  * Revision 1.1.1.1  1999/11/24 08:42:58  markt
  53.  * initial checkin of LAME
  54.  * Starting with LAME 3.57beta with some modifications
  55.  *
  56.  * Revision 1.1  1993/06/11  17:45:46  malcolm
  57.  * Initial revision
  58.  *
  59.  */
  61. #include        <limits.h>
  62. #include <stdio.h>
  63. #include <math.h>
  64. #include "ieeefloat.h"
  67. /****************************************************************
  68.  * The following two routines make up for deficiencies in many
  69.  * compilers to convert properly between unsigned integers and
  70.  * floating-point.  Some compilers which have this bug are the
  71.  * THINK_C compiler for the Macintosh and the C compiler for the
  72.  * Silicon Graphics MIPS-based Iris.
  73.  ****************************************************************/
  75. #ifdef applec /* The Apple C compiler works */
  76. # define FloatToUnsigned(f) ((unsigned long)(f))
  77. # define UnsignedToFloat(u) ((defdouble)(u))
  78. #else /* applec */
  79. # define FloatToUnsigned(f) ((unsigned long)(((long)((f) - 2147483648.0)) + 2147483647L + 1))
  80. # define UnsignedToFloat(u) (((defdouble)((long)((u) - 2147483647L - 1))) + 2147483648.0)
  81. #endif /* applec */
  84. /****************************************************************
  85.  * Single precision IEEE floating-point conversion routines
  86.  ****************************************************************/
  88. #define SEXP_MAX 255
  89. #define SEXP_OFFSET 127
  90. #define SEXP_SIZE 8
  91. #define SEXP_POSITION (32-SEXP_SIZE-1)
  94. defdouble
  95. ConvertFromIeeeSingle(char* bytes)
  96. {
  97. defdouble f;
  98. long mantissa, expon;
  99. long bits;
  101. bits = ((unsigned long)(bytes[0] & 0xFF) << 24)
  102. | ((unsigned long)(bytes[1] & 0xFF) << 16)
  103. | ((unsigned long)(bytes[2] & 0xFF) << 8)
  104. |  (unsigned long)(bytes[3] & 0xFF); /* Assemble bytes into a long */
  106. if ((bits & 0x7FFFFFFF) == 0) {
  107. f = 0;
  108. }
  110. else {
  111. expon = (bits & 0x7F800000) >> SEXP_POSITION;
  112. if (expon == SEXP_MAX) { /* Infinity or NaN */
  113. f = HUGE_VAL; /* Map NaN's to infinity */
  114. }
  115. else {
  116. if (expon == 0) { /* Denormalized number */
  117. mantissa = (bits & 0x7fffff);
  118. f = ldexp((defdouble) mantissa, (int) (expon - SEXP_OFFSET - SEXP_POSITION + 1));
  119. }
  120. else { /* Normalized number */
  121. mantissa = (bits & 0x7fffff) + 0x800000; /* Insert hidden bit */
  122. f = ldexp((defdouble) mantissa, (int) (expon - SEXP_OFFSET - SEXP_POSITION));
  123. }
  124. }
  125. }
  127. if (bits & LONG_MIN)
  128. return -f;
  129. else
  130. return f;
  131. }
  134. /****************************************************************/
  137. void
  138. ConvertToIeeeSingle(defdouble num, char* bytes)
  139. {
  140. long sign;
  141. register long bits;
  143. if (num < 0) { /* Can't distinguish a negative zero */
  144. sign = LONG_MIN;
  145. num *= -1;
  146. } else {
  147. sign = 0;
  148. }
  150. if (num == 0) {
  151. bits = 0;
  152. }
  154. else {
  155. defdouble fMant;
  156. int expon;
  158. fMant = frexp(num, &expon);
  160. if ((expon > (SEXP_MAX-SEXP_OFFSET+1)) || !(fMant < 1)) {
  161. /* NaN's and infinities fail second test */
  162. bits = sign | 0x7F800000; /* +/- infinity */
  163. }
  165. else {
  166. long mantissa;
  168. if (expon < -(SEXP_OFFSET-2)) { /* Smaller than normalized */
  169. int shift = (SEXP_POSITION+1) + (SEXP_OFFSET-2) + expon;
  170. if (shift < 0) { /* Way too small: flush to zero */
  171. bits = sign;
  172. }
  173. else { /* Nonzero denormalized number */
  174. mantissa = (long)(fMant * (1L << shift));
  175. bits = sign | mantissa;
  176. }
  177. }
  179. else { /* Normalized number */
  180. mantissa = (long)floor(fMant * (1L << (SEXP_POSITION+1)));
  181. mantissa -= (1L << SEXP_POSITION); /* Hide MSB */
  182. bits = sign | ((long)((expon + SEXP_OFFSET - 1)) << SEXP_POSITION) | mantissa;
  183. }
  184. }
  185. }
  187. bytes[0] = (char)(bits >> 24); /* Copy to byte string */
  188. bytes[1] = (char)(bits >> 16);
  189. bytes[2] = (char)(bits >> 8);
  190. bytes[3] = (char)(bits);
  191. }
  194. /****************************************************************
  195.  * Double precision IEEE floating-point conversion routines
  196.  ****************************************************************/
  198. #define DEXP_MAX 2047
  199. #define DEXP_OFFSET 1023
  200. #define DEXP_SIZE 11
  201. #define DEXP_POSITION (32-DEXP_SIZE-1)
  204. defdouble
  205. ConvertFromIeeeDouble(char* bytes)
  206. {
  207. defdouble f;
  208. long mantissa, expon;
  209. unsigned long first, second;
  211. first = ((unsigned long)(bytes[0] & 0xFF) << 24)
  212. | ((unsigned long)(bytes[1] & 0xFF) << 16)
  213. | ((unsigned long)(bytes[2] & 0xFF) << 8)
  214. |  (unsigned long)(bytes[3] & 0xFF);
  215. second= ((unsigned long)(bytes[4] & 0xFF) << 24)
  216. | ((unsigned long)(bytes[5] & 0xFF) << 16)
  217. | ((unsigned long)(bytes[6] & 0xFF) << 8)
  218. |  (unsigned long)(bytes[7] & 0xFF);
  220. if (first == 0 && second == 0) {
  221. f = 0;
  222. }
  224. else {
  225. expon = (first & 0x7FF00000) >> DEXP_POSITION;
  226. if (expon == DEXP_MAX) { /* Infinity or NaN */
  227. f = HUGE_VAL; /* Map NaN's to infinity */
  228. }
  229. else {
  230. if (expon == 0) { /* Denormalized number */
  231. mantissa = (first & 0x000FFFFF);
  232. f = ldexp((defdouble) mantissa, (int) (expon - DEXP_OFFSET - DEXP_POSITION + 1));
  233. f += ldexp(UnsignedToFloat(second), (int) (expon - DEXP_OFFSET - DEXP_POSITION + 1 - 32));
  234. }
  235. else { /* Normalized number */
  236. mantissa = (first & 0x000FFFFF) + 0x00100000; /* Insert hidden bit */
  237. f = ldexp((defdouble) mantissa, (int) (expon - DEXP_OFFSET - DEXP_POSITION));
  238. f += ldexp(UnsignedToFloat(second), (int) (expon - DEXP_OFFSET - DEXP_POSITION - 32));
  239. }
  240. }
  241. }
  243. if (first & 0x80000000)
  244. return -f;
  245. else
  246. return f;
  247. }
  250. /****************************************************************/
  253. void
  254. ConvertToIeeeDouble(defdouble num, char *bytes)
  255. {
  256. long sign;
  257. long first, second;
  259. if (num < 0) { /* Can't distinguish a negative zero */
  260. sign = LONG_MIN;
  261. num *= -1;
  262. } else {
  263. sign = 0;
  264. }
  266. if (num == 0) {
  267. first = 0;
  268. second = 0;
  269. }
  271. else {
  272. defdouble fMant, fsMant;
  273. int expon;
  275. fMant = frexp(num, &expon);
  277. if ((expon > (DEXP_MAX-DEXP_OFFSET+1)) || !(fMant < 1)) {
  278. /* NaN's and infinities fail second test */
  279. first = sign | 0x7FF00000; /* +/- infinity */
  280. second = 0;
  281. }
  283. else {
  284. long mantissa;
  286. if (expon < -(DEXP_OFFSET-2)) { /* Smaller than normalized */
  287. int shift = (DEXP_POSITION+1) + (DEXP_OFFSET-2) + expon;
  288. if (shift < 0) { /* Too small for something in the MS word */
  289. first = sign;
  290. shift += 32;
  291. if (shift < 0) { /* Way too small: flush to zero */
  292. second = 0;
  293. }
  294. else { /* Pretty small demorn */
  295. second = FloatToUnsigned(floor(ldexp(fMant, shift)));
  296. }
  297. }
  298. else { /* Nonzero denormalized number */
  299. fsMant = ldexp(fMant, shift);
  300. mantissa = (long)floor(fsMant);
  301. first = sign | mantissa;
  302. second = FloatToUnsigned(floor(ldexp(fsMant - mantissa, 32)));
  303. }
  304. }
  306. else { /* Normalized number */
  307. fsMant = ldexp(fMant, DEXP_POSITION+1);
  308. mantissa = (long)floor(fsMant);
  309. mantissa -= (1L << DEXP_POSITION); /* Hide MSB */
  310. fsMant -= (1L << DEXP_POSITION);
  311. first = sign | ((long)((expon + DEXP_OFFSET - 1)) << DEXP_POSITION) | mantissa;
  312. second = FloatToUnsigned(floor(ldexp(fsMant - mantissa, 32)));
  313. }
  314. }
  315. }
  317. bytes[0] = (char)(first >> 24);
  318. bytes[1] = (char)(first >> 16);
  319. bytes[2] = (char)(first >> 8);
  320. bytes[3] = (char)(first);
  321. bytes[4] = (char)(second >> 24);
  322. bytes[5] = (char)(second >> 16);
  323. bytes[6] = (char)(second >> 8);
  324. bytes[7] = (char)(second);
  325. }
  328. /****************************************************************
  329.  * Extended precision IEEE floating-point conversion routines
  330.  ****************************************************************/
  332. defdouble
  333. ConvertFromIeeeExtended(char* bytes)
  334. {
  335. defdouble f;
  336. long expon;
  337. unsigned long hiMant, loMant;
  339. #ifdef TEST
  340. printf("ConvertFromIEEEExtended(%lx,%lx,%lx,%lx,%lx,%lx,%lx,%lx,%lx,%lxr",
  341. (long)bytes[0], (long)bytes[1], (long)bytes[2], (long)bytes[3], 
  342. (long)bytes[4], (long)bytes[5], (long)bytes[6], 
  343. (long)bytes[7], (long)bytes[8], (long)bytes[9]);
  344. #endif
  346. expon = ((bytes[0] & 0x7F) << 8) | (bytes[1] & 0xFF);
  347. hiMant = ((unsigned long)(bytes[2] & 0xFF) << 24)
  348. | ((unsigned long)(bytes[3] & 0xFF) << 16)
  349. | ((unsigned long)(bytes[4] & 0xFF) << 8)
  350. | ((unsigned long)(bytes[5] & 0xFF));
  351. loMant = ((unsigned long)(bytes[6] & 0xFF) << 24)
  352. | ((unsigned long)(bytes[7] & 0xFF) << 16)
  353. | ((unsigned long)(bytes[8] & 0xFF) << 8)
  354. | ((unsigned long)(bytes[9] & 0xFF));
  356. if (expon == 0 && hiMant == 0 && loMant == 0) {
  357. f = 0;
  358. }
  359. else {
  360. if (expon == 0x7FFF) { /* Infinity or NaN */
  361. f = HUGE_VAL;
  362. }
  363. else {
  364. expon -= 16383;
  365. f  = ldexp(UnsignedToFloat(hiMant), (int) (expon -= 31));
  366. f += ldexp(UnsignedToFloat(loMant), (int) (expon -= 32));
  367. }
  368. }
  370. if (bytes[0] & 0x80)
  371. return -f;
  372. else
  373. return f;
  374. }
  377. /****************************************************************/
  380. void
  381. ConvertToIeeeExtended(defdouble num, char *bytes)
  382. {
  383. int sign;
  384. int expon;
  385. defdouble fMant, fsMant;
  386. unsigned long hiMant, loMant;
  388. if (num < 0) {
  389. sign = 0x8000;
  390. num *= -1;
  391. } else {
  392. sign = 0;
  393. }
  395. if (num == 0) {
  396. expon = 0; hiMant = 0; loMant = 0;
  397. }
  398. else {
  399. fMant = frexp(num, &expon);
  400. if ((expon > 16384) || !(fMant < 1)) { /* Infinity or NaN */
  401. expon = sign|0x7FFF; hiMant = 0; loMant = 0; /* infinity */
  402. }
  403. else { /* Finite */
  404. expon += 16382;
  405. if (expon < 0) { /* denormalized */
  406. fMant = ldexp(fMant, expon);
  407. expon = 0;
  408. }
  409. expon |= sign;
  410. fMant = ldexp(fMant, 32);          fsMant = floor(fMant); hiMant = FloatToUnsigned(fsMant);
  411. fMant = ldexp(fMant - fsMant, 32); fsMant = floor(fMant); loMant = FloatToUnsigned(fsMant);
  412. }
  413. }
  415. bytes[0] = expon >> 8;
  416. bytes[1] = expon;
  417. bytes[2] = (char)(hiMant >> 24);
  418. bytes[3] = (char)(hiMant >> 16);
  419. bytes[4] = (char)(hiMant >> 8);
  420. bytes[5] = (char)(hiMant);
  421. bytes[6] = (char)(loMant >> 24);
  422. bytes[7] = (char)(loMant >> 16);
  423. bytes[8] = (char)(loMant >> 8);
  424. bytes[9] = (char)(loMant);
  425. }
  427. /****************************************************************
  428.  * Testing routines for the floating-point conversions.
  429.  ****************************************************************/
  431. #ifdef METROWERKS
  432. #define IEEE
  433. #endif
  434. #ifdef applec
  435. # define IEEE
  436. #endif /* applec */
  437. #ifdef THINK_C
  438. # define IEEE
  439. #endif /* THINK_C */
  440. #ifdef sgi
  441. # define IEEE
  442. #endif /* sgi */
  443. #ifdef sequent
  444. # define IEEE
  445. # define LITTLE_ENDIAN
  446. #endif /* sequent */
  447. #ifdef sun
  448. # define IEEE
  449. #endif /* sun */
  450. #ifdef NeXT
  451. # define IEEE
  452. #endif /* NeXT */
  454. #ifdef MAIN
  456. union SParts {
  457. Single s;
  458. long i;
  459. };
  460. union DParts {
  461. Double d;
  462. long i[2];
  463. };
  464. union EParts {
  465. defdouble e;
  466. short i[6];
  467. };
  470. int
  471. GetHexValue(register int x)
  472. {
  473. x &= 0x7F;
  475. if ('0' <= x && x <= '9')
  476. x -= '0';
  477. else if ('a' <= x && x <= 'f')
  478. x = x - 'a' + 0xA;
  479. else if ('A' <= x && x <= 'F')
  480. x = x - 'A' + 0xA;
  481. else
  482. x = 0;
  484. return(x);
  485. }
  488. void
  489. Hex2Bytes(register char *hex, register char *bytes)
  490. {
  491. for ( ; *hex; hex += 2) {
  492. *bytes++ = (GetHexValue(hex[0]) << 4) | GetHexValue(hex[1]);
  493. if (hex[1] == 0)
  494. break; /* Guard against odd bytes */
  495. }
  496. }
  499. int
  500. GetHexSymbol(register int x)
  501. {
  502. x &= 0xF;
  503. if (x <= 9)
  504. x += '0';
  505. else
  506. x += 'A' - 0xA;
  507. return(x);
  508. }
  511. void
  512. Bytes2Hex(register char *bytes, register char *hex, register int nBytes)
  513. {
  514. for ( ; nBytes--; bytes++) {
  515. *hex++ = GetHexSymbol(*bytes >> 4);
  516. *hex++ = GetHexSymbol(*bytes);
  517. }
  518. *hex = 0;
  519. }
  522. void
  523. MaybeSwapBytes(char* bytes, int nBytes)
  524. {
  525. #ifdef LITTLE_ENDIAN
  526. register char *p, *q, t;
  527. for (p = bytes, q = bytes+nBytes-1; p < q; p++, q--) {
  528. t = *p;
  529. *p = *q;
  530. *q = t;
  531. }
  532. #else
  533. if (bytes, nBytes); /* Just so it's used */
  534. #endif /* LITTLE_ENDIAN */
  536. }
  539. float
  540. MachineIEEESingle(char* bytes)
  541. {
  542. float t;
  543. MaybeSwapBytes(bytes, 4);
  544. t = *((float*)(bytes));
  545. MaybeSwapBytes(bytes, 4);
  546. return (t);
  547. }
  550. Double
  551. MachineIEEEDouble(char* bytes)
  552. {
  553. Double t;
  554. MaybeSwapBytes(bytes, 8);
  555. t = *((Double*)(bytes));
  556. MaybeSwapBytes(bytes, 8);
  557. return (t);
  558. }
  561. void
  562. TestFromIeeeSingle(char *hex)
  563. {
  564. defdouble f;
  565. union SParts p;
  566. char bytes[4];
  568. Hex2Bytes(hex, bytes);
  569. f = ConvertFromIeeeSingle(bytes);
  570. p.s = f;
  572. #ifdef IEEE
  573. fprintf(stderr, "IEEE(%g) [%s] --> float(%g) [%08lX]n",
  574. MachineIEEESingle(bytes),
  575. hex, f, p.i);
  576. #else /* IEEE */
  577. fprintf(stderr, "IEEE[%s] --> float(%g) [%08lX]n", hex, f, p.i);
  578. #endif /* IEEE */
  579. }
  582. void
  583. TestToIeeeSingle(defdouble f)
  584. {
  585. union SParts p;
  586. char bytes[4];
  587. char hex[8+1];
  589. p.s = f;
  591. ConvertToIeeeSingle(f, bytes);
  592. Bytes2Hex(bytes, hex, 4);
  593. #ifdef IEEE
  594. fprintf(stderr, "float(%g) [%08lX] --> IEEE(%g) [%s]n",
  595. f, p.i,
  596. MachineIEEESingle(bytes),
  597. hex
  598. );
  599. #else /* IEEE */
  600. fprintf(stderr, "float(%g) [%08lX] --> IEEE[%s]n", f, p.i, hex);
  601. #endif /* IEEE */
  602. }
  605. void
  606. TestFromIeeeDouble(char *hex)
  607. {
  608. defdouble f;
  609. union DParts p;
  610. char bytes[8];
  612. Hex2Bytes(hex, bytes);
  613. f = ConvertFromIeeeDouble(bytes);
  614. p.d = f;
  616. #ifdef IEEE
  617. fprintf(stderr, "IEEE(%g) [%.8s %.8s] --> double(%g) [%08lX %08lX]n",
  618. MachineIEEEDouble(bytes),
  619. hex, hex+8, f, p.i[0], p.i[1]);
  620. #else /* IEEE */
  621. fprintf(stderr, "IEEE[%.8s %.8s] --> double(%g) [%08lX %08lX]n",
  622. hex, hex+8, f, p.i[0], p.i[1]);
  623. #endif /* IEEE */
  625. }
  627. void
  628. TestToIeeeDouble(defdouble f)
  629. {
  630. union DParts p;
  631. char bytes[8];
  632. char hex[16+1];
  634. p.d = f;
  636. ConvertToIeeeDouble(f, bytes);
  637. Bytes2Hex(bytes, hex, 8);
  638. #ifdef IEEE
  639. fprintf(stderr, "double(%g) [%08lX %08lX] --> IEEE(%g) [%.8s %.8s]n",
  640. f, p.i[0], p.i[1],
  641. MachineIEEEDouble(bytes),
  642. hex, hex+8
  643. );
  644. #else /* IEEE */
  645. fprintf(stderr, "double(%g) [%08lX %08lX] --> IEEE[%.8s %.8s]n",
  646. f, p.i[0], p.i[1], hex, hex+8
  647. );
  648. #endif /* IEEE */
  650. }
  653. void
  654. TestFromIeeeExtended(char *hex)
  655. {
  656. defdouble f;
  657. union EParts p;
  658. char bytes[12];
  660. Hex2Bytes(hex, bytes);
  661. f = ConvertFromIeeeExtended(bytes);
  662. p.e = f;
  664. bytes[11] = bytes[9];
  665. bytes[10] = bytes[8];
  666. bytes[9] = bytes[7];
  667. bytes[8] = bytes[6];
  668. bytes[7] = bytes[5];
  669. bytes[6] = bytes[4];
  670. bytes[5] = bytes[3];
  671. bytes[4] = bytes[2];
  672. bytes[3] = 0;
  673. bytes[2] = 0;
  675. #if defined(applec) || defined(THINK_C) || defined(METROWERKS)
  676. fprintf(stderr, "IEEE(%g) [%.4s %.8s %.8s] --> extended(%g) [%04X %04X%04X %04X%04X]n",
  677. *((defdouble*)(bytes)),
  678. hex, hex+4, hex+12, f,
  679. p.i[0]&0xFFFF, p.i[2]&0xFFFF, p.i[3]&0xFFFF, p.i[4]&0xFFFF, p.i[5]&0xFFFF
  680. );
  681. #else /* !Macintosh */
  682. fprintf(stderr, "IEEE[%.4s %.8s %.8s] --> extended(%g) [%04X %04X%04X %04X%04X]n",
  683. hex, hex+4, hex+12, f,
  684. p.i[0]&0xFFFF, p.i[2]&0xFFFF, p.i[3]&0xFFFF, p.i[4]&0xFFFF, p.i[5]&0xFFFF
  685. );
  686. #endif /* Macintosh */
  687. }
  690. void
  691. TestToIeeeExtended(defdouble f)
  692. {
  693. char bytes[12];
  694. char hex[24+1];
  696. ConvertToIeeeExtended(f, bytes);
  697. Bytes2Hex(bytes, hex, 10);
  699. bytes[11] = bytes[9];
  700. bytes[10] = bytes[8];
  701. bytes[9] = bytes[7];
  702. bytes[8] = bytes[6];
  703. bytes[7] = bytes[5];
  704. bytes[6] = bytes[4];
  705. bytes[5] = bytes[3];
  706. bytes[4] = bytes[2];
  707. bytes[3] = 0;
  708. bytes[2] = 0;
  710. #if defined(applec) || defined(THINK_C) || defined(METROWERKS)
  711. fprintf(stderr, "extended(%g) --> IEEE(%g) [%.4s %.8s %.8s]n",
  712. f, *((defdouble*)(bytes)),
  713. hex, hex+4, hex+12
  714. );
  715. #else /* !Macintosh */
  716. fprintf(stderr, "extended(%g) --> IEEE[%.4s %.8s %.8s]n",
  717. f,
  718. hex, hex+4, hex+12
  719. );
  720. #endif /* Macintosh */
  721. }
  723. #include <signal.h>
  725. void SignalFPE(int i, void (*j)())
  726. {
  727. printf("[Floating Point Interrupt Caught.]n", i, j);
  728. signal(SIGFPE, SignalFPE);
  729. }
  731. void
  732. main(void)
  733. {
  734. long d[3];
  735. char bytes[12];
  737. signal(SIGFPE, SignalFPE);
  739. TestFromIeeeSingle("00000000");
  740. TestFromIeeeSingle("80000000");
  741. TestFromIeeeSingle("3F800000");
  742. TestFromIeeeSingle("BF800000");
  743. TestFromIeeeSingle("40000000");
  744. TestFromIeeeSingle("C0000000");
  745. TestFromIeeeSingle("7F800000");
  746. TestFromIeeeSingle("FF800000");
  747. TestFromIeeeSingle("00800000");
  748. TestFromIeeeSingle("00400000");
  749. TestFromIeeeSingle("00000001");
  750. TestFromIeeeSingle("80000001");
  751. TestFromIeeeSingle("3F8FEDCB");
  752. TestFromIeeeSingle("7FC00100"); /* Quiet NaN(1) */
  753. TestFromIeeeSingle("7F800100"); /* Signalling NaN(1) */
  755. TestToIeeeSingle(0.0);
  756. TestToIeeeSingle(-0.0);
  757. TestToIeeeSingle(1.0);
  758. TestToIeeeSingle(-1.0);
  759. TestToIeeeSingle(2.0);
  760. TestToIeeeSingle(-2.0);
  761. TestToIeeeSingle(3.0);
  762. TestToIeeeSingle(-3.0);
  763. #if !(defined(sgi) || defined(NeXT))
  764. TestToIeeeSingle(HUGE_VAL);
  765. TestToIeeeSingle(-HUGE_VAL);
  766. #endif
  768. #ifdef IEEE
  769. /* These only work on big-endian IEEE machines */
  770. d[0] = 0x00800000L; MaybeSwapBytes(d,4); TestToIeeeSingle(*((float*)(&d[0]))); /* Smallest normalized */
  771. d[0] = 0x00400000L; MaybeSwapBytes(d,4); TestToIeeeSingle(*((float*)(&d[0]))); /* Almost largest denormalized */
  772. d[0] = 0x00000001L; MaybeSwapBytes(d,4); TestToIeeeSingle(*((float*)(&d[0]))); /* Smallest denormalized */
  773. d[0] = 0x00000001L; MaybeSwapBytes(d,4); TestToIeeeSingle(*((float*)(&d[0])) * 0.5); /* Smaller than smallest denorm */
  774. d[0] = 0x3F8FEDCBL; MaybeSwapBytes(d,4); TestToIeeeSingle(*((float*)(&d[0])));
  775. #if !(defined(sgi) || defined(NeXT))
  776. d[0] = 0x7FC00100L; MaybeSwapBytes(d,4); TestToIeeeSingle(*((float*)(&d[0]))); /* Quiet NaN(1) */
  777. d[0] = 0x7F800100L; MaybeSwapBytes(d,4); TestToIeeeSingle(*((float*)(&d[0]))); /* Signalling NaN(1) */
  778. #endif /* sgi */
  779. #endif /* IEEE */
  783. TestFromIeeeDouble("0000000000000000");
  784. TestFromIeeeDouble("8000000000000000");
  785. TestFromIeeeDouble("3FF0000000000000");
  786. TestFromIeeeDouble("BFF0000000000000");
  787. TestFromIeeeDouble("4000000000000000");
  788. TestFromIeeeDouble("C000000000000000");
  789. TestFromIeeeDouble("7FF0000000000000");
  790. TestFromIeeeDouble("FFF0000000000000");
  791. TestFromIeeeDouble("0010000000000000");
  792. TestFromIeeeDouble("0008000000000000");
  793. TestFromIeeeDouble("0000000000000001");
  794. TestFromIeeeDouble("8000000000000001");
  795. TestFromIeeeDouble("3FFFEDCBA9876543");
  796. TestFromIeeeDouble("7FF8002000000000"); /* Quiet NaN(1) */
  797. TestFromIeeeDouble("7FF0002000000000"); /* Signalling NaN(1) */
  799. TestToIeeeDouble(0.0);
  800. TestToIeeeDouble(-0.0);
  801. TestToIeeeDouble(1.0);
  802. TestToIeeeDouble(-1.0);
  803. TestToIeeeDouble(2.0);
  804. TestToIeeeDouble(-2.0);
  805. TestToIeeeDouble(3.0);
  806. TestToIeeeDouble(-3.0);
  807. #if !(defined(sgi) || defined(NeXT))
  808. TestToIeeeDouble(HUGE_VAL);
  809. TestToIeeeDouble(-HUGE_VAL);
  810. #endif
  812. #ifdef IEEE
  813. /* These only work on big-endian IEEE machines */
  814. Hex2Bytes("0010000000000000", bytes); MaybeSwapBytes(d,8); TestToIeeeDouble(*((Double*)(bytes))); /* Smallest normalized */
  815. Hex2Bytes("0010000080000000", bytes); MaybeSwapBytes(d,8); TestToIeeeDouble(*((Double*)(bytes))); /* Normalized, problem with unsigned */
  816. Hex2Bytes("0008000000000000", bytes); MaybeSwapBytes(d,8); TestToIeeeDouble(*((Double*)(bytes))); /* Almost largest denormalized */
  817. Hex2Bytes("0000000080000000", bytes); MaybeSwapBytes(d,8); TestToIeeeDouble(*((Double*)(bytes))); /* Denorm problem with unsigned */
  818. Hex2Bytes("0000000000000001", bytes); MaybeSwapBytes(d,8); TestToIeeeDouble(*((Double*)(bytes))); /* Smallest denormalized */
  819. Hex2Bytes("0000000000000001", bytes); MaybeSwapBytes(d,8); TestToIeeeDouble(*((Double*)(bytes)) * 0.5); /* Smaller than smallest denorm */
  820. Hex2Bytes("3FFFEDCBA9876543", bytes); MaybeSwapBytes(d,8); TestToIeeeDouble(*((Double*)(bytes))); /* accuracy test */
  821. #if !(defined(sgi) || defined(NeXT))
  822. Hex2Bytes("7FF8002000000000", bytes); MaybeSwapBytes(d,8); TestToIeeeDouble(*((Double*)(bytes))); /* Quiet NaN(1) */
  823. Hex2Bytes("7FF0002000000000", bytes); MaybeSwapBytes(d,8); TestToIeeeDouble(*((Double*)(bytes))); /* Signalling NaN(1) */
  824. #endif /* sgi */
  825. #endif /* IEEE */
  827. TestFromIeeeExtended("00000000000000000000"); /* +0 */
  828. TestFromIeeeExtended("80000000000000000000"); /* -0 */
  829. TestFromIeeeExtended("3FFF8000000000000000"); /* +1 */
  830. TestFromIeeeExtended("BFFF8000000000000000"); /* -1 */
  831. TestFromIeeeExtended("40008000000000000000"); /* +2 */
  832. TestFromIeeeExtended("C0008000000000000000"); /* -2 */
  833. TestFromIeeeExtended("7FFF0000000000000000"); /* +infinity */
  834. TestFromIeeeExtended("FFFF0000000000000000"); /* -infinity */
  835. TestFromIeeeExtended("7FFF8001000000000000"); /* Quiet NaN(1) */
  836. TestFromIeeeExtended("7FFF0001000000000000"); /* Signalling NaN(1) */
  837. TestFromIeeeExtended("3FFFFEDCBA9876543210"); /* accuracy test */
  839. TestToIeeeExtended(0.0);
  840. TestToIeeeExtended(-0.0);
  841. TestToIeeeExtended(1.0);
  842. TestToIeeeExtended(-1.0);
  843. TestToIeeeExtended(2.0);
  844. TestToIeeeExtended(-2.0);
  845. #if !(defined(sgi) || defined(NeXT))
  846. TestToIeeeExtended(HUGE_VAL);
  847. TestToIeeeExtended(-HUGE_VAL);
  848. #endif /* sgi */
  850. #if defined(applec) || defined(THINK_C) || defined(METROWERKS)
  851. Hex2Bytes("7FFF00008001000000000000", bytes); TestToIeeeExtended(*((long double*)(bytes))); /* Quiet NaN(1) */
  852. Hex2Bytes("7FFF00000001000000000000", bytes); TestToIeeeExtended(*((long double*)(bytes))); /* Signalling NaN(1) */
  853. Hex2Bytes("7FFE00008000000000000000", bytes); TestToIeeeExtended(*((long double*)(bytes)));
  854. Hex2Bytes("000000008000000000000000", bytes); TestToIeeeExtended(*((long double*)(bytes)));
  855. Hex2Bytes("000000000000000000000001", bytes); TestToIeeeExtended(*((long double*)(bytes)));
  856. Hex2Bytes("3FFF0000FEDCBA9876543210", bytes); TestToIeeeExtended(*((long double*)(bytes)));
  857. #endif
  858. }
  861. /* This is the output of the test program on an IEEE machine:
  862. IEEE(0) [00000000] --> float(0) [00000000]
  863. IEEE(-0) [80000000] --> float(-0) [80000000]
  864. IEEE(1) [3F800000] --> float(1) [3F800000]
  865. IEEE(-1) [BF800000] --> float(-1) [BF800000]
  866. IEEE(2) [40000000] --> float(2) [40000000]
  867. IEEE(-2) [C0000000] --> float(-2) [C0000000]
  868. IEEE(INF) [7F800000] --> float(INF) [7F800000]
  869. IEEE(-INF) [FF800000] --> float(-INF) [FF800000]
  870. IEEE(1.17549e-38) [00800000] --> float(1.17549e-38) [00800000]
  871. IEEE(5.87747e-39) [00400000] --> float(5.87747e-39) [00400000]
  872. IEEE(1.4013e-45) [00000001] --> float(1.4013e-45) [00000001]
  873. IEEE(-1.4013e-45) [80000001] --> float(-1.4013e-45) [80000001]
  874. IEEE(1.12444) [3F8FEDCB] --> float(1.12444) [3F8FEDCB]
  875. IEEE(NAN(001)) [7FC00100] --> float(INF) [7F800000]
  876. IEEE(NAN(001)) [7F800100] --> float(INF) [7F800000]
  877. float(0) [00000000] --> IEEE(0) [00000000]
  878. float(-0) [80000000] --> IEEE(0) [00000000]
  879. float(1) [3F800000] --> IEEE(1) [3F800000]
  880. float(-1) [BF800000] --> IEEE(-1) [BF800000]
  881. float(2) [40000000] --> IEEE(2) [40000000]
  882. float(-2) [C0000000] --> IEEE(-2) [C0000000]
  883. float(3) [40400000] --> IEEE(3) [40400000]
  884. float(-3) [C0400000] --> IEEE(-3) [C0400000]
  885. float(INF) [7F800000] --> IEEE(INF) [7F800000]
  886. float(-INF) [FF800000] --> IEEE(-INF) [FF800000]
  887. float(1.17549e-38) [00800000] --> IEEE(1.17549e-38) [00800000]
  888. float(5.87747e-39) [00400000] --> IEEE(5.87747e-39) [00400000]
  889. float(1.4013e-45) [00000001] --> IEEE(1.4013e-45) [00000001]
  890. float(7.00649e-46) [00000000] --> IEEE(0) [00000000]
  891. float(1.12444) [3F8FEDCB] --> IEEE(1.12444) [3F8FEDCB]
  892. float(NAN(001)) [7FC00100] --> IEEE(INF) [7F800000]
  893. float(NAN(001)) [7FC00100] --> IEEE(INF) [7F800000]
  894. IEEE(0) [00000000 00000000] --> double(0) [00000000 00000000]
  895. IEEE(-0) [80000000 00000000] --> double(-0) [80000000 00000000]
  896. IEEE(1) [3FF00000 00000000] --> double(1) [3FF00000 00000000]
  897. IEEE(-1) [BFF00000 00000000] --> double(-1) [BFF00000 00000000]
  898. IEEE(2) [40000000 00000000] --> double(2) [40000000 00000000]
  899. IEEE(-2) [C0000000 00000000] --> double(-2) [C0000000 00000000]
  900. IEEE(INF) [7FF00000 00000000] --> double(INF) [7FF00000 00000000]
  901. IEEE(-INF) [FFF00000 00000000] --> double(-INF) [FFF00000 00000000]
  902. IEEE(2.22507e-308) [00100000 00000000] --> double(2.22507e-308) [00100000 00000000]
  903. IEEE(1.11254e-308) [00080000 00000000] --> double(1.11254e-308) [00080000 00000000]
  904. IEEE(4.94066e-324) [00000000 00000001] --> double(4.94066e-324) [00000000 00000001]
  905. IEEE(-4.94066e-324) [80000000 00000001] --> double(-4.94066e-324) [80000000 00000001]
  906. IEEE(1.99556) [3FFFEDCB A9876543] --> double(1.99556) [3FFFEDCB A9876543]
  907. IEEE(NAN(001)) [7FF80020 00000000] --> double(INF) [7FF00000 00000000]
  908. IEEE(NAN(001)) [7FF00020 00000000] --> double(INF) [7FF00000 00000000]
  909. double(0) [00000000 00000000] --> IEEE(0) [00000000 00000000]
  910. double(-0) [80000000 00000000] --> IEEE(0) [00000000 00000000]
  911. double(1) [3FF00000 00000000] --> IEEE(1) [3FF00000 00000000]
  912. double(-1) [BFF00000 00000000] --> IEEE(-1) [BFF00000 00000000]
  913. double(2) [40000000 00000000] --> IEEE(2) [40000000 00000000]
  914. double(-2) [C0000000 00000000] --> IEEE(-2) [C0000000 00000000]
  915. double(3) [40080000 00000000] --> IEEE(3) [40080000 00000000]
  916. double(-3) [C0080000 00000000] --> IEEE(-3) [C0080000 00000000]
  917. double(INF) [7FF00000 00000000] --> IEEE(INF) [7FF00000 00000000]
  918. double(-INF) [FFF00000 00000000] --> IEEE(-INF) [FFF00000 00000000]
  919. double(2.22507e-308) [00100000 00000000] --> IEEE(2.22507e-308) [00100000 00000000]
  920. double(2.22507e-308) [00100000 80000000] --> IEEE(2.22507e-308) [00100000 80000000]
  921. double(1.11254e-308) [00080000 00000000] --> IEEE(1.11254e-308) [00080000 00000000]
  922. double(1.061e-314) [00000000 80000000] --> IEEE(1.061e-314) [00000000 80000000]
  923. double(4.94066e-324) [00000000 00000001] --> IEEE(4.94066e-324) [00000000 00000001]
  924. double(4.94066e-324) [00000000 00000001] --> IEEE(4.94066e-324) [00000000 00000001]
  925. double(1.99556) [3FFFEDCB A9876543] --> IEEE(1.99556) [3FFFEDCB A9876543]
  926. double(NAN(001)) [7FF80020 00000000] --> IEEE(INF) [7FF00000 00000000]
  927. double(NAN(001)) [7FF80020 00000000] --> IEEE(INF) [7FF00000 00000000]
  928. IEEE(0) [0000 00000000 00000000] --> extended(0) [0000 00000000 00000000]
  929. IEEE(-0) [8000 00000000 00000000] --> extended(-0) [8000 00000000 00000000]
  930. IEEE(1) [3FFF 80000000 00000000] --> extended(1) [3FFF 80000000 00000000]
  931. IEEE(-1) [BFFF 80000000 00000000] --> extended(-1) [BFFF 80000000 00000000]
  932. IEEE(2) [4000 80000000 00000000] --> extended(2) [4000 80000000 00000000]
  933. IEEE(-2) [C000 80000000 00000000] --> extended(-2) [C000 80000000 00000000]
  934. IEEE(INF) [7FFF 00000000 00000000] --> extended(INF) [7FFF 00000000 00000000]
  935. IEEE(-INF) [FFFF 00000000 00000000] --> extended(-INF) [FFFF 00000000 00000000]
  936. IEEE(NAN(001)) [7FFF 80010000 00000000] --> extended(INF) [7FFF 00000000 00000000]
  937. IEEE(NAN(001)) [7FFF 00010000 00000000] --> extended(INF) [7FFF 00000000 00000000]
  938. IEEE(1.99111) [3FFF FEDCBA98 76543210] --> extended(1.99111) [3FFF FEDCBA98 76543210]
  939. extended(0) --> IEEE(0) [0000 00000000 00000000]
  940. extended(-0) --> IEEE(0) [0000 00000000 00000000]
  941. extended(1) --> IEEE(1) [3FFF 80000000 00000000]
  942. extended(-1) --> IEEE(-1) [BFFF 80000000 00000000]
  943. extended(2) --> IEEE(2) [4000 80000000 00000000]
  944. extended(-2) --> IEEE(-2) [C000 80000000 00000000]
  945. extended(INF) --> IEEE(INF) [7FFF 00000000 00000000]
  946. extended(-INF) --> IEEE(-INF) [FFFF 00000000 00000000]
  947. extended(NAN(001)) --> IEEE(INF) [7FFF 00000000 00000000]
  948. extended(NAN(001)) --> IEEE(INF) [7FFF 00000000 00000000]
  949. extended(5.94866e+4931) --> IEEE(5.94866e+4931) [7FFE 80000000 00000000]
  950. extended(1e-4927) --> IEEE(1e-4927) [0000 80000000 00000000]
  951. extended(1e-4927) --> IEEE(1e-4927) [0000 00000000 00000001]
  952. extended(1.99111) --> IEEE(1.99111) [3FFF FEDCBA98 76543210]
  953. */
  954.  
  955. #endif /* TEST_FP */