概览
以下数学函数可应用于标量和矢量。应用于向量时,返回的值是应用于每个输入条目的函数的向量。
例如:
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
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 :反正弦除以圆周率
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
cbrt :立方根
float cbrt(float v); | |
float2 cbrt(float2 v); | |
float3 cbrt(float3 v); | |
float4 cbrt(float4 v); | |
half cbrt(half v); | 在 API 级别 24 中引入 |
half2 cbrt(half2 v); | 在 API 级别 24 中引入 |
half3 cbrt(half3 v); | 在 API 级别 24 中引入 |
half4 cbrt(half4 v); | 在 API 级别 24 中引入 |
返回立方根。
另请参阅 native_cbrt()。
ceil :不小于某个值的最小整数
clamp :将值限制在某个范围内
char clamp(char value, char min_value, char max_value); | 在 API 级别 19 中引入 |
char2 clamp(char2 value, char min_value, char max_value); | 在 API 级别 19 中引入 |
char2 clamp(char2 值, 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 的乘积
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 :不大于值的最小整数
fma :相乘和相加
float fma(float multiplicand1, float multiplicand2, float offset); | |
float2 fma(float2 multiplicand1, float2 multiplicand2, float2 offset); | |
float3 fma(float3 multiplicand1, float3 multiplicand2, float3 offset); | |
float4 fma(float4 multiplicand1, float4 multiplicand2, float4 offset); | |
half fma(half multiplicand1, half multiplicand2, half offset); | 在 API 级别 24 中引入 |
half2 fma(half2 multiplicand1, half2 multiplicand2, half2 offset); | 在 API 级别 24 中引入 |
half3 fma(half3 multiplicand1, half3 multiplicand2, half3 offset); | 在 API 级别 24 中引入 |
half4 fma(half4 multiplicand1, half4 multiplicand2, half4 offset); | 在 API 级别 24 中引入 |
fmax :最多两个浮点数
float fmax(float a, float b); | |
float2 fmax(float2 a, float b); | |
float2 fmax(float2 a, float2 b); | |
float3 fmax(float3 a, float b); | |
float3 fmax(float3 a, float3 b); | |
float4 fmax(float4 a, float b); | |
float4 fmax(float4 a, float4 b); | |
half fmax(half a, half b); | 在 API 级别 24 中引入 |
half2 fmax(half2 a, half b); | 在 API 级别 24 中引入 |
half2 fmax(half2 a, half2 b); | 在 API 级别 24 中引入 |
half3 fmax(half3 a, half b); | 在 API 级别 24 中引入 |
half3 fmax(half3 a, half3 b); | 在 API 级别 24 中引入 |
half4 fmax(half4 a, half b); | 在 API 级别 24 中引入 |
half4 fmax(half4 a, half4 b); | 在 API 级别 24 中引入 |
返回 a 和 b 的最大值,即 (a < b ? b : a)
。
max() 函数返回相同的结果,但可以应用于更多数据类型。
fmin :最少两个浮点数
float fmin(float a, float b); | |
float2 fmin(float2 a, float b); | |
float2 fmin(float2 a, float2 b); | |
float3 fmin(float3 a, float b); | |
float3 fmin(float3 a, float3 b); | |
float4 fmin(float4 a, float b); | |
float4 fmin(float4 a, float4 b); | |
half fmin(half a, half b); | 在 API 级别 24 中引入 |
half2 fmin(half2 a, half b); | 在 API 级别 24 中引入 |
half2 fmin(half2 a, half2 b); | 在 API 级别 24 中引入 |
half3 fmin(half3 a, half b); | 在 API 级别 24 中引入 |
half3 fmin(half3 a, half3 b); | 在 API 级别 24 中引入 |
half4 fmin(half4 a, half b); | 在 API 级别 24 中引入 |
half4 fmin(half4 a, half4 b); | 在 API 级别 24 中引入 |
返回 a 和 b 的最小值,即 (a > b ? b : a)
。
min() 函数会返回相同的结果,但可以应用于更多数据类型。
fmod :模数
float fmod(float 分子, 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 中引入 |
分数 :正小数部分
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 的指数。 |
half_recip :按 16 位精度计算的倒数
half_rsqrt :按 16 位精度计算的平方根的倒数
half_sqrt :按 16 位精度计算的平方根
hypot :斜边
float hypot(float a, float b); | |
float2 hypot(float2 a, float2 b); | |
float3 hypot(float3 a, float3 b); | |
float4 hypot(float4 a, float4 b); | |
half hypot(half a, half b); | 在 API 级别 24 中引入 |
half2 hypot(half2 a, half2 b); | 在 API 级别 24 中引入 |
half3 hypot(half3 a, half3 b); | 在 API 级别 24 中引入 |
half4 hypot(half4 a, half4 b); | 在 API 级别 24 中引入 |
返回斜边,即 sqrt(a * a + b * b)
。
另请参阅 native_hypot()。
ilogb :以 2 为底的指数
ldexp :由尾数和指数创建浮点数
float ldexp(float mantissa, int exponent); | |
float2 ldexp(float2 mantissa, int exponent); | |
float2 ldexp(float2 mantissa, int2 exponent); | |
float3 ldexp(float3 mantissa, int exponent); | |
float3 ldexp(float3 mantissa, int3 指数); | |
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 :自然对数
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 中引入 |
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(开始混合 half2,half2 停靠点,half2 小数); | 在 API 级别 24 中引入 |
half2 mix(开始混合 half2,half2 停止数据,half2 部分); | 在 API 级别 24 中引入 |
half3 mix(开始混合 half3,half3 停止分布,half3 部分); | 在 API 级别 24 中引入 |
half3 mix(开始混合 half3,half3 停止数据,half3 部分); | 在 API 级别 24 中引入 |
half4 mix(开始混合 half4,half4 停止分布,half4 部分); | 在 API 级别 24 中引入 |
half4 mix(开始混合 half4,half4 停止数据,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。
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 中引入 |
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 中引入 |
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 中引入 |
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 中引入 |
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 中引入 |
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 中引入 |
native_exp2 :约 2 为数字
float native_exp2(float v); | 在 API 级别 18 中引入 |
float2 native_exp2(float2 v); | 在 API 级别 18 中引入 |
float3 native_exp2(float3 v); | 在 API 级别 18 中引入 |
float4 native_exp2(float4 v); | 在 API 级别 18 中引入 |
half native_exp2(half v); | 在 API 级别 24 中引入 |
half2 native_exp2(half2 v); | 在 API 级别 24 中引入 |
half3 native_exp2(half3 v); | 在 API 级别 24 中引入 |
half4 native_exp2(half4 v); | 在 API 级别 24 中引入 |
native_expm1 :e 近似为 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 中引入 |
native_log10 :以 10 为底的近似对数
float native_log10(float v); | 在 API 级别 18 中引入 |
float2 native_log10(float2 v); | 在 API 级别 18 中引入 |
float3 native_log10(float3 v); | 在 API 级别 18 中引入 |
float4 native_log10(float4 v); | 在 API 级别 18 中引入 |
half native_log10(half v); | 在 API 级别 24 中引入 |
half2 native_log10(half2 v); | 在 API 级别 24 中引入 |
half3 native_log10(half3 v); | 在 API 级别 24 中引入 |
half4 native_log10(half4 v); | 在 API 级别 24 中引入 |
native_log1p :值加 1 的近似自然对数
float native_log1p(float v); | 在 API 级别 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 中引入 |
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 中引入 |
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 中引入 |
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 中引入 |
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 :基数为整数指数的基数
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 中引入 |
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 中引入 |
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, ")
将商的最低三位设为 3 并将符号负数设为负。它返回 0.5f。
rint :舍入到偶数
rootn :第 N 个根
float rootn(float v, int n); | |
float2 rootn(float2 v, int2 n); | |
float3 rootn(float3 v, int3 n); | |
float4 rootn(float4 v, int4 n); | |
half rootn(half v, int n); | 在 API 级别 24 中引入 |
half2 rootn(half2 v, int2 n); | 在 API 级别 24 中引入 |
half3 rootn(half3 v, int3 n); | 在 API 级别 24 中引入 |
half4 rootn(half4 v, int4 n); | 在 API 级别 24 中引入 |
计算值的 N 次方根。
另请参阅 native_rootn()。
round :向远离 0 的方向舍入
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()。
限制介于下限和上限之间的值。
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 :数值的正弦与圆周率的乘积
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 中引入 |
tan :正切
float tan(float v); | |
float2 tan(float2 v); | |
float3 tan(float3 v); | |
float4 tan(float4 v); | |
half tan(half v); | 在 API 级别 24 中引入 |
half2 tan(half2 v); | 在 API 级别 24 中引入 |
half3 tan(half3 v); | 在 API 级别 24 中引入 |
half4 tan(half4 v); | 在 API 级别 24 中引入 |
返回角度(以弧度为单位)的正切值。
另请参阅 native_tan()。
tanh :双曲正切
float tanh(float v); | |
float2 tanh(float2 v); | |
float3 tanh(float3 v); | |
float4 tanh(float4 v); | |
half tanh(half v); | 在 API 级别 24 中引入 |
half2 tanh(half2 v); | 在 API 级别 24 中引入 |
half3 tanh(half3 v); | 在 API 级别 24 中引入 |
half4 tanh(half4 v); | 在 API 级别 24 中引入 |
返回数值的双曲正切值。
另请参阅 native_tanh()。
tanpi :数值乘以 pi 的正切值
tgamma :伽玛函数
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()。