| # |
| # Copyright (C) 2014 The Android Open Source Project |
| # |
| # Licensed under the Apache License, Version 2.0 (the "License"); |
| # you may not use this file except in compliance with the License. |
| # You may obtain a copy of the License at |
| # |
| # http://www.apache.org/licenses/LICENSE-2.0 |
| # |
| # Unless required by applicable law or agreed to in writing, software |
| # distributed under the License is distributed on an "AS IS" BASIS, |
| # WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. |
| # See the License for the specific language governing permissions and |
| # limitations under the License. |
| # |
| |
| start: |
| w: 1, 2, 3, 4 |
| t: i8, i16, i32 |
| name: abs |
| ret: u#2#1 |
| arg: #2#1 v |
| comment: |
| Returns the absolute value of an integer. |
| |
| For floats, use fabs(). |
| version: 9 |
| end: |
| |
| start: |
| w: 1, 2, 3, 4 |
| t: f32 |
| name: acos |
| ret: #2#1 |
| arg: #2#1 v range(-1,1) |
| comment: |
| Returns the inverse cosine, in radians. |
| version: 9 |
| end: |
| |
| start: |
| w: 1, 2, 3, 4 |
| t: f32 |
| name: acosh |
| ret: #2#1 |
| arg: #2#1 v |
| comment: |
| Returns the inverse hyperbolic cosine, in radians. |
| version: 9 |
| end: |
| |
| start: |
| w: 1, 2, 3, 4 |
| t: f32 |
| name: acospi |
| ret: #2#1 |
| arg: #2#1 v range(-1,1) |
| comment: |
| Returns the inverse cosine in radians, divided by pi. |
| |
| To get an inverse cosine measured in degrees, use acospi(a) * 180.f. |
| version: 9 |
| end: |
| |
| start: |
| w: 1, 2, 3, 4 |
| t: f32 |
| name: asin |
| ret: #2#1 |
| arg: #2#1 v range(-1,1) |
| comment: |
| Returns the inverse sine, in radians. |
| version: 9 |
| end: |
| |
| start: |
| w: 1, 2, 3, 4 |
| t: f32 |
| name: asinh |
| ret: #2#1 |
| arg: #2#1 v |
| comment: |
| Returns the inverse hyperbolic sine, in radians. |
| version: 9 |
| end: |
| |
| start: |
| w: 1, 2, 3, 4 |
| t: f32 |
| name: asinpi |
| ret: #2#1 |
| arg: #2#1 v range(-1,1) |
| comment: |
| Returns the inverse sine in radians, divided by pi. |
| |
| To get an inverse sine measured in degrees, use asinpi(a) * 180.f. |
| version: 9 |
| end: |
| |
| start: |
| w: 1, 2, 3, 4 |
| t: f32 |
| name: atan |
| ret: #2#1 |
| arg: #2#1 v range(-1,1) |
| comment: |
| Returns the inverse tangent, in radians. |
| version: 9 |
| end: |
| |
| start: |
| w: 1, 2, 3, 4 |
| t: f32 |
| name: atan2 |
| ret: #2#1 |
| arg: #2#1 numerator |
| arg: #2#1 denominator |
| comment: |
| Returns the inverse tangent of (numerator / denominator), in radians. |
| |
| denominator can be 0. |
| version: 9 |
| end: |
| |
| start: |
| w: 1, 2, 3, 4 |
| t: f32 |
| name: atan2pi |
| ret: #2#1 |
| arg: #2#1 numerator |
| arg: #2#1 denominator |
| comment: |
| Returns the inverse tangent of (numerator / denominator), in radians, divided by pi. |
| |
| To get an inverse tangent measured in degrees, use atan2pi(n, d) * 180.f. |
| |
| denominator can be 0. |
| version: 9 |
| end: |
| |
| start: |
| w: 1, 2, 3, 4 |
| t: f32 |
| name: atanh |
| ret: #2#1 |
| arg: #2#1 v range(-1,1) |
| comment: |
| Returns the inverse hyperbolic tangent, in radians. |
| version: 9 |
| end: |
| |
| start: |
| w: 1, 2, 3, 4 |
| t: f32 |
| name: atanpi |
| ret: #2#1 |
| arg: #2#1 v range(-1,1) |
| comment: |
| Returns the inverse tangent in radians, divided by pi. |
| |
| To get an inverse tangent measured in degrees, use atanpi(a) * 180.f. |
| version: 9 |
| end: |
| |
| start: |
| w: 1, 2, 3, 4 |
| t: f32 |
| name: cbrt |
| ret: #2#1 |
| arg: #2#1 v |
| comment: |
| Returns the cube root. |
| version: 9 |
| end: |
| |
| start: |
| w: 1, 2, 3, 4 |
| t: f32 |
| name: ceil |
| ret: #2#1 |
| arg: #2#1 v |
| comment: |
| Returns the smallest integer not less than a value. |
| |
| For example, ceil(1.2f) returns 2.f, and ceil(-1.2f) returns -1.f. |
| version: 9 |
| end: |
| |
| start: |
| w: 1, 2, 3, 4 |
| t: f32 |
| name: clamp |
| ret: #2#1 |
| arg: #2#1 value |
| arg: #2#1 min_value |
| arg: #2#1 max_value above(min_value) |
| comment: |
| Clamps a value to a specified high and low bound. |
| |
| clamp() returns min_value if value < min_value, max_value if value > max_value, otherwise value. |
| |
| If min_value is greater than max_value, the results are undefined. |
| |
| @param value Value to be clamped. Supports 1, 2, 3, 4 components. |
| @param min_value Lower bound, must be scalar or matching vector. |
| @param max_value High bound, must match the type of low. |
| version: 9 |
| end: |
| |
| start: |
| w: 2, 3, 4 |
| t: f32 |
| name: clamp |
| ret: #2#1 |
| arg: #2#1 value |
| arg: #2 min_value |
| arg: #2 max_value above(min_value) |
| comment: |
| Clamps a value to a specified high and low bound. |
| |
| clamp() returns min_value if value < min_value, max_value if value > max_value, otherwise value. |
| |
| If min_value is greater than max_value, the results are undefined. |
| |
| @param value Value to be clamped. Supports 1, 2, 3, 4 components. |
| @param min_value Lower bound, must be scalar or matching vector. |
| @param max_value High bound, must match the type of low. |
| version: 9 |
| end: |
| |
| start: |
| w: 1, 2, 3, 4 |
| t: u8, u16, u32, u64, i8, i16, i32, i64 |
| name: clamp |
| ret: #2#1 |
| arg: #2#1 value |
| arg: #2#1 min_value |
| arg: #2#1 max_value above(min_value) |
| comment: |
| Clamps a value to a specified high and low bound. |
| |
| clamp() returns min_value if value < min_value, max_value if value > max_value, otherwise value. |
| |
| If min_value is greater than max_value, the results are undefined. |
| |
| @param value Value to be clamped. Supports 1, 2, 3, 4 components. |
| @param min_value Lower bound, must be scalar or matching vector. |
| @param max_value High bound, must match the type of low. |
| version: 19 |
| end: |
| |
| start: |
| w: 2, 3, 4 |
| t: u8, u16, u32, u64, i8, i16, i32, i64 |
| name: clamp |
| ret: #2#1 |
| arg: #2#1 value |
| arg: #2 min_value |
| arg: #2 max_value above(min_value) |
| comment: |
| Clamps a value to a specified high and low bound. |
| |
| clamp() returns min_value if value < min_value, max_value if value > max_value, otherwise value. |
| |
| If min_value is greater than max_value, the results are undefined. |
| |
| @param value Value to be clamped. Supports 1, 2, 3, 4 components. |
| @param min_value Lower bound, must be scalar or matching vector. |
| @param max_value High bound, must match the type of low. |
| version: 19 |
| end: |
| |
| start: |
| w: 1, 2, 3, 4 |
| t: u8, u16, u32, i8, i16, i32 |
| name: clz |
| ret: #2#1 |
| arg: #2#1 value |
| comment: |
| Returns the number of leading 0-bits in a value. |
| |
| For example, clz((char)0x03) returns 5. |
| version: 9 |
| end: |
| |
| start: |
| w: 2, 3, 4 |
| t: u8, u16, u32, i8, i16, i32, f32 |
| t: u8, u16, u32, i8, i16, i32, f32 |
| name: convert_#3#1 |
| arg: #2#1 v compatible(#3) |
| ret: #3#1 |
| comment: |
| Component wise conversion from #2#1 to #3#1. |
| |
| For the convert_* functions, conversions of floating point values to integer will truncate. |
| Conversions of numbers too large to fit the destination type yield undefined results. |
| For example, converting a float that contains 1.0e18 to a short is undefined. |
| version: 9 |
| end: |
| |
| start: |
| w: 2, 3, 4 |
| t: u64, i64, f64 |
| t: u64, i64, f64 |
| name: convert_#3#1 |
| arg: #2#1 v compatible(#3) |
| ret: #3#1 |
| comment: |
| Component wise conversion from #2#1 to #3#1. |
| |
| For the convert_* functions, conversions of floating point values to integer will truncate. |
| Conversions of numbers too large to fit the destination type yield undefined results. |
| For example, converting a float that contains 1.0e18 to a short is undefined. |
| version: 21 |
| end: |
| |
| start: |
| w: 2, 3, 4 |
| t: u64, i64, f64 |
| t: u8, u16, u32, i8, i16, i32, f32 |
| name: convert_#3#1 |
| arg: #2#1 v compatible(#3) |
| ret: #3#1 |
| comment: |
| Component wise conversion from #2#1 to #3#1. |
| |
| For the convert_* functions, conversions of floating point values to integer will truncate. |
| Conversions of numbers too large to fit the destination type yield undefined results. |
| For example, converting a float that contains 1.0e18 to a short is undefined. |
| version: 21 |
| end: |
| |
| start: |
| w: 2, 3, 4 |
| t: u8, u16, u32, i8, i16, i32, f32 |
| t: u64, i64, f64 |
| name: convert_#3#1 |
| arg: #2#1 v compatible(#3) |
| ret: #3#1 |
| comment: |
| Component wise conversion from #2#1 to #3#1. |
| |
| For the convert_* functions, conversions of floating point values to integer will truncate. |
| Conversions of numbers too large to fit the destination type yield undefined results. |
| For example, converting a float that contains 1.0e18 to a short is undefined. |
| version: 21 |
| end: |
| |
| start: |
| w: 1, 2, 3, 4 |
| t: f32 |
| name: copysign |
| ret: #2#1 |
| arg: #2#1 magnitude_value |
| arg: #2#1 sign_value |
| comment: |
| Copies the sign from sign_value to magnitude_value. |
| |
| The value returned is either magnitude_value or -magnitude_value. |
| |
| For example, copysign(4.0f, -2.7f) returns -4.0f and copysign(-4.0f, 2.7f) returns 4.0f. |
| version: 9 |
| end: |
| |
| start: |
| w: 1, 2, 3, 4 |
| t: f32 |
| name: cos |
| ret: #2#1 |
| arg: #2#1 v |
| comment: |
| Returns the cosine of an angle measured in radians. |
| version: 9 |
| end: |
| |
| start: |
| w: 1, 2, 3, 4 |
| t: f32 |
| name: cosh |
| ret: #2#1 |
| arg: #2#1 v |
| comment: |
| Returns the hypebolic cosine of v, where v is measured in radians. |
| version: 9 |
| end: |
| |
| start: |
| w: 1, 2, 3, 4 |
| t: f32 |
| name: cospi |
| ret: #2#1 |
| arg: #2#1 v |
| comment: |
| Returns the cosine of (v * pi), where (v * pi) is measured in radians. |
| |
| To get the cosine of a value measured in degrees, call cospi(v / 180.f). |
| version: 9 |
| end: |
| |
| start: |
| w: 3, 4 |
| t: f32 |
| name: cross |
| ret: #2#1 |
| arg: #2#1 left_vector |
| arg: #2#1 right_vector |
| comment: |
| Computes the cross product of two vectors. |
| version: 9 |
| test: vector |
| end: |
| |
| start: |
| w: 1, 2, 3, 4 |
| t: f32 |
| name: degrees |
| ret: #2#1 |
| arg: #2#1 v |
| comment: |
| Converts from radians to degrees. |
| version: 9 |
| end: |
| |
| start: |
| w: 1, 2, 3, 4 |
| t: f32 |
| name: distance |
| ret: #2 |
| arg: #2#1 left_vector |
| arg: #2#1 right_vector |
| comment: |
| Compute the distance between two points. |
| version: 9 |
| test: vector |
| end: |
| |
| start: |
| w: 1, 2, 3, 4 |
| t: f32 |
| name: dot |
| ret: #2 |
| arg: #2#1 left_vector |
| arg: #2#1 right_vector |
| comment: |
| Computes the dot product of two vectors. |
| version: 9 |
| test: vector |
| end: |
| |
| start: |
| w: 1, 2, 3, 4 |
| t: f32 |
| name: erf |
| ret: #2#1 |
| arg: #2#1 v |
| comment: |
| Returns the error function. |
| version: 9 |
| end: |
| |
| start: |
| w: 1, 2, 3, 4 |
| t: f32 |
| name: erfc |
| ret: #2#1 |
| arg: #2#1 v |
| comment: |
| Returns the complementary error function. |
| version: 9 |
| end: |
| |
| start: |
| w: 1, 2, 3, 4 |
| t: f32 |
| name: exp |
| ret: #2#1 |
| arg: #2#1 v |
| comment: |
| Returns e raised to v, i.e. e ^ v. |
| version: 9 |
| end: |
| |
| start: |
| w: 1, 2, 3, 4 |
| t: f32 |
| name: exp10 |
| ret: #2#1 |
| arg: #2#1 v |
| comment: |
| Returns 10 raised to v, i.e. 10.f ^ v. |
| version: 9 |
| end: |
| |
| start: |
| w: 1, 2, 3, 4 |
| t: f32 |
| name: exp2 |
| ret: #2#1 |
| arg: #2#1 v |
| comment: |
| Returns 2 raised to v, i.e. 2.f ^ v. |
| version: 9 |
| end: |
| |
| start: |
| w: 1, 2, 3, 4 |
| t: f32 |
| name: expm1 |
| ret: #2#1 |
| arg: #2#1 v |
| comment: |
| Returns e raised to v minus 1, i.e. (e ^ v) - 1. |
| version: 9 |
| end: |
| |
| start: |
| w: 1, 2, 3, 4 |
| t: f32 |
| name: fabs |
| ret: #2#1 |
| arg: #2#1 v |
| comment: |
| Returns the absolute value of the float v. |
| |
| For integers, use abs(). |
| version: 9 |
| end: |
| |
| start: |
| w: 1, 2, 3, 4 |
| t: f32 |
| name: fast_distance |
| ret: #2 |
| arg: #2#1 left_vector |
| arg: #2#1 right_vector |
| comment: |
| Computes the approximate distance between two points. |
| |
| The precision is what would be expected from doing the computation using 16 bit floating point values. |
| version: 17 |
| test: vector |
| end: |
| |
| start: |
| w: 1, 2, 3, 4 |
| t: f32 |
| name: fast_length |
| ret: #2 |
| arg: #2#1 v |
| comment: |
| Computes the approximate length of a vector. |
| |
| The precision is what would be expected from doing the computation using 16 bit floating point values. |
| version: 17 |
| test: vector |
| end: |
| |
| start: |
| w: 1, 2, 3, 4 |
| t: f32 |
| name: fast_normalize |
| ret: #2#1 |
| arg: #2#1 v |
| comment: |
| Approximately normalizes a vector. |
| |
| For vectors of size 1, returns -1.f for negative values, 0.f for null values, and 1.f for positive values. |
| |
| The precision is what would be expected from doing the computation using 16 bit floating point values. |
| version: 17 |
| test: vector |
| end: |
| |
| start: |
| w: 1, 2, 3, 4 |
| t: f32 |
| name: fdim |
| ret: #2#1 |
| arg: #2#1 a |
| arg: #2#1 b |
| comment: |
| Returns the positive difference between two values. |
| |
| If a > b, returns (a - b) otherwise returns 0f. |
| version: 9 |
| end: |
| |
| start: |
| w: 1, 2, 3, 4 |
| t: f32 |
| name: floor |
| ret: #2#1 |
| arg: #2#1 v |
| comment: |
| Returns the smallest integer not greater than a value. |
| version: 9 |
| end: |
| |
| start: |
| w: 1, 2, 3, 4 |
| t: f32 |
| name: fma |
| ret: #2#1 |
| arg: #2#1 multiplicand1 |
| arg: #2#1 multiplicand2 |
| arg: #2#1 offset |
| comment: |
| Multiply and add. Returns (multiplicand1 * multiplicand2) + offset. |
| |
| This function is identical to mad(). |
| version: 9 |
| end: |
| |
| start: |
| w: 1, 2, 3, 4 |
| t: f32 |
| name: fmax |
| ret: #2#1 |
| arg: #2#1 a |
| arg: #2#1 b |
| comment: |
| Returns the maximum of a and b, i.e. (a < b ? b : a). |
| |
| The max() function returns identical results but can be applied to more data types. |
| version: 9 |
| end: |
| |
| start: |
| w: 2, 3, 4 |
| t: f32 |
| name: fmax |
| ret: #2#1 |
| arg: #2#1 a |
| arg: #2 b |
| comment: |
| Returns the maximum of a and b, i.e. (a < b ? b : a). |
| |
| Unlike the other variants of fmax() and max(), this function compare each element of a to the scalar b. |
| version: 9 |
| end: |
| |
| start: |
| w: 1, 2, 3, 4 |
| t: f32 |
| name: fmin |
| ret: #2#1 |
| arg: #2#1 a |
| arg: #2#1 b |
| comment: |
| Returns the minimum of a and b, i.e. (a > b ? b : a). |
| |
| The min() function returns identical results but can be applied to more data types. |
| version: 9 |
| end: |
| |
| start: |
| w: 2, 3, 4 |
| t: f32 |
| name: fmin |
| ret: #2#1 |
| arg: #2#1 a |
| arg: #2 b |
| comment: |
| Returns the minimum of a and b, i.e. (a > b ? b : a) |
| |
| Unlike the other variants of fmin() and min(), this function compare each element of a to the scalar b. |
| version: 9 |
| end: |
| |
| start: |
| w: 1, 2, 3, 4 |
| t: f32 |
| name: fmod |
| ret: #2#1 |
| arg: #2#1 numerator |
| arg: #2#1 denominator |
| comment: |
| Returns the remainder of (numerator / denominator), where the quotient is rounded towards zero. |
| |
| The function remainder() is similar but rounds toward the closest interger. |
| For example, fmod(-3.8f, 2.f) returns -1.8f (-3.8f - -1.f * 2.f) |
| while remainder(-3.8f, 2.f) returns 0.2f (-3.8f - -2.f * 2.f). |
| version: 9 |
| end: |
| |
| start: |
| w: 1, 2, 3, 4 |
| t: f32 |
| name: fract |
| ret: #2#1 |
| arg: #2#1 v |
| arg: #2#1 *floor |
| comment: |
| Returns the positive fractional part of v, i.e. v - floor(v). |
| |
| For example, fract(1.3f, &val) returns 0.3f and sets val to 1.f. |
| fract(-1.3f, &val) returns 0.7f and sets val to -2.f. |
| |
| @param v Input value. |
| @param floor If floor is not null, each element of floor will be set to the floor of the corresponding element of v. |
| version: 9 |
| end: |
| |
| start: |
| w: 1, 2, 3, 4 |
| t: f32 |
| name: fract |
| ret: #2#1 |
| arg: #2#1 v |
| comment: |
| Returns the positive fractional part of v, i.e. v - floor(v). |
| |
| For example, fract(1.3f, &val) returns 0.3f and sets val to 1.f. |
| fract(-1.3f, &val) returns 0.7f and sets val to -2.f. |
| inline: |
| #2#1 unused; |
| return fract(v, &unused); |
| version: 9 |
| end: |
| |
| start: |
| w: 1, 2, 3, 4 |
| t: f32 |
| name: frexp |
| ret: #2#1 |
| arg: #2#1 v |
| arg: int#1 *exponent |
| comment: |
| Returns the binary mantissa and exponent of v, e.g. v == mantissa * 2 ^ exponent. |
| |
| The mantissa is always between 0.5 (inclusive) and 1.0 (exclusive). |
| See ldexp() for the reverse operation. |
| |
| @param v Supports float, float2, float3, float4. |
| @param exponent If exponent is not null, each element of exponent will be set to the exponent of the corresponding element of v. |
| version: 9 |
| end: |
| |
| start: |
| w: 1, 2, 3, 4 |
| t: f32 |
| name: half_recip |
| ret: #2#1 |
| arg: #2#1 v |
| comment: |
| Returns the approximate reciprocal of a value. |
| |
| The precision is that of a 16 bit floating point value. |
| version: 17 |
| end: |
| |
| start: |
| w: 1, 2, 3, 4 |
| t: f32 |
| name: half_rsqrt |
| ret: #2#1 |
| arg: #2#1 v |
| comment: |
| Returns the approximate value of (1.f / sqrt(value)). |
| |
| The precision is that of a 16 bit floating point value. |
| version: 17 |
| end: |
| |
| start: |
| w: 1, 2, 3, 4 |
| t: f32 |
| name: half_sqrt |
| ret: #2#1 |
| arg: #2#1 v |
| comment: |
| Returns the approximate square root of a value. |
| |
| The precision is that of a 16 bit floating point value. |
| version: 17 |
| end: |
| |
| start: |
| w: 1, 2, 3, 4 |
| t: f32 |
| name: hypot |
| ret: #2#1 |
| arg: #2#1 a |
| arg: #2#1 b |
| comment: |
| Returns the hypotenuse, i.e. sqrt(a * a + b * b). |
| version: 9 |
| end: |
| |
| start: |
| w: 1, 2, 3, 4 |
| t: f32 |
| name: ilogb |
| ret: int#1 |
| arg: float#1 v |
| comment: |
| Returns the base two exponent of a value, where the mantissa is between 1.f (inclusive) and 2.f (exclusive). |
| |
| For example, ilogb(8.5f) returns 3. Because of the difference in mantissa, this number is one less than |
| is returned by frexp(). |
| |
| logb() is similar but returns a float. |
| version: 9 |
| test: custom |
| end: |
| |
| start: |
| w: 1, 2, 3, 4 |
| name: ldexp |
| ret: float#1 |
| arg: float#1 mantissa |
| arg: int#1 exponent |
| comment: |
| Returns the floating point created from the mantissa and exponent, i.e. (mantissa * 2 ^ exponent). |
| |
| See frexp() for the reverse operation. |
| |
| @param mantissa Supports float, float2, float3, and float4. |
| @param exponent Supports single component or matching vector. |
| version: 9 |
| end: |
| |
| start: |
| w: 2, 3, 4 |
| name: ldexp |
| ret: float#1 |
| arg: float#1 mantissa |
| arg: int exponent |
| comment: |
| Returns the floating point created from the mantissa and exponent, i.e. (mantissa * 2 ^ exponent). |
| See frexp() for the reverse operation. |
| |
| @param mantissa Supports float, float2, float3, and float4. |
| @param exponent Supports single component or matching vector. |
| version: 9 |
| end: |
| |
| start: |
| w: 1, 2, 3, 4 |
| t: f32 |
| name: length |
| ret: #2 |
| arg: #2#1 v |
| comment: |
| Computes the length of a vector. |
| version: 9 |
| test: vector |
| end: |
| |
| start: |
| w: 1, 2, 3, 4 |
| t: f32 |
| name: lgamma |
| ret: #2#1 |
| arg: #2#1 v |
| comment: |
| Returns the natural logarithm of the absolute value of the gamma function, i.e. log(fabs(gamma(v))). |
| version: 9 |
| end: |
| |
| start: |
| w: 1, 2, 3, 4 |
| t: f32 |
| name: lgamma |
| ret: #2#1 |
| arg: #2#1 v |
| arg: int#1 *sign_of_gamma |
| comment: |
| Returns the natural logarithm of the absolute value of the gamma function, i.e. log(fabs(gamma(v))). |
| |
| Can also return the sign of the gamma function. |
| |
| @param v Input value. |
| @param sign_of_gamma If sign is not null, each element of sign will be set to -1.f if the gamma of the corresponding element of v is negative, otherwise to 1.f. |
| |
| version: 9 |
| #TODO Temporary until bionic & associated drivers are fixed |
| test: custom |
| end: |
| |
| start: |
| w: 1, 2, 3, 4 |
| t: f32 |
| name: log |
| ret: #2#1 |
| arg: #2#1 v |
| comment: |
| Returns the natural logarithm. |
| version: 9 |
| end: |
| |
| start: |
| w: 1, 2, 3, 4 |
| t: f32 |
| name: log10 |
| ret: #2#1 |
| arg: #2#1 v |
| comment: |
| Returns the base 10 logarithm. |
| version: 9 |
| end: |
| |
| start: |
| w: 1, 2, 3, 4 |
| t: f32 |
| name: log1p |
| ret: #2#1 |
| arg: #2#1 v |
| comment: |
| Returns the natural logarithm of (v + 1.f). |
| version: 9 |
| end: |
| |
| start: |
| w: 1, 2, 3, 4 |
| t: f32 |
| name: log2 |
| ret: #2#1 |
| arg: #2#1 v |
| comment: |
| Returns the base 2 logarithm. |
| version: 9 |
| end: |
| |
| start: |
| w: 1, 2, 3, 4 |
| t: f32 |
| name: logb |
| ret: #2#1 |
| arg: #2#1 v |
| comment: |
| Returns the base two exponent of a value, where the mantissa is between 1.f (inclusive) and 2.f (exclusive). |
| |
| For example, logb(8.5f) returns 3.f. Because of the difference in mantissa, this number is one less than |
| is returned by frexp(). |
| |
| ilogb() is similar but returns an integer. |
| version: 9 |
| end: |
| |
| start: |
| w: 1, 2, 3, 4 |
| t: f32 |
| name: mad |
| ret: #2#1 |
| arg: #2#1 multiplicand1 |
| arg: #2#1 multiplicand2 |
| arg: #2#1 offset |
| comment: |
| Multiply and add. Returns (multiplicand1 * multiplicand2) + offset. |
| |
| This function is identical to fma(). |
| version: 9 |
| end: |
| |
| start: |
| w: 1, 2, 3, 4 |
| t: f32 |
| name: max |
| ret: #2#1 |
| arg: #2#1 a |
| arg: #2#1 b |
| comment: |
| Returns the maximum value of two arguments. |
| version: 9 |
| end: |
| |
| start: |
| w: 1 |
| t: i8 i16 i32 u8 u16 u32 |
| name: max |
| ret: #2#1 |
| arg: #2#1 a |
| arg: #2#1 b |
| comment: |
| Returns the maximum value of two arguments. |
| inline: |
| return (a > b ? a : b); |
| version: 9 20 |
| end: |
| |
| start: |
| w: 2 |
| t: i8 i16 i32 u8 u16 u32 |
| name: max |
| ret: #2#1 |
| arg: #2#1 a |
| arg: #2#1 b |
| comment: |
| Returns the maximum value of two arguments. |
| inline: |
| #2#1 tmp; |
| tmp.x = (a.x > b.x ? a.x : b.x); |
| tmp.y = (a.y > b.y ? a.y : b.y); |
| return tmp; |
| version: 9 20 |
| end: |
| |
| start: |
| w: 3 |
| t: i8 i16 i32 u8 u16 u32 |
| name: max |
| ret: #2#1 |
| arg: #2#1 a |
| arg: #2#1 b |
| comment: |
| Returns the maximum value of two arguments. |
| inline: |
| #2#1 tmp; |
| tmp.x = (a.x > b.x ? a.x : b.x); |
| tmp.y = (a.y > b.y ? a.y : b.y); |
| tmp.z = (a.z > b.z ? a.z : b.z); |
| return tmp; |
| version: 9 20 |
| end: |
| |
| start: |
| w: 4 |
| t: i8 i16 i32 u8 u16 u32 |
| name: max |
| ret: #2#1 |
| arg: #2#1 a |
| arg: #2#1 b |
| comment: |
| Returns the maximum value of two arguments. |
| inline: |
| #2#1 tmp; |
| tmp.x = (a.x > b.x ? a.x : b.x); |
| tmp.y = (a.y > b.y ? a.y : b.y); |
| tmp.z = (a.z > b.z ? a.z : b.z); |
| tmp.w = (a.w > b.w ? a.w : b.w); |
| return tmp; |
| version: 9 20 |
| end: |
| |
| start: |
| w: 1, 2, 3, 4 |
| t: i8 i16 i32 i64 u8 u16 u32 u64 |
| name: max |
| ret: #2#1 |
| arg: #2#1 a |
| arg: #2#1 b |
| comment: |
| Returns the maximum value of two arguments. |
| version: 21 |
| end: |
| |
| start: |
| w: 1, 2, 3, 4 |
| t: f32 |
| name: min |
| ret: #2#1 |
| arg: #2#1 a |
| arg: #2#1 b |
| comment: |
| Returns the minimum value of two arguments. |
| version: 9 |
| end: |
| |
| start: |
| w: 1 |
| t: i8 i16 i32 u8 u16 u32 |
| name: min |
| ret: #2#1 |
| arg: #2#1 a |
| arg: #2#1 b |
| comment: |
| Returns the minimum value of two arguments. |
| inline: |
| return (a < b ? a : b); |
| version: 9 20 |
| end: |
| |
| start: |
| w: 2 |
| t: i8 i16 i32 u8 u16 u32 |
| name: min |
| ret: #2#1 |
| arg: #2#1 a |
| arg: #2#1 b |
| comment: |
| Returns the minimum value of two arguments. |
| inline: |
| #2#1 tmp; |
| tmp.x = (a.x < b.x ? a.x : b.x); |
| tmp.y = (a.y < b.y ? a.y : b.y); |
| return tmp; |
| version: 9 20 |
| end: |
| |
| start: |
| w: 3 |
| t: i8 i16 i32 u8 u16 u32 |
| name: min |
| ret: #2#1 |
| arg: #2#1 a |
| arg: #2#1 b |
| comment: |
| Returns the minimum value of two arguments. |
| inline: |
| #2#1 tmp; |
| tmp.x = (a.x < b.x ? a.x : b.x); |
| tmp.y = (a.y < b.y ? a.y : b.y); |
| tmp.z = (a.z < b.z ? a.z : b.z); |
| return tmp; |
| version: 9 20 |
| end: |
| |
| start: |
| w: 4 |
| t: i8 i16 i32 u8 u16 u32 |
| name: min |
| ret: #2#1 |
| arg: #2#1 a |
| arg: #2#1 b |
| comment: |
| Returns the minimum value of two arguments. |
| inline: |
| #2#1 tmp; |
| tmp.x = (a.x < b.x ? a.x : b.x); |
| tmp.y = (a.y < b.y ? a.y : b.y); |
| tmp.z = (a.z < b.z ? a.z : b.z); |
| tmp.w = (a.w < b.w ? a.w : b.w); |
| return tmp; |
| version: 9 20 |
| end: |
| |
| start: |
| w: 1, 2, 3, 4 |
| t: i8 i16 i32 i64 u8 u16 u32 u64 |
| name: min |
| ret: #2#1 |
| arg: #2#1 a |
| arg: #2#1 b |
| comment: |
| Returns the minimum value of two arguments. |
| version: 21 |
| end: |
| |
| start: |
| w: 1, 2, 3, 4 |
| t: f32 |
| name: mix |
| ret: #2#1 |
| arg: #2#1 start |
| arg: #2#1 stop |
| arg: #2#1 fraction |
| comment: |
| Returns start + ((stop - start) * fraction). |
| |
| This can be useful for mixing two values. For example, to create a new color that is 40% color1 and 60% color2, use mix(color1, color2, 0.6f). |
| version: 9 |
| end: |
| |
| start: |
| w: 2, 3, 4 |
| t: f32 |
| name: mix |
| ret: #2#1 |
| arg: #2#1 start |
| arg: #2#1 stop |
| arg: #2 fraction |
| comment: |
| Returns start + ((stop - start) * fraction). |
| |
| This can be useful for mixing two values. For example, to create a new color that is 40% color1 and 60% color2, use mix(color1, color2, 0.6f). |
| version: 9 |
| end: |
| |
| start: |
| w: 1, 2, 3, 4 |
| t: f32 |
| name: modf |
| ret: #2#1 |
| arg: #2#1 v |
| arg: #2#1 *integral_part |
| comment: |
| Returns the integral and fractional components of a number. |
| |
| Both components will have the same sign as x. For example, for an input of -3.72f, iret will be set to -3.f and .72f will be returned. |
| |
| @param v Source value |
| @param integral_part integral_part[0] will be set to the integral portion of the number. |
| @return The floating point portion of the value. |
| version: 9 |
| end: |
| |
| start: |
| w: 1 |
| t: f32 |
| name: nan |
| ret: #2#1 |
| arg: uint#1 v |
| comment: |
| Returns a NaN value (Not a Number). |
| |
| @param v Not used. |
| #TODO We're not using the argument. Once we do, add this documentation line: |
| # The argument is embedded into the return value and can be used to distinguish various NaNs. |
| version: 9 |
| end: |
| |
| start: |
| w: 1, 2, 3, 4 |
| t: f32 |
| name: native_acos |
| ret: #2#1 |
| arg: #2#1 v range(-1,1) |
| comment: |
| Returns the approximate inverse cosine, in radians. |
| version: 21 |
| # TODO Temporary |
| test: limited(0.0005) |
| end: |
| |
| start: |
| w: 1, 2, 3, 4 |
| t: f32 |
| name: native_acosh |
| ret: #2#1 |
| arg: #2#1 v |
| comment: |
| Returns the approximate inverse hyperbolic cosine, in radians. |
| version: 21 |
| # TODO Temporary |
| test: limited(0.0005) |
| end: |
| |
| start: |
| w: 1, 2, 3, 4 |
| t: f32 |
| name: native_acospi |
| ret: #2#1 |
| arg: #2#1 v range(-1,1) |
| comment: |
| Returns the approximate inverse cosine in radians, divided by pi. |
| |
| To get an inverse cosine measured in degrees, use acospi(a) * 180.f. |
| version: 21 |
| # TODO Temporary |
| test: limited(0.0005) |
| end: |
| |
| start: |
| w: 1, 2, 3, 4 |
| t: f32 |
| name: native_asin |
| ret: #2#1 |
| arg: #2#1 v range(-1,1) |
| comment: |
| Returns the approximate inverse sine, in radians. |
| version: 21 |
| # TODO Temporary |
| test: limited(0.0005) |
| end: |
| |
| start: |
| w: 1, 2, 3, 4 |
| t: f32 |
| name: native_asinh |
| ret: #2#1 |
| arg: #2#1 v |
| comment: |
| Returns the approximate inverse hyperbolic sine, in radians. |
| version: 21 |
| # TODO Temporary |
| test: limited(0.0005) |
| end: |
| |
| start: |
| w: 1, 2, 3, 4 |
| t: f32 |
| name: native_asinpi |
| ret: #2#1 |
| arg: #2#1 v range(-1,1) |
| comment: |
| Returns the approximate inverse sine in radians, divided by pi. |
| |
| To get an inverse sine measured in degrees, use asinpi(a) * 180.f. |
| version: 21 |
| # TODO Temporary |
| test: limited(0.0005) |
| end: |
| |
| start: |
| w: 1, 2, 3, 4 |
| t: f32 |
| name: native_atan |
| ret: #2#1 |
| arg: #2#1 v range(-1,1) |
| comment: |
| Returns the approximate inverse tangent, in radians. |
| version: 21 |
| # TODO Temporary |
| test: limited(0.0005) |
| end: |
| |
| start: |
| w: 1, 2, 3, 4 |
| t: f32 |
| name: native_atan2 |
| ret: #2#1 |
| arg: #2#1 numerator |
| arg: #2#1 denominator |
| comment: |
| Returns the approximate inverse tangent of numerator / denominator, in radians. |
| |
| denominator can be 0. |
| version: 21 |
| # TODO Temporary |
| test: limited(0.0005) |
| end: |
| |
| start: |
| w: 1, 2, 3, 4 |
| t: f32 |
| name: native_atan2pi |
| ret: #2#1 |
| arg: #2#1 numerator |
| arg: #2#1 denominator |
| comment: |
| Returns the approximate inverse tangent of numerator / denominator, in radians, divided by pi. |
| |
| To get an inverse tangent measured in degrees, use atan2pi(n, d) * 180.f. |
| |
| denominator can be 0. |
| version: 21 |
| # TODO Temporary |
| test: limited(0.0005) |
| end: |
| |
| start: |
| w: 1, 2, 3, 4 |
| t: f32 |
| name: native_atanh |
| ret: #2#1 |
| arg: #2#1 v range(-1,1) |
| comment: |
| Returns the approximate inverse hyperbolic tangent, in radians. |
| version: 21 |
| # TODO Temporary |
| test: limited(0.0005) |
| end: |
| |
| start: |
| w: 1, 2, 3, 4 |
| t: f32 |
| name: native_atanpi |
| ret: #2#1 |
| arg: #2#1 v range(-1,1) |
| comment: |
| Returns the approximate inverse tangent in radians, divided by pi. |
| |
| To get an inverse tangent measured in degrees, use atanpi(a) * 180.f. |
| version: 21 |
| # TODO Temporary |
| test: limited(0.0005) |
| end: |
| |
| start: |
| w: 1, 2, 3, 4 |
| t: f32 |
| name: native_cbrt |
| ret: #2#1 |
| arg: #2#1 v |
| comment: |
| Returns the approximate cubic root. |
| version: 21 |
| end: |
| |
| start: |
| w: 1, 2, 3, 4 |
| t: f32 |
| name: native_cos |
| ret: #2#1 |
| arg: #2#1 v |
| comment: |
| Returns the approximate cosine of an angle measured in radians. |
| version: 21 |
| end: |
| |
| start: |
| w: 1, 2, 3, 4 |
| t: f32 |
| name: native_cosh |
| ret: #2#1 |
| arg: #2#1 v |
| comment: |
| Returns the approximate hypebolic cosine. |
| version: 21 |
| end: |
| |
| start: |
| w: 1, 2, 3, 4 |
| t: f32 |
| name: native_cospi |
| ret: #2#1 |
| arg: #2#1 v |
| comment: |
| Returns the approximate cosine of (v * pi), where (v * pi) is measured in radians. |
| |
| To get the cosine of a value measured in degrees, call cospi(v / 180.f). |
| version: 21 |
| end: |
| |
| start: |
| w: 1, 2, 3, 4 |
| t: f32 |
| name: native_distance |
| ret: #2 |
| arg: #2#1 left_vector |
| arg: #2#1 right_vector |
| comment: |
| Computes the approximate distance between two points. |
| version: 21 |
| test: vector |
| end: |
| |
| start: |
| w: 1, 2, 3, 4 |
| t: f32 |
| name: native_divide |
| ret: #2#1 |
| arg: #2#1 left_vector |
| arg: #2#1 right_vector |
| comment: |
| Computes the approximate division result of two values. |
| version: 21 |
| end: |
| |
| start: |
| w: 1, 2, 3, 4 |
| t: f32 |
| name: native_exp |
| ret: #2#1 |
| arg: #2#1 v range(-86,86) |
| comment: |
| Fast approximate exp. |
| |
| It is valid for inputs from -86.f to 86.f. The precision is no worse than what would be expected from using 16 bit floating point values. |
| version: 18 |
| test: limited |
| end: |
| |
| start: |
| w: 1, 2, 3, 4 |
| t: f32 |
| name: native_exp10 |
| ret: #2#1 |
| arg: #2#1 v range(-37,37) |
| comment: |
| Fast approximate exp10. |
| |
| It is valid for inputs from -37.f to 37.f. The precision is no worse than what would be expected from using 16 bit floating point values. |
| version: 18 |
| test: limited |
| end: |
| |
| start: |
| w: 1, 2, 3, 4 |
| t: f32 |
| name: native_exp2 |
| ret: #2#1 |
| arg: #2#1 v range(-125,125) |
| comment: |
| Fast approximate exp2. |
| |
| It is valid for inputs from -125.f to 125.f. The precision is no worse than what would be expected from using 16 bit floating point values. |
| version: 18 |
| test: limited |
| end: |
| |
| start: |
| w: 1, 2, 3, 4 |
| t: f32 |
| name: native_expm1 |
| ret: #2#1 |
| arg: #2#1 v |
| comment: |
| Returns the approximate (e ^ v) - 1. |
| version: 21 |
| end: |
| |
| start: |
| w: 1, 2, 3, 4 |
| t: f32 |
| name: native_hypot |
| ret: #2#1 |
| arg: #2#1 a |
| arg: #2#1 b |
| comment: |
| Returns the approximate native_sqrt(a * a + b * b) |
| version: 21 |
| end: |
| |
| start: |
| w: 1, 2, 3, 4 |
| t: f32 |
| name: native_length |
| ret: #2 |
| arg: #2#1 v |
| comment: |
| Compute the approximate length of a vector. |
| version: 21 |
| test: vector |
| end: |
| |
| start: |
| w: 1, 2, 3, 4 |
| t: f32 |
| name: native_log |
| ret: #2#1 |
| arg: #2#1 v range(10e-10,10e10) |
| comment: |
| Fast approximate log. |
| |
| It is not accurate for values very close to zero. |
| version: 18 |
| test: limited |
| end: |
| |
| start: |
| w: 1, 2, 3, 4 |
| t: f32 |
| name: native_log10 |
| ret: #2#1 |
| arg: #2#1 v range(10e-10,10e10) |
| comment: |
| Fast approximate log10. |
| |
| It is not accurate for values very close to zero. |
| version: 18 |
| test: limited |
| end: |
| |
| start: |
| w: 1, 2, 3, 4 |
| t: f32 |
| name: native_log1p |
| ret: #2#1 |
| arg: #2#1 v |
| comment: |
| Returns the approximate natural logarithm of (v + 1.0f) |
| version: 21 |
| end: |
| |
| start: |
| w: 1, 2, 3, 4 |
| t: f32 |
| name: native_log2 |
| ret: #2#1 |
| arg: #2#1 v range(10e-10,10e10) |
| comment: |
| Fast approximate log2. |
| |
| It is not accurate for values very close to zero. |
| version: 18 |
| test: limited |
| end: |
| |
| start: |
| w: 1, 2, 3, 4 |
| t: f32 |
| name: native_normalize |
| ret: #2#1 |
| arg: #2#1 v |
| comment: |
| Approximately normalizes a vector. |
| version: 21 |
| test: vector |
| end: |
| |
| start: |
| w: 1, 2, 3, 4 |
| t: f32 |
| name: native_powr |
| ret: #2#1 |
| arg: #2#1 base range(0,256) |
| arg: #2#1 exponent range(-15,15) |
| comment: |
| Fast approximate (base ^ exponent). |
| |
| @param base Must be between 0.f and 256.f. The function is not accurate for values very close to zero. |
| @param exponent Must be between -15.f and 15.f. |
| version: 18 |
| test: limited |
| end: |
| |
| start: |
| w: 1, 2, 3, 4 |
| t: f32 |
| name: native_recip |
| ret: #2#1 |
| arg: #2#1 v |
| comment: |
| Returns the approximate approximate reciprocal of a value. |
| version: 21 |
| end: |
| |
| start: |
| w: 1, 2, 3, 4 |
| t: f32 |
| name: native_rootn |
| ret: #2#1 |
| arg: #2#1 v |
| arg: int#1 n |
| comment: |
| Compute the approximate Nth root of a value. |
| version: 21 |
| end: |
| |
| start: |
| w: 1, 2, 3, 4 |
| t: f32 |
| name: native_rsqrt |
| ret: #2#1 |
| arg: #2#1 v |
| comment: |
| Returns approximate (1 / sqrt(v)). |
| version: 21 |
| end: |
| |
| start: |
| w: 1, 2, 3, 4 |
| t: f32 |
| name: native_sin |
| ret: #2#1 |
| arg: #2#1 v |
| comment: |
| Returns the approximate sine of an angle measured in radians. |
| version: 21 |
| end: |
| |
| start: |
| w: 1, 2, 3, 4 |
| t: f32 |
| name: native_sincos |
| ret: #2#1 |
| arg: #2#1 v |
| arg: #2#1 *cos |
| comment: |
| Returns the approximate sine and cosine of a value. |
| |
| @return sine |
| @param v The incoming value in radians |
| @param *cos cos[0] will be set to the cosine value. |
| version: 21 |
| # TODO Temporary |
| test: limited(0.0005) |
| end: |
| |
| start: |
| w: 1, 2, 3, 4 |
| t: f32 |
| name: native_sinh |
| ret: #2#1 |
| arg: #2#1 v |
| comment: |
| Returns the approximate hyperbolic sine of a value specified in radians. |
| version: 21 |
| end: |
| |
| start: |
| w: 1, 2, 3, 4 |
| t: f32 |
| name: native_sinpi |
| ret: #2#1 |
| arg: #2#1 v |
| comment: |
| Returns the approximate sine of (v * pi), where (v * pi) is measured in radians. |
| |
| To get the sine of a value measured in degrees, call sinpi(v / 180.f). |
| version: 21 |
| end: |
| |
| start: |
| w: 1, 2, 3, 4 |
| t: f32 |
| name: native_sqrt |
| ret: #2#1 |
| arg: #2#1 v |
| comment: |
| Returns the approximate sqrt(v). |
| version: 21 |
| end: |
| |
| start: |
| w: 1, 2, 3, 4 |
| t: f32 |
| name: native_tan |
| ret: #2#1 |
| arg: #2#1 v |
| comment: |
| Returns the approximate tangent of an angle measured in radians. |
| version: 21 |
| end: |
| |
| start: |
| w: 1, 2, 3, 4 |
| t: f32 |
| name: native_tanh |
| ret: #2#1 |
| arg: #2#1 v |
| comment: |
| Returns the approximate hyperbolic tangent of a value. |
| version: 21 |
| end: |
| |
| start: |
| w: 1, 2, 3, 4 |
| t: f32 |
| name: native_tanpi |
| ret: #2#1 |
| arg: #2#1 v |
| comment: |
| Returns the approximate tangent of (v * pi), where (v * pi) is measured in radians. |
| |
| To get the tangent of a value measured in degrees, call tanpi(v / 180.f). |
| version: 21 |
| end: |
| |
| start: |
| w: 1, 2, 3, 4 |
| t: f32 |
| name: nextafter |
| ret: #2#1 |
| arg: #2#1 v |
| arg: #2#1 target |
| comment: |
| Returns the next floating point number from v towards target. |
| version: 9 |
| end: |
| |
| start: |
| w: 1, 2, 3, 4 |
| t: f32 |
| name: normalize |
| ret: #2#1 |
| arg: #2#1 v |
| comment: |
| Normalize a vector. |
| |
| For vectors of size 1, returns -1.f for negative values, 0.f for null values, and 1.f for positive values. |
| version: 9 |
| test: vector |
| end: |
| |
| start: |
| w: 1, 2, 3, 4 |
| t: f32 |
| name: pow |
| ret: #2#1 |
| arg: #2#1 base |
| arg: #2#1 exponent |
| comment: |
| Returns base raised to the power exponent, i.e. base ^ exponent. |
| |
| pown() and powr() are similar. pown() takes an integer exponent. powr() assumes the base to be non-negative. |
| version: 9 |
| end: |
| |
| start: |
| w: 1, 2, 3, 4 |
| t: f32 |
| name: pown |
| ret: #2#1 |
| arg: #2#1 base |
| arg: int#1 exponent |
| comment: |
| Returns base raised to the power exponent, i.e. base ^ exponent. |
| |
| pow() and powr() are similar. The both take a float exponent. powr() also assumes the base to be non-negative. |
| version: 9 |
| end: |
| |
| start: |
| w: 1, 2, 3, 4 |
| t: f32 |
| name: powr |
| ret: #2#1 |
| arg: #2#1 base range(0,3000) |
| arg: #2#1 exponent |
| comment: |
| Returns base raised to the power exponent, i.e. base ^ exponent. base must be >= 0. |
| |
| pow() and pown() are similar. They both make no assumptions about the base. pow() takes a float exponent while pown() take an integer. |
| version: 9 |
| end: |
| |
| start: |
| w: 1, 2, 3, 4 |
| t: f32 |
| name: radians |
| ret: #2#1 |
| arg: #2#1 v |
| comment: |
| Converts from degrees to radians. |
| version: 9 |
| end: |
| |
| start: |
| w: 1, 2, 3, 4 |
| t: f32 |
| name: remainder |
| ret: #2#1 |
| arg: #2#1 numerator |
| arg: #2#1 denominator |
| comment: |
| Returns the remainder of (numerator / denominator), where the quotient is rounded towards the nearest integer. |
| |
| The function fmod() is similar but rounds toward the closest interger. |
| For example, fmod(-3.8f, 2.f) returns -1.8f (-3.8f - -1.f * 2.f) |
| while remainder(-3.8f, 2.f) returns 0.2f (-3.8f - -2.f * 2.f). |
| version: 9 |
| end: |
| |
| start: |
| w: 1, 2, 3, 4 |
| t: f32 |
| name: remquo |
| ret: #2#1 |
| arg: #2#1 numerator |
| arg: #2#1 denominator |
| arg: int#1 *quotient |
| comment: |
| Returns the quotient and the remainder of (numerator / denominator). |
| |
| Only the sign and lowest three bits of the quotient are guaranteed to be accurate. |
| |
| This function is useful for implementing periodic functions. The low three bits of the quotient gives the quadrant and the remainder the distance within the quadrant. For example, an implementation of sin(x) could call remquo(x, PI / 2.f, &quadrant) to reduce very large value of x to something within a limited range. |
| |
| Example: remquo(-23.5f, 8.f, ") sets the lowest three bits of quot to 3 and the sign negative. It returns 0.5f. |
| |
| @param numerator The numerator. |
| @param denominator The denominator. |
| @param *quotient quotient[0] will be set to the integer quotient. |
| @return The remainder, precise only for the low three bits. |
| version: 9 |
| test: custom |
| end: |
| |
| start: |
| w: 1, 2, 3, 4 |
| t: f32 |
| name: rint |
| ret: #2#1 |
| arg: #2#1 v |
| comment: |
| Rounds to the nearest integral value. |
| |
| rint() rounds half values to even. For example, rint(0.5f) returns 0.f and rint(1.5f) returns 2.f. Similarly, rint(-0.5f) returns -0.f and rint(-1.5f) returns -2.f. |
| |
| round() is similar but rounds away from zero. trunc() truncates the decimal fraction. |
| version: 9 |
| end: |
| |
| start: |
| w: 1, 2, 3, 4 |
| t: f32 |
| name: rootn |
| ret: #2#1 |
| arg: #2#1 v |
| arg: int#1 n |
| comment: |
| Compute the Nth root of a value. |
| version: 9 |
| end: |
| |
| start: |
| w: 1, 2, 3, 4 |
| t: f32 |
| name: round |
| ret: #2#1 |
| arg: #2#1 v |
| comment: |
| Round to the nearest integral value. |
| |
| round() rounds half values away from zero. For example, round(0.5f) returns 1.f and round(1.5f) returns 2.f. Similarly, round(-0.5f) returns -1.f and round(-1.5f) returns -2.f. |
| |
| rint() is similar but rounds half values toward even. trunc() truncates the decimal fraction. |
| version: 9 |
| end: |
| |
| start: |
| w: 1, 2, 3, 4 |
| t: f32 |
| name: rsqrt |
| ret: #2#1 |
| arg: #2#1 v |
| comment: |
| Returns (1 / sqrt(v)). |
| version: 9 |
| end: |
| |
| start: |
| w: 1, 2, 3, 4 |
| t: f32 |
| name: sign |
| ret: #2#1 |
| arg: #2#1 v |
| comment: |
| Returns the sign of a value. |
| |
| if (v < 0) return -1.f; |
| else if (v > 0) return 1.f; |
| else return 0.f; |
| version: 9 |
| end: |
| |
| start: |
| w: 1, 2, 3, 4 |
| t: f32 |
| name: sin |
| ret: #2#1 |
| arg: #2#1 v |
| comment: |
| Returns the sine of an angle measured in radians. |
| version: 9 |
| end: |
| |
| start: |
| w: 1, 2, 3, 4 |
| t: f32 |
| name: sincos |
| ret: #2#1 |
| arg: #2#1 v |
| arg: #2#1 *cos |
| comment: |
| Returns the sine and cosine of a value. |
| |
| @return sine of v |
| @param v The incoming value in radians |
| @param *cos cosptr[0] will be set to the cosine value. |
| version: 9 |
| end: |
| |
| start: |
| w: 1, 2, 3, 4 |
| t: f32 |
| name: sinh |
| ret: #2#1 |
| arg: #2#1 v |
| comment: |
| Returns the hyperbolic sine of v, where v is measured in radians. |
| version: 9 |
| end: |
| |
| start: |
| w: 1, 2, 3, 4 |
| t: f32 |
| name: sinpi |
| ret: #2#1 |
| arg: #2#1 v |
| comment: |
| Returns the sine of (v * pi), where (v * pi) is measured in radians. |
| |
| To get the sine of a value measured in degrees, call sinpi(v / 180.f). |
| version: 9 |
| end: |
| |
| start: |
| w: 1, 2, 3, 4 |
| t: f32 |
| name: sqrt |
| ret: #2#1 |
| arg: #2#1 v |
| comment: |
| Returns the square root of a value. |
| version: 9 |
| end: |
| |
| start: |
| w: 1, 2, 3, 4 |
| t: f32 |
| name: step |
| ret: #2#1 |
| arg: #2#1 edge |
| arg: #2#1 v |
| comment: |
| Returns 0.f if v < edge, 1.f otherwise. |
| |
| This can be useful to create conditional computations without using loops and branching instructions. For example, instead of computing (a[i] < b[i]) ? 0.f : atan2(a[i], b[i]) for the corresponding elements of a vector, you could instead use step(a, b) * atan2(a, b). |
| version: 9 |
| end: |
| |
| start: |
| w: 2, 3, 4 |
| t: f32 |
| name: step |
| ret: #2#1 |
| arg: #2#1 edge |
| arg: #2 v |
| comment: |
| Returns 0.f if v < edge, 1.f otherwise. |
| |
| This can be useful to create conditional computations without using loops and branching instructions. For example, instead of computing (a[i] < b) ? 0.f : atan2(a[i], b) for each element of a vector, you could instead use step(a, b) * atan2(a, b). |
| version: 9 |
| end: |
| |
| start: |
| w: 2, 3, 4 |
| t: f32 |
| name: step |
| ret: #2#1 |
| arg: #2 edge |
| arg: #2#1 v |
| comment: |
| Returns 0.f if v < edge, 1.f otherwise. |
| |
| This can be useful to create conditional computations without using loops and branching instructions. For example, instead of computing (a < b[i]) ? 0.f : atan2(a, b[i]) for each element of a vector, you could instead use step(a, b) * atan2(a, b). |
| version: 21 |
| end: |
| |
| start: |
| w: 1, 2, 3, 4 |
| t: f32 |
| name: tan |
| ret: #2#1 |
| arg: #2#1 v |
| comment: |
| Returns the tangent of an angle measured in radians. |
| version: 9 |
| end: |
| |
| start: |
| w: 1, 2, 3, 4 |
| t: f32 |
| name: tanh |
| ret: #2#1 |
| arg: #2#1 v |
| comment: |
| Returns the hyperbolic tangent of a value. |
| version: 9 |
| end: |
| |
| start: |
| w: 1, 2, 3, 4 |
| t: f32 |
| name: tanpi |
| ret: #2#1 |
| arg: #2#1 v |
| comment: |
| Returns the tangent of (v * pi), where (v * pi) is measured in radians. |
| |
| To get the tangent of a value measured in degrees, call tanpi(v / 180.f). |
| version: 9 |
| end: |
| |
| start: |
| w: 1, 2, 3, 4 |
| t: f32 |
| name: tgamma |
| ret: #2#1 |
| arg: #2#1 v |
| comment: |
| Returns the gamma function of a value. |
| version: 9 |
| end: |
| |
| start: |
| w: 1, 2, 3, 4 |
| t: f32 |
| name: trunc |
| ret: #2#1 |
| arg: #2#1 v |
| comment: |
| Rounds to integral using truncation. |
| |
| For example, trunc(1.7f) returns 1.f and trunc(-1.7f) returns -1.f. |
| |
| See rint() and round() for other rounding options. |
| version: 9 |
| end: |