00001
00002
00003
00004
00005
00006
00007
00008
00009
00010
00011
00012
00013
00014
00015
00016
00017
00018 #ifndef MAGICKCORE_QUANTUM_PRIVATE_H
00019 #define MAGICKCORE_QUANTUM_PRIVATE_H
00020
00021 #include "MagickCore/memory_.h"
00022 #include "MagickCore/cache.h"
00023 #include "MagickCore/image-private.h"
00024 #include "MagickCore/pixel-accessor.h"
00025
00026 #if defined(__cplusplus) || defined(c_plusplus)
00027 extern "C" {
00028 #endif
00029
00030 typedef struct _QuantumState
00031 {
00032 double
00033 inverse_scale;
00034
00035 unsigned int
00036 pixel;
00037
00038 size_t
00039 bits;
00040
00041 const unsigned int
00042 *mask;
00043 } QuantumState;
00044
00045 struct _QuantumInfo
00046 {
00047 size_t
00048 depth,
00049 quantum;
00050
00051 QuantumFormatType
00052 format;
00053
00054 double
00055 minimum,
00056 maximum,
00057 scale;
00058
00059 size_t
00060 pad;
00061
00062 MagickBooleanType
00063 min_is_white,
00064 pack;
00065
00066 QuantumAlphaType
00067 alpha_type;
00068
00069 size_t
00070 number_threads;
00071
00072 MemoryInfo
00073 **pixels;
00074
00075 size_t
00076 extent;
00077
00078 EndianType
00079 endian;
00080
00081 QuantumState
00082 state;
00083
00084 SemaphoreInfo
00085 *semaphore;
00086
00087 size_t
00088 signature;
00089 };
00090
00091 extern MagickPrivate void
00092 ResetQuantumState(QuantumInfo *);
00093
00094 static inline MagickSizeType GetQuantumRange(const size_t depth)
00095 {
00096 MagickSizeType
00097 one;
00098
00099 size_t
00100 max_depth;
00101
00102 if (depth == 0)
00103 return(0);
00104 one=1;
00105 max_depth=8*sizeof(MagickSizeType);
00106 return((MagickSizeType) ((one << (MagickMin(depth,max_depth)-1))+
00107 ((one << (MagickMin(depth,max_depth)-1))-1)));
00108 }
00109
00110 static inline float HalfToSinglePrecision(const unsigned short half)
00111 {
00112 #define ExponentBias (127-15)
00113 #define ExponentMask 0x7c00
00114 #define ExponentShift 23
00115 #define SignBitShift 31
00116 #define SignificandShift 13
00117 #define SignificandMask 0x00000400
00118
00119 typedef union _SinglePrecision
00120 {
00121 unsigned int
00122 fixed_point;
00123
00124 float
00125 single_precision;
00126 } SinglePrecision;
00127
00128 register unsigned int
00129 exponent,
00130 significand,
00131 sign_bit;
00132
00133 SinglePrecision
00134 map;
00135
00136 unsigned int
00137 value;
00138
00139
00140
00141
00142
00143
00144
00145
00146 sign_bit=(unsigned int) ((half >> 15) & 0x00000001);
00147 exponent=(unsigned int) ((half >> 10) & 0x0000001f);
00148 significand=(unsigned int) (half & 0x000003ff);
00149 if (exponent == 0)
00150 {
00151 if (significand == 0)
00152 value=sign_bit << SignBitShift;
00153 else
00154 {
00155 while ((significand & SignificandMask) == 0)
00156 {
00157 significand<<=1;
00158 exponent--;
00159 }
00160 exponent++;
00161 significand&=(~SignificandMask);
00162 exponent+=ExponentBias;
00163 value=(sign_bit << SignBitShift) | (exponent << ExponentShift) |
00164 (significand << SignificandShift);
00165 }
00166 }
00167 else
00168 if (exponent == SignBitShift)
00169 {
00170 value=(sign_bit << SignBitShift) | 0x7f800000;
00171 if (significand != 0)
00172 value|=(significand << SignificandShift);
00173 }
00174 else
00175 {
00176 exponent+=ExponentBias;
00177 significand<<=SignificandShift;
00178 value=(sign_bit << SignBitShift) | (exponent << ExponentShift) |
00179 significand;
00180 }
00181 map.fixed_point=value;
00182 return(map.single_precision);
00183 }
00184
00185 static inline unsigned char *PopCharPixel(const unsigned char pixel,
00186 unsigned char *pixels)
00187 {
00188 *pixels++=pixel;
00189 return(pixels);
00190 }
00191
00192 static inline unsigned char *PopLongPixel(const EndianType endian,
00193 const unsigned int pixel,unsigned char *pixels)
00194 {
00195 register unsigned int
00196 quantum;
00197
00198 quantum=(unsigned int) pixel;
00199 if (endian == LSBEndian)
00200 {
00201 *pixels++=(unsigned char) (quantum);
00202 *pixels++=(unsigned char) (quantum >> 8);
00203 *pixels++=(unsigned char) (quantum >> 16);
00204 *pixels++=(unsigned char) (quantum >> 24);
00205 return(pixels);
00206 }
00207 *pixels++=(unsigned char) (quantum >> 24);
00208 *pixels++=(unsigned char) (quantum >> 16);
00209 *pixels++=(unsigned char) (quantum >> 8);
00210 *pixels++=(unsigned char) (quantum);
00211 return(pixels);
00212 }
00213
00214 static inline unsigned char *PopShortPixel(const EndianType endian,
00215 const unsigned short pixel,unsigned char *pixels)
00216 {
00217 register unsigned int
00218 quantum;
00219
00220 quantum=pixel;
00221 if (endian == LSBEndian)
00222 {
00223 *pixels++=(unsigned char) (quantum);
00224 *pixels++=(unsigned char) (quantum >> 8);
00225 return(pixels);
00226 }
00227 *pixels++=(unsigned char) (quantum >> 8);
00228 *pixels++=(unsigned char) (quantum);
00229 return(pixels);
00230 }
00231
00232 static inline const unsigned char *PushCharPixel(const unsigned char *pixels,
00233 unsigned char *pixel)
00234 {
00235 *pixel=(*pixels++);
00236 return(pixels);
00237 }
00238
00239 static inline const unsigned char *PushLongPixel(const EndianType endian,
00240 const unsigned char *pixels,unsigned int *pixel)
00241 {
00242 register unsigned int
00243 quantum;
00244
00245 if (endian == LSBEndian)
00246 {
00247 quantum=((unsigned int) *pixels++);
00248 quantum|=((unsigned int) *pixels++ << 8);
00249 quantum|=((unsigned int) *pixels++ << 16);
00250 quantum|=((unsigned int) *pixels++ << 24);
00251 *pixel=quantum;
00252 return(pixels);
00253 }
00254 quantum=((unsigned int) *pixels++ << 24);
00255 quantum|=((unsigned int) *pixels++ << 16);
00256 quantum|=((unsigned int) *pixels++ << 8);
00257 quantum|=((unsigned int) *pixels++);
00258 *pixel=quantum;
00259 return(pixels);
00260 }
00261
00262 static inline const unsigned char *PushShortPixel(const EndianType endian,
00263 const unsigned char *pixels,unsigned short *pixel)
00264 {
00265 register unsigned int
00266 quantum;
00267
00268 if (endian == LSBEndian)
00269 {
00270 quantum=(unsigned int) *pixels++;
00271 quantum|=(unsigned int) (*pixels++ << 8);
00272 *pixel=(unsigned short) (quantum & 0xffff);
00273 return(pixels);
00274 }
00275 quantum=(unsigned int) (*pixels++ << 8);
00276 quantum|=(unsigned int) *pixels++;
00277 *pixel=(unsigned short) (quantum & 0xffff);
00278 return(pixels);
00279 }
00280
00281 static inline const unsigned char *PushFloatPixel(const EndianType endian,
00282 const unsigned char *pixels,MagickFloatType *pixel)
00283 {
00284 union
00285 {
00286 unsigned int
00287 unsigned_value;
00288
00289 MagickFloatType
00290 float_value;
00291 } quantum;
00292
00293 if (endian == LSBEndian)
00294 {
00295 quantum.unsigned_value=((unsigned int) *pixels++);
00296 quantum.unsigned_value|=((unsigned int) *pixels++ << 8);
00297 quantum.unsigned_value|=((unsigned int) *pixels++ << 16);
00298 quantum.unsigned_value|=((unsigned int) *pixels++ << 24);
00299 *pixel=quantum.float_value;
00300 return(pixels);
00301 }
00302 quantum.unsigned_value=((unsigned int) *pixels++ << 24);
00303 quantum.unsigned_value|=((unsigned int) *pixels++ << 16);
00304 quantum.unsigned_value|=((unsigned int) *pixels++ << 8);
00305 quantum.unsigned_value|=((unsigned int) *pixels++);
00306 *pixel=quantum.float_value;
00307 return(pixels);
00308 }
00309
00310 static inline Quantum ScaleAnyToQuantum(const QuantumAny quantum,
00311 const QuantumAny range)
00312 {
00313 if (quantum > range)
00314 return(QuantumRange);
00315 #if !defined(MAGICKCORE_HDRI_SUPPORT)
00316 return((Quantum) (((double) QuantumRange*quantum)*
00317 PerceptibleReciprocal((double) range)+0.5));
00318 #else
00319 return((Quantum) (((double) QuantumRange*quantum)*
00320 PerceptibleReciprocal((double) range)));
00321 #endif
00322 }
00323
00324 static inline QuantumAny ScaleQuantumToAny(const Quantum quantum,
00325 const QuantumAny range)
00326 {
00327 if (quantum < 0)
00328 return((QuantumAny) 0);
00329 return((QuantumAny) (((double) range*quantum)/QuantumRange+0.5));
00330 }
00331
00332 #if (MAGICKCORE_QUANTUM_DEPTH == 8)
00333 static inline Quantum ScaleCharToQuantum(const unsigned char value)
00334 {
00335 return((Quantum) value);
00336 }
00337
00338 static inline Quantum ScaleLongToQuantum(const unsigned int value)
00339 {
00340 #if !defined(MAGICKCORE_HDRI_SUPPORT)
00341 return((Quantum) ((value)/16843009UL));
00342 #else
00343 return((Quantum) (value/16843009.0));
00344 #endif
00345 }
00346
00347 static inline Quantum ScaleLongLongToQuantum(const MagickSizeType value)
00348 {
00349 #if !defined(MAGICKCORE_HDRI_SUPPORT)
00350 return((Quantum) (value/MagickULLConstant(72340172838076673)));
00351 #else
00352 return((Quantum) (value/72340172838076673.0));
00353 #endif
00354 }
00355
00356 static inline Quantum ScaleMapToQuantum(const MagickRealType value)
00357 {
00358 if (value <= 0.0)
00359 return((Quantum) 0);
00360 if (value >= MaxMap)
00361 return(QuantumRange);
00362 #if !defined(MAGICKCORE_HDRI_SUPPORT)
00363 return((Quantum) (value+0.5));
00364 #else
00365 return((Quantum) value);
00366 #endif
00367 }
00368
00369 static inline unsigned int ScaleQuantumToLong(const Quantum quantum)
00370 {
00371 #if !defined(MAGICKCORE_HDRI_SUPPORT)
00372 return((unsigned int) (16843009UL*quantum));
00373 #else
00374 if (quantum <= 0.0)
00375 return(0UL);
00376 if ((16843009.0*quantum) >= 4294967295.0)
00377 return(4294967295UL);
00378 return((unsigned int) (16843009.0*quantum+0.5));
00379 #endif
00380 }
00381
00382 static inline MagickSizeType ScaleQuantumToLongLong(const Quantum quantum)
00383 {
00384 #if !defined(MAGICKCORE_HDRI_SUPPORT)
00385 return((MagickSizeType) (MagickULLConstant(72340172838076673)*quantum));
00386 #else
00387 if (quantum <= 0.0)
00388 return(0UL);
00389 if ((72340172838076673.0*quantum) >= 18446744073709551615.0)
00390 return(MagickULLConstant(18446744073709551615));
00391 return((MagickSizeType) (72340172838076673*quantum+0.5));
00392 #endif
00393 }
00394
00395 static inline unsigned int ScaleQuantumToMap(const Quantum quantum)
00396 {
00397 if (quantum >= (Quantum) MaxMap)
00398 return((unsigned int) MaxMap);
00399 #if !defined(MAGICKCORE_HDRI_SUPPORT)
00400 return((unsigned int) quantum);
00401 #else
00402 if (quantum < 0.0)
00403 return(0UL);
00404 return((unsigned int) (quantum+0.5));
00405 #endif
00406 }
00407
00408 static inline unsigned short ScaleQuantumToShort(const Quantum quantum)
00409 {
00410 #if !defined(MAGICKCORE_HDRI_SUPPORT)
00411 return((unsigned short) (257UL*quantum));
00412 #else
00413 if (quantum <= 0.0)
00414 return(0);
00415 if ((257.0*quantum) >= 65535.0)
00416 return(65535);
00417 return((unsigned short) (257.0*quantum+0.5));
00418 #endif
00419 }
00420
00421 static inline Quantum ScaleShortToQuantum(const unsigned short value)
00422 {
00423 #if !defined(MAGICKCORE_HDRI_SUPPORT)
00424 return((Quantum) ((value+128U)/257U));
00425 #else
00426 return((Quantum) (value/257.0));
00427 #endif
00428 }
00429 #elif (MAGICKCORE_QUANTUM_DEPTH == 16)
00430 static inline Quantum ScaleCharToQuantum(const unsigned char value)
00431 {
00432 #if !defined(MAGICKCORE_HDRI_SUPPORT)
00433 return((Quantum) (257U*value));
00434 #else
00435 return((Quantum) (257.0*value));
00436 #endif
00437 }
00438
00439 static inline Quantum ScaleLongToQuantum(const unsigned int value)
00440 {
00441 #if !defined(MAGICKCORE_HDRI_SUPPORT)
00442 return((Quantum) ((value)/MagickULLConstant(65537)));
00443 #else
00444 return((Quantum) (value/65537.0));
00445 #endif
00446 }
00447
00448 static inline Quantum ScaleLongLongToQuantum(const MagickSizeType value)
00449 {
00450 #if !defined(MAGICKCORE_HDRI_SUPPORT)
00451 return((Quantum) ((value)/MagickULLConstant(281479271743489)));
00452 #else
00453 return((Quantum) (value/281479271743489.0));
00454 #endif
00455 }
00456
00457 static inline Quantum ScaleMapToQuantum(const MagickRealType value)
00458 {
00459 if (value <= 0.0)
00460 return((Quantum) 0);
00461 if (value >= MaxMap)
00462 return(QuantumRange);
00463 #if !defined(MAGICKCORE_HDRI_SUPPORT)
00464 return((Quantum) (value+0.5));
00465 #else
00466 return((Quantum) value);
00467 #endif
00468 }
00469
00470 static inline unsigned int ScaleQuantumToLong(const Quantum quantum)
00471 {
00472 #if !defined(MAGICKCORE_HDRI_SUPPORT)
00473 return((unsigned int) (65537UL*quantum));
00474 #else
00475 if (quantum <= 0.0)
00476 return(0UL);
00477 if ((65537.0*quantum) >= 4294967295.0)
00478 return(4294967295U);
00479 return((unsigned int) (65537.0*quantum+0.5));
00480 #endif
00481 }
00482
00483 static inline MagickSizeType ScaleQuantumToLongLong(const Quantum quantum)
00484 {
00485 #if !defined(MAGICKCORE_HDRI_SUPPORT)
00486 return((MagickSizeType) (MagickULLConstant(281479271743489)*quantum));
00487 #else
00488 if (quantum <= 0.0)
00489 return(0UL);
00490 if ((281479271743489.0*quantum) >= 18446744073709551615.0)
00491 return(MagickULLConstant(18446744073709551615));
00492 return((MagickSizeType) (281479271743489.0*quantum+0.5));
00493 #endif
00494 }
00495
00496 static inline unsigned int ScaleQuantumToMap(const Quantum quantum)
00497 {
00498 if (quantum >= (Quantum) MaxMap)
00499 return((unsigned int) MaxMap);
00500 #if !defined(MAGICKCORE_HDRI_SUPPORT)
00501 return((unsigned int) quantum);
00502 #else
00503 if (quantum < 0.0)
00504 return(0UL);
00505 return((unsigned int) (quantum+0.5));
00506 #endif
00507 }
00508
00509 static inline unsigned short ScaleQuantumToShort(const Quantum quantum)
00510 {
00511 #if !defined(MAGICKCORE_HDRI_SUPPORT)
00512 return((unsigned short) quantum);
00513 #else
00514 if (quantum <= 0.0)
00515 return(0);
00516 if (quantum >= 65535.0)
00517 return(65535);
00518 return((unsigned short) (quantum+0.5));
00519 #endif
00520 }
00521
00522 static inline Quantum ScaleShortToQuantum(const unsigned short value)
00523 {
00524 return((Quantum) value);
00525 }
00526 #elif (MAGICKCORE_QUANTUM_DEPTH == 32)
00527 static inline Quantum ScaleCharToQuantum(const unsigned char value)
00528 {
00529 #if !defined(MAGICKCORE_HDRI_SUPPORT)
00530 return((Quantum) (16843009UL*value));
00531 #else
00532 return((Quantum) (16843009.0*value));
00533 #endif
00534 }
00535
00536 static inline Quantum ScaleLongToQuantum(const unsigned int value)
00537 {
00538 return((Quantum) value);
00539 }
00540
00541 static inline Quantum ScaleLongLongToQuantum(const MagickSizeType value)
00542 {
00543 #if !defined(MAGICKCORE_HDRI_SUPPORT)
00544 return((Quantum) ((value)/MagickULLConstant(4294967297)));
00545 #else
00546 return((Quantum) (value/4294967297.0));
00547 #endif
00548 }
00549
00550 static inline Quantum ScaleMapToQuantum(const MagickRealType value)
00551 {
00552 if (value <= 0.0)
00553 return((Quantum) 0);
00554 if (value >= (Quantum) MaxMap)
00555 return(QuantumRange);
00556 #if !defined(MAGICKCORE_HDRI_SUPPORT)
00557 return((Quantum) (65537.0*value+0.5));
00558 #else
00559 return((Quantum) (65537.0*value));
00560 #endif
00561 }
00562
00563 static inline unsigned int ScaleQuantumToLong(const Quantum quantum)
00564 {
00565 #if !defined(MAGICKCORE_HDRI_SUPPORT)
00566 return((unsigned int) quantum);
00567 #else
00568 if (quantum <= 0.0)
00569 return(0);
00570 if ((quantum) >= 4294967295.0)
00571 return(4294967295);
00572 return((unsigned int) (quantum+0.5));
00573 #endif
00574 }
00575
00576 static inline MagickSizeType ScaleQuantumToLongLong(const Quantum quantum)
00577 {
00578 #if !defined(MAGICKCORE_HDRI_SUPPORT)
00579 return((MagickSizeType) (MagickULLConstant(4294967297)*quantum));
00580 #else
00581 if (quantum <= 0.0)
00582 return(0UL);
00583 if ((4294967297.0*quantum) >= 18446744073709551615.0)
00584 return(MagickULLConstant(18446744073709551615));
00585 return((MagickSizeType) (4294967297.0*quantum+0.5));
00586 #endif
00587 }
00588
00589 static inline unsigned int ScaleQuantumToMap(const Quantum quantum)
00590 {
00591 if (quantum < 0.0)
00592 return(0UL);
00593 if ((quantum/65537) >= (Quantum) MaxMap)
00594 return((unsigned int) MaxMap);
00595 #if !defined(MAGICKCORE_HDRI_SUPPORT)
00596 return((unsigned int) ((quantum+MagickULLConstant(32768))/
00597 MagickULLConstant(65537)));
00598 #else
00599 return((unsigned int) (quantum/65537.0+0.5));
00600 #endif
00601 }
00602
00603 static inline unsigned short ScaleQuantumToShort(const Quantum quantum)
00604 {
00605 #if !defined(MAGICKCORE_HDRI_SUPPORT)
00606 return((unsigned short) ((quantum+MagickULLConstant(32768))/
00607 MagickULLConstant(65537)));
00608 #else
00609 if (quantum <= 0.0)
00610 return(0);
00611 if ((quantum/65537.0) >= 65535.0)
00612 return(65535);
00613 return((unsigned short) (quantum/65537.0+0.5));
00614 #endif
00615 }
00616
00617 static inline Quantum ScaleShortToQuantum(const unsigned short value)
00618 {
00619 #if !defined(MAGICKCORE_HDRI_SUPPORT)
00620 return((Quantum) (65537UL*value));
00621 #else
00622 return((Quantum) (65537.0*value));
00623 #endif
00624 }
00625 #elif (MAGICKCORE_QUANTUM_DEPTH == 64)
00626 static inline Quantum ScaleCharToQuantum(const unsigned char value)
00627 {
00628 return((Quantum) (72340172838076673.0*value));
00629 }
00630
00631 static inline Quantum ScaleLongToQuantum(const unsigned int value)
00632 {
00633 return((Quantum) (4294967297.0*value));
00634 }
00635
00636 static inline Quantum ScaleLongLongToQuantum(const MagickSizeType value)
00637 {
00638 return((Quantum) (value));
00639 }
00640
00641 static inline Quantum ScaleMapToQuantum(const MagickRealType value)
00642 {
00643 if (value <= 0.0)
00644 return((Quantum) 0);
00645 if (value >= MaxMap)
00646 return(QuantumRange);
00647 return((Quantum) (281479271743489.0*value));
00648 }
00649
00650 static inline unsigned int ScaleQuantumToLong(const Quantum quantum)
00651 {
00652 return((unsigned int) (quantum/4294967297.0+0.5));
00653 }
00654
00655 static inline MagickSizeType ScaleQuantumToLongLong(const Quantum quantum)
00656 {
00657 #if !defined(MAGICKCORE_HDRI_SUPPORT)
00658 return((MagickSizeType) quantum);
00659 #else
00660 if (quantum <= 0.0)
00661 return(0);
00662 if (quantum >= 18446744073709551615.0)
00663 return(MagickULLConstant(18446744073709551615));
00664 return((MagickSizeType) (quantum+0.5));
00665 #endif
00666 }
00667
00668 static inline unsigned int ScaleQuantumToMap(const Quantum quantum)
00669 {
00670 if (quantum <= 0.0)
00671 return(0UL);
00672 if ((quantum/281479271743489.0) >= MaxMap)
00673 return((unsigned int) MaxMap);
00674 return((unsigned int) (quantum/281479271743489.0+0.5));
00675 }
00676
00677 static inline unsigned short ScaleQuantumToShort(const Quantum quantum)
00678 {
00679 if (quantum <= 0.0)
00680 return(0);
00681 if ((quantum/281479271743489.0) >= 65535.0)
00682 return(65535);
00683 return((unsigned short) (quantum/281479271743489.0+0.5));
00684 }
00685
00686 static inline Quantum ScaleShortToQuantum(const unsigned short value)
00687 {
00688 return((Quantum) (281479271743489.0*value));
00689 }
00690 #endif
00691
00692 static inline unsigned short SinglePrecisionToHalf(const float value)
00693 {
00694 typedef union _SinglePrecision
00695 {
00696 unsigned int
00697 fixed_point;
00698
00699 float
00700 single_precision;
00701 } SinglePrecision;
00702
00703 register int
00704 exponent;
00705
00706 register unsigned int
00707 significand,
00708 sign_bit;
00709
00710 SinglePrecision
00711 map;
00712
00713 unsigned short
00714 half;
00715
00716
00717
00718
00719
00720
00721
00722
00723 map.single_precision=value;
00724 sign_bit=(map.fixed_point >> 16) & 0x00008000;
00725 exponent=(int) ((map.fixed_point >> ExponentShift) & 0x000000ff)-ExponentBias;
00726 significand=map.fixed_point & 0x007fffff;
00727 if (exponent <= 0)
00728 {
00729 int
00730 shift;
00731
00732 if (exponent < -10)
00733 return((unsigned short) sign_bit);
00734 significand=significand | 0x00800000;
00735 shift=(int) (14-exponent);
00736 significand=(unsigned int) ((significand+((1 << (shift-1))-1)+
00737 ((significand >> shift) & 0x01)) >> shift);
00738 return((unsigned short) (sign_bit | significand));
00739 }
00740 else
00741 if (exponent == (0xff-ExponentBias))
00742 {
00743 if (significand == 0)
00744 return((unsigned short) (sign_bit | ExponentMask));
00745 else
00746 {
00747 significand>>=SignificandShift;
00748 half=(unsigned short) (sign_bit | significand |
00749 (significand == 0) | ExponentMask);
00750 return(half);
00751 }
00752 }
00753 significand=significand+((significand >> SignificandShift) & 0x01)+0x00000fff;
00754 if ((significand & 0x00800000) != 0)
00755 {
00756 significand=0;
00757 exponent++;
00758 }
00759 if (exponent > 30)
00760 {
00761 float
00762 alpha;
00763
00764 register int
00765 i;
00766
00767
00768
00769
00770 alpha=1.0e10;
00771 for (i=0; i < 10; i++)
00772 alpha*=alpha;
00773 return((unsigned short) (sign_bit | ExponentMask));
00774 }
00775 half=(unsigned short) (sign_bit | (exponent << 10) |
00776 (significand >> SignificandShift));
00777 return(half);
00778 }
00779
00780 #if defined(__cplusplus) || defined(c_plusplus)
00781 }
00782 #endif
00783
00784 #endif