Simulant  21.12-194
A portable game engine for Windows, OSX, Linux, Dreamcast, and PSP
half.hpp
Go to the documentation of this file.
1 // half - IEEE 754-based half-precision floating point library.
2 //
3 // Copyright (c) 2012-2013 Christian Rau <rauy@users.sourceforge.net>
4 //
5 // Permission is hereby granted, free of charge, to any person obtaining a copy of this software and associated documentation
6 // files (the "Software"), to deal in the Software without restriction, including without limitation the rights to use, copy,
7 // modify, merge, publish, distribute, sublicense, and/or sell copies of the Software, and to permit persons to whom the
8 // Software is furnished to do so, subject to the following conditions:
9 //
10 // The above copyright notice and this permission notice shall be included in all copies or substantial portions of the Software.
11 //
12 // THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE
13 // WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR
14 // COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE,
15 // ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
16 
17 // Version 1.11.0
18 
21 
22 #ifndef HALF_HALF_HPP
23 #define HALF_HALF_HPP
24 
26 #define HALF_GNUC_VERSION (__GNUC__*100+__GNUC_MINOR__)
27 
28 //check C++11 language features
29 #if defined(__clang__) //clang
30  #if __has_feature(cxx_static_assert) && !defined(HALF_ENABLE_CPP11_STATIC_ASSERT)
31  #define HALF_ENABLE_CPP11_STATIC_ASSERT 1
32  #endif
33  #if __has_feature(cxx_constexpr) && !defined(HALF_ENABLE_CPP11_CONSTEXPR)
34  #define HALF_ENABLE_CPP11_CONSTEXPR 1
35  #endif
36  #if __has_feature(cxx_noexcept) && !defined(HALF_ENABLE_CPP11_NOEXCEPT)
37  #define HALF_ENABLE_CPP11_NOEXCEPT 1
38  #endif
39  #if __has_feature(cxx_user_literals) && !defined(HALF_ENABLE_CPP11_USER_LITERALS)
40  #define HALF_ENABLE_CPP11_USER_LITERALS 1
41  #endif
42  #if (defined(__GXX_EXPERIMENTAL_CXX0X__) || __cplusplus >= 201103L) && !defined(HALF_ENABLE_CPP11_LONG_LONG)
43  #define HALF_ENABLE_CPP11_LONG_LONG 1
44  #endif
45 /*#elif defined(__INTEL_COMPILER) //Intel C++
46  #if __INTEL_COMPILER >= 1100 && !defined(HALF_ENABLE_CPP11_STATIC_ASSERT) ????????
47  #define HALF_ENABLE_CPP11_STATIC_ASSERT 1
48  #endif
49  #if __INTEL_COMPILER >= 1300 && !defined(HALF_ENABLE_CPP11_CONSTEXPR) ????????
50  #define HALF_ENABLE_CPP11_CONSTEXPR 1
51  #endif
52  #if __INTEL_COMPILER >= 1300 && !defined(HALF_ENABLE_CPP11_NOEXCEPT) ????????
53  #define HALF_ENABLE_CPP11_NOEXCEPT 1
54  #endif
55  #if __INTEL_COMPILER >= 1100 && !defined(HALF_ENABLE_CPP11_LONG_LONG) ????????
56  #define HALF_ENABLE_CPP11_LONG_LONG 1
57  #endif*/
58 #elif defined(__GNUC__) //gcc
59  #if defined(__GXX_EXPERIMENTAL_CXX0X__) || __cplusplus >= 201103L
60  #if HALF_GNUC_VERSION >= 403 && !defined(HALF_ENABLE_CPP11_STATIC_ASSERT)
61  #define HALF_ENABLE_CPP11_STATIC_ASSERT 1
62  #endif
63  #if HALF_GNUC_VERSION >= 406 && !defined(HALF_ENABLE_CPP11_CONSTEXPR)
64  #define HALF_ENABLE_CPP11_CONSTEXPR 1
65  #endif
66  #if HALF_GNUC_VERSION >= 406 && !defined(HALF_ENABLE_CPP11_NOEXCEPT)
67  #define HALF_ENABLE_CPP11_NOEXCEPT 1
68  #endif
69  #if HALF_GNUC_VERSION >= 407 && !defined(HALF_ENABLE_CPP11_USER_LITERALS)
70  #define HALF_ENABLE_CPP11_USER_LITERALS 1
71  #endif
72  #if !defined(HALF_ENABLE_CPP11_LONG_LONG)
73  #define HALF_ENABLE_CPP11_LONG_LONG 1
74  #endif
75  #endif
76 #elif defined(_MSC_VER) //Visual C++
77  #if _MSC_VER >= 1600 && !defined(HALF_ENABLE_CPP11_STATIC_ASSERT)
78  #define HALF_ENABLE_CPP11_STATIC_ASSERT 1
79  #endif
80  #if _MSC_VER >= 1310 && !defined(HALF_ENABLE_CPP11_LONG_LONG)
81  #define HALF_ENABLE_CPP11_LONG_LONG 1
82  #endif
83  #define HALF_POP_WARNINGS 1
84  #pragma warning(push)
85  #pragma warning(disable : 4099 4127 4146) //struct vs class, constant in if, negative unsigned
86 #endif
87 
88 //check C++11 library features
89 #include <utility>
90 #if defined(_LIBCPP_VERSION) //libc++
91  #if defined(__GXX_EXPERIMENTAL_CXX0X__) || __cplusplus >= 201103
92  #ifndef HALF_ENABLE_CPP11_TYPE_TRAITS
93  #define HALF_ENABLE_CPP11_TYPE_TRAITS 1
94  #endif
95  #ifndef HALF_ENABLE_CPP11_CSTDINT
96  #define HALF_ENABLE_CPP11_CSTDINT 1
97  #endif
98  #ifndef HALF_ENABLE_CPP11_CMATH
99  #define HALF_ENABLE_CPP11_CMATH 1
100  #endif
101  #ifndef HALF_ENABLE_CPP11_HASH
102  #define HALF_ENABLE_CPP11_HASH 1
103  #endif
104  #endif
105 #elif defined(__GLIBCXX__) //libstdc++
106  #if defined(__GXX_EXPERIMENTAL_CXX0X__) || __cplusplus >= 201103
107  #ifdef __clang__
108  #if __GLIBCXX__ >= 20080606 && !defined(HALF_ENABLE_CPP11_TYPE_TRAITS)
109  #define HALF_ENABLE_CPP11_TYPE_TRAITS 1
110  #endif
111  #if __GLIBCXX__ >= 20080606 && !defined(HALF_ENABLE_CPP11_CSTDINT)
112  #define HALF_ENABLE_CPP11_CSTDINT 1
113  #endif
114  #if __GLIBCXX__ >= 20080606 && !defined(HALF_ENABLE_CPP11_CMATH)
115  #define HALF_ENABLE_CPP11_CMATH 1
116  #endif
117  #if __GLIBCXX__ >= 20080606 && !defined(HALF_ENABLE_CPP11_HASH)
118  #define HALF_ENABLE_CPP11_HASH 1
119  #endif
120  #else
121  #if HALF_GNUC_VERSION >= 403 && !defined(HALF_ENABLE_CPP11_CSTDINT)
122  #define HALF_ENABLE_CPP11_CSTDINT 1
123  #endif
124  #if HALF_GNUC_VERSION >= 403 && !defined(HALF_ENABLE_CPP11_CMATH)
125  #define HALF_ENABLE_CPP11_CMATH 1
126  #endif
127  #if HALF_GNUC_VERSION >= 403 && !defined(HALF_ENABLE_CPP11_HASH)
128  #define HALF_ENABLE_CPP11_HASH 1
129  #endif
130  #endif
131  #endif
132 #elif defined(_CPPLIB_VER) //Dinkumware/Visual C++
133  #if _CPPLIB_VER >= 520
134  #ifndef HALF_ENABLE_CPP11_TYPE_TRAITS
135  #define HALF_ENABLE_CPP11_TYPE_TRAITS 1
136  #endif
137  #ifndef HALF_ENABLE_CPP11_CSTDINT
138  #define HALF_ENABLE_CPP11_CSTDINT 1
139  #endif
140  #ifndef HALF_ENABLE_CPP11_HASH
141  #define HALF_ENABLE_CPP11_HASH 1
142  #endif
143  #endif
144  #if _CPPLIB_VER >= 610
145  #ifndef HALF_ENABLE_CPP11_CMATH
146  #define HALF_ENABLE_CPP11_CMATH 1
147  #endif
148  #endif
149 #endif
150 #undef HALF_GNUC_VERSION
151 
152 
153 #if defined(__DREAMCAST__) || defined(__PSP__)
154  #undef HALF_ENABLE_CPP11_CMATH
155  #define HALF_ENABLE_CPP11_CMATH 0
156 #endif
157 
158 
159 //support constexpr
160 #if HALF_ENABLE_CPP11_CONSTEXPR
161  #define HALF_CONSTEXPR constexpr
162  #define HALF_CONSTEXPR_CONST constexpr
163 #else
164  #define HALF_CONSTEXPR
165  #define HALF_CONSTEXPR_CONST const
166 #endif
167 
168 //support noexcept
169 #if HALF_ENABLE_CPP11_NOEXCEPT
170  #define HALF_NOEXCEPT noexcept
171  #define HALF_NOTHROW noexcept
172 #else
173  #define HALF_NOEXCEPT
174  #define HALF_NOTHROW throw()
175 #endif
176 
177 #include <algorithm>
178 #include <iostream>
179 #include <limits>
180 #include <climits>
181 #include <cmath>
182 #include <cstring>
183 #if HALF_ENABLE_CPP11_TYPE_TRAITS
184  #include <type_traits>
185 #endif
186 #if HALF_ENABLE_CPP11_CSTDINT
187  #include <cstdint>
188 #endif
189 #if HALF_ENABLE_CPP11_HASH
190  #include <functional>
191 #endif
192 
193 
210 #ifndef HALF_ROUND_STYLE
211  #define HALF_ROUND_STYLE -1 // = std::round_indeterminate
212 #endif
213 
219 #ifndef HALF_ROUND_TIES_TO_EVEN
220  #define HALF_ROUND_TIES_TO_EVEN 0 // ties away from zero
221 #endif
222 
226 #define HUGE_VALH std::numeric_limits<half_float::half>::infinity()
227 
232 #define FP_FAST_FMAH 1
233 
234 #ifndef FP_ILOGB0
235  #define FP_ILOGB0 INT_MIN
236 #endif
237 #ifndef FP_ILOGBNAN
238  #define FP_ILOGBNAN INT_MAX
239 #endif
240 #ifndef FP_SUBNORMAL
241  #define FP_SUBNORMAL 0
242 #endif
243 #ifndef FP_ZERO
244  #define FP_ZERO 1
245 #endif
246 #ifndef FP_NAN
247  #define FP_NAN 2
248 #endif
249 #ifndef FP_INFINITE
250  #define FP_INFINITE 3
251 #endif
252 #ifndef FP_NORMAL
253  #define FP_NORMAL 4
254 #endif
255 
256 
259 namespace half_float
260 {
261  class half;
262 
265  namespace detail
266  {
267  #if HALF_ENABLE_CPP11_TYPE_TRAITS
268  template<bool B,typename T,typename F> struct conditional : std::conditional<B,T,F> {};
270 
272  template<bool B> struct bool_type : std::integral_constant<bool,B> {};
273  using std::true_type;
274  using std::false_type;
275 
277  template<typename T> struct is_float : std::is_floating_point<T> {};
278  #else
279  template<bool,typename T,typename> struct conditional { typedef T type; };
281  template<typename T,typename F> struct conditional<false,T,F> { typedef F type; };
282 
284  template<bool> struct bool_type {};
285  typedef bool_type<true> true_type;
287 
289  template<typename> struct is_float : false_type {};
290  template<typename T> struct is_float<const T> : is_float<T> {};
291  template<typename T> struct is_float<volatile T> : is_float<T> {};
292  template<typename T> struct is_float<const volatile T> : is_float<T> {};
293  template<> struct is_float<float> : true_type {};
294  template<> struct is_float<double> : true_type {};
295  template<> struct is_float<long double> : true_type {};
296  #endif
297 
298  #if HALF_ENABLE_CPP11_CSTDINT
299  typedef std::uint_least16_t uint16;
301 
303  typedef std::uint_least32_t uint32;
304 
306  typedef std::int_fast32_t int17;
307  #else
308  typedef unsigned short uint16;
310 
312  typedef conditional<std::numeric_limits<unsigned int>::digits>=32,unsigned int,unsigned long>::type uint32;
313 
315  typedef conditional<std::numeric_limits<int>::digits>=16,int,long>::type int17;
316  #endif
317 
319  struct binary_t {};
320 
322  HALF_CONSTEXPR_CONST binary_t binary = binary_t();
323 
326  struct expr
327  {
330  explicit HALF_CONSTEXPR expr(float f) : value_(f) {}
331 
334  HALF_CONSTEXPR operator float() const { return value_; }
335 
336  private:
338  float value_;
339  };
340 
345  template<typename T,typename,typename=void,typename=void> struct enable {};
346  template<typename T> struct enable<T,half,void,void> { typedef T type; };
347  template<typename T> struct enable<T,expr,void,void> { typedef T type; };
348  template<typename T> struct enable<T,half,half,void> { typedef T type; };
349  template<typename T> struct enable<T,half,expr,void> { typedef T type; };
350  template<typename T> struct enable<T,expr,half,void> { typedef T type; };
351  template<typename T> struct enable<T,expr,expr,void> { typedef T type; };
352  template<typename T> struct enable<T,half,half,half> { typedef T type; };
353  template<typename T> struct enable<T,half,half,expr> { typedef T type; };
354  template<typename T> struct enable<T,half,expr,half> { typedef T type; };
355  template<typename T> struct enable<T,half,expr,expr> { typedef T type; };
356  template<typename T> struct enable<T,expr,half,half> { typedef T type; };
357  template<typename T> struct enable<T,expr,half,expr> { typedef T type; };
358  template<typename T> struct enable<T,expr,expr,half> { typedef T type; };
359  template<typename T> struct enable<T,expr,expr,expr> { typedef T type; };
360 
366  template<typename T,typename U> struct result : enable<expr,T,U> {};
367  template<> struct result<half,half> { typedef half type; };
368 
371 
377  template<typename T> bool builtin_isinf(T arg)
378  {
379  #if HALF_ENABLE_CPP11_CMATH
380  return std::isinf(arg);
381  #elif defined(_MSC_VER)
382  return !_finite(static_cast<double>(arg)) && !_isnan(static_cast<double>(arg));
383  #else
384  return arg == std::numeric_limits<T>::infinity() || arg == -std::numeric_limits<T>::infinity();
385  #endif
386  }
387 
393  template<typename T> bool builtin_isnan(T arg)
394  {
395  #if HALF_ENABLE_CPP11_CMATH
396  return std::isnan(arg);
397  #elif defined(_MSC_VER)
398  return _isnan(static_cast<double>(arg)) != 0;
399  #else
400  return arg != arg;
401  #endif
402  }
403 
409  template<typename T> bool builtin_signbit(T arg)
410  {
411  #if HALF_ENABLE_CPP11_CMATH
412  return std::signbit(arg);
413  #else
414  return arg < T() || (arg == T() && T(1)/arg < T());
415  #endif
416  }
417 
421 
427  template<std::float_round_style R> uint16 float2half_impl(float value, true_type)
428  {
429  #if HALF_ENABLE_CPP11_STATIC_ASSERT
430  static_assert(std::numeric_limits<float>::is_iec559, "float to half conversion needs IEEE 754 conformant 'float' type");
431  static_assert(sizeof(uint32)==sizeof(float), "float to half conversion needs unsigned integer type of exactly the size of a 'float'");
432  #endif
433  static const uint16 base_table[512] = {
434  0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000,
435  0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000,
436  0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000,
437  0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000,
438  0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000,
439  0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000,
440  0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0001, 0x0002, 0x0004, 0x0008, 0x0010, 0x0020, 0x0040, 0x0080, 0x0100,
441  0x0200, 0x0400, 0x0800, 0x0C00, 0x1000, 0x1400, 0x1800, 0x1C00, 0x2000, 0x2400, 0x2800, 0x2C00, 0x3000, 0x3400, 0x3800, 0x3C00,
442  0x4000, 0x4400, 0x4800, 0x4C00, 0x5000, 0x5400, 0x5800, 0x5C00, 0x6000, 0x6400, 0x6800, 0x6C00, 0x7000, 0x7400, 0x7800, 0x7C00,
443  0x7C00, 0x7C00, 0x7C00, 0x7C00, 0x7C00, 0x7C00, 0x7C00, 0x7C00, 0x7C00, 0x7C00, 0x7C00, 0x7C00, 0x7C00, 0x7C00, 0x7C00, 0x7C00,
444  0x7C00, 0x7C00, 0x7C00, 0x7C00, 0x7C00, 0x7C00, 0x7C00, 0x7C00, 0x7C00, 0x7C00, 0x7C00, 0x7C00, 0x7C00, 0x7C00, 0x7C00, 0x7C00,
445  0x7C00, 0x7C00, 0x7C00, 0x7C00, 0x7C00, 0x7C00, 0x7C00, 0x7C00, 0x7C00, 0x7C00, 0x7C00, 0x7C00, 0x7C00, 0x7C00, 0x7C00, 0x7C00,
446  0x7C00, 0x7C00, 0x7C00, 0x7C00, 0x7C00, 0x7C00, 0x7C00, 0x7C00, 0x7C00, 0x7C00, 0x7C00, 0x7C00, 0x7C00, 0x7C00, 0x7C00, 0x7C00,
447  0x7C00, 0x7C00, 0x7C00, 0x7C00, 0x7C00, 0x7C00, 0x7C00, 0x7C00, 0x7C00, 0x7C00, 0x7C00, 0x7C00, 0x7C00, 0x7C00, 0x7C00, 0x7C00,
448  0x7C00, 0x7C00, 0x7C00, 0x7C00, 0x7C00, 0x7C00, 0x7C00, 0x7C00, 0x7C00, 0x7C00, 0x7C00, 0x7C00, 0x7C00, 0x7C00, 0x7C00, 0x7C00,
449  0x7C00, 0x7C00, 0x7C00, 0x7C00, 0x7C00, 0x7C00, 0x7C00, 0x7C00, 0x7C00, 0x7C00, 0x7C00, 0x7C00, 0x7C00, 0x7C00, 0x7C00, 0x7C00,
450  0x8000, 0x8000, 0x8000, 0x8000, 0x8000, 0x8000, 0x8000, 0x8000, 0x8000, 0x8000, 0x8000, 0x8000, 0x8000, 0x8000, 0x8000, 0x8000,
451  0x8000, 0x8000, 0x8000, 0x8000, 0x8000, 0x8000, 0x8000, 0x8000, 0x8000, 0x8000, 0x8000, 0x8000, 0x8000, 0x8000, 0x8000, 0x8000,
452  0x8000, 0x8000, 0x8000, 0x8000, 0x8000, 0x8000, 0x8000, 0x8000, 0x8000, 0x8000, 0x8000, 0x8000, 0x8000, 0x8000, 0x8000, 0x8000,
453  0x8000, 0x8000, 0x8000, 0x8000, 0x8000, 0x8000, 0x8000, 0x8000, 0x8000, 0x8000, 0x8000, 0x8000, 0x8000, 0x8000, 0x8000, 0x8000,
454  0x8000, 0x8000, 0x8000, 0x8000, 0x8000, 0x8000, 0x8000, 0x8000, 0x8000, 0x8000, 0x8000, 0x8000, 0x8000, 0x8000, 0x8000, 0x8000,
455  0x8000, 0x8000, 0x8000, 0x8000, 0x8000, 0x8000, 0x8000, 0x8000, 0x8000, 0x8000, 0x8000, 0x8000, 0x8000, 0x8000, 0x8000, 0x8000,
456  0x8000, 0x8000, 0x8000, 0x8000, 0x8000, 0x8000, 0x8000, 0x8001, 0x8002, 0x8004, 0x8008, 0x8010, 0x8020, 0x8040, 0x8080, 0x8100,
457  0x8200, 0x8400, 0x8800, 0x8C00, 0x9000, 0x9400, 0x9800, 0x9C00, 0xA000, 0xA400, 0xA800, 0xAC00, 0xB000, 0xB400, 0xB800, 0xBC00,
458  0xC000, 0xC400, 0xC800, 0xCC00, 0xD000, 0xD400, 0xD800, 0xDC00, 0xE000, 0xE400, 0xE800, 0xEC00, 0xF000, 0xF400, 0xF800, 0xFC00,
459  0xFC00, 0xFC00, 0xFC00, 0xFC00, 0xFC00, 0xFC00, 0xFC00, 0xFC00, 0xFC00, 0xFC00, 0xFC00, 0xFC00, 0xFC00, 0xFC00, 0xFC00, 0xFC00,
460  0xFC00, 0xFC00, 0xFC00, 0xFC00, 0xFC00, 0xFC00, 0xFC00, 0xFC00, 0xFC00, 0xFC00, 0xFC00, 0xFC00, 0xFC00, 0xFC00, 0xFC00, 0xFC00,
461  0xFC00, 0xFC00, 0xFC00, 0xFC00, 0xFC00, 0xFC00, 0xFC00, 0xFC00, 0xFC00, 0xFC00, 0xFC00, 0xFC00, 0xFC00, 0xFC00, 0xFC00, 0xFC00,
462  0xFC00, 0xFC00, 0xFC00, 0xFC00, 0xFC00, 0xFC00, 0xFC00, 0xFC00, 0xFC00, 0xFC00, 0xFC00, 0xFC00, 0xFC00, 0xFC00, 0xFC00, 0xFC00,
463  0xFC00, 0xFC00, 0xFC00, 0xFC00, 0xFC00, 0xFC00, 0xFC00, 0xFC00, 0xFC00, 0xFC00, 0xFC00, 0xFC00, 0xFC00, 0xFC00, 0xFC00, 0xFC00,
464  0xFC00, 0xFC00, 0xFC00, 0xFC00, 0xFC00, 0xFC00, 0xFC00, 0xFC00, 0xFC00, 0xFC00, 0xFC00, 0xFC00, 0xFC00, 0xFC00, 0xFC00, 0xFC00,
465  0xFC00, 0xFC00, 0xFC00, 0xFC00, 0xFC00, 0xFC00, 0xFC00, 0xFC00, 0xFC00, 0xFC00, 0xFC00, 0xFC00, 0xFC00, 0xFC00, 0xFC00, 0xFC00 };
466  static const unsigned char shift_table[512] = {
467  24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24,
468  24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24,
469  24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24,
470  24, 24, 24, 24, 24, 24, 24, 23, 22, 21, 20, 19, 18, 17, 16, 15, 14, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13,
471  13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24,
472  24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24,
473  24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24,
474  24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 13,
475  24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24,
476  24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24,
477  24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24,
478  24, 24, 24, 24, 24, 24, 24, 23, 22, 21, 20, 19, 18, 17, 16, 15, 14, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13,
479  13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24,
480  24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24,
481  24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24,
482  24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 13 };
483  uint32 bits;// = *reinterpret_cast<uint32*>(&value); //violating strict aliasing!
484  std::memcpy(&bits, &value, sizeof(float));
485  uint16 hbits = base_table[bits>>23] + static_cast<uint16>((bits&0x7FFFFF)>>shift_table[bits>>23]);
486  if(R == std::round_to_nearest)
487  hbits += (((bits&0x7FFFFF)>>(shift_table[bits>>23]-1))|(((bits>>23)&0xFF)==102)) & ((hbits&0x7C00)!=0x7C00)
489  & (((((static_cast<uint32>(1)<<(shift_table[bits>>23]-1))-1)&bits)!=0)|hbits)
490  #endif
491  ;
492  else if(R == std::round_toward_zero)
493  hbits -= ((hbits&0x7FFF)==0x7C00) & ~shift_table[bits>>23];
494  else if(R == std::round_toward_infinity)
495  hbits += ((((bits&0x7FFFFF&((static_cast<uint32>(1)<<(shift_table[bits>>23]))-1))!=0)|(((bits>>23)<=102)&
496  ((bits>>23)!=0)))&(hbits<0x7C00)) - ((hbits==0xFC00)&((bits>>23)!=511));
497  else if(R == std::round_toward_neg_infinity)
498  hbits += ((((bits&0x7FFFFF&((static_cast<uint32>(1)<<(shift_table[bits>>23]))-1))!=0)|(((bits>>23)<=358)&
499  ((bits>>23)!=256)))&(hbits<0xFC00)&(hbits>>15)) - ((hbits==0x7C00)&((bits>>23)!=255));
500  return hbits;
501  }
502 
506  template<std::float_round_style R> uint16 float2half_impl(float value, false_type)
507  {
508  uint16 hbits = builtin_signbit(value) << 15;
509  if(value == 0.0f)
510  return hbits;
511  if(builtin_isnan(value))
512  return hbits | 0x7FFF;
513  if(builtin_isinf(value))
514  return hbits | 0x7C00;
515  int exp;
516  std::frexp(value, &exp);
517  if(exp > 16)
518  {
519  if(R == std::round_toward_zero)
520  return hbits | 0x7BFF;
521  else if(R == std::round_toward_infinity)
522  return hbits | 0x7C00 - (hbits>>15);
523  else if(R == std::round_toward_neg_infinity)
524  return hbits | 0x7BFF + (hbits>>15);
525  return hbits | 0x7C00;
526  }
527  if(exp < -13)
528  value = std::ldexp(value, 24);
529  else
530  {
531  value = std::ldexp(value, 11-exp);
532  hbits |= ((exp+14)<<10);
533  }
534  int ival = static_cast<int>(value);
535  hbits |= static_cast<uint16>(std::abs(ival)&0x3FF);
536  if(R == std::round_to_nearest)
537  {
538  float diff = std::abs(value-static_cast<float>(ival));
539  #if HALF_ROUND_TIES_TO_EVEN
540  hbits += (diff>0.5f) | ((diff==0.5f)&hbits);
541  #else
542  hbits += diff >= 0.5f;
543  #endif
544  }
545  else if(R == std::round_toward_infinity)
546  hbits += value > static_cast<float>(ival);
547  else if(R == std::round_toward_neg_infinity)
548  hbits += value < static_cast<float>(ival);
549  return hbits;
550  }
551 
555  template<std::float_round_style R> uint16 float2half(float value)
556  {
557  return float2half_impl<R>(value, bool_type<std::numeric_limits<float>::is_iec559&&sizeof(uint32)==sizeof(float)>());
558  }
559 
566  template<std::float_round_style R,bool S,typename T> uint16 int2half_impl(T value)
567  {
568  if(S)
569  value = -value;
570  uint16 bits = S << 15;
571  if(value > 65504)
572  {
573  if(R == std::round_toward_infinity)
574  bits |= 0x7C00 - S;
575  else if(R == std::round_toward_neg_infinity)
576  bits |= 0x7BFF + S;
577  else
578  bits |= 0x7BFF + (R!=std::round_toward_zero);
579  }
580  else if(value)
581  {
582  unsigned int m = value, exp = 25;
583  for(; m<0x400; m<<=1,--exp) ;
584  for(; m>0x7FF; m>>=1,++exp) ;
585  bits |= (exp<<10) | (m&0x3FF);
586  if(exp > 25)
587  {
588  if(R == std::round_to_nearest)
589  bits += (value>>(exp-26)) & 1
590  #if HALF_ROUND_TIES_TO_EVEN
591  & (((((1<<(exp-26))-1)&value)!=0)|bits)
592  #endif
593  ;
594  else if(R == std::round_toward_infinity)
595  bits += ((value&((1<<(exp-25))-1))!=0) & !S;
596  else if(R == std::round_toward_neg_infinity)
597  bits += ((value&((1<<(exp-25))-1))!=0) & S;
598  }
599  }
600  return bits;
601  }
602 
608  template<std::float_round_style R,typename T> uint16 int2half(T value)
609  {
610  return (value<0) ? int2half_impl<R,true>(value) : int2half_impl<R,false>(value);
611  }
612 
617  inline float half2float_impl(uint16 value, true_type)
618  {
619  #if HALF_ENABLE_CPP11_STATIC_ASSERT
620  static_assert(std::numeric_limits<float>::is_iec559, "half to float conversion needs IEEE 754 conformant 'float' type");
621  static_assert(sizeof(uint32)==sizeof(float), "half to float conversion needs unsigned integer type of exactly the size of a 'float'");
622  #endif
623  static const uint32 mantissa_table[2048] = {
624  0x00000000, 0x33800000, 0x34000000, 0x34400000, 0x34800000, 0x34A00000, 0x34C00000, 0x34E00000, 0x35000000, 0x35100000, 0x35200000, 0x35300000, 0x35400000, 0x35500000, 0x35600000, 0x35700000,
625  0x35800000, 0x35880000, 0x35900000, 0x35980000, 0x35A00000, 0x35A80000, 0x35B00000, 0x35B80000, 0x35C00000, 0x35C80000, 0x35D00000, 0x35D80000, 0x35E00000, 0x35E80000, 0x35F00000, 0x35F80000,
626  0x36000000, 0x36040000, 0x36080000, 0x360C0000, 0x36100000, 0x36140000, 0x36180000, 0x361C0000, 0x36200000, 0x36240000, 0x36280000, 0x362C0000, 0x36300000, 0x36340000, 0x36380000, 0x363C0000,
627  0x36400000, 0x36440000, 0x36480000, 0x364C0000, 0x36500000, 0x36540000, 0x36580000, 0x365C0000, 0x36600000, 0x36640000, 0x36680000, 0x366C0000, 0x36700000, 0x36740000, 0x36780000, 0x367C0000,
628  0x36800000, 0x36820000, 0x36840000, 0x36860000, 0x36880000, 0x368A0000, 0x368C0000, 0x368E0000, 0x36900000, 0x36920000, 0x36940000, 0x36960000, 0x36980000, 0x369A0000, 0x369C0000, 0x369E0000,
629  0x36A00000, 0x36A20000, 0x36A40000, 0x36A60000, 0x36A80000, 0x36AA0000, 0x36AC0000, 0x36AE0000, 0x36B00000, 0x36B20000, 0x36B40000, 0x36B60000, 0x36B80000, 0x36BA0000, 0x36BC0000, 0x36BE0000,
630  0x36C00000, 0x36C20000, 0x36C40000, 0x36C60000, 0x36C80000, 0x36CA0000, 0x36CC0000, 0x36CE0000, 0x36D00000, 0x36D20000, 0x36D40000, 0x36D60000, 0x36D80000, 0x36DA0000, 0x36DC0000, 0x36DE0000,
631  0x36E00000, 0x36E20000, 0x36E40000, 0x36E60000, 0x36E80000, 0x36EA0000, 0x36EC0000, 0x36EE0000, 0x36F00000, 0x36F20000, 0x36F40000, 0x36F60000, 0x36F80000, 0x36FA0000, 0x36FC0000, 0x36FE0000,
632  0x37000000, 0x37010000, 0x37020000, 0x37030000, 0x37040000, 0x37050000, 0x37060000, 0x37070000, 0x37080000, 0x37090000, 0x370A0000, 0x370B0000, 0x370C0000, 0x370D0000, 0x370E0000, 0x370F0000,
633  0x37100000, 0x37110000, 0x37120000, 0x37130000, 0x37140000, 0x37150000, 0x37160000, 0x37170000, 0x37180000, 0x37190000, 0x371A0000, 0x371B0000, 0x371C0000, 0x371D0000, 0x371E0000, 0x371F0000,
634  0x37200000, 0x37210000, 0x37220000, 0x37230000, 0x37240000, 0x37250000, 0x37260000, 0x37270000, 0x37280000, 0x37290000, 0x372A0000, 0x372B0000, 0x372C0000, 0x372D0000, 0x372E0000, 0x372F0000,
635  0x37300000, 0x37310000, 0x37320000, 0x37330000, 0x37340000, 0x37350000, 0x37360000, 0x37370000, 0x37380000, 0x37390000, 0x373A0000, 0x373B0000, 0x373C0000, 0x373D0000, 0x373E0000, 0x373F0000,
636  0x37400000, 0x37410000, 0x37420000, 0x37430000, 0x37440000, 0x37450000, 0x37460000, 0x37470000, 0x37480000, 0x37490000, 0x374A0000, 0x374B0000, 0x374C0000, 0x374D0000, 0x374E0000, 0x374F0000,
637  0x37500000, 0x37510000, 0x37520000, 0x37530000, 0x37540000, 0x37550000, 0x37560000, 0x37570000, 0x37580000, 0x37590000, 0x375A0000, 0x375B0000, 0x375C0000, 0x375D0000, 0x375E0000, 0x375F0000,
638  0x37600000, 0x37610000, 0x37620000, 0x37630000, 0x37640000, 0x37650000, 0x37660000, 0x37670000, 0x37680000, 0x37690000, 0x376A0000, 0x376B0000, 0x376C0000, 0x376D0000, 0x376E0000, 0x376F0000,
639  0x37700000, 0x37710000, 0x37720000, 0x37730000, 0x37740000, 0x37750000, 0x37760000, 0x37770000, 0x37780000, 0x37790000, 0x377A0000, 0x377B0000, 0x377C0000, 0x377D0000, 0x377E0000, 0x377F0000,
640  0x37800000, 0x37808000, 0x37810000, 0x37818000, 0x37820000, 0x37828000, 0x37830000, 0x37838000, 0x37840000, 0x37848000, 0x37850000, 0x37858000, 0x37860000, 0x37868000, 0x37870000, 0x37878000,
641  0x37880000, 0x37888000, 0x37890000, 0x37898000, 0x378A0000, 0x378A8000, 0x378B0000, 0x378B8000, 0x378C0000, 0x378C8000, 0x378D0000, 0x378D8000, 0x378E0000, 0x378E8000, 0x378F0000, 0x378F8000,
642  0x37900000, 0x37908000, 0x37910000, 0x37918000, 0x37920000, 0x37928000, 0x37930000, 0x37938000, 0x37940000, 0x37948000, 0x37950000, 0x37958000, 0x37960000, 0x37968000, 0x37970000, 0x37978000,
643  0x37980000, 0x37988000, 0x37990000, 0x37998000, 0x379A0000, 0x379A8000, 0x379B0000, 0x379B8000, 0x379C0000, 0x379C8000, 0x379D0000, 0x379D8000, 0x379E0000, 0x379E8000, 0x379F0000, 0x379F8000,
644  0x37A00000, 0x37A08000, 0x37A10000, 0x37A18000, 0x37A20000, 0x37A28000, 0x37A30000, 0x37A38000, 0x37A40000, 0x37A48000, 0x37A50000, 0x37A58000, 0x37A60000, 0x37A68000, 0x37A70000, 0x37A78000,
645  0x37A80000, 0x37A88000, 0x37A90000, 0x37A98000, 0x37AA0000, 0x37AA8000, 0x37AB0000, 0x37AB8000, 0x37AC0000, 0x37AC8000, 0x37AD0000, 0x37AD8000, 0x37AE0000, 0x37AE8000, 0x37AF0000, 0x37AF8000,
646  0x37B00000, 0x37B08000, 0x37B10000, 0x37B18000, 0x37B20000, 0x37B28000, 0x37B30000, 0x37B38000, 0x37B40000, 0x37B48000, 0x37B50000, 0x37B58000, 0x37B60000, 0x37B68000, 0x37B70000, 0x37B78000,
647  0x37B80000, 0x37B88000, 0x37B90000, 0x37B98000, 0x37BA0000, 0x37BA8000, 0x37BB0000, 0x37BB8000, 0x37BC0000, 0x37BC8000, 0x37BD0000, 0x37BD8000, 0x37BE0000, 0x37BE8000, 0x37BF0000, 0x37BF8000,
648  0x37C00000, 0x37C08000, 0x37C10000, 0x37C18000, 0x37C20000, 0x37C28000, 0x37C30000, 0x37C38000, 0x37C40000, 0x37C48000, 0x37C50000, 0x37C58000, 0x37C60000, 0x37C68000, 0x37C70000, 0x37C78000,
649  0x37C80000, 0x37C88000, 0x37C90000, 0x37C98000, 0x37CA0000, 0x37CA8000, 0x37CB0000, 0x37CB8000, 0x37CC0000, 0x37CC8000, 0x37CD0000, 0x37CD8000, 0x37CE0000, 0x37CE8000, 0x37CF0000, 0x37CF8000,
650  0x37D00000, 0x37D08000, 0x37D10000, 0x37D18000, 0x37D20000, 0x37D28000, 0x37D30000, 0x37D38000, 0x37D40000, 0x37D48000, 0x37D50000, 0x37D58000, 0x37D60000, 0x37D68000, 0x37D70000, 0x37D78000,
651  0x37D80000, 0x37D88000, 0x37D90000, 0x37D98000, 0x37DA0000, 0x37DA8000, 0x37DB0000, 0x37DB8000, 0x37DC0000, 0x37DC8000, 0x37DD0000, 0x37DD8000, 0x37DE0000, 0x37DE8000, 0x37DF0000, 0x37DF8000,
652  0x37E00000, 0x37E08000, 0x37E10000, 0x37E18000, 0x37E20000, 0x37E28000, 0x37E30000, 0x37E38000, 0x37E40000, 0x37E48000, 0x37E50000, 0x37E58000, 0x37E60000, 0x37E68000, 0x37E70000, 0x37E78000,
653  0x37E80000, 0x37E88000, 0x37E90000, 0x37E98000, 0x37EA0000, 0x37EA8000, 0x37EB0000, 0x37EB8000, 0x37EC0000, 0x37EC8000, 0x37ED0000, 0x37ED8000, 0x37EE0000, 0x37EE8000, 0x37EF0000, 0x37EF8000,
654  0x37F00000, 0x37F08000, 0x37F10000, 0x37F18000, 0x37F20000, 0x37F28000, 0x37F30000, 0x37F38000, 0x37F40000, 0x37F48000, 0x37F50000, 0x37F58000, 0x37F60000, 0x37F68000, 0x37F70000, 0x37F78000,
655  0x37F80000, 0x37F88000, 0x37F90000, 0x37F98000, 0x37FA0000, 0x37FA8000, 0x37FB0000, 0x37FB8000, 0x37FC0000, 0x37FC8000, 0x37FD0000, 0x37FD8000, 0x37FE0000, 0x37FE8000, 0x37FF0000, 0x37FF8000,
656  0x38000000, 0x38004000, 0x38008000, 0x3800C000, 0x38010000, 0x38014000, 0x38018000, 0x3801C000, 0x38020000, 0x38024000, 0x38028000, 0x3802C000, 0x38030000, 0x38034000, 0x38038000, 0x3803C000,
657  0x38040000, 0x38044000, 0x38048000, 0x3804C000, 0x38050000, 0x38054000, 0x38058000, 0x3805C000, 0x38060000, 0x38064000, 0x38068000, 0x3806C000, 0x38070000, 0x38074000, 0x38078000, 0x3807C000,
658  0x38080000, 0x38084000, 0x38088000, 0x3808C000, 0x38090000, 0x38094000, 0x38098000, 0x3809C000, 0x380A0000, 0x380A4000, 0x380A8000, 0x380AC000, 0x380B0000, 0x380B4000, 0x380B8000, 0x380BC000,
659  0x380C0000, 0x380C4000, 0x380C8000, 0x380CC000, 0x380D0000, 0x380D4000, 0x380D8000, 0x380DC000, 0x380E0000, 0x380E4000, 0x380E8000, 0x380EC000, 0x380F0000, 0x380F4000, 0x380F8000, 0x380FC000,
660  0x38100000, 0x38104000, 0x38108000, 0x3810C000, 0x38110000, 0x38114000, 0x38118000, 0x3811C000, 0x38120000, 0x38124000, 0x38128000, 0x3812C000, 0x38130000, 0x38134000, 0x38138000, 0x3813C000,
661  0x38140000, 0x38144000, 0x38148000, 0x3814C000, 0x38150000, 0x38154000, 0x38158000, 0x3815C000, 0x38160000, 0x38164000, 0x38168000, 0x3816C000, 0x38170000, 0x38174000, 0x38178000, 0x3817C000,
662  0x38180000, 0x38184000, 0x38188000, 0x3818C000, 0x38190000, 0x38194000, 0x38198000, 0x3819C000, 0x381A0000, 0x381A4000, 0x381A8000, 0x381AC000, 0x381B0000, 0x381B4000, 0x381B8000, 0x381BC000,
663  0x381C0000, 0x381C4000, 0x381C8000, 0x381CC000, 0x381D0000, 0x381D4000, 0x381D8000, 0x381DC000, 0x381E0000, 0x381E4000, 0x381E8000, 0x381EC000, 0x381F0000, 0x381F4000, 0x381F8000, 0x381FC000,
664  0x38200000, 0x38204000, 0x38208000, 0x3820C000, 0x38210000, 0x38214000, 0x38218000, 0x3821C000, 0x38220000, 0x38224000, 0x38228000, 0x3822C000, 0x38230000, 0x38234000, 0x38238000, 0x3823C000,
665  0x38240000, 0x38244000, 0x38248000, 0x3824C000, 0x38250000, 0x38254000, 0x38258000, 0x3825C000, 0x38260000, 0x38264000, 0x38268000, 0x3826C000, 0x38270000, 0x38274000, 0x38278000, 0x3827C000,
666  0x38280000, 0x38284000, 0x38288000, 0x3828C000, 0x38290000, 0x38294000, 0x38298000, 0x3829C000, 0x382A0000, 0x382A4000, 0x382A8000, 0x382AC000, 0x382B0000, 0x382B4000, 0x382B8000, 0x382BC000,
667  0x382C0000, 0x382C4000, 0x382C8000, 0x382CC000, 0x382D0000, 0x382D4000, 0x382D8000, 0x382DC000, 0x382E0000, 0x382E4000, 0x382E8000, 0x382EC000, 0x382F0000, 0x382F4000, 0x382F8000, 0x382FC000,
668  0x38300000, 0x38304000, 0x38308000, 0x3830C000, 0x38310000, 0x38314000, 0x38318000, 0x3831C000, 0x38320000, 0x38324000, 0x38328000, 0x3832C000, 0x38330000, 0x38334000, 0x38338000, 0x3833C000,
669  0x38340000, 0x38344000, 0x38348000, 0x3834C000, 0x38350000, 0x38354000, 0x38358000, 0x3835C000, 0x38360000, 0x38364000, 0x38368000, 0x3836C000, 0x38370000, 0x38374000, 0x38378000, 0x3837C000,
670  0x38380000, 0x38384000, 0x38388000, 0x3838C000, 0x38390000, 0x38394000, 0x38398000, 0x3839C000, 0x383A0000, 0x383A4000, 0x383A8000, 0x383AC000, 0x383B0000, 0x383B4000, 0x383B8000, 0x383BC000,
671  0x383C0000, 0x383C4000, 0x383C8000, 0x383CC000, 0x383D0000, 0x383D4000, 0x383D8000, 0x383DC000, 0x383E0000, 0x383E4000, 0x383E8000, 0x383EC000, 0x383F0000, 0x383F4000, 0x383F8000, 0x383FC000,
672  0x38400000, 0x38404000, 0x38408000, 0x3840C000, 0x38410000, 0x38414000, 0x38418000, 0x3841C000, 0x38420000, 0x38424000, 0x38428000, 0x3842C000, 0x38430000, 0x38434000, 0x38438000, 0x3843C000,
673  0x38440000, 0x38444000, 0x38448000, 0x3844C000, 0x38450000, 0x38454000, 0x38458000, 0x3845C000, 0x38460000, 0x38464000, 0x38468000, 0x3846C000, 0x38470000, 0x38474000, 0x38478000, 0x3847C000,
674  0x38480000, 0x38484000, 0x38488000, 0x3848C000, 0x38490000, 0x38494000, 0x38498000, 0x3849C000, 0x384A0000, 0x384A4000, 0x384A8000, 0x384AC000, 0x384B0000, 0x384B4000, 0x384B8000, 0x384BC000,
675  0x384C0000, 0x384C4000, 0x384C8000, 0x384CC000, 0x384D0000, 0x384D4000, 0x384D8000, 0x384DC000, 0x384E0000, 0x384E4000, 0x384E8000, 0x384EC000, 0x384F0000, 0x384F4000, 0x384F8000, 0x384FC000,
676  0x38500000, 0x38504000, 0x38508000, 0x3850C000, 0x38510000, 0x38514000, 0x38518000, 0x3851C000, 0x38520000, 0x38524000, 0x38528000, 0x3852C000, 0x38530000, 0x38534000, 0x38538000, 0x3853C000,
677  0x38540000, 0x38544000, 0x38548000, 0x3854C000, 0x38550000, 0x38554000, 0x38558000, 0x3855C000, 0x38560000, 0x38564000, 0x38568000, 0x3856C000, 0x38570000, 0x38574000, 0x38578000, 0x3857C000,
678  0x38580000, 0x38584000, 0x38588000, 0x3858C000, 0x38590000, 0x38594000, 0x38598000, 0x3859C000, 0x385A0000, 0x385A4000, 0x385A8000, 0x385AC000, 0x385B0000, 0x385B4000, 0x385B8000, 0x385BC000,
679  0x385C0000, 0x385C4000, 0x385C8000, 0x385CC000, 0x385D0000, 0x385D4000, 0x385D8000, 0x385DC000, 0x385E0000, 0x385E4000, 0x385E8000, 0x385EC000, 0x385F0000, 0x385F4000, 0x385F8000, 0x385FC000,
680  0x38600000, 0x38604000, 0x38608000, 0x3860C000, 0x38610000, 0x38614000, 0x38618000, 0x3861C000, 0x38620000, 0x38624000, 0x38628000, 0x3862C000, 0x38630000, 0x38634000, 0x38638000, 0x3863C000,
681  0x38640000, 0x38644000, 0x38648000, 0x3864C000, 0x38650000, 0x38654000, 0x38658000, 0x3865C000, 0x38660000, 0x38664000, 0x38668000, 0x3866C000, 0x38670000, 0x38674000, 0x38678000, 0x3867C000,
682  0x38680000, 0x38684000, 0x38688000, 0x3868C000, 0x38690000, 0x38694000, 0x38698000, 0x3869C000, 0x386A0000, 0x386A4000, 0x386A8000, 0x386AC000, 0x386B0000, 0x386B4000, 0x386B8000, 0x386BC000,
683  0x386C0000, 0x386C4000, 0x386C8000, 0x386CC000, 0x386D0000, 0x386D4000, 0x386D8000, 0x386DC000, 0x386E0000, 0x386E4000, 0x386E8000, 0x386EC000, 0x386F0000, 0x386F4000, 0x386F8000, 0x386FC000,
684  0x38700000, 0x38704000, 0x38708000, 0x3870C000, 0x38710000, 0x38714000, 0x38718000, 0x3871C000, 0x38720000, 0x38724000, 0x38728000, 0x3872C000, 0x38730000, 0x38734000, 0x38738000, 0x3873C000,
685  0x38740000, 0x38744000, 0x38748000, 0x3874C000, 0x38750000, 0x38754000, 0x38758000, 0x3875C000, 0x38760000, 0x38764000, 0x38768000, 0x3876C000, 0x38770000, 0x38774000, 0x38778000, 0x3877C000,
686  0x38780000, 0x38784000, 0x38788000, 0x3878C000, 0x38790000, 0x38794000, 0x38798000, 0x3879C000, 0x387A0000, 0x387A4000, 0x387A8000, 0x387AC000, 0x387B0000, 0x387B4000, 0x387B8000, 0x387BC000,
687  0x387C0000, 0x387C4000, 0x387C8000, 0x387CC000, 0x387D0000, 0x387D4000, 0x387D8000, 0x387DC000, 0x387E0000, 0x387E4000, 0x387E8000, 0x387EC000, 0x387F0000, 0x387F4000, 0x387F8000, 0x387FC000,
688  0x38000000, 0x38002000, 0x38004000, 0x38006000, 0x38008000, 0x3800A000, 0x3800C000, 0x3800E000, 0x38010000, 0x38012000, 0x38014000, 0x38016000, 0x38018000, 0x3801A000, 0x3801C000, 0x3801E000,
689  0x38020000, 0x38022000, 0x38024000, 0x38026000, 0x38028000, 0x3802A000, 0x3802C000, 0x3802E000, 0x38030000, 0x38032000, 0x38034000, 0x38036000, 0x38038000, 0x3803A000, 0x3803C000, 0x3803E000,
690  0x38040000, 0x38042000, 0x38044000, 0x38046000, 0x38048000, 0x3804A000, 0x3804C000, 0x3804E000, 0x38050000, 0x38052000, 0x38054000, 0x38056000, 0x38058000, 0x3805A000, 0x3805C000, 0x3805E000,
691  0x38060000, 0x38062000, 0x38064000, 0x38066000, 0x38068000, 0x3806A000, 0x3806C000, 0x3806E000, 0x38070000, 0x38072000, 0x38074000, 0x38076000, 0x38078000, 0x3807A000, 0x3807C000, 0x3807E000,
692  0x38080000, 0x38082000, 0x38084000, 0x38086000, 0x38088000, 0x3808A000, 0x3808C000, 0x3808E000, 0x38090000, 0x38092000, 0x38094000, 0x38096000, 0x38098000, 0x3809A000, 0x3809C000, 0x3809E000,
693  0x380A0000, 0x380A2000, 0x380A4000, 0x380A6000, 0x380A8000, 0x380AA000, 0x380AC000, 0x380AE000, 0x380B0000, 0x380B2000, 0x380B4000, 0x380B6000, 0x380B8000, 0x380BA000, 0x380BC000, 0x380BE000,
694  0x380C0000, 0x380C2000, 0x380C4000, 0x380C6000, 0x380C8000, 0x380CA000, 0x380CC000, 0x380CE000, 0x380D0000, 0x380D2000, 0x380D4000, 0x380D6000, 0x380D8000, 0x380DA000, 0x380DC000, 0x380DE000,
695  0x380E0000, 0x380E2000, 0x380E4000, 0x380E6000, 0x380E8000, 0x380EA000, 0x380EC000, 0x380EE000, 0x380F0000, 0x380F2000, 0x380F4000, 0x380F6000, 0x380F8000, 0x380FA000, 0x380FC000, 0x380FE000,
696  0x38100000, 0x38102000, 0x38104000, 0x38106000, 0x38108000, 0x3810A000, 0x3810C000, 0x3810E000, 0x38110000, 0x38112000, 0x38114000, 0x38116000, 0x38118000, 0x3811A000, 0x3811C000, 0x3811E000,
697  0x38120000, 0x38122000, 0x38124000, 0x38126000, 0x38128000, 0x3812A000, 0x3812C000, 0x3812E000, 0x38130000, 0x38132000, 0x38134000, 0x38136000, 0x38138000, 0x3813A000, 0x3813C000, 0x3813E000,
698  0x38140000, 0x38142000, 0x38144000, 0x38146000, 0x38148000, 0x3814A000, 0x3814C000, 0x3814E000, 0x38150000, 0x38152000, 0x38154000, 0x38156000, 0x38158000, 0x3815A000, 0x3815C000, 0x3815E000,
699  0x38160000, 0x38162000, 0x38164000, 0x38166000, 0x38168000, 0x3816A000, 0x3816C000, 0x3816E000, 0x38170000, 0x38172000, 0x38174000, 0x38176000, 0x38178000, 0x3817A000, 0x3817C000, 0x3817E000,
700  0x38180000, 0x38182000, 0x38184000, 0x38186000, 0x38188000, 0x3818A000, 0x3818C000, 0x3818E000, 0x38190000, 0x38192000, 0x38194000, 0x38196000, 0x38198000, 0x3819A000, 0x3819C000, 0x3819E000,
701  0x381A0000, 0x381A2000, 0x381A4000, 0x381A6000, 0x381A8000, 0x381AA000, 0x381AC000, 0x381AE000, 0x381B0000, 0x381B2000, 0x381B4000, 0x381B6000, 0x381B8000, 0x381BA000, 0x381BC000, 0x381BE000,
702  0x381C0000, 0x381C2000, 0x381C4000, 0x381C6000, 0x381C8000, 0x381CA000, 0x381CC000, 0x381CE000, 0x381D0000, 0x381D2000, 0x381D4000, 0x381D6000, 0x381D8000, 0x381DA000, 0x381DC000, 0x381DE000,
703  0x381E0000, 0x381E2000, 0x381E4000, 0x381E6000, 0x381E8000, 0x381EA000, 0x381EC000, 0x381EE000, 0x381F0000, 0x381F2000, 0x381F4000, 0x381F6000, 0x381F8000, 0x381FA000, 0x381FC000, 0x381FE000,
704  0x38200000, 0x38202000, 0x38204000, 0x38206000, 0x38208000, 0x3820A000, 0x3820C000, 0x3820E000, 0x38210000, 0x38212000, 0x38214000, 0x38216000, 0x38218000, 0x3821A000, 0x3821C000, 0x3821E000,
705  0x38220000, 0x38222000, 0x38224000, 0x38226000, 0x38228000, 0x3822A000, 0x3822C000, 0x3822E000, 0x38230000, 0x38232000, 0x38234000, 0x38236000, 0x38238000, 0x3823A000, 0x3823C000, 0x3823E000,
706  0x38240000, 0x38242000, 0x38244000, 0x38246000, 0x38248000, 0x3824A000, 0x3824C000, 0x3824E000, 0x38250000, 0x38252000, 0x38254000, 0x38256000, 0x38258000, 0x3825A000, 0x3825C000, 0x3825E000,
707  0x38260000, 0x38262000, 0x38264000, 0x38266000, 0x38268000, 0x3826A000, 0x3826C000, 0x3826E000, 0x38270000, 0x38272000, 0x38274000, 0x38276000, 0x38278000, 0x3827A000, 0x3827C000, 0x3827E000,
708  0x38280000, 0x38282000, 0x38284000, 0x38286000, 0x38288000, 0x3828A000, 0x3828C000, 0x3828E000, 0x38290000, 0x38292000, 0x38294000, 0x38296000, 0x38298000, 0x3829A000, 0x3829C000, 0x3829E000,
709  0x382A0000, 0x382A2000, 0x382A4000, 0x382A6000, 0x382A8000, 0x382AA000, 0x382AC000, 0x382AE000, 0x382B0000, 0x382B2000, 0x382B4000, 0x382B6000, 0x382B8000, 0x382BA000, 0x382BC000, 0x382BE000,
710  0x382C0000, 0x382C2000, 0x382C4000, 0x382C6000, 0x382C8000, 0x382CA000, 0x382CC000, 0x382CE000, 0x382D0000, 0x382D2000, 0x382D4000, 0x382D6000, 0x382D8000, 0x382DA000, 0x382DC000, 0x382DE000,
711  0x382E0000, 0x382E2000, 0x382E4000, 0x382E6000, 0x382E8000, 0x382EA000, 0x382EC000, 0x382EE000, 0x382F0000, 0x382F2000, 0x382F4000, 0x382F6000, 0x382F8000, 0x382FA000, 0x382FC000, 0x382FE000,
712  0x38300000, 0x38302000, 0x38304000, 0x38306000, 0x38308000, 0x3830A000, 0x3830C000, 0x3830E000, 0x38310000, 0x38312000, 0x38314000, 0x38316000, 0x38318000, 0x3831A000, 0x3831C000, 0x3831E000,
713  0x38320000, 0x38322000, 0x38324000, 0x38326000, 0x38328000, 0x3832A000, 0x3832C000, 0x3832E000, 0x38330000, 0x38332000, 0x38334000, 0x38336000, 0x38338000, 0x3833A000, 0x3833C000, 0x3833E000,
714  0x38340000, 0x38342000, 0x38344000, 0x38346000, 0x38348000, 0x3834A000, 0x3834C000, 0x3834E000, 0x38350000, 0x38352000, 0x38354000, 0x38356000, 0x38358000, 0x3835A000, 0x3835C000, 0x3835E000,
715  0x38360000, 0x38362000, 0x38364000, 0x38366000, 0x38368000, 0x3836A000, 0x3836C000, 0x3836E000, 0x38370000, 0x38372000, 0x38374000, 0x38376000, 0x38378000, 0x3837A000, 0x3837C000, 0x3837E000,
716  0x38380000, 0x38382000, 0x38384000, 0x38386000, 0x38388000, 0x3838A000, 0x3838C000, 0x3838E000, 0x38390000, 0x38392000, 0x38394000, 0x38396000, 0x38398000, 0x3839A000, 0x3839C000, 0x3839E000,
717  0x383A0000, 0x383A2000, 0x383A4000, 0x383A6000, 0x383A8000, 0x383AA000, 0x383AC000, 0x383AE000, 0x383B0000, 0x383B2000, 0x383B4000, 0x383B6000, 0x383B8000, 0x383BA000, 0x383BC000, 0x383BE000,
718  0x383C0000, 0x383C2000, 0x383C4000, 0x383C6000, 0x383C8000, 0x383CA000, 0x383CC000, 0x383CE000, 0x383D0000, 0x383D2000, 0x383D4000, 0x383D6000, 0x383D8000, 0x383DA000, 0x383DC000, 0x383DE000,
719  0x383E0000, 0x383E2000, 0x383E4000, 0x383E6000, 0x383E8000, 0x383EA000, 0x383EC000, 0x383EE000, 0x383F0000, 0x383F2000, 0x383F4000, 0x383F6000, 0x383F8000, 0x383FA000, 0x383FC000, 0x383FE000,
720  0x38400000, 0x38402000, 0x38404000, 0x38406000, 0x38408000, 0x3840A000, 0x3840C000, 0x3840E000, 0x38410000, 0x38412000, 0x38414000, 0x38416000, 0x38418000, 0x3841A000, 0x3841C000, 0x3841E000,
721  0x38420000, 0x38422000, 0x38424000, 0x38426000, 0x38428000, 0x3842A000, 0x3842C000, 0x3842E000, 0x38430000, 0x38432000, 0x38434000, 0x38436000, 0x38438000, 0x3843A000, 0x3843C000, 0x3843E000,
722  0x38440000, 0x38442000, 0x38444000, 0x38446000, 0x38448000, 0x3844A000, 0x3844C000, 0x3844E000, 0x38450000, 0x38452000, 0x38454000, 0x38456000, 0x38458000, 0x3845A000, 0x3845C000, 0x3845E000,
723  0x38460000, 0x38462000, 0x38464000, 0x38466000, 0x38468000, 0x3846A000, 0x3846C000, 0x3846E000, 0x38470000, 0x38472000, 0x38474000, 0x38476000, 0x38478000, 0x3847A000, 0x3847C000, 0x3847E000,
724  0x38480000, 0x38482000, 0x38484000, 0x38486000, 0x38488000, 0x3848A000, 0x3848C000, 0x3848E000, 0x38490000, 0x38492000, 0x38494000, 0x38496000, 0x38498000, 0x3849A000, 0x3849C000, 0x3849E000,
725  0x384A0000, 0x384A2000, 0x384A4000, 0x384A6000, 0x384A8000, 0x384AA000, 0x384AC000, 0x384AE000, 0x384B0000, 0x384B2000, 0x384B4000, 0x384B6000, 0x384B8000, 0x384BA000, 0x384BC000, 0x384BE000,
726  0x384C0000, 0x384C2000, 0x384C4000, 0x384C6000, 0x384C8000, 0x384CA000, 0x384CC000, 0x384CE000, 0x384D0000, 0x384D2000, 0x384D4000, 0x384D6000, 0x384D8000, 0x384DA000, 0x384DC000, 0x384DE000,
727  0x384E0000, 0x384E2000, 0x384E4000, 0x384E6000, 0x384E8000, 0x384EA000, 0x384EC000, 0x384EE000, 0x384F0000, 0x384F2000, 0x384F4000, 0x384F6000, 0x384F8000, 0x384FA000, 0x384FC000, 0x384FE000,
728  0x38500000, 0x38502000, 0x38504000, 0x38506000, 0x38508000, 0x3850A000, 0x3850C000, 0x3850E000, 0x38510000, 0x38512000, 0x38514000, 0x38516000, 0x38518000, 0x3851A000, 0x3851C000, 0x3851E000,
729  0x38520000, 0x38522000, 0x38524000, 0x38526000, 0x38528000, 0x3852A000, 0x3852C000, 0x3852E000, 0x38530000, 0x38532000, 0x38534000, 0x38536000, 0x38538000, 0x3853A000, 0x3853C000, 0x3853E000,
730  0x38540000, 0x38542000, 0x38544000, 0x38546000, 0x38548000, 0x3854A000, 0x3854C000, 0x3854E000, 0x38550000, 0x38552000, 0x38554000, 0x38556000, 0x38558000, 0x3855A000, 0x3855C000, 0x3855E000,
731  0x38560000, 0x38562000, 0x38564000, 0x38566000, 0x38568000, 0x3856A000, 0x3856C000, 0x3856E000, 0x38570000, 0x38572000, 0x38574000, 0x38576000, 0x38578000, 0x3857A000, 0x3857C000, 0x3857E000,
732  0x38580000, 0x38582000, 0x38584000, 0x38586000, 0x38588000, 0x3858A000, 0x3858C000, 0x3858E000, 0x38590000, 0x38592000, 0x38594000, 0x38596000, 0x38598000, 0x3859A000, 0x3859C000, 0x3859E000,
733  0x385A0000, 0x385A2000, 0x385A4000, 0x385A6000, 0x385A8000, 0x385AA000, 0x385AC000, 0x385AE000, 0x385B0000, 0x385B2000, 0x385B4000, 0x385B6000, 0x385B8000, 0x385BA000, 0x385BC000, 0x385BE000,
734  0x385C0000, 0x385C2000, 0x385C4000, 0x385C6000, 0x385C8000, 0x385CA000, 0x385CC000, 0x385CE000, 0x385D0000, 0x385D2000, 0x385D4000, 0x385D6000, 0x385D8000, 0x385DA000, 0x385DC000, 0x385DE000,
735  0x385E0000, 0x385E2000, 0x385E4000, 0x385E6000, 0x385E8000, 0x385EA000, 0x385EC000, 0x385EE000, 0x385F0000, 0x385F2000, 0x385F4000, 0x385F6000, 0x385F8000, 0x385FA000, 0x385FC000, 0x385FE000,
736  0x38600000, 0x38602000, 0x38604000, 0x38606000, 0x38608000, 0x3860A000, 0x3860C000, 0x3860E000, 0x38610000, 0x38612000, 0x38614000, 0x38616000, 0x38618000, 0x3861A000, 0x3861C000, 0x3861E000,
737  0x38620000, 0x38622000, 0x38624000, 0x38626000, 0x38628000, 0x3862A000, 0x3862C000, 0x3862E000, 0x38630000, 0x38632000, 0x38634000, 0x38636000, 0x38638000, 0x3863A000, 0x3863C000, 0x3863E000,
738  0x38640000, 0x38642000, 0x38644000, 0x38646000, 0x38648000, 0x3864A000, 0x3864C000, 0x3864E000, 0x38650000, 0x38652000, 0x38654000, 0x38656000, 0x38658000, 0x3865A000, 0x3865C000, 0x3865E000,
739  0x38660000, 0x38662000, 0x38664000, 0x38666000, 0x38668000, 0x3866A000, 0x3866C000, 0x3866E000, 0x38670000, 0x38672000, 0x38674000, 0x38676000, 0x38678000, 0x3867A000, 0x3867C000, 0x3867E000,
740  0x38680000, 0x38682000, 0x38684000, 0x38686000, 0x38688000, 0x3868A000, 0x3868C000, 0x3868E000, 0x38690000, 0x38692000, 0x38694000, 0x38696000, 0x38698000, 0x3869A000, 0x3869C000, 0x3869E000,
741  0x386A0000, 0x386A2000, 0x386A4000, 0x386A6000, 0x386A8000, 0x386AA000, 0x386AC000, 0x386AE000, 0x386B0000, 0x386B2000, 0x386B4000, 0x386B6000, 0x386B8000, 0x386BA000, 0x386BC000, 0x386BE000,
742  0x386C0000, 0x386C2000, 0x386C4000, 0x386C6000, 0x386C8000, 0x386CA000, 0x386CC000, 0x386CE000, 0x386D0000, 0x386D2000, 0x386D4000, 0x386D6000, 0x386D8000, 0x386DA000, 0x386DC000, 0x386DE000,
743  0x386E0000, 0x386E2000, 0x386E4000, 0x386E6000, 0x386E8000, 0x386EA000, 0x386EC000, 0x386EE000, 0x386F0000, 0x386F2000, 0x386F4000, 0x386F6000, 0x386F8000, 0x386FA000, 0x386FC000, 0x386FE000,
744  0x38700000, 0x38702000, 0x38704000, 0x38706000, 0x38708000, 0x3870A000, 0x3870C000, 0x3870E000, 0x38710000, 0x38712000, 0x38714000, 0x38716000, 0x38718000, 0x3871A000, 0x3871C000, 0x3871E000,
745  0x38720000, 0x38722000, 0x38724000, 0x38726000, 0x38728000, 0x3872A000, 0x3872C000, 0x3872E000, 0x38730000, 0x38732000, 0x38734000, 0x38736000, 0x38738000, 0x3873A000, 0x3873C000, 0x3873E000,
746  0x38740000, 0x38742000, 0x38744000, 0x38746000, 0x38748000, 0x3874A000, 0x3874C000, 0x3874E000, 0x38750000, 0x38752000, 0x38754000, 0x38756000, 0x38758000, 0x3875A000, 0x3875C000, 0x3875E000,
747  0x38760000, 0x38762000, 0x38764000, 0x38766000, 0x38768000, 0x3876A000, 0x3876C000, 0x3876E000, 0x38770000, 0x38772000, 0x38774000, 0x38776000, 0x38778000, 0x3877A000, 0x3877C000, 0x3877E000,
748  0x38780000, 0x38782000, 0x38784000, 0x38786000, 0x38788000, 0x3878A000, 0x3878C000, 0x3878E000, 0x38790000, 0x38792000, 0x38794000, 0x38796000, 0x38798000, 0x3879A000, 0x3879C000, 0x3879E000,
749  0x387A0000, 0x387A2000, 0x387A4000, 0x387A6000, 0x387A8000, 0x387AA000, 0x387AC000, 0x387AE000, 0x387B0000, 0x387B2000, 0x387B4000, 0x387B6000, 0x387B8000, 0x387BA000, 0x387BC000, 0x387BE000,
750  0x387C0000, 0x387C2000, 0x387C4000, 0x387C6000, 0x387C8000, 0x387CA000, 0x387CC000, 0x387CE000, 0x387D0000, 0x387D2000, 0x387D4000, 0x387D6000, 0x387D8000, 0x387DA000, 0x387DC000, 0x387DE000,
751  0x387E0000, 0x387E2000, 0x387E4000, 0x387E6000, 0x387E8000, 0x387EA000, 0x387EC000, 0x387EE000, 0x387F0000, 0x387F2000, 0x387F4000, 0x387F6000, 0x387F8000, 0x387FA000, 0x387FC000, 0x387FE000 };
752  static const uint32 exponent_table[64] = {
753  0x00000000, 0x00800000, 0x01000000, 0x01800000, 0x02000000, 0x02800000, 0x03000000, 0x03800000, 0x04000000, 0x04800000, 0x05000000, 0x05800000, 0x06000000, 0x06800000, 0x07000000, 0x07800000,
754  0x08000000, 0x08800000, 0x09000000, 0x09800000, 0x0A000000, 0x0A800000, 0x0B000000, 0x0B800000, 0x0C000000, 0x0C800000, 0x0D000000, 0x0D800000, 0x0E000000, 0x0E800000, 0x0F000000, 0x47800000,
755  0x80000000, 0x80800000, 0x81000000, 0x81800000, 0x82000000, 0x82800000, 0x83000000, 0x83800000, 0x84000000, 0x84800000, 0x85000000, 0x85800000, 0x86000000, 0x86800000, 0x87000000, 0x87800000,
756  0x88000000, 0x88800000, 0x89000000, 0x89800000, 0x8A000000, 0x8A800000, 0x8B000000, 0x8B800000, 0x8C000000, 0x8C800000, 0x8D000000, 0x8D800000, 0x8E000000, 0x8E800000, 0x8F000000, 0xC7800000 };
757  static const unsigned short offset_table[64] = {
758  0, 1024, 1024, 1024, 1024, 1024, 1024, 1024, 1024, 1024, 1024, 1024, 1024, 1024, 1024, 1024, 1024, 1024, 1024, 1024, 1024, 1024, 1024, 1024, 1024, 1024, 1024, 1024, 1024, 1024, 1024, 1024,
759  0, 1024, 1024, 1024, 1024, 1024, 1024, 1024, 1024, 1024, 1024, 1024, 1024, 1024, 1024, 1024, 1024, 1024, 1024, 1024, 1024, 1024, 1024, 1024, 1024, 1024, 1024, 1024, 1024, 1024, 1024, 1024 };
760  uint32 bits = mantissa_table[offset_table[value>>10]+(value&0x3FF)] + exponent_table[value>>10];
761 // uint32 bits = mantissa_table[(((value&0x7C00)!=0)<<10)+(value&0x3FF)] + exponent_table[value>>10];
762 // return *reinterpret_cast<float*>(&bits); //violating strict aliasing!
763  float out;
764  std::memcpy(&out, &bits, sizeof(float));
765  return out;
766  }
767 
771  inline float half2float_impl(uint16 value, false_type)
772  {
773  float out;
774  int abs = value & 0x7FFF;
775  if(abs > 0x7C00)
776  out = std::numeric_limits<float>::has_quiet_NaN ? std::numeric_limits<float>::quiet_NaN() : 0.0f;
777  else if(abs == 0x7C00)
778  out = std::numeric_limits<float>::has_infinity ? std::numeric_limits<float>::infinity() : std::numeric_limits<float>::max();
779  else if(abs > 0x3FF)
780  out = std::ldexp(static_cast<float>((value&0x3FF)|0x400), (abs>>10)-25);
781  else
782  out = std::ldexp(static_cast<float>(abs), -24);
783  return (value&0x8000) ? -out : out;
784  }
785 
789  inline float half2float(uint16 value)
790  {
791  return half2float_impl(value, bool_type<std::numeric_limits<float>::is_iec559&&sizeof(uint32)==sizeof(float)>());
792  }
793 
800  template<std::float_round_style R,bool E,typename T> T half2int_impl(uint16 value)
801  {
802  unsigned int e = value & 0x7FFF;
803  if(e >= 0x7C00)
804  return (value&0x8000) ? std::numeric_limits<T>::min() : std::numeric_limits<T>::max();
805  if(e < 0x3800)
806  {
807  if(R == std::round_toward_infinity)
808  return T(~(value>>15)&(e!=0));
809  else if(R == std::round_toward_neg_infinity)
810  return -T(value>0x8000);
811  return T();
812  }
813  int17 m = (value&0x3FF) | 0x400;
814  e >>= 10;
815  if(e < 25)
816  {
817  if(R == std::round_indeterminate || R == std::round_toward_zero)
818  m >>= 25 - e;
819  else
820  {
821  if(R == std::round_to_nearest)
822  m += (1<<(24-e)) - (~(m>>(25-e))&E);
823  else if(R == std::round_toward_infinity)
824  m += ((value>>15)-1) & ((1<<(25-e))-1U);
825  else if(R == std::round_toward_neg_infinity)
826  m += -(value>>15) & ((1<<(25-e))-1U);
827  m >>= 25 - e;
828  }
829  }
830  else
831  m <<= e - 25;
832 // if(std::numeric_limits<T>::digits < 16)
833 // return std::min(std::max(m, static_cast<int17>(std::numeric_limits<T>::min())), static_cast<int17>(std::numeric_limits<T>::max()));
834  return static_cast<T>((value&0x8000) ? -m : m);
835  }
836 
842  template<std::float_round_style R,typename T> T half2int(uint16 value) { return half2int_impl<R,HALF_ROUND_TIES_TO_EVEN,T>(value); }
843 
848  template<typename T> T half2int_up(uint16 value) { return half2int_impl<std::round_to_nearest,0,T>(value); }
849 
855  template<std::float_round_style R,bool E> uint16 round_half_impl(uint16 value)
856  {
857  unsigned int e = value & 0x7FFF;
858  uint16 result = value;
859  if(e < 0x3C00)
860  {
861  result &= 0x8000;
862  if(R == std::round_to_nearest)
863  result |= 0x3C00U & -(e>=(0x3800+E));
864  else if(R == std::round_toward_infinity)
865  result |= 0x3C00U & -(~(value>>15)&(e!=0));
866  else if(R == std::round_toward_neg_infinity)
867  result |= 0x3C00U & -(value>0x8000);
868  }
869  else if(e < 0x6400)
870  {
871  e = 25 - (e>>10);
872  unsigned int mask = (1<<e) - 1;
873  if(R == std::round_to_nearest)
874  result += (1<<(e-1)) - (~(result>>e)&E);
875  else if(R == std::round_toward_infinity)
876  result += mask & ((value>>15)-1);
877  else if(R == std::round_toward_neg_infinity)
878  result += mask & -(value>>15);
879  result &= ~mask;
880  }
881  return result;
882  }
883 
888  template<std::float_round_style R> uint16 round_half(uint16 value) { return round_half_impl<R,HALF_ROUND_TIES_TO_EVEN>(value); }
889 
893  inline uint16 round_half_up(uint16 value) { return round_half_impl<std::round_to_nearest,0>(value); }
895 
896  struct functions;
897  template<typename> struct unary_specialized;
898  template<typename,typename> struct binary_specialized;
899  template<typename,typename,std::float_round_style> struct half_caster;
900  }
901 
922  class half
923  {
924  friend struct detail::functions;
925  friend struct detail::unary_specialized<half>;
926  friend struct detail::binary_specialized<half,half>;
927  template<typename,typename,std::float_round_style> friend struct detail::half_caster;
928  friend class std::numeric_limits<half>;
929  #if HALF_ENABLE_CPP11_HASH
930  friend struct std::hash<half>;
931  #endif
932 
933  public:
937  HALF_CONSTEXPR half() : data_() {}
938 
942  half(detail::expr rhs) : data_(detail::float2half<round_style>(rhs)) {}
943 
946  explicit half(float rhs) : data_(detail::float2half<round_style>(rhs)) {}
947 
950  operator float() const { return detail::half2float(data_); }
951 
956  half& operator=(detail::expr rhs) { return *this = static_cast<float>(rhs); }
957 
962  template<typename T> typename detail::enable<half&,T>::type operator+=(T rhs) { return *this += static_cast<float>(rhs); }
963 
968  template<typename T> typename detail::enable<half&,T>::type operator-=(T rhs) { return *this -= static_cast<float>(rhs); }
969 
974  template<typename T> typename detail::enable<half&,T>::type operator*=(T rhs) { return *this *= static_cast<float>(rhs); }
975 
980  template<typename T> typename detail::enable<half&,T>::type operator/=(T rhs) { return *this /= static_cast<float>(rhs); }
981 
985  half& operator=(float rhs) { data_ = detail::float2half<round_style>(rhs); return *this; }
986 
990  half& operator+=(float rhs) { data_ = detail::float2half<round_style>(detail::half2float(data_)+rhs); return *this; }
991 
995  half& operator-=(float rhs) { data_ = detail::float2half<round_style>(detail::half2float(data_)-rhs); return *this; }
996 
1000  half& operator*=(float rhs) { data_ = detail::float2half<round_style>(detail::half2float(data_)*rhs); return *this; }
1001 
1005  half& operator/=(float rhs) { data_ = detail::float2half<round_style>(detail::half2float(data_)/rhs); return *this; }
1006 
1009  half& operator++() { return *this += 1.0f; }
1010 
1013  half& operator--() { return *this -= 1.0f; }
1014 
1017  half operator++(int) { half out(*this); ++*this; return out; }
1018 
1021  half operator--(int) { half out(*this); --*this; return out; }
1022 
1023  private:
1025  static const std::float_round_style round_style = (std::float_round_style)(HALF_ROUND_STYLE);
1026 
1029  HALF_CONSTEXPR half(detail::binary_t, detail::uint16 bits) : data_(bits) {}
1030 
1032  detail::uint16 data_;
1033  };
1034 
1035 #if HALF_ENABLE_CPP11_USER_LITERALS
1036  namespace literal
1043  {
1049  inline half operator "" _h(long double value) { return half(static_cast<float>(value)); }
1050  }
1051 #endif
1052 
1053  namespace detail
1054  {
1056  struct functions
1057  {
1062  static expr plus(float x, float y) { return expr(x+y); }
1063 
1068  static expr minus(float x, float y) { return expr(x-y); }
1069 
1074  static expr multiplies(float x, float y) { return expr(x*y); }
1075 
1080  static expr divides(float x, float y) { return expr(x/y); }
1081 
1086  template<typename charT,typename traits> static std::basic_ostream<charT,traits>& write(std::basic_ostream<charT,traits> &out, float arg) { return out << arg; }
1087 
1092  template<typename charT,typename traits> static std::basic_istream<charT,traits>& read(std::basic_istream<charT,traits> &in, half &arg)
1093  {
1094  float f;
1095  if(in >> f)
1096  arg = f;
1097  return in;
1098  }
1099 
1104  static expr fmod(float x, float y) { return expr(std::fmod(x, y)); }
1105 
1110  static expr remainder(float x, float y)
1111  {
1112  #if HALF_ENABLE_CPP11_CMATH
1113  return expr(std::remainder(x, y));
1114  #else
1115  if(builtin_isnan(x) || builtin_isnan(y))
1116  return expr(std::numeric_limits<float>::quiet_NaN());
1117  float ax = std::fabs(x), ay = std::fabs(y);
1118  if(ax >= 65536.0f || ay < std::ldexp(1.0f, -24))
1119  return expr(std::numeric_limits<float>::quiet_NaN());
1120  if(ay >= 65536.0f)
1121  return expr(x);
1122  if(ax == ay)
1123  return expr(builtin_signbit(x) ? -0.0f : 0.0f);
1124  ax = std::fmod(ax, ay+ay);
1125  float y2 = 0.5f * ay;
1126  if(ax > y2)
1127  {
1128  ax -= ay;
1129  if(ax >= y2)
1130  ax -= ay;
1131  }
1132  return expr(builtin_signbit(x) ? -ax : ax);
1133  #endif
1134  }
1135 
1141  static expr remquo(float x, float y, int *quo)
1142  {
1143  #if HALF_ENABLE_CPP11_CMATH
1144  return expr(std::remquo(x, y, quo));
1145  #else
1146  if(builtin_isnan(x) || builtin_isnan(y))
1147  return expr(std::numeric_limits<float>::quiet_NaN());
1148  bool sign = builtin_signbit(x), qsign = static_cast<bool>(sign^builtin_signbit(y));
1149  float ax = std::fabs(x), ay = std::fabs(y);
1150  if(ax >= 65536.0f || ay < std::ldexp(1.0f, -24))
1151  return expr(std::numeric_limits<float>::quiet_NaN());
1152  if(ay >= 65536.0f)
1153  return expr(x);
1154  if(ax == ay)
1155  return *quo = qsign ? -1 : 1, expr(sign ? -0.0f : 0.0f);
1156  ax = std::fmod(ax, 8.0f*ay);
1157  int cquo = 0;
1158  if(ax >= 4.0f * ay)
1159  {
1160  ax -= 4.0f * ay;
1161  cquo += 4;
1162  }
1163  if(ax >= 2.0f * ay)
1164  {
1165  ax -= 2.0f * ay;
1166  cquo += 2;
1167  }
1168  float y2 = 0.5f * ay;
1169  if(ax > y2)
1170  {
1171  ax -= ay;
1172  ++cquo;
1173  if(ax >= y2)
1174  {
1175  ax -= ay;
1176  ++cquo;
1177  }
1178  }
1179  return *quo = qsign ? -cquo : cquo, expr(sign ? -ax : ax);
1180  #endif
1181  }
1182 
1187  static expr fdim(float x, float y)
1188  {
1189  #if HALF_ENABLE_CPP11_CMATH
1190  return expr(std::fdim(x, y));
1191  #else
1192  return expr((x<=y) ? 0.0f : (x-y));
1193  #endif
1194  }
1195 
1201  static expr fma(float x, float y, float z)
1202  {
1203  #if HALF_ENABLE_CPP11_CMATH && defined(FP_FAST_FMAF)
1204  return expr(std::fma(x, y, z));
1205  #else
1206  return expr(x*y+z);
1207  #endif
1208  }
1209 
1212  static half nanh(const char*) { return half(binary, 0x7FFF); }
1213 
1217  static expr exp(float arg) { return expr(std::exp(arg)); }
1218 
1222  static expr expm1(float arg)
1223  {
1224  #if HALF_ENABLE_CPP11_CMATH
1225  return expr(std::expm1(arg));
1226  #else
1227  return expr(static_cast<float>(std::exp(static_cast<double>(arg))-1.0));
1228  #endif
1229  }
1230 
1234  static expr exp2(float arg)
1235  {
1236  #if HALF_ENABLE_CPP11_CMATH
1237  return expr(std::exp2(arg));
1238  #else
1239  return expr(static_cast<float>(std::exp(arg*0.69314718055994530941723212145818)));
1240  #endif
1241  }
1242 
1246  static expr log(float arg) { return expr(std::log(arg)); }
1247 
1251  static expr log10(float arg) { return expr(std::log10(arg)); }
1252 
1256  static expr log1p(float arg)
1257  {
1258  #if HALF_ENABLE_CPP11_CMATH
1259  return expr(std::log1p(arg));
1260  #else
1261  return expr(static_cast<float>(std::log(1.0+arg)));
1262  #endif
1263  }
1264 
1268  static expr log2(float arg)
1269  {
1270  #if HALF_ENABLE_CPP11_CMATH
1271  return expr(std::log2(arg));
1272  #else
1273  return expr(static_cast<float>(std::log(static_cast<double>(arg))*1.4426950408889634073599246810019));
1274  #endif
1275  }
1276 
1280  static expr sqrt(float arg) { return expr(std::sqrt(arg)); }
1281 
1285  static expr cbrt(float arg)
1286  {
1287  #if HALF_ENABLE_CPP11_CMATH
1288  return expr(std::cbrt(arg));
1289  #else
1290  if(builtin_isnan(arg) || builtin_isinf(arg))
1291  return expr(arg);
1292  return expr(builtin_signbit(arg) ? -static_cast<float>(std::pow(std::fabs(static_cast<double>(arg)), 1.0/3.0)) :
1293  static_cast<float>(std::pow(static_cast<double>(arg), 1.0/3.0)));
1294  #endif
1295  }
1296 
1301  static expr hypot(float x, float y)
1302  {
1303  #if HALF_ENABLE_CPP11_CMATH
1304  return expr(std::hypot(x, y));
1305  #else
1306  return expr((builtin_isinf(x) || builtin_isinf(y)) ? std::numeric_limits<float>::infinity() :
1307  static_cast<float>(std::sqrt(static_cast<double>(x)*x+static_cast<double>(y)*y)));
1308  #endif
1309  }
1310 
1315  static expr pow(float base, float exp) { return expr(std::pow(base, exp)); }
1316 
1320  static expr sin(float arg) { return expr(std::sin(arg)); }
1321 
1325  static expr cos(float arg) { return expr(std::cos(arg)); }
1326 
1330  static expr tan(float arg) { return expr(std::tan(arg)); }
1331 
1335  static expr asin(float arg) { return expr(std::asin(arg)); }
1336 
1340  static expr acos(float arg) { return expr(std::acos(arg)); }
1341 
1345  static expr atan(float arg) { return expr(std::atan(arg)); }
1346 
1351  static expr atan2(float x, float y) { return expr(std::atan2(x, y)); }
1352 
1356  static expr sinh(float arg) { return expr(std::sinh(arg)); }
1357 
1361  static expr cosh(float arg) { return expr(std::cosh(arg)); }
1362 
1366  static expr tanh(float arg) { return expr(std::tanh(arg)); }
1367 
1371  static expr asinh(float arg)
1372  {
1373  #if HALF_ENABLE_CPP11_CMATH
1374  return expr(std::asinh(arg));
1375  #else
1376  return expr((arg==-std::numeric_limits<float>::infinity()) ? arg : static_cast<float>(std::log(arg+std::sqrt(arg*arg+1.0))));
1377  #endif
1378  }
1379 
1383  static expr acosh(float arg)
1384  {
1385  #if HALF_ENABLE_CPP11_CMATH
1386  return expr(std::acosh(arg));
1387  #else
1388  return expr((arg<-1.0f) ? std::numeric_limits<float>::quiet_NaN() : static_cast<float>(std::log(arg+std::sqrt(arg*arg-1.0))));
1389  #endif
1390  }
1391 
1395  static expr atanh(float arg)
1396  {
1397  #if HALF_ENABLE_CPP11_CMATH
1398  return expr(std::atanh(arg));
1399  #else
1400  return expr(static_cast<float>(0.5*std::log((1.0+arg)/(1.0-arg))));
1401  #endif
1402  }
1403 
1407  static expr erf(float arg)
1408  {
1409  #if HALF_ENABLE_CPP11_CMATH
1410  return expr(std::erf(arg));
1411  #else
1412  return expr(static_cast<float>(erf(static_cast<double>(arg))));
1413  #endif
1414  }
1415 
1419  static expr erfc(float arg)
1420  {
1421  #if HALF_ENABLE_CPP11_CMATH
1422  return expr(std::erfc(arg));
1423  #else
1424  return expr(static_cast<float>(1.0-erf(static_cast<double>(arg))));
1425  #endif
1426  }
1427 
1431  static expr lgamma(float arg)
1432  {
1433  #if HALF_ENABLE_CPP11_CMATH
1434  return expr(std::lgamma(arg));
1435  #else
1436  if(builtin_isinf(arg))
1437  return expr(std::numeric_limits<float>::infinity());
1438  double z = static_cast<double>(arg);
1439  if(z < 0)
1440  {
1441  double i, f = std::modf(-z, &i);
1442  if(f == 0.0)
1443  return expr(std::numeric_limits<float>::infinity());
1444  return expr(static_cast<float>(1.1447298858494001741434273513531-std::log(std::abs(std::sin(3.1415926535897932384626433832795*f)))-lgamma(1.0-z)));
1445  }
1446 // if(z < 8.0)
1447  return expr(static_cast<float>(lgamma(static_cast<double>(arg))));
1448  return expr(static_cast<float>(0.5*(1.8378770664093454835606594728112-std::log(z))+z*(std::log(z+1.0/(12.0*z-1.0/(10.0*z)-1.0))-1.0)));
1449  #endif
1450  }
1451 
1455  static expr tgamma(float arg)
1456  {
1457  #if HALF_ENABLE_CPP11_CMATH
1458  return expr(std::tgamma(arg));
1459  #else
1460  double z = static_cast<double>(arg);
1461  if(z == 0.0)
1462  return builtin_signbit(z) ? expr(-std::numeric_limits<float>::infinity()) : expr(std::numeric_limits<float>::infinity());
1463  if(z < 0.0)
1464  {
1465  double i, f = std::modf(-z, &i);
1466  if(f == 0.0)
1467  return expr(std::numeric_limits<float>::quiet_NaN());
1468  double sign = (std::fmod(i, 2.0)==0.0) ? -1.0 : 1.0;
1469  return expr(static_cast<float>(sign*3.1415926535897932384626433832795/(std::sin(3.1415926535897932384626433832795*f)*std::exp(lgamma(1.0-z)))));
1470  }
1471  if(builtin_isinf(arg))
1472  return expr(arg);
1473 // if(arg < 8.0f)
1474  return expr(static_cast<float>(std::exp(lgamma(z))));
1475  return expr(static_cast<float>(std::sqrt(6.283185307179586476925286766559/z)*std::pow(0.36787944117144232159552377016146*(z+1.0/(12.0*z-1.0/(10.0*z))), z)));
1476  #endif
1477  }
1478 
1482  static half floor(half arg) { return half(binary, round_half<std::round_toward_neg_infinity>(arg.data_)); }
1483 
1487  static half ceil(half arg) { return half(binary, round_half<std::round_toward_infinity>(arg.data_)); }
1488 
1492  static half trunc(half arg) { return half(binary, round_half<std::round_toward_zero>(arg.data_)); }
1493 
1497  static half round(half arg) { return half(binary, round_half_up(arg.data_)); }
1498 
1502  static long lround(half arg) { return detail::half2int_up<long>(arg.data_); }
1503 
1507  static half rint(half arg) { return half(binary, round_half<half::round_style>(arg.data_)); }
1508 
1512  static long lrint(half arg) { return detail::half2int<half::round_style,long>(arg.data_); }
1513 
1514  #if HALF_ENABLE_CPP11_LONG_LONG
1515  static long long llround(half arg) { return detail::half2int_up<long long>(arg.data_); }
1519 
1523  static long long llrint(half arg) { return detail::half2int<half::round_style,long long>(arg.data_); }
1524  #endif
1525 
1530  static half frexp(half arg, int *exp)
1531  {
1532  unsigned int m = arg.data_ & 0x7FFF;
1533  if(m >= 0x7C00 || !m)
1534  return *exp = 0, arg;
1535  int e = m >> 10;
1536  if(!e)
1537  for(m<<=1; m<0x400; m<<=1,--e) ;
1538  return *exp = e-14, half(binary, static_cast<uint16>((arg.data_&0x8000)|0x3800|(m&0x3FF)));
1539  }
1540 
1545  static half modf(half arg, half *iptr)
1546  {
1547  unsigned int e = arg.data_ & 0x7C00;
1548  if(e > 0x6000)
1549  return *iptr = arg, (e==0x7C00&&(arg.data_&0x3FF)) ? arg : half(binary, arg.data_&0x8000);
1550  if(e < 0x3C00)
1551  return iptr->data_ = arg.data_ & 0x8000, arg;
1552  e >>= 10;
1553  unsigned int mask = (1<<(25-e)) - 1, m = arg.data_ & mask;
1554  iptr->data_ = arg.data_ & ~mask;
1555  if(!m)
1556  return half(binary, arg.data_&0x8000);
1557  for(; m<0x400; m<<=1,--e) ;
1558  return half(binary, static_cast<uint16>((arg.data_&0x8000)|(e<<10)|(m&0x3FF)));
1559  }
1560 
1565  static half scalbln(half arg, long exp)
1566  {
1567  long e = arg.data_ & 0x7C00;
1568  if(e == 0x7C00)
1569  return arg;
1570  unsigned int m = arg.data_ & 0x3FF;
1571  if(e >>= 10)
1572  m |= 0x400;
1573  else
1574  {
1575  if(!m)
1576  return arg;
1577  for(m<<=1; m<0x400; m<<=1,--e) ;
1578  }
1579  e += exp;
1580  uint16 value = arg.data_ & 0x8000;
1581  if(e > 30)
1582  {
1583  if(half::round_style == std::round_toward_zero)
1584  value |= 0x7BFF;
1585  else if(half::round_style == std::round_toward_infinity)
1586  value |= 0x7C00 - (value>>15);
1587  else if(half::round_style == std::round_toward_neg_infinity)
1588  value |= 0x7BFF + (value>>15);
1589  else
1590  value |= 0x7C00;
1591  }
1592  else if(e > 0)
1593  value |= (e<<10) | (m&0x3FF);
1594  else if(e > -11)
1595  {
1596  if(half::round_style == std::round_to_nearest)
1597  {
1598  m += 1 << -e;
1599  #if HALF_ROUND_TIES_TO_EVEN
1600  m -= (m>>(1-e)) & 1;
1601  #endif
1602  }
1603  else if(half::round_style == std::round_toward_infinity)
1604  m += ((value>>15)-1) & ((1<<(1-e))-1U);
1605  else if(half::round_style == std::round_toward_neg_infinity)
1606  m += -(value>>15) & ((1<<(1-e))-1U);
1607  value |= m >> (1-e);
1608  }
1609  else if(half::round_style == std::round_toward_infinity)
1610  value |= ((value>>15)-1) & 1;
1611  else if(half::round_style == std::round_toward_neg_infinity)
1612  value |= value >> 15;
1613  return half(binary, value);
1614  }
1615 
1619  static int ilogb(half arg)
1620  {
1621  int exp = arg.data_ & 0x7FFF;
1622  if(!exp)
1623  return FP_ILOGB0;
1624  if(exp < 0x7C00)
1625  {
1626  if(!(exp>>=10))
1627  for(unsigned int m=(arg.data_&0x3FF); m<0x200; m<<=1,--exp) ;
1628  return exp - 15;
1629  }
1630  if(exp > 0x7C00)
1631  return FP_ILOGBNAN;
1632  return INT_MAX;
1633  }
1634 
1638  static half logb(half arg)
1639  {
1640  int exp = arg.data_ & 0x7FFF;
1641  if(!exp)
1642  return half(binary, 0xFC00);
1643  if(exp < 0x7C00)
1644  {
1645  if(!(exp>>=10))
1646  for(unsigned int m=(arg.data_&0x3FF); m<0x200; m<<=1,--exp) ;
1647  return half(static_cast<float>(exp-15));
1648  }
1649  if(exp > 0x7C00)
1650  return arg;
1651  return half(binary, 0x7C00);
1652  }
1653 
1658  static half nextafter(half from, half to)
1659  {
1660  uint16 fabs = from.data_ & 0x7FFF, tabs = to.data_ & 0x7FFF;
1661  if(fabs > 0x7C00)
1662  return from;
1663  if(tabs > 0x7C00 || from.data_ == to.data_ || !(fabs|tabs))
1664  return to;
1665  if(!fabs)
1666  return half(binary, (to.data_&0x8000)+1);
1667  bool lt = (signbit(from) ? (static_cast<int17>(0x8000)-from.data_) : static_cast<int17>(from.data_)) <
1668  (signbit(to) ? (static_cast<int17>(0x8000)-to.data_) : static_cast<int17>(to.data_));
1669  return half(binary, from.data_+(((from.data_>>15)^static_cast<uint16>(lt))<<1)-1);
1670  }
1671 
1676  static half nexttoward(half from, long double to)
1677  {
1678  if(isnan(from))
1679  return from;
1680  long double lfrom = static_cast<long double>(from);
1681  if(builtin_isnan(to) || lfrom == to)
1682  return half(static_cast<float>(to));
1683  if(!(from.data_&0x7FFF))
1684  return half(binary, (static_cast<detail::uint16>(builtin_signbit(to))<<15)+1);
1685  return half(binary, from.data_+(((from.data_>>15)^static_cast<uint16>(lfrom<to))<<1)-1);
1686  }
1687 
1692  static half copysign(half x, half y) { return half(binary, x.data_^((x.data_^y.data_)&0x8000)); }
1693 
1698  static int fpclassify(half arg)
1699  {
1700  unsigned int abs = arg.data_ & 0x7FFF;
1701  if(abs > 0x7C00)
1702  return FP_NAN;
1703  if(abs == 0x7C00)
1704  return FP_INFINITE;
1705  if(abs > 0x3FF)
1706  return FP_NORMAL;
1707  return abs ? FP_SUBNORMAL : FP_ZERO;
1708  }
1709 
1714  static bool isfinite(half arg) { return (arg.data_&0x7C00) != 0x7C00; }
1715 
1720  static bool isinf(half arg) { return (arg.data_&0x7FFF) == 0x7C00; }
1721 
1726  static bool isnan(half arg) { return (arg.data_&0x7FFF) > 0x7C00; }
1727 
1732  static bool isnormal(half arg) { return ((arg.data_&0x7C00)!=0) & ((arg.data_&0x7C00)!=0x7C00); }
1733 
1738  static bool signbit(half arg) { return (arg.data_&0x8000) != 0; }
1739 
1745  static bool isequal(half x, half y) { return (x.data_==y.data_ || !((x.data_|y.data_)&0x7FFF)) && !isnan(x); }
1746 
1752  static bool isnotequal(half x, half y) { return (x.data_!=y.data_ && ((x.data_|y.data_)&0x7FFF)) || isnan(x); }
1753 
1759  static bool isgreater(half x, half y) { return !isnan(x) && !isnan(y) && ((signbit(x) ? (static_cast<int17>(0x8000)-x.data_) :
1760  static_cast<int17>(x.data_)) > (signbit(y) ? (static_cast<int17>(0x8000)-y.data_) : static_cast<int17>(y.data_))); }
1761 
1767  static bool isgreaterequal(half x, half y) { return !isnan(x) && !isnan(y) && ((signbit(x) ? (static_cast<int17>(0x8000)-x.data_) :
1768  static_cast<int17>(x.data_)) >= (signbit(y) ? (static_cast<int17>(0x8000)-y.data_) : static_cast<int17>(y.data_))); }
1769 
1775  static bool isless(half x, half y) { return !isnan(x) && !isnan(y) && ((signbit(x) ? (static_cast<int17>(0x8000)-x.data_) :
1776  static_cast<int17>(x.data_)) < (signbit(y) ? (static_cast<int17>(0x8000)-y.data_) : static_cast<int17>(y.data_))); }
1777 
1783  static bool islessequal(half x, half y) { return !isnan(x) && !isnan(y) && ((signbit(x) ? (static_cast<int17>(0x8000)-x.data_) :
1784  static_cast<int17>(x.data_)) <= (signbit(y) ? (static_cast<int17>(0x8000)-y.data_) : static_cast<int17>(y.data_))); }
1785 
1791  static bool islessgreater(half x, half y)
1792  {
1793  if(isnan(x) || isnan(y))
1794  return false;
1795  int17 a = signbit(x) ? (static_cast<int17>(0x8000)-x.data_) : static_cast<int17>(x.data_);
1796  int17 b = signbit(y) ? (static_cast<int17>(0x8000)-y.data_) : static_cast<int17>(y.data_);
1797  return a < b || a > b;
1798  }
1799 
1805  static bool isunordered(half x, half y) { return isnan(x) || isnan(y); }
1806 
1807  private:
1808  static double erf(double arg)
1809  {
1810  if(builtin_isinf(arg))
1811  return (arg<0.0) ? -1.0 : 1.0;
1812  double x2 = static_cast<double>(arg) * static_cast<double>(arg), ax2 = 0.147 * x2;
1813  double value = std::sqrt(1.0-std::exp(-x2*(1.2732395447351626861510701069801+ax2)/(1.0+ax2)));
1814  return builtin_signbit(arg) ? -value : value;
1815  }
1816 
1817  static double lgamma(double arg)
1818  {
1819  double v = 1.0;
1820  for(; arg<8.0; ++arg) v *= arg;
1821  double w = 1.0 / (arg * arg);
1822  return (((((((-0.02955065359477124183006535947712*w+0.00641025641025641025641025641026)*w+
1823  -0.00191752691752691752691752691753)*w+8.4175084175084175084175084175084e-4)*w+
1824  -5.952380952380952380952380952381e-4)*w+7.9365079365079365079365079365079e-4)*w+
1825  -0.00277777777777777777777777777778)*w+0.08333333333333333333333333333333)/arg +
1826  0.91893853320467274178032973640562 - std::log(v) - arg + (arg-0.5) * std::log(arg);
1827  }
1828  };
1829 
1832  template<typename T> struct unary_specialized
1833  {
1837  static HALF_CONSTEXPR half negate(half arg) { return half(binary, arg.data_^0x8000); }
1838 
1842  static half fabs(half arg) { return half(binary, arg.data_&0x7FFF); }
1843  };
1844  template<> struct unary_specialized<expr>
1845  {
1846  static HALF_CONSTEXPR expr negate(float arg) { return expr(-arg); }
1847  static expr fabs(float arg) { return expr(std::fabs(arg)); }
1848  };
1849 
1853  template<typename T,typename U> struct binary_specialized
1854  {
1859  static expr fmin(float x, float y)
1860  {
1861  #if HALF_ENABLE_CPP11_CMATH
1862  return expr(std::fmin(x, y));
1863  #else
1864  if(builtin_isnan(x))
1865  return expr(y);
1866  if(builtin_isnan(y))
1867  return expr(x);
1868  return expr(std::min(x, y));
1869  #endif
1870  }
1871 
1876  static expr fmax(float x, float y)
1877  {
1878  #if HALF_ENABLE_CPP11_CMATH
1879  return expr(std::fmax(x, y));
1880  #else
1881  if(builtin_isnan(x))
1882  return expr(y);
1883  if(builtin_isnan(y))
1884  return expr(x);
1885  return expr(std::max(x, y));
1886  #endif
1887  }
1888  };
1889  template<> struct binary_specialized<half,half>
1890  {
1891  static half fmin(half x, half y)
1892  {
1893  if(functions::isnan(x))
1894  return y;
1895  if(functions::isnan(y))
1896  return x;
1897  return ((functions::signbit(x) ? (static_cast<int17>(0x8000)-x.data_) : static_cast<int17>(x.data_)) >
1898  (functions::signbit(y) ? (static_cast<int17>(0x8000)-y.data_) : static_cast<int17>(y.data_))) ? y : x;
1899  }
1900  static half fmax(half x, half y)
1901  {
1902  if(functions::isnan(x))
1903  return y;
1904  if(functions::isnan(y))
1905  return x;
1906  return ((functions::signbit(x) ? (static_cast<int17>(0x8000)-x.data_) : static_cast<int17>(x.data_)) <
1907  (functions::signbit(y) ? (static_cast<int17>(0x8000)-y.data_) : static_cast<int17>(y.data_))) ? y : x;
1908  }
1909  };
1910 
1917  template<typename T,typename U,std::float_round_style R=(std::float_round_style)(HALF_ROUND_STYLE)> struct half_caster {};
1918  template<typename U,std::float_round_style R> struct half_caster<half,U,R>
1919  {
1920  #if HALF_ENABLE_CPP11_STATIC_ASSERT && HALF_ENABLE_CPP11_TYPE_TRAITS
1921  static_assert(std::is_arithmetic<U>::value, "half_cast from non-arithmetic type unsupported");
1922  #endif
1923 
1924  typedef half type;
1925  static half cast(U arg) { return cast_impl(arg, is_float<U>()); };
1926 
1927  private:
1928  static half cast_impl(U arg, true_type) { return half(binary, float2half<R>(static_cast<float>(arg))); }
1929  static half cast_impl(U arg, false_type) { return half(binary, int2half<R>(arg)); }
1930  };
1931  template<typename T,std::float_round_style R> struct half_caster<T,half,R>
1932  {
1933  #if HALF_ENABLE_CPP11_STATIC_ASSERT && HALF_ENABLE_CPP11_TYPE_TRAITS
1934  static_assert(std::is_arithmetic<T>::value, "half_cast to non-arithmetic type unsupported");
1935  #endif
1936 
1937  typedef T type;
1938  template<typename U> static T cast(U arg) { return cast_impl(arg, is_float<T>()); }
1939 
1940  private:
1941  static T cast_impl(float arg, true_type) { return static_cast<T>(arg); }
1942  static T cast_impl(half arg, false_type) { return half2int<R,T>(arg.data_); }
1943  };
1944  template<typename T,std::float_round_style R> struct half_caster<T,expr,R> : public half_caster<T,half,R> {};
1945  template<std::float_round_style R> struct half_caster<half,half,R>
1946  {
1947  typedef half type;
1948  static half cast(half arg) { return arg; }
1949  };
1950  template<std::float_round_style R> struct half_caster<half,expr,R> : public half_caster<half,half,R> {};
1951 
1954 
1960  template<typename T,typename U> typename enable<bool,T,U>::type operator==(T x, U y) { return functions::isequal(x, y); }
1961 
1967  template<typename T,typename U> typename enable<bool,T,U>::type operator!=(T x, U y) { return functions::isnotequal(x, y); }
1968 
1974  template<typename T,typename U> typename enable<bool,T,U>::type operator<(T x, U y) { return functions::isless(x, y); }
1975 
1981  template<typename T,typename U> typename enable<bool,T,U>::type operator>(T x, U y) { return functions::isgreater(x, y); }
1982 
1988  template<typename T,typename U> typename enable<bool,T,U>::type operator<=(T x, U y) { return functions::islessequal(x, y); }
1989 
1995  template<typename T,typename U> typename enable<bool,T,U>::type operator>=(T x, U y) { return functions::isgreaterequal(x, y); }
1996 
2000 
2005  template<typename T,typename U> typename enable<expr,T,U>::type operator+(T x, U y) { return functions::plus(x, y); }
2006 
2011  template<typename T,typename U> typename enable<expr,T,U>::type operator-(T x, U y) { return functions::minus(x, y); }
2012 
2017  template<typename T,typename U> typename enable<expr,T,U>::type operator*(T x, U y) { return functions::multiplies(x, y); }
2018 
2023  template<typename T,typename U> typename enable<expr,T,U>::type operator/(T x, U y) { return functions::divides(x, y); }
2024 
2028  template<typename T> HALF_CONSTEXPR typename enable<T,T>::type operator+(T arg) { return arg; }
2029 
2033  template<typename T> HALF_CONSTEXPR typename enable<T,T>::type operator-(T arg) { return unary_specialized<T>::negate(arg); }
2034 
2038 
2043  template<typename T,typename charT,typename traits> typename enable<std::basic_ostream<charT,traits>&,T>::type
2044  operator<<(std::basic_ostream<charT,traits> &out, T arg) { return functions::write(out, arg); }
2045 
2050  template<typename charT,typename traits> std::basic_istream<charT,traits>&
2051  operator>>(std::basic_istream<charT,traits> &in, half &arg) { return functions::read(in, arg); }
2052 
2056 
2060 // template<typename T> typename enable<T,T>::type abs(T arg) { return unary_specialized<T>::fabs(arg); }
2061  inline half abs(half arg) { return unary_specialized<half>::fabs(arg); }
2062  inline expr abs(expr arg) { return unary_specialized<expr>::fabs(arg); }
2063 
2067 // template<typename T> typename enable<T,T>::type fabs(T arg) { return unary_specialized<T>::fabs(arg); }
2068  inline half fabs(half arg) { return unary_specialized<half>::fabs(arg); }
2069  inline expr fabs(expr arg) { return unary_specialized<expr>::fabs(arg); }
2070 
2075 // template<typename T,typename U> typename enable<expr,T,U>::type fmod(T x, U y) { return functions::fmod(x, y); }
2076  inline expr fmod(half x, half y) { return functions::fmod(x, y); }
2077  inline expr fmod(half x, expr y) { return functions::fmod(x, y); }
2078  inline expr fmod(expr x, half y) { return functions::fmod(x, y); }
2079  inline expr fmod(expr x, expr y) { return functions::fmod(x, y); }
2080 
2085 // template<typename T,typename U> typename enable<expr,T,U>::type remainder(T x, U y) { return functions::remainder(x, y); }
2086  inline expr remainder(half x, half y) { return functions::remainder(x, y); }
2087  inline expr remainder(half x, expr y) { return functions::remainder(x, y); }
2088  inline expr remainder(expr x, half y) { return functions::remainder(x, y); }
2089  inline expr remainder(expr x, expr y) { return functions::remainder(x, y); }
2090 
2096 // template<typename T,typename U> typename enable<expr,T,U>::type remquo(T x, U y, int *quo) { return functions::remquo(x, y, quo); }
2097  inline expr remquo(half x, half y, int *quo) { return functions::remquo(x, y, quo); }
2098  inline expr remquo(half x, expr y, int *quo) { return functions::remquo(x, y, quo); }
2099  inline expr remquo(expr x, half y, int *quo) { return functions::remquo(x, y, quo); }
2100  inline expr remquo(expr x, expr y, int *quo) { return functions::remquo(x, y, quo); }
2101 
2107 // template<typename T,typename U,typename V> typename enable<expr,T,U,V>::type fma(T x, U y, V z) { return functions::fma(x, y, z); }
2108  inline expr fma(half x, half y, half z) { return functions::fma(x, y, z); }
2109  inline expr fma(half x, half y, expr z) { return functions::fma(x, y, z); }
2110  inline expr fma(half x, expr y, half z) { return functions::fma(x, y, z); }
2111  inline expr fma(half x, expr y, expr z) { return functions::fma(x, y, z); }
2112  inline expr fma(expr x, half y, half z) { return functions::fma(x, y, z); }
2113  inline expr fma(expr x, half y, expr z) { return functions::fma(x, y, z); }
2114  inline expr fma(expr x, expr y, half z) { return functions::fma(x, y, z); }
2115  inline expr fma(expr x, expr y, expr z) { return functions::fma(x, y, z); }
2116 
2121 // template<typename T,typename U> typename result<T,U>::type fmax(T x, U y) { return binary_specialized<T,U>::fmax(x, y); }
2122  inline half fmax(half x, half y) { return binary_specialized<half,half>::fmax(x, y); }
2123  inline expr fmax(half x, expr y) { return binary_specialized<half,expr>::fmax(x, y); }
2124  inline expr fmax(expr x, half y) { return binary_specialized<expr,half>::fmax(x, y); }
2125  inline expr fmax(expr x, expr y) { return binary_specialized<expr,expr>::fmax(x, y); }
2126 
2131 // template<typename T,typename U> typename result<T,U>::type fmin(T x, U y) { return binary_specialized<T,U>::fmin(x, y); }
2132  inline half fmin(half x, half y) { return binary_specialized<half,half>::fmin(x, y); }
2133  inline expr fmin(half x, expr y) { return binary_specialized<half,expr>::fmin(x, y); }
2134  inline expr fmin(expr x, half y) { return binary_specialized<expr,half>::fmin(x, y); }
2135  inline expr fmin(expr x, expr y) { return binary_specialized<expr,expr>::fmin(x, y); }
2136 
2141 // template<typename T,typename U> typename enable<expr,T,U>::type fdim(T x, U y) { return functions::fdim(x, y); }
2142  inline expr fdim(half x, half y) { return functions::fdim(x, y); }
2143  inline expr fdim(half x, expr y) { return functions::fdim(x, y); }
2144  inline expr fdim(expr x, half y) { return functions::fdim(x, y); }
2145  inline expr fdim(expr x, expr y) { return functions::fdim(x, y); }
2146 
2150  inline half nanh(const char *arg) { return functions::nanh(arg); }
2151 
2155 
2159 // template<typename T> typename enable<expr,T>::type exp(T arg) { return functions::exp(arg); }
2160  inline expr exp(half arg) { return functions::exp(arg); }
2161  inline expr exp(expr arg) { return functions::exp(arg); }
2162 
2166 // template<typename T> typename enable<expr,T>::type expm1(T arg) { return functions::expm1(arg); }
2167  inline expr expm1(half arg) { return functions::expm1(arg); }
2168  inline expr expm1(expr arg) { return functions::expm1(arg); }
2169 
2173 // template<typename T> typename enable<expr,T>::type exp2(T arg) { return functions::exp2(arg); }
2174  inline expr exp2(half arg) { return functions::exp2(arg); }
2175  inline expr exp2(expr arg) { return functions::exp2(arg); }
2176 
2180 // template<typename T> typename enable<expr,T>::type log(T arg) { return functions::log(arg); }
2181  inline expr log(half arg) { return functions::log(arg); }
2182  inline expr log(expr arg) { return functions::log(arg); }
2183 
2187 // template<typename T> typename enable<expr,T>::type log10(T arg) { return functions::log10(arg); }
2188  inline expr log10(half arg) { return functions::log10(arg); }
2189  inline expr log10(expr arg) { return functions::log10(arg); }
2190 
2194 // template<typename T> typename enable<expr,T>::type log1p(T arg) { return functions::log1p(arg); }
2195  inline expr log1p(half arg) { return functions::log1p(arg); }
2196  inline expr log1p(expr arg) { return functions::log1p(arg); }
2197 
2201 // template<typename T> typename enable<expr,T>::type log2(T arg) { return functions::log2(arg); }
2202  inline expr log2(half arg) { return functions::log2(arg); }
2203  inline expr log2(expr arg) { return functions::log2(arg); }
2204 
2208 
2212 // template<typename T> typename enable<expr,T>::type sqrt(T arg) { return functions::sqrt(arg); }
2213  inline expr sqrt(half arg) { return functions::sqrt(arg); }
2214  inline expr sqrt(expr arg) { return functions::sqrt(arg); }
2215 
2219 // template<typename T> typename enable<expr,T>::type cbrt(T arg) { return functions::cbrt(arg); }
2220  inline expr cbrt(half arg) { return functions::cbrt(arg); }
2221  inline expr cbrt(expr arg) { return functions::cbrt(arg); }
2222 
2227 // template<typename T,typename U> typename enable<expr,T,U>::type hypot(T x, U y) { return functions::hypot(x, y); }
2228  inline expr hypot(half x, half y) { return functions::hypot(x, y); }
2229  inline expr hypot(half x, expr y) { return functions::hypot(x, y); }
2230  inline expr hypot(expr x, half y) { return functions::hypot(x, y); }
2231  inline expr hypot(expr x, expr y) { return functions::hypot(x, y); }
2232 
2237 // template<typename T,typename U> typename enable<expr,T,U>::type pow(T base, U exp) { return functions::pow(base, exp); }
2238  inline expr pow(half base, half exp) { return functions::pow(base, exp); }
2239  inline expr pow(half base, expr exp) { return functions::pow(base, exp); }
2240  inline expr pow(expr base, half exp) { return functions::pow(base, exp); }
2241  inline expr pow(expr base, expr exp) { return functions::pow(base, exp); }
2242 
2246 
2250 // template<typename T> typename enable<expr,T>::type sin(T arg) { return functions::sin(arg); }
2251  inline expr sin(half arg) { return functions::sin(arg); }
2252  inline expr sin(expr arg) { return functions::sin(arg); }
2253 
2257 // template<typename T> typename enable<expr,T>::type cos(T arg) { return functions::cos(arg); }
2258  inline expr cos(half arg) { return functions::cos(arg); }
2259  inline expr cos(expr arg) { return functions::cos(arg); }
2260 
2264 // template<typename T> typename enable<expr,T>::type tan(T arg) { return functions::tan(arg); }
2265  inline expr tan(half arg) { return functions::tan(arg); }
2266  inline expr tan(expr arg) { return functions::tan(arg); }
2267 
2271 // template<typename T> typename enable<expr,T>::type asin(T arg) { return functions::asin(arg); }
2272  inline expr asin(half arg) { return functions::asin(arg); }
2273  inline expr asin(expr arg) { return functions::asin(arg); }
2274 
2278 // template<typename T> typename enable<expr,T>::type acos(T arg) { return functions::acos(arg); }
2279  inline expr acos(half arg) { return functions::acos(arg); }
2280  inline expr acos(expr arg) { return functions::acos(arg); }
2281 
2285 // template<typename T> typename enable<expr,T>::type atan(T arg) { return functions::atan(arg); }
2286  inline expr atan(half arg) { return functions::atan(arg); }
2287  inline expr atan(expr arg) { return functions::atan(arg); }
2288 
2293 // template<typename T,typename U> typename enable<expr,T,U>::type atan2(T x, U y) { return functions::atan2(x, y); }
2294  inline expr atan2(half x, half y) { return functions::atan2(x, y); }
2295  inline expr atan2(half x, expr y) { return functions::atan2(x, y); }
2296  inline expr atan2(expr x, half y) { return functions::atan2(x, y); }
2297  inline expr atan2(expr x, expr y) { return functions::atan2(x, y); }
2298 
2302 
2306 // template<typename T> typename enable<expr,T>::type sinh(T arg) { return functions::sinh(arg); }
2307  inline expr sinh(half arg) { return functions::sinh(arg); }
2308  inline expr sinh(expr arg) { return functions::sinh(arg); }
2309 
2313 // template<typename T> typename enable<expr,T>::type cosh(T arg) { return functions::cosh(arg); }
2314  inline expr cosh(half arg) { return functions::cosh(arg); }
2315  inline expr cosh(expr arg) { return functions::cosh(arg); }
2316 
2320 // template<typename T> typename enable<expr,T>::type tanh(T arg) { return functions::tanh(arg); }
2321  inline expr tanh(half arg) { return functions::tanh(arg); }
2322  inline expr tanh(expr arg) { return functions::tanh(arg); }
2323 
2327 // template<typename T> typename enable<expr,T>::type asinh(T arg) { return functions::asinh(arg); }
2328  inline expr asinh(half arg) { return functions::asinh(arg); }
2329  inline expr asinh(expr arg) { return functions::asinh(arg); }
2330 
2334 // template<typename T> typename enable<expr,T>::type acosh(T arg) { return functions::acosh(arg); }
2335  inline expr acosh(half arg) { return functions::acosh(arg); }
2336  inline expr acosh(expr arg) { return functions::acosh(arg); }
2337 
2341 // template<typename T> typename enable<expr,T>::type atanh(T arg) { return functions::atanh(arg); }
2342  inline expr atanh(half arg) { return functions::atanh(arg); }
2343  inline expr atanh(expr arg) { return functions::atanh(arg); }
2344 
2348 
2352 // template<typename T> typename enable<expr,T>::type erf(T arg) { return functions::erf(arg); }
2353  inline expr erf(half arg) { return functions::erf(arg); }
2354  inline expr erf(expr arg) { return functions::erf(arg); }
2355 
2359 // template<typename T> typename enable<expr,T>::type erfc(T arg) { return functions::erfc(arg); }
2360  inline expr erfc(half arg) { return functions::erfc(arg); }
2361  inline expr erfc(expr arg) { return functions::erfc(arg); }
2362 
2366 // template<typename T> typename enable<expr,T>::type lgamma(T arg) { return functions::lgamma(arg); }
2367  inline expr lgamma(half arg) { return functions::lgamma(arg); }
2368  inline expr lgamma(expr arg) { return functions::lgamma(arg); }
2369 
2373 // template<typename T> typename enable<expr,T>::type tgamma(T arg) { return functions::tgamma(arg); }
2374  inline expr tgamma(half arg) { return functions::tgamma(arg); }
2375  inline expr tgamma(expr arg) { return functions::tgamma(arg); }
2376 
2380 
2384 // template<typename T> typename enable<half,T>::type ceil(T arg) { return functions::ceil(arg); }
2385  inline half ceil(half arg) { return functions::ceil(arg); }
2386  inline half ceil(expr arg) { return functions::ceil(arg); }
2387 
2391 // template<typename T> typename enable<half,T>::type floor(T arg) { return functions::floor(arg); }
2392  inline half floor(half arg) { return functions::floor(arg); }
2393  inline half floor(expr arg) { return functions::floor(arg); }
2394 
2398 // template<typename T> typename enable<half,T>::type trunc(T arg) { return functions::trunc(arg); }
2399  inline half trunc(half arg) { return functions::trunc(arg); }
2400  inline half trunc(expr arg) { return functions::trunc(arg); }
2401 
2405 // template<typename T> typename enable<half,T>::type round(T arg) { return functions::round(arg); }
2406  inline half round(half arg) { return functions::round(arg); }
2407  inline half round(expr arg) { return functions::round(arg); }
2408 
2412 // template<typename T> typename enable<long,T>::type lround(T arg) { return functions::lround(arg); }
2413  inline long lround(half arg) { return functions::lround(arg); }
2414  inline long lround(expr arg) { return functions::lround(arg); }
2415 
2419 // template<typename T> typename enable<half,T>::type nearbyint(T arg) { return functions::nearbyint(arg); }
2420  inline half nearbyint(half arg) { return functions::rint(arg); }
2421  inline half nearbyint(expr arg) { return functions::rint(arg); }
2422 
2426 // template<typename T> typename enable<half,T>::type rint(T arg) { return functions::rint(arg); }
2427  inline half rint(half arg) { return functions::rint(arg); }
2428  inline half rint(expr arg) { return functions::rint(arg); }
2429 
2433 // template<typename T> typename enable<long,T>::type lrint(T arg) { return functions::lrint(arg); }
2434  inline long lrint(half arg) { return functions::lrint(arg); }
2435  inline long lrint(expr arg) { return functions::lrint(arg); }
2436  #if HALF_ENABLE_CPP11_LONG_LONG
2437 // template<typename T> typename enable<long long,T>::type llround(T arg) { return functions::llround(arg); }
2441  inline long long llround(half arg) { return functions::llround(arg); }
2442  inline long long llround(expr arg) { return functions::llround(arg); }
2443 
2447 // template<typename T> typename enable<long long,T>::type llrint(T arg) { return functions::llrint(arg); }
2448  inline long long llrint(half arg) { return functions::llrint(arg); }
2449  inline long long llrint(expr arg) { return functions::llrint(arg); }
2450  #endif
2451 
2455 
2460 // template<typename T> typename enable<half,T>::type frexp(T arg, int *exp) { return functions::frexp(arg, exp); }
2461  inline half frexp(half arg, int *exp) { return functions::frexp(arg, exp); }
2462  inline half frexp(expr arg, int *exp) { return functions::frexp(arg, exp); }
2463 
2468 // template<typename T> typename enable<half,T>::type ldexp(T arg, int exp) { return functions::scalbln(arg, exp); }
2469  inline half ldexp(half arg, int exp) { return functions::scalbln(arg, exp); }
2470  inline half ldexp(expr arg, int exp) { return functions::scalbln(arg, exp); }
2471 
2476 // template<typename T> typename enable<half,T>::type modf(T arg, half *iptr) { return functions::modf(arg, iptr); }
2477  inline half modf(half arg, half *iptr) { return functions::modf(arg, iptr); }
2478  inline half modf(expr arg, half *iptr) { return functions::modf(arg, iptr); }
2479 
2484 // template<typename T> typename enable<half,T>::type scalbn(T arg, int exp) { return functions::scalbln(arg, exp); }
2485  inline half scalbn(half arg, int exp) { return functions::scalbln(arg, exp); }
2486  inline half scalbn(expr arg, int exp) { return functions::scalbln(arg, exp); }
2487 
2492 // template<typename T> typename enable<half,T>::type scalbln(T arg, long exp) { return functions::scalbln(arg, exp); }
2493  inline half scalbln(half arg, long exp) { return functions::scalbln(arg, exp); }
2494  inline half scalbln(expr arg, long exp) { return functions::scalbln(arg, exp); }
2495 
2502 // template<typename T> typename enable<int,T>::type ilogb(T arg) { return functions::ilogb(arg); }
2503  inline int ilogb(half arg) { return functions::ilogb(arg); }
2504  inline int ilogb(expr arg) { return functions::ilogb(arg); }
2505 
2509 // template<typename T> typename enable<half,T>::type logb(T arg) { return functions::logb(arg); }
2510  inline half logb(half arg) { return functions::logb(arg); }
2511  inline half logb(expr arg) { return functions::logb(arg); }
2512 
2517 // template<typename T,typename U> typename enable<half,T,U>::type nextafter(T from, U to) { return functions::nextafter(from, to); }
2518  inline half nextafter(half from, half to) { return functions::nextafter(from, to); }
2519  inline half nextafter(half from, expr to) { return functions::nextafter(from, to); }
2520  inline half nextafter(expr from, half to) { return functions::nextafter(from, to); }
2521  inline half nextafter(expr from, expr to) { return functions::nextafter(from, to); }
2522 
2527 // template<typename T> typename enable<half,T>::type nexttoward(T from, long double to) { return functions::nexttoward(from, to); }
2528  inline half nexttoward(half from, long double to) { return functions::nexttoward(from, to); }
2529  inline half nexttoward(expr from, long double to) { return functions::nexttoward(from, to); }
2530 
2535 // template<typename T,typename U> typename enable<half,T,U>::type copysign(T x, U y) { return functions::copysign(x, y); }
2536  inline half copysign(half x, half y) { return functions::copysign(x, y); }
2537  inline half copysign(half x, expr y) { return functions::copysign(x, y); }
2538  inline half copysign(expr x, half y) { return functions::copysign(x, y); }
2539  inline half copysign(expr x, expr y) { return functions::copysign(x, y); }
2540 
2544 
2545 
2553 // template<typename T> typename enable<int,T>::type fpclassify(T arg) { return functions::fpclassify(arg); }
2554  inline int fpclassify(half arg) { return functions::fpclassify(arg); }
2555  inline int fpclassify(expr arg) { return functions::fpclassify(arg); }
2556 
2561 // template<typename T> typename enable<bool,T>::type isfinite(T arg) { return functions::isfinite(arg); }
2562  inline bool isfinite(half arg) { return functions::isfinite(arg); }
2563  inline bool isfinite(expr arg) { return functions::isfinite(arg); }
2564 
2569 // template<typename T> typename enable<bool,T>::type isinf(T arg) { return functions::isinf(arg); }
2570  inline bool isinf(half arg) { return functions::isinf(arg); }
2571  inline bool isinf(expr arg) { return functions::isinf(arg); }
2572 
2577 // template<typename T> typename enable<bool,T>::type isnan(T arg) { return functions::isnan(arg); }
2578  inline bool isnan(half arg) { return functions::isnan(arg); }
2579  inline bool isnan(expr arg) { return functions::isnan(arg); }
2580 
2585 // template<typename T> typename enable<bool,T>::type isnormal(T arg) { return functions::isnormal(arg); }
2586  inline bool isnormal(half arg) { return functions::isnormal(arg); }
2587  inline bool isnormal(expr arg) { return functions::isnormal(arg); }
2588 
2593 // template<typename T> typename enable<bool,T>::type signbit(T arg) { return functions::signbit(arg); }
2594  inline bool signbit(half arg) { return functions::signbit(arg); }
2595  inline bool signbit(expr arg) { return functions::signbit(arg); }
2596 
2600 
2606 // template<typename T,typename U> typename enable<bool,T,U>::type isgreater(T x, U y) { return functions::isgreater(x, y); }
2607  inline bool isgreater(half x, half y) { return functions::isgreater(x, y); }
2608  inline bool isgreater(half x, expr y) { return functions::isgreater(x, y); }
2609  inline bool isgreater(expr x, half y) { return functions::isgreater(x, y); }
2610  inline bool isgreater(expr x, expr y) { return functions::isgreater(x, y); }
2611 
2617 // template<typename T,typename U> typename enable<bool,T,U>::type isgreaterequal(T x, U y) { return functions::isgreaterequal(x, y); }
2618  inline bool isgreaterequal(half x, half y) { return functions::isgreaterequal(x, y); }
2619  inline bool isgreaterequal(half x, expr y) { return functions::isgreaterequal(x, y); }
2620  inline bool isgreaterequal(expr x, half y) { return functions::isgreaterequal(x, y); }
2621  inline bool isgreaterequal(expr x, expr y) { return functions::isgreaterequal(x, y); }
2622 
2628 // template<typename T,typename U> typename enable<bool,T,U>::type isless(T x, U y) { return functions::isless(x, y); }
2629  inline bool isless(half x, half y) { return functions::isless(x, y); }
2630  inline bool isless(half x, expr y) { return functions::isless(x, y); }
2631  inline bool isless(expr x, half y) { return functions::isless(x, y); }
2632  inline bool isless(expr x, expr y) { return functions::isless(x, y); }
2633 
2639 // template<typename T,typename U> typename enable<bool,T,U>::type islessequal(T x, U y) { return functions::islessequal(x, y); }
2640  inline bool islessequal(half x, half y) { return functions::islessequal(x, y); }
2641  inline bool islessequal(half x, expr y) { return functions::islessequal(x, y); }
2642  inline bool islessequal(expr x, half y) { return functions::islessequal(x, y); }
2643  inline bool islessequal(expr x, expr y) { return functions::islessequal(x, y); }
2644 
2650 // template<typename T,typename U> typename enable<bool,T,U>::type islessgreater(T x, U y) { return functions::islessgreater(x, y); }
2651  inline bool islessgreater(half x, half y) { return functions::islessgreater(x, y); }
2652  inline bool islessgreater(half x, expr y) { return functions::islessgreater(x, y); }
2653  inline bool islessgreater(expr x, half y) { return functions::islessgreater(x, y); }
2654  inline bool islessgreater(expr x, expr y) { return functions::islessgreater(x, y); }
2655 
2661 // template<typename T,typename U> typename enable<bool,T,U>::type isunordered(T x, U y) { return functions::isunordered(x, y); }
2662  inline bool isunordered(half x, half y) { return functions::isunordered(x, y); }
2663  inline bool isunordered(half x, expr y) { return functions::isunordered(x, y); }
2664  inline bool isunordered(expr x, half y) { return functions::isunordered(x, y); }
2665  inline bool isunordered(expr x, expr y) { return functions::isunordered(x, y); }
2666 
2669 
2684  template<typename T,typename U> typename half_caster<T,U>::type half_cast(U arg) { return half_caster<T,U>::cast(arg); }
2685 
2701  template<typename T,std::float_round_style R,typename U> typename half_caster<T,U,R>::type half_cast(U arg)
2702  { return half_caster<T,U,R>::cast(arg); }
2704  }
2705 
2706  using detail::operator==;
2707  using detail::operator!=;
2708  using detail::operator<;
2709  using detail::operator>;
2710  using detail::operator<=;
2711  using detail::operator>=;
2712  using detail::operator+;
2713  using detail::operator-;
2714  using detail::operator*;
2715  using detail::operator/;
2716  using detail::operator<<;
2717  using detail::operator>>;
2718 
2719  using detail::abs;
2720  using detail::fabs;
2721  using detail::fmod;
2722  using detail::remainder;
2723  using detail::remquo;
2724  using detail::fma;
2725  using detail::fmax;
2726  using detail::fmin;
2727  using detail::fdim;
2728  using detail::nanh;
2729  using detail::exp;
2730  using detail::expm1;
2731  using detail::exp2;
2732  using detail::log;
2733  using detail::log10;
2734  using detail::log1p;
2735  using detail::log2;
2736  using detail::sqrt;
2737  using detail::cbrt;
2738  using detail::hypot;
2739  using detail::pow;
2740  using detail::sin;
2741  using detail::cos;
2742  using detail::tan;
2743  using detail::asin;
2744  using detail::acos;
2745  using detail::atan;
2746  using detail::atan2;
2747  using detail::sinh;
2748  using detail::cosh;
2749  using detail::tanh;
2750  using detail::asinh;
2751  using detail::acosh;
2752  using detail::atanh;
2753  using detail::erf;
2754  using detail::erfc;
2755  using detail::lgamma;
2756  using detail::tgamma;
2757  using detail::ceil;
2758  using detail::floor;
2759  using detail::trunc;
2760  using detail::round;
2761  using detail::lround;
2762  using detail::nearbyint;
2763  using detail::rint;
2764  using detail::lrint;
2765 #if HALF_ENABLE_CPP11_LONG_LONG
2766  using detail::llround;
2767  using detail::llrint;
2768 #endif
2769  using detail::frexp;
2770  using detail::ldexp;
2771  using detail::modf;
2772  using detail::scalbn;
2773  using detail::scalbln;
2774  using detail::ilogb;
2775  using detail::logb;
2776  using detail::nextafter;
2777  using detail::nexttoward;
2778  using detail::copysign;
2779  using detail::fpclassify;
2780  using detail::isfinite;
2781  using detail::isinf;
2782  using detail::isnan;
2783  using detail::isnormal;
2784  using detail::signbit;
2785  using detail::isgreater;
2786  using detail::isgreaterequal;
2787  using detail::isless;
2788  using detail::islessequal;
2789  using detail::islessgreater;
2790  using detail::isunordered;
2791 
2792  using detail::half_cast;
2793 }
2794 
2795 
2797 namespace std
2798 {
2802  template<> class numeric_limits<half_float::half> : public numeric_limits<float>
2803  {
2804  public:
2806  static HALF_CONSTEXPR_CONST bool is_signed = true;
2807 
2809  static HALF_CONSTEXPR_CONST bool is_exact = false;
2810 
2812  static HALF_CONSTEXPR_CONST bool is_modulo = false;
2813 
2815  static HALF_CONSTEXPR_CONST bool is_iec559 = true;
2816 
2818  static HALF_CONSTEXPR_CONST bool has_infinity = true;
2819 
2821  static HALF_CONSTEXPR_CONST bool has_quiet_NaN = true;
2822 
2824  static HALF_CONSTEXPR_CONST float_denorm_style has_denorm = denorm_present;
2825 
2830  static HALF_CONSTEXPR_CONST float_round_style round_style = (std::numeric_limits<float>::round_style==
2831  half_float::half::round_style) ? half_float::half::round_style : round_indeterminate;
2832 
2834  static HALF_CONSTEXPR_CONST int digits = 11;
2835 
2837  static HALF_CONSTEXPR_CONST int digits10 = 3;
2838 
2840  static HALF_CONSTEXPR_CONST int max_digits10 = 5;
2841 
2843  static HALF_CONSTEXPR_CONST int radix = 2;
2844 
2846  static HALF_CONSTEXPR_CONST int min_exponent = -13;
2847 
2849  static HALF_CONSTEXPR_CONST int min_exponent10 = -4;
2850 
2852  static HALF_CONSTEXPR_CONST int max_exponent = 16;
2853 
2855  static HALF_CONSTEXPR_CONST int max_exponent10 = 4;
2856 
2858  static HALF_CONSTEXPR half_float::half min() HALF_NOTHROW { return half_float::half(half_float::detail::binary, 0x0400); }
2859 
2861  static HALF_CONSTEXPR half_float::half lowest() HALF_NOTHROW { return half_float::half(half_float::detail::binary, 0xFBFF); }
2862 
2864  static HALF_CONSTEXPR half_float::half max() HALF_NOTHROW { return half_float::half(half_float::detail::binary, 0x7BFF); }
2865 
2867  static HALF_CONSTEXPR half_float::half epsilon() HALF_NOTHROW { return half_float::half(half_float::detail::binary, 0x1400); }
2868 
2870  static HALF_CONSTEXPR half_float::half round_error() HALF_NOTHROW
2871  { return half_float::half(half_float::detail::binary, (round_style==std::round_to_nearest) ? 0x3800 : 0x3C00); }
2872 
2874  static HALF_CONSTEXPR half_float::half infinity() HALF_NOTHROW { return half_float::half(half_float::detail::binary, 0x7C00); }
2875 
2877  static HALF_CONSTEXPR half_float::half quiet_NaN() HALF_NOTHROW { return half_float::half(half_float::detail::binary, 0x7FFF); }
2878 
2880  static HALF_CONSTEXPR half_float::half signaling_NaN() HALF_NOTHROW { return half_float::half(half_float::detail::binary, 0x7DFF); }
2881 
2883  static HALF_CONSTEXPR half_float::half denorm_min() HALF_NOTHROW { return half_float::half(half_float::detail::binary, 0x0001); }
2884  };
2885 
2886 #if HALF_ENABLE_CPP11_HASH
2887  template<> struct hash<half_float::half> //: unary_function<half_float::half,size_t>
2890  {
2892  typedef half_float::half argument_type;
2893 
2895  typedef size_t result_type;
2896 
2900  result_type operator()(argument_type arg) const
2901  { return hash<half_float::detail::uint16>()(static_cast<unsigned int>(arg.data_)&-(arg.data_!=0x8000)); }
2902  };
2903 #endif
2904 }
2905 
2906 
2907 #undef HALF_CONSTEXPR
2908 #undef HALF_CONSTEXPR_CONST
2909 #undef HALF_NOEXCEPT
2910 #undef HALF_NOTHROW
2911 #ifdef HALF_POP_WARNINGS
2912  #pragma warning(pop)
2913  #undef HALF_POP_WARNINGS
2914 #endif
2915 
2916 #endif
half_float::detail::functions::scalbln
static half scalbln(half arg, long exp)
Definition: half.hpp:1565
half_float::detail::functions::atan2
static expr atan2(float x, float y)
Definition: half.hpp:1351
half_float::detail::binary_specialized::fmin
static expr fmin(float x, float y)
Definition: half.hpp:1859
half_float::half::operator*=
detail::enable< half &, T >::type operator*=(T rhs)
Definition: half.hpp:974
half_float::detail::operator+
enable< expr, T, U >::type operator+(T x, U y)
Definition: half.hpp:2005
half_float::detail::functions::remainder
static expr remainder(float x, float y)
Definition: half.hpp:1110
half_float::detail::expm1
expr expm1(half arg)
Definition: half.hpp:2167
half_float::detail::round
half round(half arg)
Definition: half.hpp:2406
half_float::detail::round_half_up
uint16 round_half_up(uint16 value)
Definition: half.hpp:893
half_float::detail::int2half
uint16 int2half(T value)
Definition: half.hpp:608
half_float::detail::int2half_impl
uint16 int2half_impl(T value)
Definition: half.hpp:566
half_float::detail::scalbln
half scalbln(half arg, long exp)
Definition: half.hpp:2493
half_float::detail::uint16
unsigned short uint16
Unsigned integer of (at least) 16 bits width.
Definition: half.hpp:309
half_float::detail::logb
half logb(half arg)
Definition: half.hpp:2510
half_float::detail::functions::ceil
static half ceil(half arg)
Definition: half.hpp:1487
half_float::detail::float2half
uint16 float2half(float value)
Definition: half.hpp:555
half_float::half::operator++
half operator++(int)
Definition: half.hpp:1017
half_float::detail::functions::asinh
static expr asinh(float arg)
Definition: half.hpp:1371
half_float::detail::ldexp
half ldexp(half arg, int exp)
Definition: half.hpp:2469
half_float::detail::half2float
float half2float(uint16 value)
Definition: half.hpp:789
half_float::detail::expr
Definition: half.hpp:327
half_float::half
Definition: half.hpp:923
half_float::detail::is_float
Type traits for floating point types.
Definition: half.hpp:289
half_float::detail::scalbn
half scalbn(half arg, int exp)
Definition: half.hpp:2485
half_float::detail::modf
half modf(half arg, half *iptr)
Definition: half.hpp:2477
half_float::detail::functions::isnormal
static bool isnormal(half arg)
Definition: half.hpp:1732
half_float::detail::functions::trunc
static half trunc(half arg)
Definition: half.hpp:1492
half_float::detail::functions::remquo
static expr remquo(float x, float y, int *quo)
Definition: half.hpp:1141
half_float::detail::binary_t
Tag type for binary construction.
Definition: half.hpp:319
half_float::detail::functions::log1p
static expr log1p(float arg)
Definition: half.hpp:1256
half_float::detail::functions::round
static half round(half arg)
Definition: half.hpp:1497
half_float::half::operator++
half & operator++()
Definition: half.hpp:1009
half_float::detail::round_half_impl
uint16 round_half_impl(uint16 value)
Definition: half.hpp:855
half_float::detail::islessequal
bool islessequal(half x, half y)
Definition: half.hpp:2640
half_float::detail::isnan
bool isnan(half arg)
Definition: half.hpp:2578
half_float::detail::isgreaterequal
bool isgreaterequal(half x, half y)
Definition: half.hpp:2618
half_float::half::half
HALF_CONSTEXPR half()
Definition: half.hpp:937
half_float::detail::log
expr log(half arg)
Definition: half.hpp:2181
half_float::detail::hypot
expr hypot(half x, half y)
Definition: half.hpp:2228
half_float::detail::functions::tan
static expr tan(float arg)
Definition: half.hpp:1330
half_float::half::half
half(detail::expr rhs)
Definition: half.hpp:942
half_float::detail::functions::isfinite
static bool isfinite(half arg)
Definition: half.hpp:1714
half_float::half::operator=
half & operator=(float rhs)
Definition: half.hpp:985
half_float::detail::functions::lrint
static long lrint(half arg)
Definition: half.hpp:1512
half_float::detail::half2float_impl
float half2float_impl(uint16 value, true_type)
Definition: half.hpp:617
half_float::half::half
half(float rhs)
Definition: half.hpp:946
half_float::detail::functions::islessequal
static bool islessequal(half x, half y)
Definition: half.hpp:1783
half_float::detail::atanh
expr atanh(half arg)
Definition: half.hpp:2342
half_float::detail::fpclassify
int fpclassify(half arg)
Definition: half.hpp:2554
half_float::detail::functions::read
static std::basic_istream< charT, traits > & read(std::basic_istream< charT, traits > &in, half &arg)
Definition: half.hpp:1092
half_float::detail::asin
expr asin(half arg)
Definition: half.hpp:2272
half_float::detail::functions::cbrt
static expr cbrt(float arg)
Definition: half.hpp:1285
half_float::detail::log10
expr log10(half arg)
Definition: half.hpp:2188
half_float::detail::lrint
long lrint(half arg)
Definition: half.hpp:2434
half_float::detail::builtin_isnan
bool builtin_isnan(T arg)
Definition: half.hpp:393
half_float::half::operator+=
detail::enable< half &, T >::type operator+=(T rhs)
Definition: half.hpp:962
half_float::half::operator*=
half & operator*=(float rhs)
Definition: half.hpp:1000
half_float::detail::exp2
expr exp2(half arg)
Definition: half.hpp:2174
half_float::detail::fabs
half fabs(half arg)
Definition: half.hpp:2068
half_float::detail::tgamma
expr tgamma(half arg)
Definition: half.hpp:2374
half_float::detail::enable
Definition: half.hpp:345
half_float::detail::functions::isnotequal
static bool isnotequal(half x, half y)
Definition: half.hpp:1752
half_float::detail::isnormal
bool isnormal(half arg)
Definition: half.hpp:2586
half_float::detail::signbit
bool signbit(half arg)
Definition: half.hpp:2594
half_float::detail::acosh
expr acosh(half arg)
Definition: half.hpp:2335
half_float::detail::binary_specialized::fmax
static expr fmax(float x, float y)
Definition: half.hpp:1876
half_float::detail::functions::nanh
static half nanh(const char *)
Definition: half.hpp:1212
half_float::detail::float2half_impl
uint16 float2half_impl(float value, true_type)
Definition: half.hpp:427
half_float::detail::functions::frexp
static half frexp(half arg, int *exp)
Definition: half.hpp:1530
half_float::detail::functions::lround
static long lround(half arg)
Definition: half.hpp:1502
half_float::detail::fmod
expr fmod(half x, half y)
Definition: half.hpp:2076
half_float::detail::tanh
expr tanh(half arg)
Definition: half.hpp:2321
half_float::detail::functions::floor
static half floor(half arg)
Definition: half.hpp:1482
half_float::detail::functions::exp2
static expr exp2(float arg)
Definition: half.hpp:1234
half_float::detail::half_cast
half_caster< T, U >::type half_cast(U arg)
Definition: half.hpp:2684
half_float::detail::erf
expr erf(half arg)
Definition: half.hpp:2353
half_float::detail::exp
expr exp(half arg)
Definition: half.hpp:2160
half_float::detail::nearbyint
half nearbyint(half arg)
Definition: half.hpp:2420
half_float::detail::functions::isinf
static bool isinf(half arg)
Definition: half.hpp:1720
half_float::detail::pow
expr pow(half base, half exp)
Definition: half.hpp:2238
half_float::detail::fdim
expr fdim(half x, half y)
Definition: half.hpp:2142
half_float::detail::functions::tgamma
static expr tgamma(float arg)
Definition: half.hpp:1455
half_float::detail::functions::nextafter
static half nextafter(half from, half to)
Definition: half.hpp:1658
half_float::detail::operator>>
std::basic_istream< charT, traits > & operator>>(std::basic_istream< charT, traits > &in, half &arg)
Definition: half.hpp:2051
half_float::detail::sin
expr sin(half arg)
Definition: half.hpp:2251
half_float::detail::functions::acosh
static expr acosh(float arg)
Definition: half.hpp:1383
half_float::detail::functions::expm1
static expr expm1(float arg)
Definition: half.hpp:1222
half_float::detail::functions
Wrapper implementing unspecialized half-precision functions.
Definition: half.hpp:1057
half_float::detail::acos
expr acos(half arg)
Definition: half.hpp:2279
half_float::detail::functions::hypot
static expr hypot(float x, float y)
Definition: half.hpp:1301
half_float::detail::islessgreater
bool islessgreater(half x, half y)
Definition: half.hpp:2651
half_float::detail::functions::log2
static expr log2(float arg)
Definition: half.hpp:1268
half_float::detail::functions::fdim
static expr fdim(float x, float y)
Definition: half.hpp:1187
half_float::half::operator-=
detail::enable< half &, T >::type operator-=(T rhs)
Definition: half.hpp:968
half_float::half::operator/=
detail::enable< half &, T >::type operator/=(T rhs)
Definition: half.hpp:980
half_float::detail::remainder
expr remainder(half x, half y)
Definition: half.hpp:2086
half_float::detail::functions::tanh
static expr tanh(float arg)
Definition: half.hpp:1366
half_float::detail::unary_specialized::fabs
static half fabs(half arg)
Definition: half.hpp:1842
half_float::detail::ceil
half ceil(half arg)
Definition: half.hpp:2385
half_float::detail::functions::cosh
static expr cosh(float arg)
Definition: half.hpp:1361
half_float::detail::atan
expr atan(half arg)
Definition: half.hpp:2286
half_float::detail::functions::write
static std::basic_ostream< charT, traits > & write(std::basic_ostream< charT, traits > &out, float arg)
Definition: half.hpp:1086
half_float::detail::isunordered
bool isunordered(half x, half y)
Definition: half.hpp:2662
half_float::detail::cos
expr cos(half arg)
Definition: half.hpp:2258
half_float::detail::functions::isgreater
static bool isgreater(half x, half y)
Definition: half.hpp:1759
HALF_ROUND_STYLE
#define HALF_ROUND_STYLE
Definition: half.hpp:211
half_float::detail::rint
half rint(half arg)
Definition: half.hpp:2427
half_float::half::operator--
half & operator--()
Definition: half.hpp:1013
half_float::detail::nextafter
half nextafter(half from, half to)
Definition: half.hpp:2518
half_float::detail::log2
expr log2(half arg)
Definition: half.hpp:2202
half_float::half::operator=
half & operator=(detail::expr rhs)
Definition: half.hpp:956
half_float::detail::unary_specialized
Definition: half.hpp:1833
half_float::detail::log1p
expr log1p(half arg)
Definition: half.hpp:2195
half_float::detail::frexp
half frexp(half arg, int *exp)
Definition: half.hpp:2461
half_float::detail::functions::atan
static expr atan(float arg)
Definition: half.hpp:1345
half_float::detail::builtin_isinf
bool builtin_isinf(T arg)
Definition: half.hpp:377
half_float::detail::abs
half abs(half arg)
Definition: half.hpp:2061
half_float::detail::isless
bool isless(half x, half y)
Definition: half.hpp:2629
half_float::half::operator--
half operator--(int)
Definition: half.hpp:1021
half_float::detail::copysign
half copysign(half x, half y)
Definition: half.hpp:2536
HALF_ROUND_TIES_TO_EVEN
#define HALF_ROUND_TIES_TO_EVEN
Definition: half.hpp:220
half_float::detail::functions::multiplies
static expr multiplies(float x, float y)
Definition: half.hpp:1074
half_float::detail::atan2
expr atan2(half x, half y)
Definition: half.hpp:2294
half_float::detail::sqrt
expr sqrt(half arg)
Definition: half.hpp:2213
half_float::half::operator/=
half & operator/=(float rhs)
Definition: half.hpp:1005
half_float::detail::functions::sqrt
static expr sqrt(float arg)
Definition: half.hpp:1280
half_float::detail::fmax
half fmax(half x, half y)
Definition: half.hpp:2122
half_float::detail::round_half
uint16 round_half(uint16 value)
Definition: half.hpp:888
half_float::detail::half2int
T half2int(uint16 value)
Definition: half.hpp:842
half_float
Definition: half.hpp:260
half_float::detail::bool_type
Helper for tag dispatching.
Definition: half.hpp:284
half_float::detail::builtin_signbit
bool builtin_signbit(T arg)
Definition: half.hpp:409
half_float::detail::floor
half floor(half arg)
Definition: half.hpp:2392
half_float::detail::functions::log
static expr log(float arg)
Definition: half.hpp:1246
half_float::detail::functions::lgamma
static expr lgamma(float arg)
Definition: half.hpp:1431
half_float::detail::functions::fma
static expr fma(float x, float y, float z)
Definition: half.hpp:1201
half_float::detail::trunc
half trunc(half arg)
Definition: half.hpp:2399
half_float::detail::functions::fmod
static expr fmod(float x, float y)
Definition: half.hpp:1104
half_float::detail::cosh
expr cosh(half arg)
Definition: half.hpp:2314
half_float::detail::functions::isequal
static bool isequal(half x, half y)
Definition: half.hpp:1745
half_float::detail::functions::erfc
static expr erfc(float arg)
Definition: half.hpp:1419
half_float::detail::functions::fpclassify
static int fpclassify(half arg)
Definition: half.hpp:1698
std
Extensions to the C++ standard library.
Definition: unique_id.h:200
half_float::detail::functions::nexttoward
static half nexttoward(half from, long double to)
Definition: half.hpp:1676
half_float::detail::nexttoward
half nexttoward(half from, long double to)
Definition: half.hpp:2528
half_float::detail::functions::isunordered
static bool isunordered(half x, half y)
Definition: half.hpp:1805
half_float::detail::isfinite
bool isfinite(half arg)
Definition: half.hpp:2562
half_float::detail::functions::log10
static expr log10(float arg)
Definition: half.hpp:1251
half_float::detail::functions::isless
static bool isless(half x, half y)
Definition: half.hpp:1775
half_float::detail::functions::logb
static half logb(half arg)
Definition: half.hpp:1638
half_float::detail::functions::sin
static expr sin(float arg)
Definition: half.hpp:1320
half_float::detail::functions::erf
static expr erf(float arg)
Definition: half.hpp:1407
half_float::detail::binary_specialized
Definition: half.hpp:1854
half_float::detail::functions::islessgreater
static bool islessgreater(half x, half y)
Definition: half.hpp:1791
half_float::detail::functions::atanh
static expr atanh(float arg)
Definition: half.hpp:1395
half_float::detail::sinh
expr sinh(half arg)
Definition: half.hpp:2307
half_float::detail::asinh
expr asinh(half arg)
Definition: half.hpp:2328
half_float::detail::lround
long lround(half arg)
Definition: half.hpp:2413
half_float::detail::functions::acos
static expr acos(float arg)
Definition: half.hpp:1340
half_float::detail::half_caster
Definition: half.hpp:1917
half_float::detail::functions::cos
static expr cos(float arg)
Definition: half.hpp:1325
half_float::detail::conditional
Conditional type.
Definition: half.hpp:280
half_float::detail::half2int_impl
T half2int_impl(uint16 value)
Definition: half.hpp:800
half_float::detail::ilogb
int ilogb(half arg)
Definition: half.hpp:2503
half_float::detail::functions::exp
static expr exp(float arg)
Definition: half.hpp:1217
half_float::detail::functions::signbit
static bool signbit(half arg)
Definition: half.hpp:1738
half_float::detail::isgreater
bool isgreater(half x, half y)
Definition: half.hpp:2607
half_float::detail::functions::minus
static expr minus(float x, float y)
Definition: half.hpp:1068
half_float::detail::functions::divides
static expr divides(float x, float y)
Definition: half.hpp:1080
half_float::detail::tan
expr tan(half arg)
Definition: half.hpp:2265
half_float::detail::erfc
expr erfc(half arg)
Definition: half.hpp:2360
half_float::detail::result
Definition: half.hpp:366
half_float::detail::functions::asin
static expr asin(float arg)
Definition: half.hpp:1335
half_float::detail::functions::copysign
static half copysign(half x, half y)
Definition: half.hpp:1692
half_float::detail::remquo
expr remquo(half x, half y, int *quo)
Definition: half.hpp:2097
half_float::detail::functions::plus
static expr plus(float x, float y)
Definition: half.hpp:1062
half_float::detail::half2int_up
T half2int_up(uint16 value)
Definition: half.hpp:848
half_float::detail::functions::isgreaterequal
static bool isgreaterequal(half x, half y)
Definition: half.hpp:1767
half_float::half::operator+=
half & operator+=(float rhs)
Definition: half.hpp:990
half_float::detail::functions::isnan
static bool isnan(half arg)
Definition: half.hpp:1726
half_float::detail::isinf
bool isinf(half arg)
Definition: half.hpp:2570
half_float::detail::lgamma
expr lgamma(half arg)
Definition: half.hpp:2367
half_float::detail::functions::modf
static half modf(half arg, half *iptr)
Definition: half.hpp:1545
half_float::detail::cbrt
expr cbrt(half arg)
Definition: half.hpp:2220
half_float::detail::fma
expr fma(half x, half y, half z)
Definition: half.hpp:2108
half_float::detail::nanh
half nanh(const char *arg)
Definition: half.hpp:2150
half_float::detail::functions::pow
static expr pow(float base, float exp)
Definition: half.hpp:1315
half_float::half::operator-=
half & operator-=(float rhs)
Definition: half.hpp:995
half_float::detail::functions::sinh
static expr sinh(float arg)
Definition: half.hpp:1356
half_float::detail::functions::rint
static half rint(half arg)
Definition: half.hpp:1507
half_float::detail::functions::ilogb
static int ilogb(half arg)
Definition: half.hpp:1619
half_float::detail::fmin
half fmin(half x, half y)
Definition: half.hpp:2132
half_float::detail::expr::expr
HALF_CONSTEXPR expr(float f)
Definition: half.hpp:330
half_float::detail::unary_specialized::negate
static HALF_CONSTEXPR half negate(half arg)
Definition: half.hpp:1837