RenderScript 数学常量和函数

概览

以下数学函数可以应用于标量和向量。当应用于向量时,返回的值是函数应用于输入的每个条目的向量。

例如:
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

float acospi(float v);
float2 acospi(float2 v);
float3 acospi(float3 v);
float4 acospi(float4 v);
half acospi(half v); 添加于 API 级别 24
half2 acospi(half2 v); 添加于 API 级别 24
half3 acospi(half3 v); 添加于 API 级别 24
half4 acospi(half4 v); 添加于 API 级别 24

返回以弧度为单位的反余弦,并除以 pi。

要获取以度为单位的反余弦,请使用 acospi(a) * 180.f

另请参阅 native_acospi()。

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

float asinpi(float v);
float2 asinpi(float2 v);
float3 asinpi(float3 v);
float4 asinpi(float4 v);
half asinpi(half v); 添加于 API 级别 24
half2 asinpi(half2 v); 添加于 API 级别 24
half3 asinpi(half3 v); 添加于 API 级别 24
half4 asinpi(half4 v); 添加于 API 级别 24

返回以弧度为单位的反正弦,并除以 pi。

要获取以度为单位的反正弦,请使用 asinpi(a) * 180.f

另请参阅 native_asinpi()。

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

float atanpi(float v);
float2 atanpi(float2 v);
float3 atanpi(float3 v);
float4 atanpi(float4 v);
half atanpi(half v); 添加于 API 级别 24
half2 atanpi(half2 v); 添加于 API 级别 24
half3 atanpi(half3 v); 添加于 API 级别 24
half4 atanpi(half4 v); 添加于 API 级别 24

返回以弧度为单位的反正切,并除以 pi。

要获取以度为单位的反正切,请使用 atanpi(a) * 180.f

另请参阅 native_atanpi()。

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 : 不小于给定值的最小整数

float ceil(float v);
float2 ceil(float2 v);
float3 ceil(float3 v);
float4 ceil(float4 v);
half ceil(half v); 添加于 API 级别 24
half2 ceil(half2 v); 添加于 API 级别 24
half3 ceil(half3 v); 添加于 API 级别 24
half4 ceil(half4 v); 添加于 API 级别 24

返回不小于给定值的最小整数。

例如,ceil(1.2f) 返回 2.f,而 ceil(-1.2f) 返回 -1.f。

另请参阅 floor()。

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 的余弦

float cospi(float v);
float2 cospi(float2 v);
float3 cospi(float3 v);
float4 cospi(float4 v);
half cospi(half v); 添加于 API 级别 24
half2 cospi(half2 v); 添加于 API 级别 24
half3 cospi(half3 v); 添加于 API 级别 24
half4 cospi(half4 v); 添加于 API 级别 24

返回 (v * pi) 的余弦,其中 (v * pi) 以弧度为单位。

要获取以度为单位的值的余弦,请调用 cospi(v / 180.f)

另请参阅 native_cospi()。

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 : 不大于给定值的最小整数

float floor(float v);
float2 floor(float2 v);
float3 floor(float3 v);
float4 floor(float4 v);
half floor(half v); 添加于 API 级别 24
half2 floor(half2 v); 添加于 API 级别 24
half3 floor(half3 v); 添加于 API 级别 24
half4 floor(half4 v); 添加于 API 级别 24

返回不大于给定值的最小整数。

例如,floor(1.2f) 返回 1.f,而 floor(-1.2f) 返回 -2.f。

另请参阅 ceil()。

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

乘加。返回 (multiplicand1 * multiplicand2) + offset

此函数类似于 mad()。fma() 保留乘法结果的完整精度,并且仅在加法后进行舍入。mad() 在乘法和加法后进行舍入。在 rs_fp_relaxed 模式下不保证这种额外精度。

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

返回 (numerator / denominator) 的余数,其中商向零舍入。

函数 remainder() 类似,但向最接近的整数舍入。例如,fmod(-3.8f, 2.f) 返回 -1.8f (-3.8f - -1.f * 2.f),而 remainder(-3.8f, 2.f) 返回 0.2f (-3.8f - -2.f * 2.f)。

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 的指数。

返回 v 的二进制尾数和指数,即 v == mantissa * 2 ^ exponent

尾数总是在 0.5(包含)和 1.0(不包含)之间。

有关逆运算,请参阅 ldexp()。另请参阅 logb() 和 ilogb()。

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

返回值的近似倒数。

精度为 16 位浮点值的精度。

另请参阅 native_recip()。

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

返回 (1.f / sqrt(value)) 的近似值。

精度为 16 位浮点值的精度。

另请参阅 rsqrt()、native_rsqrt()。

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

返回值的近似平方根。

精度为 16 位浮点值的精度。

另请参阅 sqrt()、native_sqrt()。

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 为底的指数

int ilogb(float v);
int ilogb(half v); 添加于 API 级别 24
int2 ilogb(float2 v);
int2 ilogb(half2 v); 添加于 API 级别 24
int3 ilogb(float3 v);
int3 ilogb(half3 v); 添加于 API 级别 24
int4 ilogb(float4 v);
int4 ilogb(half4 v); 添加于 API 级别 24

返回值的以 2 为底的指数,其中尾数在 1.f(包含)和 2.f(不包含)之间。

例如,ilogb(8.5f) 返回 3。

由于尾数的差异,此数字比 frexp() 返回的数字小 1。

logb() 类似,但返回一个浮点数。

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。

返回 Gamma 函数绝对值的自然对数,即 log(fabs(tgamma(v)))

另请参阅 tgamma()。

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

乘加。返回 (multiplicand1 * multiplicand2) + offset

此函数类似于 fma()。fma() 保留乘法结果的完整精度,并且仅在加法后进行舍入。mad() 在乘法和加法后进行舍入。在 rs_fp_relaxed 模式下,mad() 可能不会在乘法后进行舍入。

max : 最大值

char max(char a, char b);
char2 max(char2 a, char2 b);
char3 max(char3 a, char3 b);
char4 max(char4 a, char4 b);
float max(float a, float b);
float2 max(float2 a, float b);
float2 max(float2 a, float2 b);
float3 max(float3 a, float b);
float3 max(float3 a, float3 b);
float4 max(float4 a, float b);
float4 max(float4 a, float4 b);
half max(half a, half b); 添加于 API 级别 24
half2 max(half2 a, half b); 添加于 API 级别 24
half2 max(half2 a, half2 b); 添加于 API 级别 24
half3 max(half3 a, half b); 添加于 API 级别 24
half3 max(half3 a, half3 b); 添加于 API 级别 24
half4 max(half4 a, half b); 添加于 API 级别 24
half4 max(half4 a, half4 b); 添加于 API 级别 24
int max(int a, int b);
int2 max(int2 a, int2 b);
int3 max(int3 a, int3 b);
int4 max(int4 a, int4 b);
long max(long a, long b); 添加于 API level 21
long2 max(long2 a, long2 b); 添加于 API level 21
long3 max(long3 a, long3 b); 添加于 API level 21
long4 max(long4 a, long4 b); 添加于 API level 21
short max(short a, short b);
short2 max(short2 a, short2 b);
short3 max(short3 a, short3 b);
short4 max(short4 a, short4 b);
uchar max(uchar a, uchar b);
uchar2 max(uchar2 a, uchar2 b);
uchar3 max(uchar3 a, uchar3 b);
uchar4 max(uchar4 a, uchar4 b);
uint max(uint a, uint b);
uint2 max(uint2 a, uint2 b);
uint3 max(uint3 a, uint3 b);
uint4 max(uint4 a, uint4 b);
ulong max(ulong a, ulong b); 添加于 API level 21
ulong2 max(ulong2 a, ulong2 b); 添加于 API level 21
ulong3 max(ulong3 a, ulong3 b); 添加于 API level 21
ulong4 max(ulong4 a, ulong4 b); 添加于 API level 21
ushort max(ushort a, ushort b);
ushort2 max(ushort2 a, ushort2 b);
ushort3 max(ushort3 a, ushort3 b);
ushort4 max(ushort4 a, ushort4 b);

返回两个参数的最大值。

min : 最小值

char min(char a, char b);
char2 min(char2 a, char2 b);
char3 min(char3 a, char3 b);
char4 min(char4 a, char4 b);
float min(float a, float b);
float2 min(float2 a, float b);
float2 min(float2 a, float2 b);
float3 min(float3 a, float b);
float3 min(float3 a, float3 b);
float4 min(float4 a, float b);
float4 min(float4 a, float4 b);
half min(half a, half b); 添加于 API 级别 24
half2 min(half2 a, half b); 添加于 API 级别 24
half2 min(half2 a, half2 b); 添加于 API 级别 24
half3 min(half3 a, half b); 添加于 API 级别 24
half3 min(half3 a, half3 b); 添加于 API 级别 24
half4 min(half4 a, half b); 添加于 API 级别 24
half4 min(half4 a, half4 b); 添加于 API 级别 24
int min(int a, int b);
int2 min(int2 a, int2 b);
int3 min(int3 a, int3 b);
int4 min(int4 a, int4 b);
long min(long a, long b); 添加于 API level 21
long2 min(long2 a, long2 b); 添加于 API level 21
long3 min(long3 a, long3 b); 添加于 API level 21
long4 min(long4 a, long4 b); 添加于 API level 21
short min(short a, short b);
short2 min(short2 a, short2 b);
short3 min(short3 a, short3 b);
short4 min(short4 a, short4 b);
uchar min(uchar a, uchar b);
uchar2 min(uchar2 a, uchar2 b);
uchar3 min(uchar3 a, uchar3 b);
uchar4 min(uchar4 a, uchar4 b);
uint min(uint a, uint b);
uint2 min(uint2 a, uint2 b);
uint3 min(uint3 a, uint3 b);
uint4 min(uint4 a, uint4 b);
ulong min(ulong a, ulong b); 添加于 API level 21
ulong2 min(ulong2 a, ulong2 b); 添加于 API level 21
ulong3 min(ulong3 a, ulong3 b); 添加于 API level 21
ulong4 min(ulong4 a, ulong4 b); 添加于 API level 21
ushort min(ushort a, ushort b);
ushort2 min(ushort2 a, ushort2 b);
ushort3 min(ushort3 a, ushort3 b);
ushort4 min(ushort4 a, ushort4 b);

返回两个参数的最小值。

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。

nan : 非数字

float nan(uint v);
参数
v未使用。

返回一个 NaN 值(非数字)。

nan_half : 非数字

half nan_half(); 添加于 API 级别 24

返回一个半精度浮点 NaN 值(非数字)。

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

返回近似反余弦(以弧度为单位)。

输入值小于 -1 或大于 1 时,此函数的返回结果不确定。

另请参阅 acos()。

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

返回近似反正弦(以弧度为单位)。

输入值小于 -1 或大于 1 时,此函数的返回结果不确定。

另请参阅 asin()。

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

返回以弧度表示的近似反正切,并除以 pi。

要获取以度为单位的反正切,请使用 atanpi(a) * 180.f

另请参阅 atanpi()。

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

返回 (v * pi) 的近似余弦,其中 (v * pi) 以弧度为单位进行衡量。

要获取以度为单位的值的余弦,请调用 cospi(v / 180.f)

另请参阅 cospi()。

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

快速近似 exp。

对于介于 -86.f 和 86.f 之间的输入有效。精度不会比使用 16 位浮点数预期的精度更差。

另请参阅 exp()。

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

快速近似 exp10。

对于介于 -37.f 和 37.f 之间的输入有效。精度不会比使用 16 位浮点数预期的精度更差。

另请参阅 exp10()。

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

快速近似 exp2。

对于介于 -125.f 和 125.f 之间的输入有效。精度不会比使用 16 位浮点数预期的精度更差。

另请参阅 exp2()。

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

快速近似对数。

对于非常接近零的值不准确。

另请参阅 log()。

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

快速近似 log10。

对于非常接近零的值不准确。

另请参阅 log10()。

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

快速近似 log2。

对于非常接近零的值不准确。

另请参阅 log2()。

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

返回 (v * pi) 的近似正弦,其中 (v * pi) 以弧度为单位进行衡量。

要获取以角度为单位的值的正弦,请调用 sinpi(v / 180.f)

另请参阅 sinpi()。

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

返回近似 sqrt(v)。

另请参阅 sqrt()、half_sqrt()。

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

返回 (v * pi) 的近似正切,其中 (v * pi) 以弧度为单位进行衡量。

要获取以角度为单位的值的正切,请调用 tanpi(v / 180.f)

另请参阅 tanpi()。

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

返回底数的指数幂,即 base ^ exponent。

pown() 和 powr() 类似。pown() 接受整数指数。powr() 假定底数为非负数。

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

返回底数的指数幂,即 base ^ exponent。

pow() 和 powr() 类似。它们都接受浮点指数。powr() 也假定底数为非负数。

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

返回 (numerator / denominator) 的余数,其中商会四舍五入到最近的整数。

fmod() 函数类似,但向最近的整数舍入。例如,fmod(-3.8f, 2.f) 返回 -1.8f (-3.8f - -1.f * 2.f),而 remainder(-3.8f, 2.f) 返回 0.2f (-3.8f - -2.f * 2.f)。

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) 将 quot 的最低三位设置为 3,符号为负。它返回 0.5f。

rint : 舍入到偶数

float rint(float v);
float2 rint(float2 v);
float3 rint(float3 v);
float4 rint(float4 v);
half rint(half v); 添加于 API 级别 24
half2 rint(half2 v); 添加于 API 级别 24
half3 rint(half3 v); 添加于 API 级别 24
half4 rint(half4 v); 添加于 API 级别 24

四舍五入到最近的整数值。

rint() 将半值舍入到偶数。例如,rint(0.5f) 返回 0.f,rint(1.5f) 返回 2.f。类似地,rint(-0.5f) 返回 -0.f,rint(-1.5f) 返回 -2.f。

round() 类似,但远离零舍入。trunc() 截断小数部分。

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 : 远离零舍入

float round(float v);
float2 round(float2 v);
float3 round(float3 v);
float4 round(float4 v);
half round(half v); 添加于 API 级别 24
half2 round(half2 v); 添加于 API 级别 24
half3 round(half3 v); 添加于 API 级别 24
half4 round(half4 v); 添加于 API 级别 24

四舍五入到最近的整数值。

round() 将半值远离零舍入。例如,round(0.5f) 返回 1.f,round(1.5f) 返回 2.f。类似地,round(-0.5f) 返回 -1.f,round(-1.5f) 返回 -2.f。

rint() 类似,但将半值舍入到偶数。trunc() 截断小数部分。

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 之间。

rsFrac : 返回浮点数的小数部分

float rsFrac(float v);

已弃用。请改用 fract()。

返回浮点数的小数部分

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 的正弦

float sinpi(float v);
float2 sinpi(float2 v);
float3 sinpi(float3 v);
float4 sinpi(float4 v);
half sinpi(half v); 添加于 API 级别 24
half2 sinpi(half2 v); 添加于 API 级别 24
half3 sinpi(half3 v); 添加于 API 级别 24
half4 sinpi(half4 v); 添加于 API 级别 24

返回 (v * pi) 的正弦,其中 (v * pi) 以弧度为单位进行衡量。

要获取以角度为单位的值的正弦,请调用 sinpi(v / 180.f)

另请参阅 native_sinpi()。

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

如果 v < edge,返回 0.f,否则返回 1.f。

这对于创建条件计算非常有用,而无需使用循环和分支指令。例如,与其计算向量对应元素的 (a[i] < b[i]) ? 0.f : atan2(a[i], b[i]),不如使用 step(a, b) * atan2(a, b)

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 的数的正切值

float tanpi(float v);
float2 tanpi(float2 v);
float3 tanpi(float3 v);
float4 tanpi(float4 v);
half tanpi(half v); 添加于 API 级别 24
half2 tanpi(half2 v); 添加于 API 级别 24
half3 tanpi(half3 v); 添加于 API 级别 24
half4 tanpi(half4 v); 添加于 API 级别 24

返回 (v * pi) 的正切值,其中 (v * pi) 以弧度为单位进行测量。

要获取以角度为单位的值的正切,请调用 tanpi(v / 180.f)

另请参阅 native_tanpi()。

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()。

trunc : 截断浮点数

float trunc(float v);
float2 trunc(float2 v);
float3 trunc(float3 v);
float4 trunc(float4 v);
half trunc(half v); 添加于 API 级别 24
half2 trunc(half2 v); 添加于 API 级别 24
half3 trunc(half3 v); 添加于 API 级别 24
half4 trunc(half4 v); 添加于 API 级别 24

使用截断取整。

例如,trunc(1.7f) 返回 1.f,而 trunc(-1.7f) 返回 -1.f。

有关其他舍入选项,请参阅 rint() 和 round()。