概览
以下数学函数可以应用于标量和向量。当应用于向量时,返回的值是函数应用于输入的每个条目的向量。
例如:
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()。