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 return((QuantumAny) (((double) range*quantum)/QuantumRange+0.5));
00328 }
00329
00330 #if (MAGICKCORE_QUANTUM_DEPTH == 8)
00331 static inline Quantum ScaleCharToQuantum(const unsigned char value)
00332 {
00333 return((Quantum) value);
00334 }
00335
00336 static inline Quantum ScaleLongToQuantum(const unsigned int value)
00337 {
00338 #if !defined(MAGICKCORE_HDRI_SUPPORT)
00339 return((Quantum) ((value)/16843009UL));
00340 #else
00341 return((Quantum) (value/16843009.0));
00342 #endif
00343 }
00344
00345 static inline Quantum ScaleLongLongToQuantum(const MagickSizeType value)
00346 {
00347 #if !defined(MAGICKCORE_HDRI_SUPPORT)
00348 return((Quantum) (value/MagickULLConstant(72340172838076673)));
00349 #else
00350 return((Quantum) (value/72340172838076673.0));
00351 #endif
00352 }
00353
00354 static inline Quantum ScaleMapToQuantum(const MagickRealType value)
00355 {
00356 if (value <= 0.0)
00357 return((Quantum) 0);
00358 if (value >= MaxMap)
00359 return(QuantumRange);
00360 #if !defined(MAGICKCORE_HDRI_SUPPORT)
00361 return((Quantum) (value+0.5));
00362 #else
00363 return((Quantum) value);
00364 #endif
00365 }
00366
00367 static inline unsigned int ScaleQuantumToLong(const Quantum quantum)
00368 {
00369 #if !defined(MAGICKCORE_HDRI_SUPPORT)
00370 return((unsigned int) (16843009UL*quantum));
00371 #else
00372 if (quantum <= 0.0)
00373 return(0UL);
00374 if ((16843009.0*quantum) >= 4294967295.0)
00375 return(4294967295UL);
00376 return((unsigned int) (16843009.0*quantum+0.5));
00377 #endif
00378 }
00379
00380 static inline MagickSizeType ScaleQuantumToLongLong(const Quantum quantum)
00381 {
00382 #if !defined(MAGICKCORE_HDRI_SUPPORT)
00383 return((MagickSizeType) (MagickULLConstant(72340172838076673)*quantum));
00384 #else
00385 if (quantum <= 0.0)
00386 return(0UL);
00387 if ((72340172838076673.0*quantum) >= 18446744073709551615.0)
00388 return(MagickULLConstant(18446744073709551615));
00389 return((MagickSizeType) (72340172838076673*quantum+0.5));
00390 #endif
00391 }
00392
00393 static inline unsigned int ScaleQuantumToMap(const Quantum quantum)
00394 {
00395 if (quantum >= (Quantum) MaxMap)
00396 return((unsigned int) MaxMap);
00397 #if !defined(MAGICKCORE_HDRI_SUPPORT)
00398 return((unsigned int) quantum);
00399 #else
00400 if (quantum < 0.0)
00401 return(0UL);
00402 return((unsigned int) (quantum+0.5));
00403 #endif
00404 }
00405
00406 static inline unsigned short ScaleQuantumToShort(const Quantum quantum)
00407 {
00408 #if !defined(MAGICKCORE_HDRI_SUPPORT)
00409 return((unsigned short) (257UL*quantum));
00410 #else
00411 if (quantum <= 0.0)
00412 return(0);
00413 if ((257.0*quantum) >= 65535.0)
00414 return(65535);
00415 return((unsigned short) (257.0*quantum+0.5));
00416 #endif
00417 }
00418
00419 static inline Quantum ScaleShortToQuantum(const unsigned short value)
00420 {
00421 #if !defined(MAGICKCORE_HDRI_SUPPORT)
00422 return((Quantum) ((value+128U)/257U));
00423 #else
00424 return((Quantum) (value/257.0));
00425 #endif
00426 }
00427 #elif (MAGICKCORE_QUANTUM_DEPTH == 16)
00428 static inline Quantum ScaleCharToQuantum(const unsigned char value)
00429 {
00430 #if !defined(MAGICKCORE_HDRI_SUPPORT)
00431 return((Quantum) (257U*value));
00432 #else
00433 return((Quantum) (257.0*value));
00434 #endif
00435 }
00436
00437 static inline Quantum ScaleLongToQuantum(const unsigned int value)
00438 {
00439 #if !defined(MAGICKCORE_HDRI_SUPPORT)
00440 return((Quantum) ((value)/MagickULLConstant(65537)));
00441 #else
00442 return((Quantum) (value/65537.0));
00443 #endif
00444 }
00445
00446 static inline Quantum ScaleLongLongToQuantum(const MagickSizeType value)
00447 {
00448 #if !defined(MAGICKCORE_HDRI_SUPPORT)
00449 return((Quantum) ((value)/MagickULLConstant(281479271743489)));
00450 #else
00451 return((Quantum) (value/281479271743489.0));
00452 #endif
00453 }
00454
00455 static inline Quantum ScaleMapToQuantum(const MagickRealType value)
00456 {
00457 if (value <= 0.0)
00458 return((Quantum) 0);
00459 if (value >= MaxMap)
00460 return(QuantumRange);
00461 #if !defined(MAGICKCORE_HDRI_SUPPORT)
00462 return((Quantum) (value+0.5));
00463 #else
00464 return((Quantum) value);
00465 #endif
00466 }
00467
00468 static inline unsigned int ScaleQuantumToLong(const Quantum quantum)
00469 {
00470 #if !defined(MAGICKCORE_HDRI_SUPPORT)
00471 return((unsigned int) (65537UL*quantum));
00472 #else
00473 if (quantum <= 0.0)
00474 return(0UL);
00475 if ((65537.0*quantum) >= 4294967295.0)
00476 return(4294967295U);
00477 return((unsigned int) (65537.0*quantum+0.5));
00478 #endif
00479 }
00480
00481 static inline MagickSizeType ScaleQuantumToLongLong(const Quantum quantum)
00482 {
00483 #if !defined(MAGICKCORE_HDRI_SUPPORT)
00484 return((MagickSizeType) (MagickULLConstant(281479271743489)*quantum));
00485 #else
00486 if (quantum <= 0.0)
00487 return(0UL);
00488 if ((281479271743489.0*quantum) >= 18446744073709551615.0)
00489 return(MagickULLConstant(18446744073709551615));
00490 return((MagickSizeType) (281479271743489.0*quantum+0.5));
00491 #endif
00492 }
00493
00494 static inline unsigned int ScaleQuantumToMap(const Quantum quantum)
00495 {
00496 if (quantum >= (Quantum) MaxMap)
00497 return((unsigned int) MaxMap);
00498 #if !defined(MAGICKCORE_HDRI_SUPPORT)
00499 return((unsigned int) quantum);
00500 #else
00501 if (quantum < 0.0)
00502 return(0UL);
00503 return((unsigned int) (quantum+0.5));
00504 #endif
00505 }
00506
00507 static inline unsigned short ScaleQuantumToShort(const Quantum quantum)
00508 {
00509 #if !defined(MAGICKCORE_HDRI_SUPPORT)
00510 return((unsigned short) quantum);
00511 #else
00512 if (quantum <= 0.0)
00513 return(0);
00514 if (quantum >= 65535.0)
00515 return(65535);
00516 return((unsigned short) (quantum+0.5));
00517 #endif
00518 }
00519
00520 static inline Quantum ScaleShortToQuantum(const unsigned short value)
00521 {
00522 return((Quantum) value);
00523 }
00524 #elif (MAGICKCORE_QUANTUM_DEPTH == 32)
00525 static inline Quantum ScaleCharToQuantum(const unsigned char value)
00526 {
00527 #if !defined(MAGICKCORE_HDRI_SUPPORT)
00528 return((Quantum) (16843009UL*value));
00529 #else
00530 return((Quantum) (16843009.0*value));
00531 #endif
00532 }
00533
00534 static inline Quantum ScaleLongToQuantum(const unsigned int value)
00535 {
00536 return((Quantum) value);
00537 }
00538
00539 static inline Quantum ScaleLongLongToQuantum(const MagickSizeType value)
00540 {
00541 #if !defined(MAGICKCORE_HDRI_SUPPORT)
00542 return((Quantum) ((value)/MagickULLConstant(4294967297)));
00543 #else
00544 return((Quantum) (value/4294967297.0));
00545 #endif
00546 }
00547
00548 static inline Quantum ScaleMapToQuantum(const MagickRealType value)
00549 {
00550 if (value <= 0.0)
00551 return((Quantum) 0);
00552 if (value >= (Quantum) MaxMap)
00553 return(QuantumRange);
00554 #if !defined(MAGICKCORE_HDRI_SUPPORT)
00555 return((Quantum) (65537.0*value+0.5));
00556 #else
00557 return((Quantum) (65537.0*value));
00558 #endif
00559 }
00560
00561 static inline unsigned int ScaleQuantumToLong(const Quantum quantum)
00562 {
00563 #if !defined(MAGICKCORE_HDRI_SUPPORT)
00564 return((unsigned int) quantum);
00565 #else
00566 if (quantum <= 0.0)
00567 return(0);
00568 if ((quantum) >= 4294967295.0)
00569 return(4294967295);
00570 return((unsigned int) (quantum+0.5));
00571 #endif
00572 }
00573
00574 static inline MagickSizeType ScaleQuantumToLongLong(const Quantum quantum)
00575 {
00576 #if !defined(MAGICKCORE_HDRI_SUPPORT)
00577 return((MagickSizeType) (MagickULLConstant(4294967297)*quantum));
00578 #else
00579 if (quantum <= 0.0)
00580 return(0UL);
00581 if ((4294967297.0*quantum) >= 18446744073709551615.0)
00582 return(MagickULLConstant(18446744073709551615));
00583 return((MagickSizeType) (4294967297.0*quantum+0.5));
00584 #endif
00585 }
00586
00587 static inline unsigned int ScaleQuantumToMap(const Quantum quantum)
00588 {
00589 if (quantum < 0.0)
00590 return(0UL);
00591 if ((quantum/65537) >= (Quantum) MaxMap)
00592 return((unsigned int) MaxMap);
00593 #if !defined(MAGICKCORE_HDRI_SUPPORT)
00594 return((unsigned int) ((quantum+MagickULLConstant(32768))/
00595 MagickULLConstant(65537)));
00596 #else
00597 return((unsigned int) (quantum/65537.0+0.5));
00598 #endif
00599 }
00600
00601 static inline unsigned short ScaleQuantumToShort(const Quantum quantum)
00602 {
00603 #if !defined(MAGICKCORE_HDRI_SUPPORT)
00604 return((unsigned short) ((quantum+MagickULLConstant(32768))/
00605 MagickULLConstant(65537)));
00606 #else
00607 if (quantum <= 0.0)
00608 return(0);
00609 if ((quantum/65537.0) >= 65535.0)
00610 return(65535);
00611 return((unsigned short) (quantum/65537.0+0.5));
00612 #endif
00613 }
00614
00615 static inline Quantum ScaleShortToQuantum(const unsigned short value)
00616 {
00617 #if !defined(MAGICKCORE_HDRI_SUPPORT)
00618 return((Quantum) (65537UL*value));
00619 #else
00620 return((Quantum) (65537.0*value));
00621 #endif
00622 }
00623 #elif (MAGICKCORE_QUANTUM_DEPTH == 64)
00624 static inline Quantum ScaleCharToQuantum(const unsigned char value)
00625 {
00626 return((Quantum) (72340172838076673.0*value));
00627 }
00628
00629 static inline Quantum ScaleLongToQuantum(const unsigned int value)
00630 {
00631 return((Quantum) (4294967297.0*value));
00632 }
00633
00634 static inline Quantum ScaleLongLongToQuantum(const MagickSizeType value)
00635 {
00636 return((Quantum) (value));
00637 }
00638
00639 static inline Quantum ScaleMapToQuantum(const MagickRealType value)
00640 {
00641 if (value <= 0.0)
00642 return((Quantum) 0);
00643 if (value >= MaxMap)
00644 return(QuantumRange);
00645 return((Quantum) (281479271743489.0*value));
00646 }
00647
00648 static inline unsigned int ScaleQuantumToLong(const Quantum quantum)
00649 {
00650 return((unsigned int) (quantum/4294967297.0+0.5));
00651 }
00652
00653 static inline MagickSizeType ScaleQuantumToLongLong(const Quantum quantum)
00654 {
00655 #if !defined(MAGICKCORE_HDRI_SUPPORT)
00656 return((MagickSizeType) quantum);
00657 #else
00658 if (quantum <= 0.0)
00659 return(0);
00660 if (quantum >= 18446744073709551615)
00661 return(18446744073709551615);
00662 return((MagickSizeType) (quantum+0.5));
00663 #endif
00664 }
00665
00666 static inline unsigned int ScaleQuantumToMap(const Quantum quantum)
00667 {
00668 if (quantum <= 0.0)
00669 return(0UL);
00670 if ((quantum/281479271743489.0) >= MaxMap)
00671 return((unsigned int) MaxMap);
00672 return((unsigned int) (quantum/281479271743489.0+0.5));
00673 }
00674
00675 static inline unsigned short ScaleQuantumToShort(const Quantum quantum)
00676 {
00677 if (quantum <= 0.0)
00678 return(0);
00679 if ((quantum/281479271743489.0) >= 65535.0)
00680 return(65535);
00681 return((unsigned short) (quantum/281479271743489.0+0.5));
00682 }
00683
00684 static inline Quantum ScaleShortToQuantum(const unsigned short value)
00685 {
00686 return((Quantum) (281479271743489.0*value));
00687 }
00688 #endif
00689
00690 static inline unsigned short SinglePrecisionToHalf(const float value)
00691 {
00692 typedef union _SinglePrecision
00693 {
00694 unsigned int
00695 fixed_point;
00696
00697 float
00698 single_precision;
00699 } SinglePrecision;
00700
00701 register int
00702 exponent;
00703
00704 register unsigned int
00705 significand,
00706 sign_bit;
00707
00708 SinglePrecision
00709 map;
00710
00711 unsigned short
00712 half;
00713
00714
00715
00716
00717
00718
00719
00720
00721 map.single_precision=value;
00722 sign_bit=(map.fixed_point >> 16) & 0x00008000;
00723 exponent=(int) ((map.fixed_point >> ExponentShift) & 0x000000ff)-ExponentBias;
00724 significand=map.fixed_point & 0x007fffff;
00725 if (exponent <= 0)
00726 {
00727 int
00728 shift;
00729
00730 if (exponent < -10)
00731 return((unsigned short) sign_bit);
00732 significand=significand | 0x00800000;
00733 shift=(int) (14-exponent);
00734 significand=(unsigned int) ((significand+((1 << (shift-1))-1)+
00735 ((significand >> shift) & 0x01)) >> shift);
00736 return((unsigned short) (sign_bit | significand));
00737 }
00738 else
00739 if (exponent == (0xff-ExponentBias))
00740 {
00741 if (significand == 0)
00742 return((unsigned short) (sign_bit | ExponentMask));
00743 else
00744 {
00745 significand>>=SignificandShift;
00746 half=(unsigned short) (sign_bit | significand |
00747 (significand == 0) | ExponentMask);
00748 return(half);
00749 }
00750 }
00751 significand=significand+((significand >> SignificandShift) & 0x01)+0x00000fff;
00752 if ((significand & 0x00800000) != 0)
00753 {
00754 significand=0;
00755 exponent++;
00756 }
00757 if (exponent > 30)
00758 {
00759 float
00760 alpha;
00761
00762 register int
00763 i;
00764
00765
00766
00767
00768 alpha=1.0e10;
00769 for (i=0; i < 10; i++)
00770 alpha*=alpha;
00771 return((unsigned short) (sign_bit | ExponentMask));
00772 }
00773 half=(unsigned short) (sign_bit | (exponent << 10) |
00774 (significand >> SignificandShift));
00775 return(half);
00776 }
00777
00778 #if defined(__cplusplus) || defined(c_plusplus)
00779 }
00780 #endif
00781
00782 #endif