Halaman ini diterjemahkan oleh Cloud Translation API.

Konstanta dan Fungsi Matematika RenderScript

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

Menampilkan sisa (pembilang / penyebut), dengan hasil bagi dibulatkan menuju nol.

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

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.

Menampilkan mantissa biner dan eksponen v, yaitu v == mantissa * 2 ^ exponent.

Mantissa selalu antara 0,5 (inklusif) dan 1,0 (eksklusif).

Lihat ldexp() untuk operasi balik. Lihat juga logb() dan ilogb().

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

Menampilkan basis dua eksponen dari sebuah nilai, dengan mantissa antara 1.f (inklusif) dan 2.f (eksklusif).

Misalnya, ilogb(8.5f) akan menampilkan 3.

Karena perbedaan pada mantissa, angka ini lebih kecil satu daripada yang ditampilkan oleh frexp().

logb() serupa tetapi menampilkan float.

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.

Menampilkan logaritma alami dari nilai absolut fungsi gamma, yaitu log(fabs(tgamma(v))).

Lihat juga tgamma().

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

Log perkiraan cepat.

Tidak akurat untuk nilai yang sangat mendekati nol.

Lihat juga log().

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

Perkiraan log10 cepat.

Tidak akurat untuk nilai yang sangat mendekati nol.

Lihat juga log10().

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

Perkiraan log2 cepat.

Tidak akurat untuk nilai yang sangat mendekati nol.

Lihat juga log2().

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

Menampilkan perkiraan sqrt(v).

Lihat juga sqrt(), half_sqrt().

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

Menampilkan basis yang dipangkatkan ke eksponen pangkat, yaitu eksponen basis ^.

pown() dan powr() serupa. pown() menggunakan eksponen bilangan bulat. powr() mengasumsikan basisnya adalah non-negatif.

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

Menampilkan basis yang dipangkatkan ke eksponen pangkat, yaitu eksponen basis ^.

pow() dan powr() serupa. Keduanya mengambil eksponen float. powr() juga mengasumsikan basisnya adalah non-negatif.

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

Membulatkan ke integral menggunakan pemotongan.

Misalnya, trunc(1.7f) akan menampilkan 1.f dan trunc(-1.7f) akan menampilkan -1.f.

Lihat rint() dan round() untuk opsi pembulatan lainnya.