Gitiles
Code Review Sign In
gerrit-public.fairphone.software / platform / frameworks / rs / be2163801c33d6849ae580d42b919b8803d55095 / . / scriptc / rs_math.rsh
blob: b812f0712622e92fed767c7693225132082a2149 [file] [log] [blame]
Jason Sams044e2ee2011-08-08 16:52:30 -0700[diff] [blame]1/*
Jean-Luc Brouilletc5184e22015-03-13 13:51:24 -0700[diff] [blame]2 * Copyright (C) 2015 The Android Open Source Project
Jason Sams044e2ee2011-08-08 16:52:30 -0700[diff] [blame]3 *
4 * Licensed under the Apache License, Version 2.0 (the "License");
5 * you may not use this file except in compliance with the License.
6 * You may obtain a copy of the License at
7 *
8 * http://www.apache.org/licenses/LICENSE-2.0
9 *
10 * Unless required by applicable law or agreed to in writing, software
11 * distributed under the License is distributed on an "AS IS" BASIS,
12 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
13 * See the License for the specific language governing permissions and
14 * limitations under the License.
15 */
16
Jean-Luc Brouilletc5184e22015-03-13 13:51:24 -0700[diff] [blame]17// Don't edit this file! It is auto-generated by frameworks/rs/api/gen_runtime.
18
19/*
Jean-Luc Brouilletbe216382015-03-22 12:44:27 -0700[diff] [blame^]20 * rs_math.rsh: Mathematical functions
Jason Sams9df3b2b2011-08-08 14:31:25 -0700[diff] [blame]21 *
Jean-Luc Brouilletbe216382015-03-22 12:44:27 -0700[diff] [blame^]22 * Most mathematical functions can be applied to scalars and vectors.
23 * When applied to vectors, a vector of the function applied to each entry
24 * of the input is returned.
25 *
26 * For example:
27 *
28 * float3 a, b;
29 * // The following call sets
30 * // a.x to sin(b.x),
31 * // a.y to sin(b.y), and
32 * // a.z to sin(b.z).
33 * a = sin(b);
34 *
35 *
36 * A few functions like distance() and length() interpret instead the input
37 * as a single vector in n-dimensional space.
38 *
39 * The precision of the mathematical operations is affected by the pragmas
40 * rs_fp_relaxed and rs_fp_full.
41 *
42 * Different precision/speed tradeoffs can be achieved by using three variants
43 * of common math functions. Functions with a name starting with
44 * native_ may have custom hardware implementations with weaker precision,
45 * half_ may perform internal computations using 16 bit floats, and
46 * fast_ are n-dimensional space computations that may use 16 bit floats.
47 *
Jean-Luc Brouilletc5184e22015-03-13 13:51:24 -0700[diff] [blame]48 */
49#ifndef RENDERSCRIPT_RS_MATH_RSH
50#define RENDERSCRIPT_RS_MATH_RSH
51
52/*
Jean-Luc Brouilletbe216382015-03-22 12:44:27 -0700[diff] [blame^]53 * M_1_PI: 1 / pi, as a 32 bit float
54 *
55 * The inverse of pi, as a 32 bit float.
56 */
57#define M_1_PI 0.318309886183790671537767526745028724f
58
59/*
60 * M_2_PI: 2 / pi, as a 32 bit float
61 *
62 * 2 divided by pi, as a 32 bit float.
63 */
64#define M_2_PI 0.636619772367581343075535053490057448f
65
66/*
67 * M_2_PIl: Deprecated. Use M_2_PI instead.
68 *
69 */
70#define M_2_PIl 0.636619772367581343075535053490057448f
71
72/*
73 * M_2_SQRTPI: 2 / sqrt(pi), as a 32 bit float
74 *
75 * 2 divided by the square root of pi, as a 32 bit float.
76 */
77#define M_2_SQRTPI 1.128379167095512573896158903121545172f
78
79/*
80 * M_E: e, as a 32 bit float
81 *
82 * The number e, the base of the natural logarithm, as a 32 bit float.
83 */
84#define M_E 2.718281828459045235360287471352662498f
85
86/*
87 * M_LN10: log_e(10), as a 32 bit float
88 *
89 * The natural logarithm of 10, as a 32 bit float.
90 */
91#define M_LN10 2.302585092994045684017991454684364208f
92
93/*
94 * M_LN2: log_e(2), as a 32 bit float
95 *
96 * The natural logarithm of 2, as a 32 bit float.
97 */
98#define M_LN2 0.693147180559945309417232121458176568f
99
100/*
101 * M_LOG10E: log_10(e), as a 32 bit float
102 *
103 * The logarithm base 10 of e, as a 32 bit float.
104 */
105#define M_LOG10E 0.434294481903251827651128918916605082f
106
107/*
108 * M_LOG2E: log_2(e), as a 32 bit float
109 *
110 * The logarithm base 2 of e, as a 32 bit float.
111 */
112#define M_LOG2E 1.442695040888963407359924681001892137f
113
114/*
115 * M_PI: pi, as a 32 bit float
116 *
117 * The constant pi, as a 32 bit float.
118 */
119#define M_PI 3.141592653589793238462643383279502884f
120
121/*
122 * M_PI_2: pi / 2, as a 32 bit float
123 *
124 * Pi divided by 2, as a 32 bit float.
125 */
126#define M_PI_2 1.570796326794896619231321691639751442f
127
128/*
129 * M_PI_4: pi / 4, as a 32 bit float
130 *
131 * Pi divided by 4, as a 32 bit float.
132 */
133#define M_PI_4 0.785398163397448309615660845819875721f
134
135/*
136 * M_SQRT1_2: 1 / sqrt(2), as a 32 bit float
137 *
138 * The inverse of the square root of 2, as a 32 bit float.
139 */
140#define M_SQRT1_2 0.707106781186547524400844362104849039f
141
142/*
143 * M_SQRT2: sqrt(2), as a 32 bit float
144 *
145 * The square root of 2, as a 32 bit float.
146 */
147#define M_SQRT2 1.414213562373095048801688724209698079f
148
149/*
150 * abs: Absolute value of an integer
151 *
152 * Returns the absolute value of an integer.
153 *
154 * For floats, use fabs().
155 */
156extern uchar __attribute__((const, overloadable))
157 abs(char v);
158
159extern uchar2 __attribute__((const, overloadable))
160 abs(char2 v);
161
162extern uchar3 __attribute__((const, overloadable))
163 abs(char3 v);
164
165extern uchar4 __attribute__((const, overloadable))
166 abs(char4 v);
167
168extern ushort __attribute__((const, overloadable))
169 abs(short v);
170
171extern ushort2 __attribute__((const, overloadable))
172 abs(short2 v);
173
174extern ushort3 __attribute__((const, overloadable))
175 abs(short3 v);
176
177extern ushort4 __attribute__((const, overloadable))
178 abs(short4 v);
179
180extern uint __attribute__((const, overloadable))
181 abs(int v);
182
183extern uint2 __attribute__((const, overloadable))
184 abs(int2 v);
185
186extern uint3 __attribute__((const, overloadable))
187 abs(int3 v);
188
189extern uint4 __attribute__((const, overloadable))
190 abs(int4 v);
191
192/*
193 * acos: Inverse cosine
194 *
195 * Returns the inverse cosine, in radians.
196 *
197 * See also native_acos().
198 */
199extern float __attribute__((const, overloadable))
200 acos(float v);
201
202extern float2 __attribute__((const, overloadable))
203 acos(float2 v);
204
205extern float3 __attribute__((const, overloadable))
206 acos(float3 v);
207
208extern float4 __attribute__((const, overloadable))
209 acos(float4 v);
210
211/*
212 * acosh: Inverse hyperbolic cosine
213 *
214 * Returns the inverse hyperbolic cosine, in radians.
215 *
216 * See also native_acosh().
217 */
218extern float __attribute__((const, overloadable))
219 acosh(float v);
220
221extern float2 __attribute__((const, overloadable))
222 acosh(float2 v);
223
224extern float3 __attribute__((const, overloadable))
225 acosh(float3 v);
226
227extern float4 __attribute__((const, overloadable))
228 acosh(float4 v);
229
230/*
231 * acospi: Inverse cosine divided by pi
232 *
233 * Returns the inverse cosine in radians, divided by pi.
234 *
235 * To get an inverse cosine measured in degrees, use acospi(a) * 180.f.
236 *
237 * See also native_acospi().
238 */
239extern float __attribute__((const, overloadable))
240 acospi(float v);
241
242extern float2 __attribute__((const, overloadable))
243 acospi(float2 v);
244
245extern float3 __attribute__((const, overloadable))
246 acospi(float3 v);
247
248extern float4 __attribute__((const, overloadable))
249 acospi(float4 v);
250
251/*
252 * asin: Inverse sine
253 *
254 * Returns the inverse sine, in radians.
255 *
256 * See also native_asin().
257 */
258extern float __attribute__((const, overloadable))
259 asin(float v);
260
261extern float2 __attribute__((const, overloadable))
262 asin(float2 v);
263
264extern float3 __attribute__((const, overloadable))
265 asin(float3 v);
266
267extern float4 __attribute__((const, overloadable))
268 asin(float4 v);
269
270/*
271 * asinh: Inverse hyperbolic sine
272 *
273 * Returns the inverse hyperbolic sine, in radians.
274 *
275 * See also native_asinh().
276 */
277extern float __attribute__((const, overloadable))
278 asinh(float v);
279
280extern float2 __attribute__((const, overloadable))
281 asinh(float2 v);
282
283extern float3 __attribute__((const, overloadable))
284 asinh(float3 v);
285
286extern float4 __attribute__((const, overloadable))
287 asinh(float4 v);
288
289/*
290 * asinpi: Inverse sine divided by pi
291 *
292 * Returns the inverse sine in radians, divided by pi.
293 *
294 * To get an inverse sine measured in degrees, use asinpi(a) * 180.f.
295 *
296 * See also native_asinpi().
297 */
298extern float __attribute__((const, overloadable))
299 asinpi(float v);
300
301extern float2 __attribute__((const, overloadable))
302 asinpi(float2 v);
303
304extern float3 __attribute__((const, overloadable))
305 asinpi(float3 v);
306
307extern float4 __attribute__((const, overloadable))
308 asinpi(float4 v);
309
310/*
311 * atan: Inverse tangent
312 *
313 * Returns the inverse tangent, in radians.
314 *
315 * See also native_atan().
316 */
317extern float __attribute__((const, overloadable))
318 atan(float v);
319
320extern float2 __attribute__((const, overloadable))
321 atan(float2 v);
322
323extern float3 __attribute__((const, overloadable))
324 atan(float3 v);
325
326extern float4 __attribute__((const, overloadable))
327 atan(float4 v);
328
329/*
330 * atan2: Inverse tangent of a ratio
331 *
332 * Returns the inverse tangent of (numerator / denominator), in radians.
333 *
334 * See also native_atan2().
335 *
336 * Parameters:
337 * numerator The numerator
338 * denominator The denominator. Can be 0.
339 */
340extern float __attribute__((const, overloadable))
341 atan2(float numerator, float denominator);
342
343extern float2 __attribute__((const, overloadable))
344 atan2(float2 numerator, float2 denominator);
345
346extern float3 __attribute__((const, overloadable))
347 atan2(float3 numerator, float3 denominator);
348
349extern float4 __attribute__((const, overloadable))
350 atan2(float4 numerator, float4 denominator);
351
352/*
353 * atan2pi: Inverse tangent of a ratio, divided by pi
354 *
355 * Returns the inverse tangent of (numerator / denominator), in radians, divided by pi.
356 *
357 * To get an inverse tangent measured in degrees, use atan2pi(n, d) * 180.f.
358 *
359 * See also native_atan2pi().
360 *
361 * Parameters:
362 * numerator The numerator
363 * denominator The denominator. Can be 0.
364 */
365extern float __attribute__((const, overloadable))
366 atan2pi(float numerator, float denominator);
367
368extern float2 __attribute__((const, overloadable))
369 atan2pi(float2 numerator, float2 denominator);
370
371extern float3 __attribute__((const, overloadable))
372 atan2pi(float3 numerator, float3 denominator);
373
374extern float4 __attribute__((const, overloadable))
375 atan2pi(float4 numerator, float4 denominator);
376
377/*
378 * atanh: Inverse hyperbolic tangent
379 *
380 * Returns the inverse hyperbolic tangent, in radians.
381 *
382 * See also native_atanh().
383 */
384extern float __attribute__((const, overloadable))
385 atanh(float v);
386
387extern float2 __attribute__((const, overloadable))
388 atanh(float2 v);
389
390extern float3 __attribute__((const, overloadable))
391 atanh(float3 v);
392
393extern float4 __attribute__((const, overloadable))
394 atanh(float4 v);
395
396/*
397 * atanpi: Inverse tangent divided by pi
398 *
399 * Returns the inverse tangent in radians, divided by pi.
400 *
401 * To get an inverse tangent measured in degrees, use atanpi(a) * 180.f.
402 *
403 * See also native_atanpi().
404 */
405extern float __attribute__((const, overloadable))
406 atanpi(float v);
407
408extern float2 __attribute__((const, overloadable))
409 atanpi(float2 v);
410
411extern float3 __attribute__((const, overloadable))
412 atanpi(float3 v);
413
414extern float4 __attribute__((const, overloadable))
415 atanpi(float4 v);
416
417/*
418 * cbrt: Cube root
419 *
420 * Returns the cube root.
421 *
422 * See also native_cbrt().
423 */
424extern float __attribute__((const, overloadable))
425 cbrt(float v);
426
427extern float2 __attribute__((const, overloadable))
428 cbrt(float2 v);
429
430extern float3 __attribute__((const, overloadable))
431 cbrt(float3 v);
432
433extern float4 __attribute__((const, overloadable))
434 cbrt(float4 v);
435
436/*
437 * ceil: Smallest integer not less than a value
438 *
439 * Returns the smallest integer not less than a value.
440 *
441 * For example, ceil(1.2f) returns 2.f, and ceil(-1.2f) returns -1.f.
442 *
443 * See also floor().
444 */
445extern float __attribute__((const, overloadable))
446 ceil(float v);
447
448extern float2 __attribute__((const, overloadable))
449 ceil(float2 v);
450
451extern float3 __attribute__((const, overloadable))
452 ceil(float3 v);
453
454extern float4 __attribute__((const, overloadable))
455 ceil(float4 v);
456
457/*
458 * clamp: Restrain a value to a range
459 *
460 * Clamps a value to a specified high and low bound. clamp() returns min_value
461 * if value < min_value, max_value if value > max_value, otherwise value.
462 *
463 * There are two variants of clamp: one where the min and max are scalars applied
464 * to all entries of the value, the other where the min and max are also vectors.
465 *
466 * If min_value is greater than max_value, the results are undefined.
467 *
468 * Parameters:
469 * value Value to be clamped.
470 * min_value Lower bound, a scalar or matching vector.
471 * max_value High bound, must match the type of low.
472 */
473extern float __attribute__((const, overloadable))
474 clamp(float value, float min_value, float max_value);
475
476extern float2 __attribute__((const, overloadable))
477 clamp(float2 value, float2 min_value, float2 max_value);
478
479extern float3 __attribute__((const, overloadable))
480 clamp(float3 value, float3 min_value, float3 max_value);
481
482extern float4 __attribute__((const, overloadable))
483 clamp(float4 value, float4 min_value, float4 max_value);
484
485extern float2 __attribute__((const, overloadable))
486 clamp(float2 value, float min_value, float max_value);
487
488extern float3 __attribute__((const, overloadable))
489 clamp(float3 value, float min_value, float max_value);
490
491extern float4 __attribute__((const, overloadable))
492 clamp(float4 value, float min_value, float max_value);
493
494#if (defined(RS_VERSION) && (RS_VERSION >= 19))
495extern char __attribute__((const, overloadable))
496 clamp(char value, char min_value, char max_value);
497#endif
498
499#if (defined(RS_VERSION) && (RS_VERSION >= 19))
500extern char2 __attribute__((const, overloadable))
501 clamp(char2 value, char2 min_value, char2 max_value);
502#endif
503
504#if (defined(RS_VERSION) && (RS_VERSION >= 19))
505extern char3 __attribute__((const, overloadable))
506 clamp(char3 value, char3 min_value, char3 max_value);
507#endif
508
509#if (defined(RS_VERSION) && (RS_VERSION >= 19))
510extern char4 __attribute__((const, overloadable))
511 clamp(char4 value, char4 min_value, char4 max_value);
512#endif
513
514#if (defined(RS_VERSION) && (RS_VERSION >= 19))
515extern uchar __attribute__((const, overloadable))
516 clamp(uchar value, uchar min_value, uchar max_value);
517#endif
518
519#if (defined(RS_VERSION) && (RS_VERSION >= 19))
520extern uchar2 __attribute__((const, overloadable))
521 clamp(uchar2 value, uchar2 min_value, uchar2 max_value);
522#endif
523
524#if (defined(RS_VERSION) && (RS_VERSION >= 19))
525extern uchar3 __attribute__((const, overloadable))
526 clamp(uchar3 value, uchar3 min_value, uchar3 max_value);
527#endif
528
529#if (defined(RS_VERSION) && (RS_VERSION >= 19))
530extern uchar4 __attribute__((const, overloadable))
531 clamp(uchar4 value, uchar4 min_value, uchar4 max_value);
532#endif
533
534#if (defined(RS_VERSION) && (RS_VERSION >= 19))
535extern short __attribute__((const, overloadable))
536 clamp(short value, short min_value, short max_value);
537#endif
538
539#if (defined(RS_VERSION) && (RS_VERSION >= 19))
540extern short2 __attribute__((const, overloadable))
541 clamp(short2 value, short2 min_value, short2 max_value);
542#endif
543
544#if (defined(RS_VERSION) && (RS_VERSION >= 19))
545extern short3 __attribute__((const, overloadable))
546 clamp(short3 value, short3 min_value, short3 max_value);
547#endif
548
549#if (defined(RS_VERSION) && (RS_VERSION >= 19))
550extern short4 __attribute__((const, overloadable))
551 clamp(short4 value, short4 min_value, short4 max_value);
552#endif
553
554#if (defined(RS_VERSION) && (RS_VERSION >= 19))
555extern ushort __attribute__((const, overloadable))
556 clamp(ushort value, ushort min_value, ushort max_value);
557#endif
558
559#if (defined(RS_VERSION) && (RS_VERSION >= 19))
560extern ushort2 __attribute__((const, overloadable))
561 clamp(ushort2 value, ushort2 min_value, ushort2 max_value);
562#endif
563
564#if (defined(RS_VERSION) && (RS_VERSION >= 19))
565extern ushort3 __attribute__((const, overloadable))
566 clamp(ushort3 value, ushort3 min_value, ushort3 max_value);
567#endif
568
569#if (defined(RS_VERSION) && (RS_VERSION >= 19))
570extern ushort4 __attribute__((const, overloadable))
571 clamp(ushort4 value, ushort4 min_value, ushort4 max_value);
572#endif
573
574#if (defined(RS_VERSION) && (RS_VERSION >= 19))
575extern int __attribute__((const, overloadable))
576 clamp(int value, int min_value, int max_value);
577#endif
578
579#if (defined(RS_VERSION) && (RS_VERSION >= 19))
580extern int2 __attribute__((const, overloadable))
581 clamp(int2 value, int2 min_value, int2 max_value);
582#endif
583
584#if (defined(RS_VERSION) && (RS_VERSION >= 19))
585extern int3 __attribute__((const, overloadable))
586 clamp(int3 value, int3 min_value, int3 max_value);
587#endif
588
589#if (defined(RS_VERSION) && (RS_VERSION >= 19))
590extern int4 __attribute__((const, overloadable))
591 clamp(int4 value, int4 min_value, int4 max_value);
592#endif
593
594#if (defined(RS_VERSION) && (RS_VERSION >= 19))
595extern uint __attribute__((const, overloadable))
596 clamp(uint value, uint min_value, uint max_value);
597#endif
598
599#if (defined(RS_VERSION) && (RS_VERSION >= 19))
600extern uint2 __attribute__((const, overloadable))
601 clamp(uint2 value, uint2 min_value, uint2 max_value);
602#endif
603
604#if (defined(RS_VERSION) && (RS_VERSION >= 19))
605extern uint3 __attribute__((const, overloadable))
606 clamp(uint3 value, uint3 min_value, uint3 max_value);
607#endif
608
609#if (defined(RS_VERSION) && (RS_VERSION >= 19))
610extern uint4 __attribute__((const, overloadable))
611 clamp(uint4 value, uint4 min_value, uint4 max_value);
612#endif
613
614#if (defined(RS_VERSION) && (RS_VERSION >= 19))
615extern long __attribute__((const, overloadable))
616 clamp(long value, long min_value, long max_value);
617#endif
618
619#if (defined(RS_VERSION) && (RS_VERSION >= 19))
620extern long2 __attribute__((const, overloadable))
621 clamp(long2 value, long2 min_value, long2 max_value);
622#endif
623
624#if (defined(RS_VERSION) && (RS_VERSION >= 19))
625extern long3 __attribute__((const, overloadable))
626 clamp(long3 value, long3 min_value, long3 max_value);
627#endif
628
629#if (defined(RS_VERSION) && (RS_VERSION >= 19))
630extern long4 __attribute__((const, overloadable))
631 clamp(long4 value, long4 min_value, long4 max_value);
632#endif
633
634#if (defined(RS_VERSION) && (RS_VERSION >= 19))
635extern ulong __attribute__((const, overloadable))
636 clamp(ulong value, ulong min_value, ulong max_value);
637#endif
638
639#if (defined(RS_VERSION) && (RS_VERSION >= 19))
640extern ulong2 __attribute__((const, overloadable))
641 clamp(ulong2 value, ulong2 min_value, ulong2 max_value);
642#endif
643
644#if (defined(RS_VERSION) && (RS_VERSION >= 19))
645extern ulong3 __attribute__((const, overloadable))
646 clamp(ulong3 value, ulong3 min_value, ulong3 max_value);
647#endif
648
649#if (defined(RS_VERSION) && (RS_VERSION >= 19))
650extern ulong4 __attribute__((const, overloadable))
651 clamp(ulong4 value, ulong4 min_value, ulong4 max_value);
652#endif
653
654#if (defined(RS_VERSION) && (RS_VERSION >= 19))
655extern char2 __attribute__((const, overloadable))
656 clamp(char2 value, char min_value, char max_value);
657#endif
658
659#if (defined(RS_VERSION) && (RS_VERSION >= 19))
660extern char3 __attribute__((const, overloadable))
661 clamp(char3 value, char min_value, char max_value);
662#endif
663
664#if (defined(RS_VERSION) && (RS_VERSION >= 19))
665extern char4 __attribute__((const, overloadable))
666 clamp(char4 value, char min_value, char max_value);
667#endif
668
669#if (defined(RS_VERSION) && (RS_VERSION >= 19))
670extern uchar2 __attribute__((const, overloadable))
671 clamp(uchar2 value, uchar min_value, uchar max_value);
672#endif
673
674#if (defined(RS_VERSION) && (RS_VERSION >= 19))
675extern uchar3 __attribute__((const, overloadable))
676 clamp(uchar3 value, uchar min_value, uchar max_value);
677#endif
678
679#if (defined(RS_VERSION) && (RS_VERSION >= 19))
680extern uchar4 __attribute__((const, overloadable))
681 clamp(uchar4 value, uchar min_value, uchar max_value);
682#endif
683
684#if (defined(RS_VERSION) && (RS_VERSION >= 19))
685extern short2 __attribute__((const, overloadable))
686 clamp(short2 value, short min_value, short max_value);
687#endif
688
689#if (defined(RS_VERSION) && (RS_VERSION >= 19))
690extern short3 __attribute__((const, overloadable))
691 clamp(short3 value, short min_value, short max_value);
692#endif
693
694#if (defined(RS_VERSION) && (RS_VERSION >= 19))
695extern short4 __attribute__((const, overloadable))
696 clamp(short4 value, short min_value, short max_value);
697#endif
698
699#if (defined(RS_VERSION) && (RS_VERSION >= 19))
700extern ushort2 __attribute__((const, overloadable))
701 clamp(ushort2 value, ushort min_value, ushort max_value);
702#endif
703
704#if (defined(RS_VERSION) && (RS_VERSION >= 19))
705extern ushort3 __attribute__((const, overloadable))
706 clamp(ushort3 value, ushort min_value, ushort max_value);
707#endif
708
709#if (defined(RS_VERSION) && (RS_VERSION >= 19))
710extern ushort4 __attribute__((const, overloadable))
711 clamp(ushort4 value, ushort min_value, ushort max_value);
712#endif
713
714#if (defined(RS_VERSION) && (RS_VERSION >= 19))
715extern int2 __attribute__((const, overloadable))
716 clamp(int2 value, int min_value, int max_value);
717#endif
718
719#if (defined(RS_VERSION) && (RS_VERSION >= 19))
720extern int3 __attribute__((const, overloadable))
721 clamp(int3 value, int min_value, int max_value);
722#endif
723
724#if (defined(RS_VERSION) && (RS_VERSION >= 19))
725extern int4 __attribute__((const, overloadable))
726 clamp(int4 value, int min_value, int max_value);
727#endif
728
729#if (defined(RS_VERSION) && (RS_VERSION >= 19))
730extern uint2 __attribute__((const, overloadable))
731 clamp(uint2 value, uint min_value, uint max_value);
732#endif
733
734#if (defined(RS_VERSION) && (RS_VERSION >= 19))
735extern uint3 __attribute__((const, overloadable))
736 clamp(uint3 value, uint min_value, uint max_value);
737#endif
738
739#if (defined(RS_VERSION) && (RS_VERSION >= 19))
740extern uint4 __attribute__((const, overloadable))
741 clamp(uint4 value, uint min_value, uint max_value);
742#endif
743
744#if (defined(RS_VERSION) && (RS_VERSION >= 19))
745extern long2 __attribute__((const, overloadable))
746 clamp(long2 value, long min_value, long max_value);
747#endif
748
749#if (defined(RS_VERSION) && (RS_VERSION >= 19))
750extern long3 __attribute__((const, overloadable))
751 clamp(long3 value, long min_value, long max_value);
752#endif
753
754#if (defined(RS_VERSION) && (RS_VERSION >= 19))
755extern long4 __attribute__((const, overloadable))
756 clamp(long4 value, long min_value, long max_value);
757#endif
758
759#if (defined(RS_VERSION) && (RS_VERSION >= 19))
760extern ulong2 __attribute__((const, overloadable))
761 clamp(ulong2 value, ulong min_value, ulong max_value);
762#endif
763
764#if (defined(RS_VERSION) && (RS_VERSION >= 19))
765extern ulong3 __attribute__((const, overloadable))
766 clamp(ulong3 value, ulong min_value, ulong max_value);
767#endif
768
769#if (defined(RS_VERSION) && (RS_VERSION >= 19))
770extern ulong4 __attribute__((const, overloadable))
771 clamp(ulong4 value, ulong min_value, ulong max_value);
772#endif
773
774/*
775 * clz: Number of leading 0 bits
776 *
777 * Returns the number of leading 0-bits in a value.
778 *
779 * For example, clz((char)0x03) returns 6.
780 */
781extern char __attribute__((const, overloadable))
782 clz(char value);
783
784extern char2 __attribute__((const, overloadable))
785 clz(char2 value);
786
787extern char3 __attribute__((const, overloadable))
788 clz(char3 value);
789
790extern char4 __attribute__((const, overloadable))
791 clz(char4 value);
792
793extern uchar __attribute__((const, overloadable))
794 clz(uchar value);
795
796extern uchar2 __attribute__((const, overloadable))
797 clz(uchar2 value);
798
799extern uchar3 __attribute__((const, overloadable))
800 clz(uchar3 value);
801
802extern uchar4 __attribute__((const, overloadable))
803 clz(uchar4 value);
804
805extern short __attribute__((const, overloadable))
806 clz(short value);
807
808extern short2 __attribute__((const, overloadable))
809 clz(short2 value);
810
811extern short3 __attribute__((const, overloadable))
812 clz(short3 value);
813
814extern short4 __attribute__((const, overloadable))
815 clz(short4 value);
816
817extern ushort __attribute__((const, overloadable))
818 clz(ushort value);
819
820extern ushort2 __attribute__((const, overloadable))
821 clz(ushort2 value);
822
823extern ushort3 __attribute__((const, overloadable))
824 clz(ushort3 value);
825
826extern ushort4 __attribute__((const, overloadable))
827 clz(ushort4 value);
828
829extern int __attribute__((const, overloadable))
830 clz(int value);
831
832extern int2 __attribute__((const, overloadable))
833 clz(int2 value);
834
835extern int3 __attribute__((const, overloadable))
836 clz(int3 value);
837
838extern int4 __attribute__((const, overloadable))
839 clz(int4 value);
840
841extern uint __attribute__((const, overloadable))
842 clz(uint value);
843
844extern uint2 __attribute__((const, overloadable))
845 clz(uint2 value);
846
847extern uint3 __attribute__((const, overloadable))
848 clz(uint3 value);
849
850extern uint4 __attribute__((const, overloadable))
851 clz(uint4 value);
852
853/*
854 * copysign: Copies the sign of a number to another
855 *
856 * Copies the sign from sign_value to magnitude_value.
857 *
858 * The value returned is either magnitude_value or -magnitude_value.
859 *
860 * For example, copysign(4.0f, -2.7f) returns -4.0f and copysign(-4.0f, 2.7f) returns 4.0f.
861 */
862extern float __attribute__((const, overloadable))
863 copysign(float magnitude_value, float sign_value);
864
865extern float2 __attribute__((const, overloadable))
866 copysign(float2 magnitude_value, float2 sign_value);
867
868extern float3 __attribute__((const, overloadable))
869 copysign(float3 magnitude_value, float3 sign_value);
870
871extern float4 __attribute__((const, overloadable))
872 copysign(float4 magnitude_value, float4 sign_value);
873
874/*
875 * cos: Cosine
876 *
877 * Returns the cosine of an angle measured in radians.
878 *
879 * See also native_cos().
880 */
881extern float __attribute__((const, overloadable))
882 cos(float v);
883
884extern float2 __attribute__((const, overloadable))
885 cos(float2 v);
886
887extern float3 __attribute__((const, overloadable))
888 cos(float3 v);
889
890extern float4 __attribute__((const, overloadable))
891 cos(float4 v);
892
893/*
894 * cosh: Hypebolic cosine
895 *
896 * Returns the hypebolic cosine of v, where v is measured in radians.
897 *
898 * See also native_cosh().
899 */
900extern float __attribute__((const, overloadable))
901 cosh(float v);
902
903extern float2 __attribute__((const, overloadable))
904 cosh(float2 v);
905
906extern float3 __attribute__((const, overloadable))
907 cosh(float3 v);
908
909extern float4 __attribute__((const, overloadable))
910 cosh(float4 v);
911
912/*
913 * cospi: Cosine of a number multiplied by pi
914 *
915 * Returns the cosine of (v * pi), where (v * pi) is measured in radians.
916 *
917 * To get the cosine of a value measured in degrees, call cospi(v / 180.f).
918 *
919 * See also native_cospi().
920 */
921extern float __attribute__((const, overloadable))
922 cospi(float v);
923
924extern float2 __attribute__((const, overloadable))
925 cospi(float2 v);
926
927extern float3 __attribute__((const, overloadable))
928 cospi(float3 v);
929
930extern float4 __attribute__((const, overloadable))
931 cospi(float4 v);
932
933/*
934 * degrees: Converts radians into degrees
935 *
936 * Converts from radians to degrees.
937 */
938extern float __attribute__((const, overloadable))
939 degrees(float v);
940
941extern float2 __attribute__((const, overloadable))
942 degrees(float2 v);
943
944extern float3 __attribute__((const, overloadable))
945 degrees(float3 v);
946
947extern float4 __attribute__((const, overloadable))
948 degrees(float4 v);
949
950/*
951 * erf: Mathematical error function
952 *
953 * Returns the error function.
954 */
955extern float __attribute__((const, overloadable))
956 erf(float v);
957
958extern float2 __attribute__((const, overloadable))
959 erf(float2 v);
960
961extern float3 __attribute__((const, overloadable))
962 erf(float3 v);
963
964extern float4 __attribute__((const, overloadable))
965 erf(float4 v);
966
967/*
968 * erfc: Mathematical complementary error function
969 *
970 * Returns the complementary error function.
971 */
972extern float __attribute__((const, overloadable))
973 erfc(float v);
974
975extern float2 __attribute__((const, overloadable))
976 erfc(float2 v);
977
978extern float3 __attribute__((const, overloadable))
979 erfc(float3 v);
980
981extern float4 __attribute__((const, overloadable))
982 erfc(float4 v);
983
984/*
985 * exp: e raised to a number
986 *
987 * Returns e raised to v, i.e. e ^ v.
988 *
989 * See also native_exp().
990 */
991extern float __attribute__((const, overloadable))
992 exp(float v);
993
994extern float2 __attribute__((const, overloadable))
995 exp(float2 v);
996
997extern float3 __attribute__((const, overloadable))
998 exp(float3 v);
999
1000extern float4 __attribute__((const, overloadable))
1001 exp(float4 v);
1002
1003/*
1004 * exp10: 10 raised to a number
1005 *
1006 * Returns 10 raised to v, i.e. 10.f ^ v.
1007 *
1008 * See also native_exp10().
1009 */
1010extern float __attribute__((const, overloadable))
1011 exp10(float v);
1012
1013extern float2 __attribute__((const, overloadable))
1014 exp10(float2 v);
1015
1016extern float3 __attribute__((const, overloadable))
1017 exp10(float3 v);
1018
1019extern float4 __attribute__((const, overloadable))
1020 exp10(float4 v);
1021
1022/*
1023 * exp2: 2 raised to a number
1024 *
1025 * Returns 2 raised to v, i.e. 2.f ^ v.
1026 *
1027 * See also native_exp2().
1028 */
1029extern float __attribute__((const, overloadable))
1030 exp2(float v);
1031
1032extern float2 __attribute__((const, overloadable))
1033 exp2(float2 v);
1034
1035extern float3 __attribute__((const, overloadable))
1036 exp2(float3 v);
1037
1038extern float4 __attribute__((const, overloadable))
1039 exp2(float4 v);
1040
1041/*
1042 * expm1: e raised to a number minus one
1043 *
1044 * Returns e raised to v minus 1, i.e. (e ^ v) - 1.
1045 *
1046 * See also native_expm1().
1047 */
1048extern float __attribute__((const, overloadable))
1049 expm1(float v);
1050
1051extern float2 __attribute__((const, overloadable))
1052 expm1(float2 v);
1053
1054extern float3 __attribute__((const, overloadable))
1055 expm1(float3 v);
1056
1057extern float4 __attribute__((const, overloadable))
1058 expm1(float4 v);
1059
1060/*
1061 * fabs: Absolute value of a float
1062 *
1063 * Returns the absolute value of the float v.
1064 *
1065 * For integers, use abs().
1066 */
1067extern float __attribute__((const, overloadable))
1068 fabs(float v);
1069
1070extern float2 __attribute__((const, overloadable))
1071 fabs(float2 v);
1072
1073extern float3 __attribute__((const, overloadable))
1074 fabs(float3 v);
1075
1076extern float4 __attribute__((const, overloadable))
1077 fabs(float4 v);
1078
1079/*
1080 * fdim: Positive difference between two values
1081 *
1082 * Returns the positive difference between two values.
1083 *
1084 * If a > b, returns (a - b) otherwise returns 0f.
1085 */
1086extern float __attribute__((const, overloadable))
1087 fdim(float a, float b);
1088
1089extern float2 __attribute__((const, overloadable))
1090 fdim(float2 a, float2 b);
1091
1092extern float3 __attribute__((const, overloadable))
1093 fdim(float3 a, float3 b);
1094
1095extern float4 __attribute__((const, overloadable))
1096 fdim(float4 a, float4 b);
1097
1098/*
1099 * floor: Smallest integer not greater than a value
1100 *
1101 * Returns the smallest integer not greater than a value.
1102 *
1103 * For example, floor(1.2f) returns 1.f, and floor(-1.2f) returns -2.f.
1104 *
1105 * See also ceil().
1106 */
1107extern float __attribute__((const, overloadable))
1108 floor(float v);
1109
1110extern float2 __attribute__((const, overloadable))
1111 floor(float2 v);
1112
1113extern float3 __attribute__((const, overloadable))
1114 floor(float3 v);
1115
1116extern float4 __attribute__((const, overloadable))
1117 floor(float4 v);
1118
1119/*
1120 * fma: Multiply and add
1121 *
1122 * Multiply and add. Returns (multiplicand1 * multiplicand2) + offset.
1123 *
1124 * This function is similar to mad(). fma() retains full precision of the
1125 * multiplied result and rounds only after the addition. mad() rounds after the
1126 * multiplication and the addition. This extra precision is not guaranteed in
1127 * rs_fp_relaxed mode.
1128 */
1129extern float __attribute__((const, overloadable))
1130 fma(float multiplicand1, float multiplicand2, float offset);
1131
1132extern float2 __attribute__((const, overloadable))
1133 fma(float2 multiplicand1, float2 multiplicand2, float2 offset);
1134
1135extern float3 __attribute__((const, overloadable))
1136 fma(float3 multiplicand1, float3 multiplicand2, float3 offset);
1137
1138extern float4 __attribute__((const, overloadable))
1139 fma(float4 multiplicand1, float4 multiplicand2, float4 offset);
1140
1141/*
1142 * fmax: Maximum of two floats
1143 *
1144 * Returns the maximum of a and b, i.e. (a < b ? b : a).
1145 *
1146 * The max() function returns identical results but can be applied to more data types.
1147 */
1148extern float __attribute__((const, overloadable))
1149 fmax(float a, float b);
1150
1151extern float2 __attribute__((const, overloadable))
1152 fmax(float2 a, float2 b);
1153
1154extern float3 __attribute__((const, overloadable))
1155 fmax(float3 a, float3 b);
1156
1157extern float4 __attribute__((const, overloadable))
1158 fmax(float4 a, float4 b);
1159
1160extern float2 __attribute__((const, overloadable))
1161 fmax(float2 a, float b);
1162
1163extern float3 __attribute__((const, overloadable))
1164 fmax(float3 a, float b);
1165
1166extern float4 __attribute__((const, overloadable))
1167 fmax(float4 a, float b);
1168
1169/*
1170 * fmin: Minimum of two floats
1171 *
1172 * Returns the minimum of a and b, i.e. (a > b ? b : a).
1173 *
1174 * The min() function returns identical results but can be applied to more data types.
1175 */
1176extern float __attribute__((const, overloadable))
1177 fmin(float a, float b);
1178
1179extern float2 __attribute__((const, overloadable))
1180 fmin(float2 a, float2 b);
1181
1182extern float3 __attribute__((const, overloadable))
1183 fmin(float3 a, float3 b);
1184
1185extern float4 __attribute__((const, overloadable))
1186 fmin(float4 a, float4 b);
1187
1188extern float2 __attribute__((const, overloadable))
1189 fmin(float2 a, float b);
1190
1191extern float3 __attribute__((const, overloadable))
1192 fmin(float3 a, float b);
1193
1194extern float4 __attribute__((const, overloadable))
1195 fmin(float4 a, float b);
1196
1197/*
1198 * fmod: Modulo
1199 *
1200 * Returns the remainder of (numerator / denominator), where the quotient is rounded towards zero.
1201 *
1202 * The function remainder() is similar but rounds toward the closest interger.
1203 * For example, fmod(-3.8f, 2.f) returns -1.8f (-3.8f - -1.f * 2.f)
1204 * while remainder(-3.8f, 2.f) returns 0.2f (-3.8f - -2.f * 2.f).
1205 */
1206extern float __attribute__((const, overloadable))
1207 fmod(float numerator, float denominator);
1208
1209extern float2 __attribute__((const, overloadable))
1210 fmod(float2 numerator, float2 denominator);
1211
1212extern float3 __attribute__((const, overloadable))
1213 fmod(float3 numerator, float3 denominator);
1214
1215extern float4 __attribute__((const, overloadable))
1216 fmod(float4 numerator, float4 denominator);
1217
1218/*
1219 * fract: Positive fractional part
1220 *
1221 * Returns the positive fractional part of v, i.e. v - floor(v).
1222 *
1223 * For example, fract(1.3f, &val) returns 0.3f and sets val to 1.f.
1224 * fract(-1.3f, &val) returns 0.7f and sets val to -2.f.
1225 *
1226 * Parameters:
1227 * v Input value.
1228 * floor If floor is not null, *floor will be set to the floor of v.
1229 */
1230extern float __attribute__((overloadable))
1231 fract(float v, float* floor);
1232
1233extern float2 __attribute__((overloadable))
1234 fract(float2 v, float2* floor);
1235
1236extern float3 __attribute__((overloadable))
1237 fract(float3 v, float3* floor);
1238
1239extern float4 __attribute__((overloadable))
1240 fract(float4 v, float4* floor);
1241
1242static inline float __attribute__((const, overloadable))
1243 fract(float v) {
1244 float unused;
1245 return fract(v, &unused);
1246}
1247
1248static inline float2 __attribute__((const, overloadable))
1249 fract(float2 v) {
1250 float2 unused;
1251 return fract(v, &unused);
1252}
1253
1254static inline float3 __attribute__((const, overloadable))
1255 fract(float3 v) {
1256 float3 unused;
1257 return fract(v, &unused);
1258}
1259
1260static inline float4 __attribute__((const, overloadable))
1261 fract(float4 v) {
1262 float4 unused;
1263 return fract(v, &unused);
1264}
1265
1266/*
1267 * frexp: Binary mantissa and exponent
1268 *
1269 * Returns the binary mantissa and exponent of v, i.e. v == mantissa * 2 ^ exponent.
1270 *
1271 * The mantissa is always between 0.5 (inclusive) and 1.0 (exclusive).
1272 *
1273 * See ldexp() for the reverse operation. See also logb() and ilogb().
1274 *
1275 * Parameters:
1276 * v Input value.
1277 * exponent If exponent is not null, *exponent will be set to the exponent of v.
1278 */
1279extern float __attribute__((overloadable))
1280 frexp(float v, int* exponent);
1281
1282extern float2 __attribute__((overloadable))
1283 frexp(float2 v, int2* exponent);
1284
1285extern float3 __attribute__((overloadable))
1286 frexp(float3 v, int3* exponent);
1287
1288extern float4 __attribute__((overloadable))
1289 frexp(float4 v, int4* exponent);
1290
1291/*
1292 * half_recip: Reciprocal computed to 16 bit precision
1293 *
1294 * Returns the approximate reciprocal of a value.
1295 *
1296 * The precision is that of a 16 bit floating point value.
1297 *
1298 * See also native_recip().
1299 */
1300#if (defined(RS_VERSION) && (RS_VERSION >= 17))
1301extern float __attribute__((const, overloadable))
1302 half_recip(float v);
1303#endif
1304
1305#if (defined(RS_VERSION) && (RS_VERSION >= 17))
1306extern float2 __attribute__((const, overloadable))
1307 half_recip(float2 v);
1308#endif
1309
1310#if (defined(RS_VERSION) && (RS_VERSION >= 17))
1311extern float3 __attribute__((const, overloadable))
1312 half_recip(float3 v);
1313#endif
1314
1315#if (defined(RS_VERSION) && (RS_VERSION >= 17))
1316extern float4 __attribute__((const, overloadable))
1317 half_recip(float4 v);
1318#endif
1319
1320/*
1321 * half_rsqrt: Reciprocal of a square root computed to 16 bit precision
1322 *
1323 * Returns the approximate value of (1.f / sqrt(value)).
1324 *
1325 * The precision is that of a 16 bit floating point value.
1326 *
1327 * See also rsqrt(), native_rsqrt().
1328 */
1329#if (defined(RS_VERSION) && (RS_VERSION >= 17))
1330extern float __attribute__((const, overloadable))
1331 half_rsqrt(float v);
1332#endif
1333
1334#if (defined(RS_VERSION) && (RS_VERSION >= 17))
1335extern float2 __attribute__((const, overloadable))
1336 half_rsqrt(float2 v);
1337#endif
1338
1339#if (defined(RS_VERSION) && (RS_VERSION >= 17))
1340extern float3 __attribute__((const, overloadable))
1341 half_rsqrt(float3 v);
1342#endif
1343
1344#if (defined(RS_VERSION) && (RS_VERSION >= 17))
1345extern float4 __attribute__((const, overloadable))
1346 half_rsqrt(float4 v);
1347#endif
1348
1349/*
1350 * half_sqrt: Square root computed to 16 bit precision
1351 *
1352 * Returns the approximate square root of a value.
1353 *
1354 * The precision is that of a 16 bit floating point value.
1355 *
1356 * See also sqrt(), native_sqrt().
1357 */
1358#if (defined(RS_VERSION) && (RS_VERSION >= 17))
1359extern float __attribute__((const, overloadable))
1360 half_sqrt(float v);
1361#endif
1362
1363#if (defined(RS_VERSION) && (RS_VERSION >= 17))
1364extern float2 __attribute__((const, overloadable))
1365 half_sqrt(float2 v);
1366#endif
1367
1368#if (defined(RS_VERSION) && (RS_VERSION >= 17))
1369extern float3 __attribute__((const, overloadable))
1370 half_sqrt(float3 v);
1371#endif
1372
1373#if (defined(RS_VERSION) && (RS_VERSION >= 17))
1374extern float4 __attribute__((const, overloadable))
1375 half_sqrt(float4 v);
1376#endif
1377
1378/*
1379 * hypot: Hypotenuse
1380 *
1381 * Returns the hypotenuse, i.e. sqrt(a * a + b * b).
1382 *
1383 * See also native_hypot().
1384 */
1385extern float __attribute__((const, overloadable))
1386 hypot(float a, float b);
1387
1388extern float2 __attribute__((const, overloadable))
1389 hypot(float2 a, float2 b);
1390
1391extern float3 __attribute__((const, overloadable))
1392 hypot(float3 a, float3 b);
1393
1394extern float4 __attribute__((const, overloadable))
1395 hypot(float4 a, float4 b);
1396
1397/*
1398 * ilogb: Base two exponent
1399 *
1400 * Returns the base two exponent of a value, where the mantissa is between
1401 * 1.f (inclusive) and 2.f (exclusive).
1402 *
1403 * For example, ilogb(8.5f) returns 3.
1404 *
1405 * Because of the difference in mantissa, this number is one less than
1406 * is returned by frexp().
1407 *
1408 * logb() is similar but returns a float.
1409 */
1410extern int __attribute__((const, overloadable))
1411 ilogb(float v);
1412
1413extern int2 __attribute__((const, overloadable))
1414 ilogb(float2 v);
1415
1416extern int3 __attribute__((const, overloadable))
1417 ilogb(float3 v);
1418
1419extern int4 __attribute__((const, overloadable))
1420 ilogb(float4 v);
1421
1422/*
1423 * ldexp: Creates a floating point from mantissa and exponent
1424 *
1425 * Returns the floating point created from the mantissa and exponent,
1426 * i.e. (mantissa * 2 ^ exponent).
1427 *
1428 * See frexp() for the reverse operation.
1429 *
1430 * Parameters:
1431 * mantissa The mantissa
1432 * exponent The exponent, a single component or matching vector.
1433 */
1434extern float __attribute__((const, overloadable))
1435 ldexp(float mantissa, int exponent);
1436
1437extern float2 __attribute__((const, overloadable))
1438 ldexp(float2 mantissa, int2 exponent);
1439
1440extern float3 __attribute__((const, overloadable))
1441 ldexp(float3 mantissa, int3 exponent);
1442
1443extern float4 __attribute__((const, overloadable))
1444 ldexp(float4 mantissa, int4 exponent);
1445
1446extern float2 __attribute__((const, overloadable))
1447 ldexp(float2 mantissa, int exponent);
1448
1449extern float3 __attribute__((const, overloadable))
1450 ldexp(float3 mantissa, int exponent);
1451
1452extern float4 __attribute__((const, overloadable))
1453 ldexp(float4 mantissa, int exponent);
1454
1455/*
1456 * lgamma: Natural logarithm of the gamma function
1457 *
1458 * Returns the natural logarithm of the absolute value of the gamma function,
1459 * i.e. log(fabs(tgamma(v))).
1460 *
1461 * See also tgamma().
1462 *
1463 * Parameters:
1464 * sign_of_gamma If sign_of_gamma is not null, *sign_of_gamma will be set to -1.f if the gamma of v is negative, otherwise to 1.f.
1465 */
1466extern float __attribute__((const, overloadable))
1467 lgamma(float v);
1468
1469extern float2 __attribute__((const, overloadable))
1470 lgamma(float2 v);
1471
1472extern float3 __attribute__((const, overloadable))
1473 lgamma(float3 v);
1474
1475extern float4 __attribute__((const, overloadable))
1476 lgamma(float4 v);
1477
1478extern float __attribute__((overloadable))
1479 lgamma(float v, int* sign_of_gamma);
1480
1481extern float2 __attribute__((overloadable))
1482 lgamma(float2 v, int2* sign_of_gamma);
1483
1484extern float3 __attribute__((overloadable))
1485 lgamma(float3 v, int3* sign_of_gamma);
1486
1487extern float4 __attribute__((overloadable))
1488 lgamma(float4 v, int4* sign_of_gamma);
1489
1490/*
1491 * log: Natural logarithm
1492 *
1493 * Returns the natural logarithm.
1494 *
1495 * See also native_log().
1496 */
1497extern float __attribute__((const, overloadable))
1498 log(float v);
1499
1500extern float2 __attribute__((const, overloadable))
1501 log(float2 v);
1502
1503extern float3 __attribute__((const, overloadable))
1504 log(float3 v);
1505
1506extern float4 __attribute__((const, overloadable))
1507 log(float4 v);
1508
1509/*
1510 * log10: Base 10 logarithm
1511 *
1512 * Returns the base 10 logarithm.
1513 *
1514 * See also native_log10().
1515 */
1516extern float __attribute__((const, overloadable))
1517 log10(float v);
1518
1519extern float2 __attribute__((const, overloadable))
1520 log10(float2 v);
1521
1522extern float3 __attribute__((const, overloadable))
1523 log10(float3 v);
1524
1525extern float4 __attribute__((const, overloadable))
1526 log10(float4 v);
1527
1528/*
1529 * log1p: Natural logarithm of a value plus 1
1530 *
1531 * Returns the natural logarithm of (v + 1.f).
1532 *
1533 * See also native_log1p().
1534 */
1535extern float __attribute__((const, overloadable))
1536 log1p(float v);
1537
1538extern float2 __attribute__((const, overloadable))
1539 log1p(float2 v);
1540
1541extern float3 __attribute__((const, overloadable))
1542 log1p(float3 v);
1543
1544extern float4 __attribute__((const, overloadable))
1545 log1p(float4 v);
1546
1547/*
1548 * log2: Base 2 logarithm
1549 *
1550 * Returns the base 2 logarithm.
1551 *
1552 * See also native_log2().
1553 */
1554extern float __attribute__((const, overloadable))
1555 log2(float v);
1556
1557extern float2 __attribute__((const, overloadable))
1558 log2(float2 v);
1559
1560extern float3 __attribute__((const, overloadable))
1561 log2(float3 v);
1562
1563extern float4 __attribute__((const, overloadable))
1564 log2(float4 v);
1565
1566/*
1567 * logb: Base two exponent
1568 *
1569 * Returns the base two exponent of a value, where the mantissa is between
1570 * 1.f (inclusive) and 2.f (exclusive).
1571 *
1572 * For example, logb(8.5f) returns 3.f.
1573 *
1574 * Because of the difference in mantissa, this number is one less than
1575 * is returned by frexp().
1576 *
1577 * ilogb() is similar but returns an integer.
1578 */
1579extern float __attribute__((const, overloadable))
1580 logb(float v);
1581
1582extern float2 __attribute__((const, overloadable))
1583 logb(float2 v);
1584
1585extern float3 __attribute__((const, overloadable))
1586 logb(float3 v);
1587
1588extern float4 __attribute__((const, overloadable))
1589 logb(float4 v);
1590
1591/*
1592 * mad: Multiply and add
1593 *
1594 * Multiply and add. Returns (multiplicand1 * multiplicand2) + offset.
1595 *
1596 * This function is similar to fma(). fma() retains full precision of the
1597 * multiplied result and rounds only after the addition. mad() rounds after the
1598 * multiplication and the addition. In rs_fp_relaxed mode, mad() may not do the
1599 * rounding after multiplicaiton.
1600 */
1601extern float __attribute__((const, overloadable))
1602 mad(float multiplicand1, float multiplicand2, float offset);
1603
1604extern float2 __attribute__((const, overloadable))
1605 mad(float2 multiplicand1, float2 multiplicand2, float2 offset);
1606
1607extern float3 __attribute__((const, overloadable))
1608 mad(float3 multiplicand1, float3 multiplicand2, float3 offset);
1609
1610extern float4 __attribute__((const, overloadable))
1611 mad(float4 multiplicand1, float4 multiplicand2, float4 offset);
1612
1613/*
1614 * max: Maximum
1615 *
1616 * Returns the maximum value of two arguments.
1617 */
1618extern float __attribute__((const, overloadable))
1619 max(float a, float b);
1620
1621extern float2 __attribute__((const, overloadable))
1622 max(float2 a, float2 b);
1623
1624extern float3 __attribute__((const, overloadable))
1625 max(float3 a, float3 b);
1626
1627extern float4 __attribute__((const, overloadable))
1628 max(float4 a, float4 b);
1629
1630#if !defined(RS_VERSION) || (RS_VERSION <= 20)
1631static inline char __attribute__((const, overloadable))
1632 max(char a, char b) {
1633 return (a > b ? a : b);
1634}
1635#endif
1636
1637#if !defined(RS_VERSION) || (RS_VERSION <= 20)
1638static inline uchar __attribute__((const, overloadable))
1639 max(uchar a, uchar b) {
1640 return (a > b ? a : b);
1641}
1642#endif
1643
1644#if !defined(RS_VERSION) || (RS_VERSION <= 20)
1645static inline short __attribute__((const, overloadable))
1646 max(short a, short b) {
1647 return (a > b ? a : b);
1648}
1649#endif
1650
1651#if !defined(RS_VERSION) || (RS_VERSION <= 20)
1652static inline ushort __attribute__((const, overloadable))
1653 max(ushort a, ushort b) {
1654 return (a > b ? a : b);
1655}
1656#endif
1657
1658#if !defined(RS_VERSION) || (RS_VERSION <= 20)
1659static inline int __attribute__((const, overloadable))
1660 max(int a, int b) {
1661 return (a > b ? a : b);
1662}
1663#endif
1664
1665#if !defined(RS_VERSION) || (RS_VERSION <= 20)
1666static inline uint __attribute__((const, overloadable))
1667 max(uint a, uint b) {
1668 return (a > b ? a : b);
1669}
1670#endif
1671
1672#if !defined(RS_VERSION) || (RS_VERSION <= 20)
1673static inline char2 __attribute__((const, overloadable))
1674 max(char2 a, char2 b) {
1675 char2 tmp;
1676 tmp.x = (a.x > b.x ? a.x : b.x);
1677 tmp.y = (a.y > b.y ? a.y : b.y);
1678 return tmp;
1679}
1680#endif
1681
1682#if !defined(RS_VERSION) || (RS_VERSION <= 20)
1683static inline uchar2 __attribute__((const, overloadable))
1684 max(uchar2 a, uchar2 b) {
1685 uchar2 tmp;
1686 tmp.x = (a.x > b.x ? a.x : b.x);
1687 tmp.y = (a.y > b.y ? a.y : b.y);
1688 return tmp;
1689}
1690#endif
1691
1692#if !defined(RS_VERSION) || (RS_VERSION <= 20)
1693static inline short2 __attribute__((const, overloadable))
1694 max(short2 a, short2 b) {
1695 short2 tmp;
1696 tmp.x = (a.x > b.x ? a.x : b.x);
1697 tmp.y = (a.y > b.y ? a.y : b.y);
1698 return tmp;
1699}
1700#endif
1701
1702#if !defined(RS_VERSION) || (RS_VERSION <= 20)
1703static inline ushort2 __attribute__((const, overloadable))
1704 max(ushort2 a, ushort2 b) {
1705 ushort2 tmp;
1706 tmp.x = (a.x > b.x ? a.x : b.x);
1707 tmp.y = (a.y > b.y ? a.y : b.y);
1708 return tmp;
1709}
1710#endif
1711
1712#if !defined(RS_VERSION) || (RS_VERSION <= 20)
1713static inline int2 __attribute__((const, overloadable))
1714 max(int2 a, int2 b) {
1715 int2 tmp;
1716 tmp.x = (a.x > b.x ? a.x : b.x);
1717 tmp.y = (a.y > b.y ? a.y : b.y);
1718 return tmp;
1719}
1720#endif
1721
1722#if !defined(RS_VERSION) || (RS_VERSION <= 20)
1723static inline uint2 __attribute__((const, overloadable))
1724 max(uint2 a, uint2 b) {
1725 uint2 tmp;
1726 tmp.x = (a.x > b.x ? a.x : b.x);
1727 tmp.y = (a.y > b.y ? a.y : b.y);
1728 return tmp;
1729}
1730#endif
1731
1732#if !defined(RS_VERSION) || (RS_VERSION <= 20)
1733static inline char3 __attribute__((const, overloadable))
1734 max(char3 a, char3 b) {
1735 char3 tmp;
1736 tmp.x = (a.x > b.x ? a.x : b.x);
1737 tmp.y = (a.y > b.y ? a.y : b.y);
1738 tmp.z = (a.z > b.z ? a.z : b.z);
1739 return tmp;
1740}
1741#endif
1742
1743#if !defined(RS_VERSION) || (RS_VERSION <= 20)
1744static inline uchar3 __attribute__((const, overloadable))
1745 max(uchar3 a, uchar3 b) {
1746 uchar3 tmp;
1747 tmp.x = (a.x > b.x ? a.x : b.x);
1748 tmp.y = (a.y > b.y ? a.y : b.y);
1749 tmp.z = (a.z > b.z ? a.z : b.z);
1750 return tmp;
1751}
1752#endif
1753
1754#if !defined(RS_VERSION) || (RS_VERSION <= 20)
1755static inline short3 __attribute__((const, overloadable))
1756 max(short3 a, short3 b) {
1757 short3 tmp;
1758 tmp.x = (a.x > b.x ? a.x : b.x);
1759 tmp.y = (a.y > b.y ? a.y : b.y);
1760 tmp.z = (a.z > b.z ? a.z : b.z);
1761 return tmp;
1762}
1763#endif
1764
1765#if !defined(RS_VERSION) || (RS_VERSION <= 20)
1766static inline ushort3 __attribute__((const, overloadable))
1767 max(ushort3 a, ushort3 b) {
1768 ushort3 tmp;
1769 tmp.x = (a.x > b.x ? a.x : b.x);
1770 tmp.y = (a.y > b.y ? a.y : b.y);
1771 tmp.z = (a.z > b.z ? a.z : b.z);
1772 return tmp;
1773}
1774#endif
1775
1776#if !defined(RS_VERSION) || (RS_VERSION <= 20)
1777static inline int3 __attribute__((const, overloadable))
1778 max(int3 a, int3 b) {
1779 int3 tmp;
1780 tmp.x = (a.x > b.x ? a.x : b.x);
1781 tmp.y = (a.y > b.y ? a.y : b.y);
1782 tmp.z = (a.z > b.z ? a.z : b.z);
1783 return tmp;
1784}
1785#endif
1786
1787#if !defined(RS_VERSION) || (RS_VERSION <= 20)
1788static inline uint3 __attribute__((const, overloadable))
1789 max(uint3 a, uint3 b) {
1790 uint3 tmp;
1791 tmp.x = (a.x > b.x ? a.x : b.x);
1792 tmp.y = (a.y > b.y ? a.y : b.y);
1793 tmp.z = (a.z > b.z ? a.z : b.z);
1794 return tmp;
1795}
1796#endif
1797
1798#if !defined(RS_VERSION) || (RS_VERSION <= 20)
1799static inline char4 __attribute__((const, overloadable))
1800 max(char4 a, char4 b) {
1801 char4 tmp;
1802 tmp.x = (a.x > b.x ? a.x : b.x);
1803 tmp.y = (a.y > b.y ? a.y : b.y);
1804 tmp.z = (a.z > b.z ? a.z : b.z);
1805 tmp.w = (a.w > b.w ? a.w : b.w);
1806 return tmp;
1807}
1808#endif
1809
1810#if !defined(RS_VERSION) || (RS_VERSION <= 20)
1811static inline uchar4 __attribute__((const, overloadable))
1812 max(uchar4 a, uchar4 b) {
1813 uchar4 tmp;
1814 tmp.x = (a.x > b.x ? a.x : b.x);
1815 tmp.y = (a.y > b.y ? a.y : b.y);
1816 tmp.z = (a.z > b.z ? a.z : b.z);
1817 tmp.w = (a.w > b.w ? a.w : b.w);
1818 return tmp;
1819}
1820#endif
1821
1822#if !defined(RS_VERSION) || (RS_VERSION <= 20)
1823static inline short4 __attribute__((const, overloadable))
1824 max(short4 a, short4 b) {
1825 short4 tmp;
1826 tmp.x = (a.x > b.x ? a.x : b.x);
1827 tmp.y = (a.y > b.y ? a.y : b.y);
1828 tmp.z = (a.z > b.z ? a.z : b.z);
1829 tmp.w = (a.w > b.w ? a.w : b.w);
1830 return tmp;
1831}
1832#endif
1833
1834#if !defined(RS_VERSION) || (RS_VERSION <= 20)
1835static inline ushort4 __attribute__((const, overloadable))
1836 max(ushort4 a, ushort4 b) {
1837 ushort4 tmp;
1838 tmp.x = (a.x > b.x ? a.x : b.x);
1839 tmp.y = (a.y > b.y ? a.y : b.y);
1840 tmp.z = (a.z > b.z ? a.z : b.z);
1841 tmp.w = (a.w > b.w ? a.w : b.w);
1842 return tmp;
1843}
1844#endif
1845
1846#if !defined(RS_VERSION) || (RS_VERSION <= 20)
1847static inline int4 __attribute__((const, overloadable))
1848 max(int4 a, int4 b) {
1849 int4 tmp;
1850 tmp.x = (a.x > b.x ? a.x : b.x);
1851 tmp.y = (a.y > b.y ? a.y : b.y);
1852 tmp.z = (a.z > b.z ? a.z : b.z);
1853 tmp.w = (a.w > b.w ? a.w : b.w);
1854 return tmp;
1855}
1856#endif
1857
1858#if !defined(RS_VERSION) || (RS_VERSION <= 20)
1859static inline uint4 __attribute__((const, overloadable))
1860 max(uint4 a, uint4 b) {
1861 uint4 tmp;
1862 tmp.x = (a.x > b.x ? a.x : b.x);
1863 tmp.y = (a.y > b.y ? a.y : b.y);
1864 tmp.z = (a.z > b.z ? a.z : b.z);
1865 tmp.w = (a.w > b.w ? a.w : b.w);
1866 return tmp;
1867}
1868#endif
1869
1870#if (defined(RS_VERSION) && (RS_VERSION >= 21))
1871extern char __attribute__((const, overloadable))
1872 max(char a, char b);
1873#endif
1874
1875#if (defined(RS_VERSION) && (RS_VERSION >= 21))
1876extern char2 __attribute__((const, overloadable))
1877 max(char2 a, char2 b);
1878#endif
1879
1880#if (defined(RS_VERSION) && (RS_VERSION >= 21))
1881extern char3 __attribute__((const, overloadable))
1882 max(char3 a, char3 b);
1883#endif
1884
1885#if (defined(RS_VERSION) && (RS_VERSION >= 21))
1886extern char4 __attribute__((const, overloadable))
1887 max(char4 a, char4 b);
1888#endif
1889
1890#if (defined(RS_VERSION) && (RS_VERSION >= 21))
1891extern uchar __attribute__((const, overloadable))
1892 max(uchar a, uchar b);
1893#endif
1894
1895#if (defined(RS_VERSION) && (RS_VERSION >= 21))
1896extern uchar2 __attribute__((const, overloadable))
1897 max(uchar2 a, uchar2 b);
1898#endif
1899
1900#if (defined(RS_VERSION) && (RS_VERSION >= 21))
1901extern uchar3 __attribute__((const, overloadable))
1902 max(uchar3 a, uchar3 b);
1903#endif
1904
1905#if (defined(RS_VERSION) && (RS_VERSION >= 21))
1906extern uchar4 __attribute__((const, overloadable))
1907 max(uchar4 a, uchar4 b);
1908#endif
1909
1910#if (defined(RS_VERSION) && (RS_VERSION >= 21))
1911extern short __attribute__((const, overloadable))
1912 max(short a, short b);
1913#endif
1914
1915#if (defined(RS_VERSION) && (RS_VERSION >= 21))
1916extern short2 __attribute__((const, overloadable))
1917 max(short2 a, short2 b);
1918#endif
1919
1920#if (defined(RS_VERSION) && (RS_VERSION >= 21))
1921extern short3 __attribute__((const, overloadable))
1922 max(short3 a, short3 b);
1923#endif
1924
1925#if (defined(RS_VERSION) && (RS_VERSION >= 21))
1926extern short4 __attribute__((const, overloadable))
1927 max(short4 a, short4 b);
1928#endif
1929
1930#if (defined(RS_VERSION) && (RS_VERSION >= 21))
1931extern ushort __attribute__((const, overloadable))
1932 max(ushort a, ushort b);
1933#endif
1934
1935#if (defined(RS_VERSION) && (RS_VERSION >= 21))
1936extern ushort2 __attribute__((const, overloadable))
1937 max(ushort2 a, ushort2 b);
1938#endif
1939
1940#if (defined(RS_VERSION) && (RS_VERSION >= 21))
1941extern ushort3 __attribute__((const, overloadable))
1942 max(ushort3 a, ushort3 b);
1943#endif
1944
1945#if (defined(RS_VERSION) && (RS_VERSION >= 21))
1946extern ushort4 __attribute__((const, overloadable))
1947 max(ushort4 a, ushort4 b);
1948#endif
1949
1950#if (defined(RS_VERSION) && (RS_VERSION >= 21))
1951extern int __attribute__((const, overloadable))
1952 max(int a, int b);
1953#endif
1954
1955#if (defined(RS_VERSION) && (RS_VERSION >= 21))
1956extern int2 __attribute__((const, overloadable))
1957 max(int2 a, int2 b);
1958#endif
1959
1960#if (defined(RS_VERSION) && (RS_VERSION >= 21))
1961extern int3 __attribute__((const, overloadable))
1962 max(int3 a, int3 b);
1963#endif
1964
1965#if (defined(RS_VERSION) && (RS_VERSION >= 21))
1966extern int4 __attribute__((const, overloadable))
1967 max(int4 a, int4 b);
1968#endif
1969
1970#if (defined(RS_VERSION) && (RS_VERSION >= 21))
1971extern uint __attribute__((const, overloadable))
1972 max(uint a, uint b);
1973#endif
1974
1975#if (defined(RS_VERSION) && (RS_VERSION >= 21))
1976extern uint2 __attribute__((const, overloadable))
1977 max(uint2 a, uint2 b);
1978#endif
1979
1980#if (defined(RS_VERSION) && (RS_VERSION >= 21))
1981extern uint3 __attribute__((const, overloadable))
1982 max(uint3 a, uint3 b);
1983#endif
1984
1985#if (defined(RS_VERSION) && (RS_VERSION >= 21))
1986extern uint4 __attribute__((const, overloadable))
1987 max(uint4 a, uint4 b);
1988#endif
1989
1990#if (defined(RS_VERSION) && (RS_VERSION >= 21))
1991extern long __attribute__((const, overloadable))
1992 max(long a, long b);
1993#endif
1994
1995#if (defined(RS_VERSION) && (RS_VERSION >= 21))
1996extern long2 __attribute__((const, overloadable))
1997 max(long2 a, long2 b);
1998#endif
1999
2000#if (defined(RS_VERSION) && (RS_VERSION >= 21))
2001extern long3 __attribute__((const, overloadable))
2002 max(long3 a, long3 b);
2003#endif
2004
2005#if (defined(RS_VERSION) && (RS_VERSION >= 21))
2006extern long4 __attribute__((const, overloadable))
2007 max(long4 a, long4 b);
2008#endif
2009
2010#if (defined(RS_VERSION) && (RS_VERSION >= 21))
2011extern ulong __attribute__((const, overloadable))
2012 max(ulong a, ulong b);
2013#endif
2014
2015#if (defined(RS_VERSION) && (RS_VERSION >= 21))
2016extern ulong2 __attribute__((const, overloadable))
2017 max(ulong2 a, ulong2 b);
2018#endif
2019
2020#if (defined(RS_VERSION) && (RS_VERSION >= 21))
2021extern ulong3 __attribute__((const, overloadable))
2022 max(ulong3 a, ulong3 b);
2023#endif
2024
2025#if (defined(RS_VERSION) && (RS_VERSION >= 21))
2026extern ulong4 __attribute__((const, overloadable))
2027 max(ulong4 a, ulong4 b);
2028#endif
2029
2030/*
2031 * min: Minimum
2032 *
2033 * Returns the minimum value of two arguments.
2034 */
2035extern float __attribute__((const, overloadable))
2036 min(float a, float b);
2037
2038extern float2 __attribute__((const, overloadable))
2039 min(float2 a, float2 b);
2040
2041extern float3 __attribute__((const, overloadable))
2042 min(float3 a, float3 b);
2043
2044extern float4 __attribute__((const, overloadable))
2045 min(float4 a, float4 b);
2046
2047#if !defined(RS_VERSION) || (RS_VERSION <= 20)
2048static inline char __attribute__((const, overloadable))
2049 min(char a, char b) {
2050 return (a < b ? a : b);
2051}
2052#endif
2053
2054#if !defined(RS_VERSION) || (RS_VERSION <= 20)
2055static inline uchar __attribute__((const, overloadable))
2056 min(uchar a, uchar b) {
2057 return (a < b ? a : b);
2058}
2059#endif
2060
2061#if !defined(RS_VERSION) || (RS_VERSION <= 20)
2062static inline short __attribute__((const, overloadable))
2063 min(short a, short b) {
2064 return (a < b ? a : b);
2065}
2066#endif
2067
2068#if !defined(RS_VERSION) || (RS_VERSION <= 20)
2069static inline ushort __attribute__((const, overloadable))
2070 min(ushort a, ushort b) {
2071 return (a < b ? a : b);
2072}
2073#endif
2074
2075#if !defined(RS_VERSION) || (RS_VERSION <= 20)
2076static inline int __attribute__((const, overloadable))
2077 min(int a, int b) {
2078 return (a < b ? a : b);
2079}
2080#endif
2081
2082#if !defined(RS_VERSION) || (RS_VERSION <= 20)
2083static inline uint __attribute__((const, overloadable))
2084 min(uint a, uint b) {
2085 return (a < b ? a : b);
2086}
2087#endif
2088
2089#if !defined(RS_VERSION) || (RS_VERSION <= 20)
2090static inline char2 __attribute__((const, overloadable))
2091 min(char2 a, char2 b) {
2092 char2 tmp;
2093 tmp.x = (a.x < b.x ? a.x : b.x);
2094 tmp.y = (a.y < b.y ? a.y : b.y);
2095 return tmp;
2096}
2097#endif
2098
2099#if !defined(RS_VERSION) || (RS_VERSION <= 20)
2100static inline uchar2 __attribute__((const, overloadable))
2101 min(uchar2 a, uchar2 b) {
2102 uchar2 tmp;
2103 tmp.x = (a.x < b.x ? a.x : b.x);
2104 tmp.y = (a.y < b.y ? a.y : b.y);
2105 return tmp;
2106}
2107#endif
2108
2109#if !defined(RS_VERSION) || (RS_VERSION <= 20)
2110static inline short2 __attribute__((const, overloadable))
2111 min(short2 a, short2 b) {
2112 short2 tmp;
2113 tmp.x = (a.x < b.x ? a.x : b.x);
2114 tmp.y = (a.y < b.y ? a.y : b.y);
2115 return tmp;
2116}
2117#endif
2118
2119#if !defined(RS_VERSION) || (RS_VERSION <= 20)
2120static inline ushort2 __attribute__((const, overloadable))
2121 min(ushort2 a, ushort2 b) {
2122 ushort2 tmp;
2123 tmp.x = (a.x < b.x ? a.x : b.x);
2124 tmp.y = (a.y < b.y ? a.y : b.y);
2125 return tmp;
2126}
2127#endif
2128
2129#if !defined(RS_VERSION) || (RS_VERSION <= 20)
2130static inline int2 __attribute__((const, overloadable))
2131 min(int2 a, int2 b) {
2132 int2 tmp;
2133 tmp.x = (a.x < b.x ? a.x : b.x);
2134 tmp.y = (a.y < b.y ? a.y : b.y);
2135 return tmp;
2136}
2137#endif
2138
2139#if !defined(RS_VERSION) || (RS_VERSION <= 20)
2140static inline uint2 __attribute__((const, overloadable))
2141 min(uint2 a, uint2 b) {
2142 uint2 tmp;
2143 tmp.x = (a.x < b.x ? a.x : b.x);
2144 tmp.y = (a.y < b.y ? a.y : b.y);
2145 return tmp;
2146}
2147#endif
2148
2149#if !defined(RS_VERSION) || (RS_VERSION <= 20)
2150static inline char3 __attribute__((const, overloadable))
2151 min(char3 a, char3 b) {
2152 char3 tmp;
2153 tmp.x = (a.x < b.x ? a.x : b.x);
2154 tmp.y = (a.y < b.y ? a.y : b.y);
2155 tmp.z = (a.z < b.z ? a.z : b.z);
2156 return tmp;
2157}
2158#endif
2159
2160#if !defined(RS_VERSION) || (RS_VERSION <= 20)
2161static inline uchar3 __attribute__((const, overloadable))
2162 min(uchar3 a, uchar3 b) {
2163 uchar3 tmp;
2164 tmp.x = (a.x < b.x ? a.x : b.x);
2165 tmp.y = (a.y < b.y ? a.y : b.y);
2166 tmp.z = (a.z < b.z ? a.z : b.z);
2167 return tmp;
2168}
2169#endif
2170
2171#if !defined(RS_VERSION) || (RS_VERSION <= 20)
2172static inline short3 __attribute__((const, overloadable))
2173 min(short3 a, short3 b) {
2174 short3 tmp;
2175 tmp.x = (a.x < b.x ? a.x : b.x);
2176 tmp.y = (a.y < b.y ? a.y : b.y);
2177 tmp.z = (a.z < b.z ? a.z : b.z);
2178 return tmp;
2179}
2180#endif
2181
2182#if !defined(RS_VERSION) || (RS_VERSION <= 20)
2183static inline ushort3 __attribute__((const, overloadable))
2184 min(ushort3 a, ushort3 b) {
2185 ushort3 tmp;
2186 tmp.x = (a.x < b.x ? a.x : b.x);
2187 tmp.y = (a.y < b.y ? a.y : b.y);
2188 tmp.z = (a.z < b.z ? a.z : b.z);
2189 return tmp;
2190}
2191#endif
2192
2193#if !defined(RS_VERSION) || (RS_VERSION <= 20)
2194static inline int3 __attribute__((const, overloadable))
2195 min(int3 a, int3 b) {
2196 int3 tmp;
2197 tmp.x = (a.x < b.x ? a.x : b.x);
2198 tmp.y = (a.y < b.y ? a.y : b.y);
2199 tmp.z = (a.z < b.z ? a.z : b.z);
2200 return tmp;
2201}
2202#endif
2203
2204#if !defined(RS_VERSION) || (RS_VERSION <= 20)
2205static inline uint3 __attribute__((const, overloadable))
2206 min(uint3 a, uint3 b) {
2207 uint3 tmp;
2208 tmp.x = (a.x < b.x ? a.x : b.x);
2209 tmp.y = (a.y < b.y ? a.y : b.y);
2210 tmp.z = (a.z < b.z ? a.z : b.z);
2211 return tmp;
2212}
2213#endif
2214
2215#if !defined(RS_VERSION) || (RS_VERSION <= 20)
2216static inline char4 __attribute__((const, overloadable))
2217 min(char4 a, char4 b) {
2218 char4 tmp;
2219 tmp.x = (a.x < b.x ? a.x : b.x);
2220 tmp.y = (a.y < b.y ? a.y : b.y);
2221 tmp.z = (a.z < b.z ? a.z : b.z);
2222 tmp.w = (a.w < b.w ? a.w : b.w);
2223 return tmp;
2224}
2225#endif
2226
2227#if !defined(RS_VERSION) || (RS_VERSION <= 20)
2228static inline uchar4 __attribute__((const, overloadable))
2229 min(uchar4 a, uchar4 b) {
2230 uchar4 tmp;
2231 tmp.x = (a.x < b.x ? a.x : b.x);
2232 tmp.y = (a.y < b.y ? a.y : b.y);
2233 tmp.z = (a.z < b.z ? a.z : b.z);
2234 tmp.w = (a.w < b.w ? a.w : b.w);
2235 return tmp;
2236}
2237#endif
2238
2239#if !defined(RS_VERSION) || (RS_VERSION <= 20)
2240static inline short4 __attribute__((const, overloadable))
2241 min(short4 a, short4 b) {
2242 short4 tmp;
2243 tmp.x = (a.x < b.x ? a.x : b.x);
2244 tmp.y = (a.y < b.y ? a.y : b.y);
2245 tmp.z = (a.z < b.z ? a.z : b.z);
2246 tmp.w = (a.w < b.w ? a.w : b.w);
2247 return tmp;
2248}
2249#endif
2250
2251#if !defined(RS_VERSION) || (RS_VERSION <= 20)
2252static inline ushort4 __attribute__((const, overloadable))
2253 min(ushort4 a, ushort4 b) {
2254 ushort4 tmp;
2255 tmp.x = (a.x < b.x ? a.x : b.x);
2256 tmp.y = (a.y < b.y ? a.y : b.y);
2257 tmp.z = (a.z < b.z ? a.z : b.z);
2258 tmp.w = (a.w < b.w ? a.w : b.w);
2259 return tmp;
2260}
2261#endif
2262
2263#if !defined(RS_VERSION) || (RS_VERSION <= 20)
2264static inline int4 __attribute__((const, overloadable))
2265 min(int4 a, int4 b) {
2266 int4 tmp;
2267 tmp.x = (a.x < b.x ? a.x : b.x);
2268 tmp.y = (a.y < b.y ? a.y : b.y);
2269 tmp.z = (a.z < b.z ? a.z : b.z);
2270 tmp.w = (a.w < b.w ? a.w : b.w);
2271 return tmp;
2272}
2273#endif
2274
2275#if !defined(RS_VERSION) || (RS_VERSION <= 20)
2276static inline uint4 __attribute__((const, overloadable))
2277 min(uint4 a, uint4 b) {
2278 uint4 tmp;
2279 tmp.x = (a.x < b.x ? a.x : b.x);
2280 tmp.y = (a.y < b.y ? a.y : b.y);
2281 tmp.z = (a.z < b.z ? a.z : b.z);
2282 tmp.w = (a.w < b.w ? a.w : b.w);
2283 return tmp;
2284}
2285#endif
2286
2287#if (defined(RS_VERSION) && (RS_VERSION >= 21))
2288extern char __attribute__((const, overloadable))
2289 min(char a, char b);
2290#endif
2291
2292#if (defined(RS_VERSION) && (RS_VERSION >= 21))
2293extern char2 __attribute__((const, overloadable))
2294 min(char2 a, char2 b);
2295#endif
2296
2297#if (defined(RS_VERSION) && (RS_VERSION >= 21))
2298extern char3 __attribute__((const, overloadable))
2299 min(char3 a, char3 b);
2300#endif
2301
2302#if (defined(RS_VERSION) && (RS_VERSION >= 21))
2303extern char4 __attribute__((const, overloadable))
2304 min(char4 a, char4 b);
2305#endif
2306
2307#if (defined(RS_VERSION) && (RS_VERSION >= 21))
2308extern uchar __attribute__((const, overloadable))
2309 min(uchar a, uchar b);
2310#endif
2311
2312#if (defined(RS_VERSION) && (RS_VERSION >= 21))
2313extern uchar2 __attribute__((const, overloadable))
2314 min(uchar2 a, uchar2 b);
2315#endif
2316
2317#if (defined(RS_VERSION) && (RS_VERSION >= 21))
2318extern uchar3 __attribute__((const, overloadable))
2319 min(uchar3 a, uchar3 b);
2320#endif
2321
2322#if (defined(RS_VERSION) && (RS_VERSION >= 21))
2323extern uchar4 __attribute__((const, overloadable))
2324 min(uchar4 a, uchar4 b);
2325#endif
2326
2327#if (defined(RS_VERSION) && (RS_VERSION >= 21))
2328extern short __attribute__((const, overloadable))
2329 min(short a, short b);
2330#endif
2331
2332#if (defined(RS_VERSION) && (RS_VERSION >= 21))
2333extern short2 __attribute__((const, overloadable))
2334 min(short2 a, short2 b);
2335#endif
2336
2337#if (defined(RS_VERSION) && (RS_VERSION >= 21))
2338extern short3 __attribute__((const, overloadable))
2339 min(short3 a, short3 b);
2340#endif
2341
2342#if (defined(RS_VERSION) && (RS_VERSION >= 21))
2343extern short4 __attribute__((const, overloadable))
2344 min(short4 a, short4 b);
2345#endif
2346
2347#if (defined(RS_VERSION) && (RS_VERSION >= 21))
2348extern ushort __attribute__((const, overloadable))
2349 min(ushort a, ushort b);
2350#endif
2351
2352#if (defined(RS_VERSION) && (RS_VERSION >= 21))
2353extern ushort2 __attribute__((const, overloadable))
2354 min(ushort2 a, ushort2 b);
2355#endif
2356
2357#if (defined(RS_VERSION) && (RS_VERSION >= 21))
2358extern ushort3 __attribute__((const, overloadable))
2359 min(ushort3 a, ushort3 b);
2360#endif
2361
2362#if (defined(RS_VERSION) && (RS_VERSION >= 21))
2363extern ushort4 __attribute__((const, overloadable))
2364 min(ushort4 a, ushort4 b);
2365#endif
2366
2367#if (defined(RS_VERSION) && (RS_VERSION >= 21))
2368extern int __attribute__((const, overloadable))
2369 min(int a, int b);
2370#endif
2371
2372#if (defined(RS_VERSION) && (RS_VERSION >= 21))
2373extern int2 __attribute__((const, overloadable))
2374 min(int2 a, int2 b);
2375#endif
2376
2377#if (defined(RS_VERSION) && (RS_VERSION >= 21))
2378extern int3 __attribute__((const, overloadable))
2379 min(int3 a, int3 b);
2380#endif
2381
2382#if (defined(RS_VERSION) && (RS_VERSION >= 21))
2383extern int4 __attribute__((const, overloadable))
2384 min(int4 a, int4 b);
2385#endif
2386
2387#if (defined(RS_VERSION) && (RS_VERSION >= 21))
2388extern uint __attribute__((const, overloadable))
2389 min(uint a, uint b);
2390#endif
2391
2392#if (defined(RS_VERSION) && (RS_VERSION >= 21))
2393extern uint2 __attribute__((const, overloadable))
2394 min(uint2 a, uint2 b);
2395#endif
2396
2397#if (defined(RS_VERSION) && (RS_VERSION >= 21))
2398extern uint3 __attribute__((const, overloadable))
2399 min(uint3 a, uint3 b);
2400#endif
2401
2402#if (defined(RS_VERSION) && (RS_VERSION >= 21))
2403extern uint4 __attribute__((const, overloadable))
2404 min(uint4 a, uint4 b);
2405#endif
2406
2407#if (defined(RS_VERSION) && (RS_VERSION >= 21))
2408extern long __attribute__((const, overloadable))
2409 min(long a, long b);
2410#endif
2411
2412#if (defined(RS_VERSION) && (RS_VERSION >= 21))
2413extern long2 __attribute__((const, overloadable))
2414 min(long2 a, long2 b);
2415#endif
2416
2417#if (defined(RS_VERSION) && (RS_VERSION >= 21))
2418extern long3 __attribute__((const, overloadable))
2419 min(long3 a, long3 b);
2420#endif
2421
2422#if (defined(RS_VERSION) && (RS_VERSION >= 21))
2423extern long4 __attribute__((const, overloadable))
2424 min(long4 a, long4 b);
2425#endif
2426
2427#if (defined(RS_VERSION) && (RS_VERSION >= 21))
2428extern ulong __attribute__((const, overloadable))
2429 min(ulong a, ulong b);
2430#endif
2431
2432#if (defined(RS_VERSION) && (RS_VERSION >= 21))
2433extern ulong2 __attribute__((const, overloadable))
2434 min(ulong2 a, ulong2 b);
2435#endif
2436
2437#if (defined(RS_VERSION) && (RS_VERSION >= 21))
2438extern ulong3 __attribute__((const, overloadable))
2439 min(ulong3 a, ulong3 b);
2440#endif
2441
2442#if (defined(RS_VERSION) && (RS_VERSION >= 21))
2443extern ulong4 __attribute__((const, overloadable))
2444 min(ulong4 a, ulong4 b);
2445#endif
2446
2447/*
2448 * mix: Mixes two values
2449 *
2450 * Returns start + ((stop - start) * fraction).
2451 *
2452 * This can be useful for mixing two values. For example, to create a new color that is 40% color1 and 60% color2, use mix(color1, color2, 0.6f).
2453 */
2454extern float __attribute__((const, overloadable))
2455 mix(float start, float stop, float fraction);
2456
2457extern float2 __attribute__((const, overloadable))
2458 mix(float2 start, float2 stop, float2 fraction);
2459
2460extern float3 __attribute__((const, overloadable))
2461 mix(float3 start, float3 stop, float3 fraction);
2462
2463extern float4 __attribute__((const, overloadable))
2464 mix(float4 start, float4 stop, float4 fraction);
2465
2466extern float2 __attribute__((const, overloadable))
2467 mix(float2 start, float2 stop, float fraction);
2468
2469extern float3 __attribute__((const, overloadable))
2470 mix(float3 start, float3 stop, float fraction);
2471
2472extern float4 __attribute__((const, overloadable))
2473 mix(float4 start, float4 stop, float fraction);
2474
2475/*
2476 * modf: Integral and fractional components
2477 *
2478 * Returns the integral and fractional components of a number.
2479 *
2480 * Both components will have the same sign as x. For example, for an input of -3.72f, iret will be set to -3.f and .72f will be returned.
2481 *
2482 * Parameters:
2483 * v Source value
2484 * integral_part *integral_part will be set to the integral portion of the number.
2485 *
2486 * Returns: The floating point portion of the value.
2487 */
2488extern float __attribute__((overloadable))
2489 modf(float v, float* integral_part);
2490
2491extern float2 __attribute__((overloadable))
2492 modf(float2 v, float2* integral_part);
2493
2494extern float3 __attribute__((overloadable))
2495 modf(float3 v, float3* integral_part);
2496
2497extern float4 __attribute__((overloadable))
2498 modf(float4 v, float4* integral_part);
2499
2500/*
2501 * nan: Not a Number
2502 *
2503 * Returns a NaN value (Not a Number).
2504 *
2505 * Parameters:
2506 * v Not used.
2507 */
2508extern float __attribute__((const, overloadable))
2509 nan(uint v);
2510
2511/*
2512 * native_acos: Approximate inverse cosine
2513 *
2514 * Returns the approximate inverse cosine, in radians.
2515 *
2516 * This function yields undefined results from input values less than -1 or greater
2517 * than 1.
2518 *
2519 * See also acos().
2520 */
2521#if (defined(RS_VERSION) && (RS_VERSION >= 21))
2522extern float __attribute__((const, overloadable))
2523 native_acos(float v);
2524#endif
2525
2526#if (defined(RS_VERSION) && (RS_VERSION >= 21))
2527extern float2 __attribute__((const, overloadable))
2528 native_acos(float2 v);
2529#endif
2530
2531#if (defined(RS_VERSION) && (RS_VERSION >= 21))
2532extern float3 __attribute__((const, overloadable))
2533 native_acos(float3 v);
2534#endif
2535
2536#if (defined(RS_VERSION) && (RS_VERSION >= 21))
2537extern float4 __attribute__((const, overloadable))
2538 native_acos(float4 v);
2539#endif
2540
2541/*
2542 * native_acosh: Approximate inverse hyperbolic cosine
2543 *
2544 * Returns the approximate inverse hyperbolic cosine, in radians.
2545 *
2546 * See also acosh().
2547 */
2548#if (defined(RS_VERSION) && (RS_VERSION >= 21))
2549extern float __attribute__((const, overloadable))
2550 native_acosh(float v);
2551#endif
2552
2553#if (defined(RS_VERSION) && (RS_VERSION >= 21))
2554extern float2 __attribute__((const, overloadable))
2555 native_acosh(float2 v);
2556#endif
2557
2558#if (defined(RS_VERSION) && (RS_VERSION >= 21))
2559extern float3 __attribute__((const, overloadable))
2560 native_acosh(float3 v);
2561#endif
2562
2563#if (defined(RS_VERSION) && (RS_VERSION >= 21))
2564extern float4 __attribute__((const, overloadable))
2565 native_acosh(float4 v);
2566#endif
2567
2568/*
2569 * native_acospi: Approximate inverse cosine divided by pi
2570 *
2571 * Returns the approximate inverse cosine in radians, divided by pi.
2572 *
2573 * To get an inverse cosine measured in degrees, use acospi(a) * 180.f.
2574 *
2575 * This function yields undefined results from input values less than -1 or greater
2576 * than 1.
2577 *
2578 * See also acospi().
2579 */
2580#if (defined(RS_VERSION) && (RS_VERSION >= 21))
2581extern float __attribute__((const, overloadable))
2582 native_acospi(float v);
2583#endif
2584
2585#if (defined(RS_VERSION) && (RS_VERSION >= 21))
2586extern float2 __attribute__((const, overloadable))
2587 native_acospi(float2 v);
2588#endif
2589
2590#if (defined(RS_VERSION) && (RS_VERSION >= 21))
2591extern float3 __attribute__((const, overloadable))
2592 native_acospi(float3 v);
2593#endif
2594
2595#if (defined(RS_VERSION) && (RS_VERSION >= 21))
2596extern float4 __attribute__((const, overloadable))
2597 native_acospi(float4 v);
2598#endif
2599
2600/*
2601 * native_asin: Approximate inverse sine
2602 *
2603 * Returns the approximate inverse sine, in radians.
2604 *
2605 * This function yields undefined results from input values less than -1 or greater
2606 * than 1.
2607 *
2608 * See also asin().
2609 */
2610#if (defined(RS_VERSION) && (RS_VERSION >= 21))
2611extern float __attribute__((const, overloadable))
2612 native_asin(float v);
2613#endif
2614
2615#if (defined(RS_VERSION) && (RS_VERSION >= 21))
2616extern float2 __attribute__((const, overloadable))
2617 native_asin(float2 v);
2618#endif
2619
2620#if (defined(RS_VERSION) && (RS_VERSION >= 21))
2621extern float3 __attribute__((const, overloadable))
2622 native_asin(float3 v);
2623#endif
2624
2625#if (defined(RS_VERSION) && (RS_VERSION >= 21))
2626extern float4 __attribute__((const, overloadable))
2627 native_asin(float4 v);
2628#endif
2629
2630/*
2631 * native_asinh: Approximate inverse hyperbolic sine
2632 *
2633 * Returns the approximate inverse hyperbolic sine, in radians.
2634 *
2635 * See also asinh().
2636 */
2637#if (defined(RS_VERSION) && (RS_VERSION >= 21))
2638extern float __attribute__((const, overloadable))
2639 native_asinh(float v);
2640#endif
2641
2642#if (defined(RS_VERSION) && (RS_VERSION >= 21))
2643extern float2 __attribute__((const, overloadable))
2644 native_asinh(float2 v);
2645#endif
2646
2647#if (defined(RS_VERSION) && (RS_VERSION >= 21))
2648extern float3 __attribute__((const, overloadable))
2649 native_asinh(float3 v);
2650#endif
2651
2652#if (defined(RS_VERSION) && (RS_VERSION >= 21))
2653extern float4 __attribute__((const, overloadable))
2654 native_asinh(float4 v);
2655#endif
2656
2657/*
2658 * native_asinpi: Approximate inverse sine divided by pi
2659 *
2660 * Returns the approximate inverse sine in radians, divided by pi.
2661 *
2662 * To get an inverse sine measured in degrees, use asinpi(a) * 180.f.
2663 *
2664 * This function yields undefined results from input values less than -1 or greater
2665 * than 1.
2666 *
2667 * See also asinpi().
2668 */
2669#if (defined(RS_VERSION) && (RS_VERSION >= 21))
2670extern float __attribute__((const, overloadable))
2671 native_asinpi(float v);
2672#endif
2673
2674#if (defined(RS_VERSION) && (RS_VERSION >= 21))
2675extern float2 __attribute__((const, overloadable))
2676 native_asinpi(float2 v);
2677#endif
2678
2679#if (defined(RS_VERSION) && (RS_VERSION >= 21))
2680extern float3 __attribute__((const, overloadable))
2681 native_asinpi(float3 v);
2682#endif
2683
2684#if (defined(RS_VERSION) && (RS_VERSION >= 21))
2685extern float4 __attribute__((const, overloadable))
2686 native_asinpi(float4 v);
2687#endif
2688
2689/*
2690 * native_atan: Approximate inverse tangent
2691 *
2692 * Returns the approximate inverse tangent, in radians.
2693 *
2694 * See also atan().
2695 */
2696#if (defined(RS_VERSION) && (RS_VERSION >= 21))
2697extern float __attribute__((const, overloadable))
2698 native_atan(float v);
2699#endif
2700
2701#if (defined(RS_VERSION) && (RS_VERSION >= 21))
2702extern float2 __attribute__((const, overloadable))
2703 native_atan(float2 v);
2704#endif
2705
2706#if (defined(RS_VERSION) && (RS_VERSION >= 21))
2707extern float3 __attribute__((const, overloadable))
2708 native_atan(float3 v);
2709#endif
2710
2711#if (defined(RS_VERSION) && (RS_VERSION >= 21))
2712extern float4 __attribute__((const, overloadable))
2713 native_atan(float4 v);
2714#endif
2715
2716/*
2717 * native_atan2: Approximate inverse tangent of a ratio
2718 *
2719 * Returns the approximate inverse tangent of (numerator / denominator), in radians.
2720 *
2721 * See also atan2().
2722 *
2723 * Parameters:
2724 * numerator The numerator
2725 * denominator The denominator. Can be 0.
2726 */
2727#if (defined(RS_VERSION) && (RS_VERSION >= 21))
2728extern float __attribute__((const, overloadable))
2729 native_atan2(float numerator, float denominator);
2730#endif
2731
2732#if (defined(RS_VERSION) && (RS_VERSION >= 21))
2733extern float2 __attribute__((const, overloadable))
2734 native_atan2(float2 numerator, float2 denominator);
2735#endif
2736
2737#if (defined(RS_VERSION) && (RS_VERSION >= 21))
2738extern float3 __attribute__((const, overloadable))
2739 native_atan2(float3 numerator, float3 denominator);
2740#endif
2741
2742#if (defined(RS_VERSION) && (RS_VERSION >= 21))
2743extern float4 __attribute__((const, overloadable))
2744 native_atan2(float4 numerator, float4 denominator);
2745#endif
2746
2747/*
2748 * native_atan2pi: Approximate inverse tangent of a ratio, divided by pi
2749 *
2750 * Returns the approximate inverse tangent of (numerator / denominator), in radians, divided by pi.
2751 *
2752 * To get an inverse tangent measured in degrees, use atan2pi(n, d) * 180.f.
2753 *
2754 * See also atan2pi().
2755 *
2756 * Parameters:
2757 * numerator The numerator
2758 * denominator The denominator. Can be 0.
2759 */
2760#if (defined(RS_VERSION) && (RS_VERSION >= 21))
2761extern float __attribute__((const, overloadable))
2762 native_atan2pi(float numerator, float denominator);
2763#endif
2764
2765#if (defined(RS_VERSION) && (RS_VERSION >= 21))
2766extern float2 __attribute__((const, overloadable))
2767 native_atan2pi(float2 numerator, float2 denominator);
2768#endif
2769
2770#if (defined(RS_VERSION) && (RS_VERSION >= 21))
2771extern float3 __attribute__((const, overloadable))
2772 native_atan2pi(float3 numerator, float3 denominator);
2773#endif
2774
2775#if (defined(RS_VERSION) && (RS_VERSION >= 21))
2776extern float4 __attribute__((const, overloadable))
2777 native_atan2pi(float4 numerator, float4 denominator);
2778#endif
2779
2780/*
2781 * native_atanh: Approximate inverse hyperbolic tangent
2782 *
2783 * Returns the approximate inverse hyperbolic tangent, in radians.
2784 *
2785 * See also atanh().
2786 */
2787#if (defined(RS_VERSION) && (RS_VERSION >= 21))
2788extern float __attribute__((const, overloadable))
2789 native_atanh(float v);
2790#endif
2791
2792#if (defined(RS_VERSION) && (RS_VERSION >= 21))
2793extern float2 __attribute__((const, overloadable))
2794 native_atanh(float2 v);
2795#endif
2796
2797#if (defined(RS_VERSION) && (RS_VERSION >= 21))
2798extern float3 __attribute__((const, overloadable))
2799 native_atanh(float3 v);
2800#endif
2801
2802#if (defined(RS_VERSION) && (RS_VERSION >= 21))
2803extern float4 __attribute__((const, overloadable))
2804 native_atanh(float4 v);
2805#endif
2806
2807/*
2808 * native_atanpi: Approximate inverse tangent divided by pi
2809 *
2810 * Returns the approximate inverse tangent in radians, divided by pi.
2811 *
2812 * To get an inverse tangent measured in degrees, use atanpi(a) * 180.f.
2813 *
2814 * See also atanpi().
2815 */
2816#if (defined(RS_VERSION) && (RS_VERSION >= 21))
2817extern float __attribute__((const, overloadable))
2818 native_atanpi(float v);
2819#endif
2820
2821#if (defined(RS_VERSION) && (RS_VERSION >= 21))
2822extern float2 __attribute__((const, overloadable))
2823 native_atanpi(float2 v);
2824#endif
2825
2826#if (defined(RS_VERSION) && (RS_VERSION >= 21))
2827extern float3 __attribute__((const, overloadable))
2828 native_atanpi(float3 v);
2829#endif
2830
2831#if (defined(RS_VERSION) && (RS_VERSION >= 21))
2832extern float4 __attribute__((const, overloadable))
2833 native_atanpi(float4 v);
2834#endif
2835
2836/*
2837 * native_cbrt: Approximate cube root
2838 *
2839 * Returns the approximate cubic root.
2840 *
2841 * See also cbrt().
2842 */
2843#if (defined(RS_VERSION) && (RS_VERSION >= 21))
2844extern float __attribute__((const, overloadable))
2845 native_cbrt(float v);
2846#endif
2847
2848#if (defined(RS_VERSION) && (RS_VERSION >= 21))
2849extern float2 __attribute__((const, overloadable))
2850 native_cbrt(float2 v);
2851#endif
2852
2853#if (defined(RS_VERSION) && (RS_VERSION >= 21))
2854extern float3 __attribute__((const, overloadable))
2855 native_cbrt(float3 v);
2856#endif
2857
2858#if (defined(RS_VERSION) && (RS_VERSION >= 21))
2859extern float4 __attribute__((const, overloadable))
2860 native_cbrt(float4 v);
2861#endif
2862
2863/*
2864 * native_cos: Approximate cosine
2865 *
2866 * Returns the approximate cosine of an angle measured in radians.
2867 *
2868 * See also cos().
2869 */
2870#if (defined(RS_VERSION) && (RS_VERSION >= 21))
2871extern float __attribute__((const, overloadable))
2872 native_cos(float v);
2873#endif
2874
2875#if (defined(RS_VERSION) && (RS_VERSION >= 21))
2876extern float2 __attribute__((const, overloadable))
2877 native_cos(float2 v);
2878#endif
2879
2880#if (defined(RS_VERSION) && (RS_VERSION >= 21))
2881extern float3 __attribute__((const, overloadable))
2882 native_cos(float3 v);
2883#endif
2884
2885#if (defined(RS_VERSION) && (RS_VERSION >= 21))
2886extern float4 __attribute__((const, overloadable))
2887 native_cos(float4 v);
2888#endif
2889
2890/*
2891 * native_cosh: Approximate hypebolic cosine
2892 *
2893 * Returns the approximate hypebolic cosine.
2894 *
2895 * See also cosh().
2896 */
2897#if (defined(RS_VERSION) && (RS_VERSION >= 21))
2898extern float __attribute__((const, overloadable))
2899 native_cosh(float v);
2900#endif
2901
2902#if (defined(RS_VERSION) && (RS_VERSION >= 21))
2903extern float2 __attribute__((const, overloadable))
2904 native_cosh(float2 v);
2905#endif
2906
2907#if (defined(RS_VERSION) && (RS_VERSION >= 21))
2908extern float3 __attribute__((const, overloadable))
2909 native_cosh(float3 v);
2910#endif
2911
2912#if (defined(RS_VERSION) && (RS_VERSION >= 21))
2913extern float4 __attribute__((const, overloadable))
2914 native_cosh(float4 v);
2915#endif
2916
2917/*
2918 * native_cospi: Approximate cosine of a number multiplied by pi
2919 *
2920 * Returns the approximate cosine of (v * pi), where (v * pi) is measured in radians.
2921 *
2922 * To get the cosine of a value measured in degrees, call cospi(v / 180.f).
2923 *
2924 * See also cospi().
2925 */
2926#if (defined(RS_VERSION) && (RS_VERSION >= 21))
2927extern float __attribute__((const, overloadable))
2928 native_cospi(float v);
2929#endif
2930
2931#if (defined(RS_VERSION) && (RS_VERSION >= 21))
2932extern float2 __attribute__((const, overloadable))
2933 native_cospi(float2 v);
2934#endif
2935
2936#if (defined(RS_VERSION) && (RS_VERSION >= 21))
2937extern float3 __attribute__((const, overloadable))
2938 native_cospi(float3 v);
2939#endif
2940
2941#if (defined(RS_VERSION) && (RS_VERSION >= 21))
2942extern float4 __attribute__((const, overloadable))
2943 native_cospi(float4 v);
2944#endif
2945
2946/*
2947 * native_divide: Approximate division
2948 *
2949 * Computes the approximate division of two values.
2950 */
2951#if (defined(RS_VERSION) && (RS_VERSION >= 21))
2952extern float __attribute__((const, overloadable))
2953 native_divide(float left_vector, float right_vector);
2954#endif
2955
2956#if (defined(RS_VERSION) && (RS_VERSION >= 21))
2957extern float2 __attribute__((const, overloadable))
2958 native_divide(float2 left_vector, float2 right_vector);
2959#endif
2960
2961#if (defined(RS_VERSION) && (RS_VERSION >= 21))
2962extern float3 __attribute__((const, overloadable))
2963 native_divide(float3 left_vector, float3 right_vector);
2964#endif
2965
2966#if (defined(RS_VERSION) && (RS_VERSION >= 21))
2967extern float4 __attribute__((const, overloadable))
2968 native_divide(float4 left_vector, float4 right_vector);
2969#endif
2970
2971/*
2972 * native_exp: Approximate e raised to a number
2973 *
2974 * Fast approximate exp.
2975 *
2976 * It is valid for inputs from -86.f to 86.f. The precision is no worse than what would be expected from using 16 bit floating point values.
2977 *
2978 * See also exp().
2979 */
2980#if (defined(RS_VERSION) && (RS_VERSION >= 18))
2981extern float __attribute__((const, overloadable))
2982 native_exp(float v);
2983#endif
2984
2985#if (defined(RS_VERSION) && (RS_VERSION >= 18))
2986extern float2 __attribute__((const, overloadable))
2987 native_exp(float2 v);
2988#endif
2989
2990#if (defined(RS_VERSION) && (RS_VERSION >= 18))
2991extern float3 __attribute__((const, overloadable))
2992 native_exp(float3 v);
2993#endif
2994
2995#if (defined(RS_VERSION) && (RS_VERSION >= 18))
2996extern float4 __attribute__((const, overloadable))
2997 native_exp(float4 v);
2998#endif
2999
3000/*
3001 * native_exp10: Approximate 10 raised to a number
3002 *
3003 * Fast approximate exp10.
3004 *
3005 * It is valid for inputs from -37.f to 37.f. The precision is no worse than what would be expected from using 16 bit floating point values.
3006 *
3007 * See also exp10().
3008 */
3009#if (defined(RS_VERSION) && (RS_VERSION >= 18))
3010extern float __attribute__((const, overloadable))
3011 native_exp10(float v);
3012#endif
3013
3014#if (defined(RS_VERSION) && (RS_VERSION >= 18))
3015extern float2 __attribute__((const, overloadable))
3016 native_exp10(float2 v);
3017#endif
3018
3019#if (defined(RS_VERSION) && (RS_VERSION >= 18))
3020extern float3 __attribute__((const, overloadable))
3021 native_exp10(float3 v);
3022#endif
3023
3024#if (defined(RS_VERSION) && (RS_VERSION >= 18))
3025extern float4 __attribute__((const, overloadable))
3026 native_exp10(float4 v);
3027#endif
3028
3029/*
3030 * native_exp2: Approximate 2 raised to a number
3031 *
3032 * Fast approximate exp2.
3033 *
3034 * It is valid for inputs from -125.f to 125.f. The precision is no worse than what would be expected from using 16 bit floating point values.
3035 *
3036 * See also exp2().
3037 */
3038#if (defined(RS_VERSION) && (RS_VERSION >= 18))
3039extern float __attribute__((const, overloadable))
3040 native_exp2(float v);
3041#endif
3042
3043#if (defined(RS_VERSION) && (RS_VERSION >= 18))
3044extern float2 __attribute__((const, overloadable))
3045 native_exp2(float2 v);
3046#endif
3047
3048#if (defined(RS_VERSION) && (RS_VERSION >= 18))
3049extern float3 __attribute__((const, overloadable))
3050 native_exp2(float3 v);
3051#endif
3052
3053#if (defined(RS_VERSION) && (RS_VERSION >= 18))
3054extern float4 __attribute__((const, overloadable))
3055 native_exp2(float4 v);
3056#endif
3057
3058/*
3059 * native_expm1: Approximate e raised to a number minus one
3060 *
3061 * Returns the approximate (e ^ v) - 1.
3062 *
3063 * See also expm1().
3064 */
3065#if (defined(RS_VERSION) && (RS_VERSION >= 21))
3066extern float __attribute__((const, overloadable))
3067 native_expm1(float v);
3068#endif
3069
3070#if (defined(RS_VERSION) && (RS_VERSION >= 21))
3071extern float2 __attribute__((const, overloadable))
3072 native_expm1(float2 v);
3073#endif
3074
3075#if (defined(RS_VERSION) && (RS_VERSION >= 21))
3076extern float3 __attribute__((const, overloadable))
3077 native_expm1(float3 v);
3078#endif
3079
3080#if (defined(RS_VERSION) && (RS_VERSION >= 21))
3081extern float4 __attribute__((const, overloadable))
3082 native_expm1(float4 v);
3083#endif
3084
3085/*
3086 * native_hypot: Approximate hypotenuse
3087 *
3088 * Returns the approximate native_sqrt(a * a + b * b)
3089 *
3090 * See also hypot().
3091 */
3092#if (defined(RS_VERSION) && (RS_VERSION >= 21))
3093extern float __attribute__((const, overloadable))
3094 native_hypot(float a, float b);
3095#endif
3096
3097#if (defined(RS_VERSION) && (RS_VERSION >= 21))
3098extern float2 __attribute__((const, overloadable))
3099 native_hypot(float2 a, float2 b);
3100#endif
3101
3102#if (defined(RS_VERSION) && (RS_VERSION >= 21))
3103extern float3 __attribute__((const, overloadable))
3104 native_hypot(float3 a, float3 b);
3105#endif
3106
3107#if (defined(RS_VERSION) && (RS_VERSION >= 21))
3108extern float4 __attribute__((const, overloadable))
3109 native_hypot(float4 a, float4 b);
3110#endif
3111
3112/*
3113 * native_log: Approximate natural logarithm
3114 *
3115 * Fast approximate log.
3116 *
3117 * It is not accurate for values very close to zero.
3118 *
3119 * See also log().
3120 */
3121#if (defined(RS_VERSION) && (RS_VERSION >= 18))
3122extern float __attribute__((const, overloadable))
3123 native_log(float v);
3124#endif
3125
3126#if (defined(RS_VERSION) && (RS_VERSION >= 18))
3127extern float2 __attribute__((const, overloadable))
3128 native_log(float2 v);
3129#endif
3130
3131#if (defined(RS_VERSION) && (RS_VERSION >= 18))
3132extern float3 __attribute__((const, overloadable))
3133 native_log(float3 v);
3134#endif
3135
3136#if (defined(RS_VERSION) && (RS_VERSION >= 18))
3137extern float4 __attribute__((const, overloadable))
3138 native_log(float4 v);
3139#endif
3140
3141/*
3142 * native_log10: Approximate base 10 logarithm
3143 *
3144 * Fast approximate log10.
3145 *
3146 * It is not accurate for values very close to zero.
3147 *
3148 * See also log10().
3149 */
3150#if (defined(RS_VERSION) && (RS_VERSION >= 18))
3151extern float __attribute__((const, overloadable))
3152 native_log10(float v);
3153#endif
3154
3155#if (defined(RS_VERSION) && (RS_VERSION >= 18))
3156extern float2 __attribute__((const, overloadable))
3157 native_log10(float2 v);
3158#endif
3159
3160#if (defined(RS_VERSION) && (RS_VERSION >= 18))
3161extern float3 __attribute__((const, overloadable))
3162 native_log10(float3 v);
3163#endif
3164
3165#if (defined(RS_VERSION) && (RS_VERSION >= 18))
3166extern float4 __attribute__((const, overloadable))
3167 native_log10(float4 v);
3168#endif
3169
3170/*
3171 * native_log1p: Approximate natural logarithm of a value plus 1
3172 *
3173 * Returns the approximate natural logarithm of (v + 1.0f)
3174 *
3175 * See also log1p().
3176 */
3177#if (defined(RS_VERSION) && (RS_VERSION >= 21))
3178extern float __attribute__((const, overloadable))
3179 native_log1p(float v);
3180#endif
3181
3182#if (defined(RS_VERSION) && (RS_VERSION >= 21))
3183extern float2 __attribute__((const, overloadable))
3184 native_log1p(float2 v);
3185#endif
3186
3187#if (defined(RS_VERSION) && (RS_VERSION >= 21))
3188extern float3 __attribute__((const, overloadable))
3189 native_log1p(float3 v);
3190#endif
3191
3192#if (defined(RS_VERSION) && (RS_VERSION >= 21))
3193extern float4 __attribute__((const, overloadable))
3194 native_log1p(float4 v);
3195#endif
3196
3197/*
3198 * native_log2: Approximate base 2 logarithm
3199 *
3200 * Fast approximate log2.
3201 *
3202 * It is not accurate for values very close to zero.
3203 *
3204 * See also log2().
3205 */
3206#if (defined(RS_VERSION) && (RS_VERSION >= 18))
3207extern float __attribute__((const, overloadable))
3208 native_log2(float v);
3209#endif
3210
3211#if (defined(RS_VERSION) && (RS_VERSION >= 18))
3212extern float2 __attribute__((const, overloadable))
3213 native_log2(float2 v);
3214#endif
3215
3216#if (defined(RS_VERSION) && (RS_VERSION >= 18))
3217extern float3 __attribute__((const, overloadable))
3218 native_log2(float3 v);
3219#endif
3220
3221#if (defined(RS_VERSION) && (RS_VERSION >= 18))
3222extern float4 __attribute__((const, overloadable))
3223 native_log2(float4 v);
3224#endif
3225
3226/*
3227 * native_powr: Approximate positive base raised to an exponent
3228 *
3229 * Fast approximate (base ^ exponent).
3230 *
3231 * See also powr().
3232 *
3233 * Parameters:
3234 * base Must be between 0.f and 256.f. The function is not accurate for values very close to zero.
3235 * exponent Must be between -15.f and 15.f.
3236 */
3237#if (defined(RS_VERSION) && (RS_VERSION >= 18))
3238extern float __attribute__((const, overloadable))
3239 native_powr(float base, float exponent);
3240#endif
3241
3242#if (defined(RS_VERSION) && (RS_VERSION >= 18))
3243extern float2 __attribute__((const, overloadable))
3244 native_powr(float2 base, float2 exponent);
3245#endif
3246
3247#if (defined(RS_VERSION) && (RS_VERSION >= 18))
3248extern float3 __attribute__((const, overloadable))
3249 native_powr(float3 base, float3 exponent);
3250#endif
3251
3252#if (defined(RS_VERSION) && (RS_VERSION >= 18))
3253extern float4 __attribute__((const, overloadable))
3254 native_powr(float4 base, float4 exponent);
3255#endif
3256
3257/*
3258 * native_recip: Approximate reciprocal
3259 *
3260 * Returns the approximate approximate reciprocal of a value.
3261 *
3262 * See also half_recip().
3263 */
3264#if (defined(RS_VERSION) && (RS_VERSION >= 21))
3265extern float __attribute__((const, overloadable))
3266 native_recip(float v);
3267#endif
3268
3269#if (defined(RS_VERSION) && (RS_VERSION >= 21))
3270extern float2 __attribute__((const, overloadable))
3271 native_recip(float2 v);
3272#endif
3273
3274#if (defined(RS_VERSION) && (RS_VERSION >= 21))
3275extern float3 __attribute__((const, overloadable))
3276 native_recip(float3 v);
3277#endif
3278
3279#if (defined(RS_VERSION) && (RS_VERSION >= 21))
3280extern float4 __attribute__((const, overloadable))
3281 native_recip(float4 v);
3282#endif
3283
3284/*
3285 * native_rootn: Approximate nth root
3286 *
3287 * Compute the approximate Nth root of a value.
3288 *
3289 * See also rootn().
3290 */
3291#if (defined(RS_VERSION) && (RS_VERSION >= 21))
3292extern float __attribute__((const, overloadable))
3293 native_rootn(float v, int n);
3294#endif
3295
3296#if (defined(RS_VERSION) && (RS_VERSION >= 21))
3297extern float2 __attribute__((const, overloadable))
3298 native_rootn(float2 v, int2 n);
3299#endif
3300
3301#if (defined(RS_VERSION) && (RS_VERSION >= 21))
3302extern float3 __attribute__((const, overloadable))
3303 native_rootn(float3 v, int3 n);
3304#endif
3305
3306#if (defined(RS_VERSION) && (RS_VERSION >= 21))
3307extern float4 __attribute__((const, overloadable))
3308 native_rootn(float4 v, int4 n);
3309#endif
3310
3311/*
3312 * native_rsqrt: Approximate reciprocal of a square root
3313 *
3314 * Returns approximate (1 / sqrt(v)).
3315 *
3316 * See also rsqrt(), half_rsqrt().
3317 */
3318#if (defined(RS_VERSION) && (RS_VERSION >= 21))
3319extern float __attribute__((const, overloadable))
3320 native_rsqrt(float v);
3321#endif
3322
3323#if (defined(RS_VERSION) && (RS_VERSION >= 21))
3324extern float2 __attribute__((const, overloadable))
3325 native_rsqrt(float2 v);
3326#endif
3327
3328#if (defined(RS_VERSION) && (RS_VERSION >= 21))
3329extern float3 __attribute__((const, overloadable))
3330 native_rsqrt(float3 v);
3331#endif
3332
3333#if (defined(RS_VERSION) && (RS_VERSION >= 21))
3334extern float4 __attribute__((const, overloadable))
3335 native_rsqrt(float4 v);
3336#endif
3337
3338/*
3339 * native_sin: Approximate sine
3340 *
3341 * Returns the approximate sine of an angle measured in radians.
3342 *
3343 * See also sin().
3344 */
3345#if (defined(RS_VERSION) && (RS_VERSION >= 21))
3346extern float __attribute__((const, overloadable))
3347 native_sin(float v);
3348#endif
3349
3350#if (defined(RS_VERSION) && (RS_VERSION >= 21))
3351extern float2 __attribute__((const, overloadable))
3352 native_sin(float2 v);
3353#endif
3354
3355#if (defined(RS_VERSION) && (RS_VERSION >= 21))
3356extern float3 __attribute__((const, overloadable))
3357 native_sin(float3 v);
3358#endif
3359
3360#if (defined(RS_VERSION) && (RS_VERSION >= 21))
3361extern float4 __attribute__((const, overloadable))
3362 native_sin(float4 v);
3363#endif
3364
3365/*
3366 * native_sincos: Approximate sine and cosine
3367 *
3368 * Returns the approximate sine and cosine of a value.
3369 *
3370 * See also sincos().
3371 *
3372 * Parameters:
3373 * v The incoming value in radians.
3374 * cos *cos will be set to the cosine value.
3375 *
3376 * Returns: sine
3377 */
3378#if (defined(RS_VERSION) && (RS_VERSION >= 21))
3379extern float __attribute__((overloadable))
3380 native_sincos(float v, float* cos);
3381#endif
3382
3383#if (defined(RS_VERSION) && (RS_VERSION >= 21))
3384extern float2 __attribute__((overloadable))
3385 native_sincos(float2 v, float2* cos);
3386#endif
3387
3388#if (defined(RS_VERSION) && (RS_VERSION >= 21))
3389extern float3 __attribute__((overloadable))
3390 native_sincos(float3 v, float3* cos);
3391#endif
3392
3393#if (defined(RS_VERSION) && (RS_VERSION >= 21))
3394extern float4 __attribute__((overloadable))
3395 native_sincos(float4 v, float4* cos);
3396#endif
3397
3398/*
3399 * native_sinh: Approximate hyperbolic sine
3400 *
3401 * Returns the approximate hyperbolic sine of a value specified in radians.
3402 *
3403 * See also sinh().
3404 */
3405#if (defined(RS_VERSION) && (RS_VERSION >= 21))
3406extern float __attribute__((const, overloadable))
3407 native_sinh(float v);
3408#endif
3409
3410#if (defined(RS_VERSION) && (RS_VERSION >= 21))
3411extern float2 __attribute__((const, overloadable))
3412 native_sinh(float2 v);
3413#endif
3414
3415#if (defined(RS_VERSION) && (RS_VERSION >= 21))
3416extern float3 __attribute__((const, overloadable))
3417 native_sinh(float3 v);
3418#endif
3419
3420#if (defined(RS_VERSION) && (RS_VERSION >= 21))
3421extern float4 __attribute__((const, overloadable))
3422 native_sinh(float4 v);
3423#endif
3424
3425/*
3426 * native_sinpi: Approximate sine of a number multiplied by pi
3427 *
3428 * Returns the approximate sine of (v * pi), where (v * pi) is measured in radians.
3429 *
3430 * To get the sine of a value measured in degrees, call sinpi(v / 180.f).
3431 *
3432 * See also sinpi().
3433 */
3434#if (defined(RS_VERSION) && (RS_VERSION >= 21))
3435extern float __attribute__((const, overloadable))
3436 native_sinpi(float v);
3437#endif
3438
3439#if (defined(RS_VERSION) && (RS_VERSION >= 21))
3440extern float2 __attribute__((const, overloadable))
3441 native_sinpi(float2 v);
3442#endif
3443
3444#if (defined(RS_VERSION) && (RS_VERSION >= 21))
3445extern float3 __attribute__((const, overloadable))
3446 native_sinpi(float3 v);
3447#endif
3448
3449#if (defined(RS_VERSION) && (RS_VERSION >= 21))
3450extern float4 __attribute__((const, overloadable))
3451 native_sinpi(float4 v);
3452#endif
3453
3454/*
3455 * native_sqrt: Approximate square root
3456 *
3457 * Returns the approximate sqrt(v).
3458 *
3459 * See also sqrt(), half_sqrt().
3460 */
3461#if (defined(RS_VERSION) && (RS_VERSION >= 21))
3462extern float __attribute__((const, overloadable))
3463 native_sqrt(float v);
3464#endif
3465
3466#if (defined(RS_VERSION) && (RS_VERSION >= 21))
3467extern float2 __attribute__((const, overloadable))
3468 native_sqrt(float2 v);
3469#endif
3470
3471#if (defined(RS_VERSION) && (RS_VERSION >= 21))
3472extern float3 __attribute__((const, overloadable))
3473 native_sqrt(float3 v);
3474#endif
3475
3476#if (defined(RS_VERSION) && (RS_VERSION >= 21))
3477extern float4 __attribute__((const, overloadable))
3478 native_sqrt(float4 v);
3479#endif
3480
3481/*
3482 * native_tan: Approximate tangent
3483 *
3484 * Returns the approximate tangent of an angle measured in radians.
3485 */
3486#if (defined(RS_VERSION) && (RS_VERSION >= 21))
3487extern float __attribute__((const, overloadable))
3488 native_tan(float v);
3489#endif
3490
3491#if (defined(RS_VERSION) && (RS_VERSION >= 21))
3492extern float2 __attribute__((const, overloadable))
3493 native_tan(float2 v);
3494#endif
3495
3496#if (defined(RS_VERSION) && (RS_VERSION >= 21))
3497extern float3 __attribute__((const, overloadable))
3498 native_tan(float3 v);
3499#endif
3500
3501#if (defined(RS_VERSION) && (RS_VERSION >= 21))
3502extern float4 __attribute__((const, overloadable))
3503 native_tan(float4 v);
3504#endif
3505
3506/*
3507 * native_tanh: Approximate hyperbolic tangent
3508 *
3509 * Returns the approximate hyperbolic tangent of a value.
3510 *
3511 * See also tanh().
3512 */
3513#if (defined(RS_VERSION) && (RS_VERSION >= 21))
3514extern float __attribute__((const, overloadable))
3515 native_tanh(float v);
3516#endif
3517
3518#if (defined(RS_VERSION) && (RS_VERSION >= 21))
3519extern float2 __attribute__((const, overloadable))
3520 native_tanh(float2 v);
3521#endif
3522
3523#if (defined(RS_VERSION) && (RS_VERSION >= 21))
3524extern float3 __attribute__((const, overloadable))
3525 native_tanh(float3 v);
3526#endif
3527
3528#if (defined(RS_VERSION) && (RS_VERSION >= 21))
3529extern float4 __attribute__((const, overloadable))
3530 native_tanh(float4 v);
3531#endif
3532
3533/*
3534 * native_tanpi: Approximate tangent of a number multiplied by pi
3535 *
3536 * Returns the approximate tangent of (v * pi), where (v * pi) is measured in radians.
3537 *
3538 * To get the tangent of a value measured in degrees, call tanpi(v / 180.f).
3539 *
3540 * See also tanpi().
3541 */
3542#if (defined(RS_VERSION) && (RS_VERSION >= 21))
3543extern float __attribute__((const, overloadable))
3544 native_tanpi(float v);
3545#endif
3546
3547#if (defined(RS_VERSION) && (RS_VERSION >= 21))
3548extern float2 __attribute__((const, overloadable))
3549 native_tanpi(float2 v);
3550#endif
3551
3552#if (defined(RS_VERSION) && (RS_VERSION >= 21))
3553extern float3 __attribute__((const, overloadable))
3554 native_tanpi(float3 v);
3555#endif
3556
3557#if (defined(RS_VERSION) && (RS_VERSION >= 21))
3558extern float4 __attribute__((const, overloadable))
3559 native_tanpi(float4 v);
3560#endif
3561
3562/*
3563 * nextafter: Next floating point number
3564 *
3565 * Returns the next representable floating point number from v towards target.
3566 *
3567 * In rs_fp_relaxed mode, a denormalized input value may not yield the next
3568 * denormalized value, as support of denormalized values is optional in
3569 * relaxed mode.
3570 */
3571extern float __attribute__((const, overloadable))
3572 nextafter(float v, float target);
3573
3574extern float2 __attribute__((const, overloadable))
3575 nextafter(float2 v, float2 target);
3576
3577extern float3 __attribute__((const, overloadable))
3578 nextafter(float3 v, float3 target);
3579
3580extern float4 __attribute__((const, overloadable))
3581 nextafter(float4 v, float4 target);
3582
3583/*
3584 * pow: Base raised to an exponent
3585 *
3586 * Returns base raised to the power exponent, i.e. base ^ exponent.
3587 *
3588 * pown() and powr() are similar. pown() takes an integer exponent. powr() assumes the base to be non-negative.
3589 */
3590extern float __attribute__((const, overloadable))
3591 pow(float base, float exponent);
3592
3593extern float2 __attribute__((const, overloadable))
3594 pow(float2 base, float2 exponent);
3595
3596extern float3 __attribute__((const, overloadable))
3597 pow(float3 base, float3 exponent);
3598
3599extern float4 __attribute__((const, overloadable))
3600 pow(float4 base, float4 exponent);
3601
3602/*
3603 * pown: Base raised to an integer exponent
3604 *
3605 * Returns base raised to the power exponent, i.e. base ^ exponent.
3606 *
3607 * pow() and powr() are similar. The both take a float exponent. powr() also assumes the base to be non-negative.
3608 */
3609extern float __attribute__((const, overloadable))
3610 pown(float base, int exponent);
3611
3612extern float2 __attribute__((const, overloadable))
3613 pown(float2 base, int2 exponent);
3614
3615extern float3 __attribute__((const, overloadable))
3616 pown(float3 base, int3 exponent);
3617
3618extern float4 __attribute__((const, overloadable))
3619 pown(float4 base, int4 exponent);
3620
3621/*
3622 * powr: Positive base raised to an exponent
3623 *
3624 * Returns base raised to the power exponent, i.e. base ^ exponent. base must be >= 0.
3625 *
3626 * pow() and pown() are similar. They both make no assumptions about the base. pow() takes a float exponent while pown() take an integer.
3627 *
3628 * See also native_powr().
3629 */
3630extern float __attribute__((const, overloadable))
3631 powr(float base, float exponent);
3632
3633extern float2 __attribute__((const, overloadable))
3634 powr(float2 base, float2 exponent);
3635
3636extern float3 __attribute__((const, overloadable))
3637 powr(float3 base, float3 exponent);
3638
3639extern float4 __attribute__((const, overloadable))
3640 powr(float4 base, float4 exponent);
3641
3642/*
3643 * radians: Converts degrees into radians
3644 *
3645 * Converts from degrees to radians.
3646 */
3647extern float __attribute__((const, overloadable))
3648 radians(float v);
3649
3650extern float2 __attribute__((const, overloadable))
3651 radians(float2 v);
3652
3653extern float3 __attribute__((const, overloadable))
3654 radians(float3 v);
3655
3656extern float4 __attribute__((const, overloadable))
3657 radians(float4 v);
3658
3659/*
3660 * remainder: Remainder of a division
3661 *
3662 * Returns the remainder of (numerator / denominator), where the quotient is rounded towards the nearest integer.
3663 *
3664 * The function fmod() is similar but rounds toward the closest interger.
3665 * For example, fmod(-3.8f, 2.f) returns -1.8f (-3.8f - -1.f * 2.f)
3666 * while remainder(-3.8f, 2.f) returns 0.2f (-3.8f - -2.f * 2.f).
3667 */
3668extern float __attribute__((const, overloadable))
3669 remainder(float numerator, float denominator);
3670
3671extern float2 __attribute__((const, overloadable))
3672 remainder(float2 numerator, float2 denominator);
3673
3674extern float3 __attribute__((const, overloadable))
3675 remainder(float3 numerator, float3 denominator);
3676
3677extern float4 __attribute__((const, overloadable))
3678 remainder(float4 numerator, float4 denominator);
3679
3680/*
3681 * remquo: Remainder and quotient of a division
3682 *
3683 * Returns the quotient and the remainder of (numerator / denominator).
3684 *
3685 * Only the sign and lowest three bits of the quotient are guaranteed to be accurate.
3686 *
3687 * This function is useful for implementing periodic functions. The low three bits of the quotient gives the quadrant and the remainder the distance within the quadrant. For example, an implementation of sin(x) could call remquo(x, PI / 2.f, &quadrant) to reduce very large value of x to something within a limited range.
3688 *
3689 * Example: remquo(-23.5f, 8.f, &quot) sets the lowest three bits of quot to 3 and the sign negative. It returns 0.5f.
3690 *
3691 * Parameters:
3692 * numerator The numerator.
3693 * denominator The denominator.
3694 * quotient *quotient will be set to the integer quotient.
3695 *
3696 * Returns: The remainder, precise only for the low three bits.
3697 */
3698extern float __attribute__((overloadable))
3699 remquo(float numerator, float denominator, int* quotient);
3700
3701extern float2 __attribute__((overloadable))
3702 remquo(float2 numerator, float2 denominator, int2* quotient);
3703
3704extern float3 __attribute__((overloadable))
3705 remquo(float3 numerator, float3 denominator, int3* quotient);
3706
3707extern float4 __attribute__((overloadable))
3708 remquo(float4 numerator, float4 denominator, int4* quotient);
3709
3710/*
3711 * rint: Round to even
3712 *
3713 * Rounds to the nearest integral value.
3714 *
3715 * rint() rounds half values to even. For example, rint(0.5f) returns 0.f and rint(1.5f) returns 2.f. Similarly, rint(-0.5f) returns -0.f and rint(-1.5f) returns -2.f.
3716 *
3717 * round() is similar but rounds away from zero. trunc() truncates the decimal fraction.
3718 */
3719extern float __attribute__((const, overloadable))
3720 rint(float v);
3721
3722extern float2 __attribute__((const, overloadable))
3723 rint(float2 v);
3724
3725extern float3 __attribute__((const, overloadable))
3726 rint(float3 v);
3727
3728extern float4 __attribute__((const, overloadable))
3729 rint(float4 v);
3730
3731/*
3732 * rootn: Nth root
3733 *
3734 * Compute the Nth root of a value.
3735 *
3736 * See also native_rootn().
3737 */
3738extern float __attribute__((const, overloadable))
3739 rootn(float v, int n);
3740
3741extern float2 __attribute__((const, overloadable))
3742 rootn(float2 v, int2 n);
3743
3744extern float3 __attribute__((const, overloadable))
3745 rootn(float3 v, int3 n);
3746
3747extern float4 __attribute__((const, overloadable))
3748 rootn(float4 v, int4 n);
3749
3750/*
3751 * round: Round away from zero
3752 *
3753 * Round to the nearest integral value.
3754 *
3755 * round() rounds half values away from zero. For example, round(0.5f) returns 1.f and round(1.5f) returns 2.f. Similarly, round(-0.5f) returns -1.f and round(-1.5f) returns -2.f.
3756 *
3757 * rint() is similar but rounds half values toward even. trunc() truncates the decimal fraction.
3758 */
3759extern float __attribute__((const, overloadable))
3760 round(float v);
3761
3762extern float2 __attribute__((const, overloadable))
3763 round(float2 v);
3764
3765extern float3 __attribute__((const, overloadable))
3766 round(float3 v);
3767
3768extern float4 __attribute__((const, overloadable))
3769 round(float4 v);
3770
3771/*
3772 * rsqrt: Reciprocal of a square root
3773 *
3774 * Returns (1 / sqrt(v)).
3775 *
3776 * See also half_rsqrt(), native_rsqrt().
3777 */
3778extern float __attribute__((const, overloadable))
3779 rsqrt(float v);
3780
3781extern float2 __attribute__((const, overloadable))
3782 rsqrt(float2 v);
3783
3784extern float3 __attribute__((const, overloadable))
3785 rsqrt(float3 v);
3786
3787extern float4 __attribute__((const, overloadable))
3788 rsqrt(float4 v);
3789
3790/*
3791 * sign: Sign of a value
3792 *
3793 * Returns the sign of a value.
3794 *
3795 * if (v < 0) return -1.f;
3796 * else if (v > 0) return 1.f;
3797 * else return 0.f;
3798 */
3799extern float __attribute__((const, overloadable))
3800 sign(float v);
3801
3802extern float2 __attribute__((const, overloadable))
3803 sign(float2 v);
3804
3805extern float3 __attribute__((const, overloadable))
3806 sign(float3 v);
3807
3808extern float4 __attribute__((const, overloadable))
3809 sign(float4 v);
3810
3811/*
3812 * sin: Sine
3813 *
3814 * Returns the sine of an angle measured in radians.
3815 *
3816 * See also native_sin().
3817 */
3818extern float __attribute__((const, overloadable))
3819 sin(float v);
3820
3821extern float2 __attribute__((const, overloadable))
3822 sin(float2 v);
3823
3824extern float3 __attribute__((const, overloadable))
3825 sin(float3 v);
3826
3827extern float4 __attribute__((const, overloadable))
3828 sin(float4 v);
3829
3830/*
3831 * sincos: Sine and cosine
3832 *
3833 * Returns the sine and cosine of a value.
3834 *
3835 * See also native_sincos().
3836 *
3837 * Parameters:
3838 * v The incoming value in radians
3839 * cos *cos will be set to the cosine value.
3840 *
3841 * Returns: sine of v
3842 */
3843extern float __attribute__((overloadable))
3844 sincos(float v, float* cos);
3845
3846extern float2 __attribute__((overloadable))
3847 sincos(float2 v, float2* cos);
3848
3849extern float3 __attribute__((overloadable))
3850 sincos(float3 v, float3* cos);
3851
3852extern float4 __attribute__((overloadable))
3853 sincos(float4 v, float4* cos);
3854
3855/*
3856 * sinh: Hyperbolic sine
3857 *
3858 * Returns the hyperbolic sine of v, where v is measured in radians.
3859 *
3860 * See also native_sinh().
3861 */
3862extern float __attribute__((const, overloadable))
3863 sinh(float v);
3864
3865extern float2 __attribute__((const, overloadable))
3866 sinh(float2 v);
3867
3868extern float3 __attribute__((const, overloadable))
3869 sinh(float3 v);
3870
3871extern float4 __attribute__((const, overloadable))
3872 sinh(float4 v);
3873
3874/*
3875 * sinpi: Sine of a number multiplied by pi
3876 *
3877 * Returns the sine of (v * pi), where (v * pi) is measured in radians.
3878 *
3879 * To get the sine of a value measured in degrees, call sinpi(v / 180.f).
3880 *
3881 * See also native_sinpi().
3882 */
3883extern float __attribute__((const, overloadable))
3884 sinpi(float v);
3885
3886extern float2 __attribute__((const, overloadable))
3887 sinpi(float2 v);
3888
3889extern float3 __attribute__((const, overloadable))
3890 sinpi(float3 v);
3891
3892extern float4 __attribute__((const, overloadable))
3893 sinpi(float4 v);
3894
3895/*
3896 * sqrt: Square root
3897 *
3898 * Returns the square root of a value.
3899 *
3900 * See also half_sqrt(), native_sqrt().
3901 */
3902extern float __attribute__((const, overloadable))
3903 sqrt(float v);
3904
3905extern float2 __attribute__((const, overloadable))
3906 sqrt(float2 v);
3907
3908extern float3 __attribute__((const, overloadable))
3909 sqrt(float3 v);
3910
3911extern float4 __attribute__((const, overloadable))
3912 sqrt(float4 v);
3913
3914/*
3915 * step: 0 if less than a value, 0 otherwise
3916 *
3917 * Returns 0.f if v < edge, 1.f otherwise.
3918 *
3919 * This can be useful to create conditional computations without using loops and branching instructions. For example, instead of computing (a[i] < b[i]) ? 0.f : atan2(a[i], b[i]) for the corresponding elements of a vector, you could instead use step(a, b) * atan2(a, b).
3920 */
3921extern float __attribute__((const, overloadable))
3922 step(float edge, float v);
3923
3924extern float2 __attribute__((const, overloadable))
3925 step(float2 edge, float2 v);
3926
3927extern float3 __attribute__((const, overloadable))
3928 step(float3 edge, float3 v);
3929
3930extern float4 __attribute__((const, overloadable))
3931 step(float4 edge, float4 v);
3932
3933extern float2 __attribute__((const, overloadable))
3934 step(float2 edge, float v);
3935
3936extern float3 __attribute__((const, overloadable))
3937 step(float3 edge, float v);
3938
3939extern float4 __attribute__((const, overloadable))
3940 step(float4 edge, float v);
3941
3942#if (defined(RS_VERSION) && (RS_VERSION >= 21))
3943extern float2 __attribute__((const, overloadable))
3944 step(float edge, float2 v);
3945#endif
3946
3947#if (defined(RS_VERSION) && (RS_VERSION >= 21))
3948extern float3 __attribute__((const, overloadable))
3949 step(float edge, float3 v);
3950#endif
3951
3952#if (defined(RS_VERSION) && (RS_VERSION >= 21))
3953extern float4 __attribute__((const, overloadable))
3954 step(float edge, float4 v);
3955#endif
3956
3957/*
3958 * tan: Tangent
3959 *
3960 * Returns the tangent of an angle measured in radians.
3961 *
3962 * See also native_tan().
3963 */
3964extern float __attribute__((const, overloadable))
3965 tan(float v);
3966
3967extern float2 __attribute__((const, overloadable))
3968 tan(float2 v);
3969
3970extern float3 __attribute__((const, overloadable))
3971 tan(float3 v);
3972
3973extern float4 __attribute__((const, overloadable))
3974 tan(float4 v);
3975
3976/*
3977 * tanh: Hyperbolic tangent
3978 *
3979 * Returns the hyperbolic tangent of a value.
3980 *
3981 * See also native_tanh().
3982 */
3983extern float __attribute__((const, overloadable))
3984 tanh(float v);
3985
3986extern float2 __attribute__((const, overloadable))
3987 tanh(float2 v);
3988
3989extern float3 __attribute__((const, overloadable))
3990 tanh(float3 v);
3991
3992extern float4 __attribute__((const, overloadable))
3993 tanh(float4 v);
3994
3995/*
3996 * tanpi: Tangent of a number multiplied by pi
3997 *
3998 * Returns the tangent of (v * pi), where (v * pi) is measured in radians.
3999 *
4000 * To get the tangent of a value measured in degrees, call tanpi(v / 180.f).
4001 *
4002 * See also native_tanpi().
4003 */
4004extern float __attribute__((const, overloadable))
4005 tanpi(float v);
4006
4007extern float2 __attribute__((const, overloadable))
4008 tanpi(float2 v);
4009
4010extern float3 __attribute__((const, overloadable))
4011 tanpi(float3 v);
4012
4013extern float4 __attribute__((const, overloadable))
4014 tanpi(float4 v);
4015
4016/*
4017 * tgamma: Gamma function
4018 *
4019 * Returns the gamma function of a value.
4020 *
4021 * See also lgamma().
4022 */
4023extern float __attribute__((const, overloadable))
4024 tgamma(float v);
4025
4026extern float2 __attribute__((const, overloadable))
4027 tgamma(float2 v);
4028
4029extern float3 __attribute__((const, overloadable))
4030 tgamma(float3 v);
4031
4032extern float4 __attribute__((const, overloadable))
4033 tgamma(float4 v);
4034
4035/*
4036 * trunc: Truncates a floating point
4037 *
4038 * Rounds to integral using truncation.
4039 *
4040 * For example, trunc(1.7f) returns 1.f and trunc(-1.7f) returns -1.f.
4041 *
4042 * See rint() and round() for other rounding options.
4043 */
4044extern float __attribute__((const, overloadable))
4045 trunc(float v);
4046
4047extern float2 __attribute__((const, overloadable))
4048 trunc(float2 v);
4049
4050extern float3 __attribute__((const, overloadable))
4051 trunc(float3 v);
4052
4053extern float4 __attribute__((const, overloadable))
4054 trunc(float4 v);
4055
4056/*
Jean-Luc Brouilletc5184e22015-03-13 13:51:24 -0700[diff] [blame]4057 * rsClamp: Restrain a value to a range
Jason Sams9df3b2b2011-08-08 14:31:25 -0700[diff] [blame]4058 *
Jean-Luc Brouilletc5184e22015-03-13 13:51:24 -0700[diff] [blame]4059 * Clamp a value between low and high.
Jason Sams044e2ee2011-08-08 16:52:30 -0700[diff] [blame]4060 *
Jean-Luc Brouilletc5184e22015-03-13 13:51:24 -0700[diff] [blame]4061 * Deprecated. Use clamp() instead.
4062 *
4063 * Parameters:
4064 * amount The value to clamp
4065 * low Lower bound
4066 * high Upper bound
Jason Sams9df3b2b2011-08-08 14:31:25 -0700[diff] [blame]4067 */
Jean-Luc Brouilletc5184e22015-03-13 13:51:24 -0700[diff] [blame]4068extern char __attribute__((const, always_inline, overloadable))
4069 rsClamp(char amount, char low, char high);
Jason Sams044e2ee2011-08-08 16:52:30 -0700[diff] [blame]4070
Jean-Luc Brouilletc5184e22015-03-13 13:51:24 -0700[diff] [blame]4071extern uchar __attribute__((const, always_inline, overloadable))
4072 rsClamp(uchar amount, uchar low, uchar high);
Jason Samsc61346b2010-05-28 18:23:22 -0700[diff] [blame]4073
Jean-Luc Brouilletc5184e22015-03-13 13:51:24 -0700[diff] [blame]4074extern short __attribute__((const, always_inline, overloadable))
4075 rsClamp(short amount, short low, short high);
Jason Samse1eb6152011-06-21 16:42:30 -0700[diff] [blame]4076
Jean-Luc Brouilletc5184e22015-03-13 13:51:24 -0700[diff] [blame]4077extern ushort __attribute__((const, always_inline, overloadable))
4078 rsClamp(ushort amount, ushort low, ushort high);
4079
4080extern int __attribute__((const, always_inline, overloadable))
4081 rsClamp(int amount, int low, int high);
4082
4083extern uint __attribute__((const, always_inline, overloadable))
4084 rsClamp(uint amount, uint low, uint high);
4085
4086/*
Jean-Luc Brouilletc5184e22015-03-13 13:51:24 -0700[diff] [blame]4087 * Returns the fractional part of a float
Jason Samse1eb6152011-06-21 16:42:30 -0700[diff] [blame]4088 */
Jean-Luc Brouilletc5184e22015-03-13 13:51:24 -0700[diff] [blame]4089extern float __attribute__((const, overloadable))
4090 rsFrac(float v);
Jason Sams044e2ee2011-08-08 16:52:30 -0700[diff] [blame]4091
Jean-Luc Brouilletc5184e22015-03-13 13:51:24 -0700[diff] [blame]4092/*
Jean-Luc Brouilletc5184e22015-03-13 13:51:24 -0700[diff] [blame]4093 * Return a random value between 0 (or min_value) and max_malue.
Jason Samse1eb6152011-06-21 16:42:30 -0700[diff] [blame]4094 */
Jean-Luc Brouilletc5184e22015-03-13 13:51:24 -0700[diff] [blame]4095extern int __attribute__((overloadable))
4096 rsRand(int max_value);
Jason Samse1eb6152011-06-21 16:42:30 -0700[diff] [blame]4097
Jean-Luc Brouilletc5184e22015-03-13 13:51:24 -0700[diff] [blame]4098extern int __attribute__((overloadable))
4099 rsRand(int min_value, int max_value);
Jason Samse1eb6152011-06-21 16:42:30 -0700[diff] [blame]4100
Jean-Luc Brouilletc5184e22015-03-13 13:51:24 -0700[diff] [blame]4101extern float __attribute__((overloadable))
4102 rsRand(float max_value);
Jason Samse1eb6152011-06-21 16:42:30 -0700[diff] [blame]4103
Jean-Luc Brouilletc5184e22015-03-13 13:51:24 -0700[diff] [blame]4104extern float __attribute__((overloadable))
4105 rsRand(float min_value, float max_value);
4106
Jean-Luc Brouilletc5184e22015-03-13 13:51:24 -0700[diff] [blame]4107#endif // RENDERSCRIPT_RS_MATH_RSH