Debian Codegraph @

rts/c/scalar_f16.h

raw
1 // Start of scalar_f16.h.
2
3 // Half-precision is emulated if needed (e.g. in straight C) with the
4 // native type used if possible. The emulation works by typedef'ing
5 // 'float' to 'f16', and then implementing all operations on single
6 // precision. To cut down on duplication, we use the same code for
7 // those Futhark functions that require just operators or casts. The
8 // in-memory representation for arrays will still be 16 bits even
9 // under emulation, so the compiler will have to be careful when
10 // generating reads or writes.
11
12 #if !defined(cl_khr_fp16) && !(defined(__CUDA_ARCH__) && __CUDA_ARCH__ >= 600) && !(defined(ISPC))
13 #define EMULATE_F16
14 #endif
15
16 #if !defined(EMULATE_F16) && defined(__OPENCL_VERSION__)
17 #pragma OPENCL EXTENSION cl_khr_fp16 : enable
18 #endif
19
20 #ifdef EMULATE_F16
21
22 // Note that the half-precision storage format is still 16 bits - the
23 // compiler will have to be real careful!
24 typedef float f16;
25
26 #elif defined(ISPC)
27 typedef float16 f16;
28
29 #else
30
31 #ifdef __CUDA_ARCH__
32 #include <cuda_fp16.h>
33 #endif
34
35 typedef half f16;
36
37 #endif
38
39 // Some of these functions convert to single precision because half
40 // precision versions are not available.
41 SCALAR_FUN_ATTR f16 fadd16(f16 x, f16 y) { return x + y; }
42 SCALAR_FUN_ATTR f16 fsub16(f16 x, f16 y) { return x - y; }
43 SCALAR_FUN_ATTR f16 fmul16(f16 x, f16 y) { return x * y; }
44 SCALAR_FUN_ATTR bool cmplt16(f16 x, f16 y) { return x < y; }
45 SCALAR_FUN_ATTR bool cmple16(f16 x, f16 y) { return x <= y; }
46 SCALAR_FUN_ATTR f16 sitofp_i8_f16(int8_t x) { return (f16) x; }
47 SCALAR_FUN_ATTR f16 sitofp_i16_f16(int16_t x) { return (f16) x; }
48 SCALAR_FUN_ATTR f16 sitofp_i32_f16(int32_t x) { return (f16) x; }
49 SCALAR_FUN_ATTR f16 sitofp_i64_f16(int64_t x) { return (f16) x; }
50 SCALAR_FUN_ATTR f16 uitofp_i8_f16(uint8_t x) { return (f16) x; }
51 SCALAR_FUN_ATTR f16 uitofp_i16_f16(uint16_t x) { return (f16) x; }
52 SCALAR_FUN_ATTR f16 uitofp_i32_f16(uint32_t x) { return (f16) x; }
53 SCALAR_FUN_ATTR f16 uitofp_i64_f16(uint64_t x) { return (f16) x; }
54 SCALAR_FUN_ATTR int8_t fptosi_f16_i8(f16 x) { return (int8_t) (float) x; }
55 SCALAR_FUN_ATTR int16_t fptosi_f16_i16(f16 x) { return (int16_t) x; }
56 SCALAR_FUN_ATTR int32_t fptosi_f16_i32(f16 x) { return (int32_t) x; }
57 SCALAR_FUN_ATTR int64_t fptosi_f16_i64(f16 x) { return (int64_t) x; }
58 SCALAR_FUN_ATTR uint8_t fptoui_f16_i8(f16 x) { return (uint8_t) (float) x; }
59 SCALAR_FUN_ATTR uint16_t fptoui_f16_i16(f16 x) { return (uint16_t) x; }
60 SCALAR_FUN_ATTR uint32_t fptoui_f16_i32(f16 x) { return (uint32_t) x; }
61 SCALAR_FUN_ATTR uint64_t fptoui_f16_i64(f16 x) { return (uint64_t) x; }
62 SCALAR_FUN_ATTR bool ftob_f16_bool(f16 x) { return x != (f16)0; }
63 SCALAR_FUN_ATTR f16 btof_bool_f16(bool x) { return x ? 1 : 0; }
64
65 #ifndef EMULATE_F16
66
67 SCALAR_FUN_ATTR bool futrts_isnan16(f16 x) { return isnan((float)x); }
68
69 #ifdef __OPENCL_VERSION__
70
71 SCALAR_FUN_ATTR f16 fabs16(f16 x) { return fabs(x); }
72 SCALAR_FUN_ATTR f16 fmax16(f16 x, f16 y) { return fmax(x, y); }
73 SCALAR_FUN_ATTR f16 fmin16(f16 x, f16 y) { return fmin(x, y); }
74 SCALAR_FUN_ATTR f16 fpow16(f16 x, f16 y) { return pow(x, y); }
75
76 #elif defined(ISPC)
77
78 SCALAR_FUN_ATTR f16 fabs16(f16 x) { return abs(x); }
79 SCALAR_FUN_ATTR f16 fmax16(f16 x, f16 y) { return futrts_isnan16(x) ? y : futrts_isnan16(y) ? x : max(x, y); }
80 SCALAR_FUN_ATTR f16 fmin16(f16 x, f16 y) { return futrts_isnan16(x) ? y : futrts_isnan16(y) ? x : min(x, y); }
81 SCALAR_FUN_ATTR f16 fpow16(f16 x, f16 y) { return pow(x, y); }
82
83 #else // Assuming CUDA.
84
85 SCALAR_FUN_ATTR f16 fabs16(f16 x) { return fabsf(x); }
86 SCALAR_FUN_ATTR f16 fmax16(f16 x, f16 y) { return fmaxf(x, y); }
87 SCALAR_FUN_ATTR f16 fmin16(f16 x, f16 y) { return fminf(x, y); }
88 SCALAR_FUN_ATTR f16 fpow16(f16 x, f16 y) { return powf(x, y); }
89
90 #endif
91
92 #if defined(ISPC)
93 SCALAR_FUN_ATTR bool futrts_isinf16(float x) { return !futrts_isnan16(x) && futrts_isnan16(x - x); }
94 SCALAR_FUN_ATTR bool futrts_isfinite16(float x) { return !futrts_isnan16(x) && !futrts_isinf16(x); }
95 #else
96 SCALAR_FUN_ATTR bool futrts_isinf16(f16 x) { return isinf((float)x); }
97 #endif
98
99 #ifdef __OPENCL_VERSION__
100 SCALAR_FUN_ATTR f16 futrts_log16(f16 x) { return log(x); }
101 SCALAR_FUN_ATTR f16 futrts_log2_16(f16 x) { return log2(x); }
102 SCALAR_FUN_ATTR f16 futrts_log10_16(f16 x) { return log10(x); }
103 SCALAR_FUN_ATTR f16 futrts_log1p_16(f16 x) { return log1p(x); }
104 SCALAR_FUN_ATTR f16 futrts_sqrt16(f16 x) { return sqrt(x); }
105 SCALAR_FUN_ATTR f16 futrts_rsqrt16(f16 x) { return rsqrt(x); }
106 SCALAR_FUN_ATTR f16 futrts_cbrt16(f16 x) { return cbrt(x); }
107 SCALAR_FUN_ATTR f16 futrts_exp16(f16 x) { return exp(x); }
108 SCALAR_FUN_ATTR f16 futrts_cos16(f16 x) { return cos(x); }
109 SCALAR_FUN_ATTR f16 futrts_cospi16(f16 x) { return cospi(x); }
110 SCALAR_FUN_ATTR f16 futrts_sin16(f16 x) { return sin(x); }
111 SCALAR_FUN_ATTR f16 futrts_sinpi16(f16 x) { return sinpi(x); }
112 SCALAR_FUN_ATTR f16 futrts_tan16(f16 x) { return tan(x); }
113 SCALAR_FUN_ATTR f16 futrts_tanpi16(f16 x) { return tanpi(x); }
114 SCALAR_FUN_ATTR f16 futrts_acos16(f16 x) { return acos(x); }
115 SCALAR_FUN_ATTR f16 futrts_acospi16(f16 x) { return acospi(x); }
116 SCALAR_FUN_ATTR f16 futrts_asin16(f16 x) { return asin(x); }
117 SCALAR_FUN_ATTR f16 futrts_asinpi16(f16 x) { return asinpi(x); }
118 SCALAR_FUN_ATTR f16 futrts_atan16(f16 x) { return atan(x); }
119 SCALAR_FUN_ATTR f16 futrts_atanpi16(f16 x) { return atanpi(x); }
120 SCALAR_FUN_ATTR f16 futrts_cosh16(f16 x) { return cosh(x); }
121 SCALAR_FUN_ATTR f16 futrts_sinh16(f16 x) { return sinh(x); }
122 SCALAR_FUN_ATTR f16 futrts_tanh16(f16 x) { return tanh(x); }
123 SCALAR_FUN_ATTR f16 futrts_acosh16(f16 x) { return acosh(x); }
124 SCALAR_FUN_ATTR f16 futrts_asinh16(f16 x) { return asinh(x); }
125 SCALAR_FUN_ATTR f16 futrts_atanh16(f16 x) { return atanh(x); }
126 SCALAR_FUN_ATTR f16 futrts_atan2_16(f16 x, f16 y) { return atan2(x, y); }
127 SCALAR_FUN_ATTR f16 futrts_atan2pi_16(f16 x, f16 y) { return atan2pi(x, y); }
128 SCALAR_FUN_ATTR f16 futrts_hypot16(f16 x, f16 y) { return hypot(x, y); }
129 SCALAR_FUN_ATTR f16 futrts_gamma16(f16 x) { return tgamma(x); }
130 SCALAR_FUN_ATTR f16 futrts_lgamma16(f16 x) { return lgamma(x); }
131 SCALAR_FUN_ATTR f16 futrts_erf16(f16 x) { return erf(x); }
132 SCALAR_FUN_ATTR f16 futrts_erfc16(f16 x) { return erfc(x); }
133 SCALAR_FUN_ATTR f16 fmod16(f16 x, f16 y) { return fmod(x, y); }
134 SCALAR_FUN_ATTR f16 futrts_round16(f16 x) { return rint(x); }
135 SCALAR_FUN_ATTR f16 futrts_floor16(f16 x) { return floor(x); }
136 SCALAR_FUN_ATTR f16 futrts_ceil16(f16 x) { return ceil(x); }
137 SCALAR_FUN_ATTR f16 futrts_nextafter16(f16 x, f16 y) { return nextafter(x, y); }
138 SCALAR_FUN_ATTR f16 futrts_lerp16(f16 v0, f16 v1, f16 t) { return mix(v0, v1, t); }
139 SCALAR_FUN_ATTR f16 futrts_ldexp16(f16 x, int32_t y) { return ldexp(x, y); }
140 SCALAR_FUN_ATTR f16 futrts_copysign16(f16 x, f16 y) { return copysign(x, y); }
141 SCALAR_FUN_ATTR f16 futrts_mad16(f16 a, f16 b, f16 c) { return mad(a, b, c); }
142 SCALAR_FUN_ATTR f16 futrts_fma16(f16 a, f16 b, f16 c) { return fma(a, b, c); }
143
144 #elif defined(ISPC)
145
146 SCALAR_FUN_ATTR f16 futrts_log16(f16 x) { return futrts_isfinite16(x) || (futrts_isinf16(x) && x < 0) ? log(x) : x; }
147 SCALAR_FUN_ATTR f16 futrts_log2_16(f16 x) { return futrts_log16(x) / log(2.0f16); }
148 SCALAR_FUN_ATTR f16 futrts_log10_16(f16 x) { return futrts_log16(x) / log(10.0f16); }
149 SCALAR_FUN_ATTR f16 futrts_log1p_16(f16 x) {
150 if(x == -1.0f16 || (futrts_isinf16(x) && x > 0.0f16)) return x / 0.0f16;
151 f16 y = 1.0f16 + x;
152 f16 z = y - 1.0f16;
153 return log(y) - (z-x)/y;
154 }
155 SCALAR_FUN_ATTR f16 futrts_sqrt16(f16 x) { return (float16)sqrt((float)x); }
156 SCALAR_FUN_ATTR f16 futrts_rsqrt16(f16 x) { return (float16)1/sqrt((float)x); }
157 SCALAR_FUN_ATTR f16 futrts_exp16(f16 x) { return exp(x); }
158 SCALAR_FUN_ATTR f16 futrts_cos16(f16 x) { return (float16)cos((float)x); }
159 SCALAR_FUN_ATTR f16 futrts_cospi16(f16 x) { return (float16)cos((float)M_PI*(float)x); }
160 SCALAR_FUN_ATTR f16 futrts_sin16(f16 x) { return (float16)sin((float)x); }
161 SCALAR_FUN_ATTR f16 futrts_sinpi16(f16 x) { return (float16)sin((float)M_PI*(float)x); }
162 SCALAR_FUN_ATTR f16 futrts_tan16(f16 x) { return (float16)tan((float)x); }
163 SCALAR_FUN_ATTR f16 futrts_tanpi16(f16 x) { return (float16)(tan((float)M_PI*(float)x)); }
164 SCALAR_FUN_ATTR f16 futrts_acos16(f16 x) { return (float16)acos((float)x); }
165 SCALAR_FUN_ATTR f16 futrts_acospi16(f16 x) { return (float16)(acos((float)x)/(float)M_PI); }
166 SCALAR_FUN_ATTR f16 futrts_asin16(f16 x) { return (float16)asin((float)x); }
167 SCALAR_FUN_ATTR f16 futrts_asinpi16(f16 x) { return (float16)(asin((float)x)/(float)M_PI); }
168 SCALAR_FUN_ATTR f16 futrts_atan16(f16 x) { return (float16)atan((float)x); }
169 SCALAR_FUN_ATTR f16 futrts_atanpi16(f16 x) { return (float16)(atan((float)x)/(float)M_PI); }
170 SCALAR_FUN_ATTR f16 futrts_cosh16(f16 x) { return (exp(x)+exp(-x)) / 2.0f16; }
171 SCALAR_FUN_ATTR f16 futrts_sinh16(f16 x) { return (exp(x)-exp(-x)) / 2.0f16; }
172 SCALAR_FUN_ATTR f16 futrts_tanh16(f16 x) { return futrts_sinh16(x)/futrts_cosh16(x); }
173 SCALAR_FUN_ATTR f16 futrts_acosh16(f16 x) {
174 float16 f = x+(float16)sqrt((float)(x*x-1));
175 if(futrts_isfinite16(f)) return log(f);
176 return f;
177 }
178 SCALAR_FUN_ATTR f16 futrts_asinh16(f16 x) {
179 float16 f = x+(float16)sqrt((float)(x*x+1));
180 if(futrts_isfinite16(f)) return log(f);
181 return f;
182 }
183 SCALAR_FUN_ATTR f16 futrts_atanh16(f16 x) {
184 float16 f = (1+x)/(1-x);
185 if(futrts_isfinite16(f)) return log(f)/2.0f16;
186 return f;
187 }
188 SCALAR_FUN_ATTR f16 futrts_atan2_16(f16 x, f16 y) { return (float16)atan2((float)x, (float)y); }
189 SCALAR_FUN_ATTR f16 futrts_atan2pi_16(f16 x, f16 y) { return (float16)(atan2((float)x, (float)y)/(float)M_PI); }
190 SCALAR_FUN_ATTR f16 futrts_hypot16(f16 x, f16 y) { return (float16)futrts_hypot32((float)x, (float)y); }
191
192 extern "C" unmasked uniform float tgammaf(uniform float x);
193 SCALAR_FUN_ATTR f16 futrts_gamma16(f16 x) {
194 f16 res;
195 foreach_active (i) {
196 uniform f16 r = (f16)tgammaf(extract((float)x, i));
197 res = insert(res, i, r);
198 }
199 return res;
200 }
201
202 extern "C" unmasked uniform float lgammaf(uniform float x);
203 SCALAR_FUN_ATTR f16 futrts_lgamma16(f16 x) {
204 f16 res;
205 foreach_active (i) {
206 uniform f16 r = (f16)lgammaf(extract((float)x, i));
207 res = insert(res, i, r);
208 }
209 return res;
210 }
211 SCALAR_FUN_ATTR f16 futrts_cbrt16(f16 x) { return (f16)futrts_cbrt32((float)x); }
212 SCALAR_FUN_ATTR f16 futrts_erf16(f16 x) { return (f16)futrts_erf32((float)x); }
213 SCALAR_FUN_ATTR f16 futrts_erfc16(f16 x) { return (f16)futrts_erfc32((float)x); }
214 SCALAR_FUN_ATTR f16 fmod16(f16 x, f16 y) { return x - y * (float16)trunc((float) (x/y)); }
215 SCALAR_FUN_ATTR f16 futrts_round16(f16 x) { return (float16)round((float)x); }
216 SCALAR_FUN_ATTR f16 futrts_floor16(f16 x) { return (float16)floor((float)x); }
217 SCALAR_FUN_ATTR f16 futrts_ceil16(f16 x) { return (float16)ceil((float)x); }
218 SCALAR_FUN_ATTR f16 futrts_nextafter16(f16 x, f16 y) { return (float16)futrts_nextafter32((float)x, (float) y); }
219 SCALAR_FUN_ATTR f16 futrts_lerp16(f16 v0, f16 v1, f16 t) { return v0 + (v1 - v0) * t; }
220 SCALAR_FUN_ATTR f16 futrts_ldexp16(f16 x, int32_t y) { return futrts_ldexp32((float)x, y); }
221 SCALAR_FUN_ATTR f16 futrts_copysign16(f16 x, f16 y) { return futrts_copysign32((float)x, y); }
222 SCALAR_FUN_ATTR f16 futrts_mad16(f16 a, f16 b, f16 c) { return a * b + c; }
223 SCALAR_FUN_ATTR f16 futrts_fma16(f16 a, f16 b, f16 c) { return a * b + c; }
224
225 #else // Assume CUDA.
226
227 SCALAR_FUN_ATTR f16 futrts_log16(f16 x) { return hlog(x); }
228 SCALAR_FUN_ATTR f16 futrts_log2_16(f16 x) { return hlog2(x); }
229 SCALAR_FUN_ATTR f16 futrts_log10_16(f16 x) { return hlog10(x); }
230 SCALAR_FUN_ATTR f16 futrts_log1p_16(f16 x) { return (f16)log1pf((float)x); }
231 SCALAR_FUN_ATTR f16 futrts_sqrt16(f16 x) { return hsqrt(x); }
232 SCALAR_FUN_ATTR f16 futrts_rsqrt16(f16 x) { return hrsqrt(x); }
233 SCALAR_FUN_ATTR f16 futrts_cbrt16(f16 x) { return cbrtf(x); }
234 SCALAR_FUN_ATTR f16 futrts_exp16(f16 x) { return hexp(x); }
235 SCALAR_FUN_ATTR f16 futrts_cos16(f16 x) { return hcos(x); }
236 SCALAR_FUN_ATTR f16 futrts_cospi16(f16 x) { return hcos((f16)M_PI*x); }
237 SCALAR_FUN_ATTR f16 futrts_sin16(f16 x) { return hsin(x); }
238 SCALAR_FUN_ATTR f16 futrts_sinpi16(f16 x) { return hsin((f16)M_PI*x); }
239 SCALAR_FUN_ATTR f16 futrts_tan16(f16 x) { return tanf(x); }
240 SCALAR_FUN_ATTR f16 futrts_tanpi16(f16 x) { return tanf((f16)M_PI*x); }
241 SCALAR_FUN_ATTR f16 futrts_acos16(f16 x) { return acosf(x); }
242 SCALAR_FUN_ATTR f16 futrts_acospi16(f16 x) { return (f16)acosf(x)/(f16)M_PI; }
243 SCALAR_FUN_ATTR f16 futrts_asin16(f16 x) { return asinf(x); }
244 SCALAR_FUN_ATTR f16 futrts_asinpi16(f16 x) { return (f16)asinf(x)/(f16)M_PI; }
245 SCALAR_FUN_ATTR f16 futrts_atan16(f16 x) { return (f16)atanf(x); }
246 SCALAR_FUN_ATTR f16 futrts_atanpi16(f16 x) { return (f16)atanf(x)/(f16)M_PI; }
247 SCALAR_FUN_ATTR f16 futrts_cosh16(f16 x) { return coshf(x); }
248 SCALAR_FUN_ATTR f16 futrts_sinh16(f16 x) { return sinhf(x); }
249 SCALAR_FUN_ATTR f16 futrts_tanh16(f16 x) { return tanhf(x); }
250 SCALAR_FUN_ATTR f16 futrts_acosh16(f16 x) { return acoshf(x); }
251 SCALAR_FUN_ATTR f16 futrts_asinh16(f16 x) { return asinhf(x); }
252 SCALAR_FUN_ATTR f16 futrts_atanh16(f16 x) { return atanhf(x); }
253 SCALAR_FUN_ATTR f16 futrts_atan2_16(f16 x, f16 y) { return (f16)atan2f(x, y); }
254 SCALAR_FUN_ATTR f16 futrts_atan2pi_16(f16 x, f16 y) { return (f16)atan2f(x, y)/(f16)M_PI; }
255 SCALAR_FUN_ATTR f16 futrts_hypot16(f16 x, f16 y) { return hypotf(x, y); }
256 SCALAR_FUN_ATTR f16 futrts_gamma16(f16 x) { return tgammaf(x); }
257 SCALAR_FUN_ATTR f16 futrts_lgamma16(f16 x) { return lgammaf(x); }
258 SCALAR_FUN_ATTR f16 futrts_erf16(f16 x) { return erff(x); }
259 SCALAR_FUN_ATTR f16 futrts_erfc16(f16 x) { return erfcf(x); }
260 SCALAR_FUN_ATTR f16 fmod16(f16 x, f16 y) { return fmodf(x, y); }
261 SCALAR_FUN_ATTR f16 futrts_round16(f16 x) { return rintf(x); }
262 SCALAR_FUN_ATTR f16 futrts_floor16(f16 x) { return hfloor(x); }
263 SCALAR_FUN_ATTR f16 futrts_ceil16(f16 x) { return hceil(x); }
264 SCALAR_FUN_ATTR f16 futrts_nextafter16(f16 x, f16 y) { return __ushort_as_half(halfbitsnextafter(__half_as_ushort(x), __half_as_ushort(y))); }
265 SCALAR_FUN_ATTR f16 futrts_lerp16(f16 v0, f16 v1, f16 t) { return v0 + (v1 - v0) * t; }
266 SCALAR_FUN_ATTR f16 futrts_ldexp16(f16 x, int32_t y) { return futrts_ldexp32((float)x, y); }
267 SCALAR_FUN_ATTR f16 futrts_copysign16(f16 x, f16 y) { return futrts_copysign32((float)x, y); }
268 SCALAR_FUN_ATTR f16 futrts_mad16(f16 a, f16 b, f16 c) { return a * b + c; }
269 SCALAR_FUN_ATTR f16 futrts_fma16(f16 a, f16 b, f16 c) { return fmaf(a, b, c); }
270
271 #endif
272
273 // The CUDA __half type cannot be put in unions for some reason, so we
274 // use bespoke conversion functions instead.
275 #ifdef __CUDA_ARCH__
276 SCALAR_FUN_ATTR int16_t fptobits_f16_i16(f16 x) { return __half_as_ushort(x); }
277 SCALAR_FUN_ATTR f16 bitstofp_i16_f16(int16_t x) { return __ushort_as_half(x); }
278 #elif defined(ISPC)
279 SCALAR_FUN_ATTR int16_t fptobits_f16_i16(f16 x) { varying int16_t y = *((varying int16_t * uniform)&x); return y;
280 }
281 SCALAR_FUN_ATTR f16 bitstofp_i16_f16(int16_t x) { varying f16 y = *((varying f16 * uniform)&x); return y; }
282 #else
283 SCALAR_FUN_ATTR int16_t fptobits_f16_i16(f16 x) {
284 union {
285 f16 f;
286 int16_t t;
287 } p;
288
289 p.f = x;
290 return p.t;
291 }
292
293 SCALAR_FUN_ATTR f16 bitstofp_i16_f16(int16_t x) {
294 union {
295 int16_t f;
296 f16 t;
297 } p;
298
299 p.f = x;
300 return p.t;
301 }
302 #endif
303
304 #else // No native f16 - emulate.
305
306 SCALAR_FUN_ATTR f16 fabs16(f16 x) { return fabs32(x); }
307 SCALAR_FUN_ATTR f16 fmax16(f16 x, f16 y) { return fmax32(x, y); }
308 SCALAR_FUN_ATTR f16 fmin16(f16 x, f16 y) { return fmin32(x, y); }
309 SCALAR_FUN_ATTR f16 fpow16(f16 x, f16 y) { return fpow32(x, y); }
310 SCALAR_FUN_ATTR bool futrts_isnan16(f16 x) { return futrts_isnan32(x); }
311 SCALAR_FUN_ATTR bool futrts_isinf16(f16 x) { return futrts_isinf32(x); }
312 SCALAR_FUN_ATTR f16 futrts_log16(f16 x) { return futrts_log32(x); }
313 SCALAR_FUN_ATTR f16 futrts_log2_16(f16 x) { return futrts_log2_32(x); }
314 SCALAR_FUN_ATTR f16 futrts_log10_16(f16 x) { return futrts_log10_32(x); }
315 SCALAR_FUN_ATTR f16 futrts_log1p_16(f16 x) { return futrts_log1p_32(x); }
316 SCALAR_FUN_ATTR f16 futrts_sqrt16(f16 x) { return futrts_sqrt32(x); }
317 SCALAR_FUN_ATTR f16 futrts_rsqrt16(f16 x) { return futrts_rsqrt32(x); }
318 SCALAR_FUN_ATTR f16 futrts_cbrt16(f16 x) { return futrts_cbrt32(x); }
319 SCALAR_FUN_ATTR f16 futrts_exp16(f16 x) { return futrts_exp32(x); }
320 SCALAR_FUN_ATTR f16 futrts_cos16(f16 x) { return futrts_cos32(x); }
321 SCALAR_FUN_ATTR f16 futrts_cospi16(f16 x) { return futrts_cospi32(x); }
322 SCALAR_FUN_ATTR f16 futrts_sin16(f16 x) { return futrts_sin32(x); }
323 SCALAR_FUN_ATTR f16 futrts_sinpi16(f16 x) { return futrts_sinpi32(x); }
324 SCALAR_FUN_ATTR f16 futrts_tan16(f16 x) { return futrts_tan32(x); }
325 SCALAR_FUN_ATTR f16 futrts_tanpi16(f16 x) { return futrts_tanpi32(x); }
326 SCALAR_FUN_ATTR f16 futrts_acos16(f16 x) { return futrts_acos32(x); }
327 SCALAR_FUN_ATTR f16 futrts_acospi16(f16 x) { return futrts_acospi32(x); }
328 SCALAR_FUN_ATTR f16 futrts_asin16(f16 x) { return futrts_asin32(x); }
329 SCALAR_FUN_ATTR f16 futrts_asinpi16(f16 x) { return futrts_asinpi32(x); }
330 SCALAR_FUN_ATTR f16 futrts_atan16(f16 x) { return futrts_atan32(x); }
331 SCALAR_FUN_ATTR f16 futrts_atanpi16(f16 x) { return futrts_atanpi32(x); }
332 SCALAR_FUN_ATTR f16 futrts_cosh16(f16 x) { return futrts_cosh32(x); }
333 SCALAR_FUN_ATTR f16 futrts_sinh16(f16 x) { return futrts_sinh32(x); }
334 SCALAR_FUN_ATTR f16 futrts_tanh16(f16 x) { return futrts_tanh32(x); }
335 SCALAR_FUN_ATTR f16 futrts_acosh16(f16 x) { return futrts_acosh32(x); }
336 SCALAR_FUN_ATTR f16 futrts_asinh16(f16 x) { return futrts_asinh32(x); }
337 SCALAR_FUN_ATTR f16 futrts_atanh16(f16 x) { return futrts_atanh32(x); }
338 SCALAR_FUN_ATTR f16 futrts_atan2_16(f16 x, f16 y) { return futrts_atan2_32(x, y); }
339 SCALAR_FUN_ATTR f16 futrts_atan2pi_16(f16 x, f16 y) { return futrts_atan2pi_32(x, y); }
340 SCALAR_FUN_ATTR f16 futrts_hypot16(f16 x, f16 y) { return futrts_hypot32(x, y); }
341 SCALAR_FUN_ATTR f16 futrts_gamma16(f16 x) { return futrts_gamma32(x); }
342 SCALAR_FUN_ATTR f16 futrts_lgamma16(f16 x) { return futrts_lgamma32(x); }
343 SCALAR_FUN_ATTR f16 futrts_erf16(f16 x) { return futrts_erf32(x); }
344 SCALAR_FUN_ATTR f16 futrts_erfc16(f16 x) { return futrts_erfc32(x); }
345 SCALAR_FUN_ATTR f16 fmod16(f16 x, f16 y) { return fmod32(x, y); }
346 SCALAR_FUN_ATTR f16 futrts_round16(f16 x) { return futrts_round32(x); }
347 SCALAR_FUN_ATTR f16 futrts_floor16(f16 x) { return futrts_floor32(x); }
348 SCALAR_FUN_ATTR f16 futrts_ceil16(f16 x) { return futrts_ceil32(x); }
349 SCALAR_FUN_ATTR f16 futrts_nextafter16(f16 x, f16 y) { return halfbits2float(halfbitsnextafter(float2halfbits(x), float2halfbits(y))); }
350 SCALAR_FUN_ATTR f16 futrts_lerp16(f16 v0, f16 v1, f16 t) { return futrts_lerp32(v0, v1, t); }
351 SCALAR_FUN_ATTR f16 futrts_ldexp16(f16 x, int32_t y) { return futrts_ldexp32(x, y); }
352 SCALAR_FUN_ATTR f16 futrts_copysign16(f16 x, f16 y) { return futrts_copysign32((float)x, y); }
353 SCALAR_FUN_ATTR f16 futrts_mad16(f16 a, f16 b, f16 c) { return futrts_mad32(a, b, c); }
354 SCALAR_FUN_ATTR f16 futrts_fma16(f16 a, f16 b, f16 c) { return futrts_fma32(a, b, c); }
355
356 // Even when we are using an OpenCL that does not support cl_khr_fp16,
357 // it must still support vload_half for actually creating a
358 // half-precision number, which can then be efficiently converted to a
359 // float. Similarly for vstore_half.
360 #ifdef __OPENCL_VERSION__
361
362 SCALAR_FUN_ATTR int16_t fptobits_f16_i16(f16 x) {
363 int16_t y;
364 // Violating strict aliasing here.
365 vstore_half((float)x, 0, (half*)&y);
366 return y;
367 }
368
369 SCALAR_FUN_ATTR f16 bitstofp_i16_f16(int16_t x) {
370 return (f16)vload_half(0, (half*)&x);
371 }
372
373 #else
374 SCALAR_FUN_ATTR int16_t fptobits_f16_i16(f16 x) { return (int16_t)float2halfbits(x); }
375 SCALAR_FUN_ATTR f16 bitstofp_i16_f16(int16_t x) { return halfbits2float((uint16_t)x); }
376 SCALAR_FUN_ATTR f16 fsignum16(f16 x) { return futrts_isnan16(x) ? x : (x > 0 ? 1 : 0) - (x < 0 ? 1 : 0); }
377
378 #endif
379
380 #endif
381
382 SCALAR_FUN_ATTR float fpconv_f16_f16(f16 x) { return x; }
383 SCALAR_FUN_ATTR float fpconv_f16_f32(f16 x) { return x; }
384 SCALAR_FUN_ATTR f16 fpconv_f32_f16(float x) { return (f16) x; }
385
386 #ifdef FUTHARK_F64_ENABLED
387 SCALAR_FUN_ATTR double fpconv_f16_f64(f16 x) { return (double) x; }
388 #if defined(ISPC)
389 SCALAR_FUN_ATTR f16 fpconv_f64_f16(double x) { return (f16) ((float)x); }
390 #else
391 SCALAR_FUN_ATTR f16 fpconv_f64_f16(double x) { return (f16) x; }
392 #endif
393 #endif
394
395 // End of scalar_f16.h.