概览
以下数学函数可以应用于标量和向量。当应用于向量时,返回的值是函数应用于输入的每个条目的向量。
例如:
float3 a, b;
// 以下调用设置
// a.x 为 sin(b.x),
// a.y 为 sin(b.y),以及
// a.z 为 sin(b.z)。
a = sin(b);
请参阅矢量数学函数,了解诸如 distance() 和 length() 之类的函数,这些函数将输入解释为 n 维空间中的单个向量。
32 位浮点数的数学运算精度受 pragma rs_fp_relaxed 和 rs_fp_full 的影响。在 rs_fp_relaxed 下,次正规值可能被刷新为零,并且舍入可能趋向零。相比之下,rs_fp_full 要求正确处理次正规值,即小于 1.17549435e-38f 的值。rs_fp_full 还要求四舍五入到最接近的值,且遇半数时向上舍入到偶数。
通过使用常见数学函数的变体,可以实现不同的精度/速度权衡。名称以以下开头的函数
- native_: 可能具有精度较低的自定义硬件实现。此外,次正规值可能被刷新为零,可能使用趋向零的舍入,并且可能无法正确处理 NaN 和无穷大输入。
- half_: 可能使用 16 位浮点数执行内部计算。此外,次正规值可能被刷新为零,并且可能使用趋向零的舍入。
摘要
| 常量 | |
|---|---|
| M_1_PI | 1 / pi,作为 32 位浮点数 |
| M_2_PI | 2 / pi,作为 32 位浮点数 |
| M_2_SQRTPI | 2 / sqrt(pi),作为 32 位浮点数 |
| M_E | e,作为 32 位浮点数 |
| M_LN10 | log_e(10),作为 32 位浮点数 |
| M_LN2 | log_e(2),作为 32 位浮点数 |
| M_LOG10E | log_10(e),作为 32 位浮点数 |
| M_LOG2E | log_2(e),作为 32 位浮点数 |
| M_PI | pi,作为 32 位浮点数 |
| M_PI_2 | pi / 2,作为 32 位浮点数 |
| M_PI_4 | pi / 4,作为 32 位浮点数 |
| M_SQRT1_2 | 1 / sqrt(2),作为 32 位浮点数 |
| M_SQRT2 | sqrt(2),作为 32 位浮点数 |
| 函数 | |
|---|---|
| abs | 整数的绝对值 |
| acos | 反余弦 |
| acosh | 反双曲余弦 |
| acospi | 反余弦除以 pi |
| asin | 反正弦 |
| asinh | 反双曲正弦 |
| asinpi | 反正弦除以 pi |
| atan | 反正切 |
| atan2 | 比值的反正切 |
| atan2pi | 比值的反正切,除以 pi |
| atanh | 反双曲正切 |
| atanpi | 反正切除以 pi |
| cbrt | 立方根 |
| ceil | 不小于某个值的最小整数 |
| clamp | 将值限制在某个范围内 |
| clz | 前导零位数 |
| copysign | 将一个数字的符号复制到另一个数字 |
| cos | 余弦 |
| cosh | 双曲余弦 |
| cospi | 某个数字乘以 pi 的余弦 |
| degrees | 将弧度转换为角度 |
| erf | 数学误差函数 |
| erfc | 数学互补误差函数 |
| exp | e 的某个数的幂 |
| exp10 | 10 的某个数的幂 |
| exp2 | 2 的某个数的幂 |
| expm1 | e 的某个数的幂减一 |
| fabs | 浮点数的绝对值 |
| fdim | 两个值之间的正差 |
| floor | 不大于某个值的最大整数 |
| fma | 乘加运算 |
| fmax | 两个浮点数的最大值 |
| fmin | 两个浮点数的最小值 |
| fmod | 取模 |
| fract | 正小数部分 |
| frexp | 二进制尾数和指数 |
| half_recip | 以 16 位精度计算倒数 |
| half_rsqrt | 以 16 位精度计算平方根的倒数 |
| half_sqrt | 以 16 位精度计算平方根 |
| hypot | 斜边 |
| ilogb | 以 2 为底的指数 |
| ldexp | 根据尾数和指数创建浮点数 |
| lgamma | 伽马函数的自然对数 |
| log | 自然对数 |
| log10 | 以 10 为底的对数 |
| log1p | 某个值加 1 的自然对数 |
| log2 | 以 2 为底的对数 |
| logb | 以 2 为底的指数 |
| mad | 乘加运算 |
| max | 最大值 |
| min | 最小值 |
| mix | 混合两个值 |
| modf | 整数部分和小数部分 |
| nan | 非数字 |
| nan_half | 非数字 |
| native_acos | 近似反余弦 |
| native_acosh | 近似反双曲余弦 |
| native_acospi | 近似反余弦除以 pi |
| native_asin | 近似反正弦 |
| native_asinh | 近似反双曲正弦 |
| native_asinpi | 近似反正弦除以 pi |
| native_atan | 近似反正切 |
| native_atan2 | 近似比值的反正切 |
| native_atan2pi | 近似比值的反正切,除以 pi |
| native_atanh | 近似反双曲正切 |
| native_atanpi | 近似反正切除以 pi |
| native_cbrt | 近似立方根 |
| native_cos | 近似余弦 |
| native_cosh | 近似双曲余弦 |
| native_cospi | 近似某个数字乘以 pi 的余弦 |
| native_divide | 近似除法 |
| native_exp | 近似 e 的某个数的幂 |
| native_exp10 | 近似 10 的某个数的幂 |
| native_exp2 | 近似 2 的某个数的幂 |
| native_expm1 | 近似 e 的某个数的幂减一 |
| native_hypot | 近似斜边 |
| native_log | 近似自然对数 |
| native_log10 | 近似以 10 为底的对数 |
| native_log1p | 近似某个值加 1 的自然对数 |
| native_log2 | 近似以 2 为底的对数 |
| native_powr | 近似正底数的某个指数幂 |
| native_recip | 近似倒数 |
| native_rootn | 近似 n 次方根 |
| native_rsqrt | 近似平方根的倒数 |
| native_sin | 近似正弦 |
| native_sincos | 近似正弦和余弦 |
| native_sinh | 近似双曲正弦 |
| native_sinpi | 近似某个数字乘以 pi 的正弦 |
| native_sqrt | 近似平方根 |
| native_tan | 近似正切 |
| native_tanh | 近似双曲正切 |
| native_tanpi | 近似某个数字乘以 pi 的正切 |
| nextafter | 下一个浮点数 |
| pow | 底数的某个指数幂 |
| pown | 底数的某个整数指数幂 |
| powr | 正底数的某个指数幂 |
| radians | 将角度转换为弧度 |
| remainder | 除法的余数 |
| remquo | 除法的余数和商 |
| rint | 舍入到最接近的偶数 |
| rootn | N 次方根 |
| round | 远离零点取整 |
| rsRand | 伪随机数 |
| rsqrt | 平方根的倒数 |
| sign | 值的正负号 |
| sin | 正弦 |
| sincos | 正弦和余弦 |
| sinh | 双曲正弦 |
| sinpi | 数字乘以 pi 的正弦 |
| sqrt | 平方根 |
| step | 小于指定值返回 0,否则返回 1 |
| tan | 正切 |
| tanh | 双曲正切 |
| tanpi | 数字乘以 pi 的正切 |
| tgamma | Gamma 函数 |
| trunc | 截断浮点数 |
| 已弃用的函数 | |
|---|---|
| rsClamp | 已弃用。将值约束在范围内 |
| rsFrac | 已弃用。返回浮点数的小数部分 |
常量
M_1_PI : 1 / pi,32 位浮点数
| 值: 0.318309886183790671537767526745028724f |
pi 的倒数,32 位浮点数。
M_2_PI : 2 / pi,32 位浮点数
| 值: 0.636619772367581343075535053490057448f |
2 除以 pi,32 位浮点数。
M_2_SQRTPI : 2 / sqrt(pi),32 位浮点数
| 值: 1.128379167095512573896158903121545172f |
2 除以 pi 的平方根,32 位浮点数。
M_E : e,32 位浮点数
| 值: 2.718281828459045235360287471352662498f |
数字 e,自然对数的底,32 位浮点数。
M_LN10 : log_e(10),32 位浮点数
| 值: 2.302585092994045684017991454684364208f |
10 的自然对数,32 位浮点数。
M_LN2 : log_e(2),32 位浮点数
| 值: 0.693147180559945309417232121458176568f |
2 的自然对数,32 位浮点数。
M_LOG10E : log_10(e),32 位浮点数
| 值: 0.434294481903251827651128918916605082f |
e 的以 10 为底的对数,32 位浮点数。
M_LOG2E : log_2(e),32 位浮点数
| 值: 1.442695040888963407359924681001892137f |
e 的以 2 为底的对数,32 位浮点数。
M_PI : pi,32 位浮点数
| 值: 3.141592653589793238462643383279502884f |
常量 pi,32 位浮点数。
M_PI_2 : pi / 2,32 位浮点数
| 值: 1.570796326794896619231321691639751442f |
pi 除以 2,32 位浮点数。
M_PI_4 : pi / 4,32 位浮点数
| 值: 0.785398163397448309615660845819875721f |
pi 除以 4,32 位浮点数。
M_SQRT1_2 : 1 / sqrt(2),32 位浮点数
| 值: 0.707106781186547524400844362104849039f |
2 的平方根的倒数,32 位浮点数。
M_SQRT2 : sqrt(2),32 位浮点数
| 值: 1.414213562373095048801688724209698079f |
2 的平方根,32 位浮点数。
函数
abs : 整数的绝对值
| uchar abs(char v); | |
| uchar2 abs(char2 v); | |
| uchar3 abs(char3 v); | |
| uchar4 abs(char4 v); | |
| uint abs(int v); | |
| uint2 abs(int2 v); | |
| uint3 abs(int3 v); | |
| uint4 abs(int4 v); | |
| ushort abs(short v); | |
| ushort2 abs(short2 v); | |
| ushort3 abs(short3 v); | |
| ushort4 abs(short4 v); |
返回整数的绝对值。
对于浮点数,请使用 fabs()。
acos : 反余弦
| float acos(float v); | |
| float2 acos(float2 v); | |
| float3 acos(float3 v); | |
| float4 acos(float4 v); | |
| half acos(half v); | 添加于 API 级别 24 |
| half2 acos(half2 v); | 添加于 API 级别 24 |
| half3 acos(half3 v); | 添加于 API 级别 24 |
| half4 acos(half4 v); | 添加于 API 级别 24 |
返回反余弦,以弧度为单位。
另请参阅 native_acos()。
acosh : 反双曲余弦
| float acosh(float v); | |
| float2 acosh(float2 v); | |
| float3 acosh(float3 v); | |
| float4 acosh(float4 v); | |
| half acosh(half v); | 添加于 API 级别 24 |
| half2 acosh(half2 v); | 添加于 API 级别 24 |
| half3 acosh(half3 v); | 添加于 API 级别 24 |
| half4 acosh(half4 v); | 添加于 API 级别 24 |
返回反双曲余弦,以弧度为单位。
另请参阅 native_acosh()。
acospi : 反余弦除以 pi
asin : 反正弦
| float asin(float v); | |
| float2 asin(float2 v); | |
| float3 asin(float3 v); | |
| float4 asin(float4 v); | |
| half asin(half v); | 添加于 API 级别 24 |
| half2 asin(half2 v); | 添加于 API 级别 24 |
| half3 asin(half3 v); | 添加于 API 级别 24 |
| half4 asin(half4 v); | 添加于 API 级别 24 |
返回反正弦,以弧度为单位。
另请参阅 native_asin()。
asinh : 反双曲正弦
| float asinh(float v); | |
| float2 asinh(float2 v); | |
| float3 asinh(float3 v); | |
| float4 asinh(float4 v); | |
| half asinh(half v); | 添加于 API 级别 24 |
| half2 asinh(half2 v); | 添加于 API 级别 24 |
| half3 asinh(half3 v); | 添加于 API 级别 24 |
| half4 asinh(half4 v); | 添加于 API 级别 24 |
返回反双曲正弦,以弧度为单位。
另请参阅 native_asinh()。
asinpi : 反正弦除以 pi
atan : 反正切
| float atan(float v); | |
| float2 atan(float2 v); | |
| float3 atan(float3 v); | |
| float4 atan(float4 v); | |
| half atan(half v); | 添加于 API 级别 24 |
| half2 atan(half2 v); | 添加于 API 级别 24 |
| half3 atan(half3 v); | 添加于 API 级别 24 |
| half4 atan(half4 v); | 添加于 API 级别 24 |
返回反正切,以弧度为单位。
另请参阅 native_atan()。
atan2 : 比值的反正切
| float atan2(float numerator, float denominator); | |
| float2 atan2(float2 numerator, float2 denominator); | |
| float3 atan2(float3 numerator, float3 denominator); | |
| float4 atan2(float4 numerator, float4 denominator); | |
| half atan2(half numerator, half denominator); | 添加于 API 级别 24 |
| half2 atan2(half2 numerator, half2 denominator); | 添加于 API 级别 24 |
| half3 atan2(half3 numerator, half3 denominator); | 添加于 API 级别 24 |
| half4 atan2(half4 numerator, half4 denominator); | 添加于 API 级别 24 |
参数
| numerator | 分子。 |
|---|---|
| denominator | 分母。可以为 0。 |
返回 (numerator / denominator) 的反正切,以弧度为单位。
另请参阅 native_atan2()。
atan2pi : 比值的反正切,除以 pi
| float atan2pi(float numerator, float denominator); | |
| float2 atan2pi(float2 numerator, float2 denominator); | |
| float3 atan2pi(float3 numerator, float3 denominator); | |
| float4 atan2pi(float4 numerator, float4 denominator); | |
| half atan2pi(half numerator, half denominator); | 添加于 API 级别 24 |
| half2 atan2pi(half2 numerator, half2 denominator); | 添加于 API 级别 24 |
| half3 atan2pi(half3 numerator, half3 denominator); | 添加于 API 级别 24 |
| half4 atan2pi(half4 numerator, half4 denominator); | 添加于 API 级别 24 |
参数
| numerator | 分子。 |
|---|---|
| denominator | 分母。可以为 0。 |
返回 (numerator / denominator) 的反正切,以弧度为单位,并除以 pi。
要获取以度为单位的反正切,请使用 atan2pi(n, d) * 180.f。
另请参阅 native_atan2pi()。
atanh : 反双曲正切
| float atanh(float v); | |
| float2 atanh(float2 v); | |
| float3 atanh(float3 v); | |
| float4 atanh(float4 v); | |
| half atanh(half v); | 添加于 API 级别 24 |
| half2 atanh(half2 v); | 添加于 API 级别 24 |
| half3 atanh(half3 v); | 添加于 API 级别 24 |
| half4 atanh(half4 v); | 添加于 API 级别 24 |
返回反双曲正切,以弧度为单位。
另请参阅 native_atanh()。
atanpi : 反正切除以 pi
cbrt : 立方根
| float cbrt(float v); | |
| float2 cbrt(float2 v); | |
| float3 cbrt(float3 v); | |
| float4 cbrt(float4 v); | |
| half cbrt(half v); | 添加于 API 级别 24 |
| half2 cbrt(half2 v); | 添加于 API 级别 24 |
| half3 cbrt(half3 v); | 添加于 API 级别 24 |
| half4 cbrt(half4 v); | 添加于 API 级别 24 |
返回立方根。
另请参阅 native_cbrt()。
ceil : 不小于给定值的最小整数
clamp : 将值约束在范围内
| char clamp(char value, char min_value, char max_value); | 添加于 API 级别 19 |
| char2 clamp(char2 value, char min_value, char max_value); | 添加于 API 级别 19 |
| char2 clamp(char2 value, char2 min_value, char2 max_value); | 添加于 API 级别 19 |
| char3 clamp(char3 value, char min_value, char max_value); | 添加于 API 级别 19 |
| char3 clamp(char3 value, char3 min_value, char3 max_value); | 添加于 API 级别 19 |
| char4 clamp(char4 value, char min_value, char max_value); | 添加于 API 级别 19 |
| char4 clamp(char4 value, char4 min_value, char4 max_value); | 添加于 API 级别 19 |
| float clamp(float value, float min_value, float max_value); | |
| float2 clamp(float2 value, float min_value, float max_value); | |
| float2 clamp(float2 value, float2 min_value, float2 max_value); | |
| float3 clamp(float3 value, float min_value, float max_value); | |
| float3 clamp(float3 value, float3 min_value, float3 max_value); | |
| float4 clamp(float4 value, float min_value, float max_value); | |
| float4 clamp(float4 value, float4 min_value, float4 max_value); | |
| half clamp(half value, half min_value, half max_value); | 添加于 API 级别 24 |
| half2 clamp(half2 value, half min_value, half max_value); | 添加于 API 级别 24 |
| half2 clamp(half2 value, half2 min_value, half2 max_value); | 添加于 API 级别 24 |
| half3 clamp(half3 value, half min_value, half max_value); | 添加于 API 级别 24 |
| half3 clamp(half3 value, half3 min_value, half3 max_value); | 添加于 API 级别 24 |
| half4 clamp(half4 value, half min_value, half max_value); | 添加于 API 级别 24 |
| half4 clamp(half4 value, half4 min_value, half4 max_value); | 添加于 API 级别 24 |
| int clamp(int value, int min_value, int max_value); | 添加于 API 级别 19 |
| int2 clamp(int2 value, int min_value, int max_value); | 添加于 API 级别 19 |
| int2 clamp(int2 value, int2 min_value, int2 max_value); | 添加于 API 级别 19 |
| int3 clamp(int3 value, int min_value, int max_value); | 添加于 API 级别 19 |
| int3 clamp(int3 value, int3 min_value, int3 max_value); | 添加于 API 级别 19 |
| int4 clamp(int4 value, int min_value, int max_value); | 添加于 API 级别 19 |
| int4 clamp(int4 value, int4 min_value, int4 max_value); | 添加于 API 级别 19 |
| long clamp(long value, long min_value, long max_value); | 添加于 API 级别 19 |
| long2 clamp(long2 value, long min_value, long max_value); | 添加于 API 级别 19 |
| long2 clamp(long2 value, long2 min_value, long2 max_value); | 添加于 API 级别 19 |
| long3 clamp(long3 value, long min_value, long max_value); | 添加于 API 级别 19 |
| long3 clamp(long3 value, long3 min_value, long3 max_value); | 添加于 API 级别 19 |
| long4 clamp(long4 value, long min_value, long max_value); | 添加于 API 级别 19 |
| long4 clamp(long4 value, long4 min_value, long4 max_value); | 添加于 API 级别 19 |
| short clamp(short value, short min_value, short max_value); | 添加于 API 级别 19 |
| short2 clamp(short2 value, short min_value, short max_value); | 添加于 API 级别 19 |
| short2 clamp(short2 value, short2 min_value, short2 max_value); | 添加于 API 级别 19 |
| short3 clamp(short3 value, short min_value, short max_value); | 添加于 API 级别 19 |
| short3 clamp(short3 value, short3 min_value, short3 max_value); | 添加于 API 级别 19 |
| short4 clamp(short4 value, short min_value, short max_value); | 添加于 API 级别 19 |
| short4 clamp(short4 value, short4 min_value, short4 max_value); | 添加于 API 级别 19 |
| uchar clamp(uchar value, uchar min_value, uchar max_value); | 添加于 API 级别 19 |
| uchar2 clamp(uchar2 value, uchar min_value, uchar max_value); | 添加于 API 级别 19 |
| uchar2 clamp(uchar2 value, uchar2 min_value, uchar2 max_value); | 添加于 API 级别 19 |
| uchar3 clamp(uchar3 value, uchar min_value, uchar max_value); | 添加于 API 级别 19 |
| uchar3 clamp(uchar3 value, uchar3 min_value, uchar3 max_value); | 添加于 API 级别 19 |
| uchar4 clamp(uchar4 value, uchar min_value, uchar max_value); | 添加于 API 级别 19 |
| uchar4 clamp(uchar4 value, uchar4 min_value, uchar4 max_value); | 添加于 API 级别 19 |
| uint clamp(uint value, uint min_value, uint max_value); | 添加于 API 级别 19 |
| uint2 clamp(uint2 value, uint min_value, uint max_value); | 添加于 API 级别 19 |
| uint2 clamp(uint2 value, uint2 min_value, uint2 max_value); | 添加于 API 级别 19 |
| uint3 clamp(uint3 value, uint min_value, uint max_value); | 添加于 API 级别 19 |
| uint3 clamp(uint3 value, uint3 min_value, uint3 max_value); | 添加于 API 级别 19 |
| uint4 clamp(uint4 value, uint min_value, uint max_value); | 添加于 API 级别 19 |
| uint4 clamp(uint4 value, uint4 min_value, uint4 max_value); | 添加于 API 级别 19 |
| ulong clamp(ulong value, ulong min_value, ulong max_value); | 添加于 API 级别 19 |
| ulong2 clamp(ulong2 value, ulong min_value, ulong max_value); | 添加于 API 级别 19 |
| ulong2 clamp(ulong2 value, ulong2 min_value, ulong2 max_value); | 添加于 API 级别 19 |
| ulong3 clamp(ulong3 value, ulong min_value, ulong max_value); | 添加于 API 级别 19 |
| ulong3 clamp(ulong3 value, ulong3 min_value, ulong3 max_value); | 添加于 API 级别 19 |
| ulong4 clamp(ulong4 value, ulong min_value, ulong max_value); | 添加于 API 级别 19 |
| ulong4 clamp(ulong4 value, ulong4 min_value, ulong4 max_value); | 添加于 API 级别 19 |
| ushort clamp(ushort value, ushort min_value, ushort max_value); | 添加于 API 级别 19 |
| ushort2 clamp(ushort2 value, ushort min_value, ushort max_value); | 添加于 API 级别 19 |
| ushort2 clamp(ushort2 value, ushort2 min_value, ushort2 max_value); | 添加于 API 级别 19 |
| ushort3 clamp(ushort3 value, ushort min_value, ushort max_value); | 添加于 API 级别 19 |
| ushort3 clamp(ushort3 value, ushort3 min_value, ushort3 max_value); | 添加于 API 级别 19 |
| ushort4 clamp(ushort4 value, ushort min_value, ushort max_value); | 添加于 API 级别 19 |
| ushort4 clamp(ushort4 value, ushort4 min_value, ushort4 max_value); | 添加于 API 级别 19 |
参数
| value | 要被限制的值。 |
|---|---|
| min_value | 下界,一个标量或匹配的向量。 |
| max_value | 上界,必须与下界的类型匹配。 |
将值限制到指定的上下界。如果 value < min_value,clamp() 返回 min_value;如果 value > max_value,则返回 max_value;否则返回 value。
clamp 有两种变体:一种是 min 和 max 是应用于 value 所有条目的标量,另一种是 min 和 max 也是向量。
如果 min_value 大于 max_value,结果未定义。
clz : 开头 0 位数
| char clz(char value); | |
| char2 clz(char2 value); | |
| char3 clz(char3 value); | |
| char4 clz(char4 value); | |
| int clz(int value); | |
| int2 clz(int2 value); | |
| int3 clz(int3 value); | |
| int4 clz(int4 value); | |
| short clz(short value); | |
| short2 clz(short2 value); | |
| short3 clz(short3 value); | |
| short4 clz(short4 value); | |
| uchar clz(uchar value); | |
| uchar2 clz(uchar2 value); | |
| uchar3 clz(uchar3 value); | |
| uchar4 clz(uchar4 value); | |
| uint clz(uint value); | |
| uint2 clz(uint2 value); | |
| uint3 clz(uint3 value); | |
| uint4 clz(uint4 value); | |
| ushort clz(ushort value); | |
| ushort2 clz(ushort2 value); | |
| ushort3 clz(ushort3 value); | |
| ushort4 clz(ushort4 value); |
返回一个值的开头 0 位数。
例如,clz((char)0x03) 返回 6。
copysign : 复制一个数字的正负号到另一个数字
| float copysign(float magnitude_value, float sign_value); | |
| float2 copysign(float2 magnitude_value, float2 sign_value); | |
| float3 copysign(float3 magnitude_value, float3 sign_value); | |
| float4 copysign(float4 magnitude_value, float4 sign_value); | |
| half copysign(half magnitude_value, half sign_value); | 添加于 API 级别 24 |
| half2 copysign(half2 magnitude_value, half2 sign_value); | 添加于 API 级别 24 |
| half3 copysign(half3 magnitude_value, half3 sign_value); | 添加于 API 级别 24 |
| half4 copysign(half4 magnitude_value, half4 sign_value); | 添加于 API 级别 24 |
从 sign_value 复制正负号到 magnitude_value。
返回的值是 magnitude_value 或 -magnitude_value。
例如,copysign(4.0f, -2.7f) 返回 -4.0f,copysign(-4.0f, 2.7f) 返回 4.0f。
cos : 余弦
| float cos(float v); | |
| float2 cos(float2 v); | |
| float3 cos(float3 v); | |
| float4 cos(float4 v); | |
| half cos(half v); | 添加于 API 级别 24 |
| half2 cos(half2 v); | 添加于 API 级别 24 |
| half3 cos(half3 v); | 添加于 API 级别 24 |
| half4 cos(half4 v); | 添加于 API 级别 24 |
返回以弧度为单位的角的余弦。
另请参阅 native_cos()。
cosh : 双曲余弦
| float cosh(float v); | |
| float2 cosh(float2 v); | |
| float3 cosh(float3 v); | |
| float4 cosh(float4 v); | |
| half cosh(half v); | 添加于 API 级别 24 |
| half2 cosh(half2 v); | 添加于 API 级别 24 |
| half3 cosh(half3 v); | 添加于 API 级别 24 |
| half4 cosh(half4 v); | 添加于 API 级别 24 |
返回 v 的双曲余弦,v 以弧度为单位。
另请参阅 native_cosh()。
cospi : 数字乘以 pi 的余弦
degrees : 将弧度转换为度
| float degrees(float v); | |
| float2 degrees(float2 v); | |
| float3 degrees(float3 v); | |
| float4 degrees(float4 v); | |
| half degrees(half v); | 添加于 API 级别 24 |
| half2 degrees(half2 v); | 添加于 API 级别 24 |
| half3 degrees(half3 v); | 添加于 API 级别 24 |
| half4 degrees(half4 v); | 添加于 API 级别 24 |
将弧度转换为度。
erf : 数学误差函数
| float erf(float v); | |
| float2 erf(float2 v); | |
| float3 erf(float3 v); | |
| float4 erf(float4 v); | |
| half erf(half v); | 添加于 API 级别 24 |
| half2 erf(half2 v); | 添加于 API 级别 24 |
| half3 erf(half3 v); | 添加于 API 级别 24 |
| half4 erf(half4 v); | 添加于 API 级别 24 |
返回误差函数。
erfc : 数学互补误差函数
| float erfc(float v); | |
| float2 erfc(float2 v); | |
| float3 erfc(float3 v); | |
| float4 erfc(float4 v); | |
| half erfc(half v); | 添加于 API 级别 24 |
| half2 erfc(half2 v); | 添加于 API 级别 24 |
| half3 erfc(half3 v); | 添加于 API 级别 24 |
| half4 erfc(half4 v); | 添加于 API 级别 24 |
返回互补误差函数。
exp : e 的幂
| float exp(float v); | |
| float2 exp(float2 v); | |
| float3 exp(float3 v); | |
| float4 exp(float4 v); | |
| half exp(half v); | 添加于 API 级别 24 |
| half2 exp(half2 v); | 添加于 API 级别 24 |
| half3 exp(half3 v); | 添加于 API 级别 24 |
| half4 exp(half4 v); | 添加于 API 级别 24 |
返回 e 的 v 次方,即 e ^ v。
另请参阅 native_exp()。
exp10 : 10 的幂
| float exp10(float v); | |
| float2 exp10(float2 v); | |
| float3 exp10(float3 v); | |
| float4 exp10(float4 v); | |
| half exp10(half v); | 添加于 API 级别 24 |
| half2 exp10(half2 v); | 添加于 API 级别 24 |
| half3 exp10(half3 v); | 添加于 API 级别 24 |
| half4 exp10(half4 v); | 添加于 API 级别 24 |
返回 10 的 v 次方,即 10.f ^ v。
另请参阅 native_exp10()。
exp2 : 2 的幂
| float exp2(float v); | |
| float2 exp2(float2 v); | |
| float3 exp2(float3 v); | |
| float4 exp2(float4 v); | |
| half exp2(half v); | 添加于 API 级别 24 |
| half2 exp2(half2 v); | 添加于 API 级别 24 |
| half3 exp2(half3 v); | 添加于 API 级别 24 |
| half4 exp2(half4 v); | 添加于 API 级别 24 |
返回 2 的 v 次方,即 2.f ^ v。
另请参阅 native_exp2()。
expm1 : e 的幂减去 1
| float expm1(float v); | |
| float2 expm1(float2 v); | |
| float3 expm1(float3 v); | |
| float4 expm1(float4 v); | |
| half expm1(half v); | 添加于 API 级别 24 |
| half2 expm1(half2 v); | 添加于 API 级别 24 |
| half3 expm1(half3 v); | 添加于 API 级别 24 |
| half4 expm1(half4 v); | 添加于 API 级别 24 |
返回 e 的 v 次方减去 1,即 (e ^ v) - 1。
另请参阅 native_expm1()。
fabs : 浮点数的绝对值
| float fabs(float v); | |
| float2 fabs(float2 v); | |
| float3 fabs(float3 v); | |
| float4 fabs(float4 v); | |
| half fabs(half v); | 添加于 API 级别 24 |
| half2 fabs(half2 v); | 添加于 API 级别 24 |
| half3 fabs(half3 v); | 添加于 API 级别 24 |
| half4 fabs(half4 v); | 添加于 API 级别 24 |
返回浮点数 v 的绝对值。
对于整数,请使用 abs()。
fdim : 两个值的正差
| float fdim(float a, float b); | |
| float2 fdim(float2 a, float2 b); | |
| float3 fdim(float3 a, float3 b); | |
| float4 fdim(float4 a, float4 b); | |
| half fdim(half a, half b); | 添加于 API 级别 24 |
| half2 fdim(half2 a, half2 b); | 添加于 API 级别 24 |
| half3 fdim(half3 a, half3 b); | 添加于 API 级别 24 |
| half4 fdim(half4 a, half4 b); | 添加于 API 级别 24 |
返回两个值的正差。
如果 a > b,返回 (a - b),否则返回 0f。
floor : 不大于给定值的最小整数
fma : 乘加
| float fma(float multiplicand1, float multiplicand2, float offset); | |
| float2 fma(float2 multiplicand1, float2 multiplicand2, float2 offset); | |
| float3 fma(float3 multiplicand1, float3 multiplicand2, float3 offset); | |
| float4 fma(float4 multiplicand1, float4 multiplicand2, float4 offset); | |
| half fma(half multiplicand1, half multiplicand2, half offset); | 添加于 API 级别 24 |
| half2 fma(half2 multiplicand1, half2 multiplicand2, half2 offset); | 添加于 API 级别 24 |
| half3 fma(half3 multiplicand1, half3 multiplicand2, half3 offset); | 添加于 API 级别 24 |
| half4 fma(half4 multiplicand1, half4 multiplicand2, half4 offset); | 添加于 API 级别 24 |
fmax : 两个浮点数的最大值
| float fmax(float a, float b); | |
| float2 fmax(float2 a, float b); | |
| float2 fmax(float2 a, float2 b); | |
| float3 fmax(float3 a, float b); | |
| float3 fmax(float3 a, float3 b); | |
| float4 fmax(float4 a, float b); | |
| float4 fmax(float4 a, float4 b); | |
| half fmax(half a, half b); | 添加于 API 级别 24 |
| half2 fmax(half2 a, half b); | 添加于 API 级别 24 |
| half2 fmax(half2 a, half2 b); | 添加于 API 级别 24 |
| half3 fmax(half3 a, half b); | 添加于 API 级别 24 |
| half3 fmax(half3 a, half3 b); | 添加于 API 级别 24 |
| half4 fmax(half4 a, half b); | 添加于 API 级别 24 |
| half4 fmax(half4 a, half4 b); | 添加于 API 级别 24 |
返回 a 和 b 中的最大值,即 (a < b ? b : a)。
max() 函数返回相同的结果,但可应用于更多数据类型。
fmin : 两个浮点数的最小值
| float fmin(float a, float b); | |
| float2 fmin(float2 a, float b); | |
| float2 fmin(float2 a, float2 b); | |
| float3 fmin(float3 a, float b); | |
| float3 fmin(float3 a, float3 b); | |
| float4 fmin(float4 a, float b); | |
| float4 fmin(float4 a, float4 b); | |
| half fmin(half a, half b); | 添加于 API 级别 24 |
| half2 fmin(half2 a, half b); | 添加于 API 级别 24 |
| half2 fmin(half2 a, half2 b); | 添加于 API 级别 24 |
| half3 fmin(half3 a, half b); | 添加于 API 级别 24 |
| half3 fmin(half3 a, half3 b); | 添加于 API 级别 24 |
| half4 fmin(half4 a, half b); | 添加于 API 级别 24 |
| half4 fmin(half4 a, half4 b); | 添加于 API 级别 24 |
返回 a 和 b 中的最小值,即 (a > b ? b : a)。
min() 函数返回相同的结果,但可应用于更多数据类型。
fmod : 模
| float fmod(float numerator, float denominator); | |
| float2 fmod(float2 numerator, float2 denominator); | |
| float3 fmod(float3 numerator, float3 denominator); | |
| float4 fmod(float4 numerator, float4 denominator); | |
| half fmod(half numerator, half denominator); | 添加于 API 级别 24 |
| half2 fmod(half2 numerator, half2 denominator); | 添加于 API 级别 24 |
| half3 fmod(half3 numerator, half3 denominator); | 添加于 API 级别 24 |
| half4 fmod(half4 numerator, half4 denominator); | 添加于 API 级别 24 |
fract : 正小数部分
| float fract(float v); | |
| float fract(float v, float* floor); | |
| float2 fract(float2 v); | |
| float2 fract(float2 v, float2* floor); | |
| float3 fract(float3 v); | |
| float3 fract(float3 v, float3* floor); | |
| float4 fract(float4 v); | |
| float4 fract(float4 v, float4* floor); | |
| half fract(half v); | 添加于 API 级别 24 |
| half fract(half v, half* floor); | 添加于 API 级别 24 |
| half2 fract(half2 v); | 添加于 API 级别 24 |
| half2 fract(half2 v, half2* floor); | 添加于 API 级别 24 |
| half3 fract(half3 v); | 添加于 API 级别 24 |
| half3 fract(half3 v, half3* floor); | 添加于 API 级别 24 |
| half4 fract(half4 v); | 添加于 API 级别 24 |
| half4 fract(half4 v, half4* floor); | 添加于 API 级别 24 |
参数
| v | 输入值。 |
|---|---|
| floor | 如果 floor 不为空,则 *floor 将设置为 v 的向下取整值。 |
返回 v 的正小数部分,即 v - floor(v)。
例如,fract(1.3f, &val) 返回 0.3f 并将 val 设置为 1.f。fract(-1.3f, &val) 返回 0.7f 并将 val 设置为 -2.f。
frexp : 二进制尾数和指数
| float frexp(float v, int* exponent); | |
| float2 frexp(float2 v, int2* exponent); | |
| float3 frexp(float3 v, int3* exponent); | |
| float4 frexp(float4 v, int4* exponent); | |
| half frexp(half v, int* exponent); | 添加于 API 级别 24 |
| half2 frexp(half2 v, int2* exponent); | 添加于 API 级别 24 |
| half3 frexp(half3 v, int3* exponent); | 添加于 API 级别 24 |
| half4 frexp(half4 v, int4* exponent); | 添加于 API 级别 24 |
参数
| v | 输入值。 |
|---|---|
| exponent | 如果 exponent 不为空,则 *exponent 将设置为 v 的指数。 |
half_recip : 计算到 16 位精度的倒数
| float half_recip(float v); | 添加于 API level 17 |
| float2 half_recip(float2 v); | 添加于 API level 17 |
| float3 half_recip(float3 v); | 添加于 API level 17 |
| float4 half_recip(float4 v); | 添加于 API level 17 |
half_rsqrt : 计算到 16 位精度的平方根的倒数
| float half_rsqrt(float v); | 添加于 API level 17 |
| float2 half_rsqrt(float2 v); | 添加于 API level 17 |
| float3 half_rsqrt(float3 v); | 添加于 API level 17 |
| float4 half_rsqrt(float4 v); | 添加于 API level 17 |
half_sqrt : 计算到 16 位精度的平方根
| float half_sqrt(float v); | 添加于 API level 17 |
| float2 half_sqrt(float2 v); | 添加于 API level 17 |
| float3 half_sqrt(float3 v); | 添加于 API level 17 |
| float4 half_sqrt(float4 v); | 添加于 API level 17 |
hypot : 斜边
| float hypot(float a, float b); | |
| float2 hypot(float2 a, float2 b); | |
| float3 hypot(float3 a, float3 b); | |
| float4 hypot(float4 a, float4 b); | |
| half hypot(half a, half b); | 添加于 API 级别 24 |
| half2 hypot(half2 a, half2 b); | 添加于 API 级别 24 |
| half3 hypot(half3 a, half3 b); | 添加于 API 级别 24 |
| half4 hypot(half4 a, half4 b); | 添加于 API 级别 24 |
返回斜边,即 sqrt(a * a + b * b)。
另请参阅 native_hypot()。
ilogb : 以 2 为底的指数
ldexp : 从尾数和指数创建浮点数
| float ldexp(float mantissa, int exponent); | |
| float2 ldexp(float2 mantissa, int exponent); | |
| float2 ldexp(float2 mantissa, int2 exponent); | |
| float3 ldexp(float3 mantissa, int exponent); | |
| float3 ldexp(float3 mantissa, int3 exponent); | |
| float4 ldexp(float4 mantissa, int exponent); | |
| float4 ldexp(float4 mantissa, int4 exponent); | |
| half ldexp(half mantissa, int exponent); | 添加于 API 级别 24 |
| half2 ldexp(half2 mantissa, int exponent); | 添加于 API 级别 24 |
| half2 ldexp(half2 mantissa, int2 exponent); | 添加于 API 级别 24 |
| half3 ldexp(half3 mantissa, int exponent); | 添加于 API 级别 24 |
| half3 ldexp(half3 mantissa, int3 exponent); | 添加于 API 级别 24 |
| half4 ldexp(half4 mantissa, int exponent); | 添加于 API 级别 24 |
| half4 ldexp(half4 mantissa, int4 exponent); | 添加于 API 级别 24 |
参数
| mantissa | 尾数。 |
|---|---|
| exponent | 指数,单个分量或匹配向量。 |
返回由尾数和指数创建的浮点数,即 (mantissa * 2 ^ exponent)。
有关逆运算,请参阅 frexp()。
lgamma : Gamma 函数的自然对数
| float lgamma(float v); | |
| float lgamma(float v, int* sign_of_gamma); | |
| float2 lgamma(float2 v); | |
| float2 lgamma(float2 v, int2* sign_of_gamma); | |
| float3 lgamma(float3 v); | |
| float3 lgamma(float3 v, int3* sign_of_gamma); | |
| float4 lgamma(float4 v); | |
| float4 lgamma(float4 v, int4* sign_of_gamma); | |
| half lgamma(half v); | 添加于 API 级别 24 |
| half lgamma(half v, int* sign_of_gamma); | 添加于 API 级别 24 |
| half2 lgamma(half2 v); | 添加于 API 级别 24 |
| half2 lgamma(half2 v, int2* sign_of_gamma); | 添加于 API 级别 24 |
| half3 lgamma(half3 v); | 添加于 API 级别 24 |
| half3 lgamma(half3 v, int3* sign_of_gamma); | 添加于 API 级别 24 |
| half4 lgamma(half4 v); | 添加于 API 级别 24 |
| half4 lgamma(half4 v, int4* sign_of_gamma); | 添加于 API 级别 24 |
参数
| v | |
|---|---|
| sign_of_gamma | 如果 sign_of_gamma 不为空,则如果 v 的 Gamma 值为负,*sign_of_gamma 将设置为 -1.f,否则设置为 1.f。 |
log : 自然对数
| float log(float v); | |
| float2 log(float2 v); | |
| float3 log(float3 v); | |
| float4 log(float4 v); | |
| half log(half v); | 添加于 API 级别 24 |
| half2 log(half2 v); | 添加于 API 级别 24 |
| half3 log(half3 v); | 添加于 API 级别 24 |
| half4 log(half4 v); | 添加于 API 级别 24 |
返回自然对数。
另请参阅 native_log()。
log10 : 以 10 为底的对数
| float log10(float v); | |
| float2 log10(float2 v); | |
| float3 log10(float3 v); | |
| float4 log10(float4 v); | |
| half log10(half v); | 添加于 API 级别 24 |
| half2 log10(half2 v); | 添加于 API 级别 24 |
| half3 log10(half3 v); | 添加于 API 级别 24 |
| half4 log10(half4 v); | 添加于 API 级别 24 |
返回以 10 为底的对数。
另请参阅 native_log10()。
log1p : 值加 1 的自然对数
| float log1p(float v); | |
| float2 log1p(float2 v); | |
| float3 log1p(float3 v); | |
| float4 log1p(float4 v); | |
| half log1p(half v); | 添加于 API 级别 24 |
| half2 log1p(half2 v); | 添加于 API 级别 24 |
| half3 log1p(half3 v); | 添加于 API 级别 24 |
| half4 log1p(half4 v); | 添加于 API 级别 24 |
返回 (v + 1.f) 的自然对数。
另请参阅 native_log1p()。
log2 : 以 2 为底的对数
| float log2(float v); | |
| float2 log2(float2 v); | |
| float3 log2(float3 v); | |
| float4 log2(float4 v); | |
| half log2(half v); | 添加于 API 级别 24 |
| half2 log2(half2 v); | 添加于 API 级别 24 |
| half3 log2(half3 v); | 添加于 API 级别 24 |
| half4 log2(half4 v); | 添加于 API 级别 24 |
返回以 2 为底的对数。
另请参阅 native_log2()。
logb : 以 2 为底的指数
| float logb(float v); | |
| float2 logb(float2 v); | |
| float3 logb(float3 v); | |
| float4 logb(float4 v); | |
| half logb(half v); | 添加于 API 级别 24 |
| half2 logb(half2 v); | 添加于 API 级别 24 |
| half3 logb(half3 v); | 添加于 API 级别 24 |
| half4 logb(half4 v); | 添加于 API 级别 24 |
返回值的以 2 为底的指数,其中尾数在 1.f(包含)和 2.f(不包含)之间。
例如,logb(8.5f) 返回 3.f。
由于尾数的差异,此数字比 frexp() 返回的数字小 1。
ilogb() 类似,但返回一个整数。
mad : 乘加
| float mad(float multiplicand1, float multiplicand2, float offset); | |
| float2 mad(float2 multiplicand1, float2 multiplicand2, float2 offset); | |
| float3 mad(float3 multiplicand1, float3 multiplicand2, float3 offset); | |
| float4 mad(float4 multiplicand1, float4 multiplicand2, float4 offset); | |
| half mad(half multiplicand1, half multiplicand2, half offset); | 添加于 API 级别 24 |
| half2 mad(half2 multiplicand1, half2 multiplicand2, half2 offset); | 添加于 API 级别 24 |
| half3 mad(half3 multiplicand1, half3 multiplicand2, half3 offset); | 添加于 API 级别 24 |
| half4 mad(half4 multiplicand1, half4 multiplicand2, half4 offset); | 添加于 API 级别 24 |
max : 最大值
返回两个参数的最大值。
min : 最小值
返回两个参数的最小值。
mix : 混合两个值
| float mix(float start, float stop, float fraction); | |
| float2 mix(float2 start, float2 stop, float fraction); | |
| float2 mix(float2 start, float2 stop, float2 fraction); | |
| float3 mix(float3 start, float3 stop, float fraction); | |
| float3 mix(float3 start, float3 stop, float3 fraction); | |
| float4 mix(float4 start, float4 stop, float fraction); | |
| float4 mix(float4 start, float4 stop, float4 fraction); | |
| half mix(half start, half stop, half fraction); | 添加于 API 级别 24 |
| half2 mix(half2 start, half2 stop, half fraction); | 添加于 API 级别 24 |
| half2 mix(half2 start, half2 stop, half2 fraction); | 添加于 API 级别 24 |
| half3 mix(half3 start, half3 stop, half fraction); | 添加于 API 级别 24 |
| half3 mix(half3 start, half3 stop, half3 fraction); | 添加于 API 级别 24 |
| half4 mix(half4 start, half4 stop, half fraction); | 添加于 API 级别 24 |
| half4 mix(half4 start, half4 stop, half4 fraction); | 添加于 API 级别 24 |
返回 start + ((stop - start) * fraction)。
这对于混合两个值很有用。例如,要创建一个新颜色,其中 40% 来自 color1,60% 来自 color2,请使用 mix(color1, color2, 0.6f)。
modf : 整数部分和小数部分
| float modf(float v, float* integral_part); | |
| float2 modf(float2 v, float2* integral_part); | |
| float3 modf(float3 v, float3* integral_part); | |
| float4 modf(float4 v, float4* integral_part); | |
| half modf(half v, half* integral_part); | 添加于 API 级别 24 |
| half2 modf(half2 v, half2* integral_part); | 添加于 API 级别 24 |
| half3 modf(half3 v, half3* integral_part); | 添加于 API 级别 24 |
| half4 modf(half4 v, half4* integral_part); | 添加于 API 级别 24 |
参数
| v | 源值。 |
|---|---|
| integral_part | *integral_part 将设置为数字的整数部分。 |
返回
| 值的小数部分。 |
返回数字的整数部分和小数部分。
两个分量都将与 x 具有相同的符号。例如,对于输入 -3.72f,*integral_part 将设置为 -3.f,并返回 .72f。
native_acos : 近似反余弦
| float native_acos(float v); | 添加于 API level 21 |
| float2 native_acos(float2 v); | 添加于 API level 21 |
| float3 native_acos(float3 v); | 添加于 API level 21 |
| float4 native_acos(float4 v); | 添加于 API level 21 |
| half native_acos(half v); | 添加于 API 级别 24 |
| half2 native_acos(half2 v); | 添加于 API 级别 24 |
| half3 native_acos(half3 v); | 添加于 API 级别 24 |
| half4 native_acos(half4 v); | 添加于 API 级别 24 |
native_acosh : 近似反双曲余弦
| float native_acosh(float v); | 添加于 API level 21 |
| float2 native_acosh(float2 v); | 添加于 API level 21 |
| float3 native_acosh(float3 v); | 添加于 API level 21 |
| float4 native_acosh(float4 v); | 添加于 API level 21 |
| half native_acosh(half v); | 添加于 API 级别 24 |
| half2 native_acosh(half2 v); | 添加于 API 级别 24 |
| half3 native_acosh(half3 v); | 添加于 API 级别 24 |
| half4 native_acosh(half4 v); | 添加于 API 级别 24 |
返回近似反双曲余弦(以弧度为单位)。
另请参阅 acosh()。
native_acospi : 近似反余弦除以 pi
| float native_acospi(float v); | 添加于 API level 21 |
| float2 native_acospi(float2 v); | 添加于 API level 21 |
| float3 native_acospi(float3 v); | 添加于 API level 21 |
| float4 native_acospi(float4 v); | 添加于 API level 21 |
| half native_acospi(half v); | 添加于 API 级别 24 |
| half2 native_acospi(half2 v); | 添加于 API 级别 24 |
| half3 native_acospi(half3 v); | 添加于 API 级别 24 |
| half4 native_acospi(half4 v); | 添加于 API 级别 24 |
返回近似反余弦(以弧度为单位),再除以 pi。
要获取以度为单位的反余弦,请使用 acospi(a) * 180.f。
输入值小于 -1 或大于 1 时,此函数的返回结果不确定。
另请参阅 acospi()。
native_asin : 近似反正弦
| float native_asin(float v); | 添加于 API level 21 |
| float2 native_asin(float2 v); | 添加于 API level 21 |
| float3 native_asin(float3 v); | 添加于 API level 21 |
| float4 native_asin(float4 v); | 添加于 API level 21 |
| half native_asin(half v); | 添加于 API 级别 24 |
| half2 native_asin(half2 v); | 添加于 API 级别 24 |
| half3 native_asin(half3 v); | 添加于 API 级别 24 |
| half4 native_asin(half4 v); | 添加于 API 级别 24 |
native_asinh : 近似反双曲正弦
| float native_asinh(float v); | 添加于 API level 21 |
| float2 native_asinh(float2 v); | 添加于 API level 21 |
| float3 native_asinh(float3 v); | 添加于 API level 21 |
| float4 native_asinh(float4 v); | 添加于 API level 21 |
| half native_asinh(half v); | 添加于 API 级别 24 |
| half2 native_asinh(half2 v); | 添加于 API 级别 24 |
| half3 native_asinh(half3 v); | 添加于 API 级别 24 |
| half4 native_asinh(half4 v); | 添加于 API 级别 24 |
返回近似反双曲正弦(以弧度为单位)。
另请参阅 asinh()。
native_asinpi : 近似反正弦除以 pi
| float native_asinpi(float v); | 添加于 API level 21 |
| float2 native_asinpi(float2 v); | 添加于 API level 21 |
| float3 native_asinpi(float3 v); | 添加于 API level 21 |
| float4 native_asinpi(float4 v); | 添加于 API level 21 |
| half native_asinpi(half v); | 添加于 API 级别 24 |
| half2 native_asinpi(half2 v); | 添加于 API 级别 24 |
| half3 native_asinpi(half3 v); | 添加于 API 级别 24 |
| half4 native_asinpi(half4 v); | 添加于 API 级别 24 |
返回近似反正弦(以弧度为单位),再除以 pi。
要获取以度为单位的反正弦,请使用 asinpi(a) * 180.f。
输入值小于 -1 或大于 1 时,此函数的返回结果不确定。
另请参阅 asinpi()。
native_atan : 近似反正切
| float native_atan(float v); | 添加于 API level 21 |
| float2 native_atan(float2 v); | 添加于 API level 21 |
| float3 native_atan(float3 v); | 添加于 API level 21 |
| float4 native_atan(float4 v); | 添加于 API level 21 |
| half native_atan(half v); | 添加于 API 级别 24 |
| half2 native_atan(half2 v); | 添加于 API 级别 24 |
| half3 native_atan(half3 v); | 添加于 API 级别 24 |
| half4 native_atan(half4 v); | 添加于 API 级别 24 |
返回近似反正切(以弧度为单位)。
另请参阅 atan()。
native_atan2 : 近似比率反正切
| float native_atan2(float numerator, float denominator); | 添加于 API level 21 |
| float2 native_atan2(float2 numerator, float2 denominator); | 添加于 API level 21 |
| float3 native_atan2(float3 numerator, float3 denominator); | 添加于 API level 21 |
| float4 native_atan2(float4 numerator, float4 denominator); | 添加于 API level 21 |
| half native_atan2(half numerator, half denominator); | 添加于 API 级别 24 |
| half2 native_atan2(half2 numerator, half2 denominator); | 添加于 API 级别 24 |
| half3 native_atan2(half3 numerator, half3 denominator); | 添加于 API 级别 24 |
| half4 native_atan2(half4 numerator, half4 denominator); | 添加于 API 级别 24 |
参数
| numerator | 分子。 |
|---|---|
| denominator | 分母。可以为 0。 |
返回 (numerator / denominator) 的近似反正切,以弧度表示。
另请参阅 atan2()。
native_atan2pi : 比率的近似反正切,除以 pi
| float native_atan2pi(float numerator, float denominator); | 添加于 API level 21 |
| float2 native_atan2pi(float2 numerator, float2 denominator); | 添加于 API level 21 |
| float3 native_atan2pi(float3 numerator, float3 denominator); | 添加于 API level 21 |
| float4 native_atan2pi(float4 numerator, float4 denominator); | 添加于 API level 21 |
| half native_atan2pi(half numerator, half denominator); | 添加于 API 级别 24 |
| half2 native_atan2pi(half2 numerator, half2 denominator); | 添加于 API 级别 24 |
| half3 native_atan2pi(half3 numerator, half3 denominator); | 添加于 API 级别 24 |
| half4 native_atan2pi(half4 numerator, half4 denominator); | 添加于 API 级别 24 |
参数
| numerator | 分子。 |
|---|---|
| denominator | 分母。可以为 0。 |
返回 (numerator / denominator) 的近似反正切,以弧度表示,并除以 pi。
要获取以度为单位的反正切,请使用 atan2pi(n, d) * 180.f。
另请参阅 atan2pi()。
native_atanh : 近似反双曲正切
| float native_atanh(float v); | 添加于 API level 21 |
| float2 native_atanh(float2 v); | 添加于 API level 21 |
| float3 native_atanh(float3 v); | 添加于 API level 21 |
| float4 native_atanh(float4 v); | 添加于 API level 21 |
| half native_atanh(half v); | 添加于 API 级别 24 |
| half2 native_atanh(half2 v); | 添加于 API 级别 24 |
| half3 native_atanh(half3 v); | 添加于 API 级别 24 |
| half4 native_atanh(half4 v); | 添加于 API 级别 24 |
返回近似反双曲正切,以弧度表示。
另请参阅 atanh()。
native_atanpi : 近似反正切除以 pi
| float native_atanpi(float v); | 添加于 API level 21 |
| float2 native_atanpi(float2 v); | 添加于 API level 21 |
| float3 native_atanpi(float3 v); | 添加于 API level 21 |
| float4 native_atanpi(float4 v); | 添加于 API level 21 |
| half native_atanpi(half v); | 添加于 API 级别 24 |
| half2 native_atanpi(half2 v); | 添加于 API 级别 24 |
| half3 native_atanpi(half3 v); | 添加于 API 级别 24 |
| half4 native_atanpi(half4 v); | 添加于 API 级别 24 |
native_cbrt : 近似立方根
| float native_cbrt(float v); | 添加于 API level 21 |
| float2 native_cbrt(float2 v); | 添加于 API level 21 |
| float3 native_cbrt(float3 v); | 添加于 API level 21 |
| float4 native_cbrt(float4 v); | 添加于 API level 21 |
| half native_cbrt(half v); | 添加于 API 级别 24 |
| half2 native_cbrt(half2 v); | 添加于 API 级别 24 |
| half3 native_cbrt(half3 v); | 添加于 API 级别 24 |
| half4 native_cbrt(half4 v); | 添加于 API 级别 24 |
返回近似立方根。
另请参阅 cbrt()。
native_cos : 近似余弦
| float native_cos(float v); | 添加于 API level 21 |
| float2 native_cos(float2 v); | 添加于 API level 21 |
| float3 native_cos(float3 v); | 添加于 API level 21 |
| float4 native_cos(float4 v); | 添加于 API level 21 |
| half native_cos(half v); | 添加于 API 级别 24 |
| half2 native_cos(half2 v); | 添加于 API 级别 24 |
| half3 native_cos(half3 v); | 添加于 API 级别 24 |
| half4 native_cos(half4 v); | 添加于 API 级别 24 |
返回以弧度为单位的角度的近似余弦。
另请参阅 cos()。
native_cosh : 近似双曲余弦
| float native_cosh(float v); | 添加于 API level 21 |
| float2 native_cosh(float2 v); | 添加于 API level 21 |
| float3 native_cosh(float3 v); | 添加于 API level 21 |
| float4 native_cosh(float4 v); | 添加于 API level 21 |
| half native_cosh(half v); | 添加于 API 级别 24 |
| half2 native_cosh(half2 v); | 添加于 API 级别 24 |
| half3 native_cosh(half3 v); | 添加于 API 级别 24 |
| half4 native_cosh(half4 v); | 添加于 API 级别 24 |
返回近似双曲余弦。
另请参阅 cosh()。
native_cospi : 数字乘以 pi 的近似余弦
| float native_cospi(float v); | 添加于 API level 21 |
| float2 native_cospi(float2 v); | 添加于 API level 21 |
| float3 native_cospi(float3 v); | 添加于 API level 21 |
| float4 native_cospi(float4 v); | 添加于 API level 21 |
| half native_cospi(half v); | 添加于 API 级别 24 |
| half2 native_cospi(half2 v); | 添加于 API 级别 24 |
| half3 native_cospi(half3 v); | 添加于 API 级别 24 |
| half4 native_cospi(half4 v); | 添加于 API 级别 24 |
native_divide : 近似除法
| float native_divide(float left_vector, float right_vector); | 添加于 API level 21 |
| float2 native_divide(float2 left_vector, float2 right_vector); | 添加于 API level 21 |
| float3 native_divide(float3 left_vector, float3 right_vector); | 添加于 API level 21 |
| float4 native_divide(float4 left_vector, float4 right_vector); | 添加于 API level 21 |
| half native_divide(half left_vector, half right_vector); | 添加于 API 级别 24 |
| half2 native_divide(half2 left_vector, half2 right_vector); | 添加于 API 级别 24 |
| half3 native_divide(half3 left_vector, half3 right_vector); | 添加于 API 级别 24 |
| half4 native_divide(half4 left_vector, half4 right_vector); | 添加于 API 级别 24 |
计算两个值的近似除法。
native_exp : 近似 e 的幂
| float native_exp(float v); | 添加自 API 级别 18 |
| float2 native_exp(float2 v); | 添加自 API 级别 18 |
| float3 native_exp(float3 v); | 添加自 API 级别 18 |
| float4 native_exp(float4 v); | 添加自 API 级别 18 |
| half native_exp(half v); | 添加于 API 级别 24 |
| half2 native_exp(half2 v); | 添加于 API 级别 24 |
| half3 native_exp(half3 v); | 添加于 API 级别 24 |
| half4 native_exp(half4 v); | 添加于 API 级别 24 |
native_exp10 : 近似 10 的幂
| float native_exp10(float v); | 添加自 API 级别 18 |
| float2 native_exp10(float2 v); | 添加自 API 级别 18 |
| float3 native_exp10(float3 v); | 添加自 API 级别 18 |
| float4 native_exp10(float4 v); | 添加自 API 级别 18 |
| half native_exp10(half v); | 添加于 API 级别 24 |
| half2 native_exp10(half2 v); | 添加于 API 级别 24 |
| half3 native_exp10(half3 v); | 添加于 API 级别 24 |
| half4 native_exp10(half4 v); | 添加于 API 级别 24 |
native_exp2 : 近似 2 的幂
| float native_exp2(float v); | 添加自 API 级别 18 |
| float2 native_exp2(float2 v); | 添加自 API 级别 18 |
| float3 native_exp2(float3 v); | 添加自 API 级别 18 |
| float4 native_exp2(float4 v); | 添加自 API 级别 18 |
| half native_exp2(half v); | 添加于 API 级别 24 |
| half2 native_exp2(half2 v); | 添加于 API 级别 24 |
| half3 native_exp2(half3 v); | 添加于 API 级别 24 |
| half4 native_exp2(half4 v); | 添加于 API 级别 24 |
native_expm1 : 近似 e 的幂减去一
| float native_expm1(float v); | 添加于 API level 21 |
| float2 native_expm1(float2 v); | 添加于 API level 21 |
| float3 native_expm1(float3 v); | 添加于 API level 21 |
| float4 native_expm1(float4 v); | 添加于 API level 21 |
| half native_expm1(half v); | 添加于 API 级别 24 |
| half2 native_expm1(half2 v); | 添加于 API 级别 24 |
| half3 native_expm1(half3 v); | 添加于 API 级别 24 |
| half4 native_expm1(half4 v); | 添加于 API 级别 24 |
返回近似的 (e ^ v) - 1。
另请参阅 expm1()。
native_hypot : 近似斜边
| float native_hypot(float a, float b); | 添加于 API level 21 |
| float2 native_hypot(float2 a, float2 b); | 添加于 API level 21 |
| float3 native_hypot(float3 a, float3 b); | 添加于 API level 21 |
| float4 native_hypot(float4 a, float4 b); | 添加于 API level 21 |
| half native_hypot(half a, half b); | 添加于 API 级别 24 |
| half2 native_hypot(half2 a, half2 b); | 添加于 API 级别 24 |
| half3 native_hypot(half3 a, half3 b); | 添加于 API 级别 24 |
| half4 native_hypot(half4 a, half4 b); | 添加于 API 级别 24 |
返回近似的 native_sqrt(a * a + b * b)
另请参阅 hypot()。
native_log : 近似自然对数
| float native_log(float v); | 添加自 API 级别 18 |
| float2 native_log(float2 v); | 添加自 API 级别 18 |
| float3 native_log(float3 v); | 添加自 API 级别 18 |
| float4 native_log(float4 v); | 添加自 API 级别 18 |
| half native_log(half v); | 添加于 API 级别 24 |
| half2 native_log(half2 v); | 添加于 API 级别 24 |
| half3 native_log(half3 v); | 添加于 API 级别 24 |
| half4 native_log(half4 v); | 添加于 API 级别 24 |
native_log10 : 近似以 10 为底的对数
| float native_log10(float v); | 添加自 API 级别 18 |
| float2 native_log10(float2 v); | 添加自 API 级别 18 |
| float3 native_log10(float3 v); | 添加自 API 级别 18 |
| float4 native_log10(float4 v); | 添加自 API 级别 18 |
| half native_log10(half v); | 添加于 API 级别 24 |
| half2 native_log10(half2 v); | 添加于 API 级别 24 |
| half3 native_log10(half3 v); | 添加于 API 级别 24 |
| half4 native_log10(half4 v); | 添加于 API 级别 24 |
native_log1p : 某个值加 1 的近似自然对数
| float native_log1p(float v); | 添加于 API level 21 |
| float2 native_log1p(float2 v); | 添加于 API level 21 |
| float3 native_log1p(float3 v); | 添加于 API level 21 |
| float4 native_log1p(float4 v); | 添加于 API level 21 |
| half native_log1p(half v); | 添加于 API 级别 24 |
| half2 native_log1p(half2 v); | 添加于 API 级别 24 |
| half3 native_log1p(half3 v); | 添加于 API 级别 24 |
| half4 native_log1p(half4 v); | 添加于 API 级别 24 |
返回近似的 (v + 1.0f) 的自然对数。
另请参阅 log1p()。
native_log2 : 近似以 2 为底的对数
| float native_log2(float v); | 添加自 API 级别 18 |
| float2 native_log2(float2 v); | 添加自 API 级别 18 |
| float3 native_log2(float3 v); | 添加自 API 级别 18 |
| float4 native_log2(float4 v); | 添加自 API 级别 18 |
| half native_log2(half v); | 添加于 API 级别 24 |
| half2 native_log2(half2 v); | 添加于 API 级别 24 |
| half3 native_log2(half3 v); | 添加于 API 级别 24 |
| half4 native_log2(half4 v); | 添加于 API 级别 24 |
native_powr : 正底数幂的近似值
| float native_powr(float base, float exponent); | 添加自 API 级别 18 |
| float2 native_powr(float2 base, float2 exponent); | 添加自 API 级别 18 |
| float3 native_powr(float3 base, float3 exponent); | 添加自 API 级别 18 |
| float4 native_powr(float4 base, float4 exponent); | 添加自 API 级别 18 |
| half native_powr(half base, half exponent); | 添加于 API 级别 24 |
| half2 native_powr(half2 base, half2 exponent); | 添加于 API 级别 24 |
| half3 native_powr(half3 base, half3 exponent); | 添加于 API 级别 24 |
| half4 native_powr(half4 base, half4 exponent); | 添加于 API 级别 24 |
参数
| base | 必须介于 0.f 和 256.f 之间。对于非常接近零的值,此函数不准确。 |
|---|---|
| exponent | 必须介于 -15.f 和 15.f 之间。 |
快速近似 (base ^ exponent)。
另请参阅 powr()。
native_recip : 近似倒数
| float native_recip(float v); | 添加于 API level 21 |
| float2 native_recip(float2 v); | 添加于 API level 21 |
| float3 native_recip(float3 v); | 添加于 API level 21 |
| float4 native_recip(float4 v); | 添加于 API level 21 |
| half native_recip(half v); | 添加于 API 级别 24 |
| half2 native_recip(half2 v); | 添加于 API 级别 24 |
| half3 native_recip(half3 v); | 添加于 API 级别 24 |
| half4 native_recip(half4 v); | 添加于 API 级别 24 |
返回某个值的近似倒数。
另请参阅 half_recip()。
native_rootn : 近似 nth 根
| float native_rootn(float v, int n); | 添加于 API level 21 |
| float2 native_rootn(float2 v, int2 n); | 添加于 API level 21 |
| float3 native_rootn(float3 v, int3 n); | 添加于 API level 21 |
| float4 native_rootn(float4 v, int4 n); | 添加于 API level 21 |
| half native_rootn(half v, int n); | 添加于 API 级别 24 |
| half2 native_rootn(half2 v, int2 n); | 添加于 API 级别 24 |
| half3 native_rootn(half3 v, int3 n); | 添加于 API 级别 24 |
| half4 native_rootn(half4 v, int4 n); | 添加于 API 级别 24 |
计算某个值的近似 Nth 根。
另请参阅 rootn()。
native_rsqrt : 近似平方根的倒数
| float native_rsqrt(float v); | 添加于 API level 21 |
| float2 native_rsqrt(float2 v); | 添加于 API level 21 |
| float3 native_rsqrt(float3 v); | 添加于 API level 21 |
| float4 native_rsqrt(float4 v); | 添加于 API level 21 |
| half native_rsqrt(half v); | 添加于 API 级别 24 |
| half2 native_rsqrt(half2 v); | 添加于 API 级别 24 |
| half3 native_rsqrt(half3 v); | 添加于 API 级别 24 |
| half4 native_rsqrt(half4 v); | 添加于 API 级别 24 |
返回近似 (1 / sqrt(v))。
另请参阅 rsqrt()、half_rsqrt()。
native_sin : 近似正弦
| float native_sin(float v); | 添加于 API level 21 |
| float2 native_sin(float2 v); | 添加于 API level 21 |
| float3 native_sin(float3 v); | 添加于 API level 21 |
| float4 native_sin(float4 v); | 添加于 API level 21 |
| half native_sin(half v); | 添加于 API 级别 24 |
| half2 native_sin(half2 v); | 添加于 API 级别 24 |
| half3 native_sin(half3 v); | 添加于 API 级别 24 |
| half4 native_sin(half4 v); | 添加于 API 级别 24 |
返回以弧度为单位的角度的近似正弦。
另请参阅 sin()。
native_sincos : 近似正弦和余弦
| float native_sincos(float v, float* cos); | 添加于 API level 21 |
| float2 native_sincos(float2 v, float2* cos); | 添加于 API level 21 |
| float3 native_sincos(float3 v, float3* cos); | 添加于 API level 21 |
| float4 native_sincos(float4 v, float4* cos); | 添加于 API level 21 |
| half native_sincos(half v, half* cos); | 添加于 API 级别 24 |
| half2 native_sincos(half2 v, half2* cos); | 添加于 API 级别 24 |
| half3 native_sincos(half3 v, half3* cos); | 添加于 API 级别 24 |
| half4 native_sincos(half4 v, half4* cos); | 添加于 API 级别 24 |
参数
| v | 传入值以弧度为单位。 |
|---|---|
| cos | *cos 将设置为余弦值。 |
返回
| 正弦。 |
返回值的近似正弦和余弦。
另请参阅 sincos()。
native_sinh : 近似双曲正弦
| float native_sinh(float v); | 添加于 API level 21 |
| float2 native_sinh(float2 v); | 添加于 API level 21 |
| float3 native_sinh(float3 v); | 添加于 API level 21 |
| float4 native_sinh(float4 v); | 添加于 API level 21 |
| half native_sinh(half v); | 添加于 API 级别 24 |
| half2 native_sinh(half2 v); | 添加于 API 级别 24 |
| half3 native_sinh(half3 v); | 添加于 API 级别 24 |
| half4 native_sinh(half4 v); | 添加于 API 级别 24 |
返回以弧度为单位指定的近似双曲正弦。
另请参阅 sinh()。
native_sinpi : 数字乘以 pi 的近似正弦
| float native_sinpi(float v); | 添加于 API level 21 |
| float2 native_sinpi(float2 v); | 添加于 API level 21 |
| float3 native_sinpi(float3 v); | 添加于 API level 21 |
| float4 native_sinpi(float4 v); | 添加于 API level 21 |
| half native_sinpi(half v); | 添加于 API 级别 24 |
| half2 native_sinpi(half2 v); | 添加于 API 级别 24 |
| half3 native_sinpi(half3 v); | 添加于 API 级别 24 |
| half4 native_sinpi(half4 v); | 添加于 API 级别 24 |
native_sqrt : 近似平方根
| float native_sqrt(float v); | 添加于 API level 21 |
| float2 native_sqrt(float2 v); | 添加于 API level 21 |
| float3 native_sqrt(float3 v); | 添加于 API level 21 |
| float4 native_sqrt(float4 v); | 添加于 API level 21 |
| half native_sqrt(half v); | 添加于 API 级别 24 |
| half2 native_sqrt(half2 v); | 添加于 API 级别 24 |
| half3 native_sqrt(half3 v); | 添加于 API 级别 24 |
| half4 native_sqrt(half4 v); | 添加于 API 级别 24 |
native_tan : 近似正切
| float native_tan(float v); | 添加于 API level 21 |
| float2 native_tan(float2 v); | 添加于 API level 21 |
| float3 native_tan(float3 v); | 添加于 API level 21 |
| float4 native_tan(float4 v); | 添加于 API level 21 |
| half native_tan(half v); | 添加于 API 级别 24 |
| half2 native_tan(half2 v); | 添加于 API 级别 24 |
| half3 native_tan(half3 v); | 添加于 API 级别 24 |
| half4 native_tan(half4 v); | 添加于 API 级别 24 |
返回以弧度为单位的角度的近似正切。
native_tanh : 近似双曲正切
| float native_tanh(float v); | 添加于 API level 21 |
| float2 native_tanh(float2 v); | 添加于 API level 21 |
| float3 native_tanh(float3 v); | 添加于 API level 21 |
| float4 native_tanh(float4 v); | 添加于 API level 21 |
| half native_tanh(half v); | 添加于 API 级别 24 |
| half2 native_tanh(half2 v); | 添加于 API 级别 24 |
| half3 native_tanh(half3 v); | 添加于 API 级别 24 |
| half4 native_tanh(half4 v); | 添加于 API 级别 24 |
返回值的近似双曲正切。
另请参阅 tanh()。
native_tanpi : 数字乘以 pi 的近似正切
| float native_tanpi(float v); | 添加于 API level 21 |
| float2 native_tanpi(float2 v); | 添加于 API level 21 |
| float3 native_tanpi(float3 v); | 添加于 API level 21 |
| float4 native_tanpi(float4 v); | 添加于 API level 21 |
| half native_tanpi(half v); | 添加于 API 级别 24 |
| half2 native_tanpi(half2 v); | 添加于 API 级别 24 |
| half3 native_tanpi(half3 v); | 添加于 API 级别 24 |
| half4 native_tanpi(half4 v); | 添加于 API 级别 24 |
nextafter : 下一个浮点数
| float nextafter(float v, float target); | |
| float2 nextafter(float2 v, float2 target); | |
| float3 nextafter(float3 v, float3 target); | |
| float4 nextafter(float4 v, float4 target); | |
| half nextafter(half v, half target); | 添加于 API 级别 24 |
| half2 nextafter(half2 v, half2 target); | 添加于 API 级别 24 |
| half3 nextafter(half3 v, half3 target); | 添加于 API 级别 24 |
| half4 nextafter(half4 v, half4 target); | 添加于 API 级别 24 |
返回从 v 到 target 方向上的下一个可表示浮点数。
在 rs_fp_relaxed 模式下,非规范化输入值可能不会产生下一个非规范化值,因为在 relaxed 模式下支持非规范化值是可选的。
pow : 底数幂
| float pow(float base, float exponent); | |
| float2 pow(float2 base, float2 exponent); | |
| float3 pow(float3 base, float3 exponent); | |
| float4 pow(float4 base, float4 exponent); | |
| half pow(half base, half exponent); | 添加于 API 级别 24 |
| half2 pow(half2 base, half2 exponent); | 添加于 API 级别 24 |
| half3 pow(half3 base, half3 exponent); | 添加于 API 级别 24 |
| half4 pow(half4 base, half4 exponent); | 添加于 API 级别 24 |
pown : 底数整数幂
| float pown(float base, int exponent); | |
| float2 pown(float2 base, int2 exponent); | |
| float3 pown(float3 base, int3 exponent); | |
| float4 pown(float4 base, int4 exponent); | |
| half pown(half base, int exponent); | 添加于 API 级别 24 |
| half2 pown(half2 base, int2 exponent); | 添加于 API 级别 24 |
| half3 pown(half3 base, int3 exponent); | 添加于 API 级别 24 |
| half4 pown(half4 base, int4 exponent); | 添加于 API 级别 24 |
powr : 正底数幂
| float powr(float base, float exponent); | |
| float2 powr(float2 base, float2 exponent); | |
| float3 powr(float3 base, float3 exponent); | |
| float4 powr(float4 base, float4 exponent); | |
| half powr(half base, half exponent); | 添加于 API 级别 24 |
| half2 powr(half2 base, half2 exponent); | 添加于 API 级别 24 |
| half3 powr(half3 base, half3 exponent); | 添加于 API 级别 24 |
| half4 powr(half4 base, half4 exponent); | 添加于 API 级别 24 |
返回底数的指数幂,即 base ^ exponent。base 必须 >= 0。
pow() 和 pown() 类似。它们都对底数不做任何假定。pow() 接受浮点指数,而 pown() 接受整数。
另请参阅 native_powr()。
radians : 将角度转换为弧度
| float radians(float v); | |
| float2 radians(float2 v); | |
| float3 radians(float3 v); | |
| float4 radians(float4 v); | |
| half radians(half v); | 添加于 API 级别 24 |
| half2 radians(half2 v); | 添加于 API 级别 24 |
| half3 radians(half3 v); | 添加于 API 级别 24 |
| half4 radians(half4 v); | 添加于 API 级别 24 |
将角度从度转换为弧度。
remainder : 除法的余数
| float remainder(float numerator, float denominator); | |
| float2 remainder(float2 numerator, float2 denominator); | |
| float3 remainder(float3 numerator, float3 denominator); | |
| float4 remainder(float4 numerator, float4 denominator); | |
| half remainder(half numerator, half denominator); | 添加于 API 级别 24 |
| half2 remainder(half2 numerator, half2 denominator); | 添加于 API 级别 24 |
| half3 remainder(half3 numerator, half3 denominator); | 添加于 API 级别 24 |
| half4 remainder(half4 numerator, half4 denominator); | 添加于 API 级别 24 |
remquo : 除法的余数和商
| float remquo(float numerator, float denominator, int* quotient); | |
| float2 remquo(float2 numerator, float2 denominator, int2* quotient); | |
| float3 remquo(float3 numerator, float3 denominator, int3* quotient); | |
| float4 remquo(float4 numerator, float4 denominator, int4* quotient); | |
| half remquo(half numerator, half denominator, int* quotient); | 添加于 API 级别 24 |
| half2 remquo(half2 numerator, half2 denominator, int2* quotient); | 添加于 API 级别 24 |
| half3 remquo(half3 numerator, half3 denominator, int3* quotient); | 添加于 API 级别 24 |
| half4 remquo(half4 numerator, half4 denominator, int4* quotient); | 添加于 API 级别 24 |
参数
| numerator | 分子。 |
|---|---|
| denominator | 分母。 |
| 商 | *quotient 将设置为整数商。 |
返回
| 余数,仅在低三位精确。 |
返回 (numerator / denominator) 的商和余数。
只保证商的符号和最低三位是准确的。
此函数对于实现周期函数非常有用。商的低三位表示象限,余数表示象限内的距离。例如,sin(x) 的实现可以调用 remquo(x, PI / 2.f, &quadrant) 将很大的 x 值减小到有限范围内的值。
示例:remquo(-23.5f, 8.f, ") 将 quot 的最低三位设置为 3,符号为负。它返回 0.5f。
rint : 舍入到偶数
rootn : N 次方根
| float rootn(float v, int n); | |
| float2 rootn(float2 v, int2 n); | |
| float3 rootn(float3 v, int3 n); | |
| float4 rootn(float4 v, int4 n); | |
| half rootn(half v, int n); | 添加于 API 级别 24 |
| half2 rootn(half2 v, int2 n); | 添加于 API 级别 24 |
| half3 rootn(half3 v, int3 n); | 添加于 API 级别 24 |
| half4 rootn(half4 v, int4 n); | 添加于 API 级别 24 |
计算某个值的 N 次方根。
另请参阅 native_rootn()。
round : 远离零舍入
rsClamp : 将值限制在某个范围内
| char rsClamp(char amount, char low, char high); | |
| int rsClamp(int amount, int low, int high); | |
| short rsClamp(short amount, short low, short high); | |
| uchar rsClamp(uchar amount, uchar low, uchar high); | |
| uint rsClamp(uint amount, uint low, uint high); | |
| ushort rsClamp(ushort amount, ushort low, ushort high); |
参数
| amount | 要限制的值。 |
|---|---|
| low | 下界。 |
| high | 上界。 |
已弃用。请改用 clamp()。
将值限制在 low 和 high 之间。
rsRand : 伪随机数
| float rsRand(float max_value); | |
| float rsRand(float min_value, float max_value); | |
| int rsRand(int max_value); | |
| int rsRand(int min_value, int max_value); |
返回介于 0(或 min_value)和 max_value 之间的随机值。
rsqrt : 平方根的倒数
| float rsqrt(float v); | |
| float2 rsqrt(float2 v); | |
| float3 rsqrt(float3 v); | |
| float4 rsqrt(float4 v); | |
| half rsqrt(half v); | 添加于 API 级别 24 |
| half2 rsqrt(half2 v); | 添加于 API 级别 24 |
| half3 rsqrt(half3 v); | 添加于 API 级别 24 |
| half4 rsqrt(half4 v); | 添加于 API 级别 24 |
返回 (1 / sqrt(v))。
另请参阅 half_rsqrt()、native_rsqrt()。
sign : 值的符号
| float sign(float v); | |
| float2 sign(float2 v); | |
| float3 sign(float3 v); | |
| float4 sign(float4 v); | |
| half sign(half v); | 添加于 API 级别 24 |
| half2 sign(half2 v); | 添加于 API 级别 24 |
| half3 sign(half3 v); | 添加于 API 级别 24 |
| half4 sign(half4 v); | 添加于 API 级别 24 |
返回值符号。
if (v < 0) return -1.f; else if (v > 0) return 1.f; else return 0.f;
sin : 正弦
| float sin(float v); | |
| float2 sin(float2 v); | |
| float3 sin(float3 v); | |
| float4 sin(float4 v); | |
| half sin(half v); | 添加于 API 级别 24 |
| half2 sin(half2 v); | 添加于 API 级别 24 |
| half3 sin(half3 v); | 添加于 API 级别 24 |
| half4 sin(half4 v); | 添加于 API 级别 24 |
返回以弧度为单位的角度的正弦。
另请参阅 native_sin()。
sincos : 正弦和余弦
| float sincos(float v, float* cos); | |
| float2 sincos(float2 v, float2* cos); | |
| float3 sincos(float3 v, float3* cos); | |
| float4 sincos(float4 v, float4* cos); | |
| half sincos(half v, half* cos); | 添加于 API 级别 24 |
| half2 sincos(half2 v, half2* cos); | 添加于 API 级别 24 |
| half3 sincos(half3 v, half3* cos); | 添加于 API 级别 24 |
| half4 sincos(half4 v, half4* cos); | 添加于 API 级别 24 |
参数
| v | 传入值以弧度为单位。 |
|---|---|
| cos | *cos 将设置为余弦值。 |
返回
| v 的正弦。 |
返回值的正弦和余弦。
另请参阅 native_sincos()。
sinh : 双曲正弦
| float sinh(float v); | |
| float2 sinh(float2 v); | |
| float3 sinh(float3 v); | |
| float4 sinh(float4 v); | |
| half sinh(half v); | 添加于 API 级别 24 |
| half2 sinh(half2 v); | 添加于 API 级别 24 |
| half3 sinh(half3 v); | 添加于 API 级别 24 |
| half4 sinh(half4 v); | 添加于 API 级别 24 |
返回以弧度指定的 v 的双曲正弦。
另请参阅 native_sinh()。
sinpi : 数字乘以 pi 的正弦
sqrt : 平方根
| float sqrt(float v); | |
| float2 sqrt(float2 v); | |
| float3 sqrt(float3 v); | |
| float4 sqrt(float4 v); | |
| half sqrt(half v); | 添加于 API 级别 24 |
| half2 sqrt(half2 v); | 添加于 API 级别 24 |
| half3 sqrt(half3 v); | 添加于 API 级别 24 |
| half4 sqrt(half4 v); | 添加于 API 级别 24 |
返回值的平方根。
另请参阅 half_sqrt()、native_sqrt()。
step : 如果小于某个值,则为 0,否则为 1
| float step(float edge, float v); | |
| float2 step(float edge, float2 v); | 添加于 API level 21 |
| float2 step(float2 edge, float v); | |
| float2 step(float2 edge, float2 v); | |
| float3 step(float edge, float3 v); | 添加于 API level 21 |
| float3 step(float3 edge, float v); | |
| float3 step(float3 edge, float3 v); | |
| float4 step(float edge, float4 v); | 添加于 API level 21 |
| float4 step(float4 edge, float v); | |
| float4 step(float4 edge, float4 v); | |
| half step(half edge, half v); | 添加于 API 级别 24 |
| half2 step(half edge, half2 v); | 添加于 API 级别 24 |
| half2 step(half2 edge, half v); | 添加于 API 级别 24 |
| half2 step(half2 edge, half2 v); | 添加于 API 级别 24 |
| half3 step(half edge, half3 v); | 添加于 API 级别 24 |
| half3 step(half3 edge, half v); | 添加于 API 级别 24 |
| half3 step(half3 edge, half3 v); | 添加于 API 级别 24 |
| half4 step(half edge, half4 v); | 添加于 API 级别 24 |
| half4 step(half4 edge, half v); | 添加于 API 级别 24 |
| half4 step(half4 edge, half4 v); | 添加于 API 级别 24 |
tan : 正切
| float tan(float v); | |
| float2 tan(float2 v); | |
| float3 tan(float3 v); | |
| float4 tan(float4 v); | |
| half tan(half v); | 添加于 API 级别 24 |
| half2 tan(half2 v); | 添加于 API 级别 24 |
| half3 tan(half3 v); | 添加于 API 级别 24 |
| half4 tan(half4 v); | 添加于 API 级别 24 |
返回以弧度为单位的角度的正切值。
另请参阅 native_tan()。
tanh : 双曲正切
| float tanh(float v); | |
| float2 tanh(float2 v); | |
| float3 tanh(float3 v); | |
| float4 tanh(float4 v); | |
| half tanh(half v); | 添加于 API 级别 24 |
| half2 tanh(half2 v); | 添加于 API 级别 24 |
| half3 tanh(half3 v); | 添加于 API 级别 24 |
| half4 tanh(half4 v); | 添加于 API 级别 24 |
返回值的双曲正切值。
另请参阅 native_tanh()。
tanpi : 乘以 pi 的数的正切值
tgamma : Gamma 函数
| float tgamma(float v); | |
| float2 tgamma(float2 v); | |
| float3 tgamma(float3 v); | |
| float4 tgamma(float4 v); | |
| half tgamma(half v); | 添加于 API 级别 24 |
| half2 tgamma(half2 v); | 添加于 API 级别 24 |
| half3 tgamma(half3 v); | 添加于 API 级别 24 |
| half4 tgamma(half4 v); | 添加于 API 级别 24 |
返回值的 Gamma 函数值。
另请参阅 lgamma()。