Debian Codegraph @

rts/c/scalar.h

raw
1 // Start of scalar.h.
2
3 // Implementation of the primitive scalar operations. Very
4 // repetitive. This code is inserted directly into both CUDA and
5 // OpenCL programs, as well as the CPU code, so it has some #ifdefs to
6 // work everywhere. Some operations are defined as macros because
7 // this allows us to use them as constant expressions in things like
8 // array sizes and static initialisers.
9
10 // Some of the #ifdefs are because OpenCL uses type-generic functions
11 // for some operations (e.g. sqrt), while C and CUDA sensibly use
12 // distinct functions for different precisions (e.g. sqrtf() and
13 // sqrt()). This is quite annoying. Due to C's unfortunate casting
14 // rules, it is also really easy to accidentally implement
15 // floating-point functions in the wrong precision, so be careful.
16
17 // Double-precision definitions are only included if the preprocessor
18 // macro FUTHARK_F64_ENABLED is set.
19
20 #ifndef M_PI
21 #define M_PI 3.141592653589793
22 #endif
23
24 SCALAR_FUN_ATTR int32_t fptobits_f32_i32(float x);
25 SCALAR_FUN_ATTR float bitstofp_i32_f32(int32_t x);
26
27 SCALAR_FUN_ATTR uint8_t add8(uint8_t x, uint8_t y) { return x + y; }
28 SCALAR_FUN_ATTR uint16_t add16(uint16_t x, uint16_t y) { return x + y; }
29 SCALAR_FUN_ATTR uint32_t add32(uint32_t x, uint32_t y) { return x + y; }
30 SCALAR_FUN_ATTR uint64_t add64(uint64_t x, uint64_t y) { return x + y; }
31
32 SCALAR_FUN_ATTR uint8_t sub8(uint8_t x, uint8_t y) { return x - y; }
33 SCALAR_FUN_ATTR uint16_t sub16(uint16_t x, uint16_t y) { return x - y; }
34 SCALAR_FUN_ATTR uint32_t sub32(uint32_t x, uint32_t y) { return x - y; }
35 SCALAR_FUN_ATTR uint64_t sub64(uint64_t x, uint64_t y) { return x - y; }
36
37 SCALAR_FUN_ATTR uint8_t mul8(uint8_t x, uint8_t y) { return x * y; }
38 SCALAR_FUN_ATTR uint16_t mul16(uint16_t x, uint16_t y) { return x * y; }
39 SCALAR_FUN_ATTR uint32_t mul32(uint32_t x, uint32_t y) { return x * y; }
40 SCALAR_FUN_ATTR uint64_t mul64(uint64_t x, uint64_t y) { return x * y; }
41
42 #if defined(ISPC)
43
44 SCALAR_FUN_ATTR uint8_t udiv8(uint8_t x, uint8_t y) {
45 // This strange pattern is used to prevent the ISPC compiler from
46 // causing SIGFPEs and bogus results on divisions where inactive lanes
47 // have 0-valued divisors. It ensures that any inactive lane instead
48 // has a divisor of 1. https://github.com/ispc/ispc/issues/2292
49 uint8_t ys = 1;
50 foreach_active(i) { ys = y; }
51 return x / ys;
52 }
53
54 SCALAR_FUN_ATTR uint16_t udiv16(uint16_t x, uint16_t y) {
55 uint16_t ys = 1;
56 foreach_active(i) { ys = y; }
57 return x / ys;
58 }
59
60 SCALAR_FUN_ATTR uint32_t udiv32(uint32_t x, uint32_t y) {
61 uint32_t ys = 1;
62 foreach_active(i) { ys = y; }
63 return x / ys;
64 }
65
66 SCALAR_FUN_ATTR uint64_t udiv64(uint64_t x, uint64_t y) {
67 uint64_t ys = 1;
68 foreach_active(i) { ys = y; }
69 return x / ys;
70 }
71
72 SCALAR_FUN_ATTR uint8_t udiv_up8(uint8_t x, uint8_t y) {
73 uint8_t ys = 1;
74 foreach_active(i) { ys = y; }
75 return (x + y - 1) / ys;
76 }
77
78 SCALAR_FUN_ATTR uint16_t udiv_up16(uint16_t x, uint16_t y) {
79 uint16_t ys = 1;
80 foreach_active(i) { ys = y; }
81 return (x + y - 1) / ys;
82 }
83
84 SCALAR_FUN_ATTR uint32_t udiv_up32(uint32_t x, uint32_t y) {
85 uint32_t ys = 1;
86 foreach_active(i) { ys = y; }
87 return (x + y - 1) / ys;
88 }
89
90 SCALAR_FUN_ATTR uint64_t udiv_up64(uint64_t x, uint64_t y) {
91 uint64_t ys = 1;
92 foreach_active(i) { ys = y; }
93 return (x + y - 1) / ys;
94 }
95
96 SCALAR_FUN_ATTR uint8_t umod8(uint8_t x, uint8_t y) {
97 uint8_t ys = 1;
98 foreach_active(i) { ys = y; }
99 return x % ys;
100 }
101
102 SCALAR_FUN_ATTR uint16_t umod16(uint16_t x, uint16_t y) {
103 uint16_t ys = 1;
104 foreach_active(i) { ys = y; }
105 return x % ys;
106 }
107
108 SCALAR_FUN_ATTR uint32_t umod32(uint32_t x, uint32_t y) {
109 uint32_t ys = 1;
110 foreach_active(i) { ys = y; }
111 return x % ys;
112 }
113
114 SCALAR_FUN_ATTR uint64_t umod64(uint64_t x, uint64_t y) {
115 uint64_t ys = 1;
116 foreach_active(i) { ys = y; }
117 return x % ys;
118 }
119
120 SCALAR_FUN_ATTR uint8_t udiv_safe8(uint8_t x, uint8_t y) {
121 uint8_t ys = 1;
122 foreach_active(i) { ys = y; }
123 return y == 0 ? 0 : x / ys;
124 }
125
126 SCALAR_FUN_ATTR uint16_t udiv_safe16(uint16_t x, uint16_t y) {
127 uint16_t ys = 1;
128 foreach_active(i) { ys = y; }
129 return y == 0 ? 0 : x / ys;
130 }
131
132 SCALAR_FUN_ATTR uint32_t udiv_safe32(uint32_t x, uint32_t y) {
133 uint32_t ys = 1;
134 foreach_active(i) { ys = y; }
135 return y == 0 ? 0 : x / ys;
136 }
137
138 SCALAR_FUN_ATTR uint64_t udiv_safe64(uint64_t x, uint64_t y) {
139 uint64_t ys = 1;
140 foreach_active(i) { ys = y; }
141 return y == 0 ? 0 : x / ys;
142 }
143
144 SCALAR_FUN_ATTR uint8_t udiv_up_safe8(uint8_t x, uint8_t y) {
145 uint8_t ys = 1;
146 foreach_active(i) { ys = y; }
147 return y == 0 ? 0 : (x + y - 1) / ys;
148 }
149
150 SCALAR_FUN_ATTR uint16_t udiv_up_safe16(uint16_t x, uint16_t y) {
151 uint16_t ys = 1;
152 foreach_active(i) { ys = y; }
153 return y == 0 ? 0 : (x + y - 1) / ys;
154 }
155
156 SCALAR_FUN_ATTR uint32_t udiv_up_safe32(uint32_t x, uint32_t y) {
157 uint32_t ys = 1;
158 foreach_active(i) { ys = y; }
159 return y == 0 ? 0 : (x + y - 1) / ys;
160 }
161
162 SCALAR_FUN_ATTR uint64_t udiv_up_safe64(uint64_t x, uint64_t y) {
163 uint64_t ys = 1;
164 foreach_active(i) { ys = y; }
165 return y == 0 ? 0 : (x + y - 1) / ys;
166 }
167
168 SCALAR_FUN_ATTR uint8_t umod_safe8(uint8_t x, uint8_t y) {
169 uint8_t ys = 1;
170 foreach_active(i) { ys = y; }
171 return y == 0 ? 0 : x % ys;
172 }
173
174 SCALAR_FUN_ATTR uint16_t umod_safe16(uint16_t x, uint16_t y) {
175 uint16_t ys = 1;
176 foreach_active(i) { ys = y; }
177 return y == 0 ? 0 : x % ys;
178 }
179
180 SCALAR_FUN_ATTR uint32_t umod_safe32(uint32_t x, uint32_t y) {
181 uint32_t ys = 1;
182 foreach_active(i) { ys = y; }
183 return y == 0 ? 0 : x % ys;
184 }
185
186 SCALAR_FUN_ATTR uint64_t umod_safe64(uint64_t x, uint64_t y) {
187 uint64_t ys = 1;
188 foreach_active(i) { ys = y; }
189 return y == 0 ? 0 : x % ys;
190 }
191
192 SCALAR_FUN_ATTR int8_t sdiv8(int8_t x, int8_t y) {
193 int8_t ys = 1;
194 foreach_active(i) { ys = y; }
195 int8_t q = x / ys;
196 int8_t r = x % ys;
197 return q - ((r != 0 && r < 0 != y < 0) ? 1 : 0);
198 }
199
200 SCALAR_FUN_ATTR int16_t sdiv16(int16_t x, int16_t y) {
201 int16_t ys = 1;
202 foreach_active(i) { ys = y; }
203 int16_t q = x / ys;
204 int16_t r = x % ys;
205 return q - ((r != 0 && r < 0 != y < 0) ? 1 : 0);
206 }
207
208 SCALAR_FUN_ATTR int32_t sdiv32(int32_t x, int32_t y) {
209 int32_t ys = 1;
210 foreach_active(i) { ys = y; }
211 int32_t q = x / ys;
212 int32_t r = x % ys;
213 return q - ((r != 0 && r < 0 != y < 0) ? 1 : 0);
214 }
215
216 SCALAR_FUN_ATTR int64_t sdiv64(int64_t x, int64_t y) {
217 int64_t ys = 1;
218 foreach_active(i) { ys = y; }
219 int64_t q = x / ys;
220 int64_t r = x % ys;
221 return q - ((r != 0 && r < 0 != y < 0) ? 1 : 0);
222 }
223
224 SCALAR_FUN_ATTR int8_t sdiv_up8(int8_t x, int8_t y) { return sdiv8(x + y - 1, y); }
225 SCALAR_FUN_ATTR int16_t sdiv_up16(int16_t x, int16_t y) { return sdiv16(x + y - 1, y); }
226 SCALAR_FUN_ATTR int32_t sdiv_up32(int32_t x, int32_t y) { return sdiv32(x + y - 1, y); }
227 SCALAR_FUN_ATTR int64_t sdiv_up64(int64_t x, int64_t y) { return sdiv64(x + y - 1, y); }
228
229 SCALAR_FUN_ATTR int8_t smod8(int8_t x, int8_t y) {
230 int8_t ys = 1;
231 foreach_active(i) { ys = y; }
232 int8_t r = x % ys;
233 return r + (r == 0 || (x > 0 && y > 0) || (x < 0 && y < 0) ? 0 : y);
234 }
235
236 SCALAR_FUN_ATTR int16_t smod16(int16_t x, int16_t y) {
237 int16_t ys = 1;
238 foreach_active(i) { ys = y; }
239 int16_t r = x % ys;
240 return r + (r == 0 || (x > 0 && y > 0) || (x < 0 && y < 0) ? 0 : y);
241 }
242
243 SCALAR_FUN_ATTR int32_t smod32(int32_t x, int32_t y) {
244 int32_t ys = 1;
245 foreach_active(i) { ys = y; }
246 int32_t r = x % ys;
247 return r + (r == 0 || (x > 0 && y > 0) || (x < 0 && y < 0) ? 0 : y);
248 }
249
250 SCALAR_FUN_ATTR int64_t smod64(int64_t x, int64_t y) {
251 int64_t ys = 1;
252 foreach_active(i) { ys = y; }
253 int64_t r = x % ys;
254 return r + (r == 0 || (x > 0 && y > 0) || (x < 0 && y < 0) ? 0 : y);
255 }
256
257 SCALAR_FUN_ATTR int8_t sdiv_safe8(int8_t x, int8_t y) { return y == 0 ? 0 : sdiv8(x, y); }
258 SCALAR_FUN_ATTR int16_t sdiv_safe16(int16_t x, int16_t y) { return y == 0 ? 0 : sdiv16(x, y); }
259 SCALAR_FUN_ATTR int32_t sdiv_safe32(int32_t x, int32_t y) { return y == 0 ? 0 : sdiv32(x, y); }
260 SCALAR_FUN_ATTR int64_t sdiv_safe64(int64_t x, int64_t y) { return y == 0 ? 0 : sdiv64(x, y); }
261
262 SCALAR_FUN_ATTR int8_t sdiv_up_safe8(int8_t x, int8_t y) { return sdiv_safe8(x + y - 1, y); }
263 SCALAR_FUN_ATTR int16_t sdiv_up_safe16(int16_t x, int16_t y) { return sdiv_safe16(x + y - 1, y); }
264 SCALAR_FUN_ATTR int32_t sdiv_up_safe32(int32_t x, int32_t y) { return sdiv_safe32(x + y - 1, y); }
265 SCALAR_FUN_ATTR int64_t sdiv_up_safe64(int64_t x, int64_t y) { return sdiv_safe64(x + y - 1, y); }
266
267 SCALAR_FUN_ATTR int8_t smod_safe8(int8_t x, int8_t y) { return y == 0 ? 0 : smod8(x, y); }
268 SCALAR_FUN_ATTR int16_t smod_safe16(int16_t x, int16_t y) { return y == 0 ? 0 : smod16(x, y); }
269 SCALAR_FUN_ATTR int32_t smod_safe32(int32_t x, int32_t y) { return y == 0 ? 0 : smod32(x, y); }
270 SCALAR_FUN_ATTR int64_t smod_safe64(int64_t x, int64_t y) { return y == 0 ? 0 : smod64(x, y); }
271
272 SCALAR_FUN_ATTR int8_t squot8(int8_t x, int8_t y) {
273 int8_t ys = 1;
274 foreach_active(i) { ys = y; }
275 return x / ys;
276 }
277
278 SCALAR_FUN_ATTR int16_t squot16(int16_t x, int16_t y) {
279 int16_t ys = 1;
280 foreach_active(i) { ys = y; }
281 return x / ys;
282 }
283
284 SCALAR_FUN_ATTR int32_t squot32(int32_t x, int32_t y) {
285 int32_t ys = 1;
286 foreach_active(i) { ys = y; }
287 return x / ys;
288 }
289
290 SCALAR_FUN_ATTR int64_t squot64(int64_t x, int64_t y) {
291 int64_t ys = 1;
292 foreach_active(i) { ys = y; }
293 return x / ys;
294 }
295
296 SCALAR_FUN_ATTR int8_t srem8(int8_t x, int8_t y) {
297 int8_t ys = 1;
298 foreach_active(i) { ys = y; }
299 return x % ys;
300 }
301
302 SCALAR_FUN_ATTR int16_t srem16(int16_t x, int16_t y) {
303 int16_t ys = 1;
304 foreach_active(i) { ys = y; }
305 return x % ys;
306 }
307
308 SCALAR_FUN_ATTR int32_t srem32(int32_t x, int32_t y) {
309 int32_t ys = 1;
310 foreach_active(i) { ys = y; }
311 return x % ys;
312 }
313
314 SCALAR_FUN_ATTR int64_t srem64(int64_t x, int64_t y) {
315 int8_t ys = 1;
316 foreach_active(i) { ys = y; }
317 return x % ys;
318 }
319
320 SCALAR_FUN_ATTR int8_t squot_safe8(int8_t x, int8_t y) {
321 int8_t ys = 1;
322 foreach_active(i) { ys = y; }
323 return y == 0 ? 0 : x / ys;
324 }
325
326 SCALAR_FUN_ATTR int16_t squot_safe16(int16_t x, int16_t y) {
327 int16_t ys = 1;
328 foreach_active(i) { ys = y; }
329 return y == 0 ? 0 : x / ys;
330 }
331
332 SCALAR_FUN_ATTR int32_t squot_safe32(int32_t x, int32_t y) {
333 int32_t ys = 1;
334 foreach_active(i) { ys = y; }
335 return y == 0 ? 0 : x / ys;
336 }
337
338 SCALAR_FUN_ATTR int64_t squot_safe64(int64_t x, int64_t y) {
339 int64_t ys = 1;
340 foreach_active(i) { ys = y; }
341 return y == 0 ? 0 : x / ys;
342 }
343
344 SCALAR_FUN_ATTR int8_t srem_safe8(int8_t x, int8_t y) {
345 int8_t ys = 1;
346 foreach_active(i) { ys = y; }
347 return y == 0 ? 0 : x % ys;
348 }
349
350 SCALAR_FUN_ATTR int16_t srem_safe16(int16_t x, int16_t y) {
351 int16_t ys = 1;
352 foreach_active(i) { ys = y; }
353 return y == 0 ? 0 : x % ys;
354 }
355
356 SCALAR_FUN_ATTR int32_t srem_safe32(int32_t x, int32_t y) {
357 int32_t ys = 1;
358 foreach_active(i) { ys = y; }
359 return y == 0 ? 0 : x % ys;
360 }
361
362 SCALAR_FUN_ATTR int64_t srem_safe64(int64_t x, int64_t y) {
363 int64_t ys = 1;
364 foreach_active(i) { ys = y; }
365 return y == 0 ? 0 : x % ys;
366 }
367
368 #else
369
370 SCALAR_FUN_ATTR uint8_t udiv8(uint8_t x, uint8_t y) { return x / y; }
371 SCALAR_FUN_ATTR uint16_t udiv16(uint16_t x, uint16_t y) { return x / y; }
372 SCALAR_FUN_ATTR uint32_t udiv32(uint32_t x, uint32_t y) { return x / y; }
373 SCALAR_FUN_ATTR uint64_t udiv64(uint64_t x, uint64_t y) { return x / y; }
374
375 SCALAR_FUN_ATTR uint8_t udiv_up8(uint8_t x, uint8_t y) { return (x + y - 1) / y; }
376 SCALAR_FUN_ATTR uint16_t udiv_up16(uint16_t x, uint16_t y) { return (x + y - 1) / y; }
377 SCALAR_FUN_ATTR uint32_t udiv_up32(uint32_t x, uint32_t y) { return (x + y - 1) / y; }
378 SCALAR_FUN_ATTR uint64_t udiv_up64(uint64_t x, uint64_t y) { return (x + y - 1) / y; }
379
380 SCALAR_FUN_ATTR uint8_t umod8(uint8_t x, uint8_t y) { return x % y; }
381 SCALAR_FUN_ATTR uint16_t umod16(uint16_t x, uint16_t y) { return x % y; }
382 SCALAR_FUN_ATTR uint32_t umod32(uint32_t x, uint32_t y) { return x % y; }
383 SCALAR_FUN_ATTR uint64_t umod64(uint64_t x, uint64_t y) { return x % y; }
384
385 SCALAR_FUN_ATTR uint8_t udiv_safe8(uint8_t x, uint8_t y) { return y == 0 ? 0 : x / y; }
386 SCALAR_FUN_ATTR uint16_t udiv_safe16(uint16_t x, uint16_t y) { return y == 0 ? 0 : x / y; }
387 SCALAR_FUN_ATTR uint32_t udiv_safe32(uint32_t x, uint32_t y) { return y == 0 ? 0 : x / y; }
388 SCALAR_FUN_ATTR uint64_t udiv_safe64(uint64_t x, uint64_t y) { return y == 0 ? 0 : x / y; }
389
390 SCALAR_FUN_ATTR uint8_t udiv_up_safe8(uint8_t x, uint8_t y) { return y == 0 ? 0 : (x + y - 1) / y; }
391 SCALAR_FUN_ATTR uint16_t udiv_up_safe16(uint16_t x, uint16_t y) { return y == 0 ? 0 : (x + y - 1) / y; }
392 SCALAR_FUN_ATTR uint32_t udiv_up_safe32(uint32_t x, uint32_t y) { return y == 0 ? 0 : (x + y - 1) / y; }
393 SCALAR_FUN_ATTR uint64_t udiv_up_safe64(uint64_t x, uint64_t y) { return y == 0 ? 0 : (x + y - 1) / y; }
394
395 SCALAR_FUN_ATTR uint8_t umod_safe8(uint8_t x, uint8_t y) { return y == 0 ? 0 : x % y; }
396 SCALAR_FUN_ATTR uint16_t umod_safe16(uint16_t x, uint16_t y) { return y == 0 ? 0 : x % y; }
397 SCALAR_FUN_ATTR uint32_t umod_safe32(uint32_t x, uint32_t y) { return y == 0 ? 0 : x % y; }
398 SCALAR_FUN_ATTR uint64_t umod_safe64(uint64_t x, uint64_t y) { return y == 0 ? 0 : x % y; }
399
400 SCALAR_FUN_ATTR int8_t sdiv8(int8_t x, int8_t y) {
401 int8_t q = x / y;
402 int8_t r = x % y;
403 return q - ((r != 0 && r < 0 != y < 0) ? 1 : 0);
404 }
405
406 SCALAR_FUN_ATTR int16_t sdiv16(int16_t x, int16_t y) {
407 int16_t q = x / y;
408 int16_t r = x % y;
409 return q - ((r != 0 && r < 0 != y < 0) ? 1 : 0);
410 }
411
412 SCALAR_FUN_ATTR int32_t sdiv32(int32_t x, int32_t y) {
413 int32_t q = x / y;
414 int32_t r = x % y;
415 return q - ((r != 0 && r < 0 != y < 0) ? 1 : 0);
416 }
417
418 SCALAR_FUN_ATTR int64_t sdiv64(int64_t x, int64_t y) {
419 int64_t q = x / y;
420 int64_t r = x % y;
421 return q - ((r != 0 && r < 0 != y < 0) ? 1 : 0);
422 }
423
424 SCALAR_FUN_ATTR int8_t sdiv_up8(int8_t x, int8_t y) { return sdiv8(x + y - 1, y); }
425 SCALAR_FUN_ATTR int16_t sdiv_up16(int16_t x, int16_t y) { return sdiv16(x + y - 1, y); }
426 SCALAR_FUN_ATTR int32_t sdiv_up32(int32_t x, int32_t y) { return sdiv32(x + y - 1, y); }
427 SCALAR_FUN_ATTR int64_t sdiv_up64(int64_t x, int64_t y) { return sdiv64(x + y - 1, y); }
428
429 SCALAR_FUN_ATTR int8_t smod8(int8_t x, int8_t y) {
430 int8_t r = x % y;
431 return r + (r == 0 || (x > 0 && y > 0) || (x < 0 && y < 0) ? 0 : y);
432 }
433
434 SCALAR_FUN_ATTR int16_t smod16(int16_t x, int16_t y) {
435 int16_t r = x % y;
436 return r + (r == 0 || (x > 0 && y > 0) || (x < 0 && y < 0) ? 0 : y);
437 }
438
439 SCALAR_FUN_ATTR int32_t smod32(int32_t x, int32_t y) {
440 int32_t r = x % y;
441 return r + (r == 0 || (x > 0 && y > 0) || (x < 0 && y < 0) ? 0 : y);
442 }
443
444 SCALAR_FUN_ATTR int64_t smod64(int64_t x, int64_t y) {
445 int64_t r = x % y;
446 return r + (r == 0 || (x > 0 && y > 0) || (x < 0 && y < 0) ? 0 : y);
447 }
448
449 SCALAR_FUN_ATTR int8_t sdiv_safe8(int8_t x, int8_t y) { return y == 0 ? 0 : sdiv8(x, y); }
450 SCALAR_FUN_ATTR int16_t sdiv_safe16(int16_t x, int16_t y) { return y == 0 ? 0 : sdiv16(x, y); }
451 SCALAR_FUN_ATTR int32_t sdiv_safe32(int32_t x, int32_t y) { return y == 0 ? 0 : sdiv32(x, y); }
452 SCALAR_FUN_ATTR int64_t sdiv_safe64(int64_t x, int64_t y) { return y == 0 ? 0 : sdiv64(x, y); }
453
454 SCALAR_FUN_ATTR int8_t sdiv_up_safe8(int8_t x, int8_t y) { return sdiv_safe8(x + y - 1, y);}
455 SCALAR_FUN_ATTR int16_t sdiv_up_safe16(int16_t x, int16_t y) { return sdiv_safe16(x + y - 1, y); }
456 SCALAR_FUN_ATTR int32_t sdiv_up_safe32(int32_t x, int32_t y) { return sdiv_safe32(x + y - 1, y); }
457 SCALAR_FUN_ATTR int64_t sdiv_up_safe64(int64_t x, int64_t y) { return sdiv_safe64(x + y - 1, y); }
458
459 SCALAR_FUN_ATTR int8_t smod_safe8(int8_t x, int8_t y) { return y == 0 ? 0 : smod8(x, y); }
460 SCALAR_FUN_ATTR int16_t smod_safe16(int16_t x, int16_t y) { return y == 0 ? 0 : smod16(x, y); }
461 SCALAR_FUN_ATTR int32_t smod_safe32(int32_t x, int32_t y) { return y == 0 ? 0 : smod32(x, y); }
462 SCALAR_FUN_ATTR int64_t smod_safe64(int64_t x, int64_t y) { return y == 0 ? 0 : smod64(x, y); }
463
464 SCALAR_FUN_ATTR int8_t squot8(int8_t x, int8_t y) { return x / y; }
465 SCALAR_FUN_ATTR int16_t squot16(int16_t x, int16_t y) { return x / y; }
466 SCALAR_FUN_ATTR int32_t squot32(int32_t x, int32_t y) { return x / y; }
467 SCALAR_FUN_ATTR int64_t squot64(int64_t x, int64_t y) { return x / y; }
468
469 SCALAR_FUN_ATTR int8_t srem8(int8_t x, int8_t y) { return x % y; }
470 SCALAR_FUN_ATTR int16_t srem16(int16_t x, int16_t y) { return x % y; }
471 SCALAR_FUN_ATTR int32_t srem32(int32_t x, int32_t y) { return x % y; }
472 SCALAR_FUN_ATTR int64_t srem64(int64_t x, int64_t y) { return x % y; }
473
474 SCALAR_FUN_ATTR int8_t squot_safe8(int8_t x, int8_t y) { return y == 0 ? 0 : x / y; }
475 SCALAR_FUN_ATTR int16_t squot_safe16(int16_t x, int16_t y) { return y == 0 ? 0 : x / y; }
476 SCALAR_FUN_ATTR int32_t squot_safe32(int32_t x, int32_t y) { return y == 0 ? 0 : x / y; }
477 SCALAR_FUN_ATTR int64_t squot_safe64(int64_t x, int64_t y) { return y == 0 ? 0 : x / y; }
478
479 SCALAR_FUN_ATTR int8_t srem_safe8(int8_t x, int8_t y) { return y == 0 ? 0 : x % y; }
480 SCALAR_FUN_ATTR int16_t srem_safe16(int16_t x, int16_t y) { return y == 0 ? 0 : x % y; }
481 SCALAR_FUN_ATTR int32_t srem_safe32(int32_t x, int32_t y) { return y == 0 ? 0 : x % y; }
482 SCALAR_FUN_ATTR int64_t srem_safe64(int64_t x, int64_t y) { return y == 0 ? 0 : x % y; }
483
484 #endif
485
486 SCALAR_FUN_ATTR int8_t smin8(int8_t x, int8_t y) { return x < y ? x : y; }
487 SCALAR_FUN_ATTR int16_t smin16(int16_t x, int16_t y) { return x < y ? x : y; }
488 SCALAR_FUN_ATTR int32_t smin32(int32_t x, int32_t y) { return x < y ? x : y; }
489 SCALAR_FUN_ATTR int64_t smin64(int64_t x, int64_t y) { return x < y ? x : y; }
490
491 SCALAR_FUN_ATTR uint8_t umin8(uint8_t x, uint8_t y) { return x < y ? x : y; }
492 SCALAR_FUN_ATTR uint16_t umin16(uint16_t x, uint16_t y) { return x < y ? x : y; }
493 SCALAR_FUN_ATTR uint32_t umin32(uint32_t x, uint32_t y) { return x < y ? x : y; }
494 SCALAR_FUN_ATTR uint64_t umin64(uint64_t x, uint64_t y) { return x < y ? x : y; }
495
496 SCALAR_FUN_ATTR int8_t smax8(int8_t x, int8_t y) { return x < y ? y : x; }
497 SCALAR_FUN_ATTR int16_t smax16(int16_t x, int16_t y) { return x < y ? y : x; }
498 SCALAR_FUN_ATTR int32_t smax32(int32_t x, int32_t y) { return x < y ? y : x; }
499 SCALAR_FUN_ATTR int64_t smax64(int64_t x, int64_t y) { return x < y ? y : x; }
500
501 SCALAR_FUN_ATTR uint8_t umax8(uint8_t x, uint8_t y) { return x < y ? y : x; }
502 SCALAR_FUN_ATTR uint16_t umax16(uint16_t x, uint16_t y) { return x < y ? y : x; }
503 SCALAR_FUN_ATTR uint32_t umax32(uint32_t x, uint32_t y) { return x < y ? y : x; }
504 SCALAR_FUN_ATTR uint64_t umax64(uint64_t x, uint64_t y) { return x < y ? y : x; }
505
506 SCALAR_FUN_ATTR uint8_t shl8(uint8_t x, uint8_t y) { return (uint8_t)(x << y); }
507 SCALAR_FUN_ATTR uint16_t shl16(uint16_t x, uint16_t y) { return (uint16_t)(x << y); }
508 SCALAR_FUN_ATTR uint32_t shl32(uint32_t x, uint32_t y) { return x << y; }
509 SCALAR_FUN_ATTR uint64_t shl64(uint64_t x, uint64_t y) { return x << y; }
510
511 SCALAR_FUN_ATTR uint8_t lshr8(uint8_t x, uint8_t y) { return x >> y; }
512 SCALAR_FUN_ATTR uint16_t lshr16(uint16_t x, uint16_t y) { return x >> y; }
513 SCALAR_FUN_ATTR uint32_t lshr32(uint32_t x, uint32_t y) { return x >> y; }
514 SCALAR_FUN_ATTR uint64_t lshr64(uint64_t x, uint64_t y) { return x >> y; }
515
516 SCALAR_FUN_ATTR int8_t ashr8(int8_t x, int8_t y) { return x >> y; }
517 SCALAR_FUN_ATTR int16_t ashr16(int16_t x, int16_t y) { return x >> y; }
518 SCALAR_FUN_ATTR int32_t ashr32(int32_t x, int32_t y) { return x >> y; }
519 SCALAR_FUN_ATTR int64_t ashr64(int64_t x, int64_t y) { return x >> y; }
520
521 SCALAR_FUN_ATTR uint8_t and8(uint8_t x, uint8_t y) { return x & y; }
522 SCALAR_FUN_ATTR uint16_t and16(uint16_t x, uint16_t y) { return x & y; }
523 SCALAR_FUN_ATTR uint32_t and32(uint32_t x, uint32_t y) { return x & y; }
524 SCALAR_FUN_ATTR uint64_t and64(uint64_t x, uint64_t y) { return x & y; }
525
526 SCALAR_FUN_ATTR uint8_t or8(uint8_t x, uint8_t y) { return x | y; }
527 SCALAR_FUN_ATTR uint16_t or16(uint16_t x, uint16_t y) { return x | y; }
528 SCALAR_FUN_ATTR uint32_t or32(uint32_t x, uint32_t y) { return x | y; }
529 SCALAR_FUN_ATTR uint64_t or64(uint64_t x, uint64_t y) { return x | y; }
530
531 SCALAR_FUN_ATTR uint8_t xor8(uint8_t x, uint8_t y) { return x ^ y; }
532 SCALAR_FUN_ATTR uint16_t xor16(uint16_t x, uint16_t y) { return x ^ y; }
533 SCALAR_FUN_ATTR uint32_t xor32(uint32_t x, uint32_t y) { return x ^ y; }
534 SCALAR_FUN_ATTR uint64_t xor64(uint64_t x, uint64_t y) { return x ^ y; }
535
536 SCALAR_FUN_ATTR bool ult8(uint8_t x, uint8_t y) { return x < y; }
537 SCALAR_FUN_ATTR bool ult16(uint16_t x, uint16_t y) { return x < y; }
538 SCALAR_FUN_ATTR bool ult32(uint32_t x, uint32_t y) { return x < y; }
539 SCALAR_FUN_ATTR bool ult64(uint64_t x, uint64_t y) { return x < y; }
540
541 SCALAR_FUN_ATTR bool ule8(uint8_t x, uint8_t y) { return x <= y; }
542 SCALAR_FUN_ATTR bool ule16(uint16_t x, uint16_t y) { return x <= y; }
543 SCALAR_FUN_ATTR bool ule32(uint32_t x, uint32_t y) { return x <= y; }
544 SCALAR_FUN_ATTR bool ule64(uint64_t x, uint64_t y) { return x <= y; }
545
546 SCALAR_FUN_ATTR bool slt8(int8_t x, int8_t y) { return x < y; }
547 SCALAR_FUN_ATTR bool slt16(int16_t x, int16_t y) { return x < y; }
548 SCALAR_FUN_ATTR bool slt32(int32_t x, int32_t y) { return x < y; }
549 SCALAR_FUN_ATTR bool slt64(int64_t x, int64_t y) { return x < y; }
550
551 SCALAR_FUN_ATTR bool sle8(int8_t x, int8_t y) { return x <= y; }
552 SCALAR_FUN_ATTR bool sle16(int16_t x, int16_t y) { return x <= y; }
553 SCALAR_FUN_ATTR bool sle32(int32_t x, int32_t y) { return x <= y; }
554 SCALAR_FUN_ATTR bool sle64(int64_t x, int64_t y) { return x <= y; }
555
556 SCALAR_FUN_ATTR uint8_t pow8(uint8_t x, uint8_t y) {
557 uint8_t res = 1, rem = y;
558 while (rem != 0) {
559 if (rem & 1)
560 res *= x;
561 rem >>= 1;
562 x *= x;
563 }
564 return res;
565 }
566
567 SCALAR_FUN_ATTR uint16_t pow16(uint16_t x, uint16_t y) {
568 uint16_t res = 1, rem = y;
569 while (rem != 0) {
570 if (rem & 1)
571 res *= x;
572 rem >>= 1;
573 x *= x;
574 }
575 return res;
576 }
577
578 SCALAR_FUN_ATTR uint32_t pow32(uint32_t x, uint32_t y) {
579 uint32_t res = 1, rem = y;
580 while (rem != 0) {
581 if (rem & 1)
582 res *= x;
583 rem >>= 1;
584 x *= x;
585 }
586 return res;
587 }
588
589 SCALAR_FUN_ATTR uint64_t pow64(uint64_t x, uint64_t y) {
590 uint64_t res = 1, rem = y;
591 while (rem != 0) {
592 if (rem & 1)
593 res *= x;
594 rem >>= 1;
595 x *= x;
596 }
597 return res;
598 }
599
600 SCALAR_FUN_ATTR bool itob_i8_bool(int8_t x) { return x != 0; }
601 SCALAR_FUN_ATTR bool itob_i16_bool(int16_t x) { return x != 0; }
602 SCALAR_FUN_ATTR bool itob_i32_bool(int32_t x) { return x != 0; }
603 SCALAR_FUN_ATTR bool itob_i64_bool(int64_t x) { return x != 0; }
604
605 SCALAR_FUN_ATTR int8_t btoi_bool_i8(bool x) { return x; }
606 SCALAR_FUN_ATTR int16_t btoi_bool_i16(bool x) { return x; }
607 SCALAR_FUN_ATTR int32_t btoi_bool_i32(bool x) { return x; }
608 SCALAR_FUN_ATTR int64_t btoi_bool_i64(bool x) { return x; }
609
610 #define sext_i8_i8(x) ((int8_t) (int8_t) (x))
611 #define sext_i8_i16(x) ((int16_t) (int8_t) (x))
612 #define sext_i8_i32(x) ((int32_t) (int8_t) (x))
613 #define sext_i8_i64(x) ((int64_t) (int8_t) (x))
614 #define sext_i16_i8(x) ((int8_t) (int16_t) (x))
615 #define sext_i16_i16(x) ((int16_t) (int16_t) (x))
616 #define sext_i16_i32(x) ((int32_t) (int16_t) (x))
617 #define sext_i16_i64(x) ((int64_t) (int16_t) (x))
618 #define sext_i32_i8(x) ((int8_t) (int32_t) (x))
619 #define sext_i32_i16(x) ((int16_t) (int32_t) (x))
620 #define sext_i32_i32(x) ((int32_t) (int32_t) (x))
621 #define sext_i32_i64(x) ((int64_t) (int32_t) (x))
622 #define sext_i64_i8(x) ((int8_t) (int64_t) (x))
623 #define sext_i64_i16(x) ((int16_t) (int64_t) (x))
624 #define sext_i64_i32(x) ((int32_t) (int64_t) (x))
625 #define sext_i64_i64(x) ((int64_t) (int64_t) (x))
626 #define zext_i8_i8(x) ((int8_t) (uint8_t) (x))
627 #define zext_i8_i16(x) ((int16_t) (uint8_t) (x))
628 #define zext_i8_i32(x) ((int32_t) (uint8_t) (x))
629 #define zext_i8_i64(x) ((int64_t) (uint8_t) (x))
630 #define zext_i16_i8(x) ((int8_t) (uint16_t) (x))
631 #define zext_i16_i16(x) ((int16_t) (uint16_t) (x))
632 #define zext_i16_i32(x) ((int32_t) (uint16_t) (x))
633 #define zext_i16_i64(x) ((int64_t) (uint16_t) (x))
634 #define zext_i32_i8(x) ((int8_t) (uint32_t) (x))
635 #define zext_i32_i16(x) ((int16_t) (uint32_t) (x))
636 #define zext_i32_i32(x) ((int32_t) (uint32_t) (x))
637 #define zext_i32_i64(x) ((int64_t) (uint32_t) (x))
638 #define zext_i64_i8(x) ((int8_t) (uint64_t) (x))
639 #define zext_i64_i16(x) ((int16_t) (uint64_t) (x))
640 #define zext_i64_i32(x) ((int32_t) (uint64_t) (x))
641 #define zext_i64_i64(x) ((int64_t) (uint64_t) (x))
642
643 SCALAR_FUN_ATTR int8_t abs8(int8_t x) { return (int8_t)abs(x); }
644 SCALAR_FUN_ATTR int16_t abs16(int16_t x) { return (int16_t)abs(x); }
645 SCALAR_FUN_ATTR int32_t abs32(int32_t x) { return abs(x); }
646 SCALAR_FUN_ATTR int64_t abs64(int64_t x) {
647 #if defined(__OPENCL_VERSION__) || defined(ISPC)
648 return abs(x);
649 #else
650 return llabs(x);
651 #endif
652 }
653
654 #if defined(__OPENCL_VERSION__)
655
656 SCALAR_FUN_ATTR int32_t futrts_popc8(int8_t x) { return popcount(x); }
657 SCALAR_FUN_ATTR int32_t futrts_popc16(int16_t x) { return popcount(x); }
658 SCALAR_FUN_ATTR int32_t futrts_popc32(int32_t x) { return popcount(x); }
659 SCALAR_FUN_ATTR int32_t futrts_popc64(int64_t x) { return popcount(x); }
660
661 #elif defined(__CUDA_ARCH__)
662
663 SCALAR_FUN_ATTR int32_t futrts_popc8(int8_t x) { return __popc(zext_i8_i32(x)); }
664 SCALAR_FUN_ATTR int32_t futrts_popc16(int16_t x) { return __popc(zext_i16_i32(x)); }
665 SCALAR_FUN_ATTR int32_t futrts_popc32(int32_t x) { return __popc(x); }
666 SCALAR_FUN_ATTR int32_t futrts_popc64(int64_t x) { return __popcll(x); }
667
668 #else // Not OpenCL or CUDA, but plain C.
669
670 SCALAR_FUN_ATTR int32_t futrts_popc8(uint8_t x) {
671 int c = 0;
672 for (; x; ++c) { x &= x - 1; }
673 return c;
674 }
675
676 SCALAR_FUN_ATTR int32_t futrts_popc16(uint16_t x) {
677 int c = 0;
678 for (; x; ++c) { x &= x - 1; }
679 return c;
680 }
681
682 SCALAR_FUN_ATTR int32_t futrts_popc32(uint32_t x) {
683 int c = 0;
684 for (; x; ++c) { x &= x - 1; }
685 return c;
686 }
687
688 SCALAR_FUN_ATTR int32_t futrts_popc64(uint64_t x) {
689 int c = 0;
690 for (; x; ++c) { x &= x - 1; }
691 return c;
692 }
693 #endif
694
695 #if defined(__OPENCL_VERSION__)
696 SCALAR_FUN_ATTR uint8_t futrts_umul_hi8 ( uint8_t a, uint8_t b) { return mul_hi(a, b); }
697 SCALAR_FUN_ATTR uint16_t futrts_umul_hi16(uint16_t a, uint16_t b) { return mul_hi(a, b); }
698 SCALAR_FUN_ATTR uint32_t futrts_umul_hi32(uint32_t a, uint32_t b) { return mul_hi(a, b); }
699 SCALAR_FUN_ATTR uint64_t futrts_umul_hi64(uint64_t a, uint64_t b) { return mul_hi(a, b); }
700 SCALAR_FUN_ATTR uint8_t futrts_smul_hi8 ( int8_t a, int8_t b) { return mul_hi(a, b); }
701 SCALAR_FUN_ATTR uint16_t futrts_smul_hi16(int16_t a, int16_t b) { return mul_hi(a, b); }
702 SCALAR_FUN_ATTR uint32_t futrts_smul_hi32(int32_t a, int32_t b) { return mul_hi(a, b); }
703 SCALAR_FUN_ATTR uint64_t futrts_smul_hi64(int64_t a, int64_t b) { return mul_hi(a, b); }
704 #elif defined(__CUDA_ARCH__)
705 SCALAR_FUN_ATTR uint8_t futrts_umul_hi8(uint8_t a, uint8_t b) { return ((uint16_t)a) * ((uint16_t)b) >> 8; }
706 SCALAR_FUN_ATTR uint16_t futrts_umul_hi16(uint16_t a, uint16_t b) { return ((uint32_t)a) * ((uint32_t)b) >> 16; }
707 SCALAR_FUN_ATTR uint32_t futrts_umul_hi32(uint32_t a, uint32_t b) { return __umulhi(a, b); }
708 SCALAR_FUN_ATTR uint64_t futrts_umul_hi64(uint64_t a, uint64_t b) { return __umul64hi(a, b); }
709 SCALAR_FUN_ATTR uint8_t futrts_smul_hi8 ( int8_t a, int8_t b) { return ((int16_t)a) * ((int16_t)b) >> 8; }
710 SCALAR_FUN_ATTR uint16_t futrts_smul_hi16(int16_t a, int16_t b) { return ((int32_t)a) * ((int32_t)b) >> 16; }
711 SCALAR_FUN_ATTR uint32_t futrts_smul_hi32(int32_t a, int32_t b) { return __mulhi(a, b); }
712 SCALAR_FUN_ATTR uint64_t futrts_smul_hi64(int64_t a, int64_t b) { return __mul64hi(a, b); }
713 #elif defined(ISPC)
714 SCALAR_FUN_ATTR uint8_t futrts_umul_hi8(uint8_t a, uint8_t b) { return ((uint16_t)a) * ((uint16_t)b) >> 8; }
715 SCALAR_FUN_ATTR uint16_t futrts_umul_hi16(uint16_t a, uint16_t b) { return ((uint32_t)a) * ((uint32_t)b) >> 16; }
716 SCALAR_FUN_ATTR uint32_t futrts_umul_hi32(uint32_t a, uint32_t b) { return ((uint64_t)a) * ((uint64_t)b) >> 32; }
717 SCALAR_FUN_ATTR uint64_t futrts_umul_hi64(uint64_t a, uint64_t b) {
718 uint64_t ah = a >> 32;
719 uint64_t al = a & 0xffffffff;
720 uint64_t bh = b >> 32;
721 uint64_t bl = b & 0xffffffff;
722
723 uint64_t p1 = al * bl;
724 uint64_t p2 = al * bh;
725 uint64_t p3 = ah * bl;
726 uint64_t p4 = ah * bh;
727
728 uint64_t p1h = p1 >> 32;
729 uint64_t p2h = p2 >> 32;
730 uint64_t p3h = p3 >> 32;
731 uint64_t p2l = p2 & 0xffffffff;
732 uint64_t p3l = p3 & 0xffffffff;
733
734 uint64_t l = p1h + p2l + p3l;
735 uint64_t m = (p2 >> 32) + (p3 >> 32);
736 uint64_t h = (l >> 32) + m + p4;
737
738 return h;
739 }
740 SCALAR_FUN_ATTR int8_t futrts_smul_hi8 ( int8_t a, int8_t b) { return ((uint16_t)a) * ((uint16_t)b) >> 8; }
741 SCALAR_FUN_ATTR int16_t futrts_smul_hi16(int16_t a, int16_t b) { return ((uint32_t)a) * ((uint32_t)b) >> 16; }
742 SCALAR_FUN_ATTR int32_t futrts_smul_hi32(int32_t a, int32_t b) { return ((uint64_t)a) * ((uint64_t)b) >> 32; }
743 SCALAR_FUN_ATTR int64_t futrts_smul_hi64(int64_t a, int64_t b) {
744 uint64_t ah = a >> 32;
745 uint64_t al = a & 0xffffffff;
746 uint64_t bh = b >> 32;
747 uint64_t bl = b & 0xffffffff;
748
749 uint64_t p1 = al * bl;
750 int64_t p2 = al * bh;
751 int64_t p3 = ah * bl;
752 uint64_t p4 = ah * bh;
753
754 uint64_t p1h = p1 >> 32;
755 uint64_t p2h = p2 >> 32;
756 uint64_t p3h = p3 >> 32;
757 uint64_t p2l = p2 & 0xffffffff;
758 uint64_t p3l = p3 & 0xffffffff;
759
760 uint64_t l = p1h + p2l + p3l;
761 uint64_t m = (p2 >> 32) + (p3 >> 32);
762 uint64_t h = (l >> 32) + m + p4;
763
764 return h;
765 }
766
767 #else // Not OpenCL, ISPC, or CUDA, but plain C.
768 SCALAR_FUN_ATTR uint8_t futrts_umul_hi8(uint8_t a, uint8_t b) { return ((uint16_t)a) * ((uint16_t)b) >> 8; }
769 SCALAR_FUN_ATTR uint16_t futrts_umul_hi16(uint16_t a, uint16_t b) { return ((uint32_t)a) * ((uint32_t)b) >> 16; }
770 SCALAR_FUN_ATTR uint32_t futrts_umul_hi32(uint32_t a, uint32_t b) { return ((uint64_t)a) * ((uint64_t)b) >> 32; }
771 SCALAR_FUN_ATTR uint64_t futrts_umul_hi64(uint64_t a, uint64_t b) { return ((__uint128_t)a) * ((__uint128_t)b) >> 64; }
772 SCALAR_FUN_ATTR int8_t futrts_smul_hi8(int8_t a, int8_t b) { return ((int16_t)a) * ((int16_t)b) >> 8; }
773 SCALAR_FUN_ATTR int16_t futrts_smul_hi16(int16_t a, int16_t b) { return ((int32_t)a) * ((int32_t)b) >> 16; }
774 SCALAR_FUN_ATTR int32_t futrts_smul_hi32(int32_t a, int32_t b) { return ((int64_t)a) * ((int64_t)b) >> 32; }
775 SCALAR_FUN_ATTR int64_t futrts_smul_hi64(int64_t a, int64_t b) { return ((__int128_t)a) * ((__int128_t)b) >> 64; }
776 #endif
777
778 #if defined(__OPENCL_VERSION__)
779 SCALAR_FUN_ATTR uint8_t futrts_umad_hi8 ( uint8_t a, uint8_t b, uint8_t c) { return mad_hi(a, b, c); }
780 SCALAR_FUN_ATTR uint16_t futrts_umad_hi16(uint16_t a, uint16_t b, uint16_t c) { return mad_hi(a, b, c); }
781 SCALAR_FUN_ATTR uint32_t futrts_umad_hi32(uint32_t a, uint32_t b, uint32_t c) { return mad_hi(a, b, c); }
782 SCALAR_FUN_ATTR uint64_t futrts_umad_hi64(uint64_t a, uint64_t b, uint64_t c) { return mad_hi(a, b, c); }
783 SCALAR_FUN_ATTR uint8_t futrts_smad_hi8( int8_t a, int8_t b, int8_t c) { return mad_hi(a, b, c); }
784 SCALAR_FUN_ATTR uint16_t futrts_smad_hi16(int16_t a, int16_t b, int16_t c) { return mad_hi(a, b, c); }
785 SCALAR_FUN_ATTR uint32_t futrts_smad_hi32(int32_t a, int32_t b, int32_t c) { return mad_hi(a, b, c); }
786 SCALAR_FUN_ATTR uint64_t futrts_smad_hi64(int64_t a, int64_t b, int64_t c) { return mad_hi(a, b, c); }
787 #else // Not OpenCL
788
789 SCALAR_FUN_ATTR uint8_t futrts_umad_hi8( uint8_t a, uint8_t b, uint8_t c) { return futrts_umul_hi8(a, b) + c; }
790 SCALAR_FUN_ATTR uint16_t futrts_umad_hi16(uint16_t a, uint16_t b, uint16_t c) { return futrts_umul_hi16(a, b) + c; }
791 SCALAR_FUN_ATTR uint32_t futrts_umad_hi32(uint32_t a, uint32_t b, uint32_t c) { return futrts_umul_hi32(a, b) + c; }
792 SCALAR_FUN_ATTR uint64_t futrts_umad_hi64(uint64_t a, uint64_t b, uint64_t c) { return futrts_umul_hi64(a, b) + c; }
793 SCALAR_FUN_ATTR uint8_t futrts_smad_hi8 ( int8_t a, int8_t b, int8_t c) { return futrts_smul_hi8(a, b) + c; }
794 SCALAR_FUN_ATTR uint16_t futrts_smad_hi16(int16_t a, int16_t b, int16_t c) { return futrts_smul_hi16(a, b) + c; }
795 SCALAR_FUN_ATTR uint32_t futrts_smad_hi32(int32_t a, int32_t b, int32_t c) { return futrts_smul_hi32(a, b) + c; }
796 SCALAR_FUN_ATTR uint64_t futrts_smad_hi64(int64_t a, int64_t b, int64_t c) { return futrts_smul_hi64(a, b) + c; }
797 #endif
798
799 #if defined(__OPENCL_VERSION__)
800 SCALAR_FUN_ATTR int32_t futrts_clzz8(int8_t x) { return clz(x); }
801 SCALAR_FUN_ATTR int32_t futrts_clzz16(int16_t x) { return clz(x); }
802 SCALAR_FUN_ATTR int32_t futrts_clzz32(int32_t x) { return clz(x); }
803 SCALAR_FUN_ATTR int32_t futrts_clzz64(int64_t x) { return clz(x); }
804
805 #elif defined(__CUDA_ARCH__)
806
807 SCALAR_FUN_ATTR int32_t futrts_clzz8(int8_t x) { return __clz(zext_i8_i32(x)) - 24; }
808 SCALAR_FUN_ATTR int32_t futrts_clzz16(int16_t x) { return __clz(zext_i16_i32(x)) - 16; }
809 SCALAR_FUN_ATTR int32_t futrts_clzz32(int32_t x) { return __clz(x); }
810 SCALAR_FUN_ATTR int32_t futrts_clzz64(int64_t x) { return __clzll(x); }
811
812 #elif defined(ISPC)
813
814 SCALAR_FUN_ATTR int32_t futrts_clzz8(int8_t x) { return count_leading_zeros((int32_t)(uint8_t)x)-24; }
815 SCALAR_FUN_ATTR int32_t futrts_clzz16(int16_t x) { return count_leading_zeros((int32_t)(uint16_t)x)-16; }
816 SCALAR_FUN_ATTR int32_t futrts_clzz32(int32_t x) { return count_leading_zeros(x); }
817 SCALAR_FUN_ATTR int32_t futrts_clzz64(int64_t x) { return count_leading_zeros(x); }
818
819 #else // Not OpenCL, ISPC or CUDA, but plain C.
820
821 SCALAR_FUN_ATTR int32_t futrts_clzz8(int8_t x)
822 { return x == 0 ? 8 : __builtin_clz((uint32_t)zext_i8_i32(x)) - 24; }
823 SCALAR_FUN_ATTR int32_t futrts_clzz16(int16_t x)
824 { return x == 0 ? 16 : __builtin_clz((uint32_t)zext_i16_i32(x)) - 16; }
825 SCALAR_FUN_ATTR int32_t futrts_clzz32(int32_t x)
826 { return x == 0 ? 32 : __builtin_clz((uint32_t)x); }
827 SCALAR_FUN_ATTR int32_t futrts_clzz64(int64_t x)
828 { return x == 0 ? 64 : __builtin_clzll((uint64_t)x); }
829 #endif
830
831 #if defined(__OPENCL_VERSION__)
832 SCALAR_FUN_ATTR int32_t futrts_ctzz8(int8_t x) {
833 int i = 0;
834 for (; i < 8 && (x & 1) == 0; i++, x >>= 1) ;
835 return i;
836 }
837
838 SCALAR_FUN_ATTR int32_t futrts_ctzz16(int16_t x) {
839 int i = 0;
840 for (; i < 16 && (x & 1) == 0; i++, x >>= 1) ;
841 return i;
842 }
843
844 SCALAR_FUN_ATTR int32_t futrts_ctzz32(int32_t x) {
845 int i = 0;
846 for (; i < 32 && (x & 1) == 0; i++, x >>= 1) ;
847 return i;
848 }
849
850 SCALAR_FUN_ATTR int32_t futrts_ctzz64(int64_t x) {
851 int i = 0;
852 for (; i < 64 && (x & 1) == 0; i++, x >>= 1) ;
853 return i;
854 }
855
856 #elif defined(__CUDA_ARCH__)
857
858 SCALAR_FUN_ATTR int32_t futrts_ctzz8(int8_t x) {
859 int y = __ffs(x);
860 return y == 0 ? 8 : y - 1;
861 }
862
863 SCALAR_FUN_ATTR int32_t futrts_ctzz16(int16_t x) {
864 int y = __ffs(x);
865 return y == 0 ? 16 : y - 1;
866 }
867
868 SCALAR_FUN_ATTR int32_t futrts_ctzz32(int32_t x) {
869 int y = __ffs(x);
870 return y == 0 ? 32 : y - 1;
871 }
872
873 SCALAR_FUN_ATTR int32_t futrts_ctzz64(int64_t x) {
874 int y = __ffsll(x);
875 return y == 0 ? 64 : y - 1;
876 }
877
878 #elif defined(ISPC)
879
880 SCALAR_FUN_ATTR int32_t futrts_ctzz8(int8_t x) { return x == 0 ? 8 : count_trailing_zeros((int32_t)x); }
881 SCALAR_FUN_ATTR int32_t futrts_ctzz16(int16_t x) { return x == 0 ? 16 : count_trailing_zeros((int32_t)x); }
882 SCALAR_FUN_ATTR int32_t futrts_ctzz32(int32_t x) { return count_trailing_zeros(x); }
883 SCALAR_FUN_ATTR int32_t futrts_ctzz64(int64_t x) { return count_trailing_zeros(x); }
884
885 #else // Not OpenCL or CUDA, but plain C.
886
887 SCALAR_FUN_ATTR int32_t futrts_ctzz8(int8_t x) { return x == 0 ? 8 : __builtin_ctz((uint32_t)x); }
888 SCALAR_FUN_ATTR int32_t futrts_ctzz16(int16_t x) { return x == 0 ? 16 : __builtin_ctz((uint32_t)x); }
889 SCALAR_FUN_ATTR int32_t futrts_ctzz32(int32_t x) { return x == 0 ? 32 : __builtin_ctz((uint32_t)x); }
890 SCALAR_FUN_ATTR int32_t futrts_ctzz64(int64_t x) { return x == 0 ? 64 : __builtin_ctzll((uint64_t)x); }
891 #endif
892
893 SCALAR_FUN_ATTR float fdiv32(float x, float y) { return x / y; }
894 SCALAR_FUN_ATTR float fadd32(float x, float y) { return x + y; }
895 SCALAR_FUN_ATTR float fsub32(float x, float y) { return x - y; }
896 SCALAR_FUN_ATTR float fmul32(float x, float y) { return x * y; }
897 SCALAR_FUN_ATTR bool cmplt32(float x, float y) { return x < y; }
898 SCALAR_FUN_ATTR bool cmple32(float x, float y) { return x <= y; }
899 SCALAR_FUN_ATTR float sitofp_i8_f32(int8_t x) { return (float) x; }
900
901 SCALAR_FUN_ATTR float sitofp_i16_f32(int16_t x) { return (float) x; }
902 SCALAR_FUN_ATTR float sitofp_i32_f32(int32_t x) { return (float) x; }
903 SCALAR_FUN_ATTR float sitofp_i64_f32(int64_t x) { return (float) x; }
904 SCALAR_FUN_ATTR float uitofp_i8_f32(uint8_t x) { return (float) x; }
905 SCALAR_FUN_ATTR float uitofp_i16_f32(uint16_t x) { return (float) x; }
906 SCALAR_FUN_ATTR float uitofp_i32_f32(uint32_t x) { return (float) x; }
907 SCALAR_FUN_ATTR float uitofp_i64_f32(uint64_t x) { return (float) x; }
908
909 #ifdef __OPENCL_VERSION__
910 SCALAR_FUN_ATTR float fabs32(float x) { return fabs(x); }
911 SCALAR_FUN_ATTR float fmax32(float x, float y) { return fmax(x, y); }
912 SCALAR_FUN_ATTR float fmin32(float x, float y) { return fmin(x, y); }
913 SCALAR_FUN_ATTR float fpow32(float x, float y) { return pow(x, y); }
914
915 #elif defined(ISPC)
916
917 SCALAR_FUN_ATTR float fabs32(float x) { return abs(x); }
918 SCALAR_FUN_ATTR float fmax32(float x, float y) { return isnan(x) ? y : isnan(y) ? x : max(x, y); }
919 SCALAR_FUN_ATTR float fmin32(float x, float y) { return isnan(x) ? y : isnan(y) ? x : min(x, y); }
920 SCALAR_FUN_ATTR float fpow32(float a, float b) {
921 float ret;
922 foreach_active (i) {
923 uniform float r = pow(extract(a, i), extract(b, i));
924 ret = insert(ret, i, r);
925 }
926 return ret;
927 }
928
929 #else // Not OpenCL, but CUDA or plain C.
930
931 SCALAR_FUN_ATTR float fabs32(float x) { return fabsf(x); }
932 SCALAR_FUN_ATTR float fmax32(float x, float y) { return fmaxf(x, y); }
933 SCALAR_FUN_ATTR float fmin32(float x, float y) { return fminf(x, y); }
934 SCALAR_FUN_ATTR float fpow32(float x, float y) { return powf(x, y); }
935 #endif
936
937 SCALAR_FUN_ATTR bool futrts_isnan32(float x) { return isnan(x); }
938
939 #if defined(ISPC)
940
941 SCALAR_FUN_ATTR bool futrts_isinf32(float x) { return !isnan(x) && isnan(x - x); }
942
943 SCALAR_FUN_ATTR bool futrts_isfinite32(float x) { return !isnan(x) && !futrts_isinf32(x); }
944
945 #else
946
947 SCALAR_FUN_ATTR bool futrts_isinf32(float x) { return isinf(x); }
948
949 #endif
950
951 SCALAR_FUN_ATTR int8_t fptosi_f32_i8(float x) {
952 if (futrts_isnan32(x) || futrts_isinf32(x)) {
953 return 0;
954 } else {
955 return (int8_t) x;
956 }
957 }
958
959 SCALAR_FUN_ATTR int16_t fptosi_f32_i16(float x) {
960 if (futrts_isnan32(x) || futrts_isinf32(x)) {
961 return 0;
962 } else {
963 return (int16_t) x;
964 }
965 }
966
967 SCALAR_FUN_ATTR int32_t fptosi_f32_i32(float x) {
968 if (futrts_isnan32(x) || futrts_isinf32(x)) {
969 return 0;
970 } else {
971 return (int32_t) x;
972 }
973 }
974
975 SCALAR_FUN_ATTR int64_t fptosi_f32_i64(float x) {
976 if (futrts_isnan32(x) || futrts_isinf32(x)) {
977 return 0;
978 } else {
979 return (int64_t) x;
980 };
981 }
982
983 SCALAR_FUN_ATTR uint8_t fptoui_f32_i8(float x) {
984 if (futrts_isnan32(x) || futrts_isinf32(x)) {
985 return 0;
986 } else {
987 return (uint8_t) (int8_t) x;
988 }
989 }
990
991 SCALAR_FUN_ATTR uint16_t fptoui_f32_i16(float x) {
992 if (futrts_isnan32(x) || futrts_isinf32(x)) {
993 return 0;
994 } else {
995 return (uint16_t) (int16_t) x;
996 }
997 }
998
999 SCALAR_FUN_ATTR uint32_t fptoui_f32_i32(float x) {
1000 if (futrts_isnan32(x) || futrts_isinf32(x)) {
1001 return 0;
1002 } else {
1003 return (uint32_t) (int32_t) x;
1004 }
1005 }
1006
1007 SCALAR_FUN_ATTR uint64_t fptoui_f32_i64(float x) {
1008 if (futrts_isnan32(x) || futrts_isinf32(x)) {
1009 return 0;
1010 } else {
1011 return (uint64_t) (int64_t) x;
1012 }
1013 }
1014
1015 SCALAR_FUN_ATTR bool ftob_f32_bool(float x) { return x != 0; }
1016 SCALAR_FUN_ATTR float btof_bool_f32(bool x) { return x ? 1 : 0; }
1017
1018 #ifdef __OPENCL_VERSION__
1019 SCALAR_FUN_ATTR float futrts_log32(float x) { return log(x); }
1020 SCALAR_FUN_ATTR float futrts_log2_32(float x) { return log2(x); }
1021 SCALAR_FUN_ATTR float futrts_log10_32(float x) { return log10(x); }
1022 SCALAR_FUN_ATTR float futrts_log1p_32(float x) { return log1p(x); }
1023 SCALAR_FUN_ATTR float futrts_sqrt32(float x) { return sqrt(x); }
1024 SCALAR_FUN_ATTR float futrts_rsqrt32(float x) { return rsqrt(x); }
1025 SCALAR_FUN_ATTR float futrts_cbrt32(float x) { return cbrt(x); }
1026 SCALAR_FUN_ATTR float futrts_exp32(float x) { return exp(x); }
1027 SCALAR_FUN_ATTR float futrts_cos32(float x) { return cos(x); }
1028 SCALAR_FUN_ATTR float futrts_cospi32(float x) { return cospi(x); }
1029 SCALAR_FUN_ATTR float futrts_sin32(float x) { return sin(x); }
1030 SCALAR_FUN_ATTR float futrts_sinpi32(float x) { return sinpi(x); }
1031 SCALAR_FUN_ATTR float futrts_tan32(float x) { return tan(x); }
1032 SCALAR_FUN_ATTR float futrts_tanpi32(float x) { return tanpi(x); }
1033 SCALAR_FUN_ATTR float futrts_acos32(float x) { return acos(x); }
1034 SCALAR_FUN_ATTR float futrts_acospi32(float x) { return acospi(x); }
1035 SCALAR_FUN_ATTR float futrts_asin32(float x) { return asin(x); }
1036 SCALAR_FUN_ATTR float futrts_asinpi32(float x) { return asinpi(x); }
1037 SCALAR_FUN_ATTR float futrts_atan32(float x) { return atan(x); }
1038 SCALAR_FUN_ATTR float futrts_atanpi32(float x) { return atanpi(x); }
1039 SCALAR_FUN_ATTR float futrts_cosh32(float x) { return cosh(x); }
1040 SCALAR_FUN_ATTR float futrts_sinh32(float x) { return sinh(x); }
1041 SCALAR_FUN_ATTR float futrts_tanh32(float x) { return tanh(x); }
1042 SCALAR_FUN_ATTR float futrts_acosh32(float x) { return acosh(x); }
1043 SCALAR_FUN_ATTR float futrts_asinh32(float x) { return asinh(x); }
1044 SCALAR_FUN_ATTR float futrts_atanh32(float x) { return atanh(x); }
1045 SCALAR_FUN_ATTR float futrts_atan2_32(float x, float y) { return atan2(x, y); }
1046 SCALAR_FUN_ATTR float futrts_atan2pi_32(float x, float y) { return atan2pi(x, y); }
1047 SCALAR_FUN_ATTR float futrts_hypot32(float x, float y) { return hypot(x, y); }
1048 SCALAR_FUN_ATTR float futrts_gamma32(float x) { return tgamma(x); }
1049 SCALAR_FUN_ATTR float futrts_lgamma32(float x) { return lgamma(x); }
1050 SCALAR_FUN_ATTR float futrts_erf32(float x) { return erf(x); }
1051 SCALAR_FUN_ATTR float futrts_erfc32(float x) { return erfc(x); }
1052 SCALAR_FUN_ATTR float fmod32(float x, float y) { return fmod(x, y); }
1053 SCALAR_FUN_ATTR float futrts_round32(float x) { return rint(x); }
1054 SCALAR_FUN_ATTR float futrts_floor32(float x) { return floor(x); }
1055 SCALAR_FUN_ATTR float futrts_ceil32(float x) { return ceil(x); }
1056 SCALAR_FUN_ATTR float futrts_nextafter32(float x, float y) { return nextafter(x, y); }
1057 SCALAR_FUN_ATTR float futrts_lerp32(float v0, float v1, float t) { return mix(v0, v1, t); }
1058 SCALAR_FUN_ATTR float futrts_ldexp32(float x, int32_t y) { return ldexp(x, y); }
1059 SCALAR_FUN_ATTR float futrts_copysign32(float x, float y) { return copysign(x, y); }
1060 SCALAR_FUN_ATTR float futrts_mad32(float a, float b, float c) { return mad(a, b, c); }
1061 SCALAR_FUN_ATTR float futrts_fma32(float a, float b, float c) { return fma(a, b, c); }
1062
1063 #elif defined(ISPC)
1064
1065 SCALAR_FUN_ATTR float futrts_log32(float x) { return futrts_isfinite32(x) || (futrts_isinf32(x) && x < 0)? log(x) : x; }
1066 SCALAR_FUN_ATTR float futrts_log2_32(float x) { return futrts_log32(x) / log(2.0f); }
1067 SCALAR_FUN_ATTR float futrts_log10_32(float x) { return futrts_log32(x) / log(10.0f); }
1068
1069 SCALAR_FUN_ATTR float futrts_log1p_32(float x) {
1070 if(x == -1.0f || (futrts_isinf32(x) && x > 0.0f)) return x / 0.0f;
1071 float y = 1.0f + x;
1072 float z = y - 1.0f;
1073 return log(y) - (z-x)/y;
1074 }
1075
1076 SCALAR_FUN_ATTR float futrts_sqrt32(float x) { return sqrt(x); }
1077 SCALAR_FUN_ATTR float futrts_rsqrt32(float x) { return 1/sqrt(x); }
1078
1079 extern "C" unmasked uniform float cbrtf(uniform float);
1080 SCALAR_FUN_ATTR float futrts_cbrt32(float x) {
1081 float res;
1082 foreach_active (i) {
1083 uniform float r = cbrtf(extract(x, i));
1084 res = insert(res, i, r);
1085 }
1086 return res;
1087 }
1088
1089 SCALAR_FUN_ATTR float futrts_exp32(float x) { return exp(x); }
1090 SCALAR_FUN_ATTR float futrts_cos32(float x) { return cos(x); }
1091 SCALAR_FUN_ATTR float futrts_cospi32(float x) { return cos((float)M_PI*x); }
1092 SCALAR_FUN_ATTR float futrts_sin32(float x) { return sin(x); }
1093 SCALAR_FUN_ATTR float futrts_sinpi32(float x) { return sin(M_PI*x); }
1094 SCALAR_FUN_ATTR float futrts_tan32(float x) { return tan(x); }
1095 SCALAR_FUN_ATTR float futrts_tanpi32(float x) { return tan((float)M_PI*x); }
1096 SCALAR_FUN_ATTR float futrts_acos32(float x) { return acos(x); }
1097 SCALAR_FUN_ATTR float futrts_acospi32(float x) { return acos(x)/(float)M_PI; }
1098 SCALAR_FUN_ATTR float futrts_asin32(float x) { return asin(x); }
1099 SCALAR_FUN_ATTR float futrts_asinpi32(float x) { return asin(x)/(float)M_PI; }
1100 SCALAR_FUN_ATTR float futrts_atan32(float x) { return atan(x); }
1101 SCALAR_FUN_ATTR float futrts_atanpi32(float x) { return atan(x)/(float)M_PI; }
1102 SCALAR_FUN_ATTR float futrts_cosh32(float x) { return (exp(x)+exp(-x)) / 2.0f; }
1103 SCALAR_FUN_ATTR float futrts_sinh32(float x) { return (exp(x)-exp(-x)) / 2.0f; }
1104 SCALAR_FUN_ATTR float futrts_tanh32(float x) { return futrts_sinh32(x)/futrts_cosh32(x); }
1105
1106 SCALAR_FUN_ATTR float futrts_acosh32(float x) {
1107 float f = x+sqrt(x*x-1);
1108 if (futrts_isfinite32(f)) return log(f);
1109 return f;
1110 }
1111
1112 SCALAR_FUN_ATTR float futrts_asinh32(float x) {
1113 float f = x+sqrt(x*x+1);
1114 if (futrts_isfinite32(f)) return log(f);
1115 return f;
1116 }
1117
1118 SCALAR_FUN_ATTR float futrts_atanh32(float x) {
1119 float f = (1+x)/(1-x);
1120 if (futrts_isfinite32(f)) return log(f)/2.0f;
1121 return f;
1122 }
1123
1124 SCALAR_FUN_ATTR float futrts_atan2_32(float x, float y)
1125 { return (x == 0.0f && y == 0.0f) ? 0.0f : atan2(x, y); }
1126 SCALAR_FUN_ATTR float futrts_atan2pi_32(float x, float y)
1127 { return (x == 0.0f && y == 0.0f) ? 0.0f : atan2(x, y) / (float)M_PI; }
1128
1129 SCALAR_FUN_ATTR float futrts_hypot32(float x, float y) {
1130 if (futrts_isfinite32(x) && futrts_isfinite32(y)) {
1131 x = abs(x);
1132 y = abs(y);
1133 float a;
1134 float b;
1135 if (x >= y){
1136 a = x;
1137 b = y;
1138 } else {
1139 a = y;
1140 b = x;
1141 }
1142 if(b == 0){
1143 return a;
1144 }
1145
1146 int e;
1147 float an;
1148 float bn;
1149 an = frexp (a, &e);
1150 bn = ldexp (b, - e);
1151 float cn;
1152 cn = sqrt (an * an + bn * bn);
1153 return ldexp (cn, e);
1154 } else {
1155 if (futrts_isinf32(x) || futrts_isinf32(y)) return INFINITY;
1156 else return x + y;
1157 }
1158
1159 }
1160
1161 extern "C" unmasked uniform float tgammaf(uniform float x);
1162 SCALAR_FUN_ATTR float futrts_gamma32(float x) {
1163 float res;
1164 foreach_active (i) {
1165 uniform float r = tgammaf(extract(x, i));
1166 res = insert(res, i, r);
1167 }
1168 return res;
1169 }
1170
1171 extern "C" unmasked uniform float lgammaf(uniform float x);
1172 SCALAR_FUN_ATTR float futrts_lgamma32(float x) {
1173 float res;
1174 foreach_active (i) {
1175 uniform float r = lgammaf(extract(x, i));
1176 res = insert(res, i, r);
1177 }
1178 return res;
1179 }
1180
1181 extern "C" unmasked uniform float erff(uniform float x);
1182 SCALAR_FUN_ATTR float futrts_erf32(float x) {
1183 float res;
1184 foreach_active (i) {
1185 uniform float r = erff(extract(x, i));
1186 res = insert(res, i, r);
1187 }
1188 return res;
1189 }
1190
1191 extern "C" unmasked uniform float erfcf(uniform float x);
1192 SCALAR_FUN_ATTR float futrts_erfc32(float x) {
1193 float res;
1194 foreach_active (i) {
1195 uniform float r = erfcf(extract(x, i));
1196 res = insert(res, i, r);
1197 }
1198 return res;
1199 }
1200
1201 SCALAR_FUN_ATTR float fmod32(float x, float y) { return x - y * trunc(x/y); }
1202 SCALAR_FUN_ATTR float futrts_round32(float x) { return round(x); }
1203 SCALAR_FUN_ATTR float futrts_floor32(float x) { return floor(x); }
1204 SCALAR_FUN_ATTR float futrts_ceil32(float x) { return ceil(x); }
1205
1206 extern "C" unmasked uniform float nextafterf(uniform float x, uniform float y);
1207 SCALAR_FUN_ATTR float futrts_nextafter32(float x, float y) {
1208 float res;
1209 foreach_active (i) {
1210 uniform float r = nextafterf(extract(x, i), extract(y, i));
1211 res = insert(res, i, r);
1212 }
1213 return res;
1214 }
1215
1216 SCALAR_FUN_ATTR float futrts_lerp32(float v0, float v1, float t) {
1217 return v0 + (v1 - v0) * t;
1218 }
1219
1220 SCALAR_FUN_ATTR float futrts_ldexp32(float x, int32_t y) {
1221 return x * pow((uniform float)2.0, (float)y);
1222 }
1223
1224 SCALAR_FUN_ATTR float futrts_copysign32(float x, float y) {
1225 int32_t xb = fptobits_f32_i32(x);
1226 int32_t yb = fptobits_f32_i32(y);
1227 return bitstofp_i32_f32((xb & ~(1<<31)) | (yb & (1<<31)));
1228 }
1229
1230 SCALAR_FUN_ATTR float futrts_mad32(float a, float b, float c) {
1231 return a * b + c;
1232 }
1233
1234 SCALAR_FUN_ATTR float futrts_fma32(float a, float b, float c) {
1235 return a * b + c;
1236 }
1237
1238 #else // Not OpenCL or ISPC, but CUDA or plain C.
1239
1240 SCALAR_FUN_ATTR float futrts_log32(float x) { return logf(x); }
1241 SCALAR_FUN_ATTR float futrts_log2_32(float x) { return log2f(x); }
1242 SCALAR_FUN_ATTR float futrts_log10_32(float x) { return log10f(x); }
1243 SCALAR_FUN_ATTR float futrts_log1p_32(float x) { return log1pf(x); }
1244 SCALAR_FUN_ATTR float futrts_sqrt32(float x) { return sqrtf(x); }
1245 SCALAR_FUN_ATTR float futrts_rsqrt32(float x) { return 1/sqrtf(x); }
1246 SCALAR_FUN_ATTR float futrts_cbrt32(float x) { return cbrtf(x); }
1247 SCALAR_FUN_ATTR float futrts_exp32(float x) { return expf(x); }
1248 SCALAR_FUN_ATTR float futrts_cos32(float x) { return cosf(x); }
1249
1250 SCALAR_FUN_ATTR float futrts_cospi32(float x) {
1251 #if defined(__CUDA_ARCH__)
1252 return cospif(x);
1253 #else
1254 return cosf(((float)M_PI)*x);
1255 #endif
1256 }
1257 SCALAR_FUN_ATTR float futrts_sin32(float x) { return sinf(x); }
1258
1259 SCALAR_FUN_ATTR float futrts_sinpi32(float x) {
1260 #if defined(__CUDA_ARCH__)
1261 return sinpif(x);
1262 #else
1263 return sinf((float)M_PI*x);
1264 #endif
1265 }
1266
1267 SCALAR_FUN_ATTR float futrts_tan32(float x) { return tanf(x); }
1268 SCALAR_FUN_ATTR float futrts_tanpi32(float x) { return tanf((float)M_PI*x); }
1269 SCALAR_FUN_ATTR float futrts_acos32(float x) { return acosf(x); }
1270 SCALAR_FUN_ATTR float futrts_acospi32(float x) { return acosf(x)/(float)M_PI; }
1271 SCALAR_FUN_ATTR float futrts_asin32(float x) { return asinf(x); }
1272 SCALAR_FUN_ATTR float futrts_asinpi32(float x) { return asinf(x)/(float)M_PI; }
1273 SCALAR_FUN_ATTR float futrts_atan32(float x) { return atanf(x); }
1274 SCALAR_FUN_ATTR float futrts_atanpi32(float x) { return atanf(x)/(float)M_PI; }
1275 SCALAR_FUN_ATTR float futrts_cosh32(float x) { return coshf(x); }
1276 SCALAR_FUN_ATTR float futrts_sinh32(float x) { return sinhf(x); }
1277 SCALAR_FUN_ATTR float futrts_tanh32(float x) { return tanhf(x); }
1278 SCALAR_FUN_ATTR float futrts_acosh32(float x) { return acoshf(x); }
1279 SCALAR_FUN_ATTR float futrts_asinh32(float x) { return asinhf(x); }
1280 SCALAR_FUN_ATTR float futrts_atanh32(float x) { return atanhf(x); }
1281 SCALAR_FUN_ATTR float futrts_atan2_32(float x, float y) { return atan2f(x, y); }
1282 SCALAR_FUN_ATTR float futrts_atan2pi_32(float x, float y) { return atan2f(x, y) / (float)M_PI; }
1283 SCALAR_FUN_ATTR float futrts_hypot32(float x, float y) { return hypotf(x, y); }
1284 SCALAR_FUN_ATTR float futrts_gamma32(float x) { return tgammaf(x); }
1285 SCALAR_FUN_ATTR float futrts_lgamma32(float x) { return lgammaf(x); }
1286 SCALAR_FUN_ATTR float futrts_erf32(float x) { return erff(x); }
1287 SCALAR_FUN_ATTR float futrts_erfc32(float x) { return erfcf(x); }
1288 SCALAR_FUN_ATTR float fmod32(float x, float y) { return fmodf(x, y); }
1289 SCALAR_FUN_ATTR float futrts_round32(float x) { return rintf(x); }
1290 SCALAR_FUN_ATTR float futrts_floor32(float x) { return floorf(x); }
1291 SCALAR_FUN_ATTR float futrts_ceil32(float x) { return ceilf(x); }
1292 SCALAR_FUN_ATTR float futrts_nextafter32(float x, float y) { return nextafterf(x, y); }
1293 SCALAR_FUN_ATTR float futrts_lerp32(float v0, float v1, float t) { return v0 + (v1 - v0) * t; }
1294 SCALAR_FUN_ATTR float futrts_ldexp32(float x, int32_t y) { return ldexpf(x, y); }
1295 SCALAR_FUN_ATTR float futrts_copysign32(float x, float y) { return copysignf(x, y); }
1296 SCALAR_FUN_ATTR float futrts_mad32(float a, float b, float c) { return a * b + c; }
1297 SCALAR_FUN_ATTR float futrts_fma32(float a, float b, float c) { return fmaf(a, b, c); }
1298
1299 #endif
1300
1301 #if defined(ISPC)
1302
1303 SCALAR_FUN_ATTR int32_t fptobits_f32_i32(float x) { return intbits(x); }
1304 SCALAR_FUN_ATTR float bitstofp_i32_f32(int32_t x) { return floatbits(x); }
1305 SCALAR_FUN_ATTR uniform int32_t fptobits_f32_i32(uniform float x) { return intbits(x); }
1306 SCALAR_FUN_ATTR uniform float bitstofp_i32_f32(uniform int32_t x) { return floatbits(x); }
1307
1308 #else
1309
1310 SCALAR_FUN_ATTR int32_t fptobits_f32_i32(float x) {
1311 union {
1312 float f;
1313 int32_t t;
1314 } p;
1315
1316 p.f = x;
1317 return p.t;
1318 }
1319
1320 SCALAR_FUN_ATTR float bitstofp_i32_f32(int32_t x) {
1321 union {
1322 int32_t f;
1323 float t;
1324 } p;
1325
1326 p.f = x;
1327 return p.t;
1328 }
1329 #endif
1330
1331 SCALAR_FUN_ATTR float fsignum32(float x) {
1332 return futrts_isnan32(x) ? x : (x > 0 ? 1 : 0) - (x < 0 ? 1 : 0);
1333 }
1334
1335 #ifdef FUTHARK_F64_ENABLED
1336
1337 SCALAR_FUN_ATTR double bitstofp_i64_f64(int64_t x);
1338 SCALAR_FUN_ATTR int64_t fptobits_f64_i64(double x);
1339
1340 #if defined(ISPC)
1341
1342 SCALAR_FUN_ATTR bool futrts_isinf64(float x) { return !isnan(x) && isnan(x - x); }
1343 SCALAR_FUN_ATTR bool futrts_isfinite64(float x) { return !isnan(x) && !futrts_isinf64(x); }
1344 SCALAR_FUN_ATTR double fdiv64(double x, double y) { return x / y; }
1345 SCALAR_FUN_ATTR double fadd64(double x, double y) { return x + y; }
1346 SCALAR_FUN_ATTR double fsub64(double x, double y) { return x - y; }
1347 SCALAR_FUN_ATTR double fmul64(double x, double y) { return x * y; }
1348 SCALAR_FUN_ATTR bool cmplt64(double x, double y) { return x < y; }
1349 SCALAR_FUN_ATTR bool cmple64(double x, double y) { return x <= y; }
1350 SCALAR_FUN_ATTR double sitofp_i8_f64(int8_t x) { return (double) x; }
1351 SCALAR_FUN_ATTR double sitofp_i16_f64(int16_t x) { return (double) x; }
1352 SCALAR_FUN_ATTR double sitofp_i32_f64(int32_t x) { return (double) x; }
1353 SCALAR_FUN_ATTR double sitofp_i64_f64(int64_t x) { return (double) x; }
1354 SCALAR_FUN_ATTR double uitofp_i8_f64(uint8_t x) { return (double) x; }
1355 SCALAR_FUN_ATTR double uitofp_i16_f64(uint16_t x) { return (double) x; }
1356 SCALAR_FUN_ATTR double uitofp_i32_f64(uint32_t x) { return (double) x; }
1357 SCALAR_FUN_ATTR double uitofp_i64_f64(uint64_t x) { return (double) x; }
1358 SCALAR_FUN_ATTR double fabs64(double x) { return abs(x); }
1359 SCALAR_FUN_ATTR double fmax64(double x, double y) { return isnan(x) ? y : isnan(y) ? x : max(x, y); }
1360 SCALAR_FUN_ATTR double fmin64(double x, double y) { return isnan(x) ? y : isnan(y) ? x : min(x, y); }
1361
1362 SCALAR_FUN_ATTR double fpow64(double a, double b) {
1363 float ret;
1364 foreach_active (i) {
1365 uniform float r = pow(extract(a, i), extract(b, i));
1366 ret = insert(ret, i, r);
1367 }
1368 return ret;
1369 }
1370 SCALAR_FUN_ATTR double futrts_log64(double x) { return futrts_isfinite64(x) || (futrts_isinf64(x) && x < 0)? log(x) : x; }
1371 SCALAR_FUN_ATTR double futrts_log2_64(double x) { return futrts_log64(x)/log(2.0d); }
1372 SCALAR_FUN_ATTR double futrts_log10_64(double x) { return futrts_log64(x)/log(10.0d); }
1373
1374 SCALAR_FUN_ATTR double futrts_log1p_64(double x) {
1375 if(x == -1.0d || (futrts_isinf64(x) && x > 0.0d)) return x / 0.0d;
1376 double y = 1.0d + x;
1377 double z = y - 1.0d;
1378 return log(y) - (z-x)/y;
1379 }
1380
1381 SCALAR_FUN_ATTR double futrts_sqrt64(double x) { return sqrt(x); }
1382 SCALAR_FUN_ATTR double futrts_rsqrt64(double x) { return 1/sqrt(x); }
1383
1384 SCALAR_FUN_ATTR double futrts_cbrt64(double x) {
1385 double res;
1386 foreach_active (i) {
1387 uniform double r = cbrtf(extract(x, i));
1388 res = insert(res, i, r);
1389 }
1390 return res;
1391 }
1392 SCALAR_FUN_ATTR double futrts_exp64(double x) { return exp(x); }
1393 SCALAR_FUN_ATTR double futrts_cos64(double x) { return cos(x); }
1394 SCALAR_FUN_ATTR double futrts_cospi64(double x) { return cos(M_PI*x); }
1395 SCALAR_FUN_ATTR double futrts_sin64(double x) { return sin(x); }
1396 SCALAR_FUN_ATTR double futrts_sinpi64(double x) { return sin(M_PI*x); }
1397 SCALAR_FUN_ATTR double futrts_tan64(double x) { return tan(x); }
1398 SCALAR_FUN_ATTR double futrts_tanpi64(double x) { return tan(M_PI*x); }
1399 SCALAR_FUN_ATTR double futrts_acos64(double x) { return acos(x); }
1400 SCALAR_FUN_ATTR double futrts_acospi64(double x) { return acos(x)/M_PI; }
1401 SCALAR_FUN_ATTR double futrts_asin64(double x) { return asin(x); }
1402 SCALAR_FUN_ATTR double futrts_asinpi64(double x) { return asin(x)/M_PI; }
1403 SCALAR_FUN_ATTR double futrts_atan64(double x) { return atan(x); }
1404 SCALAR_FUN_ATTR double futrts_atanpi64(double x) { return atan(x)/M_PI; }
1405 SCALAR_FUN_ATTR double futrts_cosh64(double x) { return (exp(x)+exp(-x)) / 2.0d; }
1406 SCALAR_FUN_ATTR double futrts_sinh64(double x) { return (exp(x)-exp(-x)) / 2.0d; }
1407 SCALAR_FUN_ATTR double futrts_tanh64(double x) { return futrts_sinh64(x)/futrts_cosh64(x); }
1408
1409 SCALAR_FUN_ATTR double futrts_acosh64(double x) {
1410 double f = x+sqrt(x*x-1.0d);
1411 if(futrts_isfinite64(f)) return log(f);
1412 return f;
1413 }
1414
1415 SCALAR_FUN_ATTR double futrts_asinh64(double x) {
1416 double f = x+sqrt(x*x+1.0d);
1417 if(futrts_isfinite64(f)) return log(f);
1418 return f;
1419 }
1420
1421 SCALAR_FUN_ATTR double futrts_atanh64(double x) {
1422 double f = (1.0d+x)/(1.0d-x);
1423 if(futrts_isfinite64(f)) return log(f)/2.0d;
1424 return f;
1425 }
1426 SCALAR_FUN_ATTR double futrts_atan2_64(double x, double y) { return atan2(x, y); }
1427
1428 SCALAR_FUN_ATTR double futrts_atan2pi_64(double x, double y) { return atan2(x, y) / M_PI; }
1429
1430 extern "C" unmasked uniform double hypot(uniform double x, uniform double y);
1431 SCALAR_FUN_ATTR double futrts_hypot64(double x, double y) {
1432 double res;
1433 foreach_active (i) {
1434 uniform double r = hypot(extract(x, i), extract(y, i));
1435 res = insert(res, i, r);
1436 }
1437 return res;
1438 }
1439
1440 extern "C" unmasked uniform double tgamma(uniform double x);
1441 SCALAR_FUN_ATTR double futrts_gamma64(double x) {
1442 double res;
1443 foreach_active (i) {
1444 uniform double r = tgamma(extract(x, i));
1445 res = insert(res, i, r);
1446 }
1447 return res;
1448 }
1449
1450 extern "C" unmasked uniform double lgamma(uniform double x);
1451 SCALAR_FUN_ATTR double futrts_lgamma64(double x) {
1452 double res;
1453 foreach_active (i) {
1454 uniform double r = lgamma(extract(x, i));
1455 res = insert(res, i, r);
1456 }
1457 return res;
1458 }
1459
1460 extern "C" unmasked uniform double erf(uniform double x);
1461 SCALAR_FUN_ATTR double futrts_erf64(double x) {
1462 double res;
1463 foreach_active (i) {
1464 uniform double r = erf(extract(x, i));
1465 res = insert(res, i, r);
1466 }
1467 return res;
1468 }
1469
1470 extern "C" unmasked uniform double erfc(uniform double x);
1471 SCALAR_FUN_ATTR double futrts_erfc64(double x) {
1472 double res;
1473 foreach_active (i) {
1474 uniform double r = erfc(extract(x, i));
1475 res = insert(res, i, r);
1476 }
1477 return res;
1478 }
1479
1480 SCALAR_FUN_ATTR double futrts_fma64(double a, double b, double c) { return a * b + c; }
1481 SCALAR_FUN_ATTR double futrts_round64(double x) { return round(x); }
1482 SCALAR_FUN_ATTR double futrts_ceil64(double x) { return ceil(x); }
1483
1484 extern "C" unmasked uniform double nextafter(uniform float x, uniform double y);
1485 SCALAR_FUN_ATTR float futrts_nextafter64(double x, double y) {
1486 double res;
1487 foreach_active (i) {
1488 uniform double r = nextafter(extract(x, i), extract(y, i));
1489 res = insert(res, i, r);
1490 }
1491 return res;
1492 }
1493
1494 SCALAR_FUN_ATTR double futrts_floor64(double x) { return floor(x); }
1495 SCALAR_FUN_ATTR bool futrts_isnan64(double x) { return isnan(x); }
1496
1497 SCALAR_FUN_ATTR int8_t fptosi_f64_i8(double x) {
1498 if (futrts_isnan64(x) || futrts_isinf64(x)) {
1499 return 0;
1500 } else {
1501 return (int8_t) x;
1502 }
1503 }
1504
1505 SCALAR_FUN_ATTR int16_t fptosi_f64_i16(double x) {
1506 if (futrts_isnan64(x) || futrts_isinf64(x)) {
1507 return 0;
1508 } else {
1509 return (int16_t) x;
1510 }
1511 }
1512
1513 SCALAR_FUN_ATTR int32_t fptosi_f64_i32(double x) {
1514 if (futrts_isnan64(x) || futrts_isinf64(x)) {
1515 return 0;
1516 } else {
1517 return (int32_t) x;
1518 }
1519 }
1520
1521 SCALAR_FUN_ATTR int64_t fptosi_f64_i64(double x) {
1522 if (futrts_isnan64(x) || futrts_isinf64(x)) {
1523 return 0;
1524 } else {
1525 return (int64_t) x;
1526 }
1527 }
1528
1529 SCALAR_FUN_ATTR uint8_t fptoui_f64_i8(double x) {
1530 if (futrts_isnan64(x) || futrts_isinf64(x)) {
1531 return 0;
1532 } else {
1533 return (uint8_t) (int8_t) x;
1534 }
1535 }
1536
1537 SCALAR_FUN_ATTR uint16_t fptoui_f64_i16(double x) {
1538 if (futrts_isnan64(x) || futrts_isinf64(x)) {
1539 return 0;
1540 } else {
1541 return (uint16_t) (int16_t) x;
1542 }
1543 }
1544
1545 SCALAR_FUN_ATTR uint32_t fptoui_f64_i32(double x) {
1546 if (futrts_isnan64(x) || futrts_isinf64(x)) {
1547 return 0;
1548 } else {
1549 return (uint32_t) (int32_t) x;
1550 }
1551 }
1552
1553 SCALAR_FUN_ATTR uint64_t fptoui_f64_i64(double x) {
1554 if (futrts_isnan64(x) || futrts_isinf64(x)) {
1555 return 0;
1556 } else {
1557 return (uint64_t) (int64_t) x;
1558 }
1559 }
1560
1561 SCALAR_FUN_ATTR bool ftob_f64_bool(double x) { return x != 0.0; }
1562 SCALAR_FUN_ATTR double btof_bool_f64(bool x) { return x ? 1.0 : 0.0; }
1563
1564 SCALAR_FUN_ATTR int64_t fptobits_f64_i64(double x) {
1565 int64_t res;
1566 foreach_active (i) {
1567 uniform double tmp = extract(x, i);
1568 uniform int64_t r = *((uniform int64_t* uniform)&tmp);
1569 res = insert(res, i, r);
1570 }
1571 return res;
1572 }
1573
1574 SCALAR_FUN_ATTR double bitstofp_i64_f64(int64_t x) {
1575 double res;
1576 foreach_active (i) {
1577 uniform int64_t tmp = extract(x, i);
1578 uniform double r = *((uniform double* uniform)&tmp);
1579 res = insert(res, i, r);
1580 }
1581 return res;
1582 }
1583
1584 SCALAR_FUN_ATTR uniform int64_t fptobits_f64_i64(uniform double x) {
1585 return intbits(x);
1586 }
1587
1588 SCALAR_FUN_ATTR uniform double bitstofp_i64_f64(uniform int64_t x) {
1589 return doublebits(x);
1590 }
1591
1592 SCALAR_FUN_ATTR double fmod64(double x, double y) {
1593 return x - y * trunc(x/y);
1594 }
1595
1596 SCALAR_FUN_ATTR double fsignum64(double x) {
1597 return futrts_isnan64(x) ? x : (x > 0 ? 1.0d : 0.0d) - (x < 0 ? 1.0d : 0.0d);
1598 }
1599
1600 SCALAR_FUN_ATTR double futrts_lerp64(double v0, double v1, double t) {
1601 return v0 + (v1 - v0) * t;
1602 }
1603
1604 SCALAR_FUN_ATTR double futrts_ldexp64(double x, int32_t y) {
1605 return x * pow((uniform double)2.0, (double)y);
1606 }
1607
1608 SCALAR_FUN_ATTR double futrts_copysign64(double x, double y) {
1609 int64_t xb = fptobits_f64_i64(x);
1610 int64_t yb = fptobits_f64_i64(y);
1611 return bitstofp_i64_f64((xb & ~(((int64_t)1)<<63)) | (yb & (((int64_t)1)<<63)));
1612 }
1613
1614 SCALAR_FUN_ATTR double futrts_mad64(double a, double b, double c) { return a * b + c; }
1615 SCALAR_FUN_ATTR float fpconv_f32_f32(float x) { return (float) x; }
1616 SCALAR_FUN_ATTR double fpconv_f32_f64(float x) { return (double) x; }
1617 SCALAR_FUN_ATTR float fpconv_f64_f32(double x) { return (float) x; }
1618 SCALAR_FUN_ATTR double fpconv_f64_f64(double x) { return (double) x; }
1619
1620 #else
1621
1622 SCALAR_FUN_ATTR double fdiv64(double x, double y) { return x / y; }
1623 SCALAR_FUN_ATTR double fadd64(double x, double y) { return x + y; }
1624 SCALAR_FUN_ATTR double fsub64(double x, double y) { return x - y; }
1625 SCALAR_FUN_ATTR double fmul64(double x, double y) { return x * y; }
1626 SCALAR_FUN_ATTR bool cmplt64(double x, double y) { return x < y; }
1627 SCALAR_FUN_ATTR bool cmple64(double x, double y) { return x <= y; }
1628 SCALAR_FUN_ATTR double sitofp_i8_f64(int8_t x) { return (double) x; }
1629 SCALAR_FUN_ATTR double sitofp_i16_f64(int16_t x) { return (double) x; }
1630 SCALAR_FUN_ATTR double sitofp_i32_f64(int32_t x) { return (double) x; }
1631 SCALAR_FUN_ATTR double sitofp_i64_f64(int64_t x) { return (double) x; }
1632 SCALAR_FUN_ATTR double uitofp_i8_f64(uint8_t x) { return (double) x; }
1633 SCALAR_FUN_ATTR double uitofp_i16_f64(uint16_t x) { return (double) x; }
1634 SCALAR_FUN_ATTR double uitofp_i32_f64(uint32_t x) { return (double) x; }
1635 SCALAR_FUN_ATTR double uitofp_i64_f64(uint64_t x) { return (double) x; }
1636 SCALAR_FUN_ATTR double fabs64(double x) { return fabs(x); }
1637 SCALAR_FUN_ATTR double fmax64(double x, double y) { return fmax(x, y); }
1638 SCALAR_FUN_ATTR double fmin64(double x, double y) { return fmin(x, y); }
1639 SCALAR_FUN_ATTR double fpow64(double x, double y) { return pow(x, y); }
1640 SCALAR_FUN_ATTR double futrts_log64(double x) { return log(x); }
1641 SCALAR_FUN_ATTR double futrts_log2_64(double x) { return log2(x); }
1642 SCALAR_FUN_ATTR double futrts_log10_64(double x) { return log10(x); }
1643 SCALAR_FUN_ATTR double futrts_log1p_64(double x) { return log1p(x); }
1644 SCALAR_FUN_ATTR double futrts_sqrt64(double x) { return sqrt(x); }
1645 SCALAR_FUN_ATTR double futrts_rsqrt64(double x) { return 1/sqrt(x); }
1646 SCALAR_FUN_ATTR double futrts_cbrt64(double x) { return cbrt(x); }
1647 SCALAR_FUN_ATTR double futrts_exp64(double x) { return exp(x); }
1648 SCALAR_FUN_ATTR double futrts_cos64(double x) { return cos(x); }
1649
1650 SCALAR_FUN_ATTR double futrts_cospi64(double x) {
1651 #ifdef __OPENCL_VERSION__
1652 return cospi(x);
1653 #elif defined(__CUDA_ARCH__)
1654 return cospi(x);
1655 #else
1656 return cos(M_PI*x);
1657 #endif
1658 }
1659
1660 SCALAR_FUN_ATTR double futrts_sin64(double x) {
1661 return sin(x);
1662 }
1663
1664 SCALAR_FUN_ATTR double futrts_sinpi64(double x) {
1665 #ifdef __OPENCL_VERSION__
1666 return sinpi(x);
1667 #elif defined(__CUDA_ARCH__)
1668 return sinpi(x);
1669 #else
1670 return sin(M_PI*x);
1671 #endif
1672 }
1673
1674 SCALAR_FUN_ATTR double futrts_tan64(double x) {
1675 return tan(x);
1676 }
1677
1678 SCALAR_FUN_ATTR double futrts_tanpi64(double x) {
1679 #ifdef __OPENCL_VERSION__
1680 return tanpi(x);
1681 #else
1682 return tan(M_PI*x);
1683 #endif
1684 }
1685
1686 SCALAR_FUN_ATTR double futrts_acos64(double x) {
1687 return acos(x);
1688 }
1689
1690 SCALAR_FUN_ATTR double futrts_acospi64(double x) {
1691 #ifdef __OPENCL_VERSION__
1692 return acospi(x);
1693 #else
1694 return acos(x) / M_PI;
1695 #endif
1696 }
1697
1698 SCALAR_FUN_ATTR double futrts_asin64(double x) {
1699 return asin(x);
1700 }
1701
1702 SCALAR_FUN_ATTR double futrts_asinpi64(double x) {
1703 #ifdef __OPENCL_VERSION__
1704 return asinpi(x);
1705 #else
1706 return asin(x) / M_PI;
1707 #endif
1708 }
1709
1710 SCALAR_FUN_ATTR double futrts_atan64(double x) {
1711 return atan(x);
1712 }
1713
1714 SCALAR_FUN_ATTR double futrts_atanpi64(double x) {
1715 #ifdef __OPENCL_VERSION__
1716 return atanpi(x);
1717 #else
1718 return atan(x) / M_PI;
1719 #endif
1720 }
1721
1722 SCALAR_FUN_ATTR double futrts_cosh64(double x) { return cosh(x); }
1723 SCALAR_FUN_ATTR double futrts_sinh64(double x) { return sinh(x); }
1724 SCALAR_FUN_ATTR double futrts_tanh64(double x) { return tanh(x); }
1725 SCALAR_FUN_ATTR double futrts_acosh64(double x) { return acosh(x); }
1726 SCALAR_FUN_ATTR double futrts_asinh64(double x) { return asinh(x); }
1727 SCALAR_FUN_ATTR double futrts_atanh64(double x) { return atanh(x); }
1728 SCALAR_FUN_ATTR double futrts_atan2_64(double x, double y) { return atan2(x, y); }
1729
1730 SCALAR_FUN_ATTR double futrts_atan2pi_64(double x, double y) {
1731 #ifdef __OPENCL_VERSION__
1732 return atan2pi(x, y);
1733 #else
1734 return atan2(x, y) / M_PI;
1735 #endif
1736 }
1737
1738 SCALAR_FUN_ATTR double futrts_hypot64(double x, double y) { return hypot(x, y); }
1739 SCALAR_FUN_ATTR double futrts_gamma64(double x) { return tgamma(x); }
1740 SCALAR_FUN_ATTR double futrts_lgamma64(double x) { return lgamma(x); }
1741 SCALAR_FUN_ATTR double futrts_erf64(double x) { return erf(x); }
1742 SCALAR_FUN_ATTR double futrts_erfc64(double x) { return erfc(x); }
1743 SCALAR_FUN_ATTR double futrts_fma64(double a, double b, double c) { return fma(a, b, c); }
1744 SCALAR_FUN_ATTR double futrts_round64(double x) { return rint(x); }
1745 SCALAR_FUN_ATTR double futrts_ceil64(double x) { return ceil(x); }
1746 SCALAR_FUN_ATTR float futrts_nextafter64(float x, float y) { return nextafter(x, y); }
1747 SCALAR_FUN_ATTR double futrts_floor64(double x) { return floor(x); }
1748 SCALAR_FUN_ATTR bool futrts_isnan64(double x) { return isnan(x); }
1749 SCALAR_FUN_ATTR bool futrts_isinf64(double x) { return isinf(x); }
1750
1751 SCALAR_FUN_ATTR int8_t fptosi_f64_i8(double x) {
1752 if (futrts_isnan64(x) || futrts_isinf64(x)) {
1753 return 0;
1754 } else {
1755 return (int8_t) x;
1756 }
1757 }
1758
1759 SCALAR_FUN_ATTR int16_t fptosi_f64_i16(double x) {
1760 if (futrts_isnan64(x) || futrts_isinf64(x)) {
1761 return 0;
1762 } else {
1763 return (int16_t) x;
1764 }
1765 }
1766
1767 SCALAR_FUN_ATTR int32_t fptosi_f64_i32(double x) {
1768 if (futrts_isnan64(x) || futrts_isinf64(x)) {
1769 return 0;
1770 } else {
1771 return (int32_t) x;
1772 }
1773 }
1774
1775 SCALAR_FUN_ATTR int64_t fptosi_f64_i64(double x) {
1776 if (futrts_isnan64(x) || futrts_isinf64(x)) {
1777 return 0;
1778 } else {
1779 return (int64_t) x;
1780 }
1781 }
1782
1783 SCALAR_FUN_ATTR uint8_t fptoui_f64_i8(double x) {
1784 if (futrts_isnan64(x) || futrts_isinf64(x)) {
1785 return 0;
1786 } else {
1787 return (uint8_t) (int8_t) x;
1788 }
1789 }
1790
1791 SCALAR_FUN_ATTR uint16_t fptoui_f64_i16(double x) {
1792 if (futrts_isnan64(x) || futrts_isinf64(x)) {
1793 return 0;
1794 } else {
1795 return (uint16_t) (int16_t) x;
1796 }
1797 }
1798
1799 SCALAR_FUN_ATTR uint32_t fptoui_f64_i32(double x) {
1800 if (futrts_isnan64(x) || futrts_isinf64(x)) {
1801 return 0;
1802 } else {
1803 return (uint32_t) (int32_t) x;
1804 }
1805 }
1806
1807 SCALAR_FUN_ATTR uint64_t fptoui_f64_i64(double x) {
1808 if (futrts_isnan64(x) || futrts_isinf64(x)) {
1809 return 0;
1810 } else {
1811 return (uint64_t) (int64_t) x;
1812 }
1813 }
1814
1815 SCALAR_FUN_ATTR bool ftob_f64_bool(double x) { return x != 0; }
1816 SCALAR_FUN_ATTR double btof_bool_f64(bool x) { return x ? 1 : 0; }
1817
1818 SCALAR_FUN_ATTR int64_t fptobits_f64_i64(double x) {
1819 union {
1820 double f;
1821 int64_t t;
1822 } p;
1823
1824 p.f = x;
1825 return p.t;
1826 }
1827
1828 SCALAR_FUN_ATTR double bitstofp_i64_f64(int64_t x) {
1829 union {
1830 int64_t f;
1831 double t;
1832 } p;
1833
1834 p.f = x;
1835 return p.t;
1836 }
1837
1838 SCALAR_FUN_ATTR double fmod64(double x, double y) {
1839 return fmod(x, y);
1840 }
1841
1842 SCALAR_FUN_ATTR double fsignum64(double x) {
1843 return futrts_isnan64(x) ? x : (x > 0) - (x < 0);
1844 }
1845
1846 SCALAR_FUN_ATTR double futrts_lerp64(double v0, double v1, double t) {
1847 #ifdef __OPENCL_VERSION__
1848 return mix(v0, v1, t);
1849 #else
1850 return v0 + (v1 - v0) * t;
1851 #endif
1852 }
1853
1854 SCALAR_FUN_ATTR double futrts_ldexp64(double x, int32_t y) {
1855 return ldexp(x, y);
1856 }
1857
1858 SCALAR_FUN_ATTR float futrts_copysign64(double x, double y) {
1859 return copysign(x, y);
1860 }
1861
1862 SCALAR_FUN_ATTR double futrts_mad64(double a, double b, double c) {
1863 #ifdef __OPENCL_VERSION__
1864 return mad(a, b, c);
1865 #else
1866 return a * b + c;
1867 #endif
1868 }
1869
1870 SCALAR_FUN_ATTR float fpconv_f32_f32(float x) { return (float) x; }
1871 SCALAR_FUN_ATTR double fpconv_f32_f64(float x) { return (double) x; }
1872 SCALAR_FUN_ATTR float fpconv_f64_f32(double x) { return (float) x; }
1873 SCALAR_FUN_ATTR double fpconv_f64_f64(double x) { return (double) x; }
1874
1875 #endif
1876
1877 #endif
1878
1879 #define futrts_cond_f16(x,y,z) ((x) ? (y) : (z))
1880 #define futrts_cond_f32(x,y,z) ((x) ? (y) : (z))
1881 #define futrts_cond_f64(x,y,z) ((x) ? (y) : (z))
1882
1883 #define futrts_cond_i8(x,y,z) ((x) ? (y) : (z))
1884 #define futrts_cond_i16(x,y,z) ((x) ? (y) : (z))
1885 #define futrts_cond_i32(x,y,z) ((x) ? (y) : (z))
1886 #define futrts_cond_i64(x,y,z) ((x) ? (y) : (z))
1887
1888 #define futrts_cond_bool(x,y,z) ((x) ? (y) : (z))
1889 #define futrts_cond_unit(x,y,z) ((x) ? (y) : (z))
1890
1891 // End of scalar.h.