Debian Codegraph @

rts/c/uniform.h

raw
1 // Start of uniform.h
2
3 // Uniform versions of all library functions as to
4 // improve performance in ISPC when in an uniform context.
5
6 #if defined(ISPC)
7
8 static inline uniform uint8_t add8(uniform uint8_t x, uniform uint8_t y) {
9 return x + y;
10 }
11
12 static inline uniform uint16_t add16(uniform uint16_t x, uniform uint16_t y) {
13 return x + y;
14 }
15
16 static inline uniform uint32_t add32(uniform uint32_t x, uniform uint32_t y) {
17 return x + y;
18 }
19
20 static inline uniform uint64_t add64(uniform uint64_t x, uniform uint64_t y) {
21 return x + y;
22 }
23
24 static inline uniform uint8_t sub8(uniform uint8_t x, uniform uint8_t y) {
25 return x - y;
26 }
27
28 static inline uniform uint16_t sub16(uniform uint16_t x, uniform uint16_t y) {
29 return x - y;
30 }
31
32 static inline uniform uint32_t sub32(uniform uint32_t x, uniform uint32_t y) {
33 return x - y;
34 }
35
36 static inline uniform uint64_t sub64(uniform uint64_t x, uniform uint64_t y) {
37 return x - y;
38 }
39
40 static inline uniform uint8_t mul8(uniform uint8_t x, uniform uint8_t y) {
41 return x * y;
42 }
43
44 static inline uniform uint16_t mul16(uniform uint16_t x, uniform uint16_t y) {
45 return x * y;
46 }
47
48 static inline uniform uint32_t mul32(uniform uint32_t x, uniform uint32_t y) {
49 return x * y;
50 }
51
52 static inline uniform uint64_t mul64(uniform uint64_t x, uniform uint64_t y) {
53 return x * y;
54 }
55
56 static inline uniform uint8_t udiv8(uniform uint8_t x, uniform uint8_t y) {
57 return x / y;
58 }
59
60 static inline uniform uint16_t udiv16(uniform uint16_t x, uniform uint16_t y) {
61 return x / y;
62 }
63
64 static inline uniform uint32_t udiv32(uniform uint32_t x, uniform uint32_t y) {
65 return x / y;
66 }
67
68 static inline uniform uint64_t udiv64(uniform uint64_t x, uniform uint64_t y) {
69 return x / y;
70 }
71
72 static inline uniform uint8_t udiv_up8(uniform uint8_t x, uniform uint8_t y) {
73 return (x + y - 1) / y;
74 }
75
76 static inline uniform uint16_t udiv_up16(uniform uint16_t x, uniform uint16_t y) {
77 return (x + y - 1) / y;
78 }
79
80 static inline uniform uint32_t udiv_up32(uniform uint32_t x, uniform uint32_t y) {
81 return (x + y - 1) / y;
82 }
83
84 static inline uniform uint64_t udiv_up64(uniform uint64_t x, uniform uint64_t y) {
85 return (x + y - 1) / y;
86 }
87
88 static inline uniform uint8_t umod8(uniform uint8_t x, uniform uint8_t y) {
89 return x % y;
90 }
91
92 static inline uniform uint16_t umod16(uniform uint16_t x, uniform uint16_t y) {
93 return x % y;
94 }
95
96 static inline uniform uint32_t umod32(uniform uint32_t x, uniform uint32_t y) {
97 return x % y;
98 }
99
100 static inline uniform uint64_t umod64(uniform uint64_t x, uniform uint64_t y) {
101 return x % y;
102 }
103
104 static inline uniform uint8_t udiv_safe8(uniform uint8_t x, uniform uint8_t y) {
105 return y == 0 ? 0 : x / y;
106 }
107
108 static inline uniform uint16_t udiv_safe16(uniform uint16_t x, uniform uint16_t y) {
109 return y == 0 ? 0 : x / y;
110 }
111
112 static inline uniform uint32_t udiv_safe32(uniform uint32_t x, uniform uint32_t y) {
113 return y == 0 ? 0 : x / y;
114 }
115
116 static inline uniform uint64_t udiv_safe64(uniform uint64_t x, uniform uint64_t y) {
117 return y == 0 ? 0 : x / y;
118 }
119
120 static inline uniform uint8_t udiv_up_safe8(uniform uint8_t x, uniform uint8_t y) {
121 return y == 0 ? 0 : (x + y - 1) / y;
122 }
123
124 static inline uniform uint16_t udiv_up_safe16(uniform uint16_t x, uniform uint16_t y) {
125 return y == 0 ? 0 : (x + y - 1) / y;
126 }
127
128 static inline uniform uint32_t udiv_up_safe32(uniform uint32_t x, uniform uint32_t y) {
129 return y == 0 ? 0 : (x + y - 1) / y;
130 }
131
132 static inline uniform uint64_t udiv_up_safe64(uniform uint64_t x, uniform uint64_t y) {
133 return y == 0 ? 0 : (x + y - 1) / y;
134 }
135
136 static inline uniform uint8_t umod_safe8(uniform uint8_t x, uniform uint8_t y) {
137 return y == 0 ? 0 : x % y;
138 }
139
140 static inline uniform uint16_t umod_safe16(uniform uint16_t x, uniform uint16_t y) {
141 return y == 0 ? 0 : x % y;
142 }
143
144 static inline uniform uint32_t umod_safe32(uniform uint32_t x, uniform uint32_t y) {
145 return y == 0 ? 0 : x % y;
146 }
147
148 static inline uniform uint64_t umod_safe64(uniform uint64_t x, uniform uint64_t y) {
149 return y == 0 ? 0 : x % y;
150 }
151
152 static inline uniform int8_t sdiv8(uniform int8_t x, uniform int8_t y) {
153 uniform int8_t q = x / y;
154 uniform int8_t r = x % y;
155
156 return q - ((r != 0 && r < 0 != y < 0) ? 1 : 0);
157 }
158
159 static inline uniform int16_t sdiv16(uniform int16_t x, uniform int16_t y) {
160 uniform int16_t q = x / y;
161 uniform int16_t r = x % y;
162
163 return q - ((r != 0 && r < 0 != y < 0) ? 1 : 0);
164 }
165
166 static inline uniform int32_t sdiv32(uniform int32_t x, uniform int32_t y) {
167 uniform int32_t q = x / y;
168 uniform int32_t r = x % y;
169
170 return q - ((r != 0 && r < 0 != y < 0) ? 1 : 0);
171 }
172
173 static inline uniform int64_t sdiv64(uniform int64_t x, uniform int64_t y) {
174 uniform int64_t q = x / y;
175 uniform int64_t r = x % y;
176
177 return q - ((r != 0 && r < 0 != y < 0) ? 1 : 0);
178 }
179
180 static inline uniform int8_t sdiv_up8(uniform int8_t x, uniform int8_t y) {
181 return sdiv8(x + y - 1, y);
182 }
183
184 static inline uniform int16_t sdiv_up16(uniform int16_t x, uniform int16_t y) {
185 return sdiv16(x + y - 1, y);
186 }
187
188 static inline uniform int32_t sdiv_up32(uniform int32_t x, uniform int32_t y) {
189 return sdiv32(x + y - 1, y);
190 }
191
192 static inline uniform int64_t sdiv_up64(uniform int64_t x, uniform int64_t y) {
193 return sdiv64(x + y - 1, y);
194 }
195
196 static inline uniform int8_t smod8(uniform int8_t x, uniform int8_t y) {
197 uniform int8_t r = x % y;
198
199 return r + (r == 0 || (x > 0 && y > 0) || (x < 0 && y < 0) ? 0 : y);
200 }
201
202 static inline uniform int16_t smod16(uniform int16_t x, uniform int16_t y) {
203 uniform int16_t r = x % y;
204
205 return r + (r == 0 || (x > 0 && y > 0) || (x < 0 && y < 0) ? 0 : y);
206 }
207
208 static inline uniform int32_t smod32(uniform int32_t x, uniform int32_t y) {
209 uniform int32_t r = x % y;
210
211 return r + (r == 0 || (x > 0 && y > 0) || (x < 0 && y < 0) ? 0 : y);
212 }
213
214 static inline uniform int64_t smod64(uniform int64_t x, uniform int64_t y) {
215 uniform int64_t r = x % y;
216
217 return r + (r == 0 || (x > 0 && y > 0) || (x < 0 && y < 0) ? 0 : y);
218 }
219
220 static inline uniform int8_t sdiv_safe8(uniform int8_t x, uniform int8_t y) {
221 return y == 0 ? 0 : sdiv8(x, y);
222 }
223
224 static inline uniform int16_t sdiv_safe16(uniform int16_t x, uniform int16_t y) {
225 return y == 0 ? 0 : sdiv16(x, y);
226 }
227
228 static inline uniform int32_t sdiv_safe32(uniform int32_t x, uniform int32_t y) {
229 return y == 0 ? 0 : sdiv32(x, y);
230 }
231
232 static inline uniform int64_t sdiv_safe64(uniform int64_t x, uniform int64_t y) {
233 return y == 0 ? 0 : sdiv64(x, y);
234 }
235
236 static inline uniform int8_t sdiv_up_safe8(uniform int8_t x, uniform int8_t y) {
237 return sdiv_safe8(x + y - 1, y);
238 }
239
240 static inline uniform int16_t sdiv_up_safe16(uniform int16_t x, uniform int16_t y) {
241 return sdiv_safe16(x + y - 1, y);
242 }
243
244 static inline uniform int32_t sdiv_up_safe32(uniform int32_t x, uniform int32_t y) {
245 return sdiv_safe32(x + y - 1, y);
246 }
247
248 static inline uniform int64_t sdiv_up_safe64(uniform int64_t x, uniform int64_t y) {
249 return sdiv_safe64(x + y - 1, y);
250 }
251
252 static inline uniform int8_t smod_safe8(uniform int8_t x, uniform int8_t y) {
253 return y == 0 ? 0 : smod8(x, y);
254 }
255
256 static inline uniform int16_t smod_safe16(uniform int16_t x, uniform int16_t y) {
257 return y == 0 ? 0 : smod16(x, y);
258 }
259
260 static inline uniform int32_t smod_safe32(uniform int32_t x, uniform int32_t y) {
261 return y == 0 ? 0 : smod32(x, y);
262 }
263
264 static inline uniform int64_t smod_safe64(uniform int64_t x, uniform int64_t y) {
265 return y == 0 ? 0 : smod64(x, y);
266 }
267
268 static inline uniform int8_t squot8(uniform int8_t x, uniform int8_t y) {
269 return x / y;
270 }
271
272 static inline uniform int16_t squot16(uniform int16_t x, uniform int16_t y) {
273 return x / y;
274 }
275
276 static inline uniform int32_t squot32(uniform int32_t x, uniform int32_t y) {
277 return x / y;
278 }
279
280 static inline uniform int64_t squot64(uniform int64_t x, uniform int64_t y) {
281 return x / y;
282 }
283
284 static inline uniform int8_t srem8(uniform int8_t x, uniform int8_t y) {
285 return x % y;
286 }
287
288 static inline uniform int16_t srem16(uniform int16_t x, uniform int16_t y) {
289 return x % y;
290 }
291
292 static inline uniform int32_t srem32(uniform int32_t x, uniform int32_t y) {
293 return x % y;
294 }
295
296 static inline uniform int64_t srem64(uniform int64_t x, uniform int64_t y) {
297 return x % y;
298 }
299
300 static inline uniform int8_t squot_safe8(uniform int8_t x, uniform int8_t y) {
301 return y == 0 ? 0 : x / y;
302 }
303
304 static inline uniform int16_t squot_safe16(uniform int16_t x, uniform int16_t y) {
305 return y == 0 ? 0 : x / y;
306 }
307
308 static inline uniform int32_t squot_safe32(uniform int32_t x, uniform int32_t y) {
309 return y == 0 ? 0 : x / y;
310 }
311
312 static inline uniform int64_t squot_safe64(uniform int64_t x, uniform int64_t y) {
313 return y == 0 ? 0 : x / y;
314 }
315
316 static inline uniform int8_t srem_safe8(uniform int8_t x, uniform int8_t y) {
317 return y == 0 ? 0 : x % y;
318 }
319
320 static inline uniform int16_t srem_safe16(uniform int16_t x, uniform int16_t y) {
321 return y == 0 ? 0 : x % y;
322 }
323
324 static inline uniform int32_t srem_safe32(uniform int32_t x, uniform int32_t y) {
325 return y == 0 ? 0 : x % y;
326 }
327
328 static inline uniform int64_t srem_safe64(uniform int64_t x, uniform int64_t y) {
329 return y == 0 ? 0 : x % y;
330 }
331
332 static inline uniform int8_t smin8(uniform int8_t x, uniform int8_t y) {
333 return x < y ? x : y;
334 }
335
336 static inline uniform int16_t smin16(uniform int16_t x, uniform int16_t y) {
337 return x < y ? x : y;
338 }
339
340 static inline uniform int32_t smin32(uniform int32_t x, uniform int32_t y) {
341 return x < y ? x : y;
342 }
343
344 static inline uniform int64_t smin64(uniform int64_t x, uniform int64_t y) {
345 return x < y ? x : y;
346 }
347
348 static inline uniform uint8_t umin8(uniform uint8_t x, uniform uint8_t y) {
349 return x < y ? x : y;
350 }
351
352 static inline uniform uint16_t umin16(uniform uint16_t x, uniform uint16_t y) {
353 return x < y ? x : y;
354 }
355
356 static inline uniform uint32_t umin32(uniform uint32_t x, uniform uint32_t y) {
357 return x < y ? x : y;
358 }
359
360 static inline uniform uint64_t umin64(uniform uint64_t x, uniform uint64_t y) {
361 return x < y ? x : y;
362 }
363
364 static inline uniform int8_t smax8(uniform int8_t x, uniform int8_t y) {
365 return x < y ? y : x;
366 }
367
368 static inline uniform int16_t smax16(uniform int16_t x, uniform int16_t y) {
369 return x < y ? y : x;
370 }
371
372 static inline uniform int32_t smax32(uniform int32_t x, uniform int32_t y) {
373 return x < y ? y : x;
374 }
375
376 static inline uniform int64_t smax64(uniform int64_t x, uniform int64_t y) {
377 return x < y ? y : x;
378 }
379
380 static inline uniform uint8_t umax8(uniform uint8_t x, uniform uint8_t y) {
381 return x < y ? y : x;
382 }
383
384 static inline uniform uint16_t umax16(uniform uint16_t x, uniform uint16_t y) {
385 return x < y ? y : x;
386 }
387
388 static inline uniform uint32_t umax32(uniform uint32_t x, uniform uint32_t y) {
389 return x < y ? y : x;
390 }
391
392 static inline uniform uint64_t umax64(uniform uint64_t x, uniform uint64_t y) {
393 return x < y ? y : x;
394 }
395
396 static inline uniform uint8_t shl8(uniform uint8_t x, uniform uint8_t y) {
397 return (uniform uint8_t)(x << y);
398 }
399
400 static inline uniform uint16_t shl16(uniform uint16_t x, uniform uint16_t y) {
401 return (uniform uint16_t)(x << y);
402 }
403
404 static inline uniform uint32_t shl32(uniform uint32_t x, uniform uint32_t y) {
405 return x << y;
406 }
407
408 static inline uniform uint64_t shl64(uniform uint64_t x, uniform uint64_t y) {
409 return x << y;
410 }
411
412 static inline uniform uint8_t lshr8(uniform uint8_t x, uniform uint8_t y) {
413 return x >> y;
414 }
415
416 static inline uniform uint16_t lshr16(uniform uint16_t x, uniform uint16_t y) {
417 return x >> y;
418 }
419
420 static inline uniform uint32_t lshr32(uniform uint32_t x, uniform uint32_t y) {
421 return x >> y;
422 }
423
424 static inline uniform uint64_t lshr64(uniform uint64_t x, uniform uint64_t y) {
425 return x >> y;
426 }
427
428 static inline uniform int8_t ashr8(uniform int8_t x, uniform int8_t y) {
429 return x >> y;
430 }
431
432 static inline uniform int16_t ashr16(uniform int16_t x, uniform int16_t y) {
433 return x >> y;
434 }
435
436 static inline uniform int32_t ashr32(uniform int32_t x, uniform int32_t y) {
437 return x >> y;
438 }
439
440 static inline uniform int64_t ashr64(uniform int64_t x, uniform int64_t y) {
441 return x >> y;
442 }
443
444 static inline uniform uint8_t and8(uniform uint8_t x, uniform uint8_t y) {
445 return x & y;
446 }
447
448 static inline uniform uint16_t and16(uniform uint16_t x, uniform uint16_t y) {
449 return x & y;
450 }
451
452 static inline uniform uint32_t and32(uniform uint32_t x, uniform uint32_t y) {
453 return x & y;
454 }
455
456 static inline uniform uint64_t and64(uniform uint64_t x, uniform uint64_t y) {
457 return x & y;
458 }
459
460 static inline uniform uint8_t or8(uniform uint8_t x, uniform uint8_t y) {
461 return x | y;
462 }
463
464 static inline uniform uint16_t or16(uniform uint16_t x, uniform uint16_t y) {
465 return x | y;
466 }
467
468 static inline uniform uint32_t or32(uniform uint32_t x, uniform uint32_t y) {
469 return x | y;
470 }
471
472 static inline uniform uint64_t or64(uniform uint64_t x, uniform uint64_t y) {
473 return x | y;
474 }
475
476 static inline uniform uint8_t xor8(uniform uint8_t x, uniform uint8_t y) {
477 return x ^ y;
478 }
479
480 static inline uniform uint16_t xor16(uniform uint16_t x, uniform uint16_t y) {
481 return x ^ y;
482 }
483
484 static inline uniform uint32_t xor32(uniform uint32_t x, uniform uint32_t y) {
485 return x ^ y;
486 }
487
488 static inline uniform uint64_t xor64(uniform uint64_t x, uniform uint64_t y) {
489 return x ^ y;
490 }
491
492 static inline uniform bool ult8(uniform uint8_t x, uniform uint8_t y) {
493 return x < y;
494 }
495
496 static inline uniform bool ult16(uniform uint16_t x, uniform uint16_t y) {
497 return x < y;
498 }
499
500 static inline uniform bool ult32(uniform uint32_t x, uniform uint32_t y) {
501 return x < y;
502 }
503
504 static inline uniform bool ult64(uniform uint64_t x, uniform uint64_t y) {
505 return x < y;
506 }
507
508 static inline uniform bool ule8(uniform uint8_t x, uniform uint8_t y) {
509 return x <= y;
510 }
511
512 static inline uniform bool ule16(uniform uint16_t x, uniform uint16_t y) {
513 return x <= y;
514 }
515
516 static inline uniform bool ule32(uniform uint32_t x, uniform uint32_t y) {
517 return x <= y;
518 }
519
520 static inline uniform bool ule64(uniform uint64_t x, uniform uint64_t y) {
521 return x <= y;
522 }
523
524 static inline uniform bool slt8(uniform int8_t x, uniform int8_t y) {
525 return x < y;
526 }
527
528 static inline uniform bool slt16(uniform int16_t x, uniform int16_t y) {
529 return x < y;
530 }
531
532 static inline uniform bool slt32(uniform int32_t x, uniform int32_t y) {
533 return x < y;
534 }
535
536 static inline uniform bool slt64(uniform int64_t x, uniform int64_t y) {
537 return x < y;
538 }
539
540 static inline uniform bool sle8(uniform int8_t x, uniform int8_t y) {
541 return x <= y;
542 }
543
544 static inline uniform bool sle16(uniform int16_t x, uniform int16_t y) {
545 return x <= y;
546 }
547
548 static inline uniform bool sle32(uniform int32_t x, uniform int32_t y) {
549 return x <= y;
550 }
551
552 static inline uniform bool sle64(uniform int64_t x, uniform int64_t y) {
553 return x <= y;
554 }
555
556 static inline uniform uint8_t pow8(uniform uint8_t x, uniform uint8_t y) {
557 uniform uint8_t res = 1, rem = y;
558
559 while (rem != 0) {
560 if (rem & 1)
561 res *= x;
562 rem >>= 1;
563 x *= x;
564 }
565 return res;
566 }
567
568 static inline uniform uint16_t pow16(uniform uint16_t x, uniform uint16_t y) {
569 uniform uint16_t res = 1, rem = y;
570
571 while (rem != 0) {
572 if (rem & 1)
573 res *= x;
574 rem >>= 1;
575 x *= x;
576 }
577 return res;
578 }
579
580 static inline uniform uint32_t pow32(uniform uint32_t x, uniform uint32_t y) {
581 uniform uint32_t res = 1, rem = y;
582
583 while (rem != 0) {
584 if (rem & 1)
585 res *= x;
586 rem >>= 1;
587 x *= x;
588 }
589 return res;
590 }
591
592 static inline uniform uint64_t pow64(uniform uint64_t x, uniform uint64_t y) {
593 uniform uint64_t res = 1, rem = y;
594
595 while (rem != 0) {
596 if (rem & 1)
597 res *= x;
598 rem >>= 1;
599 x *= x;
600 }
601 return res;
602 }
603
604 static inline uniform bool itob_i8_bool(uniform int8_t x) {
605 return x != 0;
606 }
607
608 static inline uniform bool itob_i16_bool(uniform int16_t x) {
609 return x != 0;
610 }
611
612 static inline uniform bool itob_i32_bool(uniform int32_t x) {
613 return x != 0;
614 }
615
616 static inline uniform bool itob_i64_bool(uniform int64_t x) {
617 return x != 0;
618 }
619
620 static inline uniform int8_t btoi_bool_i8(uniform bool x) {
621 return x;
622 }
623
624 static inline uniform int16_t btoi_bool_i16(uniform bool x) {
625 return x;
626 }
627
628 static inline uniform int32_t btoi_bool_i32(uniform bool x) {
629 return x;
630 }
631
632 static inline uniform int64_t btoi_bool_i64(uniform bool x) {
633 return x;
634 }
635
636
637 static uniform int8_t abs8(uniform int8_t x) {
638 return (uniform int8_t)abs(x);
639 }
640
641 static uniform int16_t abs16(uniform int16_t x) {
642 return (uniform int16_t)abs(x);
643 }
644
645 static uniform int32_t abs32(uniform int32_t x) {
646 return abs(x);
647 }
648
649 static uniform int64_t abs64(uniform int64_t x) {
650 return abs(x);
651 }
652
653 static uniform int32_t futrts_popc8(uniform uint8_t x) {
654 uniform int c = 0;
655 for (; x; ++c) { x &= x - 1; }
656 return c;
657 }
658
659 static uniform int32_t futrts_popc16(uniform uint16_t x) {
660 uniform int c = 0;
661 for (; x; ++c) { x &= x - 1; }
662 return c;
663 }
664
665 static uniform int32_t futrts_popc32(uniform uint32_t x) {
666 uniform int c = 0;
667 for (; x; ++c) { x &= x - 1; }
668 return c;
669 }
670
671 static uniform int32_t futrts_popc64(uniform uint64_t x) {
672 uniform int c = 0;
673 for (; x; ++c) { x &= x - 1; }
674 return c;
675 }
676
677 static uniform uint8_t futrts_mul_hi8(uniform uint8_t a, uniform uint8_t b) {
678 uniform uint16_t aa = a;
679 uniform uint16_t bb = b;
680
681 return aa * bb >> 8;
682 }
683
684 static uniform uint16_t futrts_mul_hi16(uniform uint16_t a, uniform uint16_t b) {
685 uniform uint32_t aa = a;
686 uniform uint32_t bb = b;
687
688 return aa * bb >> 16;
689 }
690
691 static uniform uint32_t futrts_mul_hi32(uniform uint32_t a, uniform uint32_t b) {
692 uniform uint64_t aa = a;
693 uniform uint64_t bb = b;
694
695 return aa * bb >> 32;
696 }
697
698 static uniform uint64_t futrts_mul_hi64(uniform uint64_t a, uniform uint64_t b) {
699 uniform uint64_t ah = a >> 32;
700 uniform uint64_t al = a & 0xffffffff;
701 uniform uint64_t bh = b >> 32;
702 uniform uint64_t bl = b & 0xffffffff;
703
704 uniform uint64_t p1 = al * bl;
705 uniform uint64_t p2 = al * bh;
706 uniform uint64_t p3 = ah * bl;
707 uniform uint64_t p4 = ah * bh;
708
709 uniform uint64_t p1h = p1 >> 32;
710 uniform uint64_t p2h = p2 >> 32;
711 uniform uint64_t p3h = p3 >> 32;
712 uniform uint64_t p2l = p2 & 0xffffffff;
713 uniform uint64_t p3l = p3 & 0xffffffff;
714
715 uniform uint64_t l = p1h + p2l + p3l;
716 uniform uint64_t m = (p2 >> 32) + (p3 >> 32);
717 uniform uint64_t h = (l >> 32) + m + p4;
718
719 return h;
720 }
721
722 static uniform uint8_t futrts_mad_hi8(uniform uint8_t a, uniform uint8_t b, uniform uint8_t c) {
723 return futrts_mul_hi8(a, b) + c;
724 }
725
726 static uniform uint16_t futrts_mad_hi16(uniform uint16_t a, uniform uint16_t b, uniform uint16_t c) {
727 return futrts_mul_hi16(a, b) + c;
728 }
729
730 static uniform uint32_t futrts_mad_hi32(uniform uint32_t a, uniform uint32_t b, uniform uint32_t c) {
731 return futrts_mul_hi32(a, b) + c;
732 }
733
734 static uniform uint64_t futrts_mad_hi64(uniform uint64_t a, uniform uint64_t b, uniform uint64_t c) {
735 return futrts_mul_hi64(a, b) + c;
736 }
737
738 static uniform int32_t futrts_clzz8(uniform int8_t x) {
739 return count_leading_zeros((uniform int32_t)(uniform uint8_t)x)-24;
740 }
741
742 static uniform int32_t futrts_clzz16(uniform int16_t x) {
743 return count_leading_zeros((uniform int32_t)(uniform uint16_t)x)-16;
744 }
745
746 static uniform int32_t futrts_clzz32(uniform int32_t x) {
747 return count_leading_zeros(x);
748 }
749
750 static uniform int32_t futrts_clzz64(uniform int64_t x) {
751 return count_leading_zeros(x);
752 }
753
754 static uniform int32_t futrts_ctzz8(uniform int8_t x) {
755 return x == 0 ? 8 : count_trailing_zeros((uniform int32_t)x);
756 }
757
758 static uniform int32_t futrts_ctzz16(uniform int16_t x) {
759 return x == 0 ? 16 : count_trailing_zeros((uniform int32_t)x);
760 }
761
762 static uniform int32_t futrts_ctzz32(uniform int32_t x) {
763 return count_trailing_zeros(x);
764 }
765
766 static uniform int32_t futrts_ctzz64(uniform int64_t x) {
767 return count_trailing_zeros(x);
768 }
769
770
771 static inline uniform float fdiv32(uniform float x, uniform float y) {
772 return x / y;
773 }
774
775 static inline uniform float fadd32(uniform float x, uniform float y) {
776 return x + y;
777 }
778
779 static inline uniform float fsub32(uniform float x, uniform float y) {
780 return x - y;
781 }
782
783 static inline uniform float fmul32(uniform float x, uniform float y) {
784 return x * y;
785 }
786
787 static inline uniform bool cmplt32(uniform float x, uniform float y) {
788 return x < y;
789 }
790
791 static inline uniform bool cmple32(uniform float x, uniform float y) {
792 return x <= y;
793 }
794
795 static inline uniform float sitofp_i8_f32(uniform int8_t x) {
796 return (uniform float) x;
797 }
798
799 static inline uniform float sitofp_i16_f32(uniform int16_t x) {
800 return (uniform float) x;
801 }
802
803 static inline uniform float sitofp_i32_f32(uniform int32_t x) {
804 return (uniform float) x;
805 }
806
807 static inline uniform float sitofp_i64_f32(uniform int64_t x) {
808 return (uniform float) x;
809 }
810
811 static inline uniform float uitofp_i8_f32(uniform uint8_t x) {
812 return (uniform float) x;
813 }
814
815 static inline uniform float uitofp_i16_f32(uniform uint16_t x) {
816 return (uniform float) x;
817 }
818
819 static inline uniform float uitofp_i32_f32(uniform uint32_t x) {
820 return (uniform float) x;
821 }
822
823 static inline uniform float uitofp_i64_f32(uniform uint64_t x) {
824 return (uniform float) x;
825 }
826
827
828 static inline uniform float fabs32(uniform float x) {
829 return abs(x);
830 }
831
832 static inline uniform float fmax32(uniform float x, uniform float y) {
833 return isnan(x) ? y : isnan(y) ? x : max(x, y);
834 }
835
836 static inline uniform float fmin32(uniform float x, uniform float y) {
837 return isnan(x) ? y : isnan(y) ? x : min(x, y);
838 }
839
840 static inline uniform float fpow32(uniform float x, uniform float y) {
841 return pow(x, y);
842 }
843
844 static inline uniform bool futrts_isnan32(uniform float x) {
845 return isnan(x);
846 }
847
848 static inline uniform bool futrts_isinf32(uniform float x) {
849 return !isnan(x) && isnan(x - x);
850 }
851 static inline uniform bool futrts_isfinite32(uniform float x) {
852 return !isnan(x) && !futrts_isinf32(x);
853 }
854
855
856 static inline uniform int8_t fptosi_f32_i8(uniform float x) {
857 if (futrts_isnan32(x) || futrts_isinf32(x)) {
858 return 0;
859 } else {
860 return (uniform int8_t) x;
861 }
862 }
863
864 static inline uniform int16_t fptosi_f32_i16(uniform float x) {
865 if (futrts_isnan32(x) || futrts_isinf32(x)) {
866 return 0;
867 } else {
868 return (uniform int16_t) x;
869 }
870 }
871
872 static inline uniform int32_t fptosi_f32_i32(uniform float x) {
873 if (futrts_isnan32(x) || futrts_isinf32(x)) {
874 return 0;
875 } else {
876 return (uniform int32_t) x;
877 }
878 }
879
880 static inline uniform int64_t fptosi_f32_i64(uniform float x) {
881 if (futrts_isnan32(x) || futrts_isinf32(x)) {
882 return 0;
883 } else {
884 return (uniform int64_t) x;
885 };
886 }
887
888 static inline uniform uint8_t fptoui_f32_i8(uniform float x) {
889 if (futrts_isnan32(x) || futrts_isinf32(x)) {
890 return 0;
891 } else {
892 return (uniform uint8_t) (uniform int8_t) x;
893 }
894 }
895
896 static inline uniform uint16_t fptoui_f32_i16(uniform float x) {
897 if (futrts_isnan32(x) || futrts_isinf32(x)) {
898 return 0;
899 } else {
900 return (uniform uint16_t) (uniform int16_t) x;
901 }
902 }
903
904 static inline uniform uint32_t fptoui_f32_i32(uniform float x) {
905 if (futrts_isnan32(x) || futrts_isinf32(x)) {
906 return 0;
907 } else {
908 return (uniform uint32_t) (uniform int32_t) x;
909 }
910 }
911
912 static inline uniform uint64_t fptoui_f32_i64(uniform float x) {
913 if (futrts_isnan32(x) || futrts_isinf32(x)) {
914 return 0;
915 } else {
916 return (uniform uint64_t) (uniform int64_t) x;
917 }
918 }
919
920
921 static inline uniform float futrts_log32(uniform float x) {
922 return futrts_isfinite32(x) || (futrts_isinf32(x) && x < 0)? log(x) : x;
923 }
924
925 static inline uniform float futrts_log2_32(uniform float x) {
926 return futrts_log32(x) / log(2.0f);
927 }
928
929 static inline uniform float futrts_log10_32(uniform float x) {
930 return futrts_log32(x) / log(10.0f);
931 }
932
933 static inline uniform float futrts_log1p_32(uniform float x) {
934 if(x == -1.0f || (futrts_isinf32(x) && x > 0.0f)) return x / 0.0f;
935 uniform float y = 1.0f + x;
936 uniform float z = y - 1.0f;
937 return log(y) - (z-x)/y;
938 }
939
940 static inline uniform float futrts_sqrt32(uniform float x) {
941 return sqrt(x);
942 }
943
944 extern "C" unmasked uniform float cbrtf(uniform float);
945 static inline uniform float futrts_cbrt32(uniform float x) {
946 return cbrtf(x);
947 }
948
949 static inline uniform float futrts_exp32(uniform float x) {
950 return exp(x);
951 }
952
953 static inline uniform float futrts_cos32(uniform float x) {
954 return cos(x);
955 }
956
957 static inline uniform float futrts_sin32(uniform float x) {
958 return sin(x);
959 }
960
961 static inline uniform float futrts_tan32(uniform float x) {
962 return tan(x);
963 }
964
965 static inline uniform float futrts_acos32(uniform float x) {
966 return acos(x);
967 }
968
969 static inline uniform float futrts_asin32(uniform float x) {
970 return asin(x);
971 }
972
973 static inline uniform float futrts_atan32(uniform float x) {
974 return atan(x);
975 }
976
977 static inline uniform float futrts_cosh32(uniform float x) {
978 return (exp(x)+exp(-x)) / 2.0f;
979 }
980
981 static inline uniform float futrts_sinh32(uniform float x) {
982 return (exp(x)-exp(-x)) / 2.0f;
983 }
984
985 static inline uniform float futrts_tanh32(uniform float x) {
986 return futrts_sinh32(x)/futrts_cosh32(x);
987 }
988
989 static inline uniform float futrts_acosh32(uniform float x) {
990 uniform float f = x+sqrt(x*x-1);
991 if(futrts_isfinite32(f)) return log(f);
992 return f;
993 }
994
995 static inline uniform float futrts_asinh32(uniform float x) {
996 uniform float f = x+sqrt(x*x+1);
997 if(futrts_isfinite32(f)) return log(f);
998 return f;
999
1000 }
1001
1002 static inline uniform float futrts_atanh32(uniform float x) {
1003 uniform float f = (1+x)/(1-x);
1004 if(futrts_isfinite32(f)) return log(f)/2.0f;
1005 return f;
1006
1007 }
1008
1009 static inline uniform float futrts_atan2_32(uniform float x, uniform float y) {
1010 return (x == 0.0f && y == 0.0f) ? 0.0f : atan2(x, y);
1011 }
1012
1013 static inline uniform float futrts_hypot32(uniform float x, uniform float y) {
1014 if (futrts_isfinite32(x) && futrts_isfinite32(y)) {
1015 x = abs(x);
1016 y = abs(y);
1017 uniform float a;
1018 uniform float b;
1019 if (x >= y){
1020 a = x;
1021 b = y;
1022 } else {
1023 a = y;
1024 b = x;
1025 }
1026 if(b == 0){
1027 return a;
1028 }
1029
1030 uniform int e;
1031 uniform float an;
1032 uniform float bn;
1033 an = frexp (a, &e);
1034 bn = ldexp (b, - e);
1035 uniform float cn;
1036 cn = sqrt (an * an + bn * bn);
1037 return ldexp (cn, e);
1038 } else {
1039 if (futrts_isinf32(x) || futrts_isinf32(y)) return INFINITY;
1040 else return x + y;
1041 }
1042
1043 }
1044
1045 extern "C" unmasked uniform float tgammaf(uniform float x);
1046 static inline uniform float futrts_gamma32(uniform float x) {
1047 return tgammaf(x);
1048 }
1049
1050 extern "C" unmasked uniform float tgammaf(uniform float x);
1051 static inline uniform float futrts_lgamma32(uniform float x) {
1052 return lgammaf(x);
1053 }
1054
1055 extern "C" unmasked uniform float erff(uniform float);
1056 static inline uniform float futrts_erf32(uniform float x) {
1057 return erff(x);
1058 }
1059
1060 extern "C" unmasked uniform float erfcf(uniform float);
1061 static inline uniform float futrts_erfc32(uniform float x) {
1062 return erfcf(x);
1063 }
1064
1065 static inline uniform float fmod32(uniform float x, uniform float y) {
1066 return x - y * trunc(x/y);
1067 }
1068
1069 static inline uniform float futrts_round32(uniform float x) {
1070 return round(x);
1071 }
1072
1073 static inline uniform float futrts_floor32(uniform float x) {
1074 return floor(x);
1075 }
1076
1077 static inline uniform float futrts_ceil32(uniform float x) {
1078 return ceil(x);
1079 }
1080
1081 static inline uniform float futrts_lerp32(uniform float v0, uniform float v1, uniform float t) {
1082 return v0 + (v1 - v0) * t;
1083 }
1084
1085 static inline uniform float futrts_mad32(uniform float a, uniform float b, uniform float c) {
1086 return a * b + c;
1087 }
1088
1089 static inline uniform float futrts_fma32(uniform float a, uniform float b, uniform float c) {
1090 return a * b + c;
1091 }
1092
1093 static inline uniform int32_t futrts_to_bits32(uniform float x) {
1094 return intbits(x);
1095 }
1096
1097 static inline uniform float futrts_from_bits32(uniform int32_t x) {
1098 return floatbits(x);
1099 }
1100
1101 static inline uniform float fsignum32(uniform float x) {
1102 return futrts_isnan32(x) ? x : (x > 0 ? 1 : 0) - (x < 0 ? 1 : 0);
1103 }
1104
1105 #ifdef FUTHARK_F64_ENABLED
1106
1107 static inline uniform bool futrts_isinf64(uniform float x) {
1108 return !isnan(x) && isnan(x - x);
1109 }
1110 static inline uniform bool futrts_isfinite64(uniform float x) {
1111 return !isnan(x) && !futrts_isinf64(x);
1112 }
1113
1114 static inline uniform double fdiv64(uniform double x, uniform double y) {
1115 return x / y;
1116 }
1117
1118 static inline uniform double fadd64(uniform double x, uniform double y) {
1119 return x + y;
1120 }
1121
1122 static inline uniform double fsub64(uniform double x, uniform double y) {
1123 return x - y;
1124 }
1125
1126 static inline uniform double fmul64(uniform double x, uniform double y) {
1127 return x * y;
1128 }
1129
1130 static inline uniform bool cmplt64(uniform double x, uniform double y) {
1131 return x < y;
1132 }
1133
1134 static inline uniform bool cmple64(uniform double x, uniform double y) {
1135 return x <= y;
1136 }
1137
1138 static inline uniform double sitofp_i8_f64(uniform int8_t x) {
1139 return (uniform double) x;
1140 }
1141
1142 static inline uniform double sitofp_i16_f64(uniform int16_t x) {
1143 return (uniform double) x;
1144 }
1145
1146 static inline uniform double sitofp_i32_f64(uniform int32_t x) {
1147 return (uniform double) x;
1148 }
1149
1150 static inline uniform double sitofp_i64_f64(uniform int64_t x) {
1151 return (uniform double) x;
1152 }
1153
1154 static inline uniform double uitofp_i8_f64(uniform uint8_t x) {
1155 return (uniform double) x;
1156 }
1157
1158 static inline uniform double uitofp_i16_f64(uniform uint16_t x) {
1159 return (uniform double) x;
1160 }
1161
1162 static inline uniform double uitofp_i32_f64(uniform uint32_t x) {
1163 return (uniform double) x;
1164 }
1165
1166 static inline uniform double uitofp_i64_f64(uniform uint64_t x) {
1167 return (uniform double) x;
1168 }
1169
1170 static inline uniform double fabs64(uniform double x) {
1171 return abs(x);
1172 }
1173
1174 static inline uniform double fmax64(uniform double x, uniform double y) {
1175 return isnan(x) ? y : isnan(y) ? x : max(x, y);
1176 }
1177
1178 static inline uniform double fmin64(uniform double x, uniform double y) {
1179 return isnan(x) ? y : isnan(y) ? x : min(x, y);
1180 }
1181
1182 static inline uniform double fpow64(uniform double x, uniform double y) {
1183 return pow(x, y);
1184 }
1185
1186 static inline uniform double futrts_log64(uniform double x) {
1187 return futrts_isfinite64(x) || (futrts_isinf64(x) && x < 0)? log(x) : x;
1188 }
1189
1190 static inline uniform double futrts_log2_64(uniform double x) {
1191 return futrts_log64(x)/log(2.0d);
1192 }
1193
1194 static inline uniform double futrts_log10_64(uniform double x) {
1195 return futrts_log64(x)/log(10.0d);
1196 }
1197
1198 static inline uniform double futrts_log1p_64(uniform double x) {
1199 if(x == -1.0d || (futrts_isinf64(x) && x > 0.0d)) return x / 0.0d;
1200 uniform double y = 1.0d + x;
1201 uniform double z = y - 1.0d;
1202 return log(y) - (z-x)/y;
1203 }
1204
1205 static inline uniform double futrts_sqrt64(uniform double x) {
1206 return sqrt(x);
1207 }
1208
1209 static inline uniform double futrts_cbrt64(uniform double x) {
1210 return cbrt(x);
1211 }
1212
1213 static inline uniform double futrts_exp64(uniform double x) {
1214 return exp(x);
1215 }
1216
1217 static inline uniform double futrts_cos64(uniform double x) {
1218 return cos(x);
1219 }
1220
1221 static inline uniform double futrts_sin64(uniform double x) {
1222 return sin(x);
1223 }
1224
1225 static inline uniform double futrts_tan64(uniform double x) {
1226 return tan(x);
1227 }
1228
1229 static inline uniform double futrts_acos64(uniform double x) {
1230 return acos(x);
1231 }
1232
1233 static inline uniform double futrts_asin64(uniform double x) {
1234 return asin(x);
1235 }
1236
1237 static inline uniform double futrts_atan64(uniform double x) {
1238 return atan(x);
1239 }
1240
1241 static inline uniform double futrts_cosh64(uniform double x) {
1242 return (exp(x)+exp(-x)) / 2.0d;
1243 }
1244
1245 static inline uniform double futrts_sinh64(uniform double x) {
1246 return (exp(x)-exp(-x)) / 2.0d;
1247 }
1248
1249 static inline uniform double futrts_tanh64(uniform double x) {
1250 return futrts_sinh64(x)/futrts_cosh64(x);
1251 }
1252
1253 static inline uniform double futrts_acosh64(uniform double x) {
1254 uniform double f = x+sqrt(x*x-1.0d);
1255 if(futrts_isfinite64(f)) return log(f);
1256 return f;
1257 }
1258
1259 static inline uniform double futrts_asinh64(uniform double x) {
1260 uniform double f = x+sqrt(x*x+1.0d);
1261 if(futrts_isfinite64(f)) return log(f);
1262 return f;
1263 }
1264
1265 static inline uniform double futrts_atanh64(uniform double x) {
1266 uniform double f = (1.0d+x)/(1.0d-x);
1267 if(futrts_isfinite64(f)) return log(f)/2.0d;
1268 return f;
1269
1270 }
1271
1272 static inline uniform double futrts_atan2_64(uniform double x, uniform double y) {
1273 return atan2(x, y);
1274 }
1275
1276 extern "C" unmasked uniform double hypot(uniform double x, uniform double y);
1277 static inline uniform double futrts_hypot64(uniform double x, uniform double y) {
1278 return hypot(x, y);
1279 }
1280
1281 extern "C" unmasked uniform double tgamma(uniform double x);
1282 static inline uniform double futrts_gamma64(uniform double x) {
1283 return tgamma(x);
1284 }
1285
1286 extern "C" unmasked uniform double lgamma(uniform double x);
1287 static inline uniform double futrts_lgamma64(uniform double x) {
1288 return lgamma(x);
1289 }
1290
1291 extern "C" unmasked uniform double erf(uniform double);
1292 static inline uniform double futrts_erf64(uniform double x) {
1293 return erf(x);
1294 }
1295
1296 extern "C" unmasked uniform double erfc(uniform double);
1297 static inline uniform double futrts_erfc64(uniform double x) {
1298 return erfc(x);
1299 }
1300
1301 static inline uniform double futrts_fma64(uniform double a, uniform double b, uniform double c) {
1302 return a * b + c;
1303 }
1304
1305 static inline uniform double futrts_round64(uniform double x) {
1306 return round(x);
1307 }
1308
1309 static inline uniform double futrts_ceil64(uniform double x) {
1310 return ceil(x);
1311 }
1312
1313 static inline uniform double futrts_floor64(uniform double x) {
1314 return floor(x);
1315 }
1316
1317 static inline uniform bool futrts_isnan64(uniform double x) {
1318 return isnan(x);
1319 }
1320
1321 static inline uniform int8_t fptosi_f64_i8(uniform double x) {
1322 if (futrts_isnan64(x) || futrts_isinf64(x)) {
1323 return 0;
1324 } else {
1325 return (uniform int8_t) x;
1326 }
1327 }
1328
1329 static inline uniform int16_t fptosi_f64_i16(uniform double x) {
1330 if (futrts_isnan64(x) || futrts_isinf64(x)) {
1331 return 0;
1332 } else {
1333 return (uniform int16_t) x;
1334 }
1335 }
1336
1337 static inline uniform int32_t fptosi_f64_i32(uniform double x) {
1338 if (futrts_isnan64(x) || futrts_isinf64(x)) {
1339 return 0;
1340 } else {
1341 return (uniform int32_t) x;
1342 }
1343 }
1344
1345 static inline uniform int64_t fptosi_f64_i64(uniform double x) {
1346 if (futrts_isnan64(x) || futrts_isinf64(x)) {
1347 return 0;
1348 } else {
1349 return (uniform int64_t) x;
1350 }
1351 }
1352
1353 static inline uniform uint8_t fptoui_f64_i8(uniform double x) {
1354 if (futrts_isnan64(x) || futrts_isinf64(x)) {
1355 return 0;
1356 } else {
1357 return (uniform uint8_t) (uniform int8_t) x;
1358 }
1359 }
1360
1361 static inline uniform uint16_t fptoui_f64_i16(uniform double x) {
1362 if (futrts_isnan64(x) || futrts_isinf64(x)) {
1363 return 0;
1364 } else {
1365 return (uniform uint16_t) (uniform int16_t) x;
1366 }
1367 }
1368
1369 static inline uniform uint32_t fptoui_f64_i32(uniform double x) {
1370 if (futrts_isnan64(x) || futrts_isinf64(x)) {
1371 return 0;
1372 } else {
1373 return (uniform uint32_t) (uniform int32_t) x;
1374 }
1375 }
1376
1377 static inline uniform uint64_t fptoui_f64_i64(uniform double x) {
1378 if (futrts_isnan64(x) || futrts_isinf64(x)) {
1379 return 0;
1380 } else {
1381 return (uniform uint64_t) (uniform int64_t) x;
1382 }
1383 }
1384
1385 static inline uniform bool ftob_f64_bool(uniform double x) {
1386 return x != 0.0;
1387 }
1388
1389 static inline uniform double btof_bool_f64(uniform bool x) {
1390 return x ? 1.0 : 0.0;
1391 }
1392
1393 static inline uniform bool ftob_f32_bool(uniform float x) {
1394 return x != 0;
1395 }
1396
1397 static inline uniform float btof_bool_f32(uniform bool x) {
1398 return x ? 1 : 0;
1399 }
1400
1401 static inline uniform int64_t futrts_to_bits64(uniform double x) {
1402 return *((uniform int64_t* uniform)&x);
1403 }
1404
1405 static inline uniform double futrts_from_bits64(uniform int64_t x) {
1406 return *((uniform double* uniform)&x);
1407 }
1408
1409 static inline uniform double fmod64(uniform double x, uniform double y) {
1410 return x - y * trunc(x/y);
1411 }
1412
1413 static inline uniform double fsignum64(uniform double x) {
1414 return futrts_isnan64(x) ? x : (x > 0 ? 1.0d : 0.0d) - (x < 0 ? 1.0d : 0.0d);
1415 }
1416
1417 static inline uniform double futrts_lerp64(uniform double v0, uniform double v1, uniform double t) {
1418 return v0 + (v1 - v0) * t;
1419 }
1420
1421 static inline uniform double futrts_mad64(uniform double a, uniform double b, uniform double c) {
1422 return a * b + c;
1423 }
1424
1425 static inline uniform float fpconv_f32_f32(uniform float x) {
1426 return (uniform float) x;
1427 }
1428
1429 static inline uniform double fpconv_f32_f64(uniform float x) {
1430 return (uniform double) x;
1431 }
1432
1433 static inline uniform float fpconv_f64_f32(uniform double x) {
1434 return (uniform float) x;
1435 }
1436
1437 static inline uniform double fpconv_f64_f64(uniform double x) {
1438 return (uniform double) x;
1439 }
1440
1441 static inline uniform double fpconv_f16_f64(uniform f16 x) {
1442 return (uniform double) x;
1443 }
1444
1445 static inline uniform f16 fpconv_f64_f16(uniform double x) {
1446 return (uniform f16) ((uniform float)x);
1447 }
1448
1449 #endif
1450
1451
1452 static inline uniform f16 fadd16(uniform f16 x, uniform f16 y) {
1453 return x + y;
1454 }
1455
1456 static inline uniform f16 fsub16(uniform f16 x, uniform f16 y) {
1457 return x - y;
1458 }
1459
1460 static inline uniform f16 fmul16(uniform f16 x, uniform f16 y) {
1461 return x * y;
1462 }
1463
1464 static inline uniform bool cmplt16(uniform f16 x, uniform f16 y) {
1465 return x < y;
1466 }
1467
1468 static inline uniform bool cmple16(uniform f16 x, uniform f16 y) {
1469 return x <= y;
1470 }
1471
1472 static inline uniform f16 sitofp_i8_f16(uniform int8_t x) {
1473 return (uniform f16) x;
1474 }
1475
1476 static inline uniform f16 sitofp_i16_f16(uniform int16_t x) {
1477 return (uniform f16) x;
1478 }
1479
1480 static inline uniform f16 sitofp_i32_f16(uniform int32_t x) {
1481 return (uniform f16) x;
1482 }
1483
1484 static inline uniform f16 sitofp_i64_f16(uniform int64_t x) {
1485 return (uniform f16) x;
1486 }
1487
1488 static inline uniform f16 uitofp_i8_f16(uniform uint8_t x) {
1489 return (uniform f16) x;
1490 }
1491
1492 static inline uniform f16 uitofp_i16_f16(uniform uint16_t x) {
1493 return (uniform f16) x;
1494 }
1495
1496 static inline uniform f16 uitofp_i32_f16(uniform uint32_t x) {
1497 return (uniform f16) x;
1498 }
1499
1500 static inline uniform f16 uitofp_i64_f16(uniform uint64_t x) {
1501 return (uniform f16) x;
1502 }
1503
1504 static inline uniform int8_t fptosi_f16_i8(uniform f16 x) {
1505 return (uniform int8_t) (uniform float) x;
1506 }
1507
1508 static inline uniform int16_t fptosi_f16_i16(uniform f16 x) {
1509 return (uniform int16_t) x;
1510 }
1511
1512 static inline uniform int32_t fptosi_f16_i32(uniform f16 x) {
1513 return (uniform int32_t) x;
1514 }
1515
1516 static inline uniform int64_t fptosi_f16_i64(uniform f16 x) {
1517 return (uniform int64_t) x;
1518 }
1519
1520 static inline uniform uint8_t fptoui_f16_i8(uniform f16 x) {
1521 return (uniform uint8_t) (uniform float) x;
1522 }
1523
1524 static inline uniform uint16_t fptoui_f16_i16(uniform f16 x) {
1525 return (uniform uint16_t) x;
1526 }
1527
1528 static inline uniform uint32_t fptoui_f16_i32(uniform f16 x) {
1529 return (uniform uint32_t) x;
1530 }
1531
1532 static inline uniform uint64_t fptoui_f16_i64(uniform f16 x) {
1533 return (uniform uint64_t) x;
1534 }
1535
1536 static inline uniform f16 fabs16(uniform f16 x) {
1537 return abs(x);
1538 }
1539
1540 static inline uniform bool futrts_isnan16(uniform f16 x) {
1541 return isnan((uniform float)x);
1542 }
1543
1544 static inline uniform f16 fmax16(uniform f16 x, uniform f16 y) {
1545 return futrts_isnan16(x) ? y : futrts_isnan16(y) ? x : max(x, y);
1546 }
1547
1548 static inline uniform f16 fmin16(uniform f16 x, uniform f16 y) {
1549 return min(x, y);
1550 }
1551
1552 static inline uniform f16 fpow16(uniform f16 x, uniform f16 y) {
1553 return pow(x, y);
1554 }
1555
1556 static inline uniform bool futrts_isinf16(uniform float x) {
1557 return !futrts_isnan16(x) && futrts_isnan16(x - x);
1558 }
1559 static inline uniform bool futrts_isfinite16(uniform float x) {
1560 return !futrts_isnan16(x) && !futrts_isinf16(x);
1561 }
1562
1563
1564 static inline uniform f16 futrts_log16(uniform f16 x) {
1565 return futrts_isfinite16(x) || (futrts_isinf16(x) && x < 0)? log(x) : x;
1566 }
1567
1568 static inline uniform f16 futrts_log2_16(uniform f16 x) {
1569 return futrts_log16(x) / log(2.0f16);
1570 }
1571
1572 static inline uniform f16 futrts_log10_16(uniform f16 x) {
1573 return futrts_log16(x) / log(10.0f16);
1574 }
1575
1576 static inline uniform f16 futrts_log1p_16(uniform f16 x) {
1577 if(x == -1.0f16 || (futrts_isinf16(x) && x > 0.0f16)) return x / 0.0f16;
1578 uniform f16 y = 1.0f16 + x;
1579 uniform f16 z = y - 1.0f16;
1580 return log(y) - (z-x)/y;
1581 }
1582
1583 static inline uniform f16 futrts_sqrt16(uniform f16 x) {
1584 return (uniform f16)sqrt((uniform float)x);
1585 }
1586
1587 extern "C" unmasked uniform float cbrtf(uniform float);
1588 static inline uniform f16 futrts_cbrt16(uniform f16 x) {
1589 return (uniform f16)cbrtf((uniform float)x);
1590 }
1591
1592 static inline uniform f16 futrts_exp16(uniform f16 x) {
1593 return exp(x);
1594 }
1595
1596 static inline uniform f16 futrts_cos16(uniform f16 x) {
1597 return (uniform f16)cos((uniform float)x);
1598 }
1599
1600 static inline uniform f16 futrts_sin16(uniform f16 x) {
1601 return (uniform f16)sin((uniform float)x);
1602 }
1603
1604 static inline uniform f16 futrts_tan16(uniform f16 x) {
1605 return (uniform f16)tan((uniform float)x);
1606 }
1607
1608 static inline uniform f16 futrts_acos16(uniform f16 x) {
1609 return (uniform f16)acos((uniform float)x);
1610 }
1611
1612 static inline uniform f16 futrts_asin16(uniform f16 x) {
1613 return (uniform f16)asin((uniform float)x);
1614 }
1615
1616 static inline uniform f16 futrts_atan16(uniform f16 x) {
1617 return (uniform f16)atan((uniform float)x);
1618 }
1619
1620 static inline uniform f16 futrts_cosh16(uniform f16 x) {
1621 return (exp(x)+exp(-x)) / 2.0f16;
1622 }
1623
1624 static inline uniform f16 futrts_sinh16(uniform f16 x) {
1625 return (exp(x)-exp(-x)) / 2.0f16;
1626 }
1627
1628 static inline uniform f16 futrts_tanh16(uniform f16 x) {
1629 return futrts_sinh16(x)/futrts_cosh16(x);
1630 }
1631
1632 static inline uniform f16 futrts_acosh16(uniform f16 x) {
1633 uniform f16 f = x+(uniform f16)sqrt((uniform float)(x*x-1));
1634 if(futrts_isfinite16(f)) return log(f);
1635 return f;
1636 }
1637
1638 static inline uniform f16 futrts_asinh16(uniform f16 x) {
1639 uniform f16 f = x+(uniform f16)sqrt((uniform float)(x*x+1));
1640 if(futrts_isfinite16(f)) return log(f);
1641 return f;
1642 }
1643
1644 static inline uniform f16 futrts_atanh16(uniform f16 x) {
1645 uniform f16 f = (1+x)/(1-x);
1646 if(futrts_isfinite16(f)) return log(f)/2.0f16;
1647 return f;
1648 }
1649
1650 static inline uniform f16 futrts_atan2_16(uniform f16 x, uniform f16 y) {
1651 return (uniform f16)atan2((uniform float)x, (uniform float)y);
1652 }
1653
1654 static inline uniform f16 futrts_hypot16(uniform f16 x, uniform f16 y) {
1655 return (uniform f16)futrts_hypot32((uniform float)x, (uniform float)y);
1656 }
1657
1658 extern "C" unmasked uniform float tgammaf(uniform float x);
1659 static inline uniform f16 futrts_gamma16(uniform f16 x) {
1660 return (uniform f16)tgammaf((uniform float)x);
1661 }
1662
1663 extern "C" unmasked uniform float lgammaf(uniform float x);
1664 static inline uniform f16 futrts_lgamma16(uniform f16 x) {
1665 return (uniform f16)lgammaf((uniform float)x);
1666 }
1667
1668 extern "C" unmasked uniform float erff(uniform float);
1669 static inline uniform f16 futrts_erf32(uniform f16 x) {
1670 return (uniform f16)erff((uniform float)x);
1671 }
1672
1673 extern "C" unmasked uniform float erfcf(uniform float);
1674 static inline uniform f16 futrts_erfc32(uniform f16 x) {
1675 return (uniform f16)erfcf((uniform float)x);
1676 }
1677
1678 static inline uniform f16 fmod16(uniform f16 x, uniform f16 y) {
1679 return x - y * (uniform f16)trunc((uniform float) (x/y));
1680 }
1681
1682 static inline uniform f16 futrts_round16(uniform f16 x) {
1683 return (uniform f16)round((uniform float)x);
1684 }
1685
1686 static inline uniform f16 futrts_floor16(uniform f16 x) {
1687 return (uniform f16)floor((uniform float)x);
1688 }
1689
1690 static inline uniform f16 futrts_ceil16(uniform f16 x) {
1691 return (uniform f16)ceil((uniform float)x);
1692 }
1693
1694 static inline uniform f16 futrts_lerp16(uniform f16 v0, uniform f16 v1, uniform f16 t) {
1695 return v0 + (v1 - v0) * t;
1696 }
1697
1698 static inline uniform f16 futrts_mad16(uniform f16 a, uniform f16 b, uniform f16 c) {
1699 return a * b + c;
1700 }
1701
1702 static inline uniform f16 futrts_fma16(uniform f16 a, uniform f16 b, uniform f16 c) {
1703 return a * b + c;
1704 }
1705
1706 static inline uniform int16_t fptobits_f16_i16(uniform f16 x) {
1707 return *((uniform int16_t *)&x);
1708 }
1709
1710 static inline uniform f16 bitstofp_i16_f16(uniform int16_t x) {
1711 return *((uniform f16 *)&x);
1712 }
1713
1714 static inline uniform float fpconv_f16_f16(uniform f16 x) {
1715 return x;
1716 }
1717
1718 static inline uniform float fpconv_f16_f32(uniform f16 x) {
1719 return x;
1720 }
1721
1722 static inline uniform f16 fpconv_f32_f16(uniform float x) {
1723 return (uniform f16) x;
1724 }
1725 #endif
1726
1727 // End of uniform.h.