Hằng số và hàm toán học RenderScript

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ố
valueGiá trị cần được kẹp.
giá_trị_tối_nhấtGiới hạn dưới, vectơ vô hướng hoặc vectơ phù hợp.
giá_trị_tối_đaGiớ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

Nhân và cộng. Trả về (multiplicand1 * multiplicand2) + offset.

Hàm này tương tự như mad(). fma() giữ lại độ 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ính xác bổ sung này không được đảm bảo ở chế độ rs_FP_relaxed.

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

Trả về phần dư của (tử số / mẫu số), trong đó thương được làm tròn về 0.

Hàm remainder() tương tự nhưng làm tròn về số nguyên gần nhất. Ví dụ: fmod(-3.8f, 2.f) trả về -1.8f (-3.8f - -1.f * 2.f) trong khi remainder(-3.8f, 2.f) trả về 0.2f (-3.8f - -2.f * 2.f).

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ớiGiá trị nhập.
tầngNế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ớiGiá 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.

Trả về mantissa nhị phân và số mũ của v, ví dụ như v == mantissa * 2 ^ exponent.

Mantissa luôn nằm trong khoảng từ 0,5 (bao gồm) đến 1,0 (loại trừ).

Hãy xem ldexp() để biết thao tác đảo ngược. Hãy xem thêm logb() và ilogb().

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

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ụ: ilogb(8.5f) trả về 3 giá trị.

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

logb() cũng tương tự nhưng trả về một số thực có độ chính xác đơn.

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 mantissaVả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_gammaNế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.

Trả về lôgarit tự nhiên của giá trị tuyệt đối của hàm gamma, tức là log(fabs(tgamma(v))).

Xem thêm tgamma().

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ớiGiá 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ớiKhô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

Nhật ký gần đúng nhanh.

Giá trị gần bằng 0 sẽ không chính xác.

Hãy xem thêm log().

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

Nhật ký gần đúng nhanh 10.

Giá trị gần bằng 0 sẽ không chính xác.

Xem thêm log10().

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

Nhật ký gần đúng nhanh 2.

Giá trị gần bằng 0 sẽ không chính xác.

Hãy xem thêm log2().

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ớiGiá 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

Trả về sqrt(v) gần đúng.

Xem thêm sqrt(), half_sqrt().

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

Trả về cơ số được nâng lên với số mũ luỹ thừa, tức là số mũ ^.

pown() và powr() tương tự nhau. pown() lấy một số mũ nguyên. powr() giả định cơ số không phải là số âm.

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

Trả về cơ số được nâng lên với số mũ luỹ thừa, tức là số mũ ^.

pow() và powr() tương tự nhau. Cả hai đều lấy một số mũ thực. powr() cũng giả định cơ số không là số âm.

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

Trả về phần dư của (tử số / mẫu số), trong đó thương được làm tròn về số nguyên gần nhất.

Hàm fmod() tương tự nhưng làm tròn về số nguyên gần nhất. Ví dụ: fmod(-3.8f, 2.f) trả về -1.8f (-3.8f - -1.f * 2.f) trong khi remainder(-3.8f, 2.f) trả về 0.2f (-3.8f - -2.f * 2.f).

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, &quot) đặ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

Làm tròn đến giá trị tích phân gần nhất.

rint() làm tròn một nửa giá trị thành số chẵn. Ví dụ: rint(0.5f) trả về 0.f và rint(1.5f) trả về 2.f. Tương tự, rint(-0.5f) trả về -0.f và rint(-1.5f) trả về -2.f.

round() tương tự nhưng làm tròn lên từ 0. trunc() cắt bớt phân số thập phân.

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

Làm tròn đến giá trị tích phân gần nhất.

vòng() làm tròn một nửa giá trị ra xa 0. Ví dụ: round(0.5f) trả về 1.f và round(1.5f) trả về 2.f. Tương tự, round(-0.5f) trả về -1.f và round(-1.5f) trả về -2.f.

rint() tương tự nhưng làm tròn một nửa giá trị về số chẵn. trunc() cắt bớt phân số thập phân.

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ềnGiá trị cần kẹp.
thấpGiới hạn dưới.
caoGiớ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ớiGiá 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

Trả về 0.f nếu v < cạnh, 1.f nếu không.

Thao tác này có thể hữu ích khi tạo các phép tính có điều kiện mà không cần sử dụng lệnh lặp lại và phân nhánh. Ví dụ: thay vì tính toán (a[i] < b[i]) ? 0.f : atan2(a[i], b[i]) cho các phần tử tương ứng của vectơ, bạn có thể sử dụng step(a, b) * atan2(a, b).

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

Làm tròn đến tích phân bằng cách cắt ngắn.

Ví dụ: trunc(1.7f) trả về 1.f và trunc(-1.7f) trả về -1.f.

Xem rint() và round() để biết các tuỳ chọn làm tròn khác.