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