Debian Codegraph @

src/Imath/half.h

raw
1 //
2 // SPDX-License-Identifier: BSD-3-Clause
3 // Copyright Contributors to the OpenEXR Project.
4 //
5
6 //
7 // Primary original authors:
8 // Florian Kainz <[email protected]>
9 // Rod Bogart <[email protected]>
10 //
11
12 #ifndef IMATH_HALF_H_
13 #define IMATH_HALF_H_
14
15 #include "ImathExport.h"
16 #include "ImathNamespace.h"
17 #include "ImathPlatform.h"
18
19 /// @file half.h
20 /// The half type is a 16-bit floating number, compatible with the
21 /// IEEE 754-2008 binary16 type.
22 ///
23 /// **Representation of a 32-bit float:**
24 ///
25 /// We assume that a float, f, is an IEEE 754 single-precision
26 /// floating point number, whose bits are arranged as follows:
27 ///
28 /// 31 (msb)
29 /// |
30 /// | 30 23
31 /// | | |
32 /// | | | 22 0 (lsb)
33 /// | | | | |
34 /// X XXXXXXXX XXXXXXXXXXXXXXXXXXXXXXX
35 ///
36 /// s e m
37 ///
38 /// S is the sign-bit, e is the exponent and m is the significand.
39 ///
40 /// If e is between 1 and 254, f is a normalized number:
41 ///
42 /// s e-127
43 /// f = (-1) * 2 * 1.m
44 ///
45 /// If e is 0, and m is not zero, f is a denormalized number:
46 ///
47 /// s -126
48 /// f = (-1) * 2 * 0.m
49 ///
50 /// If e and m are both zero, f is zero:
51 ///
52 /// f = 0.0
53 ///
54 /// If e is 255, f is an "infinity" or "not a number" (NAN),
55 /// depending on whether m is zero or not.
56 ///
57 /// Examples:
58 ///
59 /// 0 00000000 00000000000000000000000 = 0.0
60 /// 0 01111110 00000000000000000000000 = 0.5
61 /// 0 01111111 00000000000000000000000 = 1.0
62 /// 0 10000000 00000000000000000000000 = 2.0
63 /// 0 10000000 10000000000000000000000 = 3.0
64 /// 1 10000101 11110000010000000000000 = -124.0625
65 /// 0 11111111 00000000000000000000000 = +infinity
66 /// 1 11111111 00000000000000000000000 = -infinity
67 /// 0 11111111 10000000000000000000000 = NAN
68 /// 1 11111111 11111111111111111111111 = NAN
69 ///
70 /// **Representation of a 16-bit half:**
71 ///
72 /// Here is the bit-layout for a half number, h:
73 ///
74 /// 15 (msb)
75 /// |
76 /// | 14 10
77 /// | | |
78 /// | | | 9 0 (lsb)
79 /// | | | | |
80 /// X XXXXX XXXXXXXXXX
81 ///
82 /// s e m
83 ///
84 /// S is the sign-bit, e is the exponent and m is the significand.
85 ///
86 /// If e is between 1 and 30, h is a normalized number:
87 ///
88 /// s e-15
89 /// h = (-1) * 2 * 1.m
90 ///
91 /// If e is 0, and m is not zero, h is a denormalized number:
92 ///
93 /// S -14
94 /// h = (-1) * 2 * 0.m
95 ///
96 /// If e and m are both zero, h is zero:
97 ///
98 /// h = 0.0
99 ///
100 /// If e is 31, h is an "infinity" or "not a number" (NAN),
101 /// depending on whether m is zero or not.
102 ///
103 /// Examples:
104 ///
105 /// 0 00000 0000000000 = 0.0
106 /// 0 01110 0000000000 = 0.5
107 /// 0 01111 0000000000 = 1.0
108 /// 0 10000 0000000000 = 2.0
109 /// 0 10000 1000000000 = 3.0
110 /// 1 10101 1111000001 = -124.0625
111 /// 0 11111 0000000000 = +infinity
112 /// 1 11111 0000000000 = -infinity
113 /// 0 11111 1000000000 = NAN
114 /// 1 11111 1111111111 = NAN
115 ///
116 /// **Conversion via Lookup Table:**
117 ///
118 /// Converting from half to float is performed by default using a
119 /// lookup table. There are only 65,536 different half numbers; each
120 /// of these numbers has been converted and stored in a table pointed
121 /// to by the ``imath_half_to_float_table`` pointer.
122 ///
123 /// Prior to Imath v3.1, conversion from float to half was
124 /// accomplished with the help of an exponent look table, but this is
125 /// now replaced with explicit bit shifting.
126 ///
127 /// **Conversion via Hardware:**
128 ///
129 /// For Imath v3.1, the conversion routines have been extended to use
130 /// F16C SSE instructions whenever present and enabled by compiler
131 /// flags.
132 ///
133 /// **Conversion via Bit-Shifting**
134 ///
135 /// If F16C SSE instructions are not available, conversion can be
136 /// accomplished by a bit-shifting algorithm. For half-to-float
137 /// conversion, this is generally slower than the lookup table, but it
138 /// may be preferable when memory limits preclude storing of the
139 /// 65,536-entry lookup table.
140 ///
141 /// The lookup table symbol is included in the compilation even if
142 /// ``IMATH_HALF_USE_LOOKUP_TABLE`` is false, because application code
143 /// using the exported ``half.h`` may choose to enable the use of the table.
144 ///
145 /// An implementation can eliminate the table from compilation by
146 /// defining the ``IMATH_HALF_NO_LOOKUP_TABLE`` preprocessor symbol.
147 /// Simply add:
148 ///
149 /// #define IMATH_HALF_NO_LOOKUP_TABLE
150 ///
151 /// before including ``half.h``, or define the symbol on the compile
152 /// command line.
153 ///
154 /// Furthermore, an implementation wishing to receive ``FE_OVERFLOW``
155 /// and ``FE_UNDERFLOW`` floating point exceptions when converting
156 /// float to half by the bit-shift algorithm can define the
157 /// preprocessor symbol ``IMATH_HALF_ENABLE_FP_EXCEPTIONS`` prior to
158 /// including ``half.h``:
159 ///
160 /// #define IMATH_HALF_ENABLE_FP_EXCEPTIONS
161 ///
162 /// **Conversion Performance Comparison:**
163 ///
164 /// Testing on a Core i9, the timings are approximately:
165 ///
166 /// half to float
167 /// - table: 0.71 ns / call
168 /// - no table: 1.06 ns / call
169 /// - f16c: 0.45 ns / call
170 ///
171 /// float-to-half:
172 /// - original: 5.2 ns / call
173 /// - no exp table + opt: 1.27 ns / call
174 /// - f16c: 0.45 ns / call
175 ///
176 /// **Note:** the timing above depends on the distribution of the
177 /// floats in question.
178 ///
179
180 #ifdef __CUDA_ARCH__
181 // do not include intrinsics headers on Cuda
182 #elif defined(_WIN32)
183 # include <intrin.h>
184 #elif defined(__x86_64__)
185 # include <x86intrin.h>
186 #elif defined(__F16C__)
187 # include <immintrin.h>
188 #endif
189
190 #include <stdint.h>
191 #include <stdio.h>
192
193 #ifdef IMATH_HALF_ENABLE_FP_EXCEPTIONS
194 # include <fenv.h>
195 #endif
196
197 //-------------------------------------------------------------------------
198 // Limits
199 //
200 // Visual C++ will complain if HALF_DENORM_MIN, HALF_NRM_MIN etc. are not float
201 // constants, but at least one other compiler (gcc 2.96) produces incorrect
202 // results if they are.
203 //-------------------------------------------------------------------------
204
205 #if (defined _WIN32 || defined _WIN64) && defined _MSC_VER
206
207 /// Smallest positive denormalized half
208 # define HALF_DENORM_MIN 5.96046448e-08f
209 /// Smallest positive normalized half
210 # define HALF_NRM_MIN 6.10351562e-05f
211 /// Smallest positive normalized half
212 # define HALF_MIN 6.10351562e-05f
213 /// Largest positive half
214 # define HALF_MAX 65504.0f
215 /// Smallest positive e for which ``half(1.0 + e) != half(1.0)``
216 # define HALF_EPSILON 0.00097656f
217 #else
218 /// Smallest positive denormalized half
219 # define HALF_DENORM_MIN 5.96046448e-08
220 /// Smallest positive normalized half
221 # define HALF_NRM_MIN 6.10351562e-05
222 /// Smallest positive normalized half
223 # define HALF_MIN 6.10351562e-05f
224 /// Largest positive half
225 # define HALF_MAX 65504.0
226 /// Smallest positive e for which ``half(1.0 + e) != half(1.0)``
227 # define HALF_EPSILON 0.00097656
228 #endif
229
230 /// Number of digits in mantissa (significand + hidden leading 1)
231 #define HALF_MANT_DIG 11
232 /// Number of base 10 digits that can be represented without change:
233 ///
234 /// ``floor( (HALF_MANT_DIG - 1) * log10(2) ) => 3.01... -> 3``
235 #define HALF_DIG 3
236 /// Number of base-10 digits that are necessary to uniquely represent
237 /// all distinct values:
238 ///
239 /// ``ceil(HALF_MANT_DIG * log10(2) + 1) => 4.31... -> 5``
240 #define HALF_DECIMAL_DIG 5
241 /// Base of the exponent
242 #define HALF_RADIX 2
243 /// Minimum negative integer such that ``HALF_RADIX`` raised to the power
244 /// of one less than that integer is a normalized half
245 #define HALF_DENORM_MIN_EXP -13
246 /// Maximum positive integer such that ``HALF_RADIX`` raised to the power
247 /// of one less than that integer is a normalized half
248 #define HALF_MAX_EXP 16
249 /// Minimum positive integer such that 10 raised to that power is a
250 /// normalized half
251 #define HALF_DENORM_MIN_10_EXP -4
252 /// Maximum positive integer such that 10 raised to that power is a
253 /// normalized half
254 #define HALF_MAX_10_EXP 4
255
256 /// a type for both C-only programs and C++ to use the same utilities
257 typedef union imath_half_uif
258 {
259 uint32_t i;
260 float f;
261 } imath_half_uif_t;
262
263 /// a type for both C-only programs and C++ to use the same utilities
264 typedef uint16_t imath_half_bits_t;
265
266 #if !defined(__cplusplus) && !defined(__CUDACC__)
267 /// if we're in a C-only context, alias the half bits type to half
268 typedef imath_half_bits_t half;
269 #endif
270
271 #if !defined(IMATH_HALF_NO_LOOKUP_TABLE)
272 # if defined(__cplusplus)
273 extern "C"
274 # else
275 extern
276 # endif
277 IMATH_EXPORT const imath_half_uif_t* imath_half_to_float_table;
278 #endif
279
280 ///
281 /// Convert half to float
282 ///
283
284 static inline float
285 imath_half_to_float (imath_half_bits_t h)
286 {
287 #if defined(__F16C__)
288 // NB: The intel implementation does seem to treat NaN slightly
289 // different than the original toFloat table does (i.e. where the
290 // 1 bits are, meaning the signalling or not bits). This seems
291 // benign, given that the original library didn't really deal with
292 // signalling vs non-signalling NaNs
293 # ifdef _MSC_VER
294 /* msvc does not seem to have cvtsh_ss :( */
295 return _mm_cvtss_f32 (_mm_cvtph_ps (_mm_set1_epi16 (h)));
296 # else
297 return _cvtsh_ss (h);
298 # endif
299 #elif defined(IMATH_HALF_USE_LOOKUP_TABLE) && !defined(IMATH_HALF_NO_LOOKUP_TABLE)
300 return imath_half_to_float_table[h].f;
301 #else
302 imath_half_uif_t v;
303 // this code would be clearer, although it does appear to be faster
304 // (1.06 vs 1.08 ns/call) to avoid the constants and just do 4
305 // shifts.
306 //
307 uint32_t hexpmant = ( (uint32_t)(h) << 17 ) >> 4;
308 v.i = ((uint32_t)(h >> 15)) << 31;
309
310 // the likely really does help if most of your numbers are "normal" half numbers
311 if (IMATH_LIKELY ((hexpmant >= 0x00800000)))
312 {
313 v.i |= hexpmant;
314 // either we are a normal number, in which case add in the bias difference
315 // otherwise make sure all exponent bits are set
316 if (IMATH_LIKELY ((hexpmant < 0x0f800000)))
317 v.i += 0x38000000;
318 else
319 v.i |= 0x7f800000;
320 }
321 else if (hexpmant != 0)
322 {
323 // exponent is 0 because we're denormal, don't have to extract
324 // the mantissa, can just use as is
325 //
326 //
327 // other compilers may provide count-leading-zeros primitives,
328 // but we need the community to inform us of the variants
329 uint32_t lc;
330 # if defined(_MSC_VER)
331 // The direct intrinsic for this is __lznct, but that is not supported
332 // on older x86_64 hardware or ARM. Instead uses the bsr instruction
333 // and one additional subtraction. This assumes hexpmant != 0, for 0
334 // bsr and lznct would behave differently.
335 unsigned long bsr;
336 _BitScanReverse (&bsr, hexpmant);
337 lc = (31 - bsr);
338 # elif defined(__GNUC__) || defined(__clang__)
339 lc = (uint32_t) __builtin_clz (hexpmant);
340 # else
341 lc = 0;
342 while (0 == ((hexpmant << lc) & 0x80000000))
343 ++lc;
344 # endif
345 lc -= 8;
346 // so nominally we want to remove that extra bit we shifted
347 // up, but we are going to add that bit back in, then subtract
348 // from it with the 0x38800000 - (lc << 23)....
349 //
350 // by combining, this allows us to skip the & operation (and
351 // remove a constant)
352 //
353 // hexpmant &= ~0x00800000;
354 v.i |= 0x38800000;
355 // lc is now x, where the desired exponent is then
356 // -14 - lc
357 // + 127 -> new exponent
358 v.i |= (hexpmant << lc);
359 v.i -= (lc << 23);
360 }
361 return v.f;
362 #endif
363 }
364
365 ///
366 /// Convert half to float
367 ///
368 /// Note: This only supports the "round to even" rounding mode, which
369 /// was the only mode supported by the original OpenEXR library
370 ///
371
372 static inline imath_half_bits_t
373 imath_float_to_half (float f)
374 {
375 #if defined(__F16C__)
376 # ifdef _MSC_VER
377 // msvc does not seem to have cvtsh_ss :(
378 return _mm_extract_epi16 (
379 _mm_cvtps_ph (_mm_set_ss (f), (_MM_FROUND_TO_NEAREST_INT | _MM_FROUND_NO_EXC)),
380 0);
381 # else
382 // preserve the fixed rounding mode to nearest
383 return _cvtss_sh (f, (_MM_FROUND_TO_NEAREST_INT | _MM_FROUND_NO_EXC));
384 # endif
385 #else
386 imath_half_uif_t v;
387 imath_half_bits_t ret;
388 uint32_t e, m, ui, r, shift;
389
390 v.f = f;
391
392 ui = (v.i & ~0x80000000);
393 ret = ((v.i >> 16) & 0x8000);
394
395 // exponent large enough to result in a normal number, round and return
396 if (ui >= 0x38800000)
397 {
398 // inf or nan
399 if (IMATH_UNLIKELY (ui >= 0x7f800000))
400 {
401 ret |= 0x7c00;
402 if (ui == 0x7f800000)
403 return ret;
404 m = (ui & 0x7fffff) >> 13;
405 // make sure we have at least one bit after shift to preserve nan-ness
406 return ret | (uint16_t)m | (uint16_t)(m == 0);
407 }
408
409 // too large, round to infinity
410 if (IMATH_UNLIKELY (ui > 0x477fefff))
411 {
412 # ifdef IMATH_HALF_ENABLE_FP_EXCEPTIONS
413 feraiseexcept (FE_OVERFLOW);
414 # endif
415 return ret | 0x7c00;
416 }
417
418 ui -= 0x38000000;
419 ui = ((ui + 0x00000fff + ((ui >> 13) & 1)) >> 13);
420 return ret | (uint16_t)ui;
421 }
422
423 // zero or flush to 0
424 if (ui < 0x33000001)
425 {
426 # ifdef IMATH_HALF_ENABLE_FP_EXCEPTIONS
427 if (ui == 0)
428 return ret;
429 feraiseexcept (FE_UNDERFLOW);
430 # endif
431 return ret;
432 }
433
434 // produce a denormalized half
435 e = (ui >> 23);
436 shift = 0x7e - e;
437 m = 0x800000 | (ui & 0x7fffff);
438 r = m << (32 - shift);
439 ret |= (m >> shift);
440 if (r > 0x80000000 || (r == 0x80000000 && (ret & 0x1) != 0))
441 ++ret;
442 return ret;
443 #endif
444 }
445
446 ////////////////////////////////////////
447
448 #ifdef __cplusplus
449
450 # include <iostream>
451
452 IMATH_INTERNAL_NAMESPACE_HEADER_ENTER
453
454 ///
455 ///
456 /// class half represents a 16-bit floating point number
457 ///
458 /// Type half can represent positive and negative numbers whose
459 /// magnitude is between roughly 6.1e-5 and 6.5e+4 with a relative
460 /// error of 9.8e-4; numbers smaller than 6.1e-5 can be represented
461 /// with an absolute error of 6.0e-8. All integers from -2048 to
462 /// +2048 can be represented exactly.
463 ///
464 /// Type half behaves (almost) like the built-in C++ floating point
465 /// types. In arithmetic expressions, half, float and double can be
466 /// mixed freely. Here are a few examples:
467 ///
468 /// half a (3.5);
469 /// float b (a + sqrt (a));
470 /// a += b;
471 /// b += a;
472 /// b = a + 7;
473 ///
474 /// Conversions from half to float are lossless; all half numbers
475 /// are exactly representable as floats.
476 ///
477 /// Conversions from float to half may not preserve a float's value
478 /// exactly. If a float is not representable as a half, then the
479 /// float value is rounded to the nearest representable half. If a
480 /// float value is exactly in the middle between the two closest
481 /// representable half values, then the float value is rounded to
482 /// the closest half whose least significant bit is zero.
483 ///
484 /// Overflows during float-to-half conversions cause arithmetic
485 /// exceptions. An overflow occurs when the float value to be
486 /// converted is too large to be represented as a half, or if the
487 /// float value is an infinity or a NAN.
488 ///
489 /// The implementation of type half makes the following assumptions
490 /// about the implementation of the built-in C++ types:
491 ///
492 /// * float is an IEEE 754 single-precision number
493 /// * sizeof (float) == 4
494 /// * sizeof (unsigned int) == sizeof (float)
495 /// * alignof (unsigned int) == alignof (float)
496 /// * sizeof (uint16_t) == 2
497 ///
498
499 class IMATH_EXPORT_TYPE half
500 {
501 public:
502 /// A special tag that lets us initialize a half from the raw bits.
503 enum IMATH_EXPORT_ENUM FromBitsTag
504 {
505 FromBits
506 };
507
508 /// @{
509 /// @name Constructors
510
511 /// Default construction provides no initialization (hence it is
512 /// not constexpr).
513 half() IMATH_NOEXCEPT = default;
514
515 /// Construct from float
516 half (float f) IMATH_NOEXCEPT;
517
518 /// Construct from bit-vector
519 constexpr half (FromBitsTag, uint16_t bits) IMATH_NOEXCEPT;
520
521 /// Copy constructor
522 constexpr half (const half&) IMATH_NOEXCEPT = default;
523
524 /// Move constructor
525 constexpr half (half&&) IMATH_NOEXCEPT = default;
526
527 /// Destructor
528 ~half() IMATH_NOEXCEPT = default;
529
530 /// @}
531
532 /// Conversion to float
533 operator float() const IMATH_NOEXCEPT;
534
535 /// @{
536 /// @name Basic Algebra
537
538 /// Unary minus
539 constexpr half operator-() const IMATH_NOEXCEPT;
540
541 /// Assignment
542 half& operator= (const half& h) IMATH_NOEXCEPT = default;
543
544 /// Move assignment
545 half& operator= (half&& h) IMATH_NOEXCEPT = default;
546
547 /// Assignment from float
548 half& operator= (float f) IMATH_NOEXCEPT;
549
550 /// Addition assignment
551 half& operator+= (half h) IMATH_NOEXCEPT;
552
553 /// Addition assignment from float
554 half& operator+= (float f) IMATH_NOEXCEPT;
555
556 /// Subtraction assignment
557 half& operator-= (half h) IMATH_NOEXCEPT;
558
559 /// Subtraction assignment from float
560 half& operator-= (float f) IMATH_NOEXCEPT;
561
562 /// Multiplication assignment
563 half& operator*= (half h) IMATH_NOEXCEPT;
564
565 /// Multiplication assignment from float
566 half& operator*= (float f) IMATH_NOEXCEPT;
567
568 /// Division assignment
569 half& operator/= (half h) IMATH_NOEXCEPT;
570
571 /// Division assignment from float
572 half& operator/= (float f) IMATH_NOEXCEPT;
573
574 /// @}
575
576 /// Round to n-bit precision (n should be between 0 and 10).
577 /// After rounding, the significand's 10-n least significant
578 /// bits will be zero.
579 IMATH_CONSTEXPR14 half round (unsigned int n) const IMATH_NOEXCEPT;
580
581 /// @{
582 /// @name Classification
583
584 /// Return true if a normalized number, a denormalized number, or
585 /// zero.
586 constexpr bool isFinite() const IMATH_NOEXCEPT;
587
588 /// Return true if a normalized number.
589 constexpr bool isNormalized() const IMATH_NOEXCEPT;
590
591 /// Return true if a denormalized number.
592 constexpr bool isDenormalized() const IMATH_NOEXCEPT;
593
594 /// Return true if zero.
595 constexpr bool isZero() const IMATH_NOEXCEPT;
596
597 /// Return true if NAN.
598 constexpr bool isNan() const IMATH_NOEXCEPT;
599
600 /// Return true if a positive or a negative infinity
601 constexpr bool isInfinity() const IMATH_NOEXCEPT;
602
603 /// Return true if the sign bit is set (negative)
604 constexpr bool isNegative() const IMATH_NOEXCEPT;
605
606 /// @}
607
608 /// @{
609 /// @name Special values
610
611 /// Return +infinity
612 static constexpr half posInf() IMATH_NOEXCEPT;
613
614 /// Return -infinity
615 static constexpr half negInf() IMATH_NOEXCEPT;
616
617 /// Returns a NAN with the bit pattern 0111111111111111
618 static constexpr half qNan() IMATH_NOEXCEPT;
619
620 /// Return a NAN with the bit pattern 0111110111111111
621 static constexpr half sNan() IMATH_NOEXCEPT;
622
623 /// @}
624
625 /// @{
626 /// @name Access to the internal representation
627
628 /// Return the bit pattern
629 constexpr uint16_t bits () const IMATH_NOEXCEPT;
630
631 /// Set the bit pattern
632 IMATH_CONSTEXPR14 void setBits (uint16_t bits) IMATH_NOEXCEPT;
633
634 /// @}
635
636 public:
637 static_assert (sizeof (float) == sizeof (uint32_t),
638 "Assumption about the size of floats correct");
639 using uif = imath_half_uif;
640
641 private:
642
643 constexpr uint16_t mantissa() const IMATH_NOEXCEPT;
644 constexpr uint16_t exponent() const IMATH_NOEXCEPT;
645
646 uint16_t _h;
647 };
648
649 //----------------------------
650 // Half-from-float constructor
651 //----------------------------
652
653 inline half::half (float f) IMATH_NOEXCEPT
654 : _h (imath_float_to_half (f))
655 {
656 }
657
658 //------------------------------------------
659 // Half from raw bits constructor
660 //------------------------------------------
661
662 inline constexpr half::half (FromBitsTag, uint16_t bits) IMATH_NOEXCEPT : _h (bits)
663 {}
664
665 //-------------------------
666 // Half-to-float conversion
667 //-------------------------
668
669 inline half::operator float() const IMATH_NOEXCEPT
670 {
671 return imath_half_to_float (_h);
672 }
673
674 //-------------------------
675 // Round to n-bit precision
676 //-------------------------
677
678 inline IMATH_CONSTEXPR14 half
679 half::round (unsigned int n) const IMATH_NOEXCEPT
680 {
681 //
682 // Parameter check.
683 //
684
685 if (n >= 10)
686 return *this;
687
688 //
689 // Disassemble h into the sign, s,
690 // and the combined exponent and significand, e.
691 //
692
693 uint16_t s = _h & 0x8000;
694 uint16_t e = _h & 0x7fff;
695
696 //
697 // Round the exponent and significand to the nearest value
698 // where ones occur only in the (10-n) most significant bits.
699 // Note that the exponent adjusts automatically if rounding
700 // up causes the significand to overflow.
701 //
702
703 e >>= 9 - n;
704 e += e & 1;
705 e <<= 9 - n;
706
707 //
708 // Check for exponent overflow.
709 //
710
711 if (e >= 0x7c00)
712 {
713 //
714 // Overflow occurred -- truncate instead of rounding.
715 //
716
717 e = _h;
718 e >>= 10 - n;
719 e <<= 10 - n;
720 }
721
722 //
723 // Put the original sign bit back.
724 //
725
726 half h (FromBits, s | e);
727
728 return h;
729 }
730
731 //-----------------------
732 // Other inline functions
733 //-----------------------
734
735 inline constexpr half
736 half::operator-() const IMATH_NOEXCEPT
737 {
738 return half (FromBits, bits() ^ 0x8000);
739 }
740
741 inline half&
742 half::operator= (float f) IMATH_NOEXCEPT
743 {
744 *this = half (f);
745 return *this;
746 }
747
748 inline half&
749 half::operator+= (half h) IMATH_NOEXCEPT
750 {
751 *this = half (float (*this) + float (h));
752 return *this;
753 }
754
755 inline half&
756 half::operator+= (float f) IMATH_NOEXCEPT
757 {
758 *this = half (float (*this) + f);
759 return *this;
760 }
761
762 inline half&
763 half::operator-= (half h) IMATH_NOEXCEPT
764 {
765 *this = half (float (*this) - float (h));
766 return *this;
767 }
768
769 inline half&
770 half::operator-= (float f) IMATH_NOEXCEPT
771 {
772 *this = half (float (*this) - f);
773 return *this;
774 }
775
776 inline half&
777 half::operator*= (half h) IMATH_NOEXCEPT
778 {
779 *this = half (float (*this) * float (h));
780 return *this;
781 }
782
783 inline half&
784 half::operator*= (float f) IMATH_NOEXCEPT
785 {
786 *this = half (float (*this) * f);
787 return *this;
788 }
789
790 inline half&
791 half::operator/= (half h) IMATH_NOEXCEPT
792 {
793 *this = half (float (*this) / float (h));
794 return *this;
795 }
796
797 inline half&
798 half::operator/= (float f) IMATH_NOEXCEPT
799 {
800 *this = half (float (*this) / f);
801 return *this;
802 }
803
804 inline constexpr uint16_t
805 half::mantissa() const IMATH_NOEXCEPT
806 {
807 return _h & 0x3ff;
808 }
809
810 inline constexpr uint16_t
811 half::exponent() const IMATH_NOEXCEPT
812 {
813 return (_h >> 10) & 0x001f;
814 }
815
816 inline constexpr bool
817 half::isFinite() const IMATH_NOEXCEPT
818 {
819 return exponent() < 31;
820 }
821
822 inline constexpr bool
823 half::isNormalized() const IMATH_NOEXCEPT
824 {
825 return exponent() > 0 && exponent() < 31;
826 }
827
828 inline constexpr bool
829 half::isDenormalized() const IMATH_NOEXCEPT
830 {
831 return exponent() == 0 && mantissa() != 0;
832 }
833
834 inline constexpr bool
835 half::isZero() const IMATH_NOEXCEPT
836 {
837 return (_h & 0x7fff) == 0;
838 }
839
840 inline constexpr bool
841 half::isNan() const IMATH_NOEXCEPT
842 {
843 return exponent() == 31 && mantissa() != 0;
844 }
845
846 inline constexpr bool
847 half::isInfinity() const IMATH_NOEXCEPT
848 {
849 return exponent() == 31 && mantissa() == 0;
850 }
851
852 inline constexpr bool
853 half::isNegative() const IMATH_NOEXCEPT
854 {
855 return (_h & 0x8000) != 0;
856 }
857
858 inline constexpr half
859 half::posInf() IMATH_NOEXCEPT
860 {
861 return half (FromBits, 0x7c00);
862 }
863
864 inline constexpr half
865 half::negInf() IMATH_NOEXCEPT
866 {
867 return half (FromBits, 0xfc00);
868 }
869
870 inline constexpr half
871 half::qNan() IMATH_NOEXCEPT
872 {
873 return half (FromBits, 0x7fff);
874 }
875
876 inline constexpr half
877 half::sNan() IMATH_NOEXCEPT
878 {
879 return half (FromBits, 0x7dff);
880 }
881
882 inline constexpr uint16_t
883 half::bits() const IMATH_NOEXCEPT
884 {
885 return _h;
886 }
887
888 inline IMATH_CONSTEXPR14 void
889 half::setBits (uint16_t bits) IMATH_NOEXCEPT
890 {
891 _h = bits;
892 }
893
894 IMATH_INTERNAL_NAMESPACE_HEADER_EXIT
895
896 /// Output h to os, formatted as a float
897 IMATH_EXPORT std::ostream& operator<< (std::ostream& os, IMATH_INTERNAL_NAMESPACE::half h);
898
899 /// Input h from is
900 IMATH_EXPORT std::istream& operator>> (std::istream& is, IMATH_INTERNAL_NAMESPACE::half& h);
901
902 #include <limits>
903
904 namespace std
905 {
906
907 template <> class numeric_limits<IMATH_INTERNAL_NAMESPACE::half>
908 {
909 public:
910 static const bool is_specialized = true;
911
912 static constexpr IMATH_INTERNAL_NAMESPACE::half min () IMATH_NOEXCEPT
913 {
914 return IMATH_INTERNAL_NAMESPACE::half (IMATH_INTERNAL_NAMESPACE::half::FromBits, 0x0400); /*HALF_MIN*/
915 }
916 static constexpr IMATH_INTERNAL_NAMESPACE::half max () IMATH_NOEXCEPT
917 {
918 return IMATH_INTERNAL_NAMESPACE::half (IMATH_INTERNAL_NAMESPACE::half::FromBits, 0x7bff); /*HALF_MAX*/
919 }
920 static constexpr IMATH_INTERNAL_NAMESPACE::half lowest ()
921 {
922 return IMATH_INTERNAL_NAMESPACE::half (IMATH_INTERNAL_NAMESPACE::half::FromBits, 0xfbff); /* -HALF_MAX */
923 }
924
925 static constexpr int digits = HALF_MANT_DIG;
926 static constexpr int digits10 = HALF_DIG;
927 static constexpr int max_digits10 = HALF_DECIMAL_DIG;
928 static constexpr bool is_signed = true;
929 static constexpr bool is_integer = false;
930 static constexpr bool is_exact = false;
931 static constexpr int radix = HALF_RADIX;
932 static constexpr IMATH_INTERNAL_NAMESPACE::half epsilon () IMATH_NOEXCEPT
933 {
934 return IMATH_INTERNAL_NAMESPACE::half (IMATH_INTERNAL_NAMESPACE::half::FromBits, 0x1400); /*HALF_EPSILON*/
935 }
936 static constexpr IMATH_INTERNAL_NAMESPACE::half round_error () IMATH_NOEXCEPT
937 {
938 return IMATH_INTERNAL_NAMESPACE::half (IMATH_INTERNAL_NAMESPACE::half::FromBits, 0x3800); /*0.5*/
939 }
940
941 static constexpr int min_exponent = HALF_DENORM_MIN_EXP;
942 static constexpr int min_exponent10 = HALF_DENORM_MIN_10_EXP;
943 static constexpr int max_exponent = HALF_MAX_EXP;
944 static constexpr int max_exponent10 = HALF_MAX_10_EXP;
945
946 static constexpr bool has_infinity = true;
947 static constexpr bool has_quiet_NaN = true;
948 static constexpr bool has_signaling_NaN = true;
949 static constexpr float_denorm_style has_denorm = denorm_present;
950 static constexpr bool has_denorm_loss = false;
951 static constexpr IMATH_INTERNAL_NAMESPACE::half infinity () IMATH_NOEXCEPT
952 {
953 return IMATH_INTERNAL_NAMESPACE::half (IMATH_INTERNAL_NAMESPACE::half::FromBits, 0x7c00); /*half::posInf()*/
954 }
955 static constexpr IMATH_INTERNAL_NAMESPACE::half quiet_NaN () IMATH_NOEXCEPT
956 {
957 return IMATH_INTERNAL_NAMESPACE::half (IMATH_INTERNAL_NAMESPACE::half::FromBits, 0x7fff); /*half::qNan()*/
958 }
959 static constexpr IMATH_INTERNAL_NAMESPACE::half signaling_NaN () IMATH_NOEXCEPT
960 {
961 return IMATH_INTERNAL_NAMESPACE::half (IMATH_INTERNAL_NAMESPACE::half::FromBits, 0x7dff); /*half::sNan()*/
962 }
963 static constexpr IMATH_INTERNAL_NAMESPACE::half denorm_min () IMATH_NOEXCEPT
964 {
965 return IMATH_INTERNAL_NAMESPACE::half (IMATH_INTERNAL_NAMESPACE::half::FromBits, 0x0001); /*HALF_DENORM_MIN*/
966 }
967
968 static constexpr bool is_iec559 = false;
969 static constexpr bool is_bounded = false;
970 static constexpr bool is_modulo = false;
971
972 static constexpr bool traps = true;
973 static constexpr bool tinyness_before = false;
974 static constexpr float_round_style round_style = round_to_nearest;
975 };
976
977 } // namespace std
978
979 //----------
980 // Debugging
981 //----------
982
983 IMATH_EXPORT void printBits (std::ostream& os, IMATH_INTERNAL_NAMESPACE::half h);
984 IMATH_EXPORT void printBits (std::ostream& os, float f);
985 IMATH_EXPORT void printBits (char c[19], IMATH_INTERNAL_NAMESPACE::half h);
986 IMATH_EXPORT void printBits (char c[35], float f);
987
988 #if !defined(__CUDACC__) && !defined(__CUDA_FP16_HPP__) && !defined(__HIP__)
989 using half = IMATH_INTERNAL_NAMESPACE::half;
990 #elif defined(__CUDACC__) || defined(__CUDA_FP16_HPP__)
991 #include <cuda_fp16.h>
992 #elif defined(__HIP__)
993 #include <hip/amd_detail/amd_hip_fp16.h>
994 #endif
995
996 #endif // __cplusplus
997
998 #endif // IMATH_HALF_H_