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