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