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