Tổng quan
Bạn có thể áp dụng các hàm toán học dưới đây cho đại lượng vô hướng và vectơ. Khi áp dụng cho vectơ, giá trị trả về là một vectơ của hàm được áp dụng cho mỗi mục của đầu vào.
Ví dụ:
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);
Xem Hàm toán học vectơ để tìm hiểu các hàm như distance() và length() mà diễn giải dữ liệu đầu vào dưới dạng một vectơ đơn trong không gian n chiều.
Độ chính xác của các phép toán trên số thực 32 bit chịu ảnh hưởng của các pragmas rs_FP_relaxed và rs_FP_full. Trong rs_FP_relaxed, các giá trị phụ bình thường có thể được đẩy về 0 và có thể làm tròn về 0. Để so sánh, rs_FP_full yêu cầu xử lý chính xác các giá trị bất thường, tức là nhỏ hơn 1,17549435e-38f. rs_FP_rull cũng yêu cầu làm tròn đến gần nhất với các mối liên kết với hàm chẵn.
Bạn có thể đạt được nhiều sự đánh đổi về độ chính xác/tốc độ bằng cách sử dụng các biến thể của các hàm toán học phổ biến. Các hàm có tên bắt đầu bằng
- native_: Có thể có các phương pháp triển khai phần cứng tuỳ chỉnh với độ chính xác thấp hơn. Ngoài ra, các giá trị bất thường có thể được đẩy về 0, làm tròn về 0, đồng thời NaN và phương thức nhập vô cực có thể không được xử lý chính xác.
- nửa_: Có thể thực hiện các phép tính nội bộ bằng số thực 16 bit. Ngoài ra, các giá trị bất thường có thể được đẩy về 0 và có thể được làm tròn về 0.
Tóm tắt
Hằng số | |
---|---|
M_1_PI | 1 / pi, dưới dạng số thực 32 bit |
M_2_PI | 2 / pi, dưới dạng số thực 32 bit |
M_2_SQRTPI | 2 / sqrt(pi), dưới dạng số thực 32 bit |
M_E | e, dưới dạng số thực 32 bit |
M_LN10 | log_e(10), dưới dạng số thực 32 bit |
M_LN2 | log_e(2), dưới dạng số thực 32 bit |
M_LOG10E | log_10(e), dưới dạng số thực 32 bit |
M_LOG2E | log_2(e), dưới dạng số thực 32 bit |
M_PI | pi, dưới dạng số thực 32 bit |
M_PI_2 | pi / 2, dưới dạng số thực 32 bit |
M_PI_4 | pi / 4, dưới dạng số thực 32 bit |
M_SQRT1_2 | 1 / sqrt(2), dưới dạng số thực 32 bit |
M_SQRT2 | sqrt(2), dưới dạng số thực 32 bit |
Hàm | |
---|---|
ABS | Giá trị tuyệt đối của một số nguyên |
acos | Cosin nghịch đảo |
Cosin hypebol nghịch đảo | |
Acospi | Cosin nghịch đảo chia cho pi |
asin | Sin nghịch đảo |
asinh | Sin hypebol nghịch đảo |
asinpi | Sin nghịch đảo chia cho pi |
atan | Tang nghịch đảo |
atan2 | Tang nghịch đảo của tỷ số |
atan2pi | Tang nghịch đảo của một tỷ số, chia cho pi |
atanh | Tang hyperbol nghịch đảo |
atanpi | Tang nghịch đảo chia cho pi |
cbrt | Căn bậc ba |
ceil | Số nguyên nhỏ nhất không nhỏ hơn một giá trị |
bộ kẹp | Giới hạn một giá trị trong một phạm vi |
CLz | Số lượng bit 0 ở đầu |
copysign | Sao chép dấu của một số sang số khác |
cos | Cosin |
cosh | Cosin hypebol |
cospi | Cosin của một số nhân với pi |
độ | Chuyển đổi radian thành độ |
erf | Hàm lỗi toán học |
erfc | Hàm sai số bổ trợ trong toán học |
exp | e đã nâng lên thành một số |
exp10 | số 10 được nâng lên thành một số |
biểu thức 2 | Đã nâng 2 thành số |
expm1 | e được nâng lên thành số trừ đi 1 |
đồ đen | Giá trị tuyệt đối của số thực |
fdim | Chênh lệch dương giữa hai giá trị |
sàn | Số nguyên nhỏ nhất không lớn hơn giá trị |
fma | Nhân và cộng |
Tối đa hoá hiệu suất | Tối đa hai số thực |
fmin | Tối thiểu hai số thực |
fmod | Mô-đun |
phân số | Phần thập phân dương |
frexp | Mantissa nhị phân và số mũ |
nửa_recip | Độ chính xác nghịch đảo đến 16 bit |
half_rsqrt | nghịch đảo của căn bậc hai được tính toán với độ chính xác 16 bit |
half_sqrt | Căn bậc hai được tính toán có độ chính xác là 16 bit |
khí ngược | Hoa cúc |
ilogb | Số mũ cơ số hai |
ldexp | Tạo một dấu phẩy động từ mantissa và số mũ |
lgamma | Lôgarit tự nhiên của hàm gamma |
nhật ký | Lôgarit tự nhiên |
log10 | Lôgarit cơ số 10 |
log1p | Lôgarit tự nhiên của một giá trị cộng 1 |
nhật ký 2 | Lôgarit cơ số 2 |
logb | Số mũ cơ số hai |
đen | Nhân và cộng |
tối đa | Tối đa |
phút | Tối thiểu |
danh sách kết hợp | Kết hợp hai giá trị |
modf | Thành phần tích phân và phân số |
nan | Không phải là số |
nan_half | Không phải là số |
native_acos | Cosin nghịch đảo gần đúng |
native_acosh | Cosin hypebol nghịch đảo gần đúng |
native_acospi | Cosin nghịch đảo gần đúng chia cho pi |
native_asin | Sin nghịch đảo gần đúng |
native_asinh | Sin hypebol nghịch đảo gần đúng |
native_asinpi | Sin nghịch đảo gần đúng chia cho pi |
native_atan | Tang nghịch đảo gần đúng |
native_atan2 | Tang nghịch đảo gần đúng của tỷ số |
native_atan2pi | Tang nghịch đảo gần đúng của một tỷ số, chia cho pi |
native_atanh | Tang hyperbol nghịch đảo gần đúng |
native_atanpi | Tang nghịch đảo gần đúng chia cho pi |
native_cbrt | Căn bậc ba gần đúng |
native_cos | Cosin gần đúng |
native_cosh | Cosin hypebol gần đúng |
native_cospi | Cosin gần đúng của một số nhân với pi |
native_divide | Phép chia gần đúng |
native_exp | Số e gần đúng được nâng lên một số |
native_exp10 | Khoảng 10 được nâng thành một số |
native_exp2 | Khoảng 2 được nâng thành một số |
native_expm1 | Số e gần đúng được nâng lên một số trừ đi một |
native_hypot | Cạnh huyền gần đúng |
native_log | Lôgarit tự nhiên gần đúng |
native_log10 | Lôgarit cơ số 10 gần đúng |
native_log1p | Lôgarit tự nhiên gần đúng của một giá trị cộng 1 |
native_log2 | Lôgarit cơ số 2 gần đúng |
native_powr | Cơ số dương gần đúng được nâng lên số mũ |
native_recip | Tỷ lệ nghịch đảo gần đúng |
native_root | Căn bậc n gần đúng |
native_rsqrt | nghịch đảo gần đúng của một căn bậc hai |
native_sin | Sin gần đúng |
native_sincos | Sin và cos gần đúng |
native_sinh | Sin hypebol gần đúng |
native_sinpi | Sin gần đúng của một số nhân với pi |
native_sqrt | Căn bậc hai gần đúng |
gốc_tan | Tang gần đúng |
native_tanh | Tang hyperbol gần đúng |
native_tanpi | Tang gần đúng của một số nhân với pi |
tiếp theo | Số có dấu phẩy động tiếp theo |
pow | Cơ số được nâng lên số mũ |
màu máo | Cơ số được nâng lên một số mũ nguyên |
powr | Cơ số dương được nâng lên một số mũ |
gốc | Chuyển đổi độ thành radian |
số dư | Phần còn lại của phép chia |
remquo | Số dư và thương của phép chia |
công nghệ mã hoá | Làm tròn đến chẵn |
gốc | Căn bậc n |
vòng tròn | Làm tròn từ 0 |
rsRand | Số giả ngẫu nhiên |
rsqrt | nghịch đảo của một căn bậc hai |
dấu hiệu | Ký hiệu của một giá trị |
tội lỗi | Sin |
sincos | Sin và cos |
sinh | Sin Hyperbbol |
sinpi | Sin của một số nhân với pi |
sqrt | Dấu khai căn |
bước | 0 nếu nhỏ hơn giá trị, nếu không thì bằng 1 |
màu nâu vàng nhạt | Tang |
tanh | Tang Hyperbol |
tanpi | Tiếp tuyến của một số nhân với pi |
Tgamma | Hàm Gamma |
trunc | Cắt bớt một dấu phẩy động |
Hàm không dùng nữa | |
---|---|
rsClamp | Không dùng nữa. Giới hạn một giá trị trong một phạm vi |
rsFrac | Không dùng nữa. Trả về phần thập phân của số thực |
Hằng số
M_1_PI : 1 / pi, dưới dạng số thực 32 bit
Giá trị: 0,318309886183790671537767526745028724f |
Nghịch đảo của pi, dưới dạng số thực 32 bit.
M_2_PI : 2 / pi, dưới dạng số thực 32 bit
Giá trị: 0,636619772367581343075535053490057448f |
2 chia cho pi, dưới dạng một số thực 32 bit.
M_2_SQRTPI : 2 / sqrt(pi), dưới dạng số thực 32 bit
Giá trị: 1,128379167095512573896158903121545172f |
2 chia cho căn bậc hai của pi, dưới dạng một số thực 32 bit.
M_E : e, dưới dạng số thực 32 bit
Giá trị: 2,718281828459045235360287471352662498f |
Số e, cơ số của lôgarit tự nhiên, dưới dạng một số thực 32 bit.
M_LN10 : log_e(10), dưới dạng số thực 32 bit
Giá trị: 2,302585092994045684017991454684364208f |
Lôgarit tự nhiên của 10, dưới dạng số thực 32 bit.
M_LN2 : log_e(2), dưới dạng số thực 32 bit
Giá trị: 0,693147180559945309417232121458176568f |
Lôgarit tự nhiên của 2, dưới dạng một số thực 32 bit.
M_LOG10E : log_10(e), dưới dạng số thực 32 bit
Giá trị: 0,434294481903251827651128918916605082f |
Lôgarit cơ số 10 của e, dưới dạng một số thực 32 bit.
M_LOG2E : log_2(e), dưới dạng số thực 32 bit
Giá trị: 1.442695040888963407359924681001892137f |
Lôgarit cơ số 2 của e, dưới dạng một số thực 32 bit.
M_PI : pi, dưới dạng số thực 32 bit
Giá trị: 3,141592653589793238462643383279502884f |
Số pi không đổi, dưới dạng số thực 32 bit.
M_PI_2 : pi / 2, dưới dạng số thực 32 bit
Giá trị: 1.570796326794896619231321691639751442f |
Pi chia cho 2, dưới dạng một số thực 32 bit.
M_PI_4 : pi / 4, dưới dạng số thực 32 bit
Giá trị: 0,785398163397448309615660845819875721f |
Pi chia cho 4, dưới dạng một số thực 32 bit.
M_SQRT1_2 : 1 / sqrt(2), dưới dạng số thực 32 bit
Giá trị: 0,707106781186547524400844362104849039f |
Nghịch đảo của căn bậc hai của 2, dưới dạng một số thực 32 bit.
M_SQRT2 : sqrt(2), dưới dạng số thực 32 bit
Giá trị: 1.414213562373095048801688724209698079f |
Căn bậc hai của 2, dưới dạng một số thực 32 bit.
Hàm
AB : Giá trị tuyệt đối của một số nguyên
uchar abs(char v); | |
uchar2 abs(char2 v); | |
uchar3 abs(char3 v); | |
uchar4 abs(char4 v); | |
uint abs(int v); | |
uint2 AB(int2 v); | |
uint3 AB(int3 v); | |
uint4 abs(int4 v); | |
ushort abs(short v); | |
ushort2 abs(short2 v); | |
ushort3 abs(short3 v); | |
ushort4 abs(short4 v); |
Trả về giá trị tuyệt đối của một số nguyên.
Đối với độ chính xác đơn, hãy sử dụng fabs().
acos : Cosin nghịch đảo
độ chính xác đơn acos(float v); | |
float2 acos(float2 v); | |
float3 acos(float3 v); | |
float4 acos(float4 v); | |
nửa acos(một nửa v); | Đã thêm vào API cấp 24 |
half2 acos(half2 v); | Đã thêm vào API cấp 24 |
half3 acos(half3 v); | Đã thêm vào API cấp 24 |
half4 acos(half4 v); | Đã thêm vào API cấp 24 |
Trả về cosin nghịch đảo, tính bằng radian.
Xem thêm native_acos().
acosh : Cosin hypebol nghịch đảo
float acosh(float v); | |
float2 acosh(float2 v); | |
float3 acosh(float3 v); | |
float4 acosh(float4 v); | |
nửa acosh(một nửa v); | Đã thêm vào API cấp 24 |
half2 acosh(half2 v); | Đã thêm vào API cấp 24 |
half3 acosh(half3 v); | Đã thêm vào API cấp 24 |
half4 acosh(half4 v); | Đã thêm vào API cấp 24 |
Trả về cosin hypebol nghịch đảo, tính bằng radian.
Xem thêm native_acosh().
acospi : Cosin nghịch đảo chia cho pi
float acospi(float v); | |
float2 acospi(float2 v); | |
float3 acospi(float3 v); | |
float4 acospi(float4 v); | |
nửa acospi(một nửa v); | Đã thêm vào API cấp 24 |
half2 acospi(half2 v); | Đã thêm vào API cấp 24 |
half3 acospi(half3 v); | Đã thêm vào API cấp 24 |
half4 acospi(half4 v); | Đã thêm vào API cấp 24 |
Trả về cosin nghịch đảo tính bằng radian, chia cho pi.
Để đo cosin nghịch đảo tính bằng độ, hãy sử dụng acospi(a) * 180.f
.
Xem thêm native_acospi().
asin : Sin nghịch đảo
float asin(float v); | |
float2 asin(float2 v); | |
float3 asin(float3 v); | |
float4 asin(float4 v); | |
nửa asin(một nửa v); | Đã thêm vào API cấp 24 |
half2 asin(half2 v); | Đã thêm vào API cấp 24 |
half3 asin(half3 v); | Đã thêm vào API cấp 24 |
half4 asin(half4 v); | Đã thêm vào API cấp 24 |
Trả về sin nghịch đảo, tính bằng radian.
Hãy xem thêm native_asin().
asinh : Sin hypebol nghịch đảo
float asinh(float v); | |
float2 asinh(float2 v); | |
float3 asinh(float3 v); | |
float4 asinh(float4 v); | |
half asinh(half v); | Đã thêm vào API cấp 24 |
half2 asinh(half2 v); | Đã thêm vào API cấp 24 |
half3 asinh(half3 v); | Đã thêm vào API cấp 24 |
half4 asinh(half4 v); | Đã thêm vào API cấp 24 |
Trả về sin hypebol nghịch đảo, tính bằng radian.
Xem thêm native_asinh().
asinpi : Sin nghịch đảo chia cho pi
float asinpi(float v); | |
float2 asinpi(float2 v); | |
float3 asinpi(float3 v); | |
float4 asinpi(float4 v); | |
nửa asinpi(half v); | Đã thêm vào API cấp 24 |
half2 asinpi(half2 v); | Đã thêm vào API cấp 24 |
half3 asinpi(half3 v); | Đã thêm vào API cấp 24 |
half4 asinpi(half4 v); | Đã thêm vào API cấp 24 |
Trả về sin nghịch đảo theo radian, chia cho pi.
Để đo sin nghịch đảo bằng độ, hãy sử dụng asinpi(a) * 180.f
.
Xem thêm native_asinpi().
atan : Tang nghịch đảo
float atan(float v); | |
float2 atan(float2 v); | |
float3 atan(float3 v); | |
float4 atan(float4 v); | |
nửa atan(half v); | Đã thêm vào API cấp 24 |
half2 atan(half2 v); | Đã thêm vào API cấp 24 |
half3 atan(half3 v); | Đã thêm vào API cấp 24 |
half4 atan(half4 v); | Đã thêm vào API cấp 24 |
Trả về tang nghịch đảo, tính bằng radian.
Xem thêm native_atan().
atan2 : Tang nghịch đảo của tỷ số
float atan2(tử số nổi, mẫu số nổi); | |
float2 atan2(tử số float2, mẫu số float2); | |
float3 atan2(tử số float3, mẫu số float3); | |
float4 atan2(tử số float4, mẫu số float4); | |
nửa atan2(nửa tử số, nửa mẫu số); | Đã thêm vào API cấp 24 |
half2 atan2(tử số nửa2, mẫu số half2); | Đã thêm vào API cấp 24 |
half3 atan2(tử số half3, mẫu số half3); | Đã thêm vào API cấp 24 |
half4 atan2(tử số nửa4, mẫu số nửa4); | Đã thêm vào API cấp 24 |
Tham số
tử số | Tử số. |
---|---|
mẫu số | Mẫu số. Có thể bằng 0. |
Trả về tang nghịch đảo của (numerator / denominator)
, tính bằng radian.
Xem thêm native_atan2().
atan2pi : Tang nghịch đảo của một tỷ số, chia cho pi
float atan2pi(tử số nổi, mẫu số nổi); | |
float2 atan2pi(tử số float2, mẫu số float2); | |
float3 atan2pi(tử số float3, mẫu số float3); | |
float4 atan2pi(tử số float4, mẫu số float4); | |
nửa atan2pi(nửa tử số, nửa mẫu số); | Đã thêm vào API cấp 24 |
half2 atan2pi(tử số nửa2, mẫu số half2); | Đã thêm vào API cấp 24 |
half3 atan2pi(tử số nửa3, mẫu số half3); | Đã thêm vào API cấp 24 |
half4 atan2pi(tử số half4, mẫu số half4); | Đã thêm vào API cấp 24 |
Tham số
tử số | Tử số. |
---|---|
mẫu số | Mẫu số. Có thể bằng 0. |
Trả về tang nghịch đảo của (numerator / denominator)
, tính bằng radian, chia cho pi.
Để tính nghịch đảo của tang theo độ, hãy sử dụng atan2pi(n, d) * 180.f
.
Xem thêm native_atan2pi().
atanh : Tang hyperbol nghịch đảo
float atanh(float v); | |
float2 atanh(float2 v); | |
float3 atanh(float3 v); | |
float4 atanh(float4 v); | |
nửa atanh(một nửa v); | Đã thêm vào API cấp 24 |
half2 atanh(half2 v); | Đã thêm vào API cấp 24 |
half3 atanh(half3 v); | Đã thêm vào API cấp 24 |
half4 atanh(half4 v); | Đã thêm vào API cấp 24 |
Trả về tang hyperbol nghịch đảo, tính bằng radian.
Xem thêm native_atanh().
atanpi : Tang nghịch đảo chia cho pi
float atanpi(float v); | |
float2 atanpi(float2 v); | |
float3 atanpi(float3 v); | |
float4 atanpi(float4 v); | |
nửa atanpi(half v); | Đã thêm vào API cấp 24 |
half2 atanpi(half2 v); | Đã thêm vào API cấp 24 |
half3 atanpi(half3 v); | Đã thêm vào API cấp 24 |
half4 atanpi(half4 v); | Đã thêm vào API cấp 24 |
Trả về tang nghịch đảo theo radian, chia cho pi.
Để tính nghịch đảo của tang theo độ, hãy sử dụng atanpi(a) * 180.f
.
Xem thêm native_atanpi().
cbrt : Căn bậc lập phương
float cbrt(float v); | |
float2 cbrt(float2 v); | |
float3 cbrt(float3 v); | |
float4 cbrt(float4 v); | |
nửa cbrt(half v); | Đã thêm vào API cấp 24 |
half2 cbrt(half2 v); | Đã thêm vào API cấp 24 |
half3 cbrt(half3 v); | Đã thêm vào API cấp 24 |
half4 cbrt(half4 v); | Đã thêm vào API cấp 24 |
Trả về căn bậc ba.
Xem thêm native_cbrt().
ceil : Số nguyên nhỏ nhất không nhỏ hơn một giá trị
độ chính xác đơn ceil(float v); | |
float2 ceil(float2 v); | |
float3 ceil(float3 v); | |
float4 ceil(float4 v); | |
nửa ceil(half v); | Đã thêm vào API cấp 24 |
half2 ceil(half2 v); | Đã thêm vào API cấp 24 |
half3 ceil(half3 v); | Đã thêm vào API cấp 24 |
half4 ceil(half4 v); | Đã thêm vào API cấp 24 |
Trả về số nguyên nhỏ nhất không nhỏ hơn một giá trị.
Ví dụ: ceil(1.2f)
trả về 2.f và ceil(-1.2f)
trả về -1.f.
Xem thêm floor().
clamp : Giới hạn một giá trị trong một phạm vi
kẹp ký tự(giá trị ký tự, giá trị ký tự tối thiểu, giá trị ký tự tối đa); | Đã thêm vào API cấp 19 |
Kẹp char2(giá trị char2, char min_value, char max_value); | Đã thêm vào API cấp 19 |
Kẹp char2(giá trị char2, giá trị tối thiểu char2, giá trị tối đa của char2); | Đã thêm vào API cấp 19 |
Kẹp char3(giá trị char3, char min_value, char max_value); | Đã thêm vào API cấp 19 |
Kẹp char3(giá trị char3, char3 min_value, char3 max_value); | Đã thêm vào API cấp 19 |
Kẹp char4(giá trị char4, char min_value, char max_value); | Đã thêm vào API cấp 19 |
Kẹp char4(giá trị char4, char4 min_value, char4 max_value); | Đã thêm vào API cấp 19 |
kẹp độ chính xác đơn(giá trị số thực, giá trị tối thiểu của số thực dấu phẩy động, giá trị tối đa của số thực dấu phẩy động); | |
Kẹp float2(giá trị float2, giá trị tối thiểu của số thực dấu phẩy động, giá trị tối đa của số thực dấu phẩy động); | |
Kẹp float2(giá trị float2, giá trị tối thiểu của float2, float2 max_value); | |
Kẹp float3(giá trị float3, giá trị tối thiểu của số thực dấu phẩy động, giá trị tối đa của số thực dấu phẩy động tối đa); | |
Kẹp float3(giá trị float3, giá trị tối thiểu của float3, giá trị tối đa của float3); | |
Kẹp float4(giá trị float4, giá trị tối thiểu của số thực dấu phẩy động, giá trị tối đa của số thực dấu phẩy động); | |
Kẹp float4(giá trị float4, giá trị tối thiểu float4, float4 max_value); | |
nửa giá trị kẹp(một nửa giá trị, một nửa giá trị tối thiểu, một nửa giá trị tối đa); | Đã thêm vào API cấp 24 |
half2 kẹp(half2 giá trị, một nửa giá trị tối thiểu, một nửa max_value); | Đã thêm vào API cấp 24 |
half2 kẹp(giá trị half2, giá trị tối thiểu là half2, giá trị tối đa là half2); | Đã thêm vào API cấp 24 |
half3 kẹp(half3 giá trị, một nửa giá trị tối thiểu, một nửa max_value); | Đã thêm vào API cấp 24 |
half3 kẹp(giá trị half3, giá trị tối thiểu half3, giá trị tối đa là half3); | Đã thêm vào API cấp 24 |
half4 kẹp(half4 giá trị, nửa giá trị tối thiểu, nửa_giá_trị_tối_đa); | Đã thêm vào API cấp 24 |
half4 kẹp(giá trị half4, giá trị tối thiểu half4, giá trị tối đa là half4); | Đã thêm vào API cấp 24 |
int clamp(giá trị int, giá trị int min_value, int max_value); | Đã thêm vào API cấp 19 |
int2 Clip(giá trị int2, int min_value, int max_value); | Đã thêm vào API cấp 19 |
int2 clamp(giá trị int2, int2 min_value, int2 max_value); | Đã thêm vào API cấp 19 |
int3 clamp(int3 value, int min_value, int max_value); | Đã thêm vào API cấp 19 |
int3 Clip(giá trị int3, int3 min_value, int3 max_value); | Đã thêm vào API cấp 19 |
int4 clamp(giá trị int4, int min_value, int max_value); | Đã thêm vào API cấp 19 |
int4 clamp(giá trị int4, int4 min_value, int4 max_value); | Đã thêm vào API cấp 19 |
kẹp dài(giá trị dài, giá trị tối thiểu dài, giá trị tối đa dài); | Đã thêm vào API cấp 19 |
Kẹp long2(giá trị long2, giá trị tối thiểu dài, giá trị tối đa dài); | Đã thêm vào API cấp 19 |
long2 Clip(giá trị long2, long2 min_value, long2 max_value); | Đã thêm vào API cấp 19 |
Kẹp long3(giá trị long3, giá trị tối thiểu dài, giá trị tối đa dài); | Đã thêm vào API cấp 19 |
long3 clamp(giá trị long3, long3 min_value, long3 max_value); | Đã thêm vào API cấp 19 |
Kẹp long4(giá trị long4, giá trị tối thiểu dài, giá trị tối đa dài); | Đã thêm vào API cấp 19 |
Kẹp long4(giá trị long4, giá trị tối thiểu long4, giá trị tối đa long4); | Đã thêm vào API cấp 19 |
kẹp ngắn(giá trị ngắn, giá trị tối thiểu ngắn, giá trị tối đa ngắn); | Đã thêm vào API cấp 19 |
Kẹp short2(giá trị short2, giá trị tối thiểu ngắn, giá trị tối đa ngắn); | Đã thêm vào API cấp 19 |
short2 amp(giá trị short2, short2 min_value, short2 max_value); | Đã thêm vào API cấp 19 |
short3 amp(giá trị short3, giá trị tối thiểu ngắn, giá trị tối đa ngắn); | Đã thêm vào API cấp 19 |
short3 clamp(giá trị short3, short3 min_value, short3 max_value); | Đã thêm vào API cấp 19 |
short4 amp(giá trị short4 giá trị, giá trị tối thiểu ngắn, giá trị tối đa ngắn); | Đã thêm vào API cấp 19 |
short4 Clip(giá trị short4, short4 min_value, short4 max_value); | Đã thêm vào API cấp 19 |
uchar clamp(giá trị uchar, uchar min_value, uchar max_value); | Đã thêm vào API cấp 19 |
uchar2 clamp(giá trị uchar2, uchar min_value, uchar max_value); | Đã thêm vào API cấp 19 |
uchar2 clamp(giá trị uchar2, uchar2 min_value, uchar2 max_value); | Đã thêm vào API cấp 19 |
uchar3 clamp(giá trị uchar3, uchar min_value, uchar max_value); | Đã thêm vào API cấp 19 |
uchar3 clamp(giá trị uchar3, uchar3 min_value, uchar3 max_value); | Đã thêm vào API cấp 19 |
uchar4 clamp(giá trị uchar4, uchar min_value, uchar max_value); | Đã thêm vào API cấp 19 |
uchar4 clamp(giá trị uchar4, uchar4 min_value, uchar4 max_value); | Đã thêm vào API cấp 19 |
uint clamp(giá trị uint, uint min_value, uint max_value); | Đã thêm vào API cấp 19 |
uint2 clamp(giá trị uint2, uint min_value, uint max_value); | Đã thêm vào API cấp 19 |
uint2 clamp(giá trị uint2, uint2 min_value, uint2 max_value); | Đã thêm vào API cấp 19 |
uint3 clamp(giá trị uint3, uint min_value, uint max_value); | Đã thêm vào API cấp 19 |
uint3 clamp(giá trị uint3, uint3 min_value, uint3 max_value); | Đã thêm vào API cấp 19 |
uint4 clamp(giá trị uint4, uint min_value, uint max_value); | Đã thêm vào API cấp 19 |
uint4 clamp(giá trị uint4, uint4 min_value, uint4 max_value); | Đã thêm vào API cấp 19 |
ulong kẹp(giá trị ulong, ulong min_value, ulong max_value); | Đã thêm vào API cấp 19 |
ulong2 clamp(giá trị ulong2, ulong min_value, ulong max_value); | Đã thêm vào API cấp 19 |
ulong2 clamp(giá trị ulong2, ulong2 min_value, ulong2 max_value); | Đã thêm vào API cấp 19 |
ulong3 Clip(giá trị ulong3, ulong min_value, ulong max_value); | Đã thêm vào API cấp 19 |
ulong3 clamp(giá trị ulong3, ulong3 min_value, ulong3 max_value); | Đã thêm vào API cấp 19 |
ulong4 Clip(giá trị ulong4, ulong min_value, ulong max_value); | Đã thêm vào API cấp 19 |
ulong4 clamp(giá trị ulong4, ulong4 min_value, ulong4 max_value); | Đã thêm vào API cấp 19 |
ushort clamp(ushort value, ushort min_value, ushort max_value); | Đã thêm vào API cấp 19 |
ushort2 clamp(giá trị ushort2, ushort min_value, ushort max_value); | Đã thêm vào API cấp 19 |
ushort2 clamp(giá trị ushort2, ushort2 min_value, ushort2 max_value); | Đã thêm vào API cấp 19 |
ushort3 clamp(giá trị ushort3, ushort min_value, ushort max_value); | Đã thêm vào API cấp 19 |
ushort3 clamp(giá trị ushort3, ushort3 min_value, ushort3 max_value); | Đã thêm vào API cấp 19 |
ushort4 clamp(giá trị ushort4, ushort min_value, ushort max_value); | Đã thêm vào API cấp 19 |
ushort4 clamp(giá trị ushort4, ushort4 min_value, ushort4 max_value); | Đã thêm vào API cấp 19 |
Tham số
value | Giá trị cần được kẹp. |
---|---|
giá_trị_tối_nhất | Giới hạn dưới, vectơ vô hướng hoặc vectơ phù hợp. |
giá_trị_tối_đa | Giới hạn cao, phải khớp với loại giới hạn thấp. |
Gắn một giá trị vào giới hạn cao và giới hạn thấp đã chỉ định. clamp() trả về min_value nếu giá trị < min_value, max_value nếu giá trị > max_value, nếu không sẽ trả về giá trị.
Có hai biến thể của giá trị kẹp: một biến thể trong đó giá trị tối thiểu và tối đa là các đại lượng vô hướng được áp dụng cho tất cả các mục của giá trị, biến thể còn lại là các vectơ tối thiểu và tối đa.
Nếu giá trị tối thiểu lớn hơn giá trị tối đa thì kết quả không xác định.
clz : Số bit 0 ở đầu
char clz(giá trị char); | |
char2 clz(giá trị char2); | |
char3 clz(giá trị char3); | |
char4 clz(giá trị char4); | |
int clz(giá trị int); | |
int2 clz(giá trị int2); | |
int3 clz(giá trị int3); | |
int4 clz(giá trị int4); | |
clz ngắn(giá trị ngắn); | |
short2 clz(giá trị short2); | |
short3 clz(giá trị short3); | |
short4 clz(giá trị short4); | |
uchar clz(giá trị uchar); | |
uchar2 clz(giá trị uchar2); | |
uchar3 clz(giá trị uchar3); | |
uchar4 clz(giá trị uchar4); | |
uint clz(giá trị uint); | |
uint2 clz(giá trị uint2); | |
uint3 clz(giá trị uint3); | |
uint4 clz(giá trị uint4); | |
ushort clz(giá trị ushort); | |
ushort2 clz(giá trị ushort2); | |
ushort3 clz(giá trị ushort3); | |
ushort4 clz(giá trị ushort4); |
Trả về số bit 0 ở đầu trong một giá trị.
Ví dụ: clz((char)0x03)
trả về 6.
copysign : Sao chép dấu của một số sang một số khác
float copysign(giá_trị_độ_nổi_nổi; giá_trị_của_số_nổi); | |
float2copysign(float2 phê_value, float2 sign_value); | |
float3 sao chép(float3 giá trị độ lớn, giá trị_dấu_hiệu_của float3); | |
float4 copysign(float4 thuê_giá_trị_lớn, float4 sign_value); | |
nửa copysign(một_nửa giá_trị_độ_lớn, một_nửa sign_value); | Đã thêm vào API cấp 24 |
half2 sao chép(half2 giá trị độ lớn; half2 sign_value); | Đã thêm vào API cấp 24 |
half3 sao chép(half3 giá trị cường_độ, half3 sign_value); | Đã thêm vào API cấp 24 |
half4 copysign(half4 phê_value, half4 sign_value); | Đã thêm vào API cấp 24 |
Sao chép dấu từ sign_value đến current_value.
Giá trị được trả về là giá trị độ lớn hoặc giá trị -magnitude_value.
Ví dụ: copysign(4.0f, -2.7f)
trả về -4.0f và copysign(-4.0f, 2.7f)
trả về 4.0f.
cos : Cosin
độ chính xác đơn cos(float v); | |
float2 cos(float2 v); | |
float3 cos(float3 v); | |
float4 cos(float4 v); | |
nửa cos(một nửa v); | Đã thêm vào API cấp 24 |
half2 cos(half2 v); | Đã thêm vào API cấp 24 |
half3 cos(half3 v); | Đã thêm vào API cấp 24 |
half4 cos(half4 v); | Đã thêm vào API cấp 24 |
Trả về cosin của một góc được đo bằng radian.
Hãy xem thêm native_cos().
cosh : Cosh hypebolic
độ chính xác đơn cosh(float v); | |
float2 cosh(float2 v); | |
float3 cosh(float3 v); | |
float4 cosh(float4 v); | |
nửa cosh(half v); | Đã thêm vào API cấp 24 |
half2 cosh(half2 v); | Đã thêm vào API cấp 24 |
half3 cosh(half3 v); | Đã thêm vào API cấp 24 |
half4 cosh(half4 v); | Đã thêm vào API cấp 24 |
Trả về cosin hypebol của v, trong đó v được đo bằng radian.
Hãy xem thêm native_cosh().
cospi : Cosin của một số nhân với pi
float cospi(float v); | |
float2 cospi(float2 v); | |
float3 cospi(float3 v); | |
float4 cospi(float4 v); | |
nửa cospi(một nửa v); | Đã thêm vào API cấp 24 |
half2 cospi(half2 v); | Đã thêm vào API cấp 24 |
half3 cospi(half3 v); | Đã thêm vào API cấp 24 |
half4 cospi(half4 v); | Đã thêm vào API cấp 24 |
Trả về cosin của (v * pi)
, trong đó (v * pi)
được đo bằng radian.
Để tính cosin của một giá trị được đo bằng độ, hãy gọi cospi(v / 180.f)
.
Xem thêm native_cospi().
độ : Chuyển đổi radian thành độ
độ nổi(nổi v); | |
float2 độ(float2 v); | |
float3 độ(float3 v); | |
float4 độ(float4 v); | |
nửa độ(nửa v); | Đã thêm vào API cấp 24 |
half2 độ(half2 v); | Đã thêm vào API cấp 24 |
half3 độ(half3 v); | Đã thêm vào API cấp 24 |
half4 độ(half4 v); | Đã thêm vào API cấp 24 |
Chuyển đổi từ radian sang độ.
erf : Hàm sai số trong toán học
độ chính xác đơn erf(float v); | |
float2 erf(float2 v); | |
float3 erf(float3 v); | |
float4 erf(float4 v); | |
nửa erf(một nửa v); | Đã thêm vào API cấp 24 |
half2 erf(half2 v); | Đã thêm vào API cấp 24 |
half3 erf(half3 v); | Đã thêm vào API cấp 24 |
half4 erf(half4 v); | Đã thêm vào API cấp 24 |
Trả về hàm lỗi.
erfc : Hàm sai số bổ trợ trong toán học
số thực dấu phẩy động erfc(float v); | |
float2 erfc(float2 v); | |
float3 erfc(float3 v); | |
float4 erfc(float4 v); | |
nửa erfc(nửa v); | Đã thêm vào API cấp 24 |
half2 erfc(half2 v); | Đã thêm vào API cấp 24 |
half3 erfc(half3 v); | Đã thêm vào API cấp 24 |
half4 erfc(half4 v); | Đã thêm vào API cấp 24 |
Trả về hàm lỗi bổ sung.
exp : e được nâng lên một số
float exp(float v); | |
float2 exp(float2 v); | |
float3 exp(float3 v); | |
float4 exp(float4 v); | |
half exp(half v); | Đã thêm vào API cấp 24 |
half2 exp(half2 v); | Đã thêm vào API cấp 24 |
half3 exp(half3 v); | Đã thêm vào API cấp 24 |
half4 exp(half4 v); | Đã thêm vào API cấp 24 |
Trả về e được nâng lên v, tức là e ^ v.
Hãy xem thêm native_exp().
exp10 : 10 được nâng lên một số
float exp10(float v); | |
float2 exp10(float2 v); | |
float3 exp10(float3 v); | |
float4 exp10(float4 v); | |
nửa exp10(một nửa v); | Đã thêm vào API cấp 24 |
half2 exp10(half2 v); | Đã thêm vào API cấp 24 |
half3 exp10(half3 v); | Đã thêm vào API cấp 24 |
half4 exp10(half4 v); | Đã thêm vào API cấp 24 |
Trả về 10 được nâng lên v, tức là 10.f ^ v.
Hãy xem thêm native_exp10().
exp2 : 2 được nâng lên một số
float exp2(float v); | |
float2 exp2(float2 v); | |
float3 exp2(float3 v); | |
float4 exp2(float4 v); | |
nửa exp2(một nửa v); | Đã thêm vào API cấp 24 |
half2 exp2(half2 v); | Đã thêm vào API cấp 24 |
half3 exp2(half3 v); | Đã thêm vào API cấp 24 |
half4 exp2(half4 v); | Đã thêm vào API cấp 24 |
Trả về 2 được nâng lên v, tức là 2.f ^ v.
Hãy xem thêm native_exp2().
expm1 : e được nâng lên một số trừ đi một
float expm1(float v); | |
float2 expm1(float2 v); | |
float3 expm1(float3 v); | |
float4 expm1(float4 v); | |
nửa expm1(một nửa v); | Đã thêm vào API cấp 24 |
half2 expm1(half2 v); | Đã thêm vào API cấp 24 |
half3 expm1(half3 v); | Đã thêm vào API cấp 24 |
half4 expm1(half4 v); | Đã thêm vào API cấp 24 |
Trả về e được nâng lên v trừ đi 1, tức là (e ^ v) – 1.
Hãy xem thêm native_expm1().
fab : Giá trị tuyệt đối của số thực
float fAB(float v); | |
float2 fAB(float2 v); | |
float3 fabs(float3 v); | |
float4 fAB(float4 v); | |
nửa fab(half v); | Đã thêm vào API cấp 24 |
half2 fAB(half2 v); | Đã thêm vào API cấp 24 |
half3 fAB(half3 v); | Đã thêm vào API cấp 24 |
half4 fAB(half4 v); | Đã thêm vào API cấp 24 |
Trả về giá trị tuyệt đối của số thực v.
Đối với số nguyên, hãy sử dụng AB().
fdim : Mức chênh lệch dương giữa hai giá trị
float fdim(float a, float b); | |
float2 fdim(float2 a, float2 b); | |
float3 fdim(float3 a, float3 b); | |
float4 fdim(float4 a, float4 b); | |
nửa fdim(một nửa a, một nửa b); | Đã thêm vào API cấp 24 |
half2 fdim(half2 a, half2 b); | Đã thêm vào API cấp 24 |
half3 fdim(half3 a, half3 b); | Đã thêm vào API cấp 24 |
half4 fdim(half4 a, half4 b); | Đã thêm vào API cấp 24 |
Trả về chênh lệch dương giữa hai giá trị.
Nếu a > b thì trả về (a - b), nếu không thì trả về 0f.
sàn : Số nguyên nhỏ nhất không lớn hơn một giá trị
sàn nổi(float v); | |
float2 floor(float2 v); | |
float3 tầng(float3 v); | |
float4 floor(float4 v); | |
nửa tầng(nửa v); | Đã thêm vào API cấp 24 |
half2 tầng(half2 v); | Đã thêm vào API cấp 24 |
half3 sàn(half3 v); | Đã thêm vào API cấp 24 |
half4 tầng(half4 v); | Đã thêm vào API cấp 24 |
Trả về số nguyên nhỏ nhất không lớn hơn một giá trị.
Ví dụ: floor(1.2f)
trả về 1.f và floor(-1.2f)
trả về -2.f.
Xem thêm ceil().
fma : Nhân và cộng
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); | |
nửa fma(một nửa multiplicand1, half multiplicand2, một nửa chênh lệch); | Đã thêm vào API cấp 24 |
half2 fma(half2 multiplicand1, half2 multiplicand2, half2); | Đã thêm vào API cấp 24 |
half3 fma(half3 multiplicand1, half3 multiplicand2, half3); | Đã thêm vào API cấp 24 |
half4 fma(half4 multiplicand1, half4 multiplicand2, half4 chênh lệch); | Đã thêm vào API cấp 24 |
fmax : Tối đa hai số thực
độ chính xác đơn fmax(độ chính xác đơn, độ chính xác đơn 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); | |
nửa fmax(một nửa a, nửa b); | Đã thêm vào API cấp 24 |
half2 fmax(half2 a, half b); | Đã thêm vào API cấp 24 |
half2 fmax(half2 a, half2 b); | Đã thêm vào API cấp 24 |
half3 fmax(half3 a, half b); | Đã thêm vào API cấp 24 |
half3 fmax(half3 a, half3 b); | Đã thêm vào API cấp 24 |
half4 fmax(half4 a, half b); | Đã thêm vào API cấp 24 |
half4 fmax(half4 a, half4 b); | Đã thêm vào API cấp 24 |
Trả về giá trị lớn nhất của a và b, tức là (a < b ? b : a)
.
Hàm max() trả về kết quả giống nhau nhưng có thể áp dụng cho nhiều loại dữ liệu hơn.
fmin : Tối thiểu hai số thực
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); | |
nửa fmin(nửa a, nửa b); | Đã thêm vào API cấp 24 |
half2 fmin(half2 a, half b); | Đã thêm vào API cấp 24 |
half2 fmin(half2 a, half2 b); | Đã thêm vào API cấp 24 |
half3 fmin(half3 a, half b); | Đã thêm vào API cấp 24 |
half3 fmin(half3 a, half3 b); | Đã thêm vào API cấp 24 |
half4 fmin(half4 a, half b); | Đã thêm vào API cấp 24 |
half4 fmin(half4 a, half4 b); | Đã thêm vào API cấp 24 |
Trả về giá trị nhỏ nhất của a và b, tức là (a > b ? b : a)
.
Hàm min() trả về kết quả giống hệt nhau nhưng có thể áp dụng cho nhiều loại dữ liệu hơn.
fmod : Mô-đun
số thực dấu phẩy động(t số số số thực, mẫu số số thực); | |
float2 fmod(tử số float2, mẫu số float2); | |
float3 fmod(tử số float3, mẫu số float3); | |
float4 fmod(tử số float4, mẫu số float4); | |
nửa fmod(nửa tử số, nửa mẫu số); | Đã thêm vào API cấp 24 |
half2 fmod(tử số nửa2; tử số half2); | Đã thêm vào API cấp 24 |
half3 fmod(tử số half3, mẫu số half3); | Đã thêm vào API cấp 24 |
half4 fmod(tử số half4, mẫu số half4); | Đã thêm vào API cấp 24 |
phân số : Phần phân số dương
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); | |
nửa fract(half v); | Đã thêm vào API cấp 24 |
nửa fract(half v, half* sàn); | Đã thêm vào API cấp 24 |
half2 fract(half2 v); | Đã thêm vào API cấp 24 |
half2 fract(half2 v, half2* sàn); | Đã thêm vào API cấp 24 |
half3 fract(half3 v); | Đã thêm vào API cấp 24 |
half3 fract(half3 v, half3* là sàn); | Đã thêm vào API cấp 24 |
half4 fract(half4 v); | Đã thêm vào API cấp 24 |
half4 fract(half4 v, half4* sàn); | Đã thêm vào API cấp 24 |
Tham số
so với | Giá trị nhập. |
---|---|
tầng | Nếu giá sàn không rỗng, *giá sàn sẽ được đặt thành giá sàn của v. |
Trả về phần phân số dương của v, tức là v - floor(v)
.
Ví dụ: fract(1.3f, &val)
trả về 0.3f và đặt val thành 1.f.
fract(-1.3f, &val)
trả về 0.7f và đặt val thành -2.f.
frexp : Số mũ và mantissa nhị phân
float frexp(float v, int* số mũ); | |
float2 frexp(float2 v, int2* số mũ); | |
float3 frexp(float3 v, int3* số mũ); | |
float4 frexp(float4 v, int4* số mũ); | |
nửa frexp(half v, int* số mũ); | Đã thêm vào API cấp 24 |
half2 frexp(half2 v, int2* số mũ); | Đã thêm vào API cấp 24 |
half3 frexp(half3 v, int3* số mũ); | Đã thêm vào API cấp 24 |
half4 frexp(half4 v, int4* số mũ); | Đã thêm vào API cấp 24 |
Tham số
so với | Giá trị nhập. |
---|---|
số mũ | Nếu số mũ không rỗng, *số mũ sẽ được đặt thành số mũ của v. |
half_recip : Giá trị nghịch đảo được tính với độ chính xác 16 bit
float nửa_recip(float v); | Đã thêm vào API cấp 17 |
float2 nửa_recip(float2 v); | Đã thêm vào API cấp 17 |
float3 nửa_recip(float3 v); | Đã thêm vào API cấp 17 |
float4 nửa_recip(float4 v); | Đã thêm vào API cấp 17 |
Trả về nghịch đảo gần đúng của một giá trị.
Độ chính xác là giá trị dấu phẩy động 16 bit.
Xem thêm native_recip().
half_rsqrt : Số nghịch đảo của căn bậc hai được tính với độ chính xác 16 bit
float nửa_rsqrt(float v); | Đã thêm vào API cấp 17 |
float2 nửa_rsqrt(float2 v); | Đã thêm vào API cấp 17 |
float3 nửa_rsqrt(float3 v); | Đã thêm vào API cấp 17 |
float4 nửa_rsqrt(float4 v); | Đã thêm vào API cấp 17 |
Trả về giá trị gần đúng của (1.f / sqrt(value))
.
Độ chính xác là giá trị dấu phẩy động 16 bit.
Xem thêm rsqrt(), native_rsqrt().
half_sqrt : Căn bậc hai được tính với độ chính xác là 16 bit
float nửa_sqrt(float v); | Đã thêm vào API cấp 17 |
float2 nửa_sqrt(float2 v); | Đã thêm vào API cấp 17 |
float3 nửa_sqrt(float3 v); | Đã thêm vào API cấp 17 |
float4 nửa_sqrt(float4 v); | Đã thêm vào API cấp 17 |
Trả về căn bậc hai gần đúng của một giá trị.
Độ chính xác là giá trị dấu phẩy động 16 bit.
Hãy xem thêm sqrt(), native_sqrt().
hypot : Cạnh huyền
float hyt(float a, float b); | |
float2 hyt(float2 a, float2 b); | |
float3 lowt(float3 a, float3 b); | |
float4 hytop(float4 a, float4 b); | |
nửa dưới(một nửa a, nửa b); | Đã thêm vào API cấp 24 |
nửa2 giả thuyết(half2 a, half2 b); | Đã thêm vào API cấp 24 |
half3 giả(half3 a, half3 b); | Đã thêm vào API cấp 24 |
half4 giả mạo(half4 a, half4 b); | Đã thêm vào API cấp 24 |
Trả về cạnh huyền, tức là sqrt(a * a + b * b)
.
Xem thêm native_hypot().
ilogb : Số mũ hai cơ sở
int ilogb(float v); | |
int ilogb(half v); | Đã thêm vào API cấp 24 |
int2 ilogb(float2 v); | |
int2 ilogb(half2 v); | Đã thêm vào API cấp 24 |
int3 ilogb(float3 v); | |
int3 ilogb(half3 v); | Đã thêm vào API cấp 24 |
int4 ilogb(float4 v); | |
int4 ilogb(half4 v); | Đã thêm vào API cấp 24 |
ldexp : Tạo dấu phẩy động từ mantissa và số mũ
float ldexp(nổi mantissa, số mũ int); | |
float2 ldexp(float2 mantissa, int mũ); | |
float2 ldexp(float2 mantissa, int2 số mũ); | |
float3 ldexp(float3 mantissa, int số mũ); | |
float3 ldexp(float3 mantissa, int3 số mũ); | |
float4 ldexp(float4 mantissa, int mũ); | |
float4 ldexp(float4 mantissa, int4 ex); | |
nửa ldexp(một nửa mantissa, số mũ int); | Đã thêm vào API cấp 24 |
half2 ldexp(half2 mantissa, int mũ); | Đã thêm vào API cấp 24 |
half2 ldexp(half2 mantissa, int2 số mũ); | Đã thêm vào API cấp 24 |
half3 ldexp(half3 mantissa, int mũ); | Đã thêm vào API cấp 24 |
half3 ldexp(half3 mantissa, int3 số mũ); | Đã thêm vào API cấp 24 |
half4 ldexp(half4 mantissa, int mũ); | Đã thêm vào API cấp 24 |
half4 ldexp(half4 mantissa, int4 số mũ); | Đã thêm vào API cấp 24 |
Tham số
hoa mantissa | Vải Mantissa. |
---|---|
số mũ | Số mũ, một thành phần đơn hoặc vectơ phù hợp. |
Trả về dấu phẩy động được tạo từ mantissa và số mũ, tức là (số mũ mantissa * 2 ^).
Hãy xem frexp() để biết thao tác đảo ngược.
lgamma : Lôgarit tự nhiên của hàm gamma
độ chính xác đơn lgamma(float v); | |
độ chính xác đơn 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); | |
nửa lgamma(nửa v); | Đã thêm vào API cấp 24 |
half lgamma(half v, int* sign_of_gamma); | Đã thêm vào API cấp 24 |
half2 lgamma(half2 v); | Đã thêm vào API cấp 24 |
half2 lgamma(half2 v, int2* sign_of_gamma); | Đã thêm vào API cấp 24 |
half3 lgamma(half3 v); | Đã thêm vào API cấp 24 |
half3 lgamma(half3 v, int3* sign_of_gamma); | Đã thêm vào API cấp 24 |
half4 lgamma(half4 v); | Đã thêm vào API cấp 24 |
half4 lgamma(half4 v, int4* sign_of_gamma); | Đã thêm vào API cấp 24 |
Tham số
so với | |
---|---|
dấu_của_gamma | Nếu sign_of_gamma không rỗng, *sign_of_gamma sẽ được thiết lập thành -1.f nếu giá trị gamma của v là giá trị âm, nếu không thì sẽ là 1.f. |
log : Lôgarit tự nhiên
float log(float v); | |
float2 log(float2 v); | |
float3 nhật ký(float3 v); | |
float4 log(float4 v); | |
nửa log(half v); | Đã thêm vào API cấp 24 |
half2 log(half2 v); | Đã thêm vào API cấp 24 |
half3 log(half3 v); | Đã thêm vào API cấp 24 |
half4 log(half4 v); | Đã thêm vào API cấp 24 |
Trả về lôgarit tự nhiên.
Hãy xem thêm native_log().
log10 : Lôgarit cơ số 10
float log10(float v); | |
float2 log10(float2 v); | |
float3 log10(float3 v); | |
float4 log10(float4 v); | |
nửa log10(một nửa v); | Đã thêm vào API cấp 24 |
half2 log10(half2 v); | Đã thêm vào API cấp 24 |
half3 log10(half3 v); | Đã thêm vào API cấp 24 |
half4 log10(half4 v); | Đã thêm vào API cấp 24 |
Trả về lôgarit cơ số 10.
Xem thêm native_log10().
log1p : Lôgarit tự nhiên của một giá trị cộng 1
float log1p(float v); | |
float2 log1p(float2 v); | |
float3 log1p(float3 v); | |
float4 log1p(float4 v); | |
nửa log1p(một nửa v); | Đã thêm vào API cấp 24 |
half2 log1p(half2 v); | Đã thêm vào API cấp 24 |
half3 log1p(half3 v); | Đã thêm vào API cấp 24 |
half4 log1p(half4 v); | Đã thêm vào API cấp 24 |
Trả về lôgarit tự nhiên của (v + 1.f)
.
Hãy xem thêm native_log1p().
log2 : Lôgarit cơ số 2
float log2(float v); | |
float2 log2(float2 v); | |
float3 log2(float3 v); | |
float4 log2(float4 v); | |
nửa log2(một nửa v); | Đã thêm vào API cấp 24 |
half2 log2(half2 v); | Đã thêm vào API cấp 24 |
half3 log2(half3 v); | Đã thêm vào API cấp 24 |
half4 log2(half4 v); | Đã thêm vào API cấp 24 |
Trả về lôgarit cơ số 2.
Hãy xem thêm native_log2().
logb : Số mũ hai cơ sở
độ chính xác đơn logb(float v); | |
float2 logb(float2 v); | |
float3 logb(float3 v); | |
float4 logb(float4 v); | |
nửa logb(half v); | Đã thêm vào API cấp 24 |
half2 logb(half2 v); | Đã thêm vào API cấp 24 |
half3 logb(half3 v); | Đã thêm vào API cấp 24 |
half4 logb(half4 v); | Đã thêm vào API cấp 24 |
Trả về số mũ cơ số hai của một giá trị, trong đó mantissa nằm trong khoảng từ 1.f (bao gồm) đến 2.f (loại trừ).
Ví dụ: logb(8.5f)
trả về 3.f.
Do sự khác biệt về mantissa, số này nhỏ hơn một so với được trả về bởi frexp().
ilogb() tương tự nhưng trả về một số nguyên.
mad : Nhân và cộng
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); | |
nửa điên(nửa đa nhân1, nửa đaplicand2, bù trừ một nửa); | Đã thêm vào API cấp 24 |
half2 mad(half2 multiplicand1, half2 multiplicand2, half2 offset); | Đã thêm vào API cấp 24 |
half3 mad(half3 multiplicand1, half3 multiplicand2, half3 offset); | Đã thêm vào API cấp 24 |
half4 mad(half4 multiplicand1, half4 multiplicand2, half4 offset); | Đã thêm vào API cấp 24 |
Nhân và cộng. Trả về (multiplicand1 * multiplicand2) + offset
.
Hàm này tương tự như fma(). fma() giữ nguyên độ chính xác đầy đủ của kết quả đã nhân và chỉ làm tròn sau khi thêm. mad() làm tròn sau khi nhân và cộng. Ở chế độ rs_FP_relaxed, mad() có thể không thực hiện việc làm tròn sau multiplicaiton.
tối đa : Tối đa
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); | |
nửa tối đa(một nửa a, nửa b); | Đã thêm vào API cấp 24 |
half2 max(half2 a, half b); | Đã thêm vào API cấp 24 |
half2 max(half2 a, half2 b); | Đã thêm vào API cấp 24 |
half3 max(half3 a, half b); | Đã thêm vào API cấp 24 |
half3 max(half3 a, half3 b); | Đã thêm vào API cấp 24 |
half4 max(half4 a, half b); | Đã thêm vào API cấp 24 |
half4 max(half4 a, half4 b); | Đã thêm vào API cấp 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); | Đã thêm vào API cấp 21 |
long2 max(long2 a, long2 b); | Đã thêm vào API cấp 21 |
long3 max(long3 a, long3 b); | Đã thêm vào API cấp 21 |
long4 max(long4 a, long4 b); | Đã thêm vào API cấp 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); | Đã thêm vào API cấp 21 |
ulong2 max(ulong2 a, ulong2 b); | Đã thêm vào API cấp 21 |
ulong3 max(ulong3 a, ulong3 b); | Đã thêm vào API cấp 21 |
ulong4 max(ulong4 a, ulong4 b); | Đã thêm vào API cấp 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); |
Trả về giá trị lớn nhất của hai đối số.
tối thiểu : Tối thiểu
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 phút(float2 a, float b); | |
float2 phút(float2 a, float2 b); | |
float3 phút(float3 a, float b); | |
float3 phút(float3 a, float3 b); | |
float4 phút(float4 a, float b); | |
float4 phút(float4 a, float4 b); | |
nửa phút(một nửa a, nửa b); | Đã thêm vào API cấp 24 |
half2 phút(half2 a, half b); | Đã thêm vào API cấp 24 |
half2 phút(half2 a, half2 b); | Đã thêm vào API cấp 24 |
half3 phút(half3 a, half b); | Đã thêm vào API cấp 24 |
half3 phút(half3 a, half3 b); | Đã thêm vào API cấp 24 |
half4 phút(half4 a, half b); | Đã thêm vào API cấp 24 |
half4 phút(half4 a, half4 b); | Đã thêm vào API cấp 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); | Đã thêm vào API cấp 21 |
long2 phút(long2 a, long2 b); | Đã thêm vào API cấp 21 |
long3 phút(long3 a, long3 b); | Đã thêm vào API cấp 21 |
long4 phút(long4 a, long4 b); | Đã thêm vào API cấp 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); | Đã thêm vào API cấp 21 |
ulong2 min(ulong2 a, ulong2 b); | Đã thêm vào API cấp 21 |
ulong3 min(ulong3 a, ulong3 b); | Đã thêm vào API cấp 21 |
ulong4 min(ulong4 a, ulong4 b); | Đã thêm vào API cấp 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); |
Trả về giá trị nhỏ nhất của hai đối số.
kết hợp : Kết hợp hai giá trị
kết hợp số thực(bắt đầu số thực, điểm dừng nổi, phân số số thực); | |
float2 hỗn hợp(bắt đầu float2, dừng float2, phân số dấu phẩy động); | |
Kết hợp float2(bắt đầu float2, dừng float2, phân số float2); | |
Kết hợp float3(bắt đầu float3, dừng float3, phân số dấu phẩy động); | |
float3 kết hợp(bắt đầu float3, dừng float3, phân số float3); | |
Kết hợp float4(bắt đầu float4, dừng float4, phân số dấu phẩy động); | |
float4 kết hợp(bắt đầu float4, dừng float4, phân số float4); | |
nửa kết hợp(một nửa bắt đầu, một nửa dừng, một nửa phân số); | Đã thêm vào API cấp 24 |
kết hợp half2(bắt đầu half2, half2 dừng, phân số nửa); | Đã thêm vào API cấp 24 |
kết hợp half2(bắt đầu half2, dừng half2, phân số half2); | Đã thêm vào API cấp 24 |
kết hợp half3(half3 bắt đầu, half3 dừng, phân số nửa); | Đã thêm vào API cấp 24 |
kết hợp half3(bắt đầu half3, dừng half3, phân số half3); | Đã thêm vào API cấp 24 |
kết hợp half4(half4 bắt đầu, half4 dừng, nửa phân số); | Đã thêm vào API cấp 24 |
Kết hợp half4(bắt đầu half4, dừng half4, phân đoạn half4); | Đã thêm vào API cấp 24 |
Trả về bắt đầu + ((dừng - bắt đầu) * phân số).
Cách này có thể hữu ích khi kết hợp hai giá trị. Ví dụ: để tạo màu mới là 40% color1 và 60% color2, hãy sử dụng mix(color1, color2, 0.6f)
.
modf : Thành phần tích phân và phân số
độ chính xác đơn modf(float v, float* phần_tích_hợp); | |
float2 modf(float2 v, float2* variable_part); | |
float3 modf(float3 v, float3* Integration_part); | |
float4 modf(float4 v, float4* centimeters_part); | |
nửa modf(một nửa v, half* phần_tích_hợp); | Đã thêm vào API cấp 24 |
half2 modf(half2 v, half2* từng_phần); | Đã thêm vào API cấp 24 |
half3 modf(half3 v, half3* từng_phần); | Đã thêm vào API cấp 24 |
half4 modf(half4 v, half4* từng_phần); | Đã thêm vào API cấp 24 |
Tham số
so với | Giá trị nguồn. |
---|---|
phần_tích_ phân | *phần_tích_hợp sẽ được đặt thành phần tích phân của số. |
Giá trị trả về
Phần dấu phẩy động của giá trị. |
Trả về thành phần tích phân và phân số của một số.
Cả hai thành phần sẽ có cùng ký hiệu là x. Ví dụ: Đối với giá trị đầu vào là -3.72f, *integral_part sẽ được đặt thành -3.f và .72f sẽ được trả về.
nan : Không phải số
float nan(uint v); |
Tham số
so với | Không được sử dụng. |
---|
Trả về giá trị NaN (Không phải là số).
nan_half : Không phải là số
half nan_half() | Đã thêm vào API cấp 24 |
Trả về giá trị NaN có dấu phẩy động với độ bán chính xác (Không phải là số).
native_acos : Cosin nghịch đảo gần đúng
float native_acos(float v); | Đã thêm vào API cấp 21 |
float2 native_acos(float2 v); | Đã thêm vào API cấp 21 |
float3 native_acos(float3 v); | Đã thêm vào API cấp 21 |
float4 native_acos(float4 v); | Đã thêm vào API cấp 21 |
nửa native_acos(một nửa v); | Đã thêm vào API cấp 24 |
half2 native_acos(half2 v); | Đã thêm vào API cấp 24 |
half3 native_acos(half3 v); | Đã thêm vào API cấp 24 |
half4 native_acos(half4 v); | Đã thêm vào API cấp 24 |
Trả về cosin nghịch đảo gần đúng, tính bằng radian.
Hàm này trả lại kết quả không xác định từ các giá trị đầu vào nhỏ hơn -1 hoặc lớn hơn 1.
Xem thêm acos().
native_acosh : Cosin hypebol nghịch đảo gần đúng
float native_acosh(float v); | Đã thêm vào API cấp 21 |
float2 native_acosh(float2 v); | Đã thêm vào API cấp 21 |
float3 native_acosh(float3 v); | Đã thêm vào API cấp 21 |
float4 native_acosh(float4 v); | Đã thêm vào API cấp 21 |
half native_acosh(half v); | Đã thêm vào API cấp 24 |
half2 native_acosh(half2 v); | Đã thêm vào API cấp 24 |
half3 native_acosh(half3 v); | Đã thêm vào API cấp 24 |
half4 native_acosh(half4 v); | Đã thêm vào API cấp 24 |
Trả về cosin hypebol nghịch đảo gần đúng, tính bằng radian.
Xem thêm acosh().
native_acospi : Giá trị cosin nghịch đảo gần đúng chia cho pi
float native_acospi(float v); | Đã thêm vào API cấp 21 |
float2 native_acospi(float2 v); | Đã thêm vào API cấp 21 |
float3 native_acospi(float3 v); | Đã thêm vào API cấp 21 |
float4 native_acospi(float4 v); | Đã thêm vào API cấp 21 |
half native_acospi(half v); | Đã thêm vào API cấp 24 |
half2 native_acospi(half2 v); | Đã thêm vào API cấp 24 |
half3 native_acospi(half3 v); | Đã thêm vào API cấp 24 |
half4 native_acospi(half4 v); | Đã thêm vào API cấp 24 |
Trả về cosin nghịch đảo gần đúng tính bằng radian, chia cho pi.
Để đo cosin nghịch đảo tính bằng độ, hãy sử dụng acospi(a) * 180.f
.
Hàm này trả lại kết quả không xác định từ các giá trị đầu vào nhỏ hơn -1 hoặc lớn hơn 1.
Xem thêm acospi().
native_asin : Sin nghịch đảo gần đúng
float native_asin(float v); | Đã thêm vào API cấp 21 |
float2 native_asin(float2 v); | Đã thêm vào API cấp 21 |
float3 native_asin(float3 v); | Đã thêm vào API cấp 21 |
float4 native_asin(float4 v); | Đã thêm vào API cấp 21 |
half native_asin(half v); | Đã thêm vào API cấp 24 |
half2 native_asin(half2 v); | Đã thêm vào API cấp 24 |
half3 native_asin(half3 v); | Đã thêm vào API cấp 24 |
half4 native_asin(half4 v); | Đã thêm vào API cấp 24 |
Trả về sin nghịch đảo gần đúng, tính bằng radian.
Hàm này trả lại kết quả không xác định từ các giá trị đầu vào nhỏ hơn -1 hoặc lớn hơn 1.
Xem thêm asin().
native_asinh : Sin hypebol nghịch đảo gần đúng
float native_asinh(float v); | Đã thêm vào API cấp 21 |
float2 native_asinh(float2 v); | Đã thêm vào API cấp 21 |
float3 native_asinh(float3 v); | Đã thêm vào API cấp 21 |
float4 native_asinh(float4 v); | Đã thêm vào API cấp 21 |
half native_asinh(half v); | Đã thêm vào API cấp 24 |
half2 native_asinh(half2 v); | Đã thêm vào API cấp 24 |
half3 native_asinh(half3 v); | Đã thêm vào API cấp 24 |
half4 native_asinh(half4 v); | Đã thêm vào API cấp 24 |
Trả về sin hypebol nghịch đảo gần đúng, tính bằng radian.
Xem thêm asinh().
native_asinpi : Giá trị sin nghịch đảo gần đúng chia cho pi
float native_asinpi(float v); | Đã thêm vào API cấp 21 |
float2 native_asinpi(float2 v); | Đã thêm vào API cấp 21 |
float3 native_asinpi(float3 v); | Đã thêm vào API cấp 21 |
float4 native_asinpi(float4 v); | Đã thêm vào API cấp 21 |
half native_asinpi(half v); | Đã thêm vào API cấp 24 |
half2 native_asinpi(half2 v); | Đã thêm vào API cấp 24 |
half3 native_asinpi(half3 v); | Đã thêm vào API cấp 24 |
half4 native_asinpi(half4 v); | Đã thêm vào API cấp 24 |
Trả về sin nghịch đảo gần đúng tính bằng radian, chia cho pi.
Để đo sin nghịch đảo bằng độ, hãy sử dụng asinpi(a) * 180.f
.
Hàm này trả lại kết quả không xác định từ các giá trị đầu vào nhỏ hơn -1 hoặc lớn hơn 1.
Xem thêm asinpi().
native_atan : Tang nghịch đảo gần đúng
float native_atan(float v); | Đã thêm vào API cấp 21 |
float2 native_atan(float2 v); | Đã thêm vào API cấp 21 |
float3 native_atan(float3 v); | Đã thêm vào API cấp 21 |
float4 native_atan(float4 v); | Đã thêm vào API cấp 21 |
nửa native_atan(một nửa v); | Đã thêm vào API cấp 24 |
half2 native_atan(half2 v); | Đã thêm vào API cấp 24 |
half3 native_atan(half3 v); | Đã thêm vào API cấp 24 |
half4 native_atan(half4 v); | Đã thêm vào API cấp 24 |
Trả về tang nghịch đảo gần đúng, tính bằng radian.
Xem thêm atan().
native_atan2 : Tang nghịch đảo gần đúng của một tỷ lệ
float native_atan2(tử số nổi, mẫu số nổi); | Đã thêm vào API cấp 21 |
float2 native_atan2(tử số float2, mẫu số float2); | Đã thêm vào API cấp 21 |
float3 native_atan2(tử số float3, mẫu số float3); | Đã thêm vào API cấp 21 |
float4 native_atan2(tử số float4, mẫu số float4); | Đã thêm vào API cấp 21 |
một nửa native_atan2(một nửa tử số, một nửa mẫu số); | Đã thêm vào API cấp 24 |
half2 native_atan2(tử số half2, mẫu số half2); | Đã thêm vào API cấp 24 |
half3 native_atan2(tử số half3, mẫu số half3); | Đã thêm vào API cấp 24 |
half4 native_atan2(tử số half4, mẫu số half4); | Đã thêm vào API cấp 24 |
Tham số
tử số | Tử số. |
---|---|
mẫu số | Mẫu số. Có thể bằng 0. |
Trả về tang nghịch đảo gần đúng của (numerator / denominator)
, tính bằng radian.
Xem thêm atan2().
native_atan2pi : Tang nghịch đảo gần đúng của một tỷ lệ, chia cho pi
float native_atan2pi(tử số nổi, mẫu số nổi); | Đã thêm vào API cấp 21 |
float2 native_atan2pi(tử số float2, mẫu số float2); | Đã thêm vào API cấp 21 |
float3 native_atan2pi(tử số float3, mẫu số float3); | Đã thêm vào API cấp 21 |
float4 native_atan2pi(tử số float4, mẫu số float4); | Đã thêm vào API cấp 21 |
nửa native_atan2pi(một nửa tử số, một nửa mẫu số); | Đã thêm vào API cấp 24 |
half2 native_atan2pi(tử số half2, mẫu số half2); | Đã thêm vào API cấp 24 |
half3 native_atan2pi(tử số half3, mẫu số half3); | Đã thêm vào API cấp 24 |
half4 native_atan2pi(tử số half4, mẫu số half4); | Đã thêm vào API cấp 24 |
Tham số
tử số | Tử số. |
---|---|
mẫu số | Mẫu số. Có thể bằng 0. |
Trả về tang nghịch đảo gần đúng của (numerator / denominator)
, tính bằng radian, chia cho pi.
Để tính nghịch đảo của tang theo độ, hãy sử dụng atan2pi(n, d) * 180.f
.
Xem thêm atan2pi().
native_atanh : tang hyperbol nghịch đảo gần đúng
float native_atanh(float v); | Đã thêm vào API cấp 21 |
float2 native_atanh(float2 v); | Đã thêm vào API cấp 21 |
float3 native_atanh(float3 v); | Đã thêm vào API cấp 21 |
float4 native_atanh(float4 v); | Đã thêm vào API cấp 21 |
half native_atanh(half v); | Đã thêm vào API cấp 24 |
half2 native_atanh(half2 v); | Đã thêm vào API cấp 24 |
half3 native_atanh(half3 v); | Đã thêm vào API cấp 24 |
half4 native_atanh(half4 v); | Đã thêm vào API cấp 24 |
Trả về tang hyperbol nghịch đảo gần đúng, tính bằng radian.
Xem thêm atanh().
native_atanpi : Số tiếp tuyến nghịch đảo gần đúng chia cho pi
float native_atanpi(float v); | Đã thêm vào API cấp 21 |
float2 native_atanpi(float2 v); | Đã thêm vào API cấp 21 |
float3 native_atanpi(float3 v); | Đã thêm vào API cấp 21 |
float4 native_atanpi(float4 v); | Đã thêm vào API cấp 21 |
half native_atanpi(half v); | Đã thêm vào API cấp 24 |
half2 native_atanpi(half2 v); | Đã thêm vào API cấp 24 |
half3 native_atanpi(half3 v); | Đã thêm vào API cấp 24 |
half4 native_atanpi(half4 v); | Đã thêm vào API cấp 24 |
Trả về tang nghịch đảo gần đúng tính bằng radian, chia cho pi.
Để tính nghịch đảo của tang theo độ, hãy sử dụng atanpi(a) * 180.f
.
Xem thêm atanpi().
native_cbrt : Căn bậc ba gần đúng
float native_cbrt(float v); | Đã thêm vào API cấp 21 |
float2 native_cbrt(float2 v); | Đã thêm vào API cấp 21 |
float3 native_cbrt(float3 v); | Đã thêm vào API cấp 21 |
float4 native_cbrt(float4 v); | Đã thêm vào API cấp 21 |
half native_cbrt(half v); | Đã thêm vào API cấp 24 |
half2 native_cbrt(half2 v); | Đã thêm vào API cấp 24 |
half3 native_cbrt(half3 v); | Đã thêm vào API cấp 24 |
half4 native_cbrt(half4 v); | Đã thêm vào API cấp 24 |
Trả về căn bậc ba gần đúng.
Xem thêm cbrt().
native_cos : Cosin gần đúng
float native_cos(float v); | Đã thêm vào API cấp 21 |
float2 native_cos(float2 v); | Đã thêm vào API cấp 21 |
float3 native_cos(float3 v); | Đã thêm vào API cấp 21 |
float4 native_cos(float4 v); | Đã thêm vào API cấp 21 |
nửa native_cos(một nửa v); | Đã thêm vào API cấp 24 |
half2 native_cos(half2 v); | Đã thêm vào API cấp 24 |
half3 native_cos(half3 v); | Đã thêm vào API cấp 24 |
half4 native_cos(half4 v); | Đã thêm vào API cấp 24 |
Trả về cosin gần đúng của một góc được đo bằng radian.
Xem thêm cos().
native_cosh : Cosin tăng cường gần đúng
float native_cosh(float v); | Đã thêm vào API cấp 21 |
float2 native_cosh(float2 v); | Đã thêm vào API cấp 21 |
float3 native_cosh(float3 v); | Đã thêm vào API cấp 21 |
float4 native_cosh(float4 v); | Đã thêm vào API cấp 21 |
nửa native_cosh(một nửa v); | Đã thêm vào API cấp 24 |
half2 native_cosh(half2 v); | Đã thêm vào API cấp 24 |
half3 native_cosh(half3 v); | Đã thêm vào API cấp 24 |
half4 native_cosh(half4 v); | Đã thêm vào API cấp 24 |
Trả về cosin hypebbol gần đúng.
Xem thêm cosh().
native_cospi : Cosin gần đúng của một số nhân với pi
float native_cospi(float v); | Đã thêm vào API cấp 21 |
float2 native_cospi(float2 v); | Đã thêm vào API cấp 21 |
float3 native_cospi(float3 v); | Đã thêm vào API cấp 21 |
float4 native_cospi(float4 v); | Đã thêm vào API cấp 21 |
nửa native_cospi(một nửa v); | Đã thêm vào API cấp 24 |
half2 native_cospi(half2 v); | Đã thêm vào API cấp 24 |
half3 native_cospi(half3 v); | Đã thêm vào API cấp 24 |
half4 native_cospi(half4 v); | Đã thêm vào API cấp 24 |
Trả về cosin gần đúng của (v * pi), trong đó (v * pi) được đo bằng radian.
Để tính cosin của một giá trị được đo bằng độ, hãy gọi cospi(v / 180.f)
.
Xem thêm cospi().
native_divide : Phép chia gần đúng
float native_divide(float_vectơ bên trái, float_vectơ bên phải); | Đã thêm vào API cấp 21 |
float2 native_divide(float2 left_vectơ, float2 phải_vectơ); | Đã thêm vào API cấp 21 |
float3 native_divide(float3 left_ vector, float3 right_vectơ); | Đã thêm vào API cấp 21 |
float4 native_divide(float4 left_vectơ, float4 phải_vectơ); | Đã thêm vào API cấp 21 |
một nửa native_divide(một nửa vectơ_trái_phải, nửa_vec_tơ_bên phải); | Đã thêm vào API cấp 24 |
half2 native_divide(half2 left_vectơ, half2 bên phải_vectơ); | Đã thêm vào API cấp 24 |
half3 native_divide(half3 bên trái vectơ, half3 bên phải_vectơ); | Đã thêm vào API cấp 24 |
half4 native_divide(half4 bên trái_vectơ, half4 bên phải_vectơ); | Đã thêm vào API cấp 24 |
Tính toán phép chia gần đúng của hai giá trị.
native_exp : Giá trị e gần đúng được nâng lên một số
float native_exp(float v); | Đã thêm vào API cấp 18 |
float2 native_exp(float2 v); | Đã thêm vào API cấp 18 |
float3 native_exp(float3 v); | Đã thêm vào API cấp 18 |
float4 native_exp(float4 v); | Đã thêm vào API cấp 18 |
nửa native_exp(một nửa v); | Đã thêm vào API cấp 24 |
half2 native_exp(half2 v); | Đã thêm vào API cấp 24 |
half3 native_exp(half3 v); | Đã thêm vào API cấp 24 |
half4 native_exp(half4 v); | Đã thêm vào API cấp 24 |
Trải nghiệm gần đúng nhanh
Nó hợp lệ cho các đầu vào từ -86.f đến 86.f. Độ chính xác không kém hơn mức có thể khi sử dụng giá trị dấu phẩy động 16 bit.
Hãy xem thêm exp().
native_exp10 : Giá trị khoảng 10 được nâng lên một số
float native_exp10(float v); | Đã thêm vào API cấp 18 |
float2 native_exp10(float2 v); | Đã thêm vào API cấp 18 |
float3 native_exp10(float3 v); | Đã thêm vào API cấp 18 |
float4 native_exp10(float4 v); | Đã thêm vào API cấp 18 |
nửa native_exp10(một nửa v); | Đã thêm vào API cấp 24 |
half2 native_exp10(half2 v); | Đã thêm vào API cấp 24 |
half3 native_exp10(half3 v); | Đã thêm vào API cấp 24 |
half4 native_exp10(half4 v); | Đã thêm vào API cấp 24 |
Biểu thức 10 gần đúng.
Nó hợp lệ cho đầu vào từ -37.f đến 37.f. Độ chính xác không kém hơn mức có thể khi sử dụng giá trị dấu phẩy động 16 bit.
Hãy xem thêm exp10().
native_exp2 : Giá trị gần đúng 2 được nâng lên một số
float native_exp2(float v); | Đã thêm vào API cấp 18 |
float2 native_exp2(float2 v); | Đã thêm vào API cấp 18 |
float3 native_exp2(float3 v); | Đã thêm vào API cấp 18 |
float4 native_exp2(float4 v); | Đã thêm vào API cấp 18 |
nửa native_exp2(một nửa v); | Đã thêm vào API cấp 24 |
half2 native_exp2(half2 v); | Đã thêm vào API cấp 24 |
half3 native_exp2(half3 v); | Đã thêm vào API cấp 24 |
half4 native_exp2(half4 v); | Đã thêm vào API cấp 24 |
Trải nghiệm gần đúng 2.
Nó hợp lệ cho đầu vào từ -125.f đến 125.f. Độ chính xác không kém hơn mức có thể khi sử dụng giá trị dấu phẩy động 16 bit.
Hãy xem thêm exp2().
native_expm1 : Giá trị e gần đúng được nâng lên một số trừ đi một
float native_expm1(float v); | Đã thêm vào API cấp 21 |
float2 native_expm1(float2 v); | Đã thêm vào API cấp 21 |
float3 native_expm1(float3 v); | Đã thêm vào API cấp 21 |
float4 native_expm1(float4 v); | Đã thêm vào API cấp 21 |
nửa native_expm1(một nửa v); | Đã thêm vào API cấp 24 |
half2 native_expm1(half2 v); | Đã thêm vào API cấp 24 |
half3 native_expm1(half3 v); | Đã thêm vào API cấp 24 |
half4 native_expm1(half4 v); | Đã thêm vào API cấp 24 |
Trả về giá trị gần đúng (e ^ v) – 1.
Hãy xem thêm expm1().
native_hypot : Cạnh huyền gần đúng
float native_hypot(float a, float b); | Đã thêm vào API cấp 21 |
float2 native_hypot(float2 a, float2 b); | Đã thêm vào API cấp 21 |
float3 native_hypot(float3 a, float3 b); | Đã thêm vào API cấp 21 |
float4 native_hypot(float4 a, float4 b); | Đã thêm vào API cấp 21 |
nửa native_hypot(một nửa a, một nửa b); | Đã thêm vào API cấp 24 |
half2 native_hypot(half2 a, half2 b); | Đã thêm vào API cấp 24 |
half3 native_hypot(half3 a, half3 b); | Đã thêm vào API cấp 24 |
half4 native_hypot(half4 a, half4 b); | Đã thêm vào API cấp 24 |
Trả về native_sqrt gần đúng(a * a + b * b)
Xem thêm hypot().
native_log : Lôgarit tự nhiên gần đúng
float native_log(float v); | Đã thêm vào API cấp 18 |
float2 native_log(float2 v); | Đã thêm vào API cấp 18 |
float3 native_log(float3 v); | Đã thêm vào API cấp 18 |
float4 native_log(float4 v); | Đã thêm vào API cấp 18 |
nửa native_log(một nửa v); | Đã thêm vào API cấp 24 |
half2 native_log(half2 v); | Đã thêm vào API cấp 24 |
half3 native_log(half3 v); | Đã thêm vào API cấp 24 |
half4 native_log(half4 v); | Đã thêm vào API cấp 24 |
native_log10 : Lôgarit cơ số 10 gần đúng
float native_log10(float v); | Đã thêm vào API cấp 18 |
float2 native_log10(float2 v); | Đã thêm vào API cấp 18 |
float3 native_log10(float3 v); | Đã thêm vào API cấp 18 |
float4 native_log10(float4 v); | Đã thêm vào API cấp 18 |
nửa native_log10(một nửa v); | Đã thêm vào API cấp 24 |
half2 native_log10(half2 v); | Đã thêm vào API cấp 24 |
half3 native_log10(half3 v); | Đã thêm vào API cấp 24 |
half4 native_log10(half4 v); | Đã thêm vào API cấp 24 |
native_log1p : Lôgarit tự nhiên gần đúng của một giá trị cộng 1
float native_log1p(float v); | Đã thêm vào API cấp 21 |
float2 native_log1p(float2 v); | Đã thêm vào API cấp 21 |
float3 native_log1p(float3 v); | Đã thêm vào API cấp 21 |
float4 native_log1p(float4 v); | Đã thêm vào API cấp 21 |
nửa native_log1p(một nửa v); | Đã thêm vào API cấp 24 |
half2 native_log1p(half2 v); | Đã thêm vào API cấp 24 |
half3 native_log1p(half3 v); | Đã thêm vào API cấp 24 |
half4 native_log1p(half4 v); | Đã thêm vào API cấp 24 |
Trả về lôgarit tự nhiên gần đúng của (v + 1.0f)
Hãy xem thêm log1p().
native_log2 : Lôgarit cơ số 2 gần đúng
float native_log2(float v); | Đã thêm vào API cấp 18 |
float2 native_log2(float2 v); | Đã thêm vào API cấp 18 |
float3 native_log2(float3 v); | Đã thêm vào API cấp 18 |
float4 native_log2(float4 v); | Đã thêm vào API cấp 18 |
nửa native_log2(một nửa v); | Đã thêm vào API cấp 24 |
half2 native_log2(half2 v); | Đã thêm vào API cấp 24 |
half3 native_log2(half3 v); | Đã thêm vào API cấp 24 |
half4 native_log2(half4 v); | Đã thêm vào API cấp 24 |
native_powr : Số cơ số dương gần đúng được nâng lên số mũ
float native_powr(cơ sở số thực, số mũ nổi); | Đã thêm vào API cấp 18 |
float2 native_powr(cơ sở float2, số mũ float2); | Đã thêm vào API cấp 18 |
float3 native_powr(cơ sở float3, số mũ float3); | Đã thêm vào API cấp 18 |
float4 native_powr(cơ sở float4, số mũ float4); | Đã thêm vào API cấp 18 |
nửa native_powr(một nửa cơ số, nửa số mũ); | Đã thêm vào API cấp 24 |
half2 native_powr(half2 cơ sở, half2 số mũ); | Đã thêm vào API cấp 24 |
half3 native_powr(half3 cơ số, số mũ half3); | Đã thêm vào API cấp 24 |
half4 native_powr(half4 cơ sở, half4 số mũ); | Đã thêm vào API cấp 24 |
Tham số
chân đế | Phải nằm trong khoảng từ 0.f đến 256.f. Hàm không chính xác đối với các giá trị gần bằng 0. |
---|---|
số mũ | Phải nằm trong khoảng từ -15.f đến 15.f. |
Gần đúng (cơ số ^ số mũ).
Xem thêm powr().
native_recip : Giá trị nghịch đảo gần đúng
float native_recip(float v); | Đã thêm vào API cấp 21 |
float2 native_recip(float2 v); | Đã thêm vào API cấp 21 |
float3 native_recip(float3 v); | Đã thêm vào API cấp 21 |
float4 native_recip(float4 v); | Đã thêm vào API cấp 21 |
half native_recip(half v); | Đã thêm vào API cấp 24 |
half2 native_recip(half2 v); | Đã thêm vào API cấp 24 |
half3 native_recip(half3 v); | Đã thêm vào API cấp 24 |
half4 native_recip(half4 v); | Đã thêm vào API cấp 24 |
Trả về nghịch đảo gần đúng của một giá trị.
Xem thêm half_recip().
native_rootn : Căn bậc n gần đúng
float native_rootn(float v, int n); | Đã thêm vào API cấp 21 |
float2 native_rootn(float2 v, int2 n); | Đã thêm vào API cấp 21 |
float3 native_rootn(float3 v, int3 n); | Đã thêm vào API cấp 21 |
float4 native_rootn(float4 v, int4 n); | Đã thêm vào API cấp 21 |
half native_rootn(half v, int n); | Đã thêm vào API cấp 24 |
half2 native_rootn(half2 v, int2 n); | Đã thêm vào API cấp 24 |
half3 native_rootn(half3 v, int3 n); | Đã thêm vào API cấp 24 |
half4 native_rootn(half4 v, int4 n); | Đã thêm vào API cấp 24 |
Tính căn bậc n gần đúng của một giá trị.
Xem thêm root().
native_rsqrt : Số nghịch đảo gần đúng của căn bậc hai
float native_rsqrt(float v); | Đã thêm vào API cấp 21 |
float2 native_rsqrt(float2 v); | Đã thêm vào API cấp 21 |
float3 native_rsqrt(float3 v); | Đã thêm vào API cấp 21 |
float4 native_rsqrt(float4 v); | Đã thêm vào API cấp 21 |
half native_rsqrt(half v); | Đã thêm vào API cấp 24 |
half2 native_rsqrt(half2 v); | Đã thêm vào API cấp 24 |
half3 native_rsqrt(half3 v); | Đã thêm vào API cấp 24 |
half4 native_rsqrt(half4 v); | Đã thêm vào API cấp 24 |
Trả về gần đúng (1 / sqrt(v)).
Xem thêm rsqrt(), half_rsqrt().
native_sin : Sin gần đúng
float native_sin(float v); | Đã thêm vào API cấp 21 |
float2 native_sin(float2 v); | Đã thêm vào API cấp 21 |
float3 native_sin(float3 v); | Đã thêm vào API cấp 21 |
float4 native_sin(float4 v); | Đã thêm vào API cấp 21 |
nửa native_sin(một nửa v); | Đã thêm vào API cấp 24 |
half2 native_sin(half2 v); | Đã thêm vào API cấp 24 |
half3 native_sin(half3 v); | Đã thêm vào API cấp 24 |
half4 native_sin(half4 v); | Đã thêm vào API cấp 24 |
Trả về sin gần đúng của một góc được đo bằng radian.
Xem thêm sin().
native_sincos : Sin và cosin gần đúng
float native_sincos(float v, float* cos); | Đã thêm vào API cấp 21 |
float2 native_sincos(float2 v, float2* cos); | Đã thêm vào API cấp 21 |
float3 native_sincos(float3 v, float3* cos); | Đã thêm vào API cấp 21 |
float4 native_sincos(float4 v, float4* cos); | Đã thêm vào API cấp 21 |
half native_sincos(half v, half* cos); | Đã thêm vào API cấp 24 |
half2 native_sincos(half2 v, half2* cos); | Đã thêm vào API cấp 24 |
half3 native_sincos(half3 v, half3* cos); | Đã thêm vào API cấp 24 |
half4 native_sincos(half4 v, half4* cos); | Đã thêm vào API cấp 24 |
Tham số
so với | Giá trị đến tính bằng radian. |
---|---|
cos | *cos sẽ được đặt thành giá trị cosin. |
Giá trị trả về
Sin. |
Trả về sin và cosin gần đúng của một giá trị.
Xem thêm sincos().
native_sinh : Sin hypebol gần đúng
float native_sinh(float v); | Đã thêm vào API cấp 21 |
float2 native_sinh(float2 v); | Đã thêm vào API cấp 21 |
float3 native_sinh(float3 v); | Đã thêm vào API cấp 21 |
float4 native_sinh(float4 v); | Đã thêm vào API cấp 21 |
half native_sinh(half v); | Đã thêm vào API cấp 24 |
half2 native_sinh(half2 v); | Đã thêm vào API cấp 24 |
half3 native_sinh(half3 v); | Đã thêm vào API cấp 24 |
half4 native_sinh(half4 v); | Đã thêm vào API cấp 24 |
Trả về sin hypebol gần đúng của một giá trị được chỉ định bằng radian.
Hãy xem thêm sinh().
native_sinpi : Giá trị sin gần đúng của một số nhân với pi
float native_sinpi(float v); | Đã thêm vào API cấp 21 |
float2 native_sinpi(float2 v); | Đã thêm vào API cấp 21 |
float3 native_sinpi(float3 v); | Đã thêm vào API cấp 21 |
float4 native_sinpi(float4 v); | Đã thêm vào API cấp 21 |
half native_sinpi(half v); | Đã thêm vào API cấp 24 |
half2 native_sinpi(half2 v); | Đã thêm vào API cấp 24 |
half3 native_sinpi(half3 v); | Đã thêm vào API cấp 24 |
half4 native_sinpi(half4 v); | Đã thêm vào API cấp 24 |
Trả về sin gần đúng của (v * pi), trong đó (v * pi) được đo bằng radian.
Để tính sin của một giá trị được đo bằng độ, hãy gọi sinpi(v / 180.f)
.
Xem thêm sinpi().
native_sqrt : Căn bậc hai gần đúng
float native_sqrt(float v); | Đã thêm vào API cấp 21 |
float2 native_sqrt(float2 v); | Đã thêm vào API cấp 21 |
float3 native_sqrt(float3 v); | Đã thêm vào API cấp 21 |
float4 native_sqrt(float4 v); | Đã thêm vào API cấp 21 |
half native_sqrt(half v); | Đã thêm vào API cấp 24 |
half2 native_sqrt(half2 v); | Đã thêm vào API cấp 24 |
half3 native_sqrt(half3 v); | Đã thêm vào API cấp 24 |
half4 native_sqrt(half4 v); | Đã thêm vào API cấp 24 |
native_tan : Tang gần đúng
float native_tan(float v); | Đã thêm vào API cấp 21 |
float2 native_tan(float2 v); | Đã thêm vào API cấp 21 |
float3 native_tan(float3 v); | Đã thêm vào API cấp 21 |
float4 native_tan(float4 v); | Đã thêm vào API cấp 21 |
nửa native_tan(một nửa v); | Đã thêm vào API cấp 24 |
half2 native_tan(half2 v); | Đã thêm vào API cấp 24 |
half3 native_tan(half3 v); | Đã thêm vào API cấp 24 |
half4 native_tan(half4 v); | Đã thêm vào API cấp 24 |
Trả về tang gần đúng của một góc được đo bằng radian.
native_tanh : Tang hyperbol gần đúng
float native_tanh(float v); | Đã thêm vào API cấp 21 |
float2 native_tanh(float2 v); | Đã thêm vào API cấp 21 |
float3 native_tanh(float3 v); | Đã thêm vào API cấp 21 |
float4 native_tanh(float4 v); | Đã thêm vào API cấp 21 |
nửa native_tanh(một nửa v); | Đã thêm vào API cấp 24 |
half2 native_tanh(half2 v); | Đã thêm vào API cấp 24 |
half3 native_tanh(half3 v); | Đã thêm vào API cấp 24 |
half4 native_tanh(half4 v); | Đã thêm vào API cấp 24 |
Trả về tang hyperbol gần đúng của một giá trị.
Xem thêm tanh().
native_tanpi : Tang gần đúng của một số nhân với pi
float native_tanpi(float v); | Đã thêm vào API cấp 21 |
float2 native_tanpi(float2 v); | Đã thêm vào API cấp 21 |
float3 native_tanpi(float3 v); | Đã thêm vào API cấp 21 |
float4 native_tanpi(float4 v); | Đã thêm vào API cấp 21 |
half native_tanpi(half v); | Đã thêm vào API cấp 24 |
half2 native_tanpi(half2 v); | Đã thêm vào API cấp 24 |
half3 native_tanpi(half3 v); | Đã thêm vào API cấp 24 |
half4 native_tanpi(half4 v); | Đã thêm vào API cấp 24 |
Trả về tang gần đúng của (v * pi), trong đó (v * pi) được đo bằng radian.
Để tính tiếp tuyến của một giá trị được đo bằng độ, hãy gọi tanpi(v / 180.f)
.
Xem thêm tanpi().
nextnext : Số dấu phẩy động tiếp theo
float Nextafter(float v, đích chính); | |
float2 nextafter(float2 v, mục tiêu float2); | |
float3 nextafter(float3 v, mục tiêu float3); | |
float4 nextafter(float4 v, float4 target); | |
half tiếp theo(half so với half mục tiêu); | Đã thêm vào API cấp 24 |
half2 tiếp theo(half2 so với half2 target); | Đã thêm vào API cấp 24 |
half3 tiếp theo(half3 so với half3 target); | Đã thêm vào API cấp 24 |
half4 tiếp theo(half4 so với half4 target); | Đã thêm vào API cấp 24 |
Trả về số dấu phẩy động có thể biểu thị tiếp theo từ v đến đích.
Ở chế độ rs_FP_relaxed, giá trị đầu vào không được chuẩn hoá có thể không mang lại giá trị không được chuẩn hoá tiếp theo vì việc hỗ trợ các giá trị không được chuẩn hoá là không bắt buộc ở chế độ thư giãn.
pow : Cơ số được tăng lên số mũ
dấu phẩy động pow(cơ sở số thực, số mũ nổi); | |
float2 pow(cơ sở float2, số mũ float2); | |
float3 pow(cơ sở float3, số mũ float3); | |
float4 pow(cơ sở float4, số mũ float4); | |
nửa pow(nửa cơ số, nửa số mũ); | Đã thêm vào API cấp 24 |
half2 pow(half2 cơ số, half2 số mũ); | Đã thêm vào API cấp 24 |
half3 pow(half3 cơ sở, half3 số mũ); | Đã thêm vào API cấp 24 |
half4 pow(half4 cơ số, half4 số mũ); | Đã thêm vào API cấp 24 |
pown : Cơ số được nâng lên một số mũ nguyên
pown độ nổi(cơ sở số thực, số mũ int); | |
float2 pown(cơ sở float2, số mũ int2); | |
float3 pown(cơ sở float3, số mũ int3); | |
float4 pown(cơ sở float4, số mũ int4); | |
nửa pown(half cơ sở, số mũ int); | Đã thêm vào API cấp 24 |
pown half2(cơ sở half2, số mũ int2); | Đã thêm vào API cấp 24 |
half3 pown(half3 cơ sở, số mũ int3); | Đã thêm vào API cấp 24 |
half4 pown(half4 cơ sở, số mũ int4); | Đã thêm vào API cấp 24 |
powr : Số cơ số dương được nâng lên số mũ
số mũ nổi; số mũ nổi); | |
float2 powr(cơ sở float2, số mũ float2); | |
float3 powr(cơ sở float3, số mũ float3); | |
float4 powr(cơ sở float4, số mũ float4); | |
nửa powr(một nửa cơ số, nửa số mũ); | Đã thêm vào API cấp 24 |
half2 powr(half2 cơ số, half2 số mũ); | Đã thêm vào API cấp 24 |
half3 powr(half3 cơ số, half3 số mũ); | Đã thêm vào API cấp 24 |
half4 powr(half4 cơ số, half4 số mũ); | Đã thêm vào API cấp 24 |
Trả về cơ số được nâng lên với số mũ luỹ thừa, tức là số mũ ^. cơ số phải lớn hơn 0.
pow() và pown() tương tự nhau. Cả hai đều không đưa ra giả định về cơ số. pow() lấy số mũ nổi trong khi pown() lấy một số nguyên.
Xem thêm native_powr().
rađian : Chuyển đổi độ thành radian
float radian(float v); | |
float2 radian(float2 v); | |
float3 radian(float3 v); | |
float4 radian(float4 v); | |
nửa radian(nửa v); | Đã thêm vào API cấp 24 |
half2 radian(half2 v); | Đã thêm vào API cấp 24 |
half3 radian(half3 v); | Đã thêm vào API cấp 24 |
half4 radian(half4 v); | Đã thêm vào API cấp 24 |
Chuyển đổi từ độ sang radian.
số dư : Số dư của một phép chia
phần còn lại số thực(t số số thực, mẫu số số thực); | |
phần dư float2(tử số float2, mẫu số float2); | |
phần dư float3(tử số float3, mẫu số float3); | |
phần dư float4(tử số float4, mẫu số float4); | |
nửa phần dư(nửa tử số, nửa mẫu số); | Đã thêm vào API cấp 24 |
half2 số dư(tử số nửa2, mẫu số nửa2); | Đã thêm vào API cấp 24 |
half3 phần dư(tử số half3, mẫu số half3); | Đã thêm vào API cấp 24 |
half4 phần dư(tử số nửa4, mẫu số nửa4); | Đã thêm vào API cấp 24 |
remquo : Số dư và thương của một phép chia
float remquo(t số nổi, mẫu số nổi, thương số int*); | |
float2 remquo(t số float2, mẫu số float2, thương số int2*); | |
float3 remquo(t số float3, mẫu số float3, thương số int3*); | |
float4 remquo(tử số float4, mẫu số float4, thương số int4*); | |
nửa remquo(một nửa tử số, nửa mẫu số, thương số int*); | Đã thêm vào API cấp 24 |
half2 remquo(tử số half2, mẫu số half2, thương số int2*); | Đã thêm vào API cấp 24 |
half3 remquo(tử số half3, mẫu số half3, thương số int3*); | Đã thêm vào API cấp 24 |
half4 remquo(tử số half4, mẫu số half4, thương số int4*); | Đã thêm vào API cấp 24 |
Tham số
tử số | Tử số. |
---|---|
mẫu số | Mẫu số. |
thương số | *thương số sẽ được đặt thành thương số nguyên. |
Giá trị trả về
Phần còn lại, chính xác chỉ đối với 3 bit thấp. |
Trả về thương và số dư của (tử số / mẫu số).
Chỉ dấu và ba bit nhỏ nhất của thương số là đảm bảo chính xác.
Hàm này hữu ích khi triển khai các hàm định kỳ. Ba bit thấp của thương số mang đến góc phần tư và khoảng cách còn lại trong góc phần tư.
Ví dụ: việc triển khai sin(x) có thể gọi remquo(x, PI / 2.f, &quadrant)
để giảm giá trị rất lớn của x xuống một giá trị nào đó trong một phạm vi giới hạn.
Ví dụ: remquo(-23.5f, 8.f, ")
đặt 3 bit thấp nhất của quot thành 3 và dấu âm. Nó trả về 0,5f.
rint : Làm tròn đến chẵn
float rint(float v); | |
float2 rint(float2 v); | |
float3 rint(float3 v); | |
float4 rint(float4 v); | |
nửa rint(một nửa v); | Đã thêm vào API cấp 24 |
half2 rint(half2 v); | Đã thêm vào API cấp 24 |
half3 rint(half3 v); | Đã thêm vào API cấp 24 |
half4 rint(half4 v); | Đã thêm vào API cấp 24 |
root : Căn bậc 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); | Đã thêm vào API cấp 24 |
half2 rootn(half2 v, int2 n); | Đã thêm vào API cấp 24 |
half3 rootn(half3 v, int3 n); | Đã thêm vào API cấp 24 |
half4 rootn(half4 v, int4 n); | Đã thêm vào API cấp 24 |
Tính căn bậc n của một giá trị.
Xem thêm native_rootn().
round : Làm tròn từ 0
float tròn(float v); | |
float2 vòng(float2 v); | |
float3 vòng(float3 v); | |
float4 vòng(float4 v); | |
nửa vòng(nửa v); | Đã thêm vào API cấp 24 |
half2 vòng(half2 v); | Đã thêm vào API cấp 24 |
half3 vòng(half3 v); | Đã thêm vào API cấp 24 |
half4 vòng(half4 v); | Đã thêm vào API cấp 24 |
rsClamp : Giới hạn một giá trị trong một phạm vi
char rsClamp(số lượng ký tự, lượng ký tự thấp, ký tự cao); | |
int rsClamp(số lượng int, số nguyên thấp, số nguyên cao); | |
ngắn rsClamp(số lượng ngắn, thấp ngắn, ngắn cao); | |
uchar rsClamp(số tiền uchar, uchar thấp, uchar cao); | |
uint rsClamp(số lượng uint, uint thấp, uint cao); | |
ushort rsClamp(lượng ushort, ushort thấp, ushort cao); |
Tham số
số tiền | Giá trị cần kẹp. |
---|---|
thấp | Giới hạn dưới. |
cao | Giới hạn trên. |
Không dùng nữa. Thay vào đó, hãy sử dụng clamp().
Xác định giá trị giữa thấp và cao.
rsFrac : Trả về phần thập phân của số thực
độ chính xác đơn rsFrac(float v); |
Không dùng nữa. Thay vào đó, hãy sử dụng fract().
Trả về phần thập phân của số thực
rsRand : Số giả ngẫu nhiên
độ chính xác đơn rsRand(float_value_value); | |
độ chính xác rsRand(giá trị tối thiểu của độ chính xác đơn, giá trị tối đa của độ chính xác đơn); | |
int rsRand(int max_value); | |
int rsRand(int min_value, int max_value); |
Trả về một giá trị ngẫu nhiên từ 0 (hoặc min_value) đến max_malue.
rsqrt : nghịch đảo của một căn bậc hai
độ chính xác đơn rsqrt(float v); | |
float2 rsqrt(float2 v); | |
float3 rsqrt(float3 v); | |
float4 rsqrt(float4 v); | |
nửa rsqrt(half v); | Đã thêm vào API cấp 24 |
half2 rsqrt(half2 v); | Đã thêm vào API cấp 24 |
half3 rsqrt(half3 v); | Đã thêm vào API cấp 24 |
half4 rsqrt(half4 v); | Đã thêm vào API cấp 24 |
Trả về (1 / sqrt(v)).
Xem thêm half_rsqrt(), native_rsqrt().
dấu : Dấu của một giá trị
dấu nổi(float v); | |
Dấu float2(float2 v); | |
Dấu float3(float3 v); | |
Dấu float4(float4 v); | |
nửa dấu(nửa v); | Đã thêm vào API cấp 24 |
Dấu half2(half2 v); | Đã thêm vào API cấp 24 |
Dấu half3(half3 v); | Đã thêm vào API cấp 24 |
Dấu half4(half4 v); | Đã thêm vào API cấp 24 |
Trả về dấu của một giá trị.
if (v < 0) return -1.f; else if (v > 0)trả về 1.f; else trả về 0.f;
sin : Sin
float sin(float v); | |
float2 sin(float2 v); | |
float3 sin(float3 v); | |
float4 sin(float4 v); | |
nửa sin(một nửa v); | Đã thêm vào API cấp 24 |
half2 sin(half2 v); | Đã thêm vào API cấp 24 |
half3 sin(half3 v); | Đã thêm vào API cấp 24 |
half4 sin(half4 v); | Đã thêm vào API cấp 24 |
Trả về sin của một góc được đo bằng radian.
Hãy xem thêm hàm native_sin().
sincos : Sin và cosin
độ chính xác đơn sincos(float v, float* cos); | |
float2 sincos(float2 v, float2* cos); | |
float3 sincos(float3 v, float3* cos); | |
float4 sincos(float4 v, float4* cos); | |
nửa sincos(half v, half* cos); | Đã thêm vào API cấp 24 |
half2 sincos(half2 v, half2* cos); | Đã thêm vào API cấp 24 |
half3 sincos(half3 v, half3* cos); | Đã thêm vào API cấp 24 |
half4 sincos(half4 v, half4* cos); | Đã thêm vào API cấp 24 |
Tham số
so với | Giá trị đến tính bằng radian. |
---|---|
cos | *cos sẽ được đặt thành giá trị cosin. |
Giá trị trả về
Sin của tập |
Trả về sin và cosin của một giá trị.
Xem thêm native_sincos().
sinh : Sin Hyperbolic
float sinh(float v); | |
float2 sinh(float2 v); | |
float3 sinh(float3 v); | |
float4 sinh(float4 v); | |
half sinh(half v); | Đã thêm vào API cấp 24 |
half2 sinh(half2 v); | Đã thêm vào API cấp 24 |
half3 sinh(half3 v); | Đã thêm vào API cấp 24 |
half4 sinh(half4 v); | Đã thêm vào API cấp 24 |
Trả về sin hyperbol của v, trong đó v được đo bằng radian.
Xem thêm native_sinh().
sinpi : Sin của một số nhân với pi
độ chính xác đơn sinpi(float v); | |
float2 sinpi(float2 v); | |
float3 sinpi(float3 v); | |
float4 sinpi(float4 v); | |
nửa sinpi(half v); | Đã thêm vào API cấp 24 |
half2 sinpi(half2 v); | Đã thêm vào API cấp 24 |
half3 sinpi(half3 v); | Đã thêm vào API cấp 24 |
half4 sinpi(half4 v); | Đã thêm vào API cấp 24 |
Trả về sin của (v * pi), trong đó (v * pi) được đo bằng radian.
Để tính sin của một giá trị được đo bằng độ, hãy gọi sinpi(v / 180.f)
.
Xem thêm native_sinpi().
sqrt : Căn bậc hai
float sqrt(float v); | |
float2 sqrt(float2 v); | |
float3 sqrt(float3 v); | |
float4 sqrt(float4 v); | |
nửa sqrt(half v); | Đã thêm vào API cấp 24 |
half2 sqrt(half2 v); | Đã thêm vào API cấp 24 |
half3 sqrt(half3 v); | Đã thêm vào API cấp 24 |
half4 sqrt(half4 v); | Đã thêm vào API cấp 24 |
Trả về căn bậc hai của một giá trị.
Xem thêm half_sqrt(), native_sqrt().
bước : 0 nếu nhỏ hơn giá trị, 1 nếu không
bước nổi(cạnh nổi, dấu phẩy động v); | |
float2 step(cạnh nổi, float2 v); | Đã thêm vào API cấp 21 |
float2 step(cạnh float2, float v); | |
float2 step(cạnh float2, float2 v); | |
float3 step(cạnh nổi, float3 v); | Đã thêm vào API cấp 21 |
float3 step(cạnh float3, float v); | |
float3 step(cạnh float3, float3 v); | |
bước float4(cạnh nổi, float4 v); | Đã thêm vào API cấp 21 |
float4 step(cạnh float4, float v); | |
float4 step(cạnh float4, float4 v); | |
nửa bước(nửa cạnh, nửa v); | Đã thêm vào API cấp 24 |
half2 bước(nửa cạnh, half2 v); | Đã thêm vào API cấp 24 |
half2 bước(half2 cạnh, nửa v); | Đã thêm vào API cấp 24 |
nửa2 bước(cạnh half2, half2 v); | Đã thêm vào API cấp 24 |
nửa3 bước(nửa cạnh, half3 v); | Đã thêm vào API cấp 24 |
half3 bước(half3 cạnh, nửa v); | Đã thêm vào API cấp 24 |
half3 bước(half3 cạnh, half3 v); | Đã thêm vào API cấp 24 |
half4 bước(nửa cạnh, half4 v); | Đã thêm vào API cấp 24 |
half4 bước(half4 cạnh, nửa v); | Đã thêm vào API cấp 24 |
half4 bước(half4 cạnh, half4 v); | Đã thêm vào API cấp 24 |
tan : Tang
độ chính xác đơn tan(float v); | |
float2 tan(float2 v); | |
float3 tan(float3 v); | |
float4 tan(float4 v); | |
nửa tan(half v); | Đã thêm vào API cấp 24 |
half2 tan(half2 v); | Đã thêm vào API cấp 24 |
half3 tan(half3 v); | Đã thêm vào API cấp 24 |
half4 tan(half4 v); | Đã thêm vào API cấp 24 |
Trả về tang của một góc được đo bằng radian.
Xem thêm hàm native_tan().
tanh : Tiếp tuyến Hyperbolic
float tanh(float v); | |
float2 tanh(float2 v); | |
float3 tanh(float3 v); | |
float4 tanh(float4 v); | |
nửa tanh(một nửa v); | Đã thêm vào API cấp 24 |
half2 tanh(half2 v); | Đã thêm vào API cấp 24 |
half3 tanh(half3 v); | Đã thêm vào API cấp 24 |
half4 tanh(half4 v); | Đã thêm vào API cấp 24 |
Trả về tang hyperbol của một giá trị.
Xem thêm native_tanh().
tanpi : Tang của một số nhân với pi
độ chính xác đơn tanpi(float v); | |
float2 tanpi(float2 v); | |
float3 tanpi(float3 v); | |
float4 tanpi(float4 v); | |
nửa tanpi(một nửa v); | Đã thêm vào API cấp 24 |
half2 tanpi(half2 v); | Đã thêm vào API cấp 24 |
half3 tanpi(half3 v); | Đã thêm vào API cấp 24 |
half4 tanpi(half4 v); | Đã thêm vào API cấp 24 |
Trả về tang của (v * pi), trong đó (v * pi) được đo bằng radian.
Để tính tiếp tuyến của một giá trị được đo bằng độ, hãy gọi tanpi(v / 180.f)
.
Xem thêm hàm native_tanpi().
tgamma : Hàm Gamma
độ chính xác đơn tgamma(float v); | |
float2 tgamma(float2 v); | |
float3 tgamma(float3 v); | |
float4 tgamma(float4 v); | |
nửa tgamma(nửa v); | Đã thêm vào API cấp 24 |
half2 tgamma(half2 v); | Đã thêm vào API cấp 24 |
half3 tgamma(half3 v); | Đã thêm vào API cấp 24 |
half4 tgamma(half4 v); | Đã thêm vào API cấp 24 |
Trả về hàm gamma của một giá trị.
Xem thêm lgamma().
trunc : Cắt bớt một dấu phẩy động
float trunc(float v); | |
float2 ngắn(float2 v); | |
float3 cắt ngắn(float3 v); | |
float4 cắt ngắn(float4 v); | |
nửa cắt ngắn(half v); | Đã thêm vào API cấp 24 |
half2 cắt ngắn(half2 v); | Đã thêm vào API cấp 24 |
half3 cắt ngắn(half3 v); | Đã thêm vào API cấp 24 |
half4 cắt ngắn(half4 v); | Đã thêm vào API cấp 24 |