Ringkasan
Fungsi matematika di bawah ini dapat diterapkan pada skalar dan vektor. Jika diterapkan ke vektor, nilai yang ditampilkan adalah vektor dari fungsi yang diterapkan ke setiap entri input.
Contoh:
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);
Lihat Fungsi Matematika Vektor untuk fungsi seperti jarak() dan panjang() yang menafsirkan input sebagai vektor tunggal dalam ruang dimensi n.
Presisi operasi matematika pada float 32 bit dipengaruhi oleh pragmas rs_fp_relaxed dan rs_fp_full. Di bawah rs_fp_relaxed, nilai subnormal dapat dikosongkan ke nol dan pembulatan dapat dilakukan menuju nol. Sebagai perbandingan, rs_fp_full memerlukan penanganan nilai subnormal yang benar, yaitu lebih kecil dari 1,17549435e-38f. {i>rs_fp_rull<i} juga membutuhkan pembulatan ke terdekat dengan ikatan ke genap.
Kompromi yang berbeda presisi/kecepatan dapat dicapai dengan menggunakan varian fungsi matematika umum. Fungsi dengan nama yang diawali dengan
- native_: Dapat memiliki implementasi hardware kustom dengan presisi yang lebih rendah. Selain itu, nilai subnormal mungkin akan menjadi nol, pembulatan ke arah nol dapat digunakan, dan input NaN dan tak terbatas mungkin tidak ditangani dengan benar.
- half_: Dapat melakukan komputasi internal menggunakan float 16 bit. Selain itu, nilai subnormal mungkin menjadi nol, dan pembulatan ke nol dapat digunakan.
Ringkasan
Konstanta | |
---|---|
PI_M_1 | 1 / pi, sebagai float 32 bit |
PI_M_2 | 2 / pi, sebagai float 32 bit |
SQRTPI_M_2 | 2 / sqrt(pi), sebagai float 32 bit |
M_E | e, sebagai float 32 bit |
M_LN10 | log_e(10), sebagai float 32 bit |
M_LN2 | log_e(2), sebagai float 32 bit |
M_LOG10E | log_10(e), sebagai float 32 bit |
M_LOG2E | log_2(e), sebagai float 32 bit |
P_PI | pi, sebagai float 32 bit |
P_PI_2 | pi / 2, sebagai float 32 bit |
P_PI_4 | pi / 4, sebagai float 32 bit |
SQRT1_2 | 1 / sqrt(2), sebagai float 32 bit |
SQRT2 | sqrt(2), sebagai float 32 bit |
Fungsi | |
---|---|
abs | Nilai absolut dari bilangan bulat |
acos | Kosinus terbalik |
acosh | Kosinus hiperbolik terbalik |
acospi | Kosinus terbalik dibagi pi |
asin | Sinus terbalik |
asinh | Sinus hiperbolik terbalik |
asinpi | Sinus terbalik dibagi pi |
atan | Tangen terbalik |
atan2 | Tangen terbalik dari suatu rasio |
atan2pi | Tangen terbalik dari suatu rasio, dibagi dengan pi |
atannt | Tangen hiperbolik terbalik |
atanpi | Tangen terbalik dibagi pi |
cbrt | Akar pangkat tiga |
ceil | Bilangan bulat terkecil yang tidak kurang dari nilai |
penjepit | Membatasi nilai ke rentang |
klz | Jumlah 0 bit di depan |
tanda salinan | Menyalin tanda suatu angka ke yang lain |
cos | Kosinus |
cosh | Kosinus hiperbolik |
cospi | Kosinus suatu angka dikalikan dengan pi |
derajat | Mengubah radian menjadi derajat |
erf | Fungsi error matematika |
erfc | Fungsi kesalahan komplementer matematika |
habis | e dipangkatkan ke angka |
eksp10 | 10 dipangkatkan |
eksp2 | 2 dipangkatkan ke suatu angka |
ekspm1 | e dipangkatkan ke angka minus satu |
fab | Nilai absolut dari float |
fdim | Perbedaan positif antara dua nilai |
lantai | Bilangan bulat terkecil yang tidak lebih besar dari nilai |
fma | Kalikan dan tambahkan |
fmax | Maksimum dua float |
fmin | Minimum dua float |
fmod | Modulo |
fraksi | Bagian pecahan positif |
frexp | Eksponen dan mantissa biner |
resip_setengah | Resiprokal dikomputasi dengan presisi 16 bit |
half_rsqrt | Kebalikan dari akar kuadrat yang dihitung dengan presisi 16 bit |
setengah_sqrt | Root kuadrat dihitung dengan presisi 16 bit |
hipot | Sisi miring |
ilogb | Eksponen basis dua |
ldexp | Membuat floating point dari mantissa dan eksponen |
lgamma | Logaritma alami fungsi gamma |
log | Logaritma alami |
log10 | Logaritma basis 10 |
log1p | Logaritma alami nilai ditambah 1 |
log2 | Logaritma basis 2 |
logb | Eksponen basis dua |
gila | Kalikan dan tambahkan |
maks | Maksimum |
mnt | Minimum |
campuran | Mencampur dua nilai |
modf | Komponen integral dan pecahan |
nan | Bukan Angka |
nan_half | Bukan Angka |
native_acos | Perkiraan kosinus terbalik |
native_acosh | Perkiraan kosinus hiperbolik terbalik |
acospi_native | Perkiraan kosinus terbalik dibagi pi |
native_asin | Perkiraan sinus terbalik |
native_asinh | Perkiraan sinus hiperbolik terbalik |
native_asinpi | Perkiraan sinus terbalik dibagi dengan pi |
native_atan | Perkiraan tangen terbalik |
native_atan2 | Memperkirakan tangen terbalik dari sebuah rasio |
native_atan2pi | Memperkirakan tangen terbalik dari sebuah rasio, dibagi dengan pi |
native_atanh | Memperkirakan tangen hiperbolik terbalik |
native_atanpi | Perkiraan tangen terbalik dibagi pi |
native_cbrt | Perkiraan akar pangkat tiga |
cos_native | Perkiraan kosinus |
native_cosh | Perkiraan kosinus hipebolik |
cospi_native | Perkiraan kosinus suatu angka dikalikan dengan pi |
native_divide | Perkiraan pembagian |
native_exp | Perkiraan e dinaikkan ke angka |
native_exp10 | Perkiraan 10 dinaikkan ke jumlah |
native_exp2 | Perkiraan 2 dinaikkan ke angka |
native_expm1 | Perkiraan e dinaikkan ke angka minus satu |
hipot_native | Perkiraan sisi miring |
native_log | Perkiraan logaritma natural |
native_log10 | Logaritma perkiraan basis 10 |
native_log1p | Perkiraan logaritma natural nilai plus 1 |
native_log2 | Logaritma perkiraan basis 2 |
native_powr | Perkiraan basis positif yang dipangkatkan ke eksponen |
resip_native | Perkiraan timbal balik |
native_rootn | Perkiraan akar ke-n |
native_rsqrt | Perkiraan kebalikan dari akar kuadrat |
native_sin | Perkiraan sinus |
sinko_native | Perkiraan sinus dan kosinus |
native_sinh | Perkiraan sinus hiperbolik |
sinpi_native | Perkiraan sinus suatu angka dikalikan dengan pi |
native_sqrt | Perkiraan akar kuadrat |
cokelat_native | Perkiraan tangen |
tanh_native | Perkiraan tangen hiperbolik |
tanpi_native | Perkiraan tangen sebuah angka dikalikan dengan pi |
berikutnya | Bilangan floating point berikutnya |
pow | Basis yang dipangkatkan ke eksponen |
pown | Basis yang dipangkatkan ke eksponen bilangan bulat |
powr | Basis positif yang dipangkatkan ke eksponen |
radian | Mengubah derajat menjadi radian |
sisa | Sisa pembagian |
remquo | Sisa dan hasil bagi dari suatu pembagian |
hilangkan | Bulatkan ke genap |
root | Akar ke-n |
lingkaran | Bulatkan dari nol |
rsRand | Angka acak semu |
rsqrt | Kebalikan dari akar kuadrat |
tanda tangan | Tanda nilai |
sin | Sinus |
sinko | Sinus dan kosinus |
sinh | Sinus hiperbolik |
sinpi | Sinus angka yang dikalikan dengan pi |
sqrt | Akar pangkat dua |
step (langkah) | 0 jika lebih kecil dari nilai, 1 jika tidak |
tan | Tangen |
tanh | Tangen hiperbolik |
tanpi | Tangen sebuah angka dikalikan dengan pi |
tgamma | Fungsi gamma |
trunc | Memotong floating point |
Fungsi yang Tidak Digunakan Lagi | |
---|---|
rsClamp | Tidak digunakan lagi. Membatasi nilai ke rentang |
rsFrac | Tidak digunakan lagi. Menampilkan bagian pecahan dari float |
Konstanta
M_1_PI : 1 / pi, sebagai float 32 bit
Nilai: 0.318309886183790671537767526745028724f |
Kebalikan dari pi, sebagai float 32 bit.
M_2_PI : 2 / pi, sebagai float 32 bit
Nilai: 0.636619772367581343075535053490057448f |
2 dibagi dengan pi, sebagai float 32 bit.
M_2_SQRTPI : 2 / sqrt(pi), sebagai float 32 bit
Nilai: 1.128379167095512573896158903121545172f |
2 dibagi dengan akar kuadrat pi, sebagai {i>float<i} 32 bit.
M_E : e, sebagai float 32 bit
Nilai: 2.718281828459045235360287471352662498f |
Angka e, dasar logaritma natural, sebagai float 32 bit.
M_LN10 : log_e(10), sebagai float 32 bit
Nilai: 2.302585092994045684017991454684364208f |
Logaritma natural 10, sebagai float 32 bit.
M_LN2 : log_e(2), sebagai float 32 bit
Nilai: 0.693147180559945309417232121458176568f |
Logaritma alami 2, sebagai float 32 bit.
M_LOG10E : log_10(e), sebagai float 32 bit
Nilai: 0.434294481903251827651128918916605082f |
Logaritma basis 10 dari e, sebagai float 32 bit.
M_LOG2E : log_2(e), sebagai float 32 bit
Nilai: 1.442695040888963407359924681001892137f |
Logaritma basis 2 dari e, sebagai float 32 bit.
M_PI : pi, sebagai float 32 bit
Nilai: 3.141592653589793238462643383279502884f |
Pi konstanta, sebagai float 32 bit.
M_PI_2 : pi / 2, sebagai float 32 bit
Nilai: 1.570796326794896619231321691639751442f |
Pi dibagi 2, sebagai float 32 bit.
M_PI_4 : pi / 4, sebagai float 32 bit
Nilai: 0.785398163397448309615660845819875721f |
Pi dibagi 4, sebagai float 32 bit.
M_SQRT1_2 : 1 / sqrt(2), sebagai float 32 bit
Nilai: 0.707106781186547524400844362104849039f |
Kebalikan dari akar kuadrat 2, sebagai float 32 bit.
M_SQRT2 : sqrt(2), sebagai float 32 bit
Nilai: 1.414213562373095048801688724209698079f |
Akar kuadrat dari 2, sebagai float 32 bit.
Fungsi
abs : Nilai absolut dari bilangan bulat
uchar abs(char v); | |
uchar2 abs(char2 v); | |
uchar3 abs(char3 v); | |
uchar4 abs(char4 v); | |
uint abs(int v); | |
uint2 abs(int2 v); | |
uint3 abs(int3 v); | |
uint4 abs(int4 v); | |
ushort abs(short v); | |
ushort2 abs(short2 v); | |
ushort3 abs(short3 v); | |
ushort4 abs(short4 v); |
Menampilkan nilai absolut dari bilangan bulat.
Untuk float, gunakan fabs().
acos : Kosinus terbalik
{i>float <i}acos(float v); | |
float2 acos(float2 v); | |
float3 acos(float3 v); | |
float4 acos(float4 v); | |
setengah acos(setengah v); | Ditambahkan di API level 24 |
half2 acos(half2 v); | Ditambahkan di API level 24 |
half3 acos(half3 v); | Ditambahkan di API level 24 |
half4 acos(half4 v); | Ditambahkan di API level 24 |
Menampilkan kosinus terbalik, dalam radian.
Lihat juga native_acos().
acosh : Kosinus hiperbolik terbalik
acosh mengambang(float v); | |
float2 acosh(float2 v); | |
float3 acosh(float3 v); | |
float4 acosh(float4 v); | |
setengah acosh(setengah v); | Ditambahkan di API level 24 |
half2 acosh(half2 v); | Ditambahkan di API level 24 |
setengah3 acosh(setengah3 v); | Ditambahkan di API level 24 |
setengah4 acosh(setengah4 v); | Ditambahkan di API level 24 |
Menampilkan kosinus hiperbolik terbalik, dalam radian.
Lihat juga native_acosh().
acospi : Kosinus terbalik dibagi pi
acospi(float v); | |
float2 acospi(float2 v); | |
float3 acospi(float3 v); | |
float4 acospi(float4 v); | |
setengah acospi(setengah v); | Ditambahkan di API level 24 |
half2 acospi(half2 v); | Ditambahkan di API level 24 |
half3 acospi(half3 v); | Ditambahkan di API level 24 |
half4 acospi(half4 v); | Ditambahkan di API level 24 |
Menampilkan kosinus terbalik dalam radian, dibagi dengan pi.
Untuk mendapatkan kosinus terbalik yang diukur dalam derajat, gunakan acospi(a) * 180.f
.
Lihat juga native_acospi().
asin : Sinus terbalik
{i>float asin<i}(float v); | |
float2 asin(float2 v); | |
float3 asin(float3 v); | |
float4 asin(float4 v); | |
setengah asin(setengah v); | Ditambahkan di API level 24 |
half2 asin(half2 v); | Ditambahkan di API level 24 |
half3 asin(half3 v); | Ditambahkan di API level 24 |
half4 asin(half4 v); | Ditambahkan di API level 24 |
Menampilkan sinus terbalik, dalam radian.
Lihat juga native_asin().
asinh : Sinus hiperbolik terbalik
{i>float asinh<i}(float v); | |
float2 asinh(float2 v); | |
float3 asinh(float3 v); | |
float4 asinh(float4 v); | |
setengah asinh(setengah v); | Ditambahkan di API level 24 |
half2 asinh(half2 v); | Ditambahkan di API level 24 |
half3 asinh(half3 v); | Ditambahkan di API level 24 |
half4 asinh(half4 v); | Ditambahkan di API level 24 |
Menampilkan inversi sinus hiperbolik, dalam radian.
Lihat juga native_asinh().
asinpi : Sinus terbalik dibagi pi
{i>float<i} asinpi(float v); | |
float2 asinpi(float2 v); | |
float3 asinpi(float3 v); | |
float4 asinpi(float4 v); | |
setengah asinpi(setengah v); | Ditambahkan di API level 24 |
half2 asinpi(half2 v); | Ditambahkan di API level 24 |
half3 asinpi(half3 v); | Ditambahkan di API level 24 |
half4 asinpi(half4 v); | Ditambahkan di API level 24 |
Menampilkan sinus terbalik dalam radian, dibagi dengan pi.
Untuk mendapatkan sinus terbalik yang diukur dalam derajat, gunakan asinpi(a) * 180.f
.
Lihat juga native_asinpi().
atan : Tangen terbalik
{i>float atan<i}(float v); | |
float2 atan(float2 v); | |
float3 atan(float3 v); | |
float4 atan(float4 v); | |
setengah atan(setengah v); | Ditambahkan di API level 24 |
half2 atan(half2 v); | Ditambahkan di API level 24 |
half3 atan(half3 v); | Ditambahkan di API level 24 |
half4 atan(half4 v); | Ditambahkan di API level 24 |
Menampilkan tangen terbalik, dalam radian.
Lihat juga native_atan().
atan2 : Tangen terbalik dari suatu rasio
float atan2(pembilang mengambang, penyebut mengambang); | |
float2 atan2(pembilang float2, penyebut float2); | |
float3 atan2(pembilang float3, penyebut float3); | |
float4 atan2(pembilang float4, penyebut float4); | |
setengah atan2(setengah pembilang, setengah penyebut); | Ditambahkan di API level 24 |
setengah2 atan2(pembilang setengah2, penyebut setengah2); | Ditambahkan di API level 24 |
setengah3 atan2(pembilang setengah3, penyebut setengah3); | Ditambahkan di API level 24 |
setengah4 atan2(pembilang setengah4, penyebut setengah4); | Ditambahkan di API level 24 |
Parameter
pembilang | Pembilang. |
---|---|
penyebut | Penyebut. Dapat berupa 0. |
Menampilkan tangen terbalik dari (numerator / denominator)
, dalam radian.
Lihat juga native_atan2().
atan2pi : Tangen terbalik dari suatu rasio, dibagi dengan pi
float atan2pi(pembilang mengambang, penyebut mengambang); | |
float2 atan2pi(pembilang float2, penyebut float2); | |
float3 atan2pi(pembilang float3, penyebut float3); | |
float4 atan2pi(pembilang float4, penyebut float4); | |
setengah atan2pi(setengah pembilang, setengah penyebut); | Ditambahkan di API level 24 |
setengah2 atan2pi(setengah2 pembilang, penyebut setengah2); | Ditambahkan di API level 24 |
setengah3 atan2pi(setengah3 pembilang, penyebut setengah3); | Ditambahkan di API level 24 |
setengah4 atan2pi(setengah4 pembilang, penyebut setengah4); | Ditambahkan di API level 24 |
Parameter
pembilang | Pembilang. |
---|---|
penyebut | Penyebut. Dapat berupa 0. |
Menampilkan tangen terbalik dari (numerator / denominator)
, dalam radian, dibagi dengan pi.
Untuk mendapatkan tangen terbalik yang diukur dalam derajat, gunakan atan2pi(n, d) * 180.f
.
Lihat juga native_atan2pi().
atanh : Tangen hiperbolik terbalik
{i>float atanh<i}(float v); | |
float2 atanh(float2 v); | |
float3 atanh(float3 v); | |
float4 atanh(float4 v); | |
setengah atanh(setengah v); | Ditambahkan di API level 24 |
half2 atanh(half2 v); | Ditambahkan di API level 24 |
half3 atanh(half3 v); | Ditambahkan di API level 24 |
half4 atanh(half4 v); | Ditambahkan di API level 24 |
Menampilkan tangen hiperbolik terbalik, dalam radian.
Lihat juga native_atanh().
atanpi : Tangen terbalik dibagi pi
{i>float atanpi<i}(float v); | |
float2 atanpi(float2 v); | |
float3 atanpi(float3 v); | |
float4 atanpi(float4 v); | |
setengah atanpi(setengah v); | Ditambahkan di API level 24 |
half2 atanpi(half2 v); | Ditambahkan di API level 24 |
half3 atanpi(half3 v); | Ditambahkan di API level 24 |
half4 atanpi(half4 v); | Ditambahkan di API level 24 |
Menampilkan tangen terbalik dalam radian, dibagi dengan pi.
Untuk mendapatkan tangen terbalik yang diukur dalam derajat, gunakan atanpi(a) * 180.f
.
Lihat juga native_atanpi().
cbrt : Akar pangkat tiga
float cbrt(float v); | |
float2 cbrt(float2 v); | |
float3 cbrt(float3 v); | |
float4 cbrt(float4 v); | |
setengah cbrt(setengah v); | Ditambahkan di API level 24 |
half2 cbrt(half2 v); | Ditambahkan di API level 24 |
half3 cbrt(half3 v); | Ditambahkan di API level 24 |
half4 cbrt(half4 v); | Ditambahkan di API level 24 |
Menampilkan akar pangkat tiga.
Lihat juga native_cbrt().
ceil : Bilangan bulat terkecil yang tidak kurang dari nilai
ceil mengambang(float v); | |
float2 ceil(float2 v); | |
float3 ceil(float3 v); | |
float4 ceil(float4 v); | |
setengah ceil(setengah v); | Ditambahkan di API level 24 |
half2 ceil(half2 v); | Ditambahkan di API level 24 |
half3 ceil(half3 v); | Ditambahkan di API level 24 |
half4 ceil(half4 v); | Ditambahkan di API level 24 |
Menampilkan bilangan bulat terkecil yang tidak kurang dari nilai.
Misalnya, ceil(1.2f)
akan menampilkan 2.f, dan ceil(-1.2f)
akan menampilkan -1.f.
Lihat juga floor().
klem : Membatasi nilai ke rentang
{i>char clamp<i} (nilai karakter, {i>char min_value<i}, {i>char max_value<i}); | Ditambahkan di API level 19 |
char2 clamp(nilai char2, char min_value, char max_value); | Ditambahkan di API level 19 |
char2 clamp(nilai char2, char2 min_value, char2 max_value); | Ditambahkan di API level 19 |
char3 clamp(nilai char3, char min_value, char max_value); | Ditambahkan di API level 19 |
char3 clamp(nilai char3, char3 min_value, char3 max_value); | Ditambahkan di API level 19 |
char4 clamp(nilai char4, char min_value, char max_value); | Ditambahkan di API level 19 |
char4 clamp(nilai char4, char4 min_value, char4 max_value); | Ditambahkan di API level 19 |
float clamp(nilai float, nilai min_float, nilai_maks float); | |
float2 clamp(nilai float2, float min_value, float max_value); | |
float2 clamp(nilai float2, float2 min_value, float2 max_value); | |
float3 clamp(nilai float3, float min_value, float max_value); | |
float3 clamp(nilai float3, float3 min_value, float3 max_value); | |
float4 clamp(nilai float4, float min_value, float max_value); | |
float4 clamp(nilai float4, float4 min_value, float4 max_value); | |
setengah clamp(nilai setengah, half min_value, half max_value); | Ditambahkan di API level 24 |
half2 clamp(nilai half2, half min_value, half max_value); | Ditambahkan di API level 24 |
half2 clamp(nilai half2, half2 min_value, half2 max_value); | Ditambahkan di API level 24 |
half3 clamp(nilai half3, half min_value, half max_value); | Ditambahkan di API level 24 |
half3 clamp(nilai half3, half3 min_value, half3 max_value); | Ditambahkan di API level 24 |
half4 clamp(nilai half4, half min_value, half max_value); | Ditambahkan di API level 24 |
half4 clamp(nilai half4, half4 min_value, half4 max_value); | Ditambahkan di API level 24 |
int clamp(int value, int min_value, int max_value); | Ditambahkan di API level 19 |
int2 clamp(nilai int2, int min_value, int max_value); | Ditambahkan di API level 19 |
int2 clamp(nilai int2, int2 min_value, int2 max_value); | Ditambahkan di API level 19 |
int3 clamp(nilai int3, int min_value, int max_value); | Ditambahkan di API level 19 |
int3 clamp(nilai int3, int3 min_value, int3 max_value); | Ditambahkan di API level 19 |
int4 clamp(nilai int4, int min_value, int max_value); | Ditambahkan di API level 19 |
int4 clamp(nilai int4, int4 min_value, int4 max_value); | Ditambahkan di API level 19 |
penjepit panjang(nilai panjang, nilai_min panjang, nilai_maks panjang); | Ditambahkan di API level 19 |
long2 clamp(nilai long2, long min_value, long_value_value); | Ditambahkan di API level 19 |
long2 clamp(nilai long2, long2 min_value, long2 max_value); | Ditambahkan di API level 19 |
long3 clamp(nilai long3, long min_value, long_value_value); | Ditambahkan di API level 19 |
long3 clamp(nilai long3, long3 min_value, long3 max_value); | Ditambahkan di API level 19 |
long4 clamp(nilai long4, long min_value, long_value_value); | Ditambahkan di API level 19 |
long4 clamp(nilai long4, long4 min_value, long4 max_value); | Ditambahkan di API level 19 |
penjepit pendek(nilai pendek, nilai_min pendek, nilai_maks pendek); | Ditambahkan di API level 19 |
clamp short2(nilai short2, nilai_min pendek, nilai_maks pendek); | Ditambahkan di API level 19 |
clamp short2(nilai short2, nilai_min short2, nilai_maks short2); | Ditambahkan di API level 19 |
clamp short3(nilai short3, min_value pendek, nilai_maks pendek); | Ditambahkan di API level 19 |
clamp short3(nilai short3, nilai_min short3, nilai_maks short3); | Ditambahkan di API level 19 |
clamp short4(nilai short4, min_value pendek, nilai_maks pendek); | Ditambahkan di API level 19 |
clamp short4(nilai short4, nilai_min short4, nilai_maks short4); | Ditambahkan di API level 19 |
uchar clamp(nilai uchar, uchar min_value, uchar max_value); | Ditambahkan di API level 19 |
uchar2 clamp(nilai uchar2, uchar min_value, uchar max_value); | Ditambahkan di API level 19 |
uchar2 clamp(nilai uchar2, uchar2 min_value, uchar2 max_value); | Ditambahkan di API level 19 |
uchar3 clamp(nilai uchar3, uchar min_value, uchar max_value); | Ditambahkan di API level 19 |
uchar3 clamp(nilai uchar3, uchar3 min_value, uchar3 max_value); | Ditambahkan di API level 19 |
uchar4 clamp(nilai uchar4, uchar min_value, uchar max_value); | Ditambahkan di API level 19 |
uchar4 clamp(nilai uchar4, uchar4 min_value, uchar4 max_value); | Ditambahkan di API level 19 |
uint clamp(uint value, uint min_value, uint max_value); | Ditambahkan di API level 19 |
uint2 clamp(nilai uint2, uint min_value, uint max_value); | Ditambahkan di API level 19 |
uint2 clamp(nilai uint2, uint2 min_value, uint2 max_value); | Ditambahkan di API level 19 |
uint3 clamp(nilai uint3, uint min_value, uint max_value); | Ditambahkan di API level 19 |
uint3 clamp(nilai uint3, uint3 min_value, uint3 max_value); | Ditambahkan di API level 19 |
uint4 clamp(nilai uint4, uint min_value, uint max_value); | Ditambahkan di API level 19 |
uint4 clamp(nilai uint4, uint4 min_value, uint4 max_value); | Ditambahkan di API level 19 |
ulong clamp(nilai ulong, ulong min_value, ulong max_value); | Ditambahkan di API level 19 |
ulong2 clamp(nilai ulong2, ulong min_value, ulong max_value); | Ditambahkan di API level 19 |
ulong2 clamp(nilai ulong2, ulong2 min_value, ulong2 max_value); | Ditambahkan di API level 19 |
ulong3 clamp(nilai ulong3, ulong min_value, ulong max_value); | Ditambahkan di API level 19 |
ulong3 clamp(nilai ulong3, ulong3 min_value, ulong3 max_value); | Ditambahkan di API level 19 |
ulong4 clamp(nilai ulong4, ulong min_value, ulong max_value); | Ditambahkan di API level 19 |
ulong4 clamp(nilai ulong4, ulong4 min_value, ulong4 max_value); | Ditambahkan di API level 19 |
ushort clamp(nilai ushort, min_value ushort, ushort max_value); | Ditambahkan di API level 19 |
ushort2 clamp(nilai ushort2, nilai_min ushort, nilai_maks ushort); | Ditambahkan di API level 19 |
ushort2 clamp(nilai ushort2, ushort2 min_value, ushort2 max_value); | Ditambahkan di API level 19 |
ushort3 clamp(nilai ushort3, ushort min_value, ushort max_value); | Ditambahkan di API level 19 |
ushort3 clamp(nilai ushort3, ushort3 min_value, ushort3 max_value); | Ditambahkan di API level 19 |
ushort4 clamp(nilai ushort4, ushort min_value, ushort max_value); | Ditambahkan di API level 19 |
ushort4 clamp(nilai ushort4, ushort4 min_value, ushort4 max_value); | Ditambahkan di API level 19 |
Parameter
nilai | Nilai yang akan dibatasi. |
---|---|
nilai_minimum | Batas bawah, skalar, atau vektor yang cocok. |
nilai_maks | Batas tinggi, harus cocok dengan jenis rendah. |
Menempelkan nilai ke batas tinggi dan rendah yang ditentukan. clamp() menampilkan min_value jika nilai < min_value, max_value jika nilai > max_value, jika tidak.
Ada dua varian clamp: satu dengan min dan maks adalah skalar yang diterapkan ke semua entri nilai, satunya lagi dengan min dan maks juga merupakan vektor.
Jika min_value lebih besar dari max_value, hasilnya tidak dapat ditentukan.
clz : Jumlah 0 bit di awal
{i>char clz<i}(nilai karakter); | |
char2 clz(nilai char2); | |
char3 clz(nilai char3); | |
char4 clz(nilai char4); | |
int clz(int value); | |
int2 clz(int2 value); | |
int3 clz(int3 value); | |
int4 clz(nilai int4); | |
clz pendek(nilai pendek); | |
short2 clz(nilai short2); | |
short3 clz(nilai short3); | |
short4 clz(nilai short4); | |
uchar clz(nilai uchar); | |
uchar2 clz(nilai uchar2); | |
uchar3 clz(nilai uchar3); | |
uchar4 clz(nilai uchar4); | |
uint clz(uint value); | |
uint2 clz(uint2 value); | |
uint3 clz(uint3 value); | |
uint4 clz(uint4 value); | |
ushort clz(ushort value); | |
ushort2 clz(nilai ushort2); | |
ushort3 clz(nilai ushort3); | |
ushort4 clz(nilai ushort4); |
Menampilkan jumlah 0-bit di awal dalam sebuah nilai.
Misalnya, clz((char)0x03)
akan menampilkan 6.
copysign : Menyalin tanda angka ke nomor lain
float copysign(float magnitude_value, float sign_value); | |
float2 copysign(float2 magnitude_value, float2 sign_value); | |
float3 copysign(float3 magnitude_value, float3 sign_value); | |
float4 copysign(float4 magnitude_value, float4 sign_value); | |
half copysign(setengah magnitude_value, half sign_value); | Ditambahkan di API level 24 |
half2 copysign(half2 magnitude_value, half2 sign_value); | Ditambahkan di API level 24 |
half3 copysign(half3 magnitude_value, half3 sign_value); | Ditambahkan di API level 24 |
half4 copysign(half4 magnitude_value, half4 sign_value); | Ditambahkan di API level 24 |
Menyalin tanda dari sign_value ke magnitude_value.
Nilai yang dikembalikan adalah magnitude_value atau -magnitude_value.
Misalnya, copysign(4.0f, -2.7f)
akan menampilkan -4.0f dan copysign(-4.0f, 2.7f)
akan menampilkan 4.0f.
cos : Kosinus
float cos(float v); | |
float2 cos(float2 v); | |
float3 cos(float3 v); | |
float4 cos(float4 v); | |
half cos(half v); | Ditambahkan di API level 24 |
half2 cos(half2 v); | Ditambahkan di API level 24 |
half3 cos(half3 v); | Ditambahkan di API level 24 |
half4 cos(half4 v); | Ditambahkan di API level 24 |
Menampilkan kosinus sudut yang diukur dalam radian.
Lihat juga native_cos().
cosh : Kosinus hiperbolik
float cosh(float v); | |
float2 cosh(float2 v); | |
float3 cosh(float3 v); | |
float4 cosh(float4 v); | |
setengah cosh(setengah v); | Ditambahkan di API level 24 |
half2 cosh(half2 v); | Ditambahkan di API level 24 |
half3 cosh(half3 v); | Ditambahkan di API level 24 |
half4 cosh(half4 v); | Ditambahkan di API level 24 |
Menampilkan kosinus hipebolik v, dengan v diukur dalam radian.
Lihat juga native_cosh().
cospi : Kosinus sebuah angka dikalikan dengan pi
float cospi(float v); | |
float2 cospi(float2 v); | |
float3 cospi(float3 v); | |
float4 cospi(float4 v); | |
setengah cospi(setengah v); | Ditambahkan di API level 24 |
half2 cospi(half2 v); | Ditambahkan di API level 24 |
half3 cospi(half3 v); | Ditambahkan di API level 24 |
half4 cospi(half4 v); | Ditambahkan di API level 24 |
Menampilkan kosinus (v * pi)
, dengan (v * pi)
diukur dalam radian.
Untuk mendapatkan kosinus nilai yang diukur dalam derajat, panggil cospi(v / 180.f)
.
Lihat juga native_cospi().
degrees : Mengonversi radian menjadi derajat
derajat float(float v); | |
float2 derajat(float2 v); | |
float3 derajat(float3 v); | |
float4 derajat(float4 v); | |
setengah derajat(setengah v); | Ditambahkan di API level 24 |
setengah2 derajat(half2 v); | Ditambahkan di API level 24 |
setengah3 derajat(half3 v); | Ditambahkan di API level 24 |
setengah4 derajat(half4 v); | Ditambahkan di API level 24 |
Mengonversi dari radian ke derajat.
erf : Fungsi error matematika
{i>float erf<i}(float v); | |
float2 erf(float2 v); | |
float3 erf(float3 v); | |
float4 erf(float4 v); | |
half erf(setengah v); | Ditambahkan di API level 24 |
half2 erf(half2 v); | Ditambahkan di API level 24 |
half3 erf(half3 v); | Ditambahkan di API level 24 |
half4 erf(half4 v); | Ditambahkan di API level 24 |
Menampilkan fungsi error.
erfc : Fungsi error komplementer matematika
{i>float erfc<i}(float v); | |
float2 erfc(float2 v); | |
float3 erfc(float3 v); | |
float4 erfc(float4 v); | |
setengah erfc(setengah v); | Ditambahkan di API level 24 |
half2 erfc(half2 v); | Ditambahkan di API level 24 |
half3 erfc(half3 v); | Ditambahkan di API level 24 |
half4 erfc(half4 v); | Ditambahkan di API level 24 |
Menampilkan fungsi error komplementer.
exp : e dipangkatkan menjadi angka
{i>float exp(float v<i}); | |
float2 exp(float2 v); | |
float3 exp(float3 v); | |
float4 exp(float4 v); | |
half exp(setengah v); | Ditambahkan di API level 24 |
half2 exp(half2 v); | Ditambahkan di API level 24 |
half3 exp(half3 v); | Ditambahkan di API level 24 |
half4 exp(half4 v); | Ditambahkan di API level 24 |
Menampilkan e yang dinaikkan ke v, yaitu e ^ v.
Lihat juga native_exp().
exp10 : 10 dipangkatkan menjadi angka
{i>float exp10(<i}float v); | |
float2 exp10(float2 v); | |
float3 exp10(float3 v); | |
float4 exp10(float4 v); | |
setengah exp10(setengah v); | Ditambahkan di API level 24 |
half2 exp10(half2 v); | Ditambahkan di API level 24 |
half3 exp10(half3 v); | Ditambahkan di API level 24 |
half4 exp10(half4 v); | Ditambahkan di API level 24 |
Menampilkan 10 yang dinaikkan ke v, yaitu 10.f ^ v.
Lihat juga native_exp10().
exp2 : 2 dipangkatkan menjadi suatu angka
{i>float exp2(<i}float v); | |
float2 exp2(float2 v); | |
float3 exp2(float3 v); | |
float4 exp2(float4 v); | |
half exp2(setengah v); | Ditambahkan di API level 24 |
half2 exp2(half2 v); | Ditambahkan di API level 24 |
half3 exp2(half3 v); | Ditambahkan di API level 24 |
half4 exp2(half4 v); | Ditambahkan di API level 24 |
Menampilkan 2 yang dinaikkan ke v, yaitu 2.f ^ v.
Lihat juga native_exp2().
expm1 : e dipangkatkan ke angka minus satu
float expm1(float v); | |
float2 expm1(float2 v); | |
float3 expm1(float3 v); | |
float4 expm1(float4 v); | |
setengah expm1(setengah v); | Ditambahkan di API level 24 |
half2 expm1(half2 v); | Ditambahkan di API level 24 |
half3 expm1(half3 v); | Ditambahkan di API level 24 |
half4 expm1(half4 v); | Ditambahkan di API level 24 |
Menampilkan e yang dinaikkan ke v minus 1, yaitu (e ^ v) - 1.
Lihat juga native_expm1().
fabs : Nilai absolut dari float
float fabs(float v); | |
float2 fabs(float2 v); | |
float3 fabs(float3 v); | |
float4 fabs(float4 v); | |
setengah fabs(setengah v); | Ditambahkan di API level 24 |
half2 fabs(half2 v); | Ditambahkan di API level 24 |
half3 fabs(half3 v); | Ditambahkan di API level 24 |
half4 fabs(half4 v); | Ditambahkan di API level 24 |
Menampilkan nilai absolut dari float v.
Untuk bilangan bulat, gunakan abs().
fdim : Perbedaan positif antara dua nilai
float fdim(float a, float b); | |
float2 fdim(float2 a, float2 b); | |
float3 fdim(float3 a, float3 b); | |
float4 fdim(float4 a, float4 b); | |
setengah fdim(setengah a, setengah b); | Ditambahkan di API level 24 |
half2 fdim(half2 a, half2 b); | Ditambahkan di API level 24 |
half3 fdim(half3 a, half3 b); | Ditambahkan di API level 24 |
half4 fdim(half4 a, half4 b); | Ditambahkan di API level 24 |
Menampilkan selisih positif antara dua nilai.
Jika a > b, mengembalikan (a - b) jika tidak maka mengembalikan 0f.
floor : Bilangan bulat terkecil yang tidak lebih besar dari nilai
lantai mengambang(float v); | |
float2 floor(float2 v); | |
float3 floor(float3 v); | |
float4 floor(float4 v); | |
setengah lantai(setengah v); | Ditambahkan di API level 24 |
half2 floor(half2 v); | Ditambahkan di API level 24 |
half3 floor(half3 v); | Ditambahkan di API level 24 |
half4 floor(half4 v); | Ditambahkan di API level 24 |
Menampilkan bilangan bulat terkecil yang tidak lebih besar dari nilai.
Misalnya, floor(1.2f)
akan menampilkan 1.f, dan floor(-1.2f)
akan menampilkan -2.f.
Lihat juga ceil().
fma : Kalikan dan tambahkan
float fma(float multiplicand1, float multiplicand2, offset float); | |
float2 fma(float2 multiplicand1, float2 multiplicand2, offset float2); | |
float3 fma(float3 multiplicand1, float3 multiplicand2, offset float3); | |
float4 fma(float4 multiplicand1, float4 multiplicand2, offset float4); | |
setengah fma(setengah multiplicand1, setengah multiplicand2, setengah offset); | Ditambahkan di API level 24 |
half2 fma(half2 multiplicand1, half2 multiplicand2, half2 offset); | Ditambahkan di API level 24 |
half3 fma(half3 multiplicand1, half3 multiplicand2, half3 offset); | Ditambahkan di API level 24 |
half4 fma(half4 multiplicand1, half4 multiplicand2, offset setengah4); | Ditambahkan di API level 24 |
Kalikan dan tambahkan. Menampilkan (multiplicand1 * multiplicand2) + offset
.
Fungsi ini mirip dengan mad(). fma() mempertahankan presisi penuh dari hasil perkalian dan melakukan pembulatan hanya setelah penambahan. mad() membulatkan setelah perkalian dan penambahan. Presisi tambahan ini tidak dijamin dalam mode rs_fp_relaxed.
fmax : Maksimum dua float
float fmax(float a, float b); | |
float2 fmax(float2 a, float b); | |
float2 fmax(float2 a, float2 b); | |
float3 fmax(float3 a, float b); | |
float3 fmax(float3 a, float3 b); | |
float4 fmax(float4 a, float b); | |
float4 fmax(float4 a, float4 b); | |
setengah fmax(setengah a, setengah b); | Ditambahkan di API level 24 |
half2 fmax(half2 a, setengah b); | Ditambahkan di API level 24 |
half2 fmax(half2 a, half2 b); | Ditambahkan di API level 24 |
half3 fmax(half3 a, setengah b); | Ditambahkan di API level 24 |
half3 fmax(half3 a, half3 b); | Ditambahkan di API level 24 |
half4 fmax(half4 a, setengah b); | Ditambahkan di API level 24 |
half4 fmax(half4 a, half4 b); | Ditambahkan di API level 24 |
Menampilkan nilai maksimum a dan b, yaitu (a < b ? b : a)
.
Fungsi max() menampilkan hasil yang identik, tetapi dapat diterapkan ke lebih banyak jenis data.
fmin : Minimum dua float
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); | |
setengah fmin(setengah a, setengah b); | Ditambahkan di API level 24 |
setengah2 fmin(setengah2 a, setengah b); | Ditambahkan di API level 24 |
half2 fmin(half2 a, half2 b); | Ditambahkan di API level 24 |
setengah3 fmin(setengah3 a, setengah b); | Ditambahkan di API level 24 |
half3 fmin(half3 a, half3 b); | Ditambahkan di API level 24 |
setengah4 fmin(setengah4 a, setengah b); | Ditambahkan di API level 24 |
half4 fmin(half4 a, half4 b); | Ditambahkan di API level 24 |
Menampilkan nilai minimum a dan b, yaitu (a > b ? b : a)
.
Fungsi min() menampilkan hasil yang identik, tetapi dapat diterapkan ke lebih banyak jenis data.
fmod : Modulo
{i>float fmod<i}(pembilang mengambang, penyebut {i>float<i}); | |
float2 fmod(pembilang float2, penyebut float2); | |
float3 fmod(pembilang float3, penyebut float3); | |
float4 fmod(pembilang float4, penyebut float4); | |
setengah fmod(setengah pembilang, setengah penyebut); | Ditambahkan di API level 24 |
half2 fmod(setengah2 pembilang, penyebut setengah2); | Ditambahkan di API level 24 |
half3 fmod(setengah3 pembilang, penyebut setengah3); | Ditambahkan di API level 24 |
half4 fmod(pembilang setengah4, penyebut setengah4); | Ditambahkan di API level 24 |
fraksi : Bagian pecahan positif
fraksi float(float v); | |
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); | |
setengah fraksi(setengah v); | Ditambahkan di API level 24 |
setengah frt(setengah v, setengah* lantai); | Ditambahkan di API level 24 |
half2 frt(half2 v); | Ditambahkan di API level 24 |
half2 fract(half2 v, half2* floor); | Ditambahkan di API level 24 |
half3 frt(half3 v); | Ditambahkan di API level 24 |
half3 fract(half3 v, half3* floor); | Ditambahkan di API level 24 |
setengah4 fraksi(half4 v); | Ditambahkan di API level 24 |
half4 fract(half4 v, half4* floor); | Ditambahkan di API level 24 |
Parameter
vs | Nilai input. |
---|---|
lantai | Jika lantai bukan null, *floor akan disetel ke lantai v. |
Menampilkan bagian pecahan positif dari v, yaitu v - floor(v)
.
Misalnya, fract(1.3f, &val)
menampilkan 0,3f dan menetapkan val ke 1.f.
fract(-1.3f, &val)
menampilkan 0,7f dan menetapkan val ke -2.f.
frexp : Mantissa biner dan eksponen
float frexp(float v, int* eksponen); | |
float2 frexp(eksponen float2 v, int2*); | |
float3 frexp(float3 v, int3* eksponen); | |
float4 frexp(eksponen float4 v, int4*); | |
setengah frexp(separuh v, eksponen int*); | Ditambahkan di API level 24 |
half2 frexp(eksponen half2 v, int2*); | Ditambahkan di API level 24 |
half3 frexp(eksponen half3 v, int3*); | Ditambahkan di API level 24 |
half4 frexp(eksponen half4 v, int4*); | Ditambahkan di API level 24 |
Parameter
vs | Nilai input. |
---|---|
eksponen | Jika eksponen bukan null, *eksponen akan ditetapkan ke eksponen dari v. |
half_recip : Resiprokal dikomputasi dengan presisi 16 bit
{i>float half_recip<i}(float v); | Ditambahkan di API level 17 |
float2 half_recip(float2 v); | Ditambahkan di API level 17 |
float3 half_recip(float3 v); | Ditambahkan di API level 17 |
float4 half_recip(float4 v); | Ditambahkan di API level 17 |
Menampilkan perkiraan kebalikan dari sebuah nilai.
Presisinya adalah nilai floating point 16 bit.
Lihat juga native_recip().
half_rsqrt : Kebalikan dari root kuadrat yang dihitung dengan presisi 16 bit
{i>float half_rsqrt<i}(float v); | Ditambahkan di API level 17 |
float2 half_rsqrt(float2 v); | Ditambahkan di API level 17 |
float3 half_rsqrt(float3 v); | Ditambahkan di API level 17 |
float4 half_rsqrt(float4 v); | Ditambahkan di API level 17 |
Menampilkan nilai perkiraan (1.f / sqrt(value))
.
Presisinya adalah nilai floating point 16 bit.
Lihat juga rsqrt(), native_rsqrt().
half_sqrt : Root kuadrat dihitung hingga presisi 16 bit
{i>float half_sqrt<i}(float v); | Ditambahkan di API level 17 |
float2 half_sqrt(float2 v); | Ditambahkan di API level 17 |
float3 half_sqrt(float3 v); | Ditambahkan di API level 17 |
float4 half_sqrt(float4 v); | Ditambahkan di API level 17 |
Menampilkan perkiraan akar kuadrat dari sebuah nilai.
Presisinya adalah nilai floating point 16 bit.
Lihat juga sqrt(), native_sqrt().
hipot : Sisi miring
hipot mengambang(float a, float b); | |
hypot float2(float2 a, float2 b); | |
hypot float3(float3 a, float3 b); | |
hypot float4(float4 a, float4 b); | |
setengah hipot(setengah a, setengah b); | Ditambahkan di API level 24 |
half2 hypot(half2 a, half2 b); | Ditambahkan di API level 24 |
half3 hipot(half3 a, half3 b); | Ditambahkan di API level 24 |
half4 hipot(half4 a, half4 b); | Ditambahkan di API level 24 |
Menampilkan sisi miring, yaitu sqrt(a * a + b * b)
.
Lihat juga native_hypot().
ilogb : Eksponen basis dua
int ilogb(float v); | |
int ilogb(setengah v); | Ditambahkan di API level 24 |
int2 ilogb(float2 v); | |
int2 ilogb(half2 v); | Ditambahkan di API level 24 |
int3 ilogb(float3 v); | |
int3 ilogb(half3 v); | Ditambahkan di API level 24 |
int4 ilogb(float4 v); | |
int4 ilogb(half4 v); | Ditambahkan di API level 24 |
ldexp : Membuat floating point dari mantissa dan eksponen
float ldexp(float mantissa, int eksponen); | |
float2 ldexp(float2 mantissa, int eksponen); | |
float2 ldexp(float2 mantissa, int2 eksponen); | |
float3 ldexp(float3 mantissa, int exponent); | |
float3 ldexp(float3 mantissa, int3 eksponen); | |
float4 ldexp(float4 mantissa, int exponent); | |
float4 ldexp(float4 mantissa, int4 eksponen); | |
setengah ldexp(setengah mantissa, int eksponen); | Ditambahkan di API level 24 |
half2 ldexp(half2 mantissa, int eksponen); | Ditambahkan di API level 24 |
half2 ldexp(half2 mantissa, int2 eksponen); | Ditambahkan di API level 24 |
half3 ldexp(half3 mantissa, int eksponen); | Ditambahkan di API level 24 |
half3 ldexp(half3 mantissa, int3 eksponen); | Ditambahkan di API level 24 |
half4 ldexp(half4 mantissa, int eksponen); | Ditambahkan di API level 24 |
half4 ldexp(half4 mantissa, int4 eksponen); | Ditambahkan di API level 24 |
Parameter
Mantissa | Mantissa. |
---|---|
eksponen | Eksponen, komponen tunggal atau vektor yang cocok. |
Menampilkan floating point yang dibuat dari mantissa dan eksponen, yaitu (eksponen mantissa * 2 ^).
Lihat frexp() untuk operasi balik.
lgamma : Logaritma alami fungsi gamma
float lgamma(float v); | |
float lgamma(float v, int* sign_of_gamma); | |
float2 lgamma(float2 v); | |
float2 lgamma(float2 v, int2* sign_of_gamma); | |
float3 lgamma(float3 v); | |
float3 lgamma(float3 v, int3* sign_of_gamma); | |
float4 lgamma(float4 v); | |
float4 lgamma(float4 v, int4* sign_of_gamma); | |
setengah lgamma(setengah v); | Ditambahkan di API level 24 |
half lgamma(half v, int* sign_of_gamma); | Ditambahkan di API level 24 |
half2 lgamma(half2 v); | Ditambahkan di API level 24 |
half2 lgamma(half2 v, int2* sign_of_gamma); | Ditambahkan di API level 24 |
half3 lgamma(half3 v); | Ditambahkan di API level 24 |
half3 lgamma(half3 v, int3* sign_of_gamma); | Ditambahkan di API level 24 |
half4 lgamma(half4 v); | Ditambahkan di API level 24 |
half4 lgamma(half4 v, int4* sign_of_gamma); | Ditambahkan di API level 24 |
Parameter
vs | |
---|---|
tanda_gamma | Jika sign_of_gamma bukan null, *sign_of_gamma akan diset ke -1.f jika gamma v negatif, jika tidak menjadi 1.f. |
log : Logaritma alami
log float(float v); | |
log float2(float2 v); | |
log float3(float3 v); | |
log float4(float4 v); | |
setengah log(setengah v); | Ditambahkan di API level 24 |
half2 log(half2 v); | Ditambahkan di API level 24 |
half3 log(half3 v); | Ditambahkan di API level 24 |
half4 log(half4 v); | Ditambahkan di API level 24 |
Menampilkan logaritma natural.
Lihat juga native_log().
log10 : Logaritma basis 10
float log10(float v); | |
float2 log10(float2 v); | |
float3 log10(float3 v); | |
float4 log10(float4 v); | |
setengah log10(setengah v); | Ditambahkan di API level 24 |
half2 log10(half2 v); | Ditambahkan di API level 24 |
half3 log10(half3 v); | Ditambahkan di API level 24 |
half4 log10(half4 v); | Ditambahkan di API level 24 |
Menampilkan logaritma basis 10.
Lihat juga native_log10().
log1p : Logaritma alami nilai ditambah 1
float log1p(float v); | |
float2 log1p(float2 v); | |
float3 log1p(float3 v); | |
float4 log1p(float4 v); | |
setengah log1p(setengah v); | Ditambahkan di API level 24 |
half2 log1p(half2 v); | Ditambahkan di API level 24 |
half3 log1p(half3 v); | Ditambahkan di API level 24 |
half4 log1p(half4 v); | Ditambahkan di API level 24 |
Menampilkan logaritma natural dari (v + 1.f)
.
Lihat juga native_log1p().
log2 : Logaritma basis 2
float log2(float v); | |
float2 log2(float2 v); | |
float3 log2(float3 v); | |
float4 log2(float4 v); | |
setengah log2(setengah v); | Ditambahkan di API level 24 |
half2 log2(half2 v); | Ditambahkan di API level 24 |
half3 log2(half3 v); | Ditambahkan di API level 24 |
half4 log2(half4 v); | Ditambahkan di API level 24 |
Menampilkan logaritma basis 2.
Lihat juga native_log2().
logb : Eksponen basis dua
float logb(float v); | |
float2 logb(float2 v); | |
float3 logb(float3 v); | |
float4 logb(float4 v); | |
half logb(setengah v); | Ditambahkan di API level 24 |
half2 logb(half2 v); | Ditambahkan di API level 24 |
half3 logb(half3 v); | Ditambahkan di API level 24 |
half4 logb(half4 v); | Ditambahkan di API level 24 |
Menampilkan basis dua eksponen dari sebuah nilai, dengan mantissa antara 1.f (inklusif) dan 2.f (eksklusif).
Misalnya, logb(8.5f)
akan menampilkan 3.f.
Karena perbedaan pada mantissa, angka ini kurang dari satu yang ditampilkan oleh frexp().
ilogb() serupa, tetapi menampilkan bilangan bulat.
mad : Kalikan dan tambahkan
float mad(float multiplicand1, float multiplicand2, float offset); | |
float2 mad(float2 multiplicand1, float2 multiplicand2, offset float2); | |
float3 mad(float3 multiplicand1, float3 multiplicand2, offset float3); | |
float4 mad(float4 multiplicand1, float4 multiplicand2, offset float4); | |
setengah marah(setengah multiplicand1, setengah multiplicand2, setengah offset); | Ditambahkan di API level 24 |
half2 marah(half2 multiplicand1, half2 multiplicand2, setengah2 offset); | Ditambahkan di API level 24 |
half3 mad(half3 multiplicand1, half3 multiplicand2, half3 offset); | Ditambahkan di API level 24 |
half4 marah(half4 multiplicand1, half4 multiplicand2, setengah4 offset); | Ditambahkan di API level 24 |
Kalikan dan tambahkan. Menampilkan (multiplicand1 * multiplicand2) + offset
.
Fungsi ini mirip dengan fma(). fma() mempertahankan presisi penuh dari hasil perkalian dan melakukan pembulatan hanya setelah penambahan. mad() dibulatkan setelah perkalian dan penambahan. Dalam mode rs_fp_relaxed, mad() mungkin tidak melakukan pembulatan setelah multiplicaiton.
maks : Maksimum
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 maks(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); | |
setengah maks(setengah a, setengah b); | Ditambahkan di API level 24 |
half2 maks(half2 a, setengah b); | Ditambahkan di API level 24 |
half2 maks(half2 a, half2 b); | Ditambahkan di API level 24 |
half3 maks(setengah3 a, setengah b); | Ditambahkan di API level 24 |
half3 maks(half3 a, half3 b); | Ditambahkan di API level 24 |
setengah4 maks(setengah4 a, setengah b); | Ditambahkan di API level 24 |
half4 maks(half4 a, half4 b); | Ditambahkan di API level 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); | Ditambahkan di API level 21 |
long2 max(long2 a, long2 b); | Ditambahkan di API level 21 |
long3 max(long3 a, long3 b); | Ditambahkan di API level 21 |
long4 max(long4 a, long4 b); | Ditambahkan di API level 21 |
short max(pendek a, pendek 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); | Ditambahkan di API level 21 |
ulong2 max(ulong2 a, ulong2 b); | Ditambahkan di API level 21 |
ulong3 max(ulong3 a, ulong3 b); | Ditambahkan di API level 21 |
ulong4 max(ulong4 a, ulong4 b); | Ditambahkan di API level 21 |
ushort max(ushort a, ushort b); | |
ushort2 max(ushort2 a, ushort2 b); | |
ushort3 max(ushort3 a, ushort3 b); | |
ushort4 max(ushort4 a, ushort4 b); |
Menampilkan nilai maksimum dua argumen.
mnt : Minimum
char min(char a, char b); | |
char2 min(char2 a, char2 b); | |
char3 min(char3 a, char3 b); | |
char4 min(char4 a, char4 b); | |
float min(float a, float b); | |
float2 min(float2 a, float b); | |
float2 min(float2 a, float2 b); | |
float3 min(float3 a, float b); | |
float3 min(float3 a, float3 b); | |
float4 min(float4 a, float b); | |
float4 min(float4 a, float4 b); | |
setengah menit(setengah a, setengah b); | Ditambahkan di API level 24 |
setengah2 menit(setengah2 a, setengah b); | Ditambahkan di API level 24 |
half2 menit(half2 a, half2 b); | Ditambahkan di API level 24 |
setengah3 menit(setengah3 a, setengah b); | Ditambahkan di API level 24 |
half3 menit(half3 a, half3 b); | Ditambahkan di API level 24 |
setengah4 menit(setengah4 a, setengah b); | Ditambahkan di API level 24 |
half4 menit(half4 a, half4 b); | Ditambahkan di API level 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); | |
{i>long min<i} (panjang a, panjang b); | Ditambahkan di API level 21 |
long2 mnt(long2 a, long2 b); | Ditambahkan di API level 21 |
long3 mnt(long3 a, long3 b); | Ditambahkan di API level 21 |
long4 mnt(long4 a, long4 b); | Ditambahkan di API level 21 |
min pendek(singkat a, pendek b); | |
short2 min(short2 a, short2 b); | |
short3 min(short3 a, short3 b); | |
short4 menit(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); | Ditambahkan di API level 21 |
ulong2 min(ulong2 a, ulong2 b); | Ditambahkan di API level 21 |
ulong3 min(ulong3 a, ulong3 b); | Ditambahkan di API level 21 |
ulong4 min(ulong4 a, ulong4 b); | Ditambahkan di API level 21 |
ushort min(ushort a, ushort b); | |
ushort2 min(ushort2 a, ushort2 b); | |
ushort3 min(ushort3 a, ushort3 b); | |
ushort4 min(ushort4 a, ushort4 b); |
Menampilkan nilai minimum dua argumen.
mix : Mencampur dua nilai
campuran float(awal mengambang, berhenti mengambang, fraksi mengambang); | |
mix float2(float2 start, float2 stop, float Fraksi); | |
campuran float2(float2 start, float2 stop, float2 fraksi); | |
float3 mix(float3 start, float3 stop, float integrity); | |
campuran float3(float3 start, float3 stop, float3 fraksi); | |
float4 mix(float4 start, float4 stop, floatfraksi); | |
campuran float4(float4 start, float4 stop, float4 fraksi); | |
campuran setengah(setengah bagian awal, setengah bagian, setengah pecahan); | Ditambahkan di API level 24 |
campuran half2(half2 start, half2 stop, setengah fraksi); | Ditambahkan di API level 24 |
campuran half2(half2 start, half2 stop, half2 pecahan); | Ditambahkan di API level 24 |
campuran half3(half3 start, half3 stop, setengah fraksi); | Ditambahkan di API level 24 |
campuran half3(half3 start, half3 stop, half3 fraksi); | Ditambahkan di API level 24 |
campuran setengah4(setengah4 start, half4 stop, setengah fraksi); | Ditambahkan di API level 24 |
campuran half4(half4 start, half4 stop, half4 fraksi); | Ditambahkan di API level 24 |
Mengembalikan awal + ((stop - awal) * pecahan).
Hal ini berguna untuk menggabungkan dua nilai. Misalnya, untuk membuat warna baru, yaitu
40% color1 dan 60% color2, gunakan mix(color1, color2, 0.6f)
.
modf : Komponen integral dan pecahan
float modf(float v, float* integral_part); | |
float2 modf(float2 v, float2* integral_part); | |
float3 modf(float3 v, float3* integral_part); | |
float4 modf(float4 v, float4* integral_part); | |
setengah modf(setengah v, setengah* integral_part); | Ditambahkan di API level 24 |
half2 modf(half2 v, half2* integral_part); | Ditambahkan di API level 24 |
half3 modf(half3 v, half3* integral_part); | Ditambahkan di API level 24 |
half4 modf(half4 v, half4* integral_part); | Ditambahkan di API level 24 |
Parameter
vs | Nilai sumber. |
---|---|
bagian_integral | *integral_part akan diatur ke bagian integral dari angka. |
Return
Bagian floating point dari nilai. |
Menampilkan komponen integral dan pecahan dari sebuah angka.
Kedua komponen akan memiliki tanda yang sama dengan x. Misalnya, untuk input -3.72f, *integral_part akan ditetapkan ke -3.f dan .72f akan ditampilkan.
nan : Bukan Angka
float nan(uint v); |
Parameter
vs | Tidak digunakan. |
---|
Menampilkan nilai NaN (Bukan Angka).
nan_half : Bukan Angka
half nan_half(); | Ditambahkan di API level 24 |
Menampilkan nilai NaN floating point presisi setengah (Bukan Angka).
native_acos : Perkiraan kosinus terbalik
{i>float native_acos<i}(float v); | Ditambahkan di API level 21 |
float2 native_acos(float2 v); | Ditambahkan di API level 21 |
float3 native_acos(float3 v); | Ditambahkan di API level 21 |
float4 native_acos(float4 v); | Ditambahkan di API level 21 |
setengah native_acos(setengah v); | Ditambahkan di API level 24 |
half2 native_acos(half2 v); | Ditambahkan di API level 24 |
half3 native_acos(half3 v); | Ditambahkan di API level 24 |
half4 native_acos(half4 v); | Ditambahkan di API level 24 |
Menampilkan perkiraan kosinus terbalik, dalam radian.
Fungsi ini memberikan hasil yang tidak terdefinisi dari nilai input yang kurang dari -1 atau lebih besar dari 1.
Lihat juga acos().
native_acosh : Perkiraan kosinus hiperbolik terbalik
{i>float native_acosh<i}(float v); | Ditambahkan di API level 21 |
float2 native_acosh(float2 v); | Ditambahkan di API level 21 |
float3 native_acosh(float3 v); | Ditambahkan di API level 21 |
float4 native_acosh(float4 v); | Ditambahkan di API level 21 |
setengah native_acosh(setengah v); | Ditambahkan di API level 24 |
half2 native_acosh(half2 v); | Ditambahkan di API level 24 |
half3 native_acosh(half3 v); | Ditambahkan di API level 24 |
half4 native_acosh(half4 v); | Ditambahkan di API level 24 |
Menampilkan perkiraan kosinus hiperbolik terbalik, dalam radian.
Lihat juga acosh().
native_acospi : Perkiraan kosinus terbalik dibagi pi
float native_acospi(float v); | Ditambahkan di API level 21 |
float2 native_acospi(float2 v); | Ditambahkan di API level 21 |
float3 native_acospi(float3 v); | Ditambahkan di API level 21 |
float4 native_acospi(float4 v); | Ditambahkan di API level 21 |
setengah native_acospi(setengah v); | Ditambahkan di API level 24 |
half2 native_acospi(half2 v); | Ditambahkan di API level 24 |
half3 native_acospi(half3 v); | Ditambahkan di API level 24 |
half4 native_acospi(half4 v); | Ditambahkan di API level 24 |
Menampilkan perkiraan kosinus terbalik dalam radian, dibagi dengan pi.
Untuk mendapatkan kosinus terbalik yang diukur dalam derajat, gunakan acospi(a) * 180.f
.
Fungsi ini memberikan hasil yang tidak terdefinisi dari nilai input yang kurang dari -1 atau lebih besar dari 1.
Lihat juga acospi().
native_asin : Perkiraan sinus terbalik
{i>float native_asin<i}(float v); | Ditambahkan di API level 21 |
float2 native_asin(float2 v); | Ditambahkan di API level 21 |
float3 native_asin(float3 v); | Ditambahkan di API level 21 |
float4 native_asin(float4 v); | Ditambahkan di API level 21 |
setengah native_asin(setengah v); | Ditambahkan di API level 24 |
half2 native_asin(half2 v); | Ditambahkan di API level 24 |
half3 native_asin(half3 v); | Ditambahkan di API level 24 |
half4 native_asin(half4 v); | Ditambahkan di API level 24 |
Menampilkan perkiraan sinus terbalik, dalam radian.
Fungsi ini memberikan hasil yang tidak terdefinisi dari nilai input yang kurang dari -1 atau lebih besar dari 1.
Lihat juga asin().
native_asinh : Perkiraan sinus hiperbolik terbalik
float native_asinh(float v); | Ditambahkan di API level 21 |
float2 native_asinh(float2 v); | Ditambahkan di API level 21 |
float3 native_asinh(float3 v); | Ditambahkan di API level 21 |
float4 native_asinh(float4 v); | Ditambahkan di API level 21 |
setengah native_asinh(setengah v); | Ditambahkan di API level 24 |
half2 native_asinh(half2 v); | Ditambahkan di API level 24 |
half3 native_asinh(half3 v); | Ditambahkan di API level 24 |
half4 native_asinh(half4 v); | Ditambahkan di API level 24 |
Menampilkan perkiraan sinus hiperbolik terbalik, dalam radian.
Lihat juga asinh().
native_asinpi : Perkiraan sinus terbalik dibagi pi
{i>float native_asinpi<i}(float v); | Ditambahkan di API level 21 |
float2 native_asinpi(float2 v); | Ditambahkan di API level 21 |
float3 native_asinpi(float3 v); | Ditambahkan di API level 21 |
float4 native_asinpi(float4 v); | Ditambahkan di API level 21 |
setengah native_asinpi(setengah v); | Ditambahkan di API level 24 |
half2 native_asinpi(half2 v); | Ditambahkan di API level 24 |
half3 native_asinpi(half3 v); | Ditambahkan di API level 24 |
half4 native_asinpi(half4 v); | Ditambahkan di API level 24 |
Menampilkan perkiraan sinus terbalik dalam radian, dibagi dengan pi.
Untuk mendapatkan sinus terbalik yang diukur dalam derajat, gunakan asinpi(a) * 180.f
.
Fungsi ini memberikan hasil yang tidak terdefinisi dari nilai input yang kurang dari -1 atau lebih besar dari 1.
Lihat juga asinpi().
native_atan : Perkiraan tangen terbalik
float native_atan(float v); | Ditambahkan di API level 21 |
float2 native_atan(float2 v); | Ditambahkan di API level 21 |
float3 native_atan(float3 v); | Ditambahkan di API level 21 |
float4 native_atan(float4 v); | Ditambahkan di API level 21 |
setengah native_atan(setengah v); | Ditambahkan di API level 24 |
half2 native_atan(half2 v); | Ditambahkan di API level 24 |
half3 native_atan(half3 v); | Ditambahkan di API level 24 |
half4 native_atan(half4 v); | Ditambahkan di API level 24 |
Menampilkan perkiraan tangen terbalik, dalam radian.
Lihat juga atan().
native_atan2 : Memperkirakan tangen terbalik sebuah rasio
float native_atan2(pembilang mengambang, penyebut mengambang); | Ditambahkan di API level 21 |
float2 native_atan2(pembilang float2, penyebut float2); | Ditambahkan di API level 21 |
float3 native_atan2(pembilang float3, penyebut float3); | Ditambahkan di API level 21 |
float4 native_atan2(pembilang float4, penyebut float4); | Ditambahkan di API level 21 |
setengah native_atan2(setengah pembilang, setengah penyebut); | Ditambahkan di API level 24 |
half2 native_atan2(pembilang setengah2, penyebut setengah2); | Ditambahkan di API level 24 |
half3 native_atan2(setengah3 pembilang, penyebut setengah3); | Ditambahkan di API level 24 |
half4 native_atan2(pembilang setengah4, penyebut setengah4); | Ditambahkan di API level 24 |
Parameter
pembilang | Pembilang. |
---|---|
penyebut | Penyebut. Dapat berupa 0. |
Menampilkan perkiraan tangen terbalik dari (numerator / denominator)
, dalam radian.
Lihat juga atan2().
native_atan2pi : Perkiraan tangen invers dari sebuah rasio, dibagi dengan pi
float native_atan2pi(pembilang mengambang, penyebut float); | Ditambahkan di API level 21 |
float2 native_atan2pi(pembilang float2, penyebut float2); | Ditambahkan di API level 21 |
float3 native_atan2pi(pembilang float3, penyebut float3); | Ditambahkan di API level 21 |
float4 native_atan2pi(pembilang float4, penyebut float4); | Ditambahkan di API level 21 |
setengah native_atan2pi(setengah pembilang, setengah penyebut); | Ditambahkan di API level 24 |
half2 native_atan2pi(setengah2 pembilang, penyebut setengah2); | Ditambahkan di API level 24 |
half3 native_atan2pi(setengah3 pembilang, penyebut setengah3); | Ditambahkan di API level 24 |
half4 native_atan2pi(pembilang setengah4, penyebut setengah4); | Ditambahkan di API level 24 |
Parameter
pembilang | Pembilang. |
---|---|
penyebut | Penyebut. Dapat berupa 0. |
Menampilkan perkiraan tangen terbalik dari (numerator / denominator)
, dalam radian, dibagi dengan pi.
Untuk mendapatkan tangen terbalik yang diukur dalam derajat, gunakan atan2pi(n, d) * 180.f
.
Lihat juga atan2pi().
native_atanh : Perkiraan tangen hiperbolik terbalik
float native_atanh(float v); | Ditambahkan di API level 21 |
float2 native_atanh(float2 v); | Ditambahkan di API level 21 |
float3 native_atanh(float3 v); | Ditambahkan di API level 21 |
float4 native_atanh(float4 v); | Ditambahkan di API level 21 |
setengah native_atanh(setengah v); | Ditambahkan di API level 24 |
half2 native_atanh(half2 v); | Ditambahkan di API level 24 |
half3 native_atanh(half3 v); | Ditambahkan di API level 24 |
half4 native_atanh(half4 v); | Ditambahkan di API level 24 |
Menampilkan perkiraan tangen hiperbolik terbalik, dalam radian.
Lihat juga atanh().
native_atanpi : Perkiraan tangen terbalik dibagi pi
float native_atanpi(float v); | Ditambahkan di API level 21 |
float2 native_atanpi(float2 v); | Ditambahkan di API level 21 |
float3 native_atanpi(float3 v); | Ditambahkan di API level 21 |
float4 native_atanpi(float4 v); | Ditambahkan di API level 21 |
setengah native_atanpi(setengah v); | Ditambahkan di API level 24 |
half2 native_atanpi(half2 v); | Ditambahkan di API level 24 |
half3 native_atanpi(half3 v); | Ditambahkan di API level 24 |
half4 native_atanpi(half4 v); | Ditambahkan di API level 24 |
Menampilkan perkiraan tangen terbalik dalam radian, dibagi dengan pi.
Untuk mendapatkan tangen terbalik yang diukur dalam derajat, gunakan atanpi(a) * 180.f
.
Lihat juga atanpi().
native_cbrt : Perkiraan akar pangkat tiga
{i>float native_cbrt<i}(float v); | Ditambahkan di API level 21 |
float2 native_cbrt(float2 v); | Ditambahkan di API level 21 |
float3 native_cbrt(float3 v); | Ditambahkan di API level 21 |
float4 native_cbrt(float4 v); | Ditambahkan di API level 21 |
setengah native_cbrt(setengah v); | Ditambahkan di API level 24 |
half2 native_cbrt(half2 v); | Ditambahkan di API level 24 |
half3 native_cbrt(half3 v); | Ditambahkan di API level 24 |
half4 native_cbrt(half4 v); | Ditambahkan di API level 24 |
Menampilkan perkiraan akar kubik.
Lihat juga cbrt().
native_cos : Perkiraan kosinus
float native_cos(float v); | Ditambahkan di API level 21 |
float2 native_cos(float2 v); | Ditambahkan di API level 21 |
float3 native_cos(float3 v); | Ditambahkan di API level 21 |
float4 native_cos(float4 v); | Ditambahkan di API level 21 |
half native_cos(setengah v); | Ditambahkan di API level 24 |
half2 native_cos(half2 v); | Ditambahkan di API level 24 |
half3 native_cos(half3 v); | Ditambahkan di API level 24 |
half4 native_cos(half4 v); | Ditambahkan di API level 24 |
Menampilkan perkiraan kosinus sudut yang diukur dalam radian.
Lihat juga cos().
native_cosh : Perkiraan kosinus hipebolik
{i>float native_cosh<i}(float v); | Ditambahkan di API level 21 |
float2 native_cosh(float2 v); | Ditambahkan di API level 21 |
float3 native_cosh(float3 v); | Ditambahkan di API level 21 |
float4 native_cosh(float4 v); | Ditambahkan di API level 21 |
setengah native_cosh(setengah v); | Ditambahkan di API level 24 |
half2 native_cosh(half2 v); | Ditambahkan di API level 24 |
half3 native_cosh(half3 v); | Ditambahkan di API level 24 |
half4 native_cosh(half4 v); | Ditambahkan di API level 24 |
Menampilkan perkiraan kosinus hipebolik.
Lihat juga cosh().
native_cospi : Perkiraan kosinus sebuah angka yang dikalikan dengan pi
float native_cospi(float v); | Ditambahkan di API level 21 |
float2 native_cospi(float2 v); | Ditambahkan di API level 21 |
float3 native_cospi(float3 v); | Ditambahkan di API level 21 |
float4 native_cospi(float4 v); | Ditambahkan di API level 21 |
setengah native_cospi(setengah v); | Ditambahkan di API level 24 |
half2 native_cospi(half2 v); | Ditambahkan di API level 24 |
half3 native_cospi(half3 v); | Ditambahkan di API level 24 |
half4 native_cospi(half4 v); | Ditambahkan di API level 24 |
Mengembalikan perkiraan kosinus (v * pi), dengan (v * pi) diukur dalam radian.
Untuk mendapatkan kosinus nilai yang diukur dalam derajat, panggil cospi(v / 180.f)
.
Lihat juga cospi().
native_divide : Pembagian perkiraan
{i>float native_divide<i}(float left_vector, float right_vector); | Ditambahkan di API level 21 |
float2 native_divide(float2 left_vector, float2 right_vector); | Ditambahkan di API level 21 |
float3 native_divide(float3 left_vector, float3 right_vector); | Ditambahkan di API level 21 |
float4 native_divide(float4 left_vector, float4 right_vector); | Ditambahkan di API level 21 |
setengah native_divide(setengah left_vector, half right_vector); | Ditambahkan di API level 24 |
half2 native_divide(half2 left_vector, half2 right_vector); | Ditambahkan di API level 24 |
half3 native_divide(half3 left_vector, half3 right_vector); | Ditambahkan di API level 24 |
half4 native_divide(half4 left_vector, half4 right_vector); | Ditambahkan di API level 24 |
Menghitung perkiraan pembagian dua nilai.
native_exp : Perkiraan e dinaikkan ke angka
float native_exp(float v); | Ditambahkan di API level 18 |
float2 native_exp(float2 v); | Ditambahkan di API level 18 |
float3 native_exp(float3 v); | Ditambahkan di API level 18 |
float4 native_exp(float4 v); | Ditambahkan di API level 18 |
setengah native_exp(setengah v); | Ditambahkan di API level 24 |
half2 native_exp(half2 v); | Ditambahkan di API level 24 |
half3 native_exp(half3 v); | Ditambahkan di API level 24 |
half4 native_exp(half4 v); | Ditambahkan di API level 24 |
Perkiraan waktu berakhir cepat
Ini berlaku untuk input dari -86.f hingga 86.f. Presisinya tidak lebih buruk daripada yang diharapkan dari penggunaan nilai floating point 16 bit.
Lihat juga exp().
native_exp10 : Perkiraan angka 10 ditingkatkan menjadi sebuah angka
{i>float native_exp10<i}(float v); | Ditambahkan di API level 18 |
float2 native_exp10(float2 v); | Ditambahkan di API level 18 |
float3 native_exp10(float3 v); | Ditambahkan di API level 18 |
float4 native_exp10(float4 v); | Ditambahkan di API level 18 |
setengah native_exp10(setengah v); | Ditambahkan di API level 24 |
half2 native_exp10(half2 v); | Ditambahkan di API level 24 |
half3 native_exp10(half3 v); | Ditambahkan di API level 24 |
half4 native_exp10(half4 v); | Ditambahkan di API level 24 |
Perkiraan cepat exp10.
Ini berlaku untuk input dari -37.f hingga 37.f. Presisinya tidak lebih buruk daripada yang diharapkan dari penggunaan nilai floating point 16 bit.
Lihat juga exp10().
native_exp2 : Perkiraan 2 dinaikkan ke sebuah angka
{i>float native_exp2<i}(float v); | Ditambahkan di API level 18 |
float2 native_exp2(float2 v); | Ditambahkan di API level 18 |
float3 native_exp2(float3 v); | Ditambahkan di API level 18 |
float4 native_exp2(float4 v); | Ditambahkan di API level 18 |
setengah native_exp2(setengah v); | Ditambahkan di API level 24 |
half2 native_exp2(half2 v); | Ditambahkan di API level 24 |
half3 native_exp2(half3 v); | Ditambahkan di API level 24 |
half4 native_exp2(half4 v); | Ditambahkan di API level 24 |
Perkiraan exp2 cepat.
Berlaku untuk input dari -125.f hingga 125.f. Presisinya tidak lebih buruk daripada yang diharapkan dari penggunaan nilai floating point 16 bit.
Lihat juga exp2().
native_expm1 : Perkiraan e dinaikkan ke angka minus satu
float native_expm1(float v); | Ditambahkan di API level 21 |
float2 native_expm1(float2 v); | Ditambahkan di API level 21 |
float3 native_expm1(float3 v); | Ditambahkan di API level 21 |
float4 native_expm1(float4 v); | Ditambahkan di API level 21 |
setengah native_expm1(setengah v); | Ditambahkan di API level 24 |
half2 native_expm1(half2 v); | Ditambahkan di API level 24 |
half3 native_expm1(half3 v); | Ditambahkan di API level 24 |
half4 native_expm1(half4 v); | Ditambahkan di API level 24 |
Menampilkan perkiraan (e ^ v) - 1.
Lihat juga expm1().
native_hypot : Perkiraan sisi miring
{i>float native_hypot<i}(float a, float b); | Ditambahkan di API level 21 |
float2 native_hypot(float2 a, float2 b); | Ditambahkan di API level 21 |
float3 native_hypot(float3 a, float3 b); | Ditambahkan di API level 21 |
float4 native_hypot(float4 a, float4 b); | Ditambahkan di API level 21 |
setengah native_hypot(setengah a, setengah b); | Ditambahkan di API level 24 |
half2 native_hypot(setengah2 a, setengah2 b); | Ditambahkan di API level 24 |
half3 native_hypot(half3 a, half3 b); | Ditambahkan di API level 24 |
half4 native_hypot(half4 a, half4 b); | Ditambahkan di API level 24 |
Menampilkan perkiraan native_sqrt(a * a + b * b)
Lihat juga hypot().
native_log : Perkiraan logaritma alami
{i>float native_log<i}(float v); | Ditambahkan di API level 18 |
float2 native_log(float2 v); | Ditambahkan di API level 18 |
float3 native_log(float3 v); | Ditambahkan di API level 18 |
float4 native_log(float4 v); | Ditambahkan di API level 18 |
setengah native_log(setengah v); | Ditambahkan di API level 24 |
half2 native_log(half2 v); | Ditambahkan di API level 24 |
half3 native_log(half3 v); | Ditambahkan di API level 24 |
half4 native_log(half4 v); | Ditambahkan di API level 24 |
native_log10 : Logaritma perkiraan basis 10
{i>float native_log10<i}(float v); | Ditambahkan di API level 18 |
float2 native_log10(float2 v); | Ditambahkan di API level 18 |
float3 native_log10(float3 v); | Ditambahkan di API level 18 |
float4 native_log10(float4 v); | Ditambahkan di API level 18 |
setengah native_log10(setengah v); | Ditambahkan di API level 24 |
half2 native_log10(setengah2 v); | Ditambahkan di API level 24 |
half3 native_log10(half3 v); | Ditambahkan di API level 24 |
half4 native_log10(half4 v); | Ditambahkan di API level 24 |
native_log1p : Perkiraan logaritma alami sebuah nilai ditambah 1
{i>float native_log1p<i} (float v); | Ditambahkan di API level 21 |
float2 native_log1p(float2 v); | Ditambahkan di API level 21 |
float3 native_log1p(float3 v); | Ditambahkan di API level 21 |
float4 native_log1p(float4 v); | Ditambahkan di API level 21 |
setengah native_log1p(setengah v); | Ditambahkan di API level 24 |
half2 native_log1p(half2 v); | Ditambahkan di API level 24 |
half3 native_log1p(half3 v); | Ditambahkan di API level 24 |
half4 native_log1p(half4 v); | Ditambahkan di API level 24 |
Menampilkan perkiraan logaritma natural (v + 1,0f)
Lihat juga log1p().
native_log2 : Logaritma perkiraan basis 2
{i>float native_log2<i}(float v); | Ditambahkan di API level 18 |
float2 native_log2(float2 v); | Ditambahkan di API level 18 |
float3 native_log2(float3 v); | Ditambahkan di API level 18 |
float4 native_log2(float4 v); | Ditambahkan di API level 18 |
setengah native_log2(setengah v); | Ditambahkan di API level 24 |
half2 native_log2(half2 v); | Ditambahkan di API level 24 |
half3 native_log2(half3 v); | Ditambahkan di API level 24 |
half4 native_log2(half4 v); | Ditambahkan di API level 24 |
native_powr : Perkiraan basis positif yang dipangkatkan ke dalam eksponen
float native_powr(dasar mengambang, eksponen mengambang); | Ditambahkan di API level 18 |
float2 native_powr(basis float2, eksponen float2); | Ditambahkan di API level 18 |
float3 native_powr(float3 base, eksponen float3); | Ditambahkan di API level 18 |
float4 native_powr(basis float4, eksponen float4); | Ditambahkan di API level 18 |
setengah native_powr(setengah basis, setengah eksponen); | Ditambahkan di API level 24 |
half2 native_powr(setengah2 basis, setengah2 eksponen); | Ditambahkan di API level 24 |
half3 native_powr(setengah3 basis, setengah3 eksponen); | Ditambahkan di API level 24 |
half4 native_powr(setengah4 basis, setengah4 eksponen); | Ditambahkan di API level 24 |
Parameter
dasar | Harus di antara 0.f dan 256.f. Fungsi ini tidak akurat untuk nilai yang sangat mendekati nol. |
---|---|
eksponen | Harus di antara -15.f dan 15.f. |
Perkiraan cepat (eksponen basis ^).
Lihat juga powr().
native_recip : Perkiraan timbal balik
float native_recip(float v); | Ditambahkan di API level 21 |
float2 native_recip(float2 v); | Ditambahkan di API level 21 |
float3 native_recip(float3 v); | Ditambahkan di API level 21 |
float4 native_recip(float4 v); | Ditambahkan di API level 21 |
setengah native_recip(setengah v); | Ditambahkan di API level 24 |
half2 native_recip(half2 v); | Ditambahkan di API level 24 |
half3 native_recip(half3 v); | Ditambahkan di API level 24 |
half4 native_recip(half4 v); | Ditambahkan di API level 24 |
Menampilkan perkiraan kebalikan suatu nilai.
Lihat juga half_recip().
native_rootn : Perkiraan root ke-n
float native_rootn(float v, int n); | Ditambahkan di API level 21 |
float2 native_rootn(float2 v, int2 n); | Ditambahkan di API level 21 |
float3 native_rootn(float3 v, int3 n); | Ditambahkan di API level 21 |
float4 native_rootn(float4 v, int4 n); | Ditambahkan di API level 21 |
setengah native_rootn(setengah v, int n); | Ditambahkan di API level 24 |
half2 native_rootn(half2 v, int2 n); | Ditambahkan di API level 24 |
half3 native_rootn(half3 v, int3 n); | Ditambahkan di API level 24 |
half4 native_rootn(half4 v, int4 n); | Ditambahkan di API level 24 |
Hitung perkiraan akar ke-N dari sebuah nilai.
Lihat juga rootn().
native_rsqrt : Perkiraan kebalikan akar kuadrat
{i>float native_rsqrt<i}(float v); | Ditambahkan di API level 21 |
float2 native_rsqrt(float2 v); | Ditambahkan di API level 21 |
float3 native_rsqrt(float3 v); | Ditambahkan di API level 21 |
float4 native_rsqrt(float4 v); | Ditambahkan di API level 21 |
setengah native_rsqrt(setengah v); | Ditambahkan di API level 24 |
half2 native_rsqrt(half2 v); | Ditambahkan di API level 24 |
half3 native_rsqrt(half3 v); | Ditambahkan di API level 24 |
half4 native_rsqrt(half4 v); | Ditambahkan di API level 24 |
Menampilkan perkiraan (1 / sqrt(v)).
Lihat juga rsqrt(), half_rsqrt().
native_sin : Perkiraan sinus
{i>float native_sin<i}(float v); | Ditambahkan di API level 21 |
float2 native_sin(float2 v); | Ditambahkan di API level 21 |
float3 native_sin(float3 v); | Ditambahkan di API level 21 |
float4 native_sin(float4 v); | Ditambahkan di API level 21 |
setengah native_sin(setengah v); | Ditambahkan di API level 24 |
half2 native_sin(half2 v); | Ditambahkan di API level 24 |
half3 native_sin(half3 v); | Ditambahkan di API level 24 |
half4 native_sin(half4 v); | Ditambahkan di API level 24 |
Menampilkan perkiraan sinus dari sudut yang diukur dalam radian.
Lihat juga sin().
native_sincos : Perkiraan sinus dan kosinus
float native_sincos(float v, float* cos); | Ditambahkan di API level 21 |
float2 native_sincos(float2 v, float2* cos); | Ditambahkan di API level 21 |
float3 native_sincos(float3 v, float3* cos); | Ditambahkan di API level 21 |
float4 native_sincos(float4 v, float4* cos); | Ditambahkan di API level 21 |
half native_sincos(setengah v, setengah* cos); | Ditambahkan di API level 24 |
half2 native_sincos(half2 v, half2* cos); | Ditambahkan di API level 24 |
half3 native_sincos(half3 v, half3* cos); | Ditambahkan di API level 24 |
half4 native_sincos(half4 v, half4* cos); | Ditambahkan di API level 24 |
Parameter
vs | Nilai masuk dalam radian. |
---|---|
cos | *cos akan diatur ke nilai kosinus. |
Return
Sinus. |
Menampilkan perkiraan sinus dan kosinus dari sebuah nilai.
Lihat juga sincos().
native_sinh : Perkiraan sinus hiperbolik
float native_sinh(float v); | Ditambahkan di API level 21 |
float2 native_sinh(float2 v); | Ditambahkan di API level 21 |
float3 native_sinh(float3 v); | Ditambahkan di API level 21 |
float4 native_sinh(float4 v); | Ditambahkan di API level 21 |
setengah native_sinh(setengah v); | Ditambahkan di API level 24 |
half2 native_sinh(half2 v); | Ditambahkan di API level 24 |
half3 native_sinh(half3 v); | Ditambahkan di API level 24 |
half4 native_sinh(half4 v); | Ditambahkan di API level 24 |
Menampilkan perkiraan sinus hiperbolik dari nilai yang ditentukan dalam radian.
Lihat juga sinh().
native_sinpi : Perkiraan sinus dari suatu angka yang dikalikan dengan pi
{i>float native_sinpi<i}(float v); | Ditambahkan di API level 21 |
float2 native_sinpi(float2 v); | Ditambahkan di API level 21 |
float3 native_sinpi(float3 v); | Ditambahkan di API level 21 |
float4 native_sinpi(float4 v); | Ditambahkan di API level 21 |
setengah native_sinpi(setengah v); | Ditambahkan di API level 24 |
half2 native_sinpi(setengah2 v); | Ditambahkan di API level 24 |
half3 native_sinpi(half3 v); | Ditambahkan di API level 24 |
half4 native_sinpi(setengah4 v); | Ditambahkan di API level 24 |
Menampilkan perkiraan sinus (v * pi), dengan (v * pi) diukur dalam radian.
Untuk mendapatkan sinus dari nilai yang diukur dalam derajat, panggil sinpi(v / 180.f)
.
Lihat juga sinpi().
native_sqrt : Perkiraan akar kuadrat
{i>float native_sqrt<i}(float v); | Ditambahkan di API level 21 |
float2 native_sqrt(float2 v); | Ditambahkan di API level 21 |
float3 native_sqrt(float3 v); | Ditambahkan di API level 21 |
float4 native_sqrt(float4 v); | Ditambahkan di API level 21 |
setengah native_sqrt(setengah v); | Ditambahkan di API level 24 |
half2 native_sqrt(half2 v); | Ditambahkan di API level 24 |
half3 native_sqrt(half3 v); | Ditambahkan di API level 24 |
half4 native_sqrt(half4 v); | Ditambahkan di API level 24 |
native_tan : Perkiraan tangen
{i>float native_tan<i}(float v); | Ditambahkan di API level 21 |
float2 native_tan(float2 v); | Ditambahkan di API level 21 |
float3 native_tan(float3 v); | Ditambahkan di API level 21 |
float4 native_tan(float4 v); | Ditambahkan di API level 21 |
setengah native_tan(setengah v); | Ditambahkan di API level 24 |
half2 native_tan(half2 v); | Ditambahkan di API level 24 |
half3 native_tan(half3 v); | Ditambahkan di API level 24 |
half4 native_tan(half4 v); | Ditambahkan di API level 24 |
Menampilkan perkiraan tangen sudut yang diukur dalam radian.
native_tanh : Perkiraan tangen hiperbolik
float native_tanh(float v); | Ditambahkan di API level 21 |
float2 native_tanh(float2 v); | Ditambahkan di API level 21 |
float3 native_tanh(float3 v); | Ditambahkan di API level 21 |
float4 native_tanh(float4 v); | Ditambahkan di API level 21 |
setengah native_tanh(setengah v); | Ditambahkan di API level 24 |
half2 native_tanh(half2 v); | Ditambahkan di API level 24 |
half3 native_tanh(half3 v); | Ditambahkan di API level 24 |
half4 native_tanh(half4 v); | Ditambahkan di API level 24 |
Menampilkan perkiraan tangen hiperbolik sebuah nilai.
Lihat juga tanh().
native_tanpi : Perkiraan tangen sebuah angka dikalikan dengan pi
float native_tanpi(float v); | Ditambahkan di API level 21 |
float2 native_tanpi(float2 v); | Ditambahkan di API level 21 |
float3 native_tanpi(float3 v); | Ditambahkan di API level 21 |
float4 native_tanpi(float4 v); | Ditambahkan di API level 21 |
setengah native_tanpi(setengah v); | Ditambahkan di API level 24 |
half2 native_tanpi(half2 v); | Ditambahkan di API level 24 |
half3 native_tanpi(half3 v); | Ditambahkan di API level 24 |
half4 native_tanpi(half4 v); | Ditambahkan di API level 24 |
Menampilkan perkiraan tangen (v * pi), dengan (v * pi) diukur dalam radian.
Untuk mendapatkan tangen nilai yang diukur dalam derajat, panggil tanpi(v / 180.f)
.
Lihat juga tanpi().
nextafter : Angka floating point berikutnya
float nextafter(float v, float target); | |
float2 nextafter(float2 v, float2 target); | |
float3 nextafter(float3 v, float3 target); | |
float4 nextafter(float4 v, float4 target); | |
setengah sesudahnya(setengah v, setengah target); | Ditambahkan di API level 24 |
half2 berikutnya(half2 v, half2 target); | Ditambahkan di API level 24 |
half3 nextafter(half3 v, half3 target); | Ditambahkan di API level 24 |
half4 berikutnya(half4 v, half4 target); | Ditambahkan di API level 24 |
Menampilkan bilangan floating point yang dapat diwakili berikutnya dari v menuju target.
Dalam mode rs_fp_relaxed, nilai input yang didenormalisasi mungkin tidak menghasilkan nilai yang didenormalisasi berikutnya, karena dukungan untuk nilai yang didenormalisasi bersifat opsional dalam mode santai.
pow : Basis yang dinaikkan ke eksponen
pow mengambang(dasar mengambang, eksponen mengambang); | |
float2 pow(basis float2, eksponen float2); | |
float3 pow(basis float3, eksponen float3); | |
float4 pow(basis float4, eksponen float4); | |
setengah pow(setengah basis, setengah eksponen); | Ditambahkan di API level 24 |
setengah2 pow(half2 basis, half2 eksponen); | Ditambahkan di API level 24 |
half3 pow(half3 basis, half3 eksponen); | Ditambahkan di API level 24 |
half4 pow(half4 basis, half4 eksponen); | Ditambahkan di API level 24 |
pown : Basis yang dipangkatkan ke eksponen bilangan bulat
pown float(basis mengambang, eksponen int); | |
float2 pown(float2 base, int2 eksponen); | |
float3 pown(float3 base, eksponen int3); | |
float4 pown(basis float4, eksponen int4); | |
setengah pown(setengah basis, eksponen int); | Ditambahkan di API level 24 |
half2 pown(half2 basis, eksponen int2); | Ditambahkan di API level 24 |
half3 pown(half3 base, eksponen int3); | Ditambahkan di API level 24 |
half4 pown(half4 basis, eksponen int4); | Ditambahkan di API level 24 |
powr : Basis positif yang dipangkatkan ke eksponen
powr(basis mengambang, eksponen mengambang); | |
float2 powr(basis float2, eksponen float2); | |
float3 powr(basis float3, eksponen float3); | |
float4 powr(basis float4, eksponen float4); | |
setengah powr(setengah basis, setengah eksponen); | Ditambahkan di API level 24 |
setengah2 powr(setengah2 basis, setengah2 eksponen); | Ditambahkan di API level 24 |
setengah3 powr(setengah3 basis, setengah3 eksponen); | Ditambahkan di API level 24 |
setengah4 powr(setengah4 basis, setengah4 eksponen); | Ditambahkan di API level 24 |
Menampilkan basis yang dipangkatkan ke eksponen pangkat, yaitu eksponen basis ^. basis harus >= 0.
pow() dan pown() serupa. Keduanya tidak membuat asumsi tentang basisnya. pow() menggunakan eksponen float, sedangkan pown() mengambil bilangan bulat.
Lihat juga native_powr().
radian : Mengonversi derajat menjadi radian
radian float(float v); | |
float2 radian(float2 v); | |
float3 radian(float3 v); | |
float4 radian(float4 v); | |
setengah radian(setengah v); | Ditambahkan di API level 24 |
half2 radian(half2 v); | Ditambahkan di API level 24 |
half3 radian(half3 v); | Ditambahkan di API level 24 |
half4 radian(half4 v); | Ditambahkan di API level 24 |
Mengonversi dari derajat ke radian.
sisa : Sisa pembagian
sisa {i>float<i} (pembilang mengambang, penyebut {i>float<i}); | |
float2 sisa(pembilang float2, penyebut float2); | |
float3 sisa(pembilang float3, penyebut float3); | |
float4 sisa(pembilang float4, penyebut float4); | |
setengah sisa(setengah pembilang, penyebut setengah); | Ditambahkan di API level 24 |
setengah2 sisa(setengah2 pembilang, setengah2 penyebut); | Ditambahkan di API level 24 |
setengah3 sisa(setengah3 pembilang, penyebut setengah3); | Ditambahkan di API level 24 |
setengah4 sisa(setengah4 pembilang, penyebut setengah4); | Ditambahkan di API level 24 |
Menampilkan sisa (pembilang / penyebut), dengan hasil bagi dibulatkan ke bilangan bulat terdekat.
Fungsi fmod() mirip, tetapi dibulatkan ke arah bilangan bulat terdekat.
Misalnya, fmod(-3.8f, 2.f)
menampilkan -1.8f (-3.8f - -1.f * 2.f)
sedangkan remainder(-3.8f, 2.f)
menampilkan 0.2f (-3.8f - -2.f * 2.f).
remquo : Sisa dan hasil bagi dari suatu pembagian
float remquo(pembilang mengambang, penyebut mengambang, int* quotient); | |
float2 remquo(pembilang float2, penyebut float2, hasil bagi int2*); | |
float3 remquo(pembilang float3, penyebut float3, hasil bagi int3*); | |
float4 remquo(pembilang float4, penyebut float4, hasil bagi int4*); | |
setengah remquo(setengah pembilang, setengah penyebut, int* quotient); | Ditambahkan di API level 24 |
half2 remquo(pembilang setengah2, penyebut setengah2, hasil bagi int2*); | Ditambahkan di API level 24 |
setengah3 remquo(pembilang setengah3, penyebut setengah3, hasil bagi int3*); | Ditambahkan di API level 24 |
half4 remquo(pembilang setengah4, penyebut setengah4, hasil bagi int4*); | Ditambahkan di API level 24 |
Parameter
pembilang | Pembilang. |
---|---|
penyebut | Penyebut. |
hasil bagi | *hasil bagi akan diatur ke hasil bagi bilangan bulat. |
Return
Sisanya, presisi hanya untuk tiga bit yang rendah. |
Menampilkan hasil bagi dan sisa dari (pembilang / penyebut).
Hanya tanda dan tiga bit terendah dari hasil bagi yang dijamin akurat.
Fungsi ini berguna untuk mengimplementasikan fungsi berkala. Tiga bit rendah dari hasil bagi memberikan kuadran dan sisanya jarak dalam kuadran.
Misalnya, implementasi sin(x) dapat memanggil remquo(x, PI / 2.f, &quadrant)
untuk mengurangi nilai x yang sangat besar ke sesuatu yang berada dalam rentang terbatas.
Contoh: remquo(-23.5f, 8.f, ")
menetapkan tiga bit terendah dari quot ke 3
dan tanda negatif. Hasilnya adalah 0,5f.
rint : Membulatkan ke genap
{i>float rint<i} (float v); | |
float2 rint(float2 v); | |
float3 rint(float3 v); | |
float4 rint(float4 v); | |
setengah rint(setengah v); | Ditambahkan di API level 24 |
half2 rint(half2 v); | Ditambahkan di API level 24 |
half3 rint(half3 v); | Ditambahkan di API level 24 |
half4 rint(half4 v); | Ditambahkan di API level 24 |
Membulatkan ke nilai integral terdekat.
rint() membulatkan nilai setengah menjadi genap. Misalnya, rint(0.5f)
akan menampilkan 0.f dan
rint(1.5f)
akan menampilkan 2.f. Demikian pula, rint(-0.5f)
akan menampilkan -0.f dan
rint(-1.5f)
akan menampilkan -2.f.
round() serupa, tetapi dibulatkan dari nol. trunc() memotong pecahan desimal.
rootn : Root ke-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); | |
setengah rootn(setengah v, int n); | Ditambahkan di API level 24 |
half2 rootn(half2 v, int2 n); | Ditambahkan di API level 24 |
half3 rootn(half3 v, int3 n); | Ditambahkan di API level 24 |
half4 rootn(half4 v, int4 n); | Ditambahkan di API level 24 |
Hitung akar ke-N dari sebuah nilai.
Lihat juga native_rootn().
bulat : Membulatkan menjauh dari nol
{i>float round<i} (float v); | |
float2 round(float2 v); | |
float3 round(float3 v); | |
float4 round(float4 v); | |
half round(setengah v); | Ditambahkan di API level 24 |
half2 round(half2 v); | Ditambahkan di API level 24 |
half3 round(half3 v); | Ditambahkan di API level 24 |
half4 round(half4 v); | Ditambahkan di API level 24 |
Membulatkan ke nilai integral terdekat.
round() membulatkan nilai setengah dari nol. Misalnya, round(0.5f)
akan menampilkan 1.f
dan round(1.5f)
akan menampilkan 2.f. Demikian pula, round(-0.5f)
akan menampilkan -1.f
dan round(-1.5f)
akan menampilkan -2.f.
rint() serupa, tetapi membulatkan setengah nilai menuju genap. trunc() memotong pecahan desimal.
rsClamp : Membatasi nilai ke suatu rentang
{i>char rsClamp<i}(jumlah karakter, {i>char low, char high); | |
int rsClamp(int amount, int low, int high); | |
short rsClamp(short amount, short low, short high); | |
uchar rsClamp(jumlah uchar, uchar rendah, uchar tinggi); | |
uint rsClamp(uint amount, uint low, uint high); | |
ushort rsClamp(ushort amount, ushort low, ushort high); |
Parameter
jumlah | Nilai yang harus ditetapkan. |
---|---|
rendah | Batas bawah. |
tinggi | Batas atas. |
Tidak digunakan lagi. Sebagai gantinya, gunakan clamp().
Tetapkan nilai antara rendah dan tinggi.
rsFrac : Menampilkan bagian pecahan dari float
{i>float rsFrac<i}(float v); |
Tidak digunakan lagi. Sebagai gantinya, gunakan fract().
Menampilkan bagian pecahan dari float
rsRand : Angka acak pseudo
{i>float rsRand<i}(float max_value); | |
{i>float rsRand<i}(float min_value, float max_value); | |
int rsRand(int max_value); | |
int rsRand(int min_value, int max_value); |
Menampilkan nilai acak antara 0 (atau min_value) dan max_malue.
rsqrt : Kebalikan dari akar kuadrat
{i>float rsqrt<i}(float v); | |
float2 rsqrt(float2 v); | |
float3 rsqrt(float3 v); | |
float4 rsqrt(float4 v); | |
setengah rsqrt(setengah v); | Ditambahkan di API level 24 |
half2 rsqrt(half2 v); | Ditambahkan di API level 24 |
half3 rsqrt(half3 v); | Ditambahkan di API level 24 |
half4 rsqrt(half4 v); | Ditambahkan di API level 24 |
Menampilkan (1 / sqrt(v)).
Lihat juga half_rsqrt(), native_rsqrt().
tanda : Tanda nilai
tanda {i>float<i} (float v); | |
tanda float2(float2 v); | |
tanda float3(float3 v); | |
tanda float4(float4 v); | |
tanda setengah(setengah v); | Ditambahkan di API level 24 |
tanda half2(half2 v); | Ditambahkan di API level 24 |
tanda half3(half3 v); | Ditambahkan di API level 24 |
tanda half4(half4 v); | Ditambahkan di API level 24 |
Menampilkan tanda nilai.
if (v < 0) return -1.f; else if (v > 0) return 1.f; else return 0.f;
sin : Sinus
{i>float sin<i} (float v); | |
float2 sin(float2 v); | |
float3 sin(float3 v); | |
float4 sin(float4 v); | |
half sin(setengah v); | Ditambahkan di API level 24 |
half2 sin(half2 v); | Ditambahkan di API level 24 |
half3 sin(half3 v); | Ditambahkan di API level 24 |
half4 sin(half4 v); | Ditambahkan di API level 24 |
Menampilkan sinus dari sudut yang diukur dalam radian.
Lihat juga native_sin().
sincos : Sinus dan kosinus
sincos float(float v, float* cos); | |
float2 sincos(float2 v, float2* cos); | |
float3 sincos(float3 v, float3* cos); | |
float4 sincos(float4 v, float4* cos); | |
setengah sincos(setengah v, half* cos); | Ditambahkan di API level 24 |
half2 sincos(half2 v, half2* cos); | Ditambahkan di API level 24 |
half3 sincos(half3 v, half3* cos); | Ditambahkan di API level 24 |
half4 sincos(half4 v, half4* cos); | Ditambahkan di API level 24 |
Parameter
vs | Nilai masuk dalam radian. |
---|---|
cos | *cos akan diatur ke nilai kosinus. |
Return
Sinus dari v. |
Menampilkan sinus dan kosinus dari sebuah nilai.
Lihat juga native_sincos().
sinh : Sinus hiperbolik
{i>float sinh<i}(float v); | |
float2 sinh(float2 v); | |
float3 sinh(float3 v); | |
float4 sinh(float4 v); | |
setengah sinh(setengah v); | Ditambahkan di API level 24 |
half2 sinh(half2 v); | Ditambahkan di API level 24 |
half3 sinh(half3 v); | Ditambahkan di API level 24 |
half4 sinh(half4 v); | Ditambahkan di API level 24 |
Menampilkan sinus hiperbolik v, dengan v diukur dalam radian.
Lihat juga native_sinh().
sinpi : Sinus dari sebuah angka yang dikalikan dengan pi
float sinpi(float v); | |
float2 sinpi(float2 v); | |
float3 sinpi(float3 v); | |
float4 sinpi(float4 v); | |
setengah sinpi(setengah v); | Ditambahkan di API level 24 |
half2 sinpi(half2 v); | Ditambahkan di API level 24 |
half3 sinpi(half3 v); | Ditambahkan di API level 24 |
half4 sinpi(setengah4 v); | Ditambahkan di API level 24 |
Menampilkan sinus (v * pi), dengan (v * pi) diukur dalam radian.
Untuk mendapatkan sinus dari nilai yang diukur dalam derajat, panggil sinpi(v / 180.f)
.
Lihat juga native_sinpi().
sqrt : Akar pangkat dua
{i>float sqrt<i}(float v); | |
float2 sqrt(float2 v); | |
float3 sqrt(float3 v); | |
float4 sqrt(float4 v); | |
setengah sqrt(setengah v); | Ditambahkan di API level 24 |
half2 sqrt(half2 v); | Ditambahkan di API level 24 |
half3 sqrt(half3 v); | Ditambahkan di API level 24 |
half4 sqrt(half4 v); | Ditambahkan di API level 24 |
Menampilkan akar kuadrat dari sebuah nilai.
Lihat juga half_sqrt(), native_sqrt().
step : 0 jika kurang dari nilai, 1 jika tidak
langkah float(tepi mengambang, float v); | |
float2 langkah(tepi mengambang, float2 v); | Ditambahkan di API level 21 |
float2 langkah(tepi float2, float v); | |
float2 langkah(tepi float2, float2 v); | |
float3 langkah(tepi mengambang, float3 v); | Ditambahkan di API level 21 |
float3 langkah(tepi float3, float v); | |
float3 langkah(tepi float3, float3 v); | |
float4 langkah(tepi mengambang, float4 v); | Ditambahkan di API level 21 |
float4 langkah(tepi float4, float v); | |
float4 langkah(tepi float4, float4 v); | |
setengah langkah(setengah tepi, setengah v); | Ditambahkan di API level 24 |
setengah2 langkah(setengah edge, half2 v); | Ditambahkan di API level 24 |
half2 langkah(half2 edge, half v); | Ditambahkan di API level 24 |
half2 langkah(half2 edge, half2 v); | Ditambahkan di API level 24 |
setengah3 langkah(setengah edge, half3 v); | Ditambahkan di API level 24 |
half3 langkah(half3 edge, half v); | Ditambahkan di API level 24 |
half3 langkah(half3 edge, half3 v); | Ditambahkan di API level 24 |
setengah4 langkah(setengah edge, half4 v); | Ditambahkan di API level 24 |
setengah4 langkah(setengah4 edge, half v); | Ditambahkan di API level 24 |
half4 langkah(half4 edge, half4 v); | Ditambahkan di API level 24 |
Menampilkan 0.f jika v < edge, 1.f jika sebaliknya.
Fungsi ini dapat berguna untuk membuat komputasi bersyarat tanpa menggunakan loop dan petunjuk
cabang. Misalnya, daripada menghitung (a[i] < b[i]) ? 0.f : atan2(a[i], b[i])
untuk elemen vektor yang terkait, Anda dapat menggunakan step(a, b) * atan2(a, b)
.
tan : Tangen
warna cokelat(float v); | |
float2 tan(float2 v); | |
float3 tan(float3 v); | |
float4 tan(float4 v); | |
half tan(setengah v); | Ditambahkan di API level 24 |
half2 tan(half2 v); | Ditambahkan di API level 24 |
half3 tan(half3 v); | Ditambahkan di API level 24 |
half4 tan(half4 v); | Ditambahkan di API level 24 |
Menampilkan tangen sudut yang diukur dalam radian.
Lihat juga native_tan().
tanh : Tangen hiperbolik
tanh float(float v); | |
float2 tanh(float2 v); | |
float3 tanh(float3 v); | |
float4 tanh(float4 v); | |
setengah tanh(setengah v); | Ditambahkan di API level 24 |
half2 tanh(half2 v); | Ditambahkan di API level 24 |
half3 tanh(half3 v); | Ditambahkan di API level 24 |
half4 tanh(half4 v); | Ditambahkan di API level 24 |
Menampilkan tangen hiperbolik sebuah nilai.
Lihat juga native_tanh().
tanpi : Tangen suatu angka dikalikan dengan pi
tanpi float(float v); | |
float2 tanpi(float2 v); | |
float3 tanpi(float3 v); | |
float4 tanpi(float4 v); | |
setengah tanpi(setengah v); | Ditambahkan di API level 24 |
half2 tanpi(half2 v); | Ditambahkan di API level 24 |
half3 tanpi(half3 v); | Ditambahkan di API level 24 |
half4 tanpi(half4 v); | Ditambahkan di API level 24 |
Menampilkan tangen dari (v * pi), dengan (v * pi) diukur dalam radian.
Untuk mendapatkan tangen nilai yang diukur dalam derajat, panggil tanpi(v / 180.f)
.
Lihat juga native_tanpi().
tgamma : Fungsi gamma
float tgamma(float v); | |
float2 tgamma(float2 v); | |
float3 tgamma(float3 v); | |
float4 tgamma(float4 v); | |
half tgamma(half v); | Ditambahkan di API level 24 |
half2 tgamma(half2 v); | Ditambahkan di API level 24 |
half3 tgamma(half3 v); | Ditambahkan di API level 24 |
half4 tgamma(half4 v); | Ditambahkan di API level 24 |
Menampilkan fungsi gamma dari sebuah nilai.
Lihat juga lgamma().
trunc : Memotong floating point
float trunc(float v); | |
float2 trunc(float2 v); | |
float3 trunc(float3 v); | |
float4 trunc(float4 v); | |
setengah trunc(setengah v); | Ditambahkan di API level 24 |
half2 trunc(half2 v); | Ditambahkan di API level 24 |
half3 trunc(half3 v); | Ditambahkan di API level 24 |
half4 trunc(half4 v); | Ditambahkan di API level 24 |