1 /* 2 * Copyright (C) 2015 The Android Open Source Project 3 * 4 * Licensed under the Apache License, Version 2.0 (the "License"); 5 * you may not use this file except in compliance with the License. 6 * You may obtain a copy of the License at 7 * 8 * http://www.apache.org/licenses/LICENSE-2.0 9 * 10 * Unless required by applicable law or agreed to in writing, software 11 * distributed under the License is distributed on an "AS IS" BASIS, 12 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. 13 * See the License for the specific language governing permissions and 14 * limitations under the License. 15 */ 16 17 // Don't edit this file! It is auto-generated by frameworks/rs/api/generate.sh. 18 19 /* 20 * rs_math.rsh: Mathematical Constants and Functions 21 * 22 * The mathematical functions below can be applied to scalars and vectors. When applied 23 * to vectors, the returned value is a vector of the function applied to each entry of the input. 24 * 25 * For example: 26 * float3 a, b; 27 * // The following call sets 28 * // a.x to sin(b.x), 29 * // a.y to sin(b.y), and 30 * // a.z to sin(b.z). 31 * a = sin(b); 32 * 33 * 34 * See Vector Math Functions for functions like distance() and length() that interpret 35 * instead the input as a single vector in n-dimensional space. 36 * 37 * The precision of the mathematical operations on 32 bit floats is affected by the pragmas 38 * rs_fp_relaxed and rs_fp_full. Under rs_fp_relaxed, subnormal values may be flushed to zero and 39 * rounding may be done towards zero. In comparison, rs_fp_full requires correct handling of 40 * subnormal values, i.e. smaller than 1.17549435e-38f. rs_fp_rull also requires round to nearest 41 * with ties to even. 42 * 43 * Different precision/speed tradeoffs can be achieved by using variants of the common math 44 * functions. Functions with a name starting with 45 * - native_: May have custom hardware implementations with weaker precision. Additionally, 46 * subnormal values may be flushed to zero, rounding towards zero may be used, and NaN and 47 * infinity input may not be handled correctly. 48 * - half_: May perform internal computations using 16 bit floats. Additionally, subnormal 49 * values may be flushed to zero, and rounding towards zero may be used. 50 * 51 */ 52 53 #ifndef RENDERSCRIPT_RS_MATH_RSH 54 #define RENDERSCRIPT_RS_MATH_RSH 55 56 /* 57 * M_1_PI: 1 / pi, as a 32 bit float 58 * 59 * The inverse of pi, as a 32 bit float. 60 */ 61 #define M_1_PI 0.318309886183790671537767526745028724f 62 63 /* 64 * M_2_PI: 2 / pi, as a 32 bit float 65 * 66 * 2 divided by pi, as a 32 bit float. 67 */ 68 #define M_2_PI 0.636619772367581343075535053490057448f 69 70 /* 71 * M_2_PIl: 2 / pi, as a 32 bit float 72 * 73 * DEPRECATED. Do not use. 74 * 75 * 2 divided by pi, as a 32 bit float. 76 */ 77 #define M_2_PIl 0.636619772367581343075535053490057448f 78 79 /* 80 * M_2_SQRTPI: 2 / sqrt(pi), as a 32 bit float 81 * 82 * 2 divided by the square root of pi, as a 32 bit float. 83 */ 84 #define M_2_SQRTPI 1.128379167095512573896158903121545172f 85 86 /* 87 * M_E: e, as a 32 bit float 88 * 89 * The number e, the base of the natural logarithm, as a 32 bit float. 90 */ 91 #define M_E 2.718281828459045235360287471352662498f 92 93 /* 94 * M_LN10: log_e(10), as a 32 bit float 95 * 96 * The natural logarithm of 10, as a 32 bit float. 97 */ 98 #define M_LN10 2.302585092994045684017991454684364208f 99 100 /* 101 * M_LN2: log_e(2), as a 32 bit float 102 * 103 * The natural logarithm of 2, as a 32 bit float. 104 */ 105 #define M_LN2 0.693147180559945309417232121458176568f 106 107 /* 108 * M_LOG10E: log_10(e), as a 32 bit float 109 * 110 * The logarithm base 10 of e, as a 32 bit float. 111 */ 112 #define M_LOG10E 0.434294481903251827651128918916605082f 113 114 /* 115 * M_LOG2E: log_2(e), as a 32 bit float 116 * 117 * The logarithm base 2 of e, as a 32 bit float. 118 */ 119 #define M_LOG2E 1.442695040888963407359924681001892137f 120 121 /* 122 * M_PI: pi, as a 32 bit float 123 * 124 * The constant pi, as a 32 bit float. 125 */ 126 #define M_PI 3.141592653589793238462643383279502884f 127 128 /* 129 * M_PI_2: pi / 2, as a 32 bit float 130 * 131 * Pi divided by 2, as a 32 bit float. 132 */ 133 #define M_PI_2 1.570796326794896619231321691639751442f 134 135 /* 136 * M_PI_4: pi / 4, as a 32 bit float 137 * 138 * Pi divided by 4, as a 32 bit float. 139 */ 140 #define M_PI_4 0.785398163397448309615660845819875721f 141 142 /* 143 * M_SQRT1_2: 1 / sqrt(2), as a 32 bit float 144 * 145 * The inverse of the square root of 2, as a 32 bit float. 146 */ 147 #define M_SQRT1_2 0.707106781186547524400844362104849039f 148 149 /* 150 * M_SQRT2: sqrt(2), as a 32 bit float 151 * 152 * The square root of 2, as a 32 bit float. 153 */ 154 #define M_SQRT2 1.414213562373095048801688724209698079f 155 156 /* 157 * abs: Absolute value of an integer 158 * 159 * Returns the absolute value of an integer. 160 * 161 * For floats, use fabs(). 162 */ 163 extern uchar __attribute__((const, overloadable)) 164 abs(char v); 165 166 extern uchar2 __attribute__((const, overloadable)) 167 abs(char2 v); 168 169 extern uchar3 __attribute__((const, overloadable)) 170 abs(char3 v); 171 172 extern uchar4 __attribute__((const, overloadable)) 173 abs(char4 v); 174 175 extern ushort __attribute__((const, overloadable)) 176 abs(short v); 177 178 extern ushort2 __attribute__((const, overloadable)) 179 abs(short2 v); 180 181 extern ushort3 __attribute__((const, overloadable)) 182 abs(short3 v); 183 184 extern ushort4 __attribute__((const, overloadable)) 185 abs(short4 v); 186 187 extern uint __attribute__((const, overloadable)) 188 abs(int v); 189 190 extern uint2 __attribute__((const, overloadable)) 191 abs(int2 v); 192 193 extern uint3 __attribute__((const, overloadable)) 194 abs(int3 v); 195 196 extern 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 */ 206 extern float __attribute__((const, overloadable)) 207 acos(float v); 208 209 extern float2 __attribute__((const, overloadable)) 210 acos(float2 v); 211 212 extern float3 __attribute__((const, overloadable)) 213 acos(float3 v); 214 215 extern 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 */ 225 extern float __attribute__((const, overloadable)) 226 acosh(float v); 227 228 extern float2 __attribute__((const, overloadable)) 229 acosh(float2 v); 230 231 extern float3 __attribute__((const, overloadable)) 232 acosh(float3 v); 233 234 extern 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 */ 246 extern float __attribute__((const, overloadable)) 247 acospi(float v); 248 249 extern float2 __attribute__((const, overloadable)) 250 acospi(float2 v); 251 252 extern float3 __attribute__((const, overloadable)) 253 acospi(float3 v); 254 255 extern 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 */ 265 extern float __attribute__((const, overloadable)) 266 asin(float v); 267 268 extern float2 __attribute__((const, overloadable)) 269 asin(float2 v); 270 271 extern float3 __attribute__((const, overloadable)) 272 asin(float3 v); 273 274 extern 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 */ 284 extern float __attribute__((const, overloadable)) 285 asinh(float v); 286 287 extern float2 __attribute__((const, overloadable)) 288 asinh(float2 v); 289 290 extern float3 __attribute__((const, overloadable)) 291 asinh(float3 v); 292 293 extern 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 */ 305 extern float __attribute__((const, overloadable)) 306 asinpi(float v); 307 308 extern float2 __attribute__((const, overloadable)) 309 asinpi(float2 v); 310 311 extern float3 __attribute__((const, overloadable)) 312 asinpi(float3 v); 313 314 extern 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 */ 324 extern float __attribute__((const, overloadable)) 325 atan(float v); 326 327 extern float2 __attribute__((const, overloadable)) 328 atan(float2 v); 329 330 extern float3 __attribute__((const, overloadable)) 331 atan(float3 v); 332 333 extern float4 __attribute__((const, overloadable)) 334 atan(float4 v); 335 336 /* 337 * atan2: Inverse tangent of a ratio 338 * 339 * Returns the inverse tangent of (numerator / denominator), in radians. 340 * 341 * See also native_atan2(). 342 * 343 * Parameters: 344 * numerator: Numerator. 345 * denominator: Denominator. Can be 0. 346 */ 347 extern float __attribute__((const, overloadable)) 348 atan2(float numerator, float denominator); 349 350 extern float2 __attribute__((const, overloadable)) 351 atan2(float2 numerator, float2 denominator); 352 353 extern float3 __attribute__((const, overloadable)) 354 atan2(float3 numerator, float3 denominator); 355 356 extern float4 __attribute__((const, overloadable)) 357 atan2(float4 numerator, float4 denominator); 358 359 /* 360 * atan2pi: Inverse tangent of a ratio, divided by pi 361 * 362 * Returns the inverse tangent of (numerator / denominator), in radians, divided by pi. 363 * 364 * To get an inverse tangent measured in degrees, use atan2pi(n, d) * 180.f. 365 * 366 * See also native_atan2pi(). 367 * 368 * Parameters: 369 * numerator: Numerator. 370 * denominator: Denominator. Can be 0. 371 */ 372 extern float __attribute__((const, overloadable)) 373 atan2pi(float numerator, float denominator); 374 375 extern float2 __attribute__((const, overloadable)) 376 atan2pi(float2 numerator, float2 denominator); 377 378 extern float3 __attribute__((const, overloadable)) 379 atan2pi(float3 numerator, float3 denominator); 380 381 extern 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 */ 391 extern float __attribute__((const, overloadable)) 392 atanh(float v); 393 394 extern float2 __attribute__((const, overloadable)) 395 atanh(float2 v); 396 397 extern float3 __attribute__((const, overloadable)) 398 atanh(float3 v); 399 400 extern 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 */ 412 extern float __attribute__((const, overloadable)) 413 atanpi(float v); 414 415 extern float2 __attribute__((const, overloadable)) 416 atanpi(float2 v); 417 418 extern float3 __attribute__((const, overloadable)) 419 atanpi(float3 v); 420 421 extern 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 */ 431 extern float __attribute__((const, overloadable)) 432 cbrt(float v); 433 434 extern float2 __attribute__((const, overloadable)) 435 cbrt(float2 v); 436 437 extern float3 __attribute__((const, overloadable)) 438 cbrt(float3 v); 439 440 extern 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 */ 452 extern float __attribute__((const, overloadable)) 453 ceil(float v); 454 455 extern float2 __attribute__((const, overloadable)) 456 ceil(float2 v); 457 458 extern float3 __attribute__((const, overloadable)) 459 ceil(float3 v); 460 461 extern float4 __attribute__((const, overloadable)) 462 ceil(float4 v); 463 464 /* 465 * clamp: Restrain a value to a range 466 * 467 * Clamps a value to a specified high and low bound. clamp() returns min_value 468 * if value < min_value, max_value if value > max_value, otherwise value. 469 * 470 * There are two variants of clamp: one where the min and max are scalars applied 471 * to all entries of the value, the other where the min and max are also vectors. 472 * 473 * If min_value is greater than max_value, the results are undefined. 474 * 475 * Parameters: 476 * value: Value to be clamped. 477 * min_value: Lower bound, a scalar or matching vector. 478 * max_value: High bound, must match the type of low. 479 */ 480 extern float __attribute__((const, overloadable)) 481 clamp(float value, float min_value, float max_value); 482 483 extern float2 __attribute__((const, overloadable)) 484 clamp(float2 value, float2 min_value, float2 max_value); 485 486 extern float3 __attribute__((const, overloadable)) 487 clamp(float3 value, float3 min_value, float3 max_value); 488 489 extern float4 __attribute__((const, overloadable)) 490 clamp(float4 value, float4 min_value, float4 max_value); 491 492 extern float2 __attribute__((const, overloadable)) 493 clamp(float2 value, float min_value, float max_value); 494 495 extern float3 __attribute__((const, overloadable)) 496 clamp(float3 value, float min_value, float max_value); 497 498 extern float4 __attribute__((const, overloadable)) 499 clamp(float4 value, float min_value, float max_value); 500 501 #if (defined(RS_VERSION) && (RS_VERSION >= 19)) 502 extern 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)) 507 extern 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)) 512 extern 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)) 517 extern 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)) 522 extern 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)) 527 extern 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)) 532 extern 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)) 537 extern 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)) 542 extern 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)) 547 extern 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)) 552 extern 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)) 557 extern 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)) 562 extern 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)) 567 extern 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)) 572 extern 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)) 577 extern 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)) 582 extern 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)) 587 extern 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)) 592 extern 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)) 597 extern 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)) 602 extern 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)) 607 extern 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)) 612 extern 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)) 617 extern 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)) 622 extern 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)) 627 extern 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)) 632 extern 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)) 637 extern 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)) 642 extern 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)) 647 extern 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)) 652 extern 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)) 657 extern 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)) 662 extern 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)) 667 extern 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)) 672 extern 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)) 677 extern 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)) 682 extern 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)) 687 extern 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)) 692 extern 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)) 697 extern 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)) 702 extern 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)) 707 extern 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)) 712 extern 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)) 717 extern 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)) 722 extern 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)) 727 extern 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)) 732 extern 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)) 737 extern 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)) 742 extern 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)) 747 extern 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)) 752 extern 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)) 757 extern 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)) 762 extern 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)) 767 extern 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)) 772 extern 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)) 777 extern 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 */ 788 extern char __attribute__((const, overloadable)) 789 clz(char value); 790 791 extern char2 __attribute__((const, overloadable)) 792 clz(char2 value); 793 794 extern char3 __attribute__((const, overloadable)) 795 clz(char3 value); 796 797 extern char4 __attribute__((const, overloadable)) 798 clz(char4 value); 799 800 extern uchar __attribute__((const, overloadable)) 801 clz(uchar value); 802 803 extern uchar2 __attribute__((const, overloadable)) 804 clz(uchar2 value); 805 806 extern uchar3 __attribute__((const, overloadable)) 807 clz(uchar3 value); 808 809 extern uchar4 __attribute__((const, overloadable)) 810 clz(uchar4 value); 811 812 extern short __attribute__((const, overloadable)) 813 clz(short value); 814 815 extern short2 __attribute__((const, overloadable)) 816 clz(short2 value); 817 818 extern short3 __attribute__((const, overloadable)) 819 clz(short3 value); 820 821 extern short4 __attribute__((const, overloadable)) 822 clz(short4 value); 823 824 extern ushort __attribute__((const, overloadable)) 825 clz(ushort value); 826 827 extern ushort2 __attribute__((const, overloadable)) 828 clz(ushort2 value); 829 830 extern ushort3 __attribute__((const, overloadable)) 831 clz(ushort3 value); 832 833 extern ushort4 __attribute__((const, overloadable)) 834 clz(ushort4 value); 835 836 extern int __attribute__((const, overloadable)) 837 clz(int value); 838 839 extern int2 __attribute__((const, overloadable)) 840 clz(int2 value); 841 842 extern int3 __attribute__((const, overloadable)) 843 clz(int3 value); 844 845 extern int4 __attribute__((const, overloadable)) 846 clz(int4 value); 847 848 extern uint __attribute__((const, overloadable)) 849 clz(uint value); 850 851 extern uint2 __attribute__((const, overloadable)) 852 clz(uint2 value); 853 854 extern uint3 __attribute__((const, overloadable)) 855 clz(uint3 value); 856 857 extern 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 */ 869 extern float __attribute__((const, overloadable)) 870 copysign(float magnitude_value, float sign_value); 871 872 extern float2 __attribute__((const, overloadable)) 873 copysign(float2 magnitude_value, float2 sign_value); 874 875 extern float3 __attribute__((const, overloadable)) 876 copysign(float3 magnitude_value, float3 sign_value); 877 878 extern 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 */ 888 extern float __attribute__((const, overloadable)) 889 cos(float v); 890 891 extern float2 __attribute__((const, overloadable)) 892 cos(float2 v); 893 894 extern float3 __attribute__((const, overloadable)) 895 cos(float3 v); 896 897 extern 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 */ 907 extern float __attribute__((const, overloadable)) 908 cosh(float v); 909 910 extern float2 __attribute__((const, overloadable)) 911 cosh(float2 v); 912 913 extern float3 __attribute__((const, overloadable)) 914 cosh(float3 v); 915 916 extern 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 */ 928 extern float __attribute__((const, overloadable)) 929 cospi(float v); 930 931 extern float2 __attribute__((const, overloadable)) 932 cospi(float2 v); 933 934 extern float3 __attribute__((const, overloadable)) 935 cospi(float3 v); 936 937 extern float4 __attribute__((const, overloadable)) 938 cospi(float4 v); 939 940 /* 941 * degrees: Converts radians into degrees 942 * 943 * Converts from radians to degrees. 944 */ 945 extern float __attribute__((const, overloadable)) 946 degrees(float v); 947 948 extern float2 __attribute__((const, overloadable)) 949 degrees(float2 v); 950 951 extern float3 __attribute__((const, overloadable)) 952 degrees(float3 v); 953 954 extern float4 __attribute__((const, overloadable)) 955 degrees(float4 v); 956 957 /* 958 * erf: Mathematical error function 959 * 960 * Returns the error function. 961 */ 962 extern float __attribute__((const, overloadable)) 963 erf(float v); 964 965 extern float2 __attribute__((const, overloadable)) 966 erf(float2 v); 967 968 extern float3 __attribute__((const, overloadable)) 969 erf(float3 v); 970 971 extern float4 __attribute__((const, overloadable)) 972 erf(float4 v); 973 974 /* 975 * erfc: Mathematical complementary error function 976 * 977 * Returns the complementary error function. 978 */ 979 extern float __attribute__((const, overloadable)) 980 erfc(float v); 981 982 extern float2 __attribute__((const, overloadable)) 983 erfc(float2 v); 984 985 extern float3 __attribute__((const, overloadable)) 986 erfc(float3 v); 987 988 extern 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 */ 998 extern float __attribute__((const, overloadable)) 999 exp(float v); 1000 1001 extern float2 __attribute__((const, overloadable)) 1002 exp(float2 v); 1003 1004 extern float3 __attribute__((const, overloadable)) 1005 exp(float3 v); 1006 1007 extern 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 */ 1017 extern float __attribute__((const, overloadable)) 1018 exp10(float v); 1019 1020 extern float2 __attribute__((const, overloadable)) 1021 exp10(float2 v); 1022 1023 extern float3 __attribute__((const, overloadable)) 1024 exp10(float3 v); 1025 1026 extern 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 */ 1036 extern float __attribute__((const, overloadable)) 1037 exp2(float v); 1038 1039 extern float2 __attribute__((const, overloadable)) 1040 exp2(float2 v); 1041 1042 extern float3 __attribute__((const, overloadable)) 1043 exp2(float3 v); 1044 1045 extern 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 */ 1055 extern float __attribute__((const, overloadable)) 1056 expm1(float v); 1057 1058 extern float2 __attribute__((const, overloadable)) 1059 expm1(float2 v); 1060 1061 extern float3 __attribute__((const, overloadable)) 1062 expm1(float3 v); 1063 1064 extern 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 */ 1074 extern float __attribute__((const, overloadable)) 1075 fabs(float v); 1076 1077 extern float2 __attribute__((const, overloadable)) 1078 fabs(float2 v); 1079 1080 extern float3 __attribute__((const, overloadable)) 1081 fabs(float3 v); 1082 1083 extern 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 */ 1093 extern float __attribute__((const, overloadable)) 1094 fdim(float a, float b); 1095 1096 extern float2 __attribute__((const, overloadable)) 1097 fdim(float2 a, float2 b); 1098 1099 extern float3 __attribute__((const, overloadable)) 1100 fdim(float3 a, float3 b); 1101 1102 extern 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 */ 1114 extern float __attribute__((const, overloadable)) 1115 floor(float v); 1116 1117 extern float2 __attribute__((const, overloadable)) 1118 floor(float2 v); 1119 1120 extern float3 __attribute__((const, overloadable)) 1121 floor(float3 v); 1122 1123 extern float4 __attribute__((const, overloadable)) 1124 floor(float4 v); 1125 1126 /* 1127 * fma: Multiply and add 1128 * 1129 * Multiply and add. Returns (multiplicand1 * multiplicand2) + offset. 1130 * 1131 * This function is similar to mad(). fma() retains full precision of the multiplied result 1132 * and rounds only after the addition. mad() rounds after the multiplication and the addition. 1133 * This extra precision is not guaranteed in rs_fp_relaxed mode. 1134 */ 1135 extern float __attribute__((const, overloadable)) 1136 fma(float multiplicand1, float multiplicand2, float offset); 1137 1138 extern float2 __attribute__((const, overloadable)) 1139 fma(float2 multiplicand1, float2 multiplicand2, float2 offset); 1140 1141 extern float3 __attribute__((const, overloadable)) 1142 fma(float3 multiplicand1, float3 multiplicand2, float3 offset); 1143 1144 extern 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 */ 1154 extern float __attribute__((const, overloadable)) 1155 fmax(float a, float b); 1156 1157 extern float2 __attribute__((const, overloadable)) 1158 fmax(float2 a, float2 b); 1159 1160 extern float3 __attribute__((const, overloadable)) 1161 fmax(float3 a, float3 b); 1162 1163 extern float4 __attribute__((const, overloadable)) 1164 fmax(float4 a, float4 b); 1165 1166 extern float2 __attribute__((const, overloadable)) 1167 fmax(float2 a, float b); 1168 1169 extern float3 __attribute__((const, overloadable)) 1170 fmax(float3 a, float b); 1171 1172 extern 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 */ 1182 extern float __attribute__((const, overloadable)) 1183 fmin(float a, float b); 1184 1185 extern float2 __attribute__((const, overloadable)) 1186 fmin(float2 a, float2 b); 1187 1188 extern float3 __attribute__((const, overloadable)) 1189 fmin(float3 a, float3 b); 1190 1191 extern float4 __attribute__((const, overloadable)) 1192 fmin(float4 a, float4 b); 1193 1194 extern float2 __attribute__((const, overloadable)) 1195 fmin(float2 a, float b); 1196 1197 extern float3 __attribute__((const, overloadable)) 1198 fmin(float3 a, float b); 1199 1200 extern 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 */ 1212 extern float __attribute__((const, overloadable)) 1213 fmod(float numerator, float denominator); 1214 1215 extern float2 __attribute__((const, overloadable)) 1216 fmod(float2 numerator, float2 denominator); 1217 1218 extern float3 __attribute__((const, overloadable)) 1219 fmod(float3 numerator, float3 denominator); 1220 1221 extern float4 __attribute__((const, overloadable)) 1222 fmod(float4 numerator, float4 denominator); 1223 1224 /* 1225 * fract: Positive fractional part 1226 * 1227 * Returns the positive fractional part of v, i.e. v - floor(v). 1228 * 1229 * For example, fract(1.3f, &val) returns 0.3f and sets val to 1.f. 1230 * fract(-1.3f, &val) returns 0.7f and sets val to -2.f. 1231 * 1232 * Parameters: 1233 * v: Input value. 1234 * floor: If floor is not null, *floor will be set to the floor of v. 1235 */ 1236 extern float __attribute__((overloadable)) 1237 fract(float v, float* floor); 1238 1239 extern float2 __attribute__((overloadable)) 1240 fract(float2 v, float2* floor); 1241 1242 extern float3 __attribute__((overloadable)) 1243 fract(float3 v, float3* floor); 1244 1245 extern float4 __attribute__((overloadable)) 1246 fract(float4 v, float4* floor); 1247 1248 static inline float __attribute__((const, overloadable)) 1249 fract(float v) { 1250 float unused; 1251 return fract(v, &unused); 1252 } 1253 1254 static inline float2 __attribute__((const, overloadable)) 1255 fract(float2 v) { 1256 float2 unused; 1257 return fract(v, &unused); 1258 } 1259 1260 static inline float3 __attribute__((const, overloadable)) 1261 fract(float3 v) { 1262 float3 unused; 1263 return fract(v, &unused); 1264 } 1265 1266 static inline float4 __attribute__((const, overloadable)) 1267 fract(float4 v) { 1268 float4 unused; 1269 return fract(v, &unused); 1270 } 1271 1272 /* 1273 * frexp: Binary mantissa and exponent 1274 * 1275 * Returns the binary mantissa and exponent of v, i.e. v == mantissa * 2 ^ exponent. 1276 * 1277 * The mantissa is always between 0.5 (inclusive) and 1.0 (exclusive). 1278 * 1279 * See ldexp() for the reverse operation. See also logb() and ilogb(). 1280 * 1281 * Parameters: 1282 * v: Input value. 1283 * exponent: If exponent is not null, *exponent will be set to the exponent of v. 1284 */ 1285 extern float __attribute__((overloadable)) 1286 frexp(float v, int* exponent); 1287 1288 extern float2 __attribute__((overloadable)) 1289 frexp(float2 v, int2* exponent); 1290 1291 extern float3 __attribute__((overloadable)) 1292 frexp(float3 v, int3* exponent); 1293 1294 extern 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)) 1307 extern float __attribute__((const, overloadable)) 1308 half_recip(float v); 1309 #endif 1310 1311 #if (defined(RS_VERSION) && (RS_VERSION >= 17)) 1312 extern float2 __attribute__((const, overloadable)) 1313 half_recip(float2 v); 1314 #endif 1315 1316 #if (defined(RS_VERSION) && (RS_VERSION >= 17)) 1317 extern float3 __attribute__((const, overloadable)) 1318 half_recip(float3 v); 1319 #endif 1320 1321 #if (defined(RS_VERSION) && (RS_VERSION >= 17)) 1322 extern 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)) 1336 extern float __attribute__((const, overloadable)) 1337 half_rsqrt(float v); 1338 #endif 1339 1340 #if (defined(RS_VERSION) && (RS_VERSION >= 17)) 1341 extern float2 __attribute__((const, overloadable)) 1342 half_rsqrt(float2 v); 1343 #endif 1344 1345 #if (defined(RS_VERSION) && (RS_VERSION >= 17)) 1346 extern float3 __attribute__((const, overloadable)) 1347 half_rsqrt(float3 v); 1348 #endif 1349 1350 #if (defined(RS_VERSION) && (RS_VERSION >= 17)) 1351 extern 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)) 1365 extern float __attribute__((const, overloadable)) 1366 half_sqrt(float v); 1367 #endif 1368 1369 #if (defined(RS_VERSION) && (RS_VERSION >= 17)) 1370 extern float2 __attribute__((const, overloadable)) 1371 half_sqrt(float2 v); 1372 #endif 1373 1374 #if (defined(RS_VERSION) && (RS_VERSION >= 17)) 1375 extern float3 __attribute__((const, overloadable)) 1376 half_sqrt(float3 v); 1377 #endif 1378 1379 #if (defined(RS_VERSION) && (RS_VERSION >= 17)) 1380 extern 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 */ 1391 extern float __attribute__((const, overloadable)) 1392 hypot(float a, float b); 1393 1394 extern float2 __attribute__((const, overloadable)) 1395 hypot(float2 a, float2 b); 1396 1397 extern float3 __attribute__((const, overloadable)) 1398 hypot(float3 a, float3 b); 1399 1400 extern float4 __attribute__((const, overloadable)) 1401 hypot(float4 a, float4 b); 1402 1403 /* 1404 * ilogb: Base two exponent 1405 * 1406 * Returns the base two exponent of a value, where the mantissa is between 1407 * 1.f (inclusive) and 2.f (exclusive). 1408 * 1409 * For example, ilogb(8.5f) returns 3. 1410 * 1411 * Because of the difference in mantissa, this number is one less than is returned by frexp(). 1412 * 1413 * logb() is similar but returns a float. 1414 */ 1415 extern int __attribute__((const, overloadable)) 1416 ilogb(float v); 1417 1418 extern int2 __attribute__((const, overloadable)) 1419 ilogb(float2 v); 1420 1421 extern int3 __attribute__((const, overloadable)) 1422 ilogb(float3 v); 1423 1424 extern int4 __attribute__((const, overloadable)) 1425 ilogb(float4 v); 1426 1427 /* 1428 * ldexp: Creates a floating point from mantissa and exponent 1429 * 1430 * Returns the floating point created from the mantissa and exponent, 1431 * i.e. (mantissa * 2 ^ exponent). 1432 * 1433 * See frexp() for the reverse operation. 1434 * 1435 * Parameters: 1436 * mantissa: Mantissa. 1437 * exponent: Exponent, a single component or matching vector. 1438 */ 1439 extern float __attribute__((const, overloadable)) 1440 ldexp(float mantissa, int exponent); 1441 1442 extern float2 __attribute__((const, overloadable)) 1443 ldexp(float2 mantissa, int2 exponent); 1444 1445 extern float3 __attribute__((const, overloadable)) 1446 ldexp(float3 mantissa, int3 exponent); 1447 1448 extern float4 __attribute__((const, overloadable)) 1449 ldexp(float4 mantissa, int4 exponent); 1450 1451 extern float2 __attribute__((const, overloadable)) 1452 ldexp(float2 mantissa, int exponent); 1453 1454 extern float3 __attribute__((const, overloadable)) 1455 ldexp(float3 mantissa, int exponent); 1456 1457 extern float4 __attribute__((const, overloadable)) 1458 ldexp(float4 mantissa, int exponent); 1459 1460 /* 1461 * lgamma: Natural logarithm of the gamma function 1462 * 1463 * Returns the natural logarithm of the absolute value of the gamma function, 1464 * i.e. log(fabs(tgamma(v))). 1465 * 1466 * See also tgamma(). 1467 * 1468 * Parameters: 1469 * sign_of_gamma: If sign_of_gamma is not null, *sign_of_gamma will be set to -1.f if the gamma of v is negative, otherwise to 1.f. 1470 */ 1471 extern float __attribute__((const, overloadable)) 1472 lgamma(float v); 1473 1474 extern float2 __attribute__((const, overloadable)) 1475 lgamma(float2 v); 1476 1477 extern float3 __attribute__((const, overloadable)) 1478 lgamma(float3 v); 1479 1480 extern float4 __attribute__((const, overloadable)) 1481 lgamma(float4 v); 1482 1483 extern float __attribute__((overloadable)) 1484 lgamma(float v, int* sign_of_gamma); 1485 1486 extern float2 __attribute__((overloadable)) 1487 lgamma(float2 v, int2* sign_of_gamma); 1488 1489 extern float3 __attribute__((overloadable)) 1490 lgamma(float3 v, int3* sign_of_gamma); 1491 1492 extern 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 */ 1502 extern float __attribute__((const, overloadable)) 1503 log(float v); 1504 1505 extern float2 __attribute__((const, overloadable)) 1506 log(float2 v); 1507 1508 extern float3 __attribute__((const, overloadable)) 1509 log(float3 v); 1510 1511 extern 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 */ 1521 extern float __attribute__((const, overloadable)) 1522 log10(float v); 1523 1524 extern float2 __attribute__((const, overloadable)) 1525 log10(float2 v); 1526 1527 extern float3 __attribute__((const, overloadable)) 1528 log10(float3 v); 1529 1530 extern 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 */ 1540 extern float __attribute__((const, overloadable)) 1541 log1p(float v); 1542 1543 extern float2 __attribute__((const, overloadable)) 1544 log1p(float2 v); 1545 1546 extern float3 __attribute__((const, overloadable)) 1547 log1p(float3 v); 1548 1549 extern 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 */ 1559 extern float __attribute__((const, overloadable)) 1560 log2(float v); 1561 1562 extern float2 __attribute__((const, overloadable)) 1563 log2(float2 v); 1564 1565 extern float3 __attribute__((const, overloadable)) 1566 log2(float3 v); 1567 1568 extern float4 __attribute__((const, overloadable)) 1569 log2(float4 v); 1570 1571 /* 1572 * logb: Base two exponent 1573 * 1574 * Returns the base two exponent of a value, where the mantissa is between 1575 * 1.f (inclusive) and 2.f (exclusive). 1576 * 1577 * For example, logb(8.5f) returns 3.f. 1578 * 1579 * Because of the difference in mantissa, this number is one less than is returned by frexp(). 1580 * 1581 * ilogb() is similar but returns an integer. 1582 */ 1583 extern float __attribute__((const, overloadable)) 1584 logb(float v); 1585 1586 extern float2 __attribute__((const, overloadable)) 1587 logb(float2 v); 1588 1589 extern float3 __attribute__((const, overloadable)) 1590 logb(float3 v); 1591 1592 extern float4 __attribute__((const, overloadable)) 1593 logb(float4 v); 1594 1595 /* 1596 * mad: Multiply and add 1597 * 1598 * Multiply and add. Returns (multiplicand1 * multiplicand2) + offset. 1599 * 1600 * This function is similar to fma(). fma() retains full precision of the multiplied result 1601 * and rounds only after the addition. mad() rounds after the multiplication and the addition. 1602 * In rs_fp_relaxed mode, mad() may not do the rounding after multiplicaiton. 1603 */ 1604 extern float __attribute__((const, overloadable)) 1605 mad(float multiplicand1, float multiplicand2, float offset); 1606 1607 extern float2 __attribute__((const, overloadable)) 1608 mad(float2 multiplicand1, float2 multiplicand2, float2 offset); 1609 1610 extern float3 __attribute__((const, overloadable)) 1611 mad(float3 multiplicand1, float3 multiplicand2, float3 offset); 1612 1613 extern 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 */ 1621 extern float __attribute__((const, overloadable)) 1622 max(float a, float b); 1623 1624 extern float2 __attribute__((const, overloadable)) 1625 max(float2 a, float2 b); 1626 1627 extern float3 __attribute__((const, overloadable)) 1628 max(float3 a, float3 b); 1629 1630 extern float4 __attribute__((const, overloadable)) 1631 max(float4 a, float4 b); 1632 1633 #if !defined(RS_VERSION) || (RS_VERSION <= 20) 1634 static 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) 1641 static 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) 1648 static 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) 1655 static 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) 1662 static 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) 1669 static 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) 1676 static 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) 1686 static 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) 1696 static 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) 1706 static 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) 1716 static 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) 1726 static 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) 1736 static 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) 1747 static 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) 1758 static 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) 1769 static 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) 1780 static 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) 1791 static 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) 1802 static 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) 1814 static 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) 1826 static 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) 1838 static 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) 1850 static 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) 1862 static 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)) 1874 extern char __attribute__((const, overloadable)) 1875 max(char a, char b); 1876 #endif 1877 1878 #if (defined(RS_VERSION) && (RS_VERSION >= 21)) 1879 extern char2 __attribute__((const, overloadable)) 1880 max(char2 a, char2 b); 1881 #endif 1882 1883 #if (defined(RS_VERSION) && (RS_VERSION >= 21)) 1884 extern char3 __attribute__((const, overloadable)) 1885 max(char3 a, char3 b); 1886 #endif 1887 1888 #if (defined(RS_VERSION) && (RS_VERSION >= 21)) 1889 extern char4 __attribute__((const, overloadable)) 1890 max(char4 a, char4 b); 1891 #endif 1892 1893 #if (defined(RS_VERSION) && (RS_VERSION >= 21)) 1894 extern uchar __attribute__((const, overloadable)) 1895 max(uchar a, uchar b); 1896 #endif 1897 1898 #if (defined(RS_VERSION) && (RS_VERSION >= 21)) 1899 extern uchar2 __attribute__((const, overloadable)) 1900 max(uchar2 a, uchar2 b); 1901 #endif 1902 1903 #if (defined(RS_VERSION) && (RS_VERSION >= 21)) 1904 extern uchar3 __attribute__((const, overloadable)) 1905 max(uchar3 a, uchar3 b); 1906 #endif 1907 1908 #if (defined(RS_VERSION) && (RS_VERSION >= 21)) 1909 extern uchar4 __attribute__((const, overloadable)) 1910 max(uchar4 a, uchar4 b); 1911 #endif 1912 1913 #if (defined(RS_VERSION) && (RS_VERSION >= 21)) 1914 extern short __attribute__((const, overloadable)) 1915 max(short a, short b); 1916 #endif 1917 1918 #if (defined(RS_VERSION) && (RS_VERSION >= 21)) 1919 extern short2 __attribute__((const, overloadable)) 1920 max(short2 a, short2 b); 1921 #endif 1922 1923 #if (defined(RS_VERSION) && (RS_VERSION >= 21)) 1924 extern short3 __attribute__((const, overloadable)) 1925 max(short3 a, short3 b); 1926 #endif 1927 1928 #if (defined(RS_VERSION) && (RS_VERSION >= 21)) 1929 extern short4 __attribute__((const, overloadable)) 1930 max(short4 a, short4 b); 1931 #endif 1932 1933 #if (defined(RS_VERSION) && (RS_VERSION >= 21)) 1934 extern ushort __attribute__((const, overloadable)) 1935 max(ushort a, ushort b); 1936 #endif 1937 1938 #if (defined(RS_VERSION) && (RS_VERSION >= 21)) 1939 extern ushort2 __attribute__((const, overloadable)) 1940 max(ushort2 a, ushort2 b); 1941 #endif 1942 1943 #if (defined(RS_VERSION) && (RS_VERSION >= 21)) 1944 extern ushort3 __attribute__((const, overloadable)) 1945 max(ushort3 a, ushort3 b); 1946 #endif 1947 1948 #if (defined(RS_VERSION) && (RS_VERSION >= 21)) 1949 extern ushort4 __attribute__((const, overloadable)) 1950 max(ushort4 a, ushort4 b); 1951 #endif 1952 1953 #if (defined(RS_VERSION) && (RS_VERSION >= 21)) 1954 extern int __attribute__((const, overloadable)) 1955 max(int a, int b); 1956 #endif 1957 1958 #if (defined(RS_VERSION) && (RS_VERSION >= 21)) 1959 extern int2 __attribute__((const, overloadable)) 1960 max(int2 a, int2 b); 1961 #endif 1962 1963 #if (defined(RS_VERSION) && (RS_VERSION >= 21)) 1964 extern int3 __attribute__((const, overloadable)) 1965 max(int3 a, int3 b); 1966 #endif 1967 1968 #if (defined(RS_VERSION) && (RS_VERSION >= 21)) 1969 extern int4 __attribute__((const, overloadable)) 1970 max(int4 a, int4 b); 1971 #endif 1972 1973 #if (defined(RS_VERSION) && (RS_VERSION >= 21)) 1974 extern uint __attribute__((const, overloadable)) 1975 max(uint a, uint b); 1976 #endif 1977 1978 #if (defined(RS_VERSION) && (RS_VERSION >= 21)) 1979 extern uint2 __attribute__((const, overloadable)) 1980 max(uint2 a, uint2 b); 1981 #endif 1982 1983 #if (defined(RS_VERSION) && (RS_VERSION >= 21)) 1984 extern uint3 __attribute__((const, overloadable)) 1985 max(uint3 a, uint3 b); 1986 #endif 1987 1988 #if (defined(RS_VERSION) && (RS_VERSION >= 21)) 1989 extern uint4 __attribute__((const, overloadable)) 1990 max(uint4 a, uint4 b); 1991 #endif 1992 1993 #if (defined(RS_VERSION) && (RS_VERSION >= 21)) 1994 extern long __attribute__((const, overloadable)) 1995 max(long a, long b); 1996 #endif 1997 1998 #if (defined(RS_VERSION) && (RS_VERSION >= 21)) 1999 extern long2 __attribute__((const, overloadable)) 2000 max(long2 a, long2 b); 2001 #endif 2002 2003 #if (defined(RS_VERSION) && (RS_VERSION >= 21)) 2004 extern long3 __attribute__((const, overloadable)) 2005 max(long3 a, long3 b); 2006 #endif 2007 2008 #if (defined(RS_VERSION) && (RS_VERSION >= 21)) 2009 extern long4 __attribute__((const, overloadable)) 2010 max(long4 a, long4 b); 2011 #endif 2012 2013 #if (defined(RS_VERSION) && (RS_VERSION >= 21)) 2014 extern ulong __attribute__((const, overloadable)) 2015 max(ulong a, ulong b); 2016 #endif 2017 2018 #if (defined(RS_VERSION) && (RS_VERSION >= 21)) 2019 extern ulong2 __attribute__((const, overloadable)) 2020 max(ulong2 a, ulong2 b); 2021 #endif 2022 2023 #if (defined(RS_VERSION) && (RS_VERSION >= 21)) 2024 extern ulong3 __attribute__((const, overloadable)) 2025 max(ulong3 a, ulong3 b); 2026 #endif 2027 2028 #if (defined(RS_VERSION) && (RS_VERSION >= 21)) 2029 extern 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 */ 2038 extern float __attribute__((const, overloadable)) 2039 min(float a, float b); 2040 2041 extern float2 __attribute__((const, overloadable)) 2042 min(float2 a, float2 b); 2043 2044 extern float3 __attribute__((const, overloadable)) 2045 min(float3 a, float3 b); 2046 2047 extern float4 __attribute__((const, overloadable)) 2048 min(float4 a, float4 b); 2049 2050 #if !defined(RS_VERSION) || (RS_VERSION <= 20) 2051 static 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) 2058 static 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) 2065 static 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) 2072 static 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) 2079 static 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) 2086 static 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) 2093 static 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) 2103 static 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) 2113 static 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) 2123 static 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) 2133 static 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) 2143 static 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) 2153 static 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) 2164 static 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) 2175 static 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) 2186 static 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) 2197 static 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) 2208 static 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) 2219 static 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) 2231 static 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) 2243 static 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) 2255 static 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) 2267 static 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) 2279 static 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)) 2291 extern char __attribute__((const, overloadable)) 2292 min(char a, char b); 2293 #endif 2294 2295 #if (defined(RS_VERSION) && (RS_VERSION >= 21)) 2296 extern char2 __attribute__((const, overloadable)) 2297 min(char2 a, char2 b); 2298 #endif 2299 2300 #if (defined(RS_VERSION) && (RS_VERSION >= 21)) 2301 extern char3 __attribute__((const, overloadable)) 2302 min(char3 a, char3 b); 2303 #endif 2304 2305 #if (defined(RS_VERSION) && (RS_VERSION >= 21)) 2306 extern char4 __attribute__((const, overloadable)) 2307 min(char4 a, char4 b); 2308 #endif 2309 2310 #if (defined(RS_VERSION) && (RS_VERSION >= 21)) 2311 extern uchar __attribute__((const, overloadable)) 2312 min(uchar a, uchar b); 2313 #endif 2314 2315 #if (defined(RS_VERSION) && (RS_VERSION >= 21)) 2316 extern uchar2 __attribute__((const, overloadable)) 2317 min(uchar2 a, uchar2 b); 2318 #endif 2319 2320 #if (defined(RS_VERSION) && (RS_VERSION >= 21)) 2321 extern uchar3 __attribute__((const, overloadable)) 2322 min(uchar3 a, uchar3 b); 2323 #endif 2324 2325 #if (defined(RS_VERSION) && (RS_VERSION >= 21)) 2326 extern uchar4 __attribute__((const, overloadable)) 2327 min(uchar4 a, uchar4 b); 2328 #endif 2329 2330 #if (defined(RS_VERSION) && (RS_VERSION >= 21)) 2331 extern short __attribute__((const, overloadable)) 2332 min(short a, short b); 2333 #endif 2334 2335 #if (defined(RS_VERSION) && (RS_VERSION >= 21)) 2336 extern short2 __attribute__((const, overloadable)) 2337 min(short2 a, short2 b); 2338 #endif 2339 2340 #if (defined(RS_VERSION) && (RS_VERSION >= 21)) 2341 extern short3 __attribute__((const, overloadable)) 2342 min(short3 a, short3 b); 2343 #endif 2344 2345 #if (defined(RS_VERSION) && (RS_VERSION >= 21)) 2346 extern short4 __attribute__((const, overloadable)) 2347 min(short4 a, short4 b); 2348 #endif 2349 2350 #if (defined(RS_VERSION) && (RS_VERSION >= 21)) 2351 extern ushort __attribute__((const, overloadable)) 2352 min(ushort a, ushort b); 2353 #endif 2354 2355 #if (defined(RS_VERSION) && (RS_VERSION >= 21)) 2356 extern ushort2 __attribute__((const, overloadable)) 2357 min(ushort2 a, ushort2 b); 2358 #endif 2359 2360 #if (defined(RS_VERSION) && (RS_VERSION >= 21)) 2361 extern ushort3 __attribute__((const, overloadable)) 2362 min(ushort3 a, ushort3 b); 2363 #endif 2364 2365 #if (defined(RS_VERSION) && (RS_VERSION >= 21)) 2366 extern ushort4 __attribute__((const, overloadable)) 2367 min(ushort4 a, ushort4 b); 2368 #endif 2369 2370 #if (defined(RS_VERSION) && (RS_VERSION >= 21)) 2371 extern int __attribute__((const, overloadable)) 2372 min(int a, int b); 2373 #endif 2374 2375 #if (defined(RS_VERSION) && (RS_VERSION >= 21)) 2376 extern int2 __attribute__((const, overloadable)) 2377 min(int2 a, int2 b); 2378 #endif 2379 2380 #if (defined(RS_VERSION) && (RS_VERSION >= 21)) 2381 extern int3 __attribute__((const, overloadable)) 2382 min(int3 a, int3 b); 2383 #endif 2384 2385 #if (defined(RS_VERSION) && (RS_VERSION >= 21)) 2386 extern int4 __attribute__((const, overloadable)) 2387 min(int4 a, int4 b); 2388 #endif 2389 2390 #if (defined(RS_VERSION) && (RS_VERSION >= 21)) 2391 extern uint __attribute__((const, overloadable)) 2392 min(uint a, uint b); 2393 #endif 2394 2395 #if (defined(RS_VERSION) && (RS_VERSION >= 21)) 2396 extern uint2 __attribute__((const, overloadable)) 2397 min(uint2 a, uint2 b); 2398 #endif 2399 2400 #if (defined(RS_VERSION) && (RS_VERSION >= 21)) 2401 extern uint3 __attribute__((const, overloadable)) 2402 min(uint3 a, uint3 b); 2403 #endif 2404 2405 #if (defined(RS_VERSION) && (RS_VERSION >= 21)) 2406 extern uint4 __attribute__((const, overloadable)) 2407 min(uint4 a, uint4 b); 2408 #endif 2409 2410 #if (defined(RS_VERSION) && (RS_VERSION >= 21)) 2411 extern long __attribute__((const, overloadable)) 2412 min(long a, long b); 2413 #endif 2414 2415 #if (defined(RS_VERSION) && (RS_VERSION >= 21)) 2416 extern long2 __attribute__((const, overloadable)) 2417 min(long2 a, long2 b); 2418 #endif 2419 2420 #if (defined(RS_VERSION) && (RS_VERSION >= 21)) 2421 extern long3 __attribute__((const, overloadable)) 2422 min(long3 a, long3 b); 2423 #endif 2424 2425 #if (defined(RS_VERSION) && (RS_VERSION >= 21)) 2426 extern long4 __attribute__((const, overloadable)) 2427 min(long4 a, long4 b); 2428 #endif 2429 2430 #if (defined(RS_VERSION) && (RS_VERSION >= 21)) 2431 extern ulong __attribute__((const, overloadable)) 2432 min(ulong a, ulong b); 2433 #endif 2434 2435 #if (defined(RS_VERSION) && (RS_VERSION >= 21)) 2436 extern ulong2 __attribute__((const, overloadable)) 2437 min(ulong2 a, ulong2 b); 2438 #endif 2439 2440 #if (defined(RS_VERSION) && (RS_VERSION >= 21)) 2441 extern ulong3 __attribute__((const, overloadable)) 2442 min(ulong3 a, ulong3 b); 2443 #endif 2444 2445 #if (defined(RS_VERSION) && (RS_VERSION >= 21)) 2446 extern 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 * 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). 2457 */ 2458 extern float __attribute__((const, overloadable)) 2459 mix(float start, float stop, float fraction); 2460 2461 extern float2 __attribute__((const, overloadable)) 2462 mix(float2 start, float2 stop, float2 fraction); 2463 2464 extern float3 __attribute__((const, overloadable)) 2465 mix(float3 start, float3 stop, float3 fraction); 2466 2467 extern float4 __attribute__((const, overloadable)) 2468 mix(float4 start, float4 stop, float4 fraction); 2469 2470 extern float2 __attribute__((const, overloadable)) 2471 mix(float2 start, float2 stop, float fraction); 2472 2473 extern float3 __attribute__((const, overloadable)) 2474 mix(float3 start, float3 stop, float fraction); 2475 2476 extern 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 * 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. 2486 * 2487 * Parameters: 2488 * v: Source value. 2489 * integral_part: *integral_part will be set to the integral portion of the number. 2490 * 2491 * Returns: Floating point portion of the value. 2492 */ 2493 extern float __attribute__((overloadable)) 2494 modf(float v, float* integral_part); 2495 2496 extern float2 __attribute__((overloadable)) 2497 modf(float2 v, float2* integral_part); 2498 2499 extern float3 __attribute__((overloadable)) 2500 modf(float3 v, float3* integral_part); 2501 2502 extern 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: 2511 * v: Not used. 2512 */ 2513 extern 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 * 2521 * This function yields undefined results from input values less than -1 or greater than 1. 2522 * 2523 * See also acos(). 2524 */ 2525 #if (defined(RS_VERSION) && (RS_VERSION >= 21)) 2526 extern float __attribute__((const, overloadable)) 2527 native_acos(float v); 2528 #endif 2529 2530 #if (defined(RS_VERSION) && (RS_VERSION >= 21)) 2531 extern float2 __attribute__((const, overloadable)) 2532 native_acos(float2 v); 2533 #endif 2534 2535 #if (defined(RS_VERSION) && (RS_VERSION >= 21)) 2536 extern float3 __attribute__((const, overloadable)) 2537 native_acos(float3 v); 2538 #endif 2539 2540 #if (defined(RS_VERSION) && (RS_VERSION >= 21)) 2541 extern 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)) 2553 extern float __attribute__((const, overloadable)) 2554 native_acosh(float v); 2555 #endif 2556 2557 #if (defined(RS_VERSION) && (RS_VERSION >= 21)) 2558 extern float2 __attribute__((const, overloadable)) 2559 native_acosh(float2 v); 2560 #endif 2561 2562 #if (defined(RS_VERSION) && (RS_VERSION >= 21)) 2563 extern float3 __attribute__((const, overloadable)) 2564 native_acosh(float3 v); 2565 #endif 2566 2567 #if (defined(RS_VERSION) && (RS_VERSION >= 21)) 2568 extern 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 * 2579 * This function yields undefined results from input values less than -1 or greater than 1. 2580 * 2581 * See also acospi(). 2582 */ 2583 #if (defined(RS_VERSION) && (RS_VERSION >= 21)) 2584 extern float __attribute__((const, overloadable)) 2585 native_acospi(float v); 2586 #endif 2587 2588 #if (defined(RS_VERSION) && (RS_VERSION >= 21)) 2589 extern float2 __attribute__((const, overloadable)) 2590 native_acospi(float2 v); 2591 #endif 2592 2593 #if (defined(RS_VERSION) && (RS_VERSION >= 21)) 2594 extern float3 __attribute__((const, overloadable)) 2595 native_acospi(float3 v); 2596 #endif 2597 2598 #if (defined(RS_VERSION) && (RS_VERSION >= 21)) 2599 extern 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 * 2608 * This function yields undefined results from input values less than -1 or greater than 1. 2609 * 2610 * See also asin(). 2611 */ 2612 #if (defined(RS_VERSION) && (RS_VERSION >= 21)) 2613 extern float __attribute__((const, overloadable)) 2614 native_asin(float v); 2615 #endif 2616 2617 #if (defined(RS_VERSION) && (RS_VERSION >= 21)) 2618 extern float2 __attribute__((const, overloadable)) 2619 native_asin(float2 v); 2620 #endif 2621 2622 #if (defined(RS_VERSION) && (RS_VERSION >= 21)) 2623 extern float3 __attribute__((const, overloadable)) 2624 native_asin(float3 v); 2625 #endif 2626 2627 #if (defined(RS_VERSION) && (RS_VERSION >= 21)) 2628 extern 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)) 2640 extern float __attribute__((const, overloadable)) 2641 native_asinh(float v); 2642 #endif 2643 2644 #if (defined(RS_VERSION) && (RS_VERSION >= 21)) 2645 extern float2 __attribute__((const, overloadable)) 2646 native_asinh(float2 v); 2647 #endif 2648 2649 #if (defined(RS_VERSION) && (RS_VERSION >= 21)) 2650 extern float3 __attribute__((const, overloadable)) 2651 native_asinh(float3 v); 2652 #endif 2653 2654 #if (defined(RS_VERSION) && (RS_VERSION >= 21)) 2655 extern 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 * 2666 * This function yields undefined results from input values less than -1 or greater than 1. 2667 * 2668 * See also asinpi(). 2669 */ 2670 #if (defined(RS_VERSION) && (RS_VERSION >= 21)) 2671 extern float __attribute__((const, overloadable)) 2672 native_asinpi(float v); 2673 #endif 2674 2675 #if (defined(RS_VERSION) && (RS_VERSION >= 21)) 2676 extern float2 __attribute__((const, overloadable)) 2677 native_asinpi(float2 v); 2678 #endif 2679 2680 #if (defined(RS_VERSION) && (RS_VERSION >= 21)) 2681 extern float3 __attribute__((const, overloadable)) 2682 native_asinpi(float3 v); 2683 #endif 2684 2685 #if (defined(RS_VERSION) && (RS_VERSION >= 21)) 2686 extern 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)) 2698 extern float __attribute__((const, overloadable)) 2699 native_atan(float v); 2700 #endif 2701 2702 #if (defined(RS_VERSION) && (RS_VERSION >= 21)) 2703 extern float2 __attribute__((const, overloadable)) 2704 native_atan(float2 v); 2705 #endif 2706 2707 #if (defined(RS_VERSION) && (RS_VERSION >= 21)) 2708 extern float3 __attribute__((const, overloadable)) 2709 native_atan(float3 v); 2710 #endif 2711 2712 #if (defined(RS_VERSION) && (RS_VERSION >= 21)) 2713 extern 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: 2725 * numerator: Numerator. 2726 * denominator: Denominator. Can be 0. 2727 */ 2728 #if (defined(RS_VERSION) && (RS_VERSION >= 21)) 2729 extern float __attribute__((const, overloadable)) 2730 native_atan2(float numerator, float denominator); 2731 #endif 2732 2733 #if (defined(RS_VERSION) && (RS_VERSION >= 21)) 2734 extern float2 __attribute__((const, overloadable)) 2735 native_atan2(float2 numerator, float2 denominator); 2736 #endif 2737 2738 #if (defined(RS_VERSION) && (RS_VERSION >= 21)) 2739 extern float3 __attribute__((const, overloadable)) 2740 native_atan2(float3 numerator, float3 denominator); 2741 #endif 2742 2743 #if (defined(RS_VERSION) && (RS_VERSION >= 21)) 2744 extern 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 * 2751 * Returns the approximate inverse tangent of (numerator / denominator), 2752 * in radians, divided by pi. 2753 * 2754 * To get an inverse tangent measured in degrees, use atan2pi(n, d) * 180.f. 2755 * 2756 * See also atan2pi(). 2757 * 2758 * Parameters: 2759 * numerator: Numerator. 2760 * denominator: Denominator. Can be 0. 2761 */ 2762 #if (defined(RS_VERSION) && (RS_VERSION >= 21)) 2763 extern float __attribute__((const, overloadable)) 2764 native_atan2pi(float numerator, float denominator); 2765 #endif 2766 2767 #if (defined(RS_VERSION) && (RS_VERSION >= 21)) 2768 extern float2 __attribute__((const, overloadable)) 2769 native_atan2pi(float2 numerator, float2 denominator); 2770 #endif 2771 2772 #if (defined(RS_VERSION) && (RS_VERSION >= 21)) 2773 extern float3 __attribute__((const, overloadable)) 2774 native_atan2pi(float3 numerator, float3 denominator); 2775 #endif 2776 2777 #if (defined(RS_VERSION) && (RS_VERSION >= 21)) 2778 extern 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)) 2790 extern float __attribute__((const, overloadable)) 2791 native_atanh(float v); 2792 #endif 2793 2794 #if (defined(RS_VERSION) && (RS_VERSION >= 21)) 2795 extern float2 __attribute__((const, overloadable)) 2796 native_atanh(float2 v); 2797 #endif 2798 2799 #if (defined(RS_VERSION) && (RS_VERSION >= 21)) 2800 extern float3 __attribute__((const, overloadable)) 2801 native_atanh(float3 v); 2802 #endif 2803 2804 #if (defined(RS_VERSION) && (RS_VERSION >= 21)) 2805 extern 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)) 2819 extern float __attribute__((const, overloadable)) 2820 native_atanpi(float v); 2821 #endif 2822 2823 #if (defined(RS_VERSION) && (RS_VERSION >= 21)) 2824 extern float2 __attribute__((const, overloadable)) 2825 native_atanpi(float2 v); 2826 #endif 2827 2828 #if (defined(RS_VERSION) && (RS_VERSION >= 21)) 2829 extern float3 __attribute__((const, overloadable)) 2830 native_atanpi(float3 v); 2831 #endif 2832 2833 #if (defined(RS_VERSION) && (RS_VERSION >= 21)) 2834 extern 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)) 2846 extern float __attribute__((const, overloadable)) 2847 native_cbrt(float v); 2848 #endif 2849 2850 #if (defined(RS_VERSION) && (RS_VERSION >= 21)) 2851 extern float2 __attribute__((const, overloadable)) 2852 native_cbrt(float2 v); 2853 #endif 2854 2855 #if (defined(RS_VERSION) && (RS_VERSION >= 21)) 2856 extern float3 __attribute__((const, overloadable)) 2857 native_cbrt(float3 v); 2858 #endif 2859 2860 #if (defined(RS_VERSION) && (RS_VERSION >= 21)) 2861 extern 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)) 2873 extern float __attribute__((const, overloadable)) 2874 native_cos(float v); 2875 #endif 2876 2877 #if (defined(RS_VERSION) && (RS_VERSION >= 21)) 2878 extern float2 __attribute__((const, overloadable)) 2879 native_cos(float2 v); 2880 #endif 2881 2882 #if (defined(RS_VERSION) && (RS_VERSION >= 21)) 2883 extern float3 __attribute__((const, overloadable)) 2884 native_cos(float3 v); 2885 #endif 2886 2887 #if (defined(RS_VERSION) && (RS_VERSION >= 21)) 2888 extern 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)) 2900 extern float __attribute__((const, overloadable)) 2901 native_cosh(float v); 2902 #endif 2903 2904 #if (defined(RS_VERSION) && (RS_VERSION >= 21)) 2905 extern float2 __attribute__((const, overloadable)) 2906 native_cosh(float2 v); 2907 #endif 2908 2909 #if (defined(RS_VERSION) && (RS_VERSION >= 21)) 2910 extern float3 __attribute__((const, overloadable)) 2911 native_cosh(float3 v); 2912 #endif 2913 2914 #if (defined(RS_VERSION) && (RS_VERSION >= 21)) 2915 extern 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)) 2929 extern float __attribute__((const, overloadable)) 2930 native_cospi(float v); 2931 #endif 2932 2933 #if (defined(RS_VERSION) && (RS_VERSION >= 21)) 2934 extern float2 __attribute__((const, overloadable)) 2935 native_cospi(float2 v); 2936 #endif 2937 2938 #if (defined(RS_VERSION) && (RS_VERSION >= 21)) 2939 extern float3 __attribute__((const, overloadable)) 2940 native_cospi(float3 v); 2941 #endif 2942 2943 #if (defined(RS_VERSION) && (RS_VERSION >= 21)) 2944 extern 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)) 2954 extern float __attribute__((const, overloadable)) 2955 native_divide(float left_vector, float right_vector); 2956 #endif 2957 2958 #if (defined(RS_VERSION) && (RS_VERSION >= 21)) 2959 extern float2 __attribute__((const, overloadable)) 2960 native_divide(float2 left_vector, float2 right_vector); 2961 #endif 2962 2963 #if (defined(RS_VERSION) && (RS_VERSION >= 21)) 2964 extern float3 __attribute__((const, overloadable)) 2965 native_divide(float3 left_vector, float3 right_vector); 2966 #endif 2967 2968 #if (defined(RS_VERSION) && (RS_VERSION >= 21)) 2969 extern 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 * 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. 2980 * 2981 * See also exp(). 2982 */ 2983 #if (defined(RS_VERSION) && (RS_VERSION >= 18)) 2984 extern float __attribute__((const, overloadable)) 2985 native_exp(float v); 2986 #endif 2987 2988 #if (defined(RS_VERSION) && (RS_VERSION >= 18)) 2989 extern float2 __attribute__((const, overloadable)) 2990 native_exp(float2 v); 2991 #endif 2992 2993 #if (defined(RS_VERSION) && (RS_VERSION >= 18)) 2994 extern float3 __attribute__((const, overloadable)) 2995 native_exp(float3 v); 2996 #endif 2997 2998 #if (defined(RS_VERSION) && (RS_VERSION >= 18)) 2999 extern 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 * 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. 3010 * 3011 * See also exp10(). 3012 */ 3013 #if (defined(RS_VERSION) && (RS_VERSION >= 18)) 3014 extern float __attribute__((const, overloadable)) 3015 native_exp10(float v); 3016 #endif 3017 3018 #if (defined(RS_VERSION) && (RS_VERSION >= 18)) 3019 extern float2 __attribute__((const, overloadable)) 3020 native_exp10(float2 v); 3021 #endif 3022 3023 #if (defined(RS_VERSION) && (RS_VERSION >= 18)) 3024 extern float3 __attribute__((const, overloadable)) 3025 native_exp10(float3 v); 3026 #endif 3027 3028 #if (defined(RS_VERSION) && (RS_VERSION >= 18)) 3029 extern 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 * 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. 3040 * 3041 * See also exp2(). 3042 */ 3043 #if (defined(RS_VERSION) && (RS_VERSION >= 18)) 3044 extern float __attribute__((const, overloadable)) 3045 native_exp2(float v); 3046 #endif 3047 3048 #if (defined(RS_VERSION) && (RS_VERSION >= 18)) 3049 extern float2 __attribute__((const, overloadable)) 3050 native_exp2(float2 v); 3051 #endif 3052 3053 #if (defined(RS_VERSION) && (RS_VERSION >= 18)) 3054 extern float3 __attribute__((const, overloadable)) 3055 native_exp2(float3 v); 3056 #endif 3057 3058 #if (defined(RS_VERSION) && (RS_VERSION >= 18)) 3059 extern 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)) 3071 extern float __attribute__((const, overloadable)) 3072 native_expm1(float v); 3073 #endif 3074 3075 #if (defined(RS_VERSION) && (RS_VERSION >= 21)) 3076 extern float2 __attribute__((const, overloadable)) 3077 native_expm1(float2 v); 3078 #endif 3079 3080 #if (defined(RS_VERSION) && (RS_VERSION >= 21)) 3081 extern float3 __attribute__((const, overloadable)) 3082 native_expm1(float3 v); 3083 #endif 3084 3085 #if (defined(RS_VERSION) && (RS_VERSION >= 21)) 3086 extern 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)) 3098 extern float __attribute__((const, overloadable)) 3099 native_hypot(float a, float b); 3100 #endif 3101 3102 #if (defined(RS_VERSION) && (RS_VERSION >= 21)) 3103 extern float2 __attribute__((const, overloadable)) 3104 native_hypot(float2 a, float2 b); 3105 #endif 3106 3107 #if (defined(RS_VERSION) && (RS_VERSION >= 21)) 3108 extern float3 __attribute__((const, overloadable)) 3109 native_hypot(float3 a, float3 b); 3110 #endif 3111 3112 #if (defined(RS_VERSION) && (RS_VERSION >= 21)) 3113 extern 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)) 3127 extern float __attribute__((const, overloadable)) 3128 native_log(float v); 3129 #endif 3130 3131 #if (defined(RS_VERSION) && (RS_VERSION >= 18)) 3132 extern float2 __attribute__((const, overloadable)) 3133 native_log(float2 v); 3134 #endif 3135 3136 #if (defined(RS_VERSION) && (RS_VERSION >= 18)) 3137 extern float3 __attribute__((const, overloadable)) 3138 native_log(float3 v); 3139 #endif 3140 3141 #if (defined(RS_VERSION) && (RS_VERSION >= 18)) 3142 extern 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)) 3156 extern float __attribute__((const, overloadable)) 3157 native_log10(float v); 3158 #endif 3159 3160 #if (defined(RS_VERSION) && (RS_VERSION >= 18)) 3161 extern float2 __attribute__((const, overloadable)) 3162 native_log10(float2 v); 3163 #endif 3164 3165 #if (defined(RS_VERSION) && (RS_VERSION >= 18)) 3166 extern float3 __attribute__((const, overloadable)) 3167 native_log10(float3 v); 3168 #endif 3169 3170 #if (defined(RS_VERSION) && (RS_VERSION >= 18)) 3171 extern 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)) 3183 extern float __attribute__((const, overloadable)) 3184 native_log1p(float v); 3185 #endif 3186 3187 #if (defined(RS_VERSION) && (RS_VERSION >= 21)) 3188 extern float2 __attribute__((const, overloadable)) 3189 native_log1p(float2 v); 3190 #endif 3191 3192 #if (defined(RS_VERSION) && (RS_VERSION >= 21)) 3193 extern float3 __attribute__((const, overloadable)) 3194 native_log1p(float3 v); 3195 #endif 3196 3197 #if (defined(RS_VERSION) && (RS_VERSION >= 21)) 3198 extern 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)) 3212 extern float __attribute__((const, overloadable)) 3213 native_log2(float v); 3214 #endif 3215 3216 #if (defined(RS_VERSION) && (RS_VERSION >= 18)) 3217 extern float2 __attribute__((const, overloadable)) 3218 native_log2(float2 v); 3219 #endif 3220 3221 #if (defined(RS_VERSION) && (RS_VERSION >= 18)) 3222 extern float3 __attribute__((const, overloadable)) 3223 native_log2(float3 v); 3224 #endif 3225 3226 #if (defined(RS_VERSION) && (RS_VERSION >= 18)) 3227 extern 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: 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. 3241 */ 3242 #if (defined(RS_VERSION) && (RS_VERSION >= 18)) 3243 extern float __attribute__((const, overloadable)) 3244 native_powr(float base, float exponent); 3245 #endif 3246 3247 #if (defined(RS_VERSION) && (RS_VERSION >= 18)) 3248 extern float2 __attribute__((const, overloadable)) 3249 native_powr(float2 base, float2 exponent); 3250 #endif 3251 3252 #if (defined(RS_VERSION) && (RS_VERSION >= 18)) 3253 extern float3 __attribute__((const, overloadable)) 3254 native_powr(float3 base, float3 exponent); 3255 #endif 3256 3257 #if (defined(RS_VERSION) && (RS_VERSION >= 18)) 3258 extern 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)) 3270 extern float __attribute__((const, overloadable)) 3271 native_recip(float v); 3272 #endif 3273 3274 #if (defined(RS_VERSION) && (RS_VERSION >= 21)) 3275 extern float2 __attribute__((const, overloadable)) 3276 native_recip(float2 v); 3277 #endif 3278 3279 #if (defined(RS_VERSION) && (RS_VERSION >= 21)) 3280 extern float3 __attribute__((const, overloadable)) 3281 native_recip(float3 v); 3282 #endif 3283 3284 #if (defined(RS_VERSION) && (RS_VERSION >= 21)) 3285 extern 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)) 3297 extern float __attribute__((const, overloadable)) 3298 native_rootn(float v, int n); 3299 #endif 3300 3301 #if (defined(RS_VERSION) && (RS_VERSION >= 21)) 3302 extern float2 __attribute__((const, overloadable)) 3303 native_rootn(float2 v, int2 n); 3304 #endif 3305 3306 #if (defined(RS_VERSION) && (RS_VERSION >= 21)) 3307 extern float3 __attribute__((const, overloadable)) 3308 native_rootn(float3 v, int3 n); 3309 #endif 3310 3311 #if (defined(RS_VERSION) && (RS_VERSION >= 21)) 3312 extern 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)) 3324 extern float __attribute__((const, overloadable)) 3325 native_rsqrt(float v); 3326 #endif 3327 3328 #if (defined(RS_VERSION) && (RS_VERSION >= 21)) 3329 extern float2 __attribute__((const, overloadable)) 3330 native_rsqrt(float2 v); 3331 #endif 3332 3333 #if (defined(RS_VERSION) && (RS_VERSION >= 21)) 3334 extern float3 __attribute__((const, overloadable)) 3335 native_rsqrt(float3 v); 3336 #endif 3337 3338 #if (defined(RS_VERSION) && (RS_VERSION >= 21)) 3339 extern 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)) 3351 extern float __attribute__((const, overloadable)) 3352 native_sin(float v); 3353 #endif 3354 3355 #if (defined(RS_VERSION) && (RS_VERSION >= 21)) 3356 extern float2 __attribute__((const, overloadable)) 3357 native_sin(float2 v); 3358 #endif 3359 3360 #if (defined(RS_VERSION) && (RS_VERSION >= 21)) 3361 extern float3 __attribute__((const, overloadable)) 3362 native_sin(float3 v); 3363 #endif 3364 3365 #if (defined(RS_VERSION) && (RS_VERSION >= 21)) 3366 extern 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: 3378 * v: Incoming value in radians. 3379 * cos: *cos will be set to the cosine value. 3380 * 3381 * Returns: Sine. 3382 */ 3383 #if (defined(RS_VERSION) && (RS_VERSION >= 21)) 3384 extern float __attribute__((overloadable)) 3385 native_sincos(float v, float* cos); 3386 #endif 3387 3388 #if (defined(RS_VERSION) && (RS_VERSION >= 21)) 3389 extern float2 __attribute__((overloadable)) 3390 native_sincos(float2 v, float2* cos); 3391 #endif 3392 3393 #if (defined(RS_VERSION) && (RS_VERSION >= 21)) 3394 extern float3 __attribute__((overloadable)) 3395 native_sincos(float3 v, float3* cos); 3396 #endif 3397 3398 #if (defined(RS_VERSION) && (RS_VERSION >= 21)) 3399 extern 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)) 3411 extern float __attribute__((const, overloadable)) 3412 native_sinh(float v); 3413 #endif 3414 3415 #if (defined(RS_VERSION) && (RS_VERSION >= 21)) 3416 extern float2 __attribute__((const, overloadable)) 3417 native_sinh(float2 v); 3418 #endif 3419 3420 #if (defined(RS_VERSION) && (RS_VERSION >= 21)) 3421 extern float3 __attribute__((const, overloadable)) 3422 native_sinh(float3 v); 3423 #endif 3424 3425 #if (defined(RS_VERSION) && (RS_VERSION >= 21)) 3426 extern 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)) 3440 extern float __attribute__((const, overloadable)) 3441 native_sinpi(float v); 3442 #endif 3443 3444 #if (defined(RS_VERSION) && (RS_VERSION >= 21)) 3445 extern float2 __attribute__((const, overloadable)) 3446 native_sinpi(float2 v); 3447 #endif 3448 3449 #if (defined(RS_VERSION) && (RS_VERSION >= 21)) 3450 extern float3 __attribute__((const, overloadable)) 3451 native_sinpi(float3 v); 3452 #endif 3453 3454 #if (defined(RS_VERSION) && (RS_VERSION >= 21)) 3455 extern 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)) 3467 extern float __attribute__((const, overloadable)) 3468 native_sqrt(float v); 3469 #endif 3470 3471 #if (defined(RS_VERSION) && (RS_VERSION >= 21)) 3472 extern float2 __attribute__((const, overloadable)) 3473 native_sqrt(float2 v); 3474 #endif 3475 3476 #if (defined(RS_VERSION) && (RS_VERSION >= 21)) 3477 extern float3 __attribute__((const, overloadable)) 3478 native_sqrt(float3 v); 3479 #endif 3480 3481 #if (defined(RS_VERSION) && (RS_VERSION >= 21)) 3482 extern 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)) 3492 extern float __attribute__((const, overloadable)) 3493 native_tan(float v); 3494 #endif 3495 3496 #if (defined(RS_VERSION) && (RS_VERSION >= 21)) 3497 extern float2 __attribute__((const, overloadable)) 3498 native_tan(float2 v); 3499 #endif 3500 3501 #if (defined(RS_VERSION) && (RS_VERSION >= 21)) 3502 extern float3 __attribute__((const, overloadable)) 3503 native_tan(float3 v); 3504 #endif 3505 3506 #if (defined(RS_VERSION) && (RS_VERSION >= 21)) 3507 extern 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)) 3519 extern float __attribute__((const, overloadable)) 3520 native_tanh(float v); 3521 #endif 3522 3523 #if (defined(RS_VERSION) && (RS_VERSION >= 21)) 3524 extern float2 __attribute__((const, overloadable)) 3525 native_tanh(float2 v); 3526 #endif 3527 3528 #if (defined(RS_VERSION) && (RS_VERSION >= 21)) 3529 extern float3 __attribute__((const, overloadable)) 3530 native_tanh(float3 v); 3531 #endif 3532 3533 #if (defined(RS_VERSION) && (RS_VERSION >= 21)) 3534 extern 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)) 3548 extern float __attribute__((const, overloadable)) 3549 native_tanpi(float v); 3550 #endif 3551 3552 #if (defined(RS_VERSION) && (RS_VERSION >= 21)) 3553 extern float2 __attribute__((const, overloadable)) 3554 native_tanpi(float2 v); 3555 #endif 3556 3557 #if (defined(RS_VERSION) && (RS_VERSION >= 21)) 3558 extern float3 __attribute__((const, overloadable)) 3559 native_tanpi(float3 v); 3560 #endif 3561 3562 #if (defined(RS_VERSION) && (RS_VERSION >= 21)) 3563 extern 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 * 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. 3574 */ 3575 extern float __attribute__((const, overloadable)) 3576 nextafter(float v, float target); 3577 3578 extern float2 __attribute__((const, overloadable)) 3579 nextafter(float2 v, float2 target); 3580 3581 extern float3 __attribute__((const, overloadable)) 3582 nextafter(float3 v, float3 target); 3583 3584 extern 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 * 3592 * pown() and powr() are similar. pown() takes an integer exponent. powr() assumes the 3593 * base to be non-negative. 3594 */ 3595 extern float __attribute__((const, overloadable)) 3596 pow(float base, float exponent); 3597 3598 extern float2 __attribute__((const, overloadable)) 3599 pow(float2 base, float2 exponent); 3600 3601 extern float3 __attribute__((const, overloadable)) 3602 pow(float3 base, float3 exponent); 3603 3604 extern 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 * 3612 * pow() and powr() are similar. The both take a float exponent. powr() also assumes the 3613 * base to be non-negative. 3614 */ 3615 extern float __attribute__((const, overloadable)) 3616 pown(float base, int exponent); 3617 3618 extern float2 __attribute__((const, overloadable)) 3619 pown(float2 base, int2 exponent); 3620 3621 extern float3 __attribute__((const, overloadable)) 3622 pown(float3 base, int3 exponent); 3623 3624 extern 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 * 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. 3634 * 3635 * See also native_powr(). 3636 */ 3637 extern float __attribute__((const, overloadable)) 3638 powr(float base, float exponent); 3639 3640 extern float2 __attribute__((const, overloadable)) 3641 powr(float2 base, float2 exponent); 3642 3643 extern float3 __attribute__((const, overloadable)) 3644 powr(float3 base, float3 exponent); 3645 3646 extern 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 */ 3654 extern float __attribute__((const, overloadable)) 3655 radians(float v); 3656 3657 extern float2 __attribute__((const, overloadable)) 3658 radians(float2 v); 3659 3660 extern float3 __attribute__((const, overloadable)) 3661 radians(float3 v); 3662 3663 extern float4 __attribute__((const, overloadable)) 3664 radians(float4 v); 3665 3666 /* 3667 * remainder: Remainder of a division 3668 * 3669 * Returns the remainder of (numerator / denominator), where the quotient is rounded towards 3670 * the nearest integer. 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 */ 3676 extern float __attribute__((const, overloadable)) 3677 remainder(float numerator, float denominator); 3678 3679 extern float2 __attribute__((const, overloadable)) 3680 remainder(float2 numerator, float2 denominator); 3681 3682 extern float3 __attribute__((const, overloadable)) 3683 remainder(float3 numerator, float3 denominator); 3684 3685 extern 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 * 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. 3699 * 3700 * Example: remquo(-23.5f, 8.f, ") sets the lowest three bits of quot to 3 3701 * and the sign negative. It returns 0.5f. 3702 * 3703 * Parameters: 3704 * numerator: Numerator. 3705 * denominator: Denominator. 3706 * quotient: *quotient will be set to the integer quotient. 3707 * 3708 * Returns: Remainder, precise only for the low three bits. 3709 */ 3710 extern float __attribute__((overloadable)) 3711 remquo(float numerator, float denominator, int* quotient); 3712 3713 extern float2 __attribute__((overloadable)) 3714 remquo(float2 numerator, float2 denominator, int2* quotient); 3715 3716 extern float3 __attribute__((overloadable)) 3717 remquo(float3 numerator, float3 denominator, int3* quotient); 3718 3719 extern 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 * 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. 3730 * 3731 * round() is similar but rounds away from zero. trunc() truncates the decimal fraction. 3732 */ 3733 extern float __attribute__((const, overloadable)) 3734 rint(float v); 3735 3736 extern float2 __attribute__((const, overloadable)) 3737 rint(float2 v); 3738 3739 extern float3 __attribute__((const, overloadable)) 3740 rint(float3 v); 3741 3742 extern 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 */ 3752 extern float __attribute__((const, overloadable)) 3753 rootn(float v, int n); 3754 3755 extern float2 __attribute__((const, overloadable)) 3756 rootn(float2 v, int2 n); 3757 3758 extern float3 __attribute__((const, overloadable)) 3759 rootn(float3 v, int3 n); 3760 3761 extern 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 * 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. 3772 * 3773 * rint() is similar but rounds half values toward even. trunc() truncates the decimal fraction. 3774 */ 3775 extern float __attribute__((const, overloadable)) 3776 round(float v); 3777 3778 extern float2 __attribute__((const, overloadable)) 3779 round(float2 v); 3780 3781 extern float3 __attribute__((const, overloadable)) 3782 round(float3 v); 3783 3784 extern 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 */ 3794 extern float __attribute__((const, overloadable)) 3795 rsqrt(float v); 3796 3797 extern float2 __attribute__((const, overloadable)) 3798 rsqrt(float2 v); 3799 3800 extern float3 __attribute__((const, overloadable)) 3801 rsqrt(float3 v); 3802 3803 extern 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 */ 3815 extern float __attribute__((const, overloadable)) 3816 sign(float v); 3817 3818 extern float2 __attribute__((const, overloadable)) 3819 sign(float2 v); 3820 3821 extern float3 __attribute__((const, overloadable)) 3822 sign(float3 v); 3823 3824 extern 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 */ 3834 extern float __attribute__((const, overloadable)) 3835 sin(float v); 3836 3837 extern float2 __attribute__((const, overloadable)) 3838 sin(float2 v); 3839 3840 extern float3 __attribute__((const, overloadable)) 3841 sin(float3 v); 3842 3843 extern 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: 3854 * v: Incoming value in radians. 3855 * cos: *cos will be set to the cosine value. 3856 * 3857 * Returns: Sine of v. 3858 */ 3859 extern float __attribute__((overloadable)) 3860 sincos(float v, float* cos); 3861 3862 extern float2 __attribute__((overloadable)) 3863 sincos(float2 v, float2* cos); 3864 3865 extern float3 __attribute__((overloadable)) 3866 sincos(float3 v, float3* cos); 3867 3868 extern 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 */ 3878 extern float __attribute__((const, overloadable)) 3879 sinh(float v); 3880 3881 extern float2 __attribute__((const, overloadable)) 3882 sinh(float2 v); 3883 3884 extern float3 __attribute__((const, overloadable)) 3885 sinh(float3 v); 3886 3887 extern 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 */ 3899 extern float __attribute__((const, overloadable)) 3900 sinpi(float v); 3901 3902 extern float2 __attribute__((const, overloadable)) 3903 sinpi(float2 v); 3904 3905 extern float3 __attribute__((const, overloadable)) 3906 sinpi(float3 v); 3907 3908 extern 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 */ 3918 extern float __attribute__((const, overloadable)) 3919 sqrt(float v); 3920 3921 extern float2 __attribute__((const, overloadable)) 3922 sqrt(float2 v); 3923 3924 extern float3 __attribute__((const, overloadable)) 3925 sqrt(float3 v); 3926 3927 extern 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 * 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). 3938 */ 3939 extern float __attribute__((const, overloadable)) 3940 step(float edge, float v); 3941 3942 extern float2 __attribute__((const, overloadable)) 3943 step(float2 edge, float2 v); 3944 3945 extern float3 __attribute__((const, overloadable)) 3946 step(float3 edge, float3 v); 3947 3948 extern float4 __attribute__((const, overloadable)) 3949 step(float4 edge, float4 v); 3950 3951 extern float2 __attribute__((const, overloadable)) 3952 step(float2 edge, float v); 3953 3954 extern float3 __attribute__((const, overloadable)) 3955 step(float3 edge, float v); 3956 3957 extern float4 __attribute__((const, overloadable)) 3958 step(float4 edge, float v); 3959 3960 #if (defined(RS_VERSION) && (RS_VERSION >= 21)) 3961 extern float2 __attribute__((const, overloadable)) 3962 step(float edge, float2 v); 3963 #endif 3964 3965 #if (defined(RS_VERSION) && (RS_VERSION >= 21)) 3966 extern float3 __attribute__((const, overloadable)) 3967 step(float edge, float3 v); 3968 #endif 3969 3970 #if (defined(RS_VERSION) && (RS_VERSION >= 21)) 3971 extern 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 */ 3982 extern float __attribute__((const, overloadable)) 3983 tan(float v); 3984 3985 extern float2 __attribute__((const, overloadable)) 3986 tan(float2 v); 3987 3988 extern float3 __attribute__((const, overloadable)) 3989 tan(float3 v); 3990 3991 extern 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 */ 4001 extern float __attribute__((const, overloadable)) 4002 tanh(float v); 4003 4004 extern float2 __attribute__((const, overloadable)) 4005 tanh(float2 v); 4006 4007 extern float3 __attribute__((const, overloadable)) 4008 tanh(float3 v); 4009 4010 extern 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 */ 4022 extern float __attribute__((const, overloadable)) 4023 tanpi(float v); 4024 4025 extern float2 __attribute__((const, overloadable)) 4026 tanpi(float2 v); 4027 4028 extern float3 __attribute__((const, overloadable)) 4029 tanpi(float3 v); 4030 4031 extern 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 */ 4041 extern float __attribute__((const, overloadable)) 4042 tgamma(float v); 4043 4044 extern float2 __attribute__((const, overloadable)) 4045 tgamma(float2 v); 4046 4047 extern float3 __attribute__((const, overloadable)) 4048 tgamma(float3 v); 4049 4050 extern 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 */ 4062 extern float __attribute__((const, overloadable)) 4063 trunc(float v); 4064 4065 extern float2 __attribute__((const, overloadable)) 4066 trunc(float2 v); 4067 4068 extern float3 __attribute__((const, overloadable)) 4069 trunc(float3 v); 4070 4071 extern float4 __attribute__((const, overloadable)) 4072 trunc(float4 v); 4073 4074 /* 4075 * rsClamp: Restrain a value to a range 4076 * 4077 * DEPRECATED. Do not use. 4078 * 4079 * Clamp a value between low and high. 4080 * 4081 * Parameters: 4082 * amount: Value to clamp. 4083 * low: Lower bound. 4084 * high: Upper bound. 4085 */ 4086 extern char __attribute__((const, always_inline, overloadable 4087 #if (defined(RS_VERSION) && (RS_VERSION >= 22)) 4088 , deprecated("Use clamp() instead.") 4089 #endif 4090 )) 4091 rsClamp(char amount, char low, char high); 4092 4093 extern uchar __attribute__((const, always_inline, overloadable 4094 #if (defined(RS_VERSION) && (RS_VERSION >= 22)) 4095 , deprecated("Use clamp() instead.") 4096 #endif 4097 )) 4098 rsClamp(uchar amount, uchar low, uchar high); 4099 4100 extern short __attribute__((const, always_inline, overloadable 4101 #if (defined(RS_VERSION) && (RS_VERSION >= 22)) 4102 , deprecated("Use clamp() instead.") 4103 #endif 4104 )) 4105 rsClamp(short amount, short low, short high); 4106 4107 extern ushort __attribute__((const, always_inline, overloadable 4108 #if (defined(RS_VERSION) && (RS_VERSION >= 22)) 4109 , deprecated("Use clamp() instead.") 4110 #endif 4111 )) 4112 rsClamp(ushort amount, ushort low, ushort high); 4113 4114 extern int __attribute__((const, always_inline, overloadable 4115 #if (defined(RS_VERSION) && (RS_VERSION >= 22)) 4116 , deprecated("Use clamp() instead.") 4117 #endif 4118 )) 4119 rsClamp(int amount, int low, int high); 4120 4121 extern uint __attribute__((const, always_inline, overloadable 4122 #if (defined(RS_VERSION) && (RS_VERSION >= 22)) 4123 , deprecated("Use clamp() instead.") 4124 #endif 4125 )) 4126 rsClamp(uint amount, uint low, uint high); 4127 4128 /* 4129 * rsFrac: Returns the fractional part of a float 4130 * 4131 * DEPRECATED. Do not use. 4132 * 4133 * Returns the fractional part of a float 4134 */ 4135 extern float __attribute__((const, overloadable 4136 #if (defined(RS_VERSION) && (RS_VERSION >= 22)) 4137 , deprecated("Use fract() instead.") 4138 #endif 4139 )) 4140 rsFrac(float v); 4141 4142 /* 4143 * rsRand: Pseudo-random number 4144 * 4145 * Return a random value between 0 (or min_value) and max_malue. 4146 */ 4147 extern int __attribute__((overloadable)) 4148 rsRand(int max_value); 4149 4150 extern int __attribute__((overloadable)) 4151 rsRand(int min_value, int max_value); 4152 4153 extern float __attribute__((overloadable)) 4154 rsRand(float max_value); 4155 4156 extern float __attribute__((overloadable)) 4157 rsRand(float min_value, float max_value); 4158 4159 #endif // RENDERSCRIPT_RS_MATH_RSH 4160