Gitiles
Code Review Sign In
gerrit-public.fairphone.software / platform / frameworks / rs / 6386ceb3bf25e442513224aaa45691dfe49562d9 / . / scriptc / rs_math.rsh
blob: 7ab69756c70d8632b76ad9e75eba9c78d08e880e [file] [log] [blame]
Jason Sams044e2ee2011-08-08 16:52:30 -0700[diff] [blame]1/*
Jean-Luc Brouilletc5184e22015-03-13 13:51:24 -0700[diff] [blame]2 * Copyright (C) 2015 The Android Open Source Project
Jason Sams044e2ee2011-08-08 16:52:30 -0700[diff] [blame]3 *
4 * Licensed under the Apache License, Version 2.0 (the "License");
5 * you may not use this file except in compliance with the License.
6 * You may obtain a copy of the License at
7 *
8 * http://www.apache.org/licenses/LICENSE-2.0
9 *
10 * Unless required by applicable law or agreed to in writing, software
11 * distributed under the License is distributed on an "AS IS" BASIS,
12 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
13 * See the License for the specific language governing permissions and
14 * limitations under the License.
15 */
16
Jean-Luc Brouillet4a730042015-04-02 16:15:25 -0700[diff] [blame]17// Don't edit this file! It is auto-generated by frameworks/rs/api/generate.sh.
Jean-Luc Brouilletc5184e22015-03-13 13:51:24 -0700[diff] [blame]18
19/*
Jean-Luc Brouillet20b27d62015-04-03 14:39:53 -0700[diff] [blame]20 * rs_math.rsh: Mathematical Constants and Functions
Jason Sams9df3b2b2011-08-08 14:31:25 -0700[diff] [blame]21 *
Jean-Luc Brouillet6386ceb2015-04-28 15:06:30 -0700[diff] [blame^]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.
Jean-Luc Brouilletbe216382015-03-22 12:44:27 -0700[diff] [blame]24 *
25 * For example:
Jean-Luc Brouilletbe216382015-03-22 12:44:27 -0700[diff] [blame]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 *
Jean-Luc Brouillet6386ceb2015-04-28 15:06:30 -0700[diff] [blame^]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.
Jean-Luc Brouilletbe216382015-03-22 12:44:27 -0700[diff] [blame]36 *
Jean-Luc Brouillet6386ceb2015-04-28 15:06:30 -0700[diff] [blame^]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.
Jean-Luc Brouilletbe216382015-03-22 12:44:27 -0700[diff] [blame]42 *
Jean-Luc Brouillet6386ceb2015-04-28 15:06:30 -0700[diff] [blame^]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.
Jean-Luc Brouilletbe216382015-03-22 12:44:27 -0700[diff] [blame]50 *
Jean-Luc Brouilletc5184e22015-03-13 13:51:24 -0700[diff] [blame]51 */
Jean-Luc Brouillet4a730042015-04-02 16:15:25 -0700[diff] [blame]52
Jean-Luc Brouilletc5184e22015-03-13 13:51:24 -0700[diff] [blame]53#ifndef RENDERSCRIPT_RS_MATH_RSH
54#define RENDERSCRIPT_RS_MATH_RSH
55
56/*
Jean-Luc Brouilletbe216382015-03-22 12:44:27 -0700[diff] [blame]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/*
Jean-Luc Brouillet20b27d62015-04-03 14:39:53 -0700[diff] [blame]71 * M_2_PIl: 2 / pi, as a 32 bit float
Jean-Luc Brouilletbe216382015-03-22 12:44:27 -0700[diff] [blame]72 *
Jean-Luc Brouillet20b27d62015-04-03 14:39:53 -0700[diff] [blame]73 * DEPRECATED. Do not use.
74 *
75 * 2 divided by pi, as a 32 bit float.
Jean-Luc Brouilletbe216382015-03-22 12:44:27 -0700[diff] [blame]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:
Jean-Luc Brouillet6386ceb2015-04-28 15:06:30 -0700[diff] [blame^]344 * numerator: Numerator.
345 * denominator: Denominator. Can be 0.
Jean-Luc Brouilletbe216382015-03-22 12:44:27 -0700[diff] [blame]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:
Jean-Luc Brouillet6386ceb2015-04-28 15:06:30 -0700[diff] [blame^]369 * numerator: Numerator.
370 * denominator: Denominator. Can be 0.
Jean-Luc Brouilletbe216382015-03-22 12:44:27 -0700[diff] [blame]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:
Jean-Luc Brouillet4a730042015-04-02 16:15:25 -0700[diff] [blame]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.
Jean-Luc Brouilletbe216382015-03-22 12:44:27 -0700[diff] [blame]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 *
Jean-Luc Brouillet6386ceb2015-04-28 15:06:30 -0700[diff] [blame^]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.
Jean-Luc Brouilletbe216382015-03-22 12:44:27 -0700[diff] [blame]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:
Jean-Luc Brouillet4a730042015-04-02 16:15:25 -0700[diff] [blame]1233 * v: Input value.
1234 * floor: If floor is not null, *floor will be set to the floor of v.
Jean-Luc Brouilletbe216382015-03-22 12:44:27 -0700[diff] [blame]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:
Jean-Luc Brouillet4a730042015-04-02 16:15:25 -0700[diff] [blame]1282 * v: Input value.
1283 * exponent: If exponent is not null, *exponent will be set to the exponent of v.
Jean-Luc Brouilletbe216382015-03-22 12:44:27 -0700[diff] [blame]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 *
Jean-Luc Brouillet6386ceb2015-04-28 15:06:30 -0700[diff] [blame^]1411 * Because of the difference in mantissa, this number is one less than is returned by frexp().
Jean-Luc Brouilletbe216382015-03-22 12:44:27 -0700[diff] [blame]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:
Jean-Luc Brouillet6386ceb2015-04-28 15:06:30 -0700[diff] [blame^]1436 * mantissa: Mantissa.
1437 * exponent: Exponent, a single component or matching vector.
Jean-Luc Brouilletbe216382015-03-22 12:44:27 -0700[diff] [blame]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:
Jean-Luc Brouillet4a730042015-04-02 16:15:25 -0700[diff] [blame]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.
Jean-Luc Brouilletbe216382015-03-22 12:44:27 -0700[diff] [blame]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 *
Jean-Luc Brouillet6386ceb2015-04-28 15:06:30 -0700[diff] [blame^]1579 * Because of the difference in mantissa, this number is one less than is returned by frexp().
Jean-Luc Brouilletbe216382015-03-22 12:44:27 -0700[diff] [blame]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 *
Jean-Luc Brouillet6386ceb2015-04-28 15:06:30 -0700[diff] [blame^]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.
Jean-Luc Brouilletbe216382015-03-22 12:44:27 -0700[diff] [blame]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
1633#if !defined(RS_VERSION) || (RS_VERSION <= 20)
1634static inline char __attribute__((const, overloadable))
1635 max(char a, char b) {
1636 return (a > b ? a : b);
1637}
1638#endif
1639
1640#if !defined(RS_VERSION) || (RS_VERSION <= 20)
1641static inline uchar __attribute__((const, overloadable))
1642 max(uchar a, uchar b) {
1643 return (a > b ? a : b);
1644}
1645#endif
1646
1647#if !defined(RS_VERSION) || (RS_VERSION <= 20)
1648static inline short __attribute__((const, overloadable))
1649 max(short a, short b) {
1650 return (a > b ? a : b);
1651}
1652#endif
1653
1654#if !defined(RS_VERSION) || (RS_VERSION <= 20)
1655static inline ushort __attribute__((const, overloadable))
1656 max(ushort a, ushort b) {
1657 return (a > b ? a : b);
1658}
1659#endif
1660
1661#if !defined(RS_VERSION) || (RS_VERSION <= 20)
1662static inline int __attribute__((const, overloadable))
1663 max(int a, int b) {
1664 return (a > b ? a : b);
1665}
1666#endif
1667
1668#if !defined(RS_VERSION) || (RS_VERSION <= 20)
1669static inline uint __attribute__((const, overloadable))
1670 max(uint a, uint b) {
1671 return (a > b ? a : b);
1672}
1673#endif
1674
1675#if !defined(RS_VERSION) || (RS_VERSION <= 20)
1676static inline char2 __attribute__((const, overloadable))
1677 max(char2 a, char2 b) {
1678 char2 tmp;
1679 tmp.x = (a.x > b.x ? a.x : b.x);
1680 tmp.y = (a.y > b.y ? a.y : b.y);
1681 return tmp;
1682}
1683#endif
1684
1685#if !defined(RS_VERSION) || (RS_VERSION <= 20)
1686static inline uchar2 __attribute__((const, overloadable))
1687 max(uchar2 a, uchar2 b) {
1688 uchar2 tmp;
1689 tmp.x = (a.x > b.x ? a.x : b.x);
1690 tmp.y = (a.y > b.y ? a.y : b.y);
1691 return tmp;
1692}
1693#endif
1694
1695#if !defined(RS_VERSION) || (RS_VERSION <= 20)
1696static inline short2 __attribute__((const, overloadable))
1697 max(short2 a, short2 b) {
1698 short2 tmp;
1699 tmp.x = (a.x > b.x ? a.x : b.x);
1700 tmp.y = (a.y > b.y ? a.y : b.y);
1701 return tmp;
1702}
1703#endif
1704
1705#if !defined(RS_VERSION) || (RS_VERSION <= 20)
1706static inline ushort2 __attribute__((const, overloadable))
1707 max(ushort2 a, ushort2 b) {
1708 ushort2 tmp;
1709 tmp.x = (a.x > b.x ? a.x : b.x);
1710 tmp.y = (a.y > b.y ? a.y : b.y);
1711 return tmp;
1712}
1713#endif
1714
1715#if !defined(RS_VERSION) || (RS_VERSION <= 20)
1716static inline int2 __attribute__((const, overloadable))
1717 max(int2 a, int2 b) {
1718 int2 tmp;
1719 tmp.x = (a.x > b.x ? a.x : b.x);
1720 tmp.y = (a.y > b.y ? a.y : b.y);
1721 return tmp;
1722}
1723#endif
1724
1725#if !defined(RS_VERSION) || (RS_VERSION <= 20)
1726static inline uint2 __attribute__((const, overloadable))
1727 max(uint2 a, uint2 b) {
1728 uint2 tmp;
1729 tmp.x = (a.x > b.x ? a.x : b.x);
1730 tmp.y = (a.y > b.y ? a.y : b.y);
1731 return tmp;
1732}
1733#endif
1734
1735#if !defined(RS_VERSION) || (RS_VERSION <= 20)
1736static inline char3 __attribute__((const, overloadable))
1737 max(char3 a, char3 b) {
1738 char3 tmp;
1739 tmp.x = (a.x > b.x ? a.x : b.x);
1740 tmp.y = (a.y > b.y ? a.y : b.y);
1741 tmp.z = (a.z > b.z ? a.z : b.z);
1742 return tmp;
1743}
1744#endif
1745
1746#if !defined(RS_VERSION) || (RS_VERSION <= 20)
1747static inline uchar3 __attribute__((const, overloadable))
1748 max(uchar3 a, uchar3 b) {
1749 uchar3 tmp;
1750 tmp.x = (a.x > b.x ? a.x : b.x);
1751 tmp.y = (a.y > b.y ? a.y : b.y);
1752 tmp.z = (a.z > b.z ? a.z : b.z);
1753 return tmp;
1754}
1755#endif
1756
1757#if !defined(RS_VERSION) || (RS_VERSION <= 20)
1758static inline short3 __attribute__((const, overloadable))
1759 max(short3 a, short3 b) {
1760 short3 tmp;
1761 tmp.x = (a.x > b.x ? a.x : b.x);
1762 tmp.y = (a.y > b.y ? a.y : b.y);
1763 tmp.z = (a.z > b.z ? a.z : b.z);
1764 return tmp;
1765}
1766#endif
1767
1768#if !defined(RS_VERSION) || (RS_VERSION <= 20)
1769static inline ushort3 __attribute__((const, overloadable))
1770 max(ushort3 a, ushort3 b) {
1771 ushort3 tmp;
1772 tmp.x = (a.x > b.x ? a.x : b.x);
1773 tmp.y = (a.y > b.y ? a.y : b.y);
1774 tmp.z = (a.z > b.z ? a.z : b.z);
1775 return tmp;
1776}
1777#endif
1778
1779#if !defined(RS_VERSION) || (RS_VERSION <= 20)
1780static inline int3 __attribute__((const, overloadable))
1781 max(int3 a, int3 b) {
1782 int3 tmp;
1783 tmp.x = (a.x > b.x ? a.x : b.x);
1784 tmp.y = (a.y > b.y ? a.y : b.y);
1785 tmp.z = (a.z > b.z ? a.z : b.z);
1786 return tmp;
1787}
1788#endif
1789
1790#if !defined(RS_VERSION) || (RS_VERSION <= 20)
1791static inline uint3 __attribute__((const, overloadable))
1792 max(uint3 a, uint3 b) {
1793 uint3 tmp;
1794 tmp.x = (a.x > b.x ? a.x : b.x);
1795 tmp.y = (a.y > b.y ? a.y : b.y);
1796 tmp.z = (a.z > b.z ? a.z : b.z);
1797 return tmp;
1798}
1799#endif
1800
1801#if !defined(RS_VERSION) || (RS_VERSION <= 20)
1802static inline char4 __attribute__((const, overloadable))
1803 max(char4 a, char4 b) {
1804 char4 tmp;
1805 tmp.x = (a.x > b.x ? a.x : b.x);
1806 tmp.y = (a.y > b.y ? a.y : b.y);
1807 tmp.z = (a.z > b.z ? a.z : b.z);
1808 tmp.w = (a.w > b.w ? a.w : b.w);
1809 return tmp;
1810}
1811#endif
1812
1813#if !defined(RS_VERSION) || (RS_VERSION <= 20)
1814static inline uchar4 __attribute__((const, overloadable))
1815 max(uchar4 a, uchar4 b) {
1816 uchar4 tmp;
1817 tmp.x = (a.x > b.x ? a.x : b.x);
1818 tmp.y = (a.y > b.y ? a.y : b.y);
1819 tmp.z = (a.z > b.z ? a.z : b.z);
1820 tmp.w = (a.w > b.w ? a.w : b.w);
1821 return tmp;
1822}
1823#endif
1824
1825#if !defined(RS_VERSION) || (RS_VERSION <= 20)
1826static inline short4 __attribute__((const, overloadable))
1827 max(short4 a, short4 b) {
1828 short4 tmp;
1829 tmp.x = (a.x > b.x ? a.x : b.x);
1830 tmp.y = (a.y > b.y ? a.y : b.y);
1831 tmp.z = (a.z > b.z ? a.z : b.z);
1832 tmp.w = (a.w > b.w ? a.w : b.w);
1833 return tmp;
1834}
1835#endif
1836
1837#if !defined(RS_VERSION) || (RS_VERSION <= 20)
1838static inline ushort4 __attribute__((const, overloadable))
1839 max(ushort4 a, ushort4 b) {
1840 ushort4 tmp;
1841 tmp.x = (a.x > b.x ? a.x : b.x);
1842 tmp.y = (a.y > b.y ? a.y : b.y);
1843 tmp.z = (a.z > b.z ? a.z : b.z);
1844 tmp.w = (a.w > b.w ? a.w : b.w);
1845 return tmp;
1846}
1847#endif
1848
1849#if !defined(RS_VERSION) || (RS_VERSION <= 20)
1850static inline int4 __attribute__((const, overloadable))
1851 max(int4 a, int4 b) {
1852 int4 tmp;
1853 tmp.x = (a.x > b.x ? a.x : b.x);
1854 tmp.y = (a.y > b.y ? a.y : b.y);
1855 tmp.z = (a.z > b.z ? a.z : b.z);
1856 tmp.w = (a.w > b.w ? a.w : b.w);
1857 return tmp;
1858}
1859#endif
1860
1861#if !defined(RS_VERSION) || (RS_VERSION <= 20)
1862static inline uint4 __attribute__((const, overloadable))
1863 max(uint4 a, uint4 b) {
1864 uint4 tmp;
1865 tmp.x = (a.x > b.x ? a.x : b.x);
1866 tmp.y = (a.y > b.y ? a.y : b.y);
1867 tmp.z = (a.z > b.z ? a.z : b.z);
1868 tmp.w = (a.w > b.w ? a.w : b.w);
1869 return tmp;
1870}
1871#endif
1872
1873#if (defined(RS_VERSION) && (RS_VERSION >= 21))
1874extern char __attribute__((const, overloadable))
1875 max(char a, char b);
1876#endif
1877
1878#if (defined(RS_VERSION) && (RS_VERSION >= 21))
1879extern char2 __attribute__((const, overloadable))
1880 max(char2 a, char2 b);
1881#endif
1882
1883#if (defined(RS_VERSION) && (RS_VERSION >= 21))
1884extern char3 __attribute__((const, overloadable))
1885 max(char3 a, char3 b);
1886#endif
1887
1888#if (defined(RS_VERSION) && (RS_VERSION >= 21))
1889extern char4 __attribute__((const, overloadable))
1890 max(char4 a, char4 b);
1891#endif
1892
1893#if (defined(RS_VERSION) && (RS_VERSION >= 21))
1894extern uchar __attribute__((const, overloadable))
1895 max(uchar a, uchar b);
1896#endif
1897
1898#if (defined(RS_VERSION) && (RS_VERSION >= 21))
1899extern uchar2 __attribute__((const, overloadable))
1900 max(uchar2 a, uchar2 b);
1901#endif
1902
1903#if (defined(RS_VERSION) && (RS_VERSION >= 21))
1904extern uchar3 __attribute__((const, overloadable))
1905 max(uchar3 a, uchar3 b);
1906#endif
1907
1908#if (defined(RS_VERSION) && (RS_VERSION >= 21))
1909extern uchar4 __attribute__((const, overloadable))
1910 max(uchar4 a, uchar4 b);
1911#endif
1912
1913#if (defined(RS_VERSION) && (RS_VERSION >= 21))
1914extern short __attribute__((const, overloadable))
1915 max(short a, short b);
1916#endif
1917
1918#if (defined(RS_VERSION) && (RS_VERSION >= 21))
1919extern short2 __attribute__((const, overloadable))
1920 max(short2 a, short2 b);
1921#endif
1922
1923#if (defined(RS_VERSION) && (RS_VERSION >= 21))
1924extern short3 __attribute__((const, overloadable))
1925 max(short3 a, short3 b);
1926#endif
1927
1928#if (defined(RS_VERSION) && (RS_VERSION >= 21))
1929extern short4 __attribute__((const, overloadable))
1930 max(short4 a, short4 b);
1931#endif
1932
1933#if (defined(RS_VERSION) && (RS_VERSION >= 21))
1934extern ushort __attribute__((const, overloadable))
1935 max(ushort a, ushort b);
1936#endif
1937
1938#if (defined(RS_VERSION) && (RS_VERSION >= 21))
1939extern ushort2 __attribute__((const, overloadable))
1940 max(ushort2 a, ushort2 b);
1941#endif
1942
1943#if (defined(RS_VERSION) && (RS_VERSION >= 21))
1944extern ushort3 __attribute__((const, overloadable))
1945 max(ushort3 a, ushort3 b);
1946#endif
1947
1948#if (defined(RS_VERSION) && (RS_VERSION >= 21))
1949extern ushort4 __attribute__((const, overloadable))
1950 max(ushort4 a, ushort4 b);
1951#endif
1952
1953#if (defined(RS_VERSION) && (RS_VERSION >= 21))
1954extern int __attribute__((const, overloadable))
1955 max(int a, int b);
1956#endif
1957
1958#if (defined(RS_VERSION) && (RS_VERSION >= 21))
1959extern int2 __attribute__((const, overloadable))
1960 max(int2 a, int2 b);
1961#endif
1962
1963#if (defined(RS_VERSION) && (RS_VERSION >= 21))
1964extern int3 __attribute__((const, overloadable))
1965 max(int3 a, int3 b);
1966#endif
1967
1968#if (defined(RS_VERSION) && (RS_VERSION >= 21))
1969extern int4 __attribute__((const, overloadable))
1970 max(int4 a, int4 b);
1971#endif
1972
1973#if (defined(RS_VERSION) && (RS_VERSION >= 21))
1974extern uint __attribute__((const, overloadable))
1975 max(uint a, uint b);
1976#endif
1977
1978#if (defined(RS_VERSION) && (RS_VERSION >= 21))
1979extern uint2 __attribute__((const, overloadable))
1980 max(uint2 a, uint2 b);
1981#endif
1982
1983#if (defined(RS_VERSION) && (RS_VERSION >= 21))
1984extern uint3 __attribute__((const, overloadable))
1985 max(uint3 a, uint3 b);
1986#endif
1987
1988#if (defined(RS_VERSION) && (RS_VERSION >= 21))
1989extern uint4 __attribute__((const, overloadable))
1990 max(uint4 a, uint4 b);
1991#endif
1992
1993#if (defined(RS_VERSION) && (RS_VERSION >= 21))
1994extern long __attribute__((const, overloadable))
1995 max(long a, long b);
1996#endif
1997
1998#if (defined(RS_VERSION) && (RS_VERSION >= 21))
1999extern long2 __attribute__((const, overloadable))
2000 max(long2 a, long2 b);
2001#endif
2002
2003#if (defined(RS_VERSION) && (RS_VERSION >= 21))
2004extern long3 __attribute__((const, overloadable))
2005 max(long3 a, long3 b);
2006#endif
2007
2008#if (defined(RS_VERSION) && (RS_VERSION >= 21))
2009extern long4 __attribute__((const, overloadable))
2010 max(long4 a, long4 b);
2011#endif
2012
2013#if (defined(RS_VERSION) && (RS_VERSION >= 21))
2014extern ulong __attribute__((const, overloadable))
2015 max(ulong a, ulong b);
2016#endif
2017
2018#if (defined(RS_VERSION) && (RS_VERSION >= 21))
2019extern ulong2 __attribute__((const, overloadable))
2020 max(ulong2 a, ulong2 b);
2021#endif
2022
2023#if (defined(RS_VERSION) && (RS_VERSION >= 21))
2024extern ulong3 __attribute__((const, overloadable))
2025 max(ulong3 a, ulong3 b);
2026#endif
2027
2028#if (defined(RS_VERSION) && (RS_VERSION >= 21))
2029extern ulong4 __attribute__((const, overloadable))
2030 max(ulong4 a, ulong4 b);
2031#endif
2032
2033/*
2034 * min: Minimum
2035 *
2036 * Returns the minimum value of two arguments.
2037 */
2038extern float __attribute__((const, overloadable))
2039 min(float a, float b);
2040
2041extern float2 __attribute__((const, overloadable))
2042 min(float2 a, float2 b);
2043
2044extern float3 __attribute__((const, overloadable))
2045 min(float3 a, float3 b);
2046
2047extern float4 __attribute__((const, overloadable))
2048 min(float4 a, float4 b);
2049
2050#if !defined(RS_VERSION) || (RS_VERSION <= 20)
2051static inline char __attribute__((const, overloadable))
2052 min(char a, char b) {
2053 return (a < b ? a : b);
2054}
2055#endif
2056
2057#if !defined(RS_VERSION) || (RS_VERSION <= 20)
2058static inline uchar __attribute__((const, overloadable))
2059 min(uchar a, uchar b) {
2060 return (a < b ? a : b);
2061}
2062#endif
2063
2064#if !defined(RS_VERSION) || (RS_VERSION <= 20)
2065static inline short __attribute__((const, overloadable))
2066 min(short a, short b) {
2067 return (a < b ? a : b);
2068}
2069#endif
2070
2071#if !defined(RS_VERSION) || (RS_VERSION <= 20)
2072static inline ushort __attribute__((const, overloadable))
2073 min(ushort a, ushort b) {
2074 return (a < b ? a : b);
2075}
2076#endif
2077
2078#if !defined(RS_VERSION) || (RS_VERSION <= 20)
2079static inline int __attribute__((const, overloadable))
2080 min(int a, int b) {
2081 return (a < b ? a : b);
2082}
2083#endif
2084
2085#if !defined(RS_VERSION) || (RS_VERSION <= 20)
2086static inline uint __attribute__((const, overloadable))
2087 min(uint a, uint b) {
2088 return (a < b ? a : b);
2089}
2090#endif
2091
2092#if !defined(RS_VERSION) || (RS_VERSION <= 20)
2093static inline char2 __attribute__((const, overloadable))
2094 min(char2 a, char2 b) {
2095 char2 tmp;
2096 tmp.x = (a.x < b.x ? a.x : b.x);
2097 tmp.y = (a.y < b.y ? a.y : b.y);
2098 return tmp;
2099}
2100#endif
2101
2102#if !defined(RS_VERSION) || (RS_VERSION <= 20)
2103static inline uchar2 __attribute__((const, overloadable))
2104 min(uchar2 a, uchar2 b) {
2105 uchar2 tmp;
2106 tmp.x = (a.x < b.x ? a.x : b.x);
2107 tmp.y = (a.y < b.y ? a.y : b.y);
2108 return tmp;
2109}
2110#endif
2111
2112#if !defined(RS_VERSION) || (RS_VERSION <= 20)
2113static inline short2 __attribute__((const, overloadable))
2114 min(short2 a, short2 b) {
2115 short2 tmp;
2116 tmp.x = (a.x < b.x ? a.x : b.x);
2117 tmp.y = (a.y < b.y ? a.y : b.y);
2118 return tmp;
2119}
2120#endif
2121
2122#if !defined(RS_VERSION) || (RS_VERSION <= 20)
2123static inline ushort2 __attribute__((const, overloadable))
2124 min(ushort2 a, ushort2 b) {
2125 ushort2 tmp;
2126 tmp.x = (a.x < b.x ? a.x : b.x);
2127 tmp.y = (a.y < b.y ? a.y : b.y);
2128 return tmp;
2129}
2130#endif
2131
2132#if !defined(RS_VERSION) || (RS_VERSION <= 20)
2133static inline int2 __attribute__((const, overloadable))
2134 min(int2 a, int2 b) {
2135 int2 tmp;
2136 tmp.x = (a.x < b.x ? a.x : b.x);
2137 tmp.y = (a.y < b.y ? a.y : b.y);
2138 return tmp;
2139}
2140#endif
2141
2142#if !defined(RS_VERSION) || (RS_VERSION <= 20)
2143static inline uint2 __attribute__((const, overloadable))
2144 min(uint2 a, uint2 b) {
2145 uint2 tmp;
2146 tmp.x = (a.x < b.x ? a.x : b.x);
2147 tmp.y = (a.y < b.y ? a.y : b.y);
2148 return tmp;
2149}
2150#endif
2151
2152#if !defined(RS_VERSION) || (RS_VERSION <= 20)
2153static inline char3 __attribute__((const, overloadable))
2154 min(char3 a, char3 b) {
2155 char3 tmp;
2156 tmp.x = (a.x < b.x ? a.x : b.x);
2157 tmp.y = (a.y < b.y ? a.y : b.y);
2158 tmp.z = (a.z < b.z ? a.z : b.z);
2159 return tmp;
2160}
2161#endif
2162
2163#if !defined(RS_VERSION) || (RS_VERSION <= 20)
2164static inline uchar3 __attribute__((const, overloadable))
2165 min(uchar3 a, uchar3 b) {
2166 uchar3 tmp;
2167 tmp.x = (a.x < b.x ? a.x : b.x);
2168 tmp.y = (a.y < b.y ? a.y : b.y);
2169 tmp.z = (a.z < b.z ? a.z : b.z);
2170 return tmp;
2171}
2172#endif
2173
2174#if !defined(RS_VERSION) || (RS_VERSION <= 20)
2175static inline short3 __attribute__((const, overloadable))
2176 min(short3 a, short3 b) {
2177 short3 tmp;
2178 tmp.x = (a.x < b.x ? a.x : b.x);
2179 tmp.y = (a.y < b.y ? a.y : b.y);
2180 tmp.z = (a.z < b.z ? a.z : b.z);
2181 return tmp;
2182}
2183#endif
2184
2185#if !defined(RS_VERSION) || (RS_VERSION <= 20)
2186static inline ushort3 __attribute__((const, overloadable))
2187 min(ushort3 a, ushort3 b) {
2188 ushort3 tmp;
2189 tmp.x = (a.x < b.x ? a.x : b.x);
2190 tmp.y = (a.y < b.y ? a.y : b.y);
2191 tmp.z = (a.z < b.z ? a.z : b.z);
2192 return tmp;
2193}
2194#endif
2195
2196#if !defined(RS_VERSION) || (RS_VERSION <= 20)
2197static inline int3 __attribute__((const, overloadable))
2198 min(int3 a, int3 b) {
2199 int3 tmp;
2200 tmp.x = (a.x < b.x ? a.x : b.x);
2201 tmp.y = (a.y < b.y ? a.y : b.y);
2202 tmp.z = (a.z < b.z ? a.z : b.z);
2203 return tmp;
2204}
2205#endif
2206
2207#if !defined(RS_VERSION) || (RS_VERSION <= 20)
2208static inline uint3 __attribute__((const, overloadable))
2209 min(uint3 a, uint3 b) {
2210 uint3 tmp;
2211 tmp.x = (a.x < b.x ? a.x : b.x);
2212 tmp.y = (a.y < b.y ? a.y : b.y);
2213 tmp.z = (a.z < b.z ? a.z : b.z);
2214 return tmp;
2215}
2216#endif
2217
2218#if !defined(RS_VERSION) || (RS_VERSION <= 20)
2219static inline char4 __attribute__((const, overloadable))
2220 min(char4 a, char4 b) {
2221 char4 tmp;
2222 tmp.x = (a.x < b.x ? a.x : b.x);
2223 tmp.y = (a.y < b.y ? a.y : b.y);
2224 tmp.z = (a.z < b.z ? a.z : b.z);
2225 tmp.w = (a.w < b.w ? a.w : b.w);
2226 return tmp;
2227}
2228#endif
2229
2230#if !defined(RS_VERSION) || (RS_VERSION <= 20)
2231static inline uchar4 __attribute__((const, overloadable))
2232 min(uchar4 a, uchar4 b) {
2233 uchar4 tmp;
2234 tmp.x = (a.x < b.x ? a.x : b.x);
2235 tmp.y = (a.y < b.y ? a.y : b.y);
2236 tmp.z = (a.z < b.z ? a.z : b.z);
2237 tmp.w = (a.w < b.w ? a.w : b.w);
2238 return tmp;
2239}
2240#endif
2241
2242#if !defined(RS_VERSION) || (RS_VERSION <= 20)
2243static inline short4 __attribute__((const, overloadable))
2244 min(short4 a, short4 b) {
2245 short4 tmp;
2246 tmp.x = (a.x < b.x ? a.x : b.x);
2247 tmp.y = (a.y < b.y ? a.y : b.y);
2248 tmp.z = (a.z < b.z ? a.z : b.z);
2249 tmp.w = (a.w < b.w ? a.w : b.w);
2250 return tmp;
2251}
2252#endif
2253
2254#if !defined(RS_VERSION) || (RS_VERSION <= 20)
2255static inline ushort4 __attribute__((const, overloadable))
2256 min(ushort4 a, ushort4 b) {
2257 ushort4 tmp;
2258 tmp.x = (a.x < b.x ? a.x : b.x);
2259 tmp.y = (a.y < b.y ? a.y : b.y);
2260 tmp.z = (a.z < b.z ? a.z : b.z);
2261 tmp.w = (a.w < b.w ? a.w : b.w);
2262 return tmp;
2263}
2264#endif
2265
2266#if !defined(RS_VERSION) || (RS_VERSION <= 20)
2267static inline int4 __attribute__((const, overloadable))
2268 min(int4 a, int4 b) {
2269 int4 tmp;
2270 tmp.x = (a.x < b.x ? a.x : b.x);
2271 tmp.y = (a.y < b.y ? a.y : b.y);
2272 tmp.z = (a.z < b.z ? a.z : b.z);
2273 tmp.w = (a.w < b.w ? a.w : b.w);
2274 return tmp;
2275}
2276#endif
2277
2278#if !defined(RS_VERSION) || (RS_VERSION <= 20)
2279static inline uint4 __attribute__((const, overloadable))
2280 min(uint4 a, uint4 b) {
2281 uint4 tmp;
2282 tmp.x = (a.x < b.x ? a.x : b.x);
2283 tmp.y = (a.y < b.y ? a.y : b.y);
2284 tmp.z = (a.z < b.z ? a.z : b.z);
2285 tmp.w = (a.w < b.w ? a.w : b.w);
2286 return tmp;
2287}
2288#endif
2289
2290#if (defined(RS_VERSION) && (RS_VERSION >= 21))
2291extern char __attribute__((const, overloadable))
2292 min(char a, char b);
2293#endif
2294
2295#if (defined(RS_VERSION) && (RS_VERSION >= 21))
2296extern char2 __attribute__((const, overloadable))
2297 min(char2 a, char2 b);
2298#endif
2299
2300#if (defined(RS_VERSION) && (RS_VERSION >= 21))
2301extern char3 __attribute__((const, overloadable))
2302 min(char3 a, char3 b);
2303#endif
2304
2305#if (defined(RS_VERSION) && (RS_VERSION >= 21))
2306extern char4 __attribute__((const, overloadable))
2307 min(char4 a, char4 b);
2308#endif
2309
2310#if (defined(RS_VERSION) && (RS_VERSION >= 21))
2311extern uchar __attribute__((const, overloadable))
2312 min(uchar a, uchar b);
2313#endif
2314
2315#if (defined(RS_VERSION) && (RS_VERSION >= 21))
2316extern uchar2 __attribute__((const, overloadable))
2317 min(uchar2 a, uchar2 b);
2318#endif
2319
2320#if (defined(RS_VERSION) && (RS_VERSION >= 21))
2321extern uchar3 __attribute__((const, overloadable))
2322 min(uchar3 a, uchar3 b);
2323#endif
2324
2325#if (defined(RS_VERSION) && (RS_VERSION >= 21))
2326extern uchar4 __attribute__((const, overloadable))
2327 min(uchar4 a, uchar4 b);
2328#endif
2329
2330#if (defined(RS_VERSION) && (RS_VERSION >= 21))
2331extern short __attribute__((const, overloadable))
2332 min(short a, short b);
2333#endif
2334
2335#if (defined(RS_VERSION) && (RS_VERSION >= 21))
2336extern short2 __attribute__((const, overloadable))
2337 min(short2 a, short2 b);
2338#endif
2339
2340#if (defined(RS_VERSION) && (RS_VERSION >= 21))
2341extern short3 __attribute__((const, overloadable))
2342 min(short3 a, short3 b);
2343#endif
2344
2345#if (defined(RS_VERSION) && (RS_VERSION >= 21))
2346extern short4 __attribute__((const, overloadable))
2347 min(short4 a, short4 b);
2348#endif
2349
2350#if (defined(RS_VERSION) && (RS_VERSION >= 21))
2351extern ushort __attribute__((const, overloadable))
2352 min(ushort a, ushort b);
2353#endif
2354
2355#if (defined(RS_VERSION) && (RS_VERSION >= 21))
2356extern ushort2 __attribute__((const, overloadable))
2357 min(ushort2 a, ushort2 b);
2358#endif
2359
2360#if (defined(RS_VERSION) && (RS_VERSION >= 21))
2361extern ushort3 __attribute__((const, overloadable))
2362 min(ushort3 a, ushort3 b);
2363#endif
2364
2365#if (defined(RS_VERSION) && (RS_VERSION >= 21))
2366extern ushort4 __attribute__((const, overloadable))
2367 min(ushort4 a, ushort4 b);
2368#endif
2369
2370#if (defined(RS_VERSION) && (RS_VERSION >= 21))
2371extern int __attribute__((const, overloadable))
2372 min(int a, int b);
2373#endif
2374
2375#if (defined(RS_VERSION) && (RS_VERSION >= 21))
2376extern int2 __attribute__((const, overloadable))
2377 min(int2 a, int2 b);
2378#endif
2379
2380#if (defined(RS_VERSION) && (RS_VERSION >= 21))
2381extern int3 __attribute__((const, overloadable))
2382 min(int3 a, int3 b);
2383#endif
2384
2385#if (defined(RS_VERSION) && (RS_VERSION >= 21))
2386extern int4 __attribute__((const, overloadable))
2387 min(int4 a, int4 b);
2388#endif
2389
2390#if (defined(RS_VERSION) && (RS_VERSION >= 21))
2391extern uint __attribute__((const, overloadable))
2392 min(uint a, uint b);
2393#endif
2394
2395#if (defined(RS_VERSION) && (RS_VERSION >= 21))
2396extern uint2 __attribute__((const, overloadable))
2397 min(uint2 a, uint2 b);
2398#endif
2399
2400#if (defined(RS_VERSION) && (RS_VERSION >= 21))
2401extern uint3 __attribute__((const, overloadable))
2402 min(uint3 a, uint3 b);
2403#endif
2404
2405#if (defined(RS_VERSION) && (RS_VERSION >= 21))
2406extern uint4 __attribute__((const, overloadable))
2407 min(uint4 a, uint4 b);
2408#endif
2409
2410#if (defined(RS_VERSION) && (RS_VERSION >= 21))
2411extern long __attribute__((const, overloadable))
2412 min(long a, long b);
2413#endif
2414
2415#if (defined(RS_VERSION) && (RS_VERSION >= 21))
2416extern long2 __attribute__((const, overloadable))
2417 min(long2 a, long2 b);
2418#endif
2419
2420#if (defined(RS_VERSION) && (RS_VERSION >= 21))
2421extern long3 __attribute__((const, overloadable))
2422 min(long3 a, long3 b);
2423#endif
2424
2425#if (defined(RS_VERSION) && (RS_VERSION >= 21))
2426extern long4 __attribute__((const, overloadable))
2427 min(long4 a, long4 b);
2428#endif
2429
2430#if (defined(RS_VERSION) && (RS_VERSION >= 21))
2431extern ulong __attribute__((const, overloadable))
2432 min(ulong a, ulong b);
2433#endif
2434
2435#if (defined(RS_VERSION) && (RS_VERSION >= 21))
2436extern ulong2 __attribute__((const, overloadable))
2437 min(ulong2 a, ulong2 b);
2438#endif
2439
2440#if (defined(RS_VERSION) && (RS_VERSION >= 21))
2441extern ulong3 __attribute__((const, overloadable))
2442 min(ulong3 a, ulong3 b);
2443#endif
2444
2445#if (defined(RS_VERSION) && (RS_VERSION >= 21))
2446extern ulong4 __attribute__((const, overloadable))
2447 min(ulong4 a, ulong4 b);
2448#endif
2449
2450/*
2451 * mix: Mixes two values
2452 *
2453 * Returns start + ((stop - start) * fraction).
2454 *
Jean-Luc Brouillet6386ceb2015-04-28 15:06:30 -0700[diff] [blame^]2455 * This can be useful for mixing two values. For example, to create a new color that is
2456 * 40% color1 and 60% color2, use mix(color1, color2, 0.6f).
Jean-Luc Brouilletbe216382015-03-22 12:44:27 -0700[diff] [blame]2457 */
2458extern float __attribute__((const, overloadable))
2459 mix(float start, float stop, float fraction);
2460
2461extern float2 __attribute__((const, overloadable))
2462 mix(float2 start, float2 stop, float2 fraction);
2463
2464extern float3 __attribute__((const, overloadable))
2465 mix(float3 start, float3 stop, float3 fraction);
2466
2467extern float4 __attribute__((const, overloadable))
2468 mix(float4 start, float4 stop, float4 fraction);
2469
2470extern float2 __attribute__((const, overloadable))
2471 mix(float2 start, float2 stop, float fraction);
2472
2473extern float3 __attribute__((const, overloadable))
2474 mix(float3 start, float3 stop, float fraction);
2475
2476extern float4 __attribute__((const, overloadable))
2477 mix(float4 start, float4 stop, float fraction);
2478
2479/*
2480 * modf: Integral and fractional components
2481 *
2482 * Returns the integral and fractional components of a number.
2483 *
Jean-Luc Brouillet6386ceb2015-04-28 15:06:30 -0700[diff] [blame^]2484 * Both components will have the same sign as x. For example, for an input of -3.72f,
2485 * iret will be set to -3.f and .72f will be returned.
Jean-Luc Brouilletbe216382015-03-22 12:44:27 -0700[diff] [blame]2486 *
2487 * Parameters:
Jean-Luc Brouillet6386ceb2015-04-28 15:06:30 -0700[diff] [blame^]2488 * v: Source value.
Jean-Luc Brouillet4a730042015-04-02 16:15:25 -0700[diff] [blame]2489 * integral_part: *integral_part will be set to the integral portion of the number.
Jean-Luc Brouilletbe216382015-03-22 12:44:27 -0700[diff] [blame]2490 *
Jean-Luc Brouillet6386ceb2015-04-28 15:06:30 -0700[diff] [blame^]2491 * Returns: Floating point portion of the value.
Jean-Luc Brouilletbe216382015-03-22 12:44:27 -0700[diff] [blame]2492 */
2493extern float __attribute__((overloadable))
2494 modf(float v, float* integral_part);
2495
2496extern float2 __attribute__((overloadable))
2497 modf(float2 v, float2* integral_part);
2498
2499extern float3 __attribute__((overloadable))
2500 modf(float3 v, float3* integral_part);
2501
2502extern float4 __attribute__((overloadable))
2503 modf(float4 v, float4* integral_part);
2504
2505/*
2506 * nan: Not a Number
2507 *
2508 * Returns a NaN value (Not a Number).
2509 *
2510 * Parameters:
Jean-Luc Brouillet4a730042015-04-02 16:15:25 -0700[diff] [blame]2511 * v: Not used.
Jean-Luc Brouilletbe216382015-03-22 12:44:27 -0700[diff] [blame]2512 */
2513extern float __attribute__((const, overloadable))
2514 nan(uint v);
2515
2516/*
2517 * native_acos: Approximate inverse cosine
2518 *
2519 * Returns the approximate inverse cosine, in radians.
2520 *
Jean-Luc Brouillet6386ceb2015-04-28 15:06:30 -0700[diff] [blame^]2521 * This function yields undefined results from input values less than -1 or greater than 1.
Jean-Luc Brouilletbe216382015-03-22 12:44:27 -0700[diff] [blame]2522 *
2523 * See also acos().
2524 */
2525#if (defined(RS_VERSION) && (RS_VERSION >= 21))
2526extern float __attribute__((const, overloadable))
2527 native_acos(float v);
2528#endif
2529
2530#if (defined(RS_VERSION) && (RS_VERSION >= 21))
2531extern float2 __attribute__((const, overloadable))
2532 native_acos(float2 v);
2533#endif
2534
2535#if (defined(RS_VERSION) && (RS_VERSION >= 21))
2536extern float3 __attribute__((const, overloadable))
2537 native_acos(float3 v);
2538#endif
2539
2540#if (defined(RS_VERSION) && (RS_VERSION >= 21))
2541extern float4 __attribute__((const, overloadable))
2542 native_acos(float4 v);
2543#endif
2544
2545/*
2546 * native_acosh: Approximate inverse hyperbolic cosine
2547 *
2548 * Returns the approximate inverse hyperbolic cosine, in radians.
2549 *
2550 * See also acosh().
2551 */
2552#if (defined(RS_VERSION) && (RS_VERSION >= 21))
2553extern float __attribute__((const, overloadable))
2554 native_acosh(float v);
2555#endif
2556
2557#if (defined(RS_VERSION) && (RS_VERSION >= 21))
2558extern float2 __attribute__((const, overloadable))
2559 native_acosh(float2 v);
2560#endif
2561
2562#if (defined(RS_VERSION) && (RS_VERSION >= 21))
2563extern float3 __attribute__((const, overloadable))
2564 native_acosh(float3 v);
2565#endif
2566
2567#if (defined(RS_VERSION) && (RS_VERSION >= 21))
2568extern float4 __attribute__((const, overloadable))
2569 native_acosh(float4 v);
2570#endif
2571
2572/*
2573 * native_acospi: Approximate inverse cosine divided by pi
2574 *
2575 * Returns the approximate inverse cosine in radians, divided by pi.
2576 *
2577 * To get an inverse cosine measured in degrees, use acospi(a) * 180.f.
2578 *
Jean-Luc Brouillet6386ceb2015-04-28 15:06:30 -0700[diff] [blame^]2579 * This function yields undefined results from input values less than -1 or greater than 1.
Jean-Luc Brouilletbe216382015-03-22 12:44:27 -0700[diff] [blame]2580 *
2581 * See also acospi().
2582 */
2583#if (defined(RS_VERSION) && (RS_VERSION >= 21))
2584extern float __attribute__((const, overloadable))
2585 native_acospi(float v);
2586#endif
2587
2588#if (defined(RS_VERSION) && (RS_VERSION >= 21))
2589extern float2 __attribute__((const, overloadable))
2590 native_acospi(float2 v);
2591#endif
2592
2593#if (defined(RS_VERSION) && (RS_VERSION >= 21))
2594extern float3 __attribute__((const, overloadable))
2595 native_acospi(float3 v);
2596#endif
2597
2598#if (defined(RS_VERSION) && (RS_VERSION >= 21))
2599extern float4 __attribute__((const, overloadable))
2600 native_acospi(float4 v);
2601#endif
2602
2603/*
2604 * native_asin: Approximate inverse sine
2605 *
2606 * Returns the approximate inverse sine, in radians.
2607 *
Jean-Luc Brouillet6386ceb2015-04-28 15:06:30 -0700[diff] [blame^]2608 * This function yields undefined results from input values less than -1 or greater than 1.
Jean-Luc Brouilletbe216382015-03-22 12:44:27 -0700[diff] [blame]2609 *
2610 * See also asin().
2611 */
2612#if (defined(RS_VERSION) && (RS_VERSION >= 21))
2613extern float __attribute__((const, overloadable))
2614 native_asin(float v);
2615#endif
2616
2617#if (defined(RS_VERSION) && (RS_VERSION >= 21))
2618extern float2 __attribute__((const, overloadable))
2619 native_asin(float2 v);
2620#endif
2621
2622#if (defined(RS_VERSION) && (RS_VERSION >= 21))
2623extern float3 __attribute__((const, overloadable))
2624 native_asin(float3 v);
2625#endif
2626
2627#if (defined(RS_VERSION) && (RS_VERSION >= 21))
2628extern float4 __attribute__((const, overloadable))
2629 native_asin(float4 v);
2630#endif
2631
2632/*
2633 * native_asinh: Approximate inverse hyperbolic sine
2634 *
2635 * Returns the approximate inverse hyperbolic sine, in radians.
2636 *
2637 * See also asinh().
2638 */
2639#if (defined(RS_VERSION) && (RS_VERSION >= 21))
2640extern float __attribute__((const, overloadable))
2641 native_asinh(float v);
2642#endif
2643
2644#if (defined(RS_VERSION) && (RS_VERSION >= 21))
2645extern float2 __attribute__((const, overloadable))
2646 native_asinh(float2 v);
2647#endif
2648
2649#if (defined(RS_VERSION) && (RS_VERSION >= 21))
2650extern float3 __attribute__((const, overloadable))
2651 native_asinh(float3 v);
2652#endif
2653
2654#if (defined(RS_VERSION) && (RS_VERSION >= 21))
2655extern float4 __attribute__((const, overloadable))
2656 native_asinh(float4 v);
2657#endif
2658
2659/*
2660 * native_asinpi: Approximate inverse sine divided by pi
2661 *
2662 * Returns the approximate inverse sine in radians, divided by pi.
2663 *
2664 * To get an inverse sine measured in degrees, use asinpi(a) * 180.f.
2665 *
Jean-Luc Brouillet6386ceb2015-04-28 15:06:30 -0700[diff] [blame^]2666 * This function yields undefined results from input values less than -1 or greater than 1.
Jean-Luc Brouilletbe216382015-03-22 12:44:27 -0700[diff] [blame]2667 *
2668 * See also asinpi().
2669 */
2670#if (defined(RS_VERSION) && (RS_VERSION >= 21))
2671extern float __attribute__((const, overloadable))
2672 native_asinpi(float v);
2673#endif
2674
2675#if (defined(RS_VERSION) && (RS_VERSION >= 21))
2676extern float2 __attribute__((const, overloadable))
2677 native_asinpi(float2 v);
2678#endif
2679
2680#if (defined(RS_VERSION) && (RS_VERSION >= 21))
2681extern float3 __attribute__((const, overloadable))
2682 native_asinpi(float3 v);
2683#endif
2684
2685#if (defined(RS_VERSION) && (RS_VERSION >= 21))
2686extern float4 __attribute__((const, overloadable))
2687 native_asinpi(float4 v);
2688#endif
2689
2690/*
2691 * native_atan: Approximate inverse tangent
2692 *
2693 * Returns the approximate inverse tangent, in radians.
2694 *
2695 * See also atan().
2696 */
2697#if (defined(RS_VERSION) && (RS_VERSION >= 21))
2698extern float __attribute__((const, overloadable))
2699 native_atan(float v);
2700#endif
2701
2702#if (defined(RS_VERSION) && (RS_VERSION >= 21))
2703extern float2 __attribute__((const, overloadable))
2704 native_atan(float2 v);
2705#endif
2706
2707#if (defined(RS_VERSION) && (RS_VERSION >= 21))
2708extern float3 __attribute__((const, overloadable))
2709 native_atan(float3 v);
2710#endif
2711
2712#if (defined(RS_VERSION) && (RS_VERSION >= 21))
2713extern float4 __attribute__((const, overloadable))
2714 native_atan(float4 v);
2715#endif
2716
2717/*
2718 * native_atan2: Approximate inverse tangent of a ratio
2719 *
2720 * Returns the approximate inverse tangent of (numerator / denominator), in radians.
2721 *
2722 * See also atan2().
2723 *
2724 * Parameters:
Jean-Luc Brouillet6386ceb2015-04-28 15:06:30 -0700[diff] [blame^]2725 * numerator: Numerator.
2726 * denominator: Denominator. Can be 0.
Jean-Luc Brouilletbe216382015-03-22 12:44:27 -0700[diff] [blame]2727 */
2728#if (defined(RS_VERSION) && (RS_VERSION >= 21))
2729extern float __attribute__((const, overloadable))
2730 native_atan2(float numerator, float denominator);
2731#endif
2732
2733#if (defined(RS_VERSION) && (RS_VERSION >= 21))
2734extern float2 __attribute__((const, overloadable))
2735 native_atan2(float2 numerator, float2 denominator);
2736#endif
2737
2738#if (defined(RS_VERSION) && (RS_VERSION >= 21))
2739extern float3 __attribute__((const, overloadable))
2740 native_atan2(float3 numerator, float3 denominator);
2741#endif
2742
2743#if (defined(RS_VERSION) && (RS_VERSION >= 21))
2744extern float4 __attribute__((const, overloadable))
2745 native_atan2(float4 numerator, float4 denominator);
2746#endif
2747
2748/*
2749 * native_atan2pi: Approximate inverse tangent of a ratio, divided by pi
2750 *
Jean-Luc Brouillet6386ceb2015-04-28 15:06:30 -0700[diff] [blame^]2751 * Returns the approximate inverse tangent of (numerator / denominator),
2752 * in radians, divided by pi.
Jean-Luc Brouilletbe216382015-03-22 12:44:27 -0700[diff] [blame]2753 *
2754 * To get an inverse tangent measured in degrees, use atan2pi(n, d) * 180.f.
2755 *
2756 * See also atan2pi().
2757 *
2758 * Parameters:
Jean-Luc Brouillet6386ceb2015-04-28 15:06:30 -0700[diff] [blame^]2759 * numerator: Numerator.
2760 * denominator: Denominator. Can be 0.
Jean-Luc Brouilletbe216382015-03-22 12:44:27 -0700[diff] [blame]2761 */
2762#if (defined(RS_VERSION) && (RS_VERSION >= 21))
2763extern float __attribute__((const, overloadable))
2764 native_atan2pi(float numerator, float denominator);
2765#endif
2766
2767#if (defined(RS_VERSION) && (RS_VERSION >= 21))
2768extern float2 __attribute__((const, overloadable))
2769 native_atan2pi(float2 numerator, float2 denominator);
2770#endif
2771
2772#if (defined(RS_VERSION) && (RS_VERSION >= 21))
2773extern float3 __attribute__((const, overloadable))
2774 native_atan2pi(float3 numerator, float3 denominator);
2775#endif
2776
2777#if (defined(RS_VERSION) && (RS_VERSION >= 21))
2778extern float4 __attribute__((const, overloadable))
2779 native_atan2pi(float4 numerator, float4 denominator);
2780#endif
2781
2782/*
2783 * native_atanh: Approximate inverse hyperbolic tangent
2784 *
2785 * Returns the approximate inverse hyperbolic tangent, in radians.
2786 *
2787 * See also atanh().
2788 */
2789#if (defined(RS_VERSION) && (RS_VERSION >= 21))
2790extern float __attribute__((const, overloadable))
2791 native_atanh(float v);
2792#endif
2793
2794#if (defined(RS_VERSION) && (RS_VERSION >= 21))
2795extern float2 __attribute__((const, overloadable))
2796 native_atanh(float2 v);
2797#endif
2798
2799#if (defined(RS_VERSION) && (RS_VERSION >= 21))
2800extern float3 __attribute__((const, overloadable))
2801 native_atanh(float3 v);
2802#endif
2803
2804#if (defined(RS_VERSION) && (RS_VERSION >= 21))
2805extern float4 __attribute__((const, overloadable))
2806 native_atanh(float4 v);
2807#endif
2808
2809/*
2810 * native_atanpi: Approximate inverse tangent divided by pi
2811 *
2812 * Returns the approximate inverse tangent in radians, divided by pi.
2813 *
2814 * To get an inverse tangent measured in degrees, use atanpi(a) * 180.f.
2815 *
2816 * See also atanpi().
2817 */
2818#if (defined(RS_VERSION) && (RS_VERSION >= 21))
2819extern float __attribute__((const, overloadable))
2820 native_atanpi(float v);
2821#endif
2822
2823#if (defined(RS_VERSION) && (RS_VERSION >= 21))
2824extern float2 __attribute__((const, overloadable))
2825 native_atanpi(float2 v);
2826#endif
2827
2828#if (defined(RS_VERSION) && (RS_VERSION >= 21))
2829extern float3 __attribute__((const, overloadable))
2830 native_atanpi(float3 v);
2831#endif
2832
2833#if (defined(RS_VERSION) && (RS_VERSION >= 21))
2834extern float4 __attribute__((const, overloadable))
2835 native_atanpi(float4 v);
2836#endif
2837
2838/*
2839 * native_cbrt: Approximate cube root
2840 *
2841 * Returns the approximate cubic root.
2842 *
2843 * See also cbrt().
2844 */
2845#if (defined(RS_VERSION) && (RS_VERSION >= 21))
2846extern float __attribute__((const, overloadable))
2847 native_cbrt(float v);
2848#endif
2849
2850#if (defined(RS_VERSION) && (RS_VERSION >= 21))
2851extern float2 __attribute__((const, overloadable))
2852 native_cbrt(float2 v);
2853#endif
2854
2855#if (defined(RS_VERSION) && (RS_VERSION >= 21))
2856extern float3 __attribute__((const, overloadable))
2857 native_cbrt(float3 v);
2858#endif
2859
2860#if (defined(RS_VERSION) && (RS_VERSION >= 21))
2861extern float4 __attribute__((const, overloadable))
2862 native_cbrt(float4 v);
2863#endif
2864
2865/*
2866 * native_cos: Approximate cosine
2867 *
2868 * Returns the approximate cosine of an angle measured in radians.
2869 *
2870 * See also cos().
2871 */
2872#if (defined(RS_VERSION) && (RS_VERSION >= 21))
2873extern float __attribute__((const, overloadable))
2874 native_cos(float v);
2875#endif
2876
2877#if (defined(RS_VERSION) && (RS_VERSION >= 21))
2878extern float2 __attribute__((const, overloadable))
2879 native_cos(float2 v);
2880#endif
2881
2882#if (defined(RS_VERSION) && (RS_VERSION >= 21))
2883extern float3 __attribute__((const, overloadable))
2884 native_cos(float3 v);
2885#endif
2886
2887#if (defined(RS_VERSION) && (RS_VERSION >= 21))
2888extern float4 __attribute__((const, overloadable))
2889 native_cos(float4 v);
2890#endif
2891
2892/*
2893 * native_cosh: Approximate hypebolic cosine
2894 *
2895 * Returns the approximate hypebolic cosine.
2896 *
2897 * See also cosh().
2898 */
2899#if (defined(RS_VERSION) && (RS_VERSION >= 21))
2900extern float __attribute__((const, overloadable))
2901 native_cosh(float v);
2902#endif
2903
2904#if (defined(RS_VERSION) && (RS_VERSION >= 21))
2905extern float2 __attribute__((const, overloadable))
2906 native_cosh(float2 v);
2907#endif
2908
2909#if (defined(RS_VERSION) && (RS_VERSION >= 21))
2910extern float3 __attribute__((const, overloadable))
2911 native_cosh(float3 v);
2912#endif
2913
2914#if (defined(RS_VERSION) && (RS_VERSION >= 21))
2915extern float4 __attribute__((const, overloadable))
2916 native_cosh(float4 v);
2917#endif
2918
2919/*
2920 * native_cospi: Approximate cosine of a number multiplied by pi
2921 *
2922 * Returns the approximate cosine of (v * pi), where (v * pi) is measured in radians.
2923 *
2924 * To get the cosine of a value measured in degrees, call cospi(v / 180.f).
2925 *
2926 * See also cospi().
2927 */
2928#if (defined(RS_VERSION) && (RS_VERSION >= 21))
2929extern float __attribute__((const, overloadable))
2930 native_cospi(float v);
2931#endif
2932
2933#if (defined(RS_VERSION) && (RS_VERSION >= 21))
2934extern float2 __attribute__((const, overloadable))
2935 native_cospi(float2 v);
2936#endif
2937
2938#if (defined(RS_VERSION) && (RS_VERSION >= 21))
2939extern float3 __attribute__((const, overloadable))
2940 native_cospi(float3 v);
2941#endif
2942
2943#if (defined(RS_VERSION) && (RS_VERSION >= 21))
2944extern float4 __attribute__((const, overloadable))
2945 native_cospi(float4 v);
2946#endif
2947
2948/*
2949 * native_divide: Approximate division
2950 *
2951 * Computes the approximate division of two values.
2952 */
2953#if (defined(RS_VERSION) && (RS_VERSION >= 21))
2954extern float __attribute__((const, overloadable))
2955 native_divide(float left_vector, float right_vector);
2956#endif
2957
2958#if (defined(RS_VERSION) && (RS_VERSION >= 21))
2959extern float2 __attribute__((const, overloadable))
2960 native_divide(float2 left_vector, float2 right_vector);
2961#endif
2962
2963#if (defined(RS_VERSION) && (RS_VERSION >= 21))
2964extern float3 __attribute__((const, overloadable))
2965 native_divide(float3 left_vector, float3 right_vector);
2966#endif
2967
2968#if (defined(RS_VERSION) && (RS_VERSION >= 21))
2969extern float4 __attribute__((const, overloadable))
2970 native_divide(float4 left_vector, float4 right_vector);
2971#endif
2972
2973/*
2974 * native_exp: Approximate e raised to a number
2975 *
2976 * Fast approximate exp.
2977 *
Jean-Luc Brouillet6386ceb2015-04-28 15:06:30 -0700[diff] [blame^]2978 * It is valid for inputs from -86.f to 86.f. The precision is no worse than what would be
2979 * expected from using 16 bit floating point values.
Jean-Luc Brouilletbe216382015-03-22 12:44:27 -0700[diff] [blame]2980 *
2981 * See also exp().
2982 */
2983#if (defined(RS_VERSION) && (RS_VERSION >= 18))
2984extern float __attribute__((const, overloadable))
2985 native_exp(float v);
2986#endif
2987
2988#if (defined(RS_VERSION) && (RS_VERSION >= 18))
2989extern float2 __attribute__((const, overloadable))
2990 native_exp(float2 v);
2991#endif
2992
2993#if (defined(RS_VERSION) && (RS_VERSION >= 18))
2994extern float3 __attribute__((const, overloadable))
2995 native_exp(float3 v);
2996#endif
2997
2998#if (defined(RS_VERSION) && (RS_VERSION >= 18))
2999extern float4 __attribute__((const, overloadable))
3000 native_exp(float4 v);
3001#endif
3002
3003/*
3004 * native_exp10: Approximate 10 raised to a number
3005 *
3006 * Fast approximate exp10.
3007 *
Jean-Luc Brouillet6386ceb2015-04-28 15:06:30 -0700[diff] [blame^]3008 * It is valid for inputs from -37.f to 37.f. The precision is no worse than what would be
3009 * expected from using 16 bit floating point values.
Jean-Luc Brouilletbe216382015-03-22 12:44:27 -0700[diff] [blame]3010 *
3011 * See also exp10().
3012 */
3013#if (defined(RS_VERSION) && (RS_VERSION >= 18))
3014extern float __attribute__((const, overloadable))
3015 native_exp10(float v);
3016#endif
3017
3018#if (defined(RS_VERSION) && (RS_VERSION >= 18))
3019extern float2 __attribute__((const, overloadable))
3020 native_exp10(float2 v);
3021#endif
3022
3023#if (defined(RS_VERSION) && (RS_VERSION >= 18))
3024extern float3 __attribute__((const, overloadable))
3025 native_exp10(float3 v);
3026#endif
3027
3028#if (defined(RS_VERSION) && (RS_VERSION >= 18))
3029extern float4 __attribute__((const, overloadable))
3030 native_exp10(float4 v);
3031#endif
3032
3033/*
3034 * native_exp2: Approximate 2 raised to a number
3035 *
3036 * Fast approximate exp2.
3037 *
Jean-Luc Brouillet6386ceb2015-04-28 15:06:30 -0700[diff] [blame^]3038 * It is valid for inputs from -125.f to 125.f. The precision is no worse than what would be
3039 * expected from using 16 bit floating point values.
Jean-Luc Brouilletbe216382015-03-22 12:44:27 -0700[diff] [blame]3040 *
3041 * See also exp2().
3042 */
3043#if (defined(RS_VERSION) && (RS_VERSION >= 18))
3044extern float __attribute__((const, overloadable))
3045 native_exp2(float v);
3046#endif
3047
3048#if (defined(RS_VERSION) && (RS_VERSION >= 18))
3049extern float2 __attribute__((const, overloadable))
3050 native_exp2(float2 v);
3051#endif
3052
3053#if (defined(RS_VERSION) && (RS_VERSION >= 18))
3054extern float3 __attribute__((const, overloadable))
3055 native_exp2(float3 v);
3056#endif
3057
3058#if (defined(RS_VERSION) && (RS_VERSION >= 18))
3059extern float4 __attribute__((const, overloadable))
3060 native_exp2(float4 v);
3061#endif
3062
3063/*
3064 * native_expm1: Approximate e raised to a number minus one
3065 *
3066 * Returns the approximate (e ^ v) - 1.
3067 *
3068 * See also expm1().
3069 */
3070#if (defined(RS_VERSION) && (RS_VERSION >= 21))
3071extern float __attribute__((const, overloadable))
3072 native_expm1(float v);
3073#endif
3074
3075#if (defined(RS_VERSION) && (RS_VERSION >= 21))
3076extern float2 __attribute__((const, overloadable))
3077 native_expm1(float2 v);
3078#endif
3079
3080#if (defined(RS_VERSION) && (RS_VERSION >= 21))
3081extern float3 __attribute__((const, overloadable))
3082 native_expm1(float3 v);
3083#endif
3084
3085#if (defined(RS_VERSION) && (RS_VERSION >= 21))
3086extern float4 __attribute__((const, overloadable))
3087 native_expm1(float4 v);
3088#endif
3089
3090/*
3091 * native_hypot: Approximate hypotenuse
3092 *
3093 * Returns the approximate native_sqrt(a * a + b * b)
3094 *
3095 * See also hypot().
3096 */
3097#if (defined(RS_VERSION) && (RS_VERSION >= 21))
3098extern float __attribute__((const, overloadable))
3099 native_hypot(float a, float b);
3100#endif
3101
3102#if (defined(RS_VERSION) && (RS_VERSION >= 21))
3103extern float2 __attribute__((const, overloadable))
3104 native_hypot(float2 a, float2 b);
3105#endif
3106
3107#if (defined(RS_VERSION) && (RS_VERSION >= 21))
3108extern float3 __attribute__((const, overloadable))
3109 native_hypot(float3 a, float3 b);
3110#endif
3111
3112#if (defined(RS_VERSION) && (RS_VERSION >= 21))
3113extern float4 __attribute__((const, overloadable))
3114 native_hypot(float4 a, float4 b);
3115#endif
3116
3117/*
3118 * native_log: Approximate natural logarithm
3119 *
3120 * Fast approximate log.
3121 *
3122 * It is not accurate for values very close to zero.
3123 *
3124 * See also log().
3125 */
3126#if (defined(RS_VERSION) && (RS_VERSION >= 18))
3127extern float __attribute__((const, overloadable))
3128 native_log(float v);
3129#endif
3130
3131#if (defined(RS_VERSION) && (RS_VERSION >= 18))
3132extern float2 __attribute__((const, overloadable))
3133 native_log(float2 v);
3134#endif
3135
3136#if (defined(RS_VERSION) && (RS_VERSION >= 18))
3137extern float3 __attribute__((const, overloadable))
3138 native_log(float3 v);
3139#endif
3140
3141#if (defined(RS_VERSION) && (RS_VERSION >= 18))
3142extern float4 __attribute__((const, overloadable))
3143 native_log(float4 v);
3144#endif
3145
3146/*
3147 * native_log10: Approximate base 10 logarithm
3148 *
3149 * Fast approximate log10.
3150 *
3151 * It is not accurate for values very close to zero.
3152 *
3153 * See also log10().
3154 */
3155#if (defined(RS_VERSION) && (RS_VERSION >= 18))
3156extern float __attribute__((const, overloadable))
3157 native_log10(float v);
3158#endif
3159
3160#if (defined(RS_VERSION) && (RS_VERSION >= 18))
3161extern float2 __attribute__((const, overloadable))
3162 native_log10(float2 v);
3163#endif
3164
3165#if (defined(RS_VERSION) && (RS_VERSION >= 18))
3166extern float3 __attribute__((const, overloadable))
3167 native_log10(float3 v);
3168#endif
3169
3170#if (defined(RS_VERSION) && (RS_VERSION >= 18))
3171extern float4 __attribute__((const, overloadable))
3172 native_log10(float4 v);
3173#endif
3174
3175/*
3176 * native_log1p: Approximate natural logarithm of a value plus 1
3177 *
3178 * Returns the approximate natural logarithm of (v + 1.0f)
3179 *
3180 * See also log1p().
3181 */
3182#if (defined(RS_VERSION) && (RS_VERSION >= 21))
3183extern float __attribute__((const, overloadable))
3184 native_log1p(float v);
3185#endif
3186
3187#if (defined(RS_VERSION) && (RS_VERSION >= 21))
3188extern float2 __attribute__((const, overloadable))
3189 native_log1p(float2 v);
3190#endif
3191
3192#if (defined(RS_VERSION) && (RS_VERSION >= 21))
3193extern float3 __attribute__((const, overloadable))
3194 native_log1p(float3 v);
3195#endif
3196
3197#if (defined(RS_VERSION) && (RS_VERSION >= 21))
3198extern float4 __attribute__((const, overloadable))
3199 native_log1p(float4 v);
3200#endif
3201
3202/*
3203 * native_log2: Approximate base 2 logarithm
3204 *
3205 * Fast approximate log2.
3206 *
3207 * It is not accurate for values very close to zero.
3208 *
3209 * See also log2().
3210 */
3211#if (defined(RS_VERSION) && (RS_VERSION >= 18))
3212extern float __attribute__((const, overloadable))
3213 native_log2(float v);
3214#endif
3215
3216#if (defined(RS_VERSION) && (RS_VERSION >= 18))
3217extern float2 __attribute__((const, overloadable))
3218 native_log2(float2 v);
3219#endif
3220
3221#if (defined(RS_VERSION) && (RS_VERSION >= 18))
3222extern float3 __attribute__((const, overloadable))
3223 native_log2(float3 v);
3224#endif
3225
3226#if (defined(RS_VERSION) && (RS_VERSION >= 18))
3227extern float4 __attribute__((const, overloadable))
3228 native_log2(float4 v);
3229#endif
3230
3231/*
3232 * native_powr: Approximate positive base raised to an exponent
3233 *
3234 * Fast approximate (base ^ exponent).
3235 *
3236 * See also powr().
3237 *
3238 * Parameters:
Jean-Luc Brouillet4a730042015-04-02 16:15:25 -0700[diff] [blame]3239 * base: Must be between 0.f and 256.f. The function is not accurate for values very close to zero.
3240 * exponent: Must be between -15.f and 15.f.
Jean-Luc Brouilletbe216382015-03-22 12:44:27 -0700[diff] [blame]3241 */
3242#if (defined(RS_VERSION) && (RS_VERSION >= 18))
3243extern float __attribute__((const, overloadable))
3244 native_powr(float base, float exponent);
3245#endif
3246
3247#if (defined(RS_VERSION) && (RS_VERSION >= 18))
3248extern float2 __attribute__((const, overloadable))
3249 native_powr(float2 base, float2 exponent);
3250#endif
3251
3252#if (defined(RS_VERSION) && (RS_VERSION >= 18))
3253extern float3 __attribute__((const, overloadable))
3254 native_powr(float3 base, float3 exponent);
3255#endif
3256
3257#if (defined(RS_VERSION) && (RS_VERSION >= 18))
3258extern float4 __attribute__((const, overloadable))
3259 native_powr(float4 base, float4 exponent);
3260#endif
3261
3262/*
3263 * native_recip: Approximate reciprocal
3264 *
3265 * Returns the approximate approximate reciprocal of a value.
3266 *
3267 * See also half_recip().
3268 */
3269#if (defined(RS_VERSION) && (RS_VERSION >= 21))
3270extern float __attribute__((const, overloadable))
3271 native_recip(float v);
3272#endif
3273
3274#if (defined(RS_VERSION) && (RS_VERSION >= 21))
3275extern float2 __attribute__((const, overloadable))
3276 native_recip(float2 v);
3277#endif
3278
3279#if (defined(RS_VERSION) && (RS_VERSION >= 21))
3280extern float3 __attribute__((const, overloadable))
3281 native_recip(float3 v);
3282#endif
3283
3284#if (defined(RS_VERSION) && (RS_VERSION >= 21))
3285extern float4 __attribute__((const, overloadable))
3286 native_recip(float4 v);
3287#endif
3288
3289/*
3290 * native_rootn: Approximate nth root
3291 *
3292 * Compute the approximate Nth root of a value.
3293 *
3294 * See also rootn().
3295 */
3296#if (defined(RS_VERSION) && (RS_VERSION >= 21))
3297extern float __attribute__((const, overloadable))
3298 native_rootn(float v, int n);
3299#endif
3300
3301#if (defined(RS_VERSION) && (RS_VERSION >= 21))
3302extern float2 __attribute__((const, overloadable))
3303 native_rootn(float2 v, int2 n);
3304#endif
3305
3306#if (defined(RS_VERSION) && (RS_VERSION >= 21))
3307extern float3 __attribute__((const, overloadable))
3308 native_rootn(float3 v, int3 n);
3309#endif
3310
3311#if (defined(RS_VERSION) && (RS_VERSION >= 21))
3312extern float4 __attribute__((const, overloadable))
3313 native_rootn(float4 v, int4 n);
3314#endif
3315
3316/*
3317 * native_rsqrt: Approximate reciprocal of a square root
3318 *
3319 * Returns approximate (1 / sqrt(v)).
3320 *
3321 * See also rsqrt(), half_rsqrt().
3322 */
3323#if (defined(RS_VERSION) && (RS_VERSION >= 21))
3324extern float __attribute__((const, overloadable))
3325 native_rsqrt(float v);
3326#endif
3327
3328#if (defined(RS_VERSION) && (RS_VERSION >= 21))
3329extern float2 __attribute__((const, overloadable))
3330 native_rsqrt(float2 v);
3331#endif
3332
3333#if (defined(RS_VERSION) && (RS_VERSION >= 21))
3334extern float3 __attribute__((const, overloadable))
3335 native_rsqrt(float3 v);
3336#endif
3337
3338#if (defined(RS_VERSION) && (RS_VERSION >= 21))
3339extern float4 __attribute__((const, overloadable))
3340 native_rsqrt(float4 v);
3341#endif
3342
3343/*
3344 * native_sin: Approximate sine
3345 *
3346 * Returns the approximate sine of an angle measured in radians.
3347 *
3348 * See also sin().
3349 */
3350#if (defined(RS_VERSION) && (RS_VERSION >= 21))
3351extern float __attribute__((const, overloadable))
3352 native_sin(float v);
3353#endif
3354
3355#if (defined(RS_VERSION) && (RS_VERSION >= 21))
3356extern float2 __attribute__((const, overloadable))
3357 native_sin(float2 v);
3358#endif
3359
3360#if (defined(RS_VERSION) && (RS_VERSION >= 21))
3361extern float3 __attribute__((const, overloadable))
3362 native_sin(float3 v);
3363#endif
3364
3365#if (defined(RS_VERSION) && (RS_VERSION >= 21))
3366extern float4 __attribute__((const, overloadable))
3367 native_sin(float4 v);
3368#endif
3369
3370/*
3371 * native_sincos: Approximate sine and cosine
3372 *
3373 * Returns the approximate sine and cosine of a value.
3374 *
3375 * See also sincos().
3376 *
3377 * Parameters:
Jean-Luc Brouillet6386ceb2015-04-28 15:06:30 -0700[diff] [blame^]3378 * v: Incoming value in radians.
Jean-Luc Brouillet4a730042015-04-02 16:15:25 -0700[diff] [blame]3379 * cos: *cos will be set to the cosine value.
Jean-Luc Brouilletbe216382015-03-22 12:44:27 -0700[diff] [blame]3380 *
Jean-Luc Brouillet6386ceb2015-04-28 15:06:30 -0700[diff] [blame^]3381 * Returns: Sine.
Jean-Luc Brouilletbe216382015-03-22 12:44:27 -0700[diff] [blame]3382 */
3383#if (defined(RS_VERSION) && (RS_VERSION >= 21))
3384extern float __attribute__((overloadable))
3385 native_sincos(float v, float* cos);
3386#endif
3387
3388#if (defined(RS_VERSION) && (RS_VERSION >= 21))
3389extern float2 __attribute__((overloadable))
3390 native_sincos(float2 v, float2* cos);
3391#endif
3392
3393#if (defined(RS_VERSION) && (RS_VERSION >= 21))
3394extern float3 __attribute__((overloadable))
3395 native_sincos(float3 v, float3* cos);
3396#endif
3397
3398#if (defined(RS_VERSION) && (RS_VERSION >= 21))
3399extern float4 __attribute__((overloadable))
3400 native_sincos(float4 v, float4* cos);
3401#endif
3402
3403/*
3404 * native_sinh: Approximate hyperbolic sine
3405 *
3406 * Returns the approximate hyperbolic sine of a value specified in radians.
3407 *
3408 * See also sinh().
3409 */
3410#if (defined(RS_VERSION) && (RS_VERSION >= 21))
3411extern float __attribute__((const, overloadable))
3412 native_sinh(float v);
3413#endif
3414
3415#if (defined(RS_VERSION) && (RS_VERSION >= 21))
3416extern float2 __attribute__((const, overloadable))
3417 native_sinh(float2 v);
3418#endif
3419
3420#if (defined(RS_VERSION) && (RS_VERSION >= 21))
3421extern float3 __attribute__((const, overloadable))
3422 native_sinh(float3 v);
3423#endif
3424
3425#if (defined(RS_VERSION) && (RS_VERSION >= 21))
3426extern float4 __attribute__((const, overloadable))
3427 native_sinh(float4 v);
3428#endif
3429
3430/*
3431 * native_sinpi: Approximate sine of a number multiplied by pi
3432 *
3433 * Returns the approximate sine of (v * pi), where (v * pi) is measured in radians.
3434 *
3435 * To get the sine of a value measured in degrees, call sinpi(v / 180.f).
3436 *
3437 * See also sinpi().
3438 */
3439#if (defined(RS_VERSION) && (RS_VERSION >= 21))
3440extern float __attribute__((const, overloadable))
3441 native_sinpi(float v);
3442#endif
3443
3444#if (defined(RS_VERSION) && (RS_VERSION >= 21))
3445extern float2 __attribute__((const, overloadable))
3446 native_sinpi(float2 v);
3447#endif
3448
3449#if (defined(RS_VERSION) && (RS_VERSION >= 21))
3450extern float3 __attribute__((const, overloadable))
3451 native_sinpi(float3 v);
3452#endif
3453
3454#if (defined(RS_VERSION) && (RS_VERSION >= 21))
3455extern float4 __attribute__((const, overloadable))
3456 native_sinpi(float4 v);
3457#endif
3458
3459/*
3460 * native_sqrt: Approximate square root
3461 *
3462 * Returns the approximate sqrt(v).
3463 *
3464 * See also sqrt(), half_sqrt().
3465 */
3466#if (defined(RS_VERSION) && (RS_VERSION >= 21))
3467extern float __attribute__((const, overloadable))
3468 native_sqrt(float v);
3469#endif
3470
3471#if (defined(RS_VERSION) && (RS_VERSION >= 21))
3472extern float2 __attribute__((const, overloadable))
3473 native_sqrt(float2 v);
3474#endif
3475
3476#if (defined(RS_VERSION) && (RS_VERSION >= 21))
3477extern float3 __attribute__((const, overloadable))
3478 native_sqrt(float3 v);
3479#endif
3480
3481#if (defined(RS_VERSION) && (RS_VERSION >= 21))
3482extern float4 __attribute__((const, overloadable))
3483 native_sqrt(float4 v);
3484#endif
3485
3486/*
3487 * native_tan: Approximate tangent
3488 *
3489 * Returns the approximate tangent of an angle measured in radians.
3490 */
3491#if (defined(RS_VERSION) && (RS_VERSION >= 21))
3492extern float __attribute__((const, overloadable))
3493 native_tan(float v);
3494#endif
3495
3496#if (defined(RS_VERSION) && (RS_VERSION >= 21))
3497extern float2 __attribute__((const, overloadable))
3498 native_tan(float2 v);
3499#endif
3500
3501#if (defined(RS_VERSION) && (RS_VERSION >= 21))
3502extern float3 __attribute__((const, overloadable))
3503 native_tan(float3 v);
3504#endif
3505
3506#if (defined(RS_VERSION) && (RS_VERSION >= 21))
3507extern float4 __attribute__((const, overloadable))
3508 native_tan(float4 v);
3509#endif
3510
3511/*
3512 * native_tanh: Approximate hyperbolic tangent
3513 *
3514 * Returns the approximate hyperbolic tangent of a value.
3515 *
3516 * See also tanh().
3517 */
3518#if (defined(RS_VERSION) && (RS_VERSION >= 21))
3519extern float __attribute__((const, overloadable))
3520 native_tanh(float v);
3521#endif
3522
3523#if (defined(RS_VERSION) && (RS_VERSION >= 21))
3524extern float2 __attribute__((const, overloadable))
3525 native_tanh(float2 v);
3526#endif
3527
3528#if (defined(RS_VERSION) && (RS_VERSION >= 21))
3529extern float3 __attribute__((const, overloadable))
3530 native_tanh(float3 v);
3531#endif
3532
3533#if (defined(RS_VERSION) && (RS_VERSION >= 21))
3534extern float4 __attribute__((const, overloadable))
3535 native_tanh(float4 v);
3536#endif
3537
3538/*
3539 * native_tanpi: Approximate tangent of a number multiplied by pi
3540 *
3541 * Returns the approximate tangent of (v * pi), where (v * pi) is measured in radians.
3542 *
3543 * To get the tangent of a value measured in degrees, call tanpi(v / 180.f).
3544 *
3545 * See also tanpi().
3546 */
3547#if (defined(RS_VERSION) && (RS_VERSION >= 21))
3548extern float __attribute__((const, overloadable))
3549 native_tanpi(float v);
3550#endif
3551
3552#if (defined(RS_VERSION) && (RS_VERSION >= 21))
3553extern float2 __attribute__((const, overloadable))
3554 native_tanpi(float2 v);
3555#endif
3556
3557#if (defined(RS_VERSION) && (RS_VERSION >= 21))
3558extern float3 __attribute__((const, overloadable))
3559 native_tanpi(float3 v);
3560#endif
3561
3562#if (defined(RS_VERSION) && (RS_VERSION >= 21))
3563extern float4 __attribute__((const, overloadable))
3564 native_tanpi(float4 v);
3565#endif
3566
3567/*
3568 * nextafter: Next floating point number
3569 *
3570 * Returns the next representable floating point number from v towards target.
3571 *
Jean-Luc Brouillet6386ceb2015-04-28 15:06:30 -0700[diff] [blame^]3572 * In rs_fp_relaxed mode, a denormalized input value may not yield the next denormalized
3573 * value, as support of denormalized values is optional in relaxed mode.
Jean-Luc Brouilletbe216382015-03-22 12:44:27 -0700[diff] [blame]3574 */
3575extern float __attribute__((const, overloadable))
3576 nextafter(float v, float target);
3577
3578extern float2 __attribute__((const, overloadable))
3579 nextafter(float2 v, float2 target);
3580
3581extern float3 __attribute__((const, overloadable))
3582 nextafter(float3 v, float3 target);
3583
3584extern float4 __attribute__((const, overloadable))
3585 nextafter(float4 v, float4 target);
3586
3587/*
3588 * pow: Base raised to an exponent
3589 *
3590 * Returns base raised to the power exponent, i.e. base ^ exponent.
3591 *
Jean-Luc Brouillet6386ceb2015-04-28 15:06:30 -0700[diff] [blame^]3592 * pown() and powr() are similar. pown() takes an integer exponent. powr() assumes the
3593 * base to be non-negative.
Jean-Luc Brouilletbe216382015-03-22 12:44:27 -0700[diff] [blame]3594 */
3595extern float __attribute__((const, overloadable))
3596 pow(float base, float exponent);
3597
3598extern float2 __attribute__((const, overloadable))
3599 pow(float2 base, float2 exponent);
3600
3601extern float3 __attribute__((const, overloadable))
3602 pow(float3 base, float3 exponent);
3603
3604extern float4 __attribute__((const, overloadable))
3605 pow(float4 base, float4 exponent);
3606
3607/*
3608 * pown: Base raised to an integer exponent
3609 *
3610 * Returns base raised to the power exponent, i.e. base ^ exponent.
3611 *
Jean-Luc Brouillet6386ceb2015-04-28 15:06:30 -0700[diff] [blame^]3612 * pow() and powr() are similar. The both take a float exponent. powr() also assumes the
3613 * base to be non-negative.
Jean-Luc Brouilletbe216382015-03-22 12:44:27 -0700[diff] [blame]3614 */
3615extern float __attribute__((const, overloadable))
3616 pown(float base, int exponent);
3617
3618extern float2 __attribute__((const, overloadable))
3619 pown(float2 base, int2 exponent);
3620
3621extern float3 __attribute__((const, overloadable))
3622 pown(float3 base, int3 exponent);
3623
3624extern float4 __attribute__((const, overloadable))
3625 pown(float4 base, int4 exponent);
3626
3627/*
3628 * powr: Positive base raised to an exponent
3629 *
3630 * Returns base raised to the power exponent, i.e. base ^ exponent. base must be >= 0.
3631 *
Jean-Luc Brouillet6386ceb2015-04-28 15:06:30 -0700[diff] [blame^]3632 * pow() and pown() are similar. They both make no assumptions about the base.
3633 * pow() takes a float exponent while pown() take an integer.
Jean-Luc Brouilletbe216382015-03-22 12:44:27 -0700[diff] [blame]3634 *
3635 * See also native_powr().
3636 */
3637extern float __attribute__((const, overloadable))
3638 powr(float base, float exponent);
3639
3640extern float2 __attribute__((const, overloadable))
3641 powr(float2 base, float2 exponent);
3642
3643extern float3 __attribute__((const, overloadable))
3644 powr(float3 base, float3 exponent);
3645
3646extern float4 __attribute__((const, overloadable))
3647 powr(float4 base, float4 exponent);
3648
3649/*
3650 * radians: Converts degrees into radians
3651 *
3652 * Converts from degrees to radians.
3653 */
3654extern float __attribute__((const, overloadable))
3655 radians(float v);
3656
3657extern float2 __attribute__((const, overloadable))
3658 radians(float2 v);
3659
3660extern float3 __attribute__((const, overloadable))
3661 radians(float3 v);
3662
3663extern float4 __attribute__((const, overloadable))
3664 radians(float4 v);
3665
3666/*
3667 * remainder: Remainder of a division
3668 *
Jean-Luc Brouillet6386ceb2015-04-28 15:06:30 -0700[diff] [blame^]3669 * Returns the remainder of (numerator / denominator), where the quotient is rounded towards
3670 * the nearest integer.
Jean-Luc Brouilletbe216382015-03-22 12:44:27 -0700[diff] [blame]3671 *
3672 * The function fmod() is similar but rounds toward the closest interger.
3673 * For example, fmod(-3.8f, 2.f) returns -1.8f (-3.8f - -1.f * 2.f)
3674 * while remainder(-3.8f, 2.f) returns 0.2f (-3.8f - -2.f * 2.f).
3675 */
3676extern float __attribute__((const, overloadable))
3677 remainder(float numerator, float denominator);
3678
3679extern float2 __attribute__((const, overloadable))
3680 remainder(float2 numerator, float2 denominator);
3681
3682extern float3 __attribute__((const, overloadable))
3683 remainder(float3 numerator, float3 denominator);
3684
3685extern float4 __attribute__((const, overloadable))
3686 remainder(float4 numerator, float4 denominator);
3687
3688/*
3689 * remquo: Remainder and quotient of a division
3690 *
3691 * Returns the quotient and the remainder of (numerator / denominator).
3692 *
3693 * Only the sign and lowest three bits of the quotient are guaranteed to be accurate.
3694 *
Jean-Luc Brouillet6386ceb2015-04-28 15:06:30 -0700[diff] [blame^]3695 * This function is useful for implementing periodic functions. The low three bits of the
3696 * quotient gives the quadrant and the remainder the distance within the quadrant.
3697 * For example, an implementation of sin(x) could call remquo(x, PI / 2.f, &quadrant)
3698 * to reduce very large value of x to something within a limited range.
Jean-Luc Brouilletbe216382015-03-22 12:44:27 -0700[diff] [blame]3699 *
Jean-Luc Brouillet6386ceb2015-04-28 15:06:30 -0700[diff] [blame^]3700 * Example: remquo(-23.5f, 8.f, &quot) sets the lowest three bits of quot to 3
3701 * and the sign negative. It returns 0.5f.
Jean-Luc Brouilletbe216382015-03-22 12:44:27 -0700[diff] [blame]3702 *
3703 * Parameters:
Jean-Luc Brouillet6386ceb2015-04-28 15:06:30 -0700[diff] [blame^]3704 * numerator: Numerator.
3705 * denominator: Denominator.
Jean-Luc Brouillet4a730042015-04-02 16:15:25 -0700[diff] [blame]3706 * quotient: *quotient will be set to the integer quotient.
Jean-Luc Brouilletbe216382015-03-22 12:44:27 -0700[diff] [blame]3707 *
Jean-Luc Brouillet6386ceb2015-04-28 15:06:30 -0700[diff] [blame^]3708 * Returns: Remainder, precise only for the low three bits.
Jean-Luc Brouilletbe216382015-03-22 12:44:27 -0700[diff] [blame]3709 */
3710extern float __attribute__((overloadable))
3711 remquo(float numerator, float denominator, int* quotient);
3712
3713extern float2 __attribute__((overloadable))
3714 remquo(float2 numerator, float2 denominator, int2* quotient);
3715
3716extern float3 __attribute__((overloadable))
3717 remquo(float3 numerator, float3 denominator, int3* quotient);
3718
3719extern float4 __attribute__((overloadable))
3720 remquo(float4 numerator, float4 denominator, int4* quotient);
3721
3722/*
3723 * rint: Round to even
3724 *
3725 * Rounds to the nearest integral value.
3726 *
Jean-Luc Brouillet6386ceb2015-04-28 15:06:30 -0700[diff] [blame^]3727 * rint() rounds half values to even. For example, rint(0.5f) returns 0.f and
3728 * rint(1.5f) returns 2.f. Similarly, rint(-0.5f) returns -0.f and
3729 * rint(-1.5f) returns -2.f.
Jean-Luc Brouilletbe216382015-03-22 12:44:27 -0700[diff] [blame]3730 *
3731 * round() is similar but rounds away from zero. trunc() truncates the decimal fraction.
3732 */
3733extern float __attribute__((const, overloadable))
3734 rint(float v);
3735
3736extern float2 __attribute__((const, overloadable))
3737 rint(float2 v);
3738
3739extern float3 __attribute__((const, overloadable))
3740 rint(float3 v);
3741
3742extern float4 __attribute__((const, overloadable))
3743 rint(float4 v);
3744
3745/*
3746 * rootn: Nth root
3747 *
3748 * Compute the Nth root of a value.
3749 *
3750 * See also native_rootn().
3751 */
3752extern float __attribute__((const, overloadable))
3753 rootn(float v, int n);
3754
3755extern float2 __attribute__((const, overloadable))
3756 rootn(float2 v, int2 n);
3757
3758extern float3 __attribute__((const, overloadable))
3759 rootn(float3 v, int3 n);
3760
3761extern float4 __attribute__((const, overloadable))
3762 rootn(float4 v, int4 n);
3763
3764/*
3765 * round: Round away from zero
3766 *
3767 * Round to the nearest integral value.
3768 *
Jean-Luc Brouillet6386ceb2015-04-28 15:06:30 -0700[diff] [blame^]3769 * round() rounds half values away from zero. For example, round(0.5f) returns 1.f
3770 * and round(1.5f) returns 2.f. Similarly, round(-0.5f) returns -1.f
3771 * and round(-1.5f) returns -2.f.
Jean-Luc Brouilletbe216382015-03-22 12:44:27 -0700[diff] [blame]3772 *
3773 * rint() is similar but rounds half values toward even. trunc() truncates the decimal fraction.
3774 */
3775extern float __attribute__((const, overloadable))
3776 round(float v);
3777
3778extern float2 __attribute__((const, overloadable))
3779 round(float2 v);
3780
3781extern float3 __attribute__((const, overloadable))
3782 round(float3 v);
3783
3784extern float4 __attribute__((const, overloadable))
3785 round(float4 v);
3786
3787/*
3788 * rsqrt: Reciprocal of a square root
3789 *
3790 * Returns (1 / sqrt(v)).
3791 *
3792 * See also half_rsqrt(), native_rsqrt().
3793 */
3794extern float __attribute__((const, overloadable))
3795 rsqrt(float v);
3796
3797extern float2 __attribute__((const, overloadable))
3798 rsqrt(float2 v);
3799
3800extern float3 __attribute__((const, overloadable))
3801 rsqrt(float3 v);
3802
3803extern float4 __attribute__((const, overloadable))
3804 rsqrt(float4 v);
3805
3806/*
3807 * sign: Sign of a value
3808 *
3809 * Returns the sign of a value.
3810 *
3811 * if (v < 0) return -1.f;
3812 * else if (v > 0) return 1.f;
3813 * else return 0.f;
3814 */
3815extern float __attribute__((const, overloadable))
3816 sign(float v);
3817
3818extern float2 __attribute__((const, overloadable))
3819 sign(float2 v);
3820
3821extern float3 __attribute__((const, overloadable))
3822 sign(float3 v);
3823
3824extern float4 __attribute__((const, overloadable))
3825 sign(float4 v);
3826
3827/*
3828 * sin: Sine
3829 *
3830 * Returns the sine of an angle measured in radians.
3831 *
3832 * See also native_sin().
3833 */
3834extern float __attribute__((const, overloadable))
3835 sin(float v);
3836
3837extern float2 __attribute__((const, overloadable))
3838 sin(float2 v);
3839
3840extern float3 __attribute__((const, overloadable))
3841 sin(float3 v);
3842
3843extern float4 __attribute__((const, overloadable))
3844 sin(float4 v);
3845
3846/*
3847 * sincos: Sine and cosine
3848 *
3849 * Returns the sine and cosine of a value.
3850 *
3851 * See also native_sincos().
3852 *
3853 * Parameters:
Jean-Luc Brouillet6386ceb2015-04-28 15:06:30 -0700[diff] [blame^]3854 * v: Incoming value in radians.
Jean-Luc Brouillet4a730042015-04-02 16:15:25 -0700[diff] [blame]3855 * cos: *cos will be set to the cosine value.
Jean-Luc Brouilletbe216382015-03-22 12:44:27 -0700[diff] [blame]3856 *
Jean-Luc Brouillet6386ceb2015-04-28 15:06:30 -0700[diff] [blame^]3857 * Returns: Sine of v.
Jean-Luc Brouilletbe216382015-03-22 12:44:27 -0700[diff] [blame]3858 */
3859extern float __attribute__((overloadable))
3860 sincos(float v, float* cos);
3861
3862extern float2 __attribute__((overloadable))
3863 sincos(float2 v, float2* cos);
3864
3865extern float3 __attribute__((overloadable))
3866 sincos(float3 v, float3* cos);
3867
3868extern float4 __attribute__((overloadable))
3869 sincos(float4 v, float4* cos);
3870
3871/*
3872 * sinh: Hyperbolic sine
3873 *
3874 * Returns the hyperbolic sine of v, where v is measured in radians.
3875 *
3876 * See also native_sinh().
3877 */
3878extern float __attribute__((const, overloadable))
3879 sinh(float v);
3880
3881extern float2 __attribute__((const, overloadable))
3882 sinh(float2 v);
3883
3884extern float3 __attribute__((const, overloadable))
3885 sinh(float3 v);
3886
3887extern float4 __attribute__((const, overloadable))
3888 sinh(float4 v);
3889
3890/*
3891 * sinpi: Sine of a number multiplied by pi
3892 *
3893 * Returns the sine of (v * pi), where (v * pi) is measured in radians.
3894 *
3895 * To get the sine of a value measured in degrees, call sinpi(v / 180.f).
3896 *
3897 * See also native_sinpi().
3898 */
3899extern float __attribute__((const, overloadable))
3900 sinpi(float v);
3901
3902extern float2 __attribute__((const, overloadable))
3903 sinpi(float2 v);
3904
3905extern float3 __attribute__((const, overloadable))
3906 sinpi(float3 v);
3907
3908extern float4 __attribute__((const, overloadable))
3909 sinpi(float4 v);
3910
3911/*
3912 * sqrt: Square root
3913 *
3914 * Returns the square root of a value.
3915 *
3916 * See also half_sqrt(), native_sqrt().
3917 */
3918extern float __attribute__((const, overloadable))
3919 sqrt(float v);
3920
3921extern float2 __attribute__((const, overloadable))
3922 sqrt(float2 v);
3923
3924extern float3 __attribute__((const, overloadable))
3925 sqrt(float3 v);
3926
3927extern float4 __attribute__((const, overloadable))
3928 sqrt(float4 v);
3929
3930/*
3931 * step: 0 if less than a value, 0 otherwise
3932 *
3933 * Returns 0.f if v < edge, 1.f otherwise.
3934 *
Jean-Luc Brouillet6386ceb2015-04-28 15:06:30 -0700[diff] [blame^]3935 * This can be useful to create conditional computations without using loops and branching
3936 * instructions. For example, instead of computing (a[i] < b[i]) ? 0.f : atan2(a[i], b[i])
3937 * for the corresponding elements of a vector, you could instead use step(a, b) * atan2(a, b).
Jean-Luc Brouilletbe216382015-03-22 12:44:27 -0700[diff] [blame]3938 */
3939extern float __attribute__((const, overloadable))
3940 step(float edge, float v);
3941
3942extern float2 __attribute__((const, overloadable))
3943 step(float2 edge, float2 v);
3944
3945extern float3 __attribute__((const, overloadable))
3946 step(float3 edge, float3 v);
3947
3948extern float4 __attribute__((const, overloadable))
3949 step(float4 edge, float4 v);
3950
3951extern float2 __attribute__((const, overloadable))
3952 step(float2 edge, float v);
3953
3954extern float3 __attribute__((const, overloadable))
3955 step(float3 edge, float v);
3956
3957extern float4 __attribute__((const, overloadable))
3958 step(float4 edge, float v);
3959
3960#if (defined(RS_VERSION) && (RS_VERSION >= 21))
3961extern float2 __attribute__((const, overloadable))
3962 step(float edge, float2 v);
3963#endif
3964
3965#if (defined(RS_VERSION) && (RS_VERSION >= 21))
3966extern float3 __attribute__((const, overloadable))
3967 step(float edge, float3 v);
3968#endif
3969
3970#if (defined(RS_VERSION) && (RS_VERSION >= 21))
3971extern float4 __attribute__((const, overloadable))
3972 step(float edge, float4 v);
3973#endif
3974
3975/*
3976 * tan: Tangent
3977 *
3978 * Returns the tangent of an angle measured in radians.
3979 *
3980 * See also native_tan().
3981 */
3982extern float __attribute__((const, overloadable))
3983 tan(float v);
3984
3985extern float2 __attribute__((const, overloadable))
3986 tan(float2 v);
3987
3988extern float3 __attribute__((const, overloadable))
3989 tan(float3 v);
3990
3991extern float4 __attribute__((const, overloadable))
3992 tan(float4 v);
3993
3994/*
3995 * tanh: Hyperbolic tangent
3996 *
3997 * Returns the hyperbolic tangent of a value.
3998 *
3999 * See also native_tanh().
4000 */
4001extern float __attribute__((const, overloadable))
4002 tanh(float v);
4003
4004extern float2 __attribute__((const, overloadable))
4005 tanh(float2 v);
4006
4007extern float3 __attribute__((const, overloadable))
4008 tanh(float3 v);
4009
4010extern float4 __attribute__((const, overloadable))
4011 tanh(float4 v);
4012
4013/*
4014 * tanpi: Tangent of a number multiplied by pi
4015 *
4016 * Returns the tangent of (v * pi), where (v * pi) is measured in radians.
4017 *
4018 * To get the tangent of a value measured in degrees, call tanpi(v / 180.f).
4019 *
4020 * See also native_tanpi().
4021 */
4022extern float __attribute__((const, overloadable))
4023 tanpi(float v);
4024
4025extern float2 __attribute__((const, overloadable))
4026 tanpi(float2 v);
4027
4028extern float3 __attribute__((const, overloadable))
4029 tanpi(float3 v);
4030
4031extern float4 __attribute__((const, overloadable))
4032 tanpi(float4 v);
4033
4034/*
4035 * tgamma: Gamma function
4036 *
4037 * Returns the gamma function of a value.
4038 *
4039 * See also lgamma().
4040 */
4041extern float __attribute__((const, overloadable))
4042 tgamma(float v);
4043
4044extern float2 __attribute__((const, overloadable))
4045 tgamma(float2 v);
4046
4047extern float3 __attribute__((const, overloadable))
4048 tgamma(float3 v);
4049
4050extern float4 __attribute__((const, overloadable))
4051 tgamma(float4 v);
4052
4053/*
4054 * trunc: Truncates a floating point
4055 *
4056 * Rounds to integral using truncation.
4057 *
4058 * For example, trunc(1.7f) returns 1.f and trunc(-1.7f) returns -1.f.
4059 *
4060 * See rint() and round() for other rounding options.
4061 */
4062extern float __attribute__((const, overloadable))
4063 trunc(float v);
4064
4065extern float2 __attribute__((const, overloadable))
4066 trunc(float2 v);
4067
4068extern float3 __attribute__((const, overloadable))
4069 trunc(float3 v);
4070
4071extern float4 __attribute__((const, overloadable))
4072 trunc(float4 v);
4073
4074/*
Jean-Luc Brouilletc5184e22015-03-13 13:51:24 -0700[diff] [blame]4075 * rsClamp: Restrain a value to a range
Jason Sams9df3b2b2011-08-08 14:31:25 -0700[diff] [blame]4076 *
Jean-Luc Brouillet20b27d62015-04-03 14:39:53 -0700[diff] [blame]4077 * DEPRECATED. Do not use.
Jason Sams044e2ee2011-08-08 16:52:30 -0700[diff] [blame]4078 *
Jean-Luc Brouillet20b27d62015-04-03 14:39:53 -0700[diff] [blame]4079 * Clamp a value between low and high.
Jean-Luc Brouilletc5184e22015-03-13 13:51:24 -0700[diff] [blame]4080 *
4081 * Parameters:
Jean-Luc Brouillet6386ceb2015-04-28 15:06:30 -0700[diff] [blame^]4082 * amount: Value to clamp.
4083 * low: Lower bound.
4084 * high: Upper bound.
Jason Sams9df3b2b2011-08-08 14:31:25 -0700[diff] [blame]4085 */
Jean-Luc Brouilletc5184e22015-03-13 13:51:24 -0700[diff] [blame]4086extern char __attribute__((const, always_inline, overloadable))
4087 rsClamp(char amount, char low, char high);
Jason Sams044e2ee2011-08-08 16:52:30 -0700[diff] [blame]4088
Jean-Luc Brouilletc5184e22015-03-13 13:51:24 -0700[diff] [blame]4089extern uchar __attribute__((const, always_inline, overloadable))
4090 rsClamp(uchar amount, uchar low, uchar high);
Jason Samsc61346b2010-05-28 18:23:22 -0700[diff] [blame]4091
Jean-Luc Brouilletc5184e22015-03-13 13:51:24 -0700[diff] [blame]4092extern short __attribute__((const, always_inline, overloadable))
4093 rsClamp(short amount, short low, short high);
Jason Samse1eb6152011-06-21 16:42:30 -0700[diff] [blame]4094
Jean-Luc Brouilletc5184e22015-03-13 13:51:24 -0700[diff] [blame]4095extern ushort __attribute__((const, always_inline, overloadable))
4096 rsClamp(ushort amount, ushort low, ushort high);
4097
4098extern int __attribute__((const, always_inline, overloadable))
4099 rsClamp(int amount, int low, int high);
4100
4101extern uint __attribute__((const, always_inline, overloadable))
4102 rsClamp(uint amount, uint low, uint high);
4103
4104/*
Jean-Luc Brouillet20b27d62015-04-03 14:39:53 -0700[diff] [blame]4105 * rsFrac: Returns the fractional part of a float
4106 *
4107 * DEPRECATED. Do not use.
4108 *
Jean-Luc Brouilletc5184e22015-03-13 13:51:24 -0700[diff] [blame]4109 * Returns the fractional part of a float
Jason Samse1eb6152011-06-21 16:42:30 -0700[diff] [blame]4110 */
Jean-Luc Brouilletc5184e22015-03-13 13:51:24 -0700[diff] [blame]4111extern float __attribute__((const, overloadable))
4112 rsFrac(float v);
Jason Sams044e2ee2011-08-08 16:52:30 -0700[diff] [blame]4113
Jean-Luc Brouilletc5184e22015-03-13 13:51:24 -0700[diff] [blame]4114/*
Jean-Luc Brouillet20b27d62015-04-03 14:39:53 -0700[diff] [blame]4115 * rsRand: Pseudo-random number
4116 *
Jean-Luc Brouilletc5184e22015-03-13 13:51:24 -0700[diff] [blame]4117 * Return a random value between 0 (or min_value) and max_malue.
Jason Samse1eb6152011-06-21 16:42:30 -0700[diff] [blame]4118 */
Jean-Luc Brouilletc5184e22015-03-13 13:51:24 -0700[diff] [blame]4119extern int __attribute__((overloadable))
4120 rsRand(int max_value);
Jason Samse1eb6152011-06-21 16:42:30 -0700[diff] [blame]4121
Jean-Luc Brouilletc5184e22015-03-13 13:51:24 -0700[diff] [blame]4122extern int __attribute__((overloadable))
4123 rsRand(int min_value, int max_value);
Jason Samse1eb6152011-06-21 16:42:30 -0700[diff] [blame]4124
Jean-Luc Brouilletc5184e22015-03-13 13:51:24 -0700[diff] [blame]4125extern float __attribute__((overloadable))
4126 rsRand(float max_value);
Jason Samse1eb6152011-06-21 16:42:30 -0700[diff] [blame]4127
Jean-Luc Brouilletc5184e22015-03-13 13:51:24 -0700[diff] [blame]4128extern float __attribute__((overloadable))
4129 rsRand(float min_value, float max_value);
4130
Jean-Luc Brouilletc5184e22015-03-13 13:51:24 -0700[diff] [blame]4131#endif // RENDERSCRIPT_RS_MATH_RSH