RenderScript 数学常量和函数

概览

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

例如:
float3 a, b;
// The following call sets
// a.x to sin(b.x),
// a.y to sin(b.y), and
// a.z to sin(b.z).
a = sin(b);

有关 distance() 和 length() 等可将输入解释为 n 维空间中单个向量的函数,请参阅矢量数学函数

对 32 位浮点数进行数学运算的精度受 pragmas rs_fp_relaxed 和 rs_fp_full 的影响。在 rs_fp_relaxed 下,次正常值可能会被刷新为 0,并可能会舍入到零。相比之下,rs_fp_full 需要正确处理次正规值,即小于 1.17549435e-38f。rs_fp_rull 还需要舍入到最接近并且等于偶数。

通过使用常见数学函数的变体,可以实现不同的精度/速度权衡。名称以

  • native_:可能包含精确度较低的自定义硬件实现。此外,次正规值可能会被刷新到零,可以使用向零舍入,并且可能无法正确处理 NaN 和无穷大输入。
  • double_:可以使用 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 反余弦除以圆周率
asin 反正弦
Asinh 反双曲正弦
asinpi 反正弦除以圆周率
atan 反正切
atan2 比率的反正切
atan2pi 比率的反正切值除以圆周率
atanh 反双曲正切
atanpi 反正切值除以圆周率
cbrt 立方根
ceil 不小于某个值的最小整数
夹扣 将值限制在某个范围内
clz 前导 0 位的数量
文案签名 将一个数字的符号复制到另一个
cos 余弦
cosh 连字符余弦
cospi 数值的余弦值与 pi 的乘积
将弧度转换为角度
erf 数学误差函数
erfc 数学互补误差函数
exp e 取值为数字
exp10 10 取整
exp2 2 变为数字
expm1 e 增加为减 1 的数字
Fab 浮点数的绝对值
fdim 两个值之间的正差
floor 不大于值的最小整数
fma 相乘和相加
fmax 最多两个浮点数
fmin 最少 2 个浮点数
fmod
分数 正小数部分
frexp 二元尾数和指数
half_recip 按照 16 位精度计算的倒数
half_rsqrt 按 16 位精度计算的平方根的倒数
half_sqrt 计算到 16 位精度的平方根
hypot 斜边
ilogb 以二基数为底的指数
ldexp 根据尾数和指数创建浮点数
lgamma 伽玛函数的自然对数
log 自然对数
log10 以 10 为底的对数
log1p 数值加 1 的自然对数
log2 以 2 为底的对数
logb 以二基数为底的指数
疯狂 相乘和相加
max 上限
min 下限
合辑 混合两个值
modf 积分分量和小数分量
nan 不是数字
nan_half 不是数字
native_acos 近似反余弦
native_acosh 近似双曲余弦
native_acospi 近似反余弦值除以圆周率
native_asin 近似反正弦
native_asinh 近似双曲正弦
native_asinpi 近似反正弦除以 pi
native_atan 近似反正切
native_atan2 比率的近似反正切
native_atan2pi 比率的近似反正切值,除以 pi
native_atanh 近似双曲正切
native_atanpi 近似反正切值/圆周率
native_cbrt 近似立方根
native_cos 近似余弦
native_cosh 近似双曲余弦
native_cospi 数值的近似余弦值乘以圆周率
native_divide 近似除法
native_exp 将 e 近似计算为数字
native_exp10 将近似 10 取为数字
native_exp2 将近似 2 取为数值
native_expm1 e 近似值,取数值减 1
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 数值的近似正弦与圆周率的乘积
native_sqrt 近似平方根
native_tan 近似正切
native_tanh 近似双曲正切
native_tanpi 数值的近似正切值与圆周率的乘积
nextafter 下一个浮点数
pow 基数为指数的幂
pown 基数为整数指数的基数
powr 以正数为底数为指数的数值
弧度 将角度转换为弧度
余数 除法余数
remquo 除法的余数和商
rint 四舍五入到偶数
rootn n 次方根
round 向远离 0 方向舍入
rsRand 伪随机数
rsqrt 平方根的倒数
签名 值的符号
sin 正弦
sincos 正弦和余弦
sinh 双曲正弦
sinpi 数值的正弦与圆周率的乘积
sqrt 平方根
step 如果小于某个值,则为 0,否则为 1
tan 正切
Tanh 双曲正切
Tanpi 数值乘以 pi 的正切值
tgamma 伽玛函数
trunc 截断浮点数
已弃用的函数
rsClamp 已弃用。将值限制在某个范围内
rsFrac 已弃用。返回浮点数的小数部分

常量

M_1_PI :1 / pi,32 位浮点数


值:0.318309886183790671537767526745028724f

圆周率的倒数,表示为 32 位浮点数。

M_2_PI :2 / pi,32 位浮点数


值:0.636619772367581343075535053490057448f

2 除以圆周率,表示为 32 位浮点数。

M_2_SQRTPI :2 / sqrt(pi),32 位浮点数


值:1.128379167095512573896158903121545172f

2 除以圆周率的平方根,表示为 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

圆周率常数,采用 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 位浮点数。

函数

绝对值 :整数的绝对值

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 中引入

返回用弧度除以圆周率的反余弦值。

如需获取以度为单位的反余弦值,请使用 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 :反正弦除以圆周率

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 中引入

返回用弧度除以圆周率的反正弦值。

如需获取以度为单位的反正弦值,请使用 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(浮点分子, 浮点分母);
float2 atan2(float2 分子, float2分母);
float3 atan2(float3 分子, float3分母);
float4 atan2(float4 分子,float4分母);
half atan2(half 分子,half 分母); API 级别 24 中引入
half2 atan2(half2 分子,half2 分母); API 级别 24 中引入
half3 atan2(half3 分子,half3 分母); API 级别 24 中引入
half4 atan2(half4 分子,half4 分母); API 级别 24 中引入
参数
分子分子。
分母分母。可为 0。

返回 (numerator / denominator) 的反正切值,以弧度表示。

另请参阅 native_atan2()。

atan2pi :比率的反正切值除以 pi

float atan2pi(浮点分子, 浮点分母);
float2 atan2pi(float2 分子, float2分母);
float3 atan2pi(float3 分子, float3分母);
float4 atan2pi(float4 分子,float4分母);
half atan2pi(half 分子,half 分母); API 级别 24 中引入
half2 atan2pi(half2 分子,half2 分母); API 级别 24 中引入
half3 atan2pi(half3 分子,half3 分母); API 级别 24 中引入
half4 atan2pi(half4 分子,half4 分母); API 级别 24 中引入
参数
分子分子。
分母分母。可为 0。

返回 (numerator / denominator) 的反正切值,以弧度除以圆周率。

如需获取以度为单位的反正切值,请使用 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 中引入

返回弧度除以圆周率的反正切值。

如需获取以度为单位的反正切值,请使用 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 值, 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 值, 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 值, half min_value, half max_value); API 级别 24 中引入
half2 clamp(half2 value, half2 min_value, half2 max_value); API 级别 24 中引入
half3 clamp(half3 值, half min_value, half max_value); API 级别 24 中引入
half3 clamp(half3 value, half3 min_value, half3 max_value); API 级别 24 中引入
half4 clamp(half4 值, 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 值, long min_value, long max_value); API 级别 19 中引入
long2 clamp(long2 值, long2 min_value, long2 max_value); API 级别 19 中引入
long3 clamp(long3 value, long min_value, long max_value); API 级别 19 中引入
long3 clamp(long3 值, long3 min_value, long3 max_value); API 级别 19 中引入
long4 clamp(long4 value, long min_value, long max_value); API 级别 19 中引入
long4 clamp(long4 值, 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 值, short2 min_value, short2 max_value); API 级别 19 中引入
short3 clamp(short3 value, short min_value, short max_value); API 级别 19 中引入
short3 clamp(short3 值, short3 min_value, short3 max_value); API 级别 19 中引入
short4 clamp(short4 value, short min_value, short max_value); API 级别 19 中引入
short4 clamp(short4 值, 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 值, ushort min_value, ushort max_value); API 级别 19 中引入
ushort2 clamp(ushort2 值, ushort min_value, ushort max_value); API 级别 19 中引入
ushort2 clamp(ushort2 值, ushort2 min_value, ushort2 max_value); API 级别 19 中引入
ushort3 clamp(ushort3 值, ushort min_value, ushort max_value); API 级别 19 中引入
ushort3 clamp(ushort3 值, ushort3 min_value, ushort3 max_value); API 级别 19 中引入
ushort4 clamp(ushort4 值, ushort min_value, ushort max_value); API 级别 19 中引入
ushort4 clamp(ushort4 值, ushort4 min_value, ushort4 max_value); API 级别 19 中引入
参数
value要限定的值。
最小值下限,标量或匹配向量。
最大值上限,必须与下限类型相匹配。

将值限制在指定的上界和下界。如果值 < min_value,则 clamp() 返回 min_value;如果 value > max_value,则返回 max_value,否则返回 value。

clamp 有两种变体:一种是最小值和最大值是应用于值的所有条目的标量,另一种是最小值和最大值也是矢量。

如果 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 值);
short3 clz(short3 value);
short4 clz(short4 值)
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 值);
ushort2 clz(ushort2 值);
ushort3 clz(ushort3 值);
ushort4 clz(ushort4 值);

返回值中前导 0 位的数量。

例如,clz((char)0x03) 会返回 6。

复制符号 :将一个数字的符号复制到另一个数字

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 度(float2 v);
float3 度(float3 v);
float4 度(float4 v);
half 度(half v); API 级别 24 中引入
half2 度(half2 v); API 级别 24 中引入
half3 度(half3 v); API 级别 24 中引入
half4 度(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 中引入

返回增加为 v 的 e,即 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 中引入

返回增加到 v 减 1 的 e,即 (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 分子, float denominator);
float2 fmod(float2 分子, float2分母);
float3 fmod(float3 分子, float3分母);
float4 fmod(float4 分子, float4分母);
half fmod(half 分子,half 分母); API 级别 24 中引入
half2 fmod(half2 分子,half2 分母); API 级别 24 中引入
half3 fmod(half3 分子,half3 分母); API 级别 24 中引入
half4 fmod(half4 分子,half4 分母); API 级别 24 中引入

返回(分子 / 分母)的余数,其中商的四舍五入到零。

函数 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)。

分数 :正小数部分

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* 楼层); API 级别 24 中引入
参数
v输入值。
如果 floor 不为 null,*floor 将设为 v 的 floor。

返回 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* 指数);
float2 frexp(float2 v, int2* 指数);
float3 frexp(float3 v, int3* 指数);
float4 frexp(float4 v, int4* 指数);
half frexp(half v, int* exponent); API 级别 24 中引入
half2 frexp(half2 v, int2* 指数); API 级别 24 中引入
half3 frexp(half3 v, int3* 指数); API 级别 24 中引入
half4 frexp(half4 v, int4* 指数); API 级别 24 中引入
参数
v输入值。
指数如果指数不为 null,*指数将设为 v 的指数。

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

尾数始终介于 0.5(含)和 1.0(不含)之间。

有关反向操作,请参阅 ldexp()。另请参阅 logb() 和 ilogb()。

half_recip :按 16 位精度计算的倒数

float half_recip(float v); API 级别 17 中引入
float2 half_recip(float2 v); API 级别 17 中引入
float3 half_recip(float3 v); API 级别 17 中引入
float4 half_recip(float4 v); API 级别 17 中引入

返回数值的近似倒数。

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

另请参阅 native_recip()。

half_rsqrt :按 16 位精度计算的平方根的倒数

float half_rsqrt(float v); API 级别 17 中引入
float2 half_rsqrt(float2 v); API 级别 17 中引入
float3 half_rsqrt(float3 v); API 级别 17 中引入
float4 half_rsqrt(float4 v); API 级别 17 中引入

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

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

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

half_sqrt :按 16 位精度计算的平方根

float half_sqrt(float v); API 级别 17 中引入
float2 half_sqrt(float2 v); API 级别 17 中引入
float3 half_sqrt(float3 v); API 级别 17 中引入
float4 half_sqrt(float4 v); API 级别 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 中引入

返回数值以二为底的指数,尾数介于 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 指数);
float4 ldexp(float4 mantissa, int exponent);
float4 ldexp(float4 mantissa, int4 指数);
ldexp(half 尾数, 整数指数); API 级别 24 中引入
half2 ldexp(half2 尾数, int exponent); API 级别 24 中引入
half2 ldexp(half2 尾数, int2 指数); API 级别 24 中引入
half3 ldexp(half3 尾数, int exponent); API 级别 24 中引入
half3 ldexp(half3 尾数, int3 指数); API 级别 24 中引入
half4 ldexp(half4 尾数, int exponent); API 级别 24 中引入
half4 ldexp(half4 尾数, int4 指数); API 级别 24 中引入
参数
蝠鲼Mantissa。
指数指数、单个分量或匹配矢量。

返回用尾数和指数创建的浮点数,即(尾数 * 2 ^ 指数)。

请参阅 frexp(),了解反向操作。

lgamma :伽马函数的自然对数

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 不为 null,如果 v 的 Gamma 为负数,*sign_of_gamma 将设置为 -1.f,否则设置为 1.f。

返回伽玛函数的绝对值的自然对数,即 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 中引入

返回数值以二为底的指数,尾数介于 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 级别 21 中引入
long2 max(long2 a, long2 b); API 级别 21 中引入
long3 max(long3 a, long3 b); API 级别 21 中引入
long4 max(long4 a, long4 b); API 级别 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 级别 21 中引入
ulong2 max(ulong2 a, ulong2 b); API 级别 21 中引入
ulong3 max(ulong3 a, ulong3 b); API 级别 21 中引入
ulong4 max(ulong4 a, ulong4 b); API 级别 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 级别 21 中引入
long2 min(long2 a, long2 b); API 级别 21 中引入
long3 min(long3 a, long3 b); API 级别 21 中引入
long4 min(long4 a, long4 b); API 级别 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 级别 21 中引入
ulong2 min(ulong2 a, ulong2 b); API 级别 21 中引入
ulong3 min(ulong3 a, ulong3 b); API 级别 21 中引入
ulong4 min(ulong4 a, ulong4 b); API 级别 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 lead);
float2 mix(float2 start, float2 stop, float point);
float2 mix(float2 start, float2 stop, float2 score);
float3 mix(float3 start, float3 stop, float point);
float3 mix(float3 start, float3 stop, float3ffffff);
float4 mix(float4 start, float4 stop, float score);
float4 mix(float4 start, float4 stop, float4ffffff);
半场混合(开始,停止,部分); API 级别 24 中引入
half2 mix(开始混合 half2half2 停靠点,half2 小数); API 级别 24 中引入
half2 mix(开始混合 half2half2 停止数据,half2 部分); API 级别 24 中引入
half3 mix(开始混合 half3half3 停止分布,half3 部分); API 级别 24 中引入
half3 mix(开始混合 half3half3 停止数据,half3 部分); API 级别 24 中引入
half4 mix(开始混合 half4half4 停止分布,half4 部分); API 级别 24 中引入
half4 mix(开始混合 half4half4 停止数据,half4 部分); API 级别 24 中引入

返回开始 + ((停止 - 起始) * 分数)。

这在混合两个值时非常有用。例如,如需创建一个颜色为 40% 且颜色为 60% 的新颜色,请使用 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 将设为数值的整数部分。
开球回攻次数
值的浮点部分。

返回数值的积分分量和小数分量。

两个分量的符号与 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 级别 21 中引入
float2 native_acos(float2 v); API 级别 21 中引入
float3 native_acos(float3 v); API 级别 21 中引入
float4 native_acos(float4 v); API 级别 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 级别 21 中引入
float2 native_acosh(float2 v); API 级别 21 中引入
float3 native_acosh(float3 v); API 级别 21 中引入
float4 native_acosh(float4 v); API 级别 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 级别 21 中引入
float2 native_acospi(float2 v); API 级别 21 中引入
float3 native_acospi(float3 v); API 级别 21 中引入
float4 native_acospi(float4 v); API 级别 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 中引入

返回近似反余弦值(以弧度为单位)除以圆周率。

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

此函数会从小于 -1 或大于 1 的输入值中产生未定义的结果。

另请参阅 acospi()。

native_asin :近似反正弦

float native_asin(float v); API 级别 21 中引入
float2 native_asin(float2 v); API 级别 21 中引入
float3 native_asin(float3 v); API 级别 21 中引入
float4 native_asin(float4 v); API 级别 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 级别 21 中引入
float2 native_asinh(float2 v); API 级别 21 中引入
float3 native_asinh(float3 v); API 级别 21 中引入
float4 native_asinh(float4 v); API 级别 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 级别 21 中引入
float2 native_asinpi(float2 v); API 级别 21 中引入
float3 native_asinpi(float3 v); API 级别 21 中引入
float4 native_asinpi(float4 v); API 级别 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 中引入

返回近似正弦值(以弧度为单位)除以圆周率。

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

此函数会从小于 -1 或大于 1 的输入值中产生未定义的结果。

另请参阅 asinpi()。

native_atan :近似反正切

float native_atan(float v); API 级别 21 中引入
float2 native_atan(float2 v); API 级别 21 中引入
float3 native_atan(float3 v); API 级别 21 中引入
float4 native_atan(float4 v); API 级别 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(浮点分子, 浮点分母); API 级别 21 中引入
float2 native_atan2(float2 分子, float2分母); API 级别 21 中引入
float3 native_atan2(float3 分子, float3分母); API 级别 21 中引入
float4 native_atan2(float4 分子,float4分母); API 级别 21 中引入
half native_atan2(half 分子,half 分母); API 级别 24 中引入
half2 native_atan2(half2 分子,half2 分母); API 级别 24 中引入
half3 native_atan2(half3 分子,half3 分母); API 级别 24 中引入
half4 native_atan2(half4 分子,half4 分母); API 级别 24 中引入
参数
分子分子。
分母分母。可为 0。

返回 (numerator / denominator) 的近似反正切值,以弧度表示。

另请参阅 atan2()。

native_atan2pi :比率的近似反正切值除以 pi

float native_atan2pi(浮点分子, 浮点分母); API 级别 21 中引入
float2 native_atan2pi(float2 分子, float2分母); API 级别 21 中引入
float3 native_atan2pi(float3 分子, float3分母); API 级别 21 中引入
float4 native_atan2pi(float4 分子, float4分母); API 级别 21 中引入
half native_atan2pi(half 分子,half 分母); API 级别 24 中引入
half2 native_atan2pi(half2 分子,half2 分母); API 级别 24 中引入
half3 native_atan2pi(half3 分子,half3 分母); API 级别 24 中引入
half4 native_atan2pi(half4 分子,half4 分母); API 级别 24 中引入
参数
分子分子。
分母分母。可为 0。

返回 (numerator / denominator) 的近似反正切值,以弧度除以 pi。

如需获取以度为单位的反正切值,请使用 atan2pi(n, d) * 180.f

另请参阅 atan2pi()。

native_atanh :近似双曲正切

float native_atanh(float v); API 级别 21 中引入
float2 native_atanh(float2 v); API 级别 21 中引入
float3 native_atanh(float3 v); API 级别 21 中引入
float4 native_atanh(float4 v); API 级别 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 级别 21 中引入
float2 native_atanpi(float2 v); API 级别 21 中引入
float3 native_atanpi(float3 v); API 级别 21 中引入
float4 native_atanpi(float4 v); API 级别 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 中引入

返回近似反正切值(以弧度除以圆周率)。

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

另请参阅 atanpi()。

native_cbrt :近似立方根

float native_cbrt(float v); API 级别 21 中引入
float2 native_cbrt(float2 v); API 级别 21 中引入
float3 native_cbrt(float3 v); API 级别 21 中引入
float4 native_cbrt(float4 v); API 级别 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 级别 21 中引入
float2 native_cos(float2 v); API 级别 21 中引入
float3 native_cos(float3 v); API 级别 21 中引入
float4 native_cos(float4 v); API 级别 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 级别 21 中引入
float2 native_cosh(float2 v); API 级别 21 中引入
float3 native_cosh(float3 v); API 级别 21 中引入
float4 native_cosh(float4 v); API 级别 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 级别 21 中引入
float2 native_cospi(float2 v); API 级别 21 中引入
float3 native_cospi(float3 v); API 级别 21 中引入
float4 native_cospi(float4 v); API 级别 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 级别 21 中引入
float2 native_divide(float2 left_vector, float2 right_vector); API 级别 21 中引入
float3 native_divide(float3 left_vector, float3 right_vector); API 级别 21 中引入
float4 native_divide(float4 left_vector, float4 right_vector); API 级别 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 中引入

快速近似体验

此类型适用于从 -86.f 到 86.f 的输入。精度并不比使用 16 位浮点值时的预期差很多。

另请参阅 exp()。

native_exp10 :约为 10,取 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 中引入

快速近似体验 2。

此类型适用于从 -125.f 到 125.f 的输入。精度并不比使用 16 位浮点值时的预期差很多。

另请参阅 exp2()。

native_expm1 :e 近似为 e,取 1 为减 1

float native_expm1(float v); API 级别 21 中引入
float2 native_expm1(float2 v); API 级别 21 中引入
float3 native_expm1(float3 v); API 级别 21 中引入
float4 native_expm1(float4 v); API 级别 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 级别 21 中引入
float2 native_hypot(float2 a, float2 b); API 级别 21 中引入
float3 native_hypot(float3 a, float3 b); API 级别 21 中引入
float4 native_hypot(float4 a, float4 b); API 级别 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 中引入

快速近似 log0。

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

另请参阅 log10()。

native_log1p :值加 1 的近似自然对数

float native_log1p(float v); API 级别 21 中引入
float2 native_log1p(float2 v); API 级别 21 中引入
float3 native_log1p(float3 v); API 级别 21 中引入
float4 native_log1p(float4 v); API 级别 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(半底基数, 半指数); API 级别 24 中引入
half2 native_powr(half2 的底数,half2 指数); API 级别 24 中引入
half3 native_powr(half3 的底数,half3 指数); API 级别 24 中引入
half4 native_powr(half4 的底数,half4 指数); API 级别 24 中引入
参数
基础必须介于 0.f 到 256.f 之间。该函数不适用于非常接近零的值。
指数必须介于 -15.f 到 15.f 之间。

快速近似(底数 ^ 指数)。

另请参阅 powr()。

native_recip :近似倒数

float native_recip(float v); API 级别 21 中引入
float2 native_recip(float2 v); API 级别 21 中引入
float3 native_recip(float3 v); API 级别 21 中引入
float4 native_recip(float4 v); API 级别 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 :近似 n 个根

float native_rootn(float v, int n); API 级别 21 中引入
float2 native_rootn(float2 v, int2 n); API 级别 21 中引入
float3 native_rootn(float3 v, int3 n); API 级别 21 中引入
float4 native_rootn(float4 v, int4 n); API 级别 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 中引入

计算某个值的近似 N 次方根。

另请参阅 rootn()。

native_rsqrt :平方根的近似倒数

float native_rsqrt(float v); API 级别 21 中引入
float2 native_rsqrt(float2 v); API 级别 21 中引入
float3 native_rsqrt(float3 v); API 级别 21 中引入
float4 native_rsqrt(float4 v); API 级别 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 级别 21 中引入
float2 native_sin(float2 v); API 级别 21 中引入
float3 native_sin(float3 v); API 级别 21 中引入
float4 native_sin(float4 v); API 级别 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 级别 21 中引入
float2 native_sincos(float2 v, float2* cos); API 级别 21 中引入
float3 native_sincos(float3 v, float3* cos); API 级别 21 中引入
float4 native_sincos(float4 v, float4* cos); API 级别 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 级别 21 中引入
float2 native_sinh(float2 v); API 级别 21 中引入
float3 native_sinh(float3 v); API 级别 21 中引入
float4 native_sinh(float4 v); API 级别 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 级别 21 中引入
float2 native_sinpi(float2 v); API 级别 21 中引入
float3 native_sinpi(float3 v); API 级别 21 中引入
float4 native_sinpi(float4 v); API 级别 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 级别 21 中引入
float2 native_sqrt(float2 v); API 级别 21 中引入
float3 native_sqrt(float3 v); API 级别 21 中引入
float4 native_sqrt(float4 v); API 级别 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 级别 21 中引入
float2 native_tan(float2 v); API 级别 21 中引入
float3 native_tan(float3 v); API 级别 21 中引入
float4 native_tan(float4 v); API 级别 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 级别 21 中引入
float2 native_tanh(float2 v); API 级别 21 中引入
float3 native_tanh(float3 v); API 级别 21 中引入
float4 native_tanh(float4 v); API 级别 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 级别 21 中引入
float2 native_tanpi(float2 v); API 级别 21 中引入
float3 native_tanpi(float3 v); API 级别 21 中引入
float4 native_tanpi(float4 v); API 级别 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 指向目标的下一个可表示浮点数。

在 rs_fp_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(半底数, 半指数); API 级别 24 中引入
half2 pow(half2 的底数, half2 指数); API 级别 24 中引入
half3 pow(half3 的底数,half3 指数); API 级别 24 中引入
half4 pow(half4 底数,half4 指数); API 级别 24 中引入

返回底数的幂指数(即底数 ^ 指数)。

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 基数, int2 指数); API 级别 24 中引入
half3 pown(half3 基数, int3 指数); API 级别 24 中引入
half4 pown(half4 底数,int4 指数); API 级别 24 中引入

返回底数的幂指数(即底数 ^ 指数)。

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(半底数, 半数指数); API 级别 24 中引入
half2 powr(half2 底数,half2 指数); API 级别 24 中引入
half3 powr(half3 底数,half3 指数); API 级别 24 中引入
half4 powr(half4 的底数,half4 指数); API 级别 24 中引入

返回底数的幂指数(即底数 ^ 指数)。底数必须大于等于 0。

pow() 和 pown() 类似。它们都没有关于底数的任何假设。pow() 接受浮点指数,而 pown() 则接受整数。

另请参阅 native_powr()。

弧度 :将角度转换为弧度

float radians(float v);
float2 弧度(float2 v);
float3 radians(float3 v);
float4 radians(float4 v);
half 弧度(half v); API 级别 24 中引入
half2 弧度(half2 v); API 级别 24 中引入
half3 弧度(half3 v); API 级别 24 中引入
half4 弧度(half4 v); API 级别 24 中引入

从角度转换为弧度。

余数 :除法的余数

float match(float 分子, float denominator);
float2 Rest(float2 分子, float2分母);
float3 keep(float3 分子, float3分母);
float4 keep(float4 分子, float4分母);
half 余数(half 分子, half 分母); API 级别 24 中引入
half2 余数(half2 分子,half2 分母); API 级别 24 中引入
half3 余数(half3 分子,half3 分母); API 级别 24 中引入
half4 余数(half4 分子,half4 分母); API 级别 24 中引入

返回(分子 / 分母)的余数,其中商的四舍五入为最接近的整数。

函数 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 分子, float2分母, int2* 商数);
float3 remquo(float3 分子, float3分母, int3* 商数);
float4 remquo(float4 分子, float4分母, int4* 商;
half remquo(half 分子, half 分母, int* 商); API 级别 24 中引入
half2 remquo(half2 分子, half2 分母, int2* 商); API 级别 24 中引入
half3 remquo(half3 分子, half3 分母, int3* 商); API 级别 24 中引入
half4 remquo(half4 分子, half4 分母, int4* 商); API 级别 24 中引入
参数
分子分子。
分母分母。
*商将设置为整数商。
开球回攻次数
其余部分,仅针对低三位。

返回商和余数(分子 / 分母)。

只有商的符号和最低三位可以保证准确。

此函数对于实现周期性函数非常有用。商的低 3 位表示象限,余下部分表示该象限内的距离。例如,sin(x) 的实现可以调用 remquo(x, PI / 2.f, &quadrant) 来将非常大的 x 值减少为有限范围内的值。

示例:remquo(-23.5f, 8.f, &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 :向远离 0 的方向舍入

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() 将一半的值向远离 0 的方向舍入。例如,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 top);
uchar rsClamp(uchar amount, uchar low, uchar high);
uint rsClamp(uint amount, uint low, uint high);
ushort rsClamp(ushort amount, ushort low, ushort high);
参数
金额要限定的值。
下限。
上限。

已弃用。请改用 clamp()。

限制介于下限和上限之间的值。

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_malue 之间的随机值。

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 符号(half v); API 级别 24 中引入
half2 符号(half2 v); API 级别 24 中引入
half3 符号(half3 v); API 级别 24 中引入
half4 符号(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()。

正弦 :正弦和余弦

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 的双曲正弦值,其中 v 以弧度为单位。

另请参阅 native_sinh()。

sinpi :数值的正弦与圆周率的乘积

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 级别 21 中引入
float2 step(float2 edge, float v);
float2 step(float2 edge, float2 v);
float3 step(float edge, float3 v); API 级别 21 中引入
float3 step(float3 edge, float v);
float3 step(float3 edge, float3 v);
float4 step(float edge, float4 v); API 级别 21 中引入
float4 step(float4 edge, float v);
float4 step(float4 edge, float4 v);
步(边缘, v); API 级别 24 中引入
half2 步(边缘, half2 v); API 级别 24 中引入
半程步(半程边缘, v); API 级别 24 中引入
half2 步(半程边缘, half2 v); API 级别 24 中引入
half3 step(half3edge, half3 v); API 级别 24 中引入
half3 步(半程边缘, v); API 级别 24 中引入
half3 step(half3 edge, half3 v); API 级别 24 中引入
half4 步(边缘, half4 v); API 级别 24 中引入
half4 步(半程边缘, v); API 级别 24 中引入
half4 step(half4 edge, half4 v); API 级别 24 中引入

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

这对于在不使用循环和分支指令的情况下创建条件计算非常有用。例如,您可以改用 step(a, b) * atan2(a, b),而不是为矢量的相应元素计算 (a[i] < b[i]) ? 0.f : atan2(a[i], b[i])

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 :伽玛函数

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 中引入

返回数值的伽马函数。

另请参阅 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()。