MagickCore 7.1.2-32
Convert, Edit, Or Compose Bitmap Images
Loading...
Searching...
No Matches
quantum-private.h
1/*
2 Copyright @ 1999 ImageMagick Studio LLC, a non-profit organization
3 dedicated to making software imaging solutions freely available.
4
5 You may not use this file except in compliance with the License. You may
6 obtain a copy of the License at
7
8 https://imagemagick.org/license/
9
10 Unless required by applicable law or agreed to in writing, software
11 distributed under the License is distributed on an "AS IS" BASIS,
12 WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
13 See the License for the specific language governing permissions and
14 limitations under the License.
15
16 MagickCore quantum inline methods.
17*/
18#ifndef MAGICKCORE_QUANTUM_PRIVATE_H
19#define MAGICKCORE_QUANTUM_PRIVATE_H
20
21#include <stddef.h>
22#include "MagickCore/memory_.h"
23#include "MagickCore/cache.h"
24#include "MagickCore/image-private.h"
25#include "MagickCore/pixel-accessor.h"
26#include "MagickCore/statistic-private.h"
27
28#if defined(__cplusplus) || defined(c_plusplus)
29extern "C" {
30#endif
31
32#define MagickMax(x,y) (((x) > (y)) ? (x) : (y))
33#define MagickMin(x,y) (((x) < (y)) ? (x) : (y))
34
35typedef struct _QuantumState
36{
37 double
38 inverse_scale;
39
40 unsigned int
41 pixel;
42
43 size_t
44 bits;
45
46 const unsigned int
47 *mask;
48} QuantumState;
49
50struct _QuantumInfo
51{
52 size_t
53 depth,
54 quantum;
55
56 QuantumFormatType
57 format;
58
59 double
60 minimum,
61 maximum,
62 scale;
63
64 size_t
65 pad;
66
67 MagickBooleanType
68 min_is_white,
69 pack;
70
71 QuantumAlphaType
72 alpha_type;
73
74 size_t
75 number_threads;
76
77 MemoryInfo
78 **pixels;
79
80 size_t
81 extent;
82
83 EndianType
84 endian;
85
86 QuantumState
87 state;
88
89 SemaphoreInfo
90 *semaphore;
91
92 size_t
93 signature;
94
95 size_t
96 meta_channel;
97};
98
99extern MagickExport MagickBooleanType
100 SetQuantumExtent(const Image *,QuantumInfo *);
101
102extern MagickPrivate void
103 ResetQuantumState(QuantumInfo *);
104
105static inline MagickSizeType GetQuantumRange(const size_t depth)
106{
107 MagickSizeType
108 one;
109
110 size_t
111 max_depth;
112
113 if (depth == 0)
114 return(0);
115 one=1;
116 max_depth=8*sizeof(MagickSizeType);
117 return((MagickSizeType) ((one << (MagickMin(depth,max_depth)-1))+
118 ((one << (MagickMin(depth,max_depth)-1))-1)));
119}
120
121static inline EndianType GetHostEndian(void)
122{
123 unsigned long
124 lsb_first;
125
126 lsb_first=1;
127 return((*(char *) &lsb_first) == 1 ? LSBEndian : MSBEndian);
128}
129
130static inline float HalfToSinglePrecision(const unsigned short half)
131{
132#define ExponentBias (127-15)
133#define ExponentMask (0x7c00U)
134#define ExponentShift 23
135#define SignBitShift 31
136#define SignificandShift 13
137#define SignificandMask (0x00000400U)
138
139 typedef union _SinglePrecision
140 {
141 unsigned int
142 fixed_point;
143
144 float
145 single_precision;
146 } SinglePrecision;
147
148 SinglePrecision
149 map;
150
151 unsigned int
152 exponent,
153 significand,
154 sign_bit,
155 value;
156
157 /*
158 The IEEE 754 standard specifies half precision as having:
159
160 Sign bit: 1 bit
161 Exponent width: 5 bits
162 Significand precision: 11 (10 explicitly stored)
163 */
164 sign_bit=(unsigned int) ((half >> 15) & 0x00000001);
165 exponent=(unsigned int) ((half >> 10) & 0x0000001f);
166 significand=(unsigned int) (half & 0x000003ff);
167 if (exponent == 0)
168 {
169 if (significand == 0)
170 value=sign_bit << SignBitShift;
171 else
172 {
173 while ((significand & SignificandMask) == 0)
174 {
175 significand<<=1;
176 exponent--;
177 }
178 exponent++;
179 significand&=(~SignificandMask);
180 exponent+=ExponentBias;
181 value=(sign_bit << SignBitShift) | (exponent << ExponentShift) |
182 (significand << SignificandShift);
183 }
184 }
185 else
186 if (exponent == SignBitShift)
187 {
188 value=(sign_bit << SignBitShift) | 0x7f800000;
189 if (significand != 0)
190 value|=(significand << SignificandShift);
191 }
192 else
193 {
194 exponent+=ExponentBias;
195 significand<<=SignificandShift;
196 value=(sign_bit << SignBitShift) | (exponent << ExponentShift) |
197 significand;
198 }
199 map.fixed_point=value;
200 return(map.single_precision);
201}
202
203static inline unsigned char *PopCharPixel(const unsigned char pixel,
204 unsigned char *magick_restrict pixels)
205{
206 *pixels++=pixel;
207 return(pixels);
208}
209
210static inline unsigned char *PopLongPixel(const EndianType endian,
211 const unsigned int pixel,unsigned char *magick_restrict pixels)
212{
213 unsigned int
214 quantum;
215
216 quantum=(unsigned int) pixel;
217 if (endian == LSBEndian)
218 {
219 *pixels++=(unsigned char) (quantum);
220 *pixels++=(unsigned char) (quantum >> 8);
221 *pixels++=(unsigned char) (quantum >> 16);
222 *pixels++=(unsigned char) (quantum >> 24);
223 return(pixels);
224 }
225 *pixels++=(unsigned char) (quantum >> 24);
226 *pixels++=(unsigned char) (quantum >> 16);
227 *pixels++=(unsigned char) (quantum >> 8);
228 *pixels++=(unsigned char) (quantum);
229 return(pixels);
230}
231
232static inline unsigned char *PopShortPixel(const EndianType endian,
233 const unsigned short pixel,unsigned char *magick_restrict pixels)
234{
235 unsigned int
236 quantum;
237
238 quantum=pixel;
239 if (endian == LSBEndian)
240 {
241 *pixels++=(unsigned char) (quantum);
242 *pixels++=(unsigned char) (quantum >> 8);
243 return(pixels);
244 }
245 *pixels++=(unsigned char) (quantum >> 8);
246 *pixels++=(unsigned char) (quantum);
247 return(pixels);
248}
249
250static inline const unsigned char *PushCharPixel(
251 const unsigned char *magick_restrict pixels,
252 unsigned char *magick_restrict pixel)
253{
254 *pixel=(*pixels++);
255 return(pixels);
256}
257
258static inline const unsigned char *PushLongPixel(const EndianType endian,
259 const unsigned char *magick_restrict pixels,
260 unsigned int *magick_restrict pixel)
261{
262 unsigned int
263 quantum;
264
265 if (endian == LSBEndian)
266 {
267 quantum=((unsigned int) *pixels++);
268 quantum|=((unsigned int) *pixels++ << 8);
269 quantum|=((unsigned int) *pixels++ << 16);
270 quantum|=((unsigned int) *pixels++ << 24);
271 *pixel=quantum;
272 return(pixels);
273 }
274 quantum=((unsigned int) *pixels++ << 24);
275 quantum|=((unsigned int) *pixels++ << 16);
276 quantum|=((unsigned int) *pixels++ << 8);
277 quantum|=((unsigned int) *pixels++);
278 *pixel=quantum;
279 return(pixels);
280}
281
282static inline const unsigned char *PushShortPixel(const EndianType endian,
283 const unsigned char *magick_restrict pixels,
284 unsigned short *magick_restrict pixel)
285{
286 unsigned int
287 quantum;
288
289 if (endian == LSBEndian)
290 {
291 quantum=(unsigned int) *pixels++;
292 quantum|=(unsigned int) (*pixels++ << 8);
293 *pixel=(unsigned short) (quantum & 0xffff);
294 return(pixels);
295 }
296 quantum=(unsigned int) (*pixels++ << 8);
297 quantum|=(unsigned int) *pixels++;
298 *pixel=(unsigned short) (quantum & 0xffff);
299 return(pixels);
300}
301
302static inline const unsigned char *PushFloatPixel(const EndianType endian,
303 const unsigned char *magick_restrict pixels,
304 MagickFloatType *magick_restrict pixel)
305{
306 union
307 {
308 unsigned int
309 unsigned_value;
310
311 MagickFloatType
312 float_value;
313 } quantum;
314
315 if (endian == LSBEndian)
316 {
317 quantum.unsigned_value=((unsigned int) *pixels++);
318 quantum.unsigned_value|=((unsigned int) *pixels++ << 8);
319 quantum.unsigned_value|=((unsigned int) *pixels++ << 16);
320 quantum.unsigned_value|=((unsigned int) *pixels++ << 24);
321 *pixel=quantum.float_value;
322 return(pixels);
323 }
324 quantum.unsigned_value=((unsigned int) *pixels++ << 24);
325 quantum.unsigned_value|=((unsigned int) *pixels++ << 16);
326 quantum.unsigned_value|=((unsigned int) *pixels++ << 8);
327 quantum.unsigned_value|=((unsigned int) *pixels++);
328 *pixel=quantum.float_value;
329 return(pixels);
330}
331
332static inline Quantum ScaleAnyToQuantum(const QuantumAny quantum,
333 const QuantumAny range)
334{
335 if (quantum > range)
336 return(QuantumRange);
337#if !defined(MAGICKCORE_HDRI_SUPPORT)
338 return((Quantum) ((double) QuantumRange*(quantum*
339 MagickSafeReciprocal((double) range))+0.5));
340#else
341 return((Quantum) ((double) QuantumRange*((double) quantum*
342 MagickSafeReciprocal((double) range))));
343#endif
344}
345
346static inline QuantumAny ScaleQuantumToAny(const Quantum quantum,
347 const QuantumAny range)
348{
349#if !defined(MAGICKCORE_HDRI_SUPPORT)
350 return((QuantumAny) ((double) range*quantum/QuantumRange));
351#else
352 if ((IsNaN(quantum) != 0) || (quantum <= 0.0f))
353 return((QuantumAny) 0UL);
354 if (((double) range*(double) quantum/(double) QuantumRange) >= 18446744073709551615.0)
355 return((QuantumAny) MagickULLConstant(18446744073709551615));
356 return((QuantumAny) ((double) range*(double) quantum/(double) QuantumRange+0.5));
357#endif
358}
359
360#if (MAGICKCORE_QUANTUM_DEPTH == 8)
361static inline Quantum ScaleCharToQuantum(const unsigned char value)
362{
363 return((Quantum) value);
364}
365
366static inline Quantum ScaleLongToQuantum(const unsigned int value)
367{
368#if !defined(MAGICKCORE_HDRI_SUPPORT)
369 return((Quantum) ((value)/16843009UL));
370#else
371 return((Quantum) (value/16843009.0));
372#endif
373}
374
375static inline Quantum ScaleLongLongToQuantum(const MagickSizeType value)
376{
377#if !defined(MAGICKCORE_HDRI_SUPPORT)
378 return((Quantum) (value/MagickULLConstant(72340172838076673)));
379#else
380 return((Quantum) (value/72340172838076673.0));
381#endif
382}
383
384static inline Quantum ScaleMapToQuantum(const MagickRealType value)
385{
386 if (value <= 0.0)
387 return((Quantum) 0);
388 if (value >= MaxMap)
389 return(QuantumRange);
390#if !defined(MAGICKCORE_HDRI_SUPPORT)
391 return((Quantum) (value+0.5));
392#else
393 return((Quantum) value);
394#endif
395}
396
397static inline unsigned int ScaleQuantumToLong(const Quantum quantum)
398{
399#if !defined(MAGICKCORE_HDRI_SUPPORT)
400 return((unsigned int) (16843009UL*quantum));
401#else
402 if ((IsNaN(quantum) != 0) || (quantum <= 0.0))
403 return(0U);
404 if ((16843009.0*quantum) >= 4294967295.0)
405 return(4294967295UL);
406 return((unsigned int) (16843009.0*quantum+0.5));
407#endif
408}
409
410static inline MagickSizeType ScaleQuantumToLongLong(const Quantum quantum)
411{
412#if !defined(MAGICKCORE_HDRI_SUPPORT)
413 return((MagickSizeType) (MagickULLConstant(72340172838076673)*quantum));
414#else
415 if ((IsNaN(quantum) != 0) || (quantum <= 0.0))
416 return(0UL);
417 if ((72340172838076673.0*quantum) >= 18446744073709551615.0)
418 return(MagickULLConstant(18446744073709551615));
419 return((MagickSizeType) (72340172838076673.0*quantum+0.5));
420#endif
421}
422
423static inline unsigned int ScaleQuantumToMap(const Quantum quantum)
424{
425 if (quantum >= (Quantum) MaxMap)
426 return((unsigned int) MaxMap);
427#if !defined(MAGICKCORE_HDRI_SUPPORT)
428 return((unsigned int) quantum);
429#else
430 if ((IsNaN(quantum) != 0) || (quantum <= 0.0))
431 return(0U);
432 return((unsigned int) (quantum+0.5));
433#endif
434}
435
436static inline unsigned short ScaleQuantumToShort(const Quantum quantum)
437{
438#if !defined(MAGICKCORE_HDRI_SUPPORT)
439 return((unsigned short) (257UL*quantum));
440#else
441 if ((IsNaN(quantum) != 0) || (quantum <= 0.0))
442 return(0);
443 if ((257.0*quantum) >= 65535.0)
444 return(65535);
445 return((unsigned short) (257.0*quantum+0.5));
446#endif
447}
448
449static inline Quantum ScaleShortToQuantum(const unsigned short value)
450{
451#if !defined(MAGICKCORE_HDRI_SUPPORT)
452 return((Quantum) ((value+128U)/257U));
453#else
454 return((Quantum) (value/257.0));
455#endif
456}
457#elif (MAGICKCORE_QUANTUM_DEPTH == 16)
458static inline Quantum ScaleCharToQuantum(const unsigned char value)
459{
460#if !defined(MAGICKCORE_HDRI_SUPPORT)
461 return((Quantum) (257U*value));
462#else
463 return((Quantum) (257.0*value));
464#endif
465}
466
467static inline Quantum ScaleLongToQuantum(const unsigned int value)
468{
469#if !defined(MAGICKCORE_HDRI_SUPPORT)
470 return((Quantum) ((value)/MagickULLConstant(65537)));
471#else
472 return((Quantum) (value/65537.0));
473#endif
474}
475
476static inline Quantum ScaleLongLongToQuantum(const MagickSizeType value)
477{
478#if !defined(MAGICKCORE_HDRI_SUPPORT)
479 return((Quantum) ((value)/MagickULLConstant(281479271743489)));
480#else
481 return((Quantum) ((double) value/281479271743489.0));
482#endif
483}
484
485static inline Quantum ScaleMapToQuantum(const MagickRealType value)
486{
487 if (value <= 0.0)
488 return((Quantum) 0);
489 if (value >= MaxMap)
490 return(QuantumRange);
491#if !defined(MAGICKCORE_HDRI_SUPPORT)
492 return((Quantum) (value+0.5));
493#else
494 return((Quantum) value);
495#endif
496}
497
498static inline unsigned int ScaleQuantumToLong(const Quantum quantum)
499{
500#if !defined(MAGICKCORE_HDRI_SUPPORT)
501 return((unsigned int) (65537UL*quantum));
502#else
503 if ((IsNaN(quantum) != 0) || (quantum <= 0.0f))
504 return(0U);
505 if ((65537.0*(double) quantum) >= 4294967295.0)
506 return(4294967295U);
507 return((unsigned int) (65537.0*(double) quantum+0.5));
508#endif
509}
510
511static inline MagickSizeType ScaleQuantumToLongLong(const Quantum quantum)
512{
513#if !defined(MAGICKCORE_HDRI_SUPPORT)
514 return((MagickSizeType) (MagickULLConstant(281479271743489)*quantum));
515#else
516 if ((IsNaN(quantum) != 0) || (quantum <= 0.0f))
517 return(0UL);
518 if ((281479271743489.0*(double) quantum) >= 18446744073709551615.0)
519 return(MagickULLConstant(18446744073709551615));
520 return((MagickSizeType) (281479271743489.0*(double) quantum+0.5));
521#endif
522}
523
524static inline unsigned int ScaleQuantumToMap(const Quantum quantum)
525{
526 if (quantum >= (Quantum) MaxMap)
527 return((unsigned int) MaxMap);
528#if !defined(MAGICKCORE_HDRI_SUPPORT)
529 return((unsigned int) quantum);
530#else
531 if ((IsNaN(quantum) != 0) || (quantum <= 0.0f))
532 return(0U);
533 return((unsigned int) (quantum+0.5f));
534#endif
535}
536
537static inline unsigned short ScaleQuantumToShort(const Quantum quantum)
538{
539#if !defined(MAGICKCORE_HDRI_SUPPORT)
540 return((unsigned short) quantum);
541#else
542 if ((IsNaN(quantum) != 0) || (quantum <= 0.0f))
543 return(0);
544 if (quantum >= 65535.0f)
545 return(65535);
546 return((unsigned short) (quantum+0.5f));
547#endif
548}
549
550static inline Quantum ScaleShortToQuantum(const unsigned short value)
551{
552 return((Quantum) value);
553}
554#elif (MAGICKCORE_QUANTUM_DEPTH == 32)
555static inline Quantum ScaleCharToQuantum(const unsigned char value)
556{
557#if !defined(MAGICKCORE_HDRI_SUPPORT)
558 return((Quantum) (16843009UL*value));
559#else
560 return((Quantum) (16843009.0*value));
561#endif
562}
563
564static inline Quantum ScaleLongToQuantum(const unsigned int value)
565{
566 return((Quantum) value);
567}
568
569static inline Quantum ScaleLongLongToQuantum(const MagickSizeType value)
570{
571#if !defined(MAGICKCORE_HDRI_SUPPORT)
572 return((Quantum) ((value)/MagickULLConstant(4294967297)));
573#else
574 return((Quantum) (value/4294967297.0));
575#endif
576}
577
578static inline Quantum ScaleMapToQuantum(const MagickRealType value)
579{
580 if (value <= 0.0)
581 return((Quantum) 0);
582 if (value >= (Quantum) MaxMap)
583 return(QuantumRange);
584#if !defined(MAGICKCORE_HDRI_SUPPORT)
585 return((Quantum) (65537.0*value+0.5));
586#else
587 return((Quantum) (65537.0*value));
588#endif
589}
590
591static inline unsigned int ScaleQuantumToLong(const Quantum quantum)
592{
593#if !defined(MAGICKCORE_HDRI_SUPPORT)
594 return((unsigned int) quantum);
595#else
596 if ((IsNaN(quantum) != 0) || (quantum <= 0.0))
597 return(0U);
598 if ((quantum) >= 4294967295.0)
599 return(4294967295);
600 return((unsigned int) (quantum+0.5));
601#endif
602}
603
604static inline MagickSizeType ScaleQuantumToLongLong(const Quantum quantum)
605{
606#if !defined(MAGICKCORE_HDRI_SUPPORT)
607 return((MagickSizeType) (MagickULLConstant(4294967297)*quantum));
608#else
609 if ((IsNaN(quantum) != 0) || (quantum <= 0.0))
610 return(0UL);
611 if ((4294967297.0*quantum) >= 18446744073709551615.0)
612 return(MagickULLConstant(18446744073709551615));
613 return((MagickSizeType) (4294967297.0*quantum+0.5));
614#endif
615}
616
617static inline unsigned int ScaleQuantumToMap(const Quantum quantum)
618{
619 if ((quantum/65537) >= (Quantum) MaxMap)
620 return((unsigned int) MaxMap);
621#if !defined(MAGICKCORE_HDRI_SUPPORT)
622 return((unsigned int) ((quantum+MagickULLConstant(32768))/
623 MagickULLConstant(65537)));
624#else
625 if ((IsNaN(quantum) != 0) || (quantum <= 0.0))
626 return(0U);
627 return((unsigned int) (quantum/65537.0+0.5));
628#endif
629}
630
631static inline unsigned short ScaleQuantumToShort(const Quantum quantum)
632{
633#if !defined(MAGICKCORE_HDRI_SUPPORT)
634 return((unsigned short) ((quantum+MagickULLConstant(32768))/
635 MagickULLConstant(65537)));
636#else
637 if ((IsNaN(quantum) != 0) || (quantum <= 0.0))
638 return(0);
639 if ((quantum/65537.0) >= 65535.0)
640 return(65535);
641 return((unsigned short) (quantum/65537.0+0.5));
642#endif
643}
644
645static inline Quantum ScaleShortToQuantum(const unsigned short value)
646{
647#if !defined(MAGICKCORE_HDRI_SUPPORT)
648 return((Quantum) (65537UL*value));
649#else
650 return((Quantum) (65537.0*value));
651#endif
652}
653#elif (MAGICKCORE_QUANTUM_DEPTH == 64)
654static inline Quantum ScaleCharToQuantum(const unsigned char value)
655{
656 return((Quantum) (72340172838076673.0*value));
657}
658
659static inline Quantum ScaleLongToQuantum(const unsigned int value)
660{
661 return((Quantum) (4294967297.0*value));
662}
663
664static inline Quantum ScaleLongLongToQuantum(const MagickSizeType value)
665{
666 return((Quantum) (value));
667}
668
669static inline Quantum ScaleMapToQuantum(const MagickRealType value)
670{
671 if (value <= 0.0)
672 return((Quantum) 0);
673 if (value >= MaxMap)
674 return(QuantumRange);
675 return((Quantum) (281479271743489.0*value));
676}
677
678static inline unsigned int ScaleQuantumToLong(const Quantum quantum)
679{
680 return((unsigned int) (quantum/4294967297.0+0.5));
681}
682
683static inline MagickSizeType ScaleQuantumToLongLong(const Quantum quantum)
684{
685#if !defined(MAGICKCORE_HDRI_SUPPORT)
686 return((MagickSizeType) quantum);
687#else
688 if ((IsNaN(quantum) != 0) || (quantum <= 0.0))
689 return(0UL);
690 if (quantum >= 18446744073709551615.0)
691 return(MagickULLConstant(18446744073709551615));
692 return((MagickSizeType) (quantum+0.5));
693#endif
694}
695
696static inline unsigned int ScaleQuantumToMap(const Quantum quantum)
697{
698 if ((IsNaN(quantum) != 0) || (quantum <= 0.0))
699 return(0U);
700 if ((quantum/281479271743489.0) >= MaxMap)
701 return((unsigned int) MaxMap);
702 return((unsigned int) (quantum/281479271743489.0+0.5));
703}
704
705static inline unsigned short ScaleQuantumToShort(const Quantum quantum)
706{
707 if ((IsNaN(quantum) != 0) || (quantum <= 0.0))
708 return(0);
709 if ((quantum/281479271743489.0) >= 65535.0)
710 return(65535);
711 return((unsigned short) (quantum/281479271743489.0+0.5));
712}
713
714static inline Quantum ScaleShortToQuantum(const unsigned short value)
715{
716 return((Quantum) (281479271743489.0*value));
717}
718#endif
719
720static inline unsigned short SinglePrecisionToHalf(const double value)
721{
722 typedef union _SinglePrecision
723 {
724 unsigned int
725 fixed_point;
726
727 float
728 single_precision;
729 } SinglePrecision;
730
731 int
732 exponent;
733
734 SinglePrecision
735 map;
736
737 unsigned int
738 significand,
739 sign_bit;
740
741 unsigned short
742 half;
743
744 /*
745 The IEEE 754 standard specifies half precision as having:
746
747 Sign bit: 1 bit
748 Exponent width: 5 bits
749 Significand precision: 11 (10 explicitly stored)
750 */
751 map.single_precision=(float) value;
752 sign_bit=(map.fixed_point >> 16) & 0x00008000;
753 exponent=(int) ((map.fixed_point >> ExponentShift) & 0x000000ff)-ExponentBias;
754 significand=map.fixed_point & 0x007fffff;
755 if (exponent <= 0)
756 {
757 int
758 shift;
759
760 if (exponent < -10)
761 return((unsigned short) sign_bit);
762 significand=significand | 0x00800000;
763 shift=(int) (14-exponent);
764 significand=(unsigned int) ((significand+((1U << (shift-1))-1)+
765 ((significand >> shift) & 0x01)) >> shift);
766 return((unsigned short) (sign_bit | significand));
767 }
768 else
769 if (exponent == (0xff-ExponentBias))
770 {
771 if (significand == 0)
772 return((unsigned short) (sign_bit | ExponentMask));
773 else
774 {
775 significand>>=SignificandShift;
776 half=(unsigned short) (sign_bit | significand |
777 (significand == 0) | ExponentMask);
778 return(half);
779 }
780 }
781 significand=significand+((significand >> SignificandShift) & 0x01)+0x00000fff;
782 if ((significand & 0x00800000) != 0)
783 {
784 significand=0;
785 exponent++;
786 }
787 if (exponent > 30)
788 {
789 float
790 alpha;
791
792 int
793 i;
794
795 /*
796 Float overflow.
797 */
798 alpha=1.0e10;
799 for (i=0; i < 10; i++)
800 alpha*=alpha;
801 return((unsigned short) (sign_bit | ExponentMask));
802 }
803 half=(unsigned short) (sign_bit | ((unsigned int) exponent << 10) |
804 (significand >> SignificandShift));
805 return(half);
806}
807
808#if defined(__cplusplus) || defined(c_plusplus)
809}
810#endif
811
812#endif
_QuantumInfo
Definition quantum-private.h:51
_QuantumState
Definition quantum-private.h:36