Bu sayfa, Cloud Translation API ile çevrilmiştir.

RenderScript Matematiksel Sabitler ve İşlevler

Genel bakış

Aşağıdaki matematiksel fonksiyonlar skalerler ve vektörlere uygulanabilir. Vektörlere uygulandığında döndürülen değer, girişteki her bir girişe uygulanan fonksiyonun vektörüdür.

Örnek: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);

Bunun yerine girdiyi n boyutlu uzayda tek bir vektör olarak yorumlayan distance() ve length() gibi işlevler için Vektör Matematik İşlevleri konusuna bakın.

32 bitlik kayan noktalardaki matematik işlemlerinin hassasiyeti, pragmas rs_fp_relaxed ve rs_fp_full değerlerinden etkilenir. rs_fp_relaxed altında, normal altı değerler sıfıra atılabilir ve yuvarlama sıfıra doğru yapılabilir. Buna karşılık, rs_fp_full özelliğinin normal olmayan değerlerin (yani 1.17549435e-38f'den küçük) doğru şekilde işlenmesini gerektirir. rs_fp_rull ayrıca çifte eşit şekilde yuvarlama gerektirir.

Yaygın matematik fonksiyonlarının değişkenleri kullanılarak farklı hassasiyet/hız dengelemeleri elde edilebilir. ile başlayan bir ada sahip işlevler

yerel_: Daha düşük kesinliğe sahip özel donanım uygulamaları içerebilir. Ayrıca, normal alt değerler sıfıra kaydırılabilir, sıfıra yuvarlama kullanılabilir ve NaN ve sonsuzluk girişi doğru şekilde işlenemez.
Yarı_: 16 bit kayan öğeleri kullanarak dahili hesaplamalar yapabilir. Ayrıca, normal altı değerler sıfıra kaydırılabilir ve sıfıra yuvarlama kullanılabilir.

Özet

Sabitler
E_1_P	1 / pi, 32 bit kayan nokta olarak
M_2_PI	2 / pi, 32 bit kayan nokta olarak
M_2_KAREKÖKPİ	2 / karekök(pi), 32 bit kayan nokta olarak
E	e, 32 bit kayan nokta olarak
M_LN10	log_e(10), 32 bit kayan nokta olarak
M_LN2	log_e(2), 32 bit kayan nokta olarak
M_LOG10E	log_10(e), 32 bit kayan nokta olarak
M_LOG2E	log_2(e), 32 bit kayan nokta olarak
M_PI	pi, 32 bit kayan nokta olarak
E_PI_2	pi / 2, 32 bit kayan nokta olarak
E_PI_4	pi / 4, 32 bit kayan nokta olarak
E_KAREKÖK1_2	1 / karekök(2), 32 bit kayan nokta olarak
M_KAREKÖK2	kare(2), 32 bit kayan nokta olarak

Fonksiyonlar
mutlak	Bir tam sayının mutlak değeri
Acos	Ters kosinüs
Acosh	Ters hiperbolik kosinüs
Acospi	Ters kosinüs bölü pi
asin	Ters sinüs
asinh	Ters hiperbolik sinüs
Asenpi	Ters sinüsün pi sayısına bölümü
atan	Ters tanjant
atan2	Oranın ters tanjantı
atan2pi	Oranın ters tanjantının pi sayısına bölümü
atanh	Ters hiperbolik tanjant
atanpi	Ters tanjantın pi sayısına bölümü
cbrt	Küpkök
tavan	Değerden küçük olmayan en küçük tam sayı
kelepçe	Bir değeri aralıkla sınırlandırma
cz	Baştaki 0 bit sayısı
copysign	Bir sayının işaretini başka bir sayıya kopyalar
cos	Kosinüs
cosh	Hipbolik kosinüs
cospi	Bir sayının kosinüsünün pi sayısıyla çarpımı
derece	Radyanları dereceye dönüştürür
erf	Matematiksel hata işlevi
erfc	Matematiksel tamamlayıcı hata işlevi
exp	bir sayıya yükseltilen e
exp10	Sayıya yükseltilen 10
exp2	2 sayıya yükseltilmiş
expm1	e eksi bir sayıya yükseltilir
fabs	Bir hareketli sayının mutlak değeri
fdim	İki değer arasında pozitif fark
zemin	Bir değerden büyük olmayan en küçük tam sayı
fma	Çoğalt ve ekle
fmaks	Maksimum iki kayan noktalı
fd	En az iki kayan
fmod	Modlo
kesirli	Pozitif kesirli kısım
frexp	İkili mantis ve üs
half_recip	16 bit hassasiyete göre hesaplanan terslik
half_rsqrt	16 bit hassasiyetle hesaplanan bir karekökün tersi
yarım_sqrt	16 bit hassasiyetle hesaplanan karekök
hipot	Hipotenüs
ilogb	İki taban üs
ldexp	Mantissa ve üsden bir kayan nokta oluşturur
lgamma	Gama işlevinin doğal logaritması
log	Doğal logaritma
log10	10 tabanında logaritma
log1p	Değer artı 1'in doğal logaritması
log2	2. taban logaritma
logb	İki taban üs
çılgın	Çoğalt ve ekle
maks	Maksimum
dk.	Minimum
karma	İki değeri karıştırır
modf	İntegral ve kesirli bileşenler
nan	Sayı değil
in_half	Sayı değil
yerel_acos	Yaklaşık ters kosinüs
yerel_acosh	Yaklaşık ters hiperbolik kosinüs
yerel_acospi	Yaklaşık ters kosinüsün pi sayısına bölümü
yerel_asin	Yaklaşık ters sinüs
yerel_asin	Yaklaşık ters hiperbolik sinüs
yerel_asinpi	Yaklaşık ters sinüsün pi sayısına bölümü
yerel_atan	Yaklaşık ters tanjant
yerel_atan2	Bir oranın yaklaşık ters tanjantı
yerel_atan2pi	Oranın yaklaşık ters tanjantının pi sayısına bölümü
yerel_atanh	Yaklaşık ters hiperbolik tanjant
yerel_atanpi	Yaklaşık ters tanjantın pi sayısına bölümü
yerel_cbrt	Yaklaşık küpkök
yerel_cos	Yaklaşık kosinüs
yerel_cosh	Yaklaşık hipebolik kosinüs
doğal_cospi	Bir sayının yaklaşık kosinüsünün pi sayısıyla çarpımı
yerel_böl	Yaklaşık bölüm
yerel_exp	Bir sayıya yükseltilen yaklaşık e
yerel_exp10	Bir sayıya yükseltilen yaklaşık 10
yerel_exp2	Bir sayıya yükseltilmiş yaklaşık 2
yerel_expm1	Bir sayıya eksi bire yükseltilen yaklaşık e
yerel_hypot	Yaklaşık hipotenüs
yerel_log	Yaklaşık doğal logaritma
yerel_log10	Yaklaşık 10 tabanında logaritma
yerel_log1p	Değerin yaklaşık doğal logaritması ve 1
yerel_log2	Yaklaşık 2 tabanındaki logaritma
yerel_ güç	Üsse yükseltilen yaklaşık pozitif taban
yerel_recip	Yaklaşık tersi
yerel_kök	Yaklaşık n'inci kök
yerel_rsqrt	Karekökün yaklaşık tersi
yerel_sin	Yaklaşık sinüs
yerel_sincos	Yaklaşık sinüs ve kosinüs
yerel_sinh	Yaklaşık hiperbolik sinüs
yerel_sinpi	Bir sayının yaklaşık sinüsünün pi sayısıyla çarpımı
yerel_sqrt	Yaklaşık karekök
yerel_tan	Yaklaşık tanjant
yerel_tanh	Yaklaşık hiperbolik tanjant
yerel_tanpi	Bir sayının yaklaşık tanjantının pi ile çarpımı
nextsonra	Sonraki kayan nokta sayısı
güç	Üsse yükseltilen taban
pown	Taban, bir tam sayı üssüne yükseltilir
güç	Üsse yükseltilen pozitif taban
radyan	Dereceleri radyana dönüştürür
kalan	Bir bölümün kalan kısmı
remquo	Bir bölümde kalan kısım ve bölüm
rint	Eşit sayıya yuvarla
rootn	N'inci kök
yuvarlat	Sıfırdan uzaklaştırın
rsRand	Rastgele rastgele sayı
rsqrt	Karekökün tersi
işaret	Değer işareti
sin	Sinüs
Sincos	Sinüs ve kosinüs
sinh	Hiperbolik sinüs
Sinpi	Bir sayının sinüsünün pi ile çarpımı
kare	Karekök
adımı	Değerden küçükse 0, aksi takdirde 1
ten	Tanjant
tanh	Hiperbolik tanjant
tanpi	Bir sayının tanjantı ile pi sayısının çarpımı
tgama	Gama işlevi
trunc	Kayan noktayı kısaltır

Kullanımdan Kaldırılan İşlevler
rsClamp	Kullanımdan kaldırıldı. Bir değeri aralıkla sınırlandırma
rsFrac	Kullanımdan kaldırıldı. Kayan öğenin kesirli kısmını döndürür

Sabitler

M_1_PI : 32 bit kayan nokta olarak 1 / pi

Değer: 0,318309886183790671537767526745028724f

32 bit'lik kayan nokta olarak pi'nin tersi.

M_2_PI : 32 bit kayan nokta olarak 2 / pi

Değer: 0,636619772367581343075535053490057448f

32 bitlik ondalık değer olarak 2'nin pi sayısına bölümü.

M_2_SQRTPI : 2 / kare(pi), 32 bit kayan nokta olarak

Değer: 1,128379167095512573896158903121545172f

2'nin 32 bitlik ondalık sayı olarak pi sayısının kareköküne bölünmesiyle elde edilir.

M_E : e, 32 bit kayan nokta olarak

Değer: 2,718281828459045235360287471352662498f

32 bitlik bir kesir şeklinde doğal logaritmanın tabanı olan e sayısı.

M_LN10 : log_e(10), 32 bit kayan nokta olarak

Değer: 2,302585092994045684017991454684364208f

32 bitlik bir ondalık değer olarak 10'un doğal logaritması.

M_LN2 : log_e(2), 32 bit kayan nokta olarak

Değer: 0,693147180559945309417232121458176568f

32 bitlik bir kesir şeklinde 2'nin doğal logaritması.

M_LOG10E : log_10(e), 32 bit kayan nokta olarak

Değer: 0,434294481903251827651128918916605082f

32 bitlik kayan nokta olarak e'nin 10 tabanındaki logaritma tabanı.

M_LOG2E : log_2(e), 32 bit kayan nokta olarak

Değer: 1,442695040888963407359924681001892137f

32 bitlik kayan nokta olarak e'nin logaritma tabanı 2.

M_PI : pi, 32 bit kayan nokta olarak

Değer: 3,141592653589793238462643383279502884f

32 bitlik bir kayma olarak pi sabiti.

M_PI_2 : pi / 2, 32 bit kayan nokta olarak

Değer: 1,570796326794896619231321691639751442f

32 bit kayan nokta olarak pi sayısının 2'ye bölümü.

M_PI_4 : pi / 4, 32 bit kayan nokta olarak

Değer: 0,785398163397448309615660845819875721f

32 bit kayan nokta olarak pi sayısının 4'e bölümü.

M_SQRT1_2 : 1 / karekök(2), 32 bit kayan nokta olarak

Değer: 0,707106781186547524400844362104849039f

32 bitlik ondalık değer olarak 2'nin karekökünün tersi.

M_SQRT2 : kare(2), 32 bit kayan nokta olarak

Değer: 1,414213562373095048801688724209698079f

32 bitlik ondalık değer olarak 2'nin karekökü.

Fonksiyonlar

abs : Bir tam sayının mutlak değeri

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);

Bir tam sayının mutlak değerini döndürür.

Kayan öğeler için fabs() kullanın.

acos : Ters kosinüs

float acos(float v);
float2 acos(float2 v);
float3 acos(float3 v);
float4 acos(float4 v);
yarım acos(yarım v);	API düzeyi 24'te eklendi
half2 acos(half2 v);	API düzeyi 24'te eklendi
half3 acos(half3 v);	API düzeyi 24'te eklendi
half4 acos(half4 v);	API düzeyi 24'te eklendi

Ters kosinüsü radyan cinsinden döndürür.

Ayrıca native_acos() işlevini de inceleyin.

acosh : Ters hiperbolik kosinüs

float acosh(float v);
float2 acosh(float2 v);
float3 acosh(float3 v);
float4 acosh(float4 v);
yarım acosh(yarım v);	API düzeyi 24'te eklendi
half2 acosh(half2 v);	API düzeyi 24'te eklendi
half3 acosh(half3 v);	API düzeyi 24'te eklendi
half4 acosh(half4 v);	API düzeyi 24'te eklendi

Ters hiperbolik kosinüsü radyan cinsinden döndürür.

Ayrıca native_acosh() işlevini de inceleyin.

acospi : Ters kosinüs bölü pi

float acospi(float v);
float2 acospi(float2 v);
float3 acospi(float3 v);
float4 acospi(float4 v);
yarım acospi(yarım v);	API düzeyi 24'te eklendi
half2 acospi(half2 v);	API düzeyi 24'te eklendi
half3 acospi(half3 v);	API düzeyi 24'te eklendi
half4 acospi(half4 v);	API düzeyi 24'te eklendi

Ters kosinüsü radyan cinsinden, pi sayısına bölerek döndürür.

Derece olarak ölçülen bir ters kosinüsü elde etmek için acospi(a) * 180.f işlevini kullanın.

Ayrıca native_acospi() işlevini de inceleyin.

asin : Ters sinüs

float asin(float v);
float2 asin(float2 v);
float3 asin(float3 v);
float4 asin(float4 v);
half asin(yarım v);	API düzeyi 24'te eklendi
half2 asin(half2 v);	API düzeyi 24'te eklendi
half3 asin(half3 v);	API düzeyi 24'te eklendi
half4 asin(half4 v);	API düzeyi 24'te eklendi

Ters sinüsü radyan cinsinden döndürür.

Ayrıca bkz. native_asin().

asinh : Ters hiperbolik sinüs

float asinh(float v);
float2 asinh(float2 v);
float3 asinh(float3 v);
float4 asinh(float4 v);
half asinh(half v);	API düzeyi 24'te eklendi
half2 asinh(half2 v);	API düzeyi 24'te eklendi
half3 asinh(half3 v);	API düzeyi 24'te eklendi
half4 asinh(half4 v);	API düzeyi 24'te eklendi

Ters hiperbolik sinüsü radyan cinsinden döndürür.

Ayrıca native_asinh() işlevini de inceleyin.

asinpi : Ters sinüs bölü pi

float asinpi(float v);
float2 asinpi(float2 v);
float3 asinpi(float3 v);
float4 asinpi(float4 v);
half asinpi(yarım v);	API düzeyi 24'te eklendi
half2 asinpi(half2 v);	API düzeyi 24'te eklendi
half3 asinpi(half3 v);	API düzeyi 24'te eklendi
half4 asinpi(half4 v);	API düzeyi 24'te eklendi

Ters sinüsü radyan cinsinden, pi sayısına bölerek döndürür.

Derece cinsinden ters sinüsü ölçmek için asinpi(a) * 180.f işlevini kullanın.

Ayrıca bkz. native_asinpi().

atan : Ters tanjant

float(float v);
float2 atan(float2 v);
float3 atan(float3 v);
float4 atan(float4 v);
half atan(half v);	API düzeyi 24'te eklendi
half2 atan(half2 v);	API düzeyi 24'te eklendi
half3 ata(half3 v);	API düzeyi 24'te eklendi
half4 atan(half4 v);	API düzeyi 24'te eklendi

Ters tanjantı radyan cinsinden döndürür.

Ayrıca bkz. native_atan().

atan2 : Oranın ters tanjantı

kayan atan2(kayan pay, kayan payda);
float2 atan2(float2 pay, float2 payda);
float3 atan2(float3 pay, float3 payda);
float4 atan2(float4 pay, float4 payda);
yarım atan2(yarım pay, yarım payda);	API düzeyi 24'te eklendi
half2 atan2(yarım2 pay; yarım2 payda);	API düzeyi 24'te eklendi
half3 atan2(yarım3 pay; yarım3 payda);	API düzeyi 24'te eklendi
half4 atan2(yarım4 payı, yarım4 payda);	API düzeyi 24'te eklendi

Parametreler

pay	Pay.
payda	Payda. 0 olabilir.

(numerator / denominator) işlevinin ters tanjantını radyan cinsinden döndürür.

Ayrıca bkz. native_atan2().

atan2pi : Oranın ters tanjantının pi sayısına bölümü

kayan atan2pi(kayan pay, kayan payda);
float2 atan2pi(float2 pay, float2 payda);
float3 atan2pi(float3 pay, float3 payda);
float4 atan2pi(float4 pay, float4 payda);
yarım atan2pi(yarım pay, yarım payda);	API düzeyi 24'te eklendi
half2 atan2pi(yarım2 payı, yarım2 payda);	API düzeyi 24'te eklendi
half3 atan2pi(yarım3 payı, yarım3 payda);	API düzeyi 24'te eklendi
half4 atan2pi(yarım4 payı, yarım4 payda);	API düzeyi 24'te eklendi

Parametreler

pay	Pay.
payda	Payda. 0 olabilir.

(numerator / denominator) işlevinin ters tanjantını radyan cinsinden pi sayısına bölerek döndürür.

Derece olarak ölçülen bir ters tanjant elde etmek için atan2pi(n, d) * 180.f işlevini kullanın.

Ayrıca bkz. native_atan2pi().

atanh : Ters hiperbolik tanjant

float atanh(float v);
float2 atanh(float2 v);
float3 atanh(float3 v);
float4 atanh(float4 v);
half atanh(half v);	API düzeyi 24'te eklendi
half2 atanh(half2 v);	API düzeyi 24'te eklendi
half3 atanh(half3 v);	API düzeyi 24'te eklendi
half4 atanh(half4 v);	API düzeyi 24'te eklendi

Ters hiperbolik tanjantı radyan cinsinden döndürür.

Ayrıca native_atanh() işlevini de inceleyin.

atanpi : Ters tanjantın pi sayısına bölümü

float atanpi(float v);
float2 atanpi(float2 v);
float3 atanpi(float3 v);
float4 atanpi(float4 v);
half atanpi(half v);	API düzeyi 24'te eklendi
half2 atanpi(half2 v);	API düzeyi 24'te eklendi
half3 atanpi(half3 v);	API düzeyi 24'te eklendi
half4 atanpi(half4 v);	API düzeyi 24'te eklendi

Ters tanjantı radyan cinsinden, pi sayısına bölerek döndürür.

Derece olarak ölçülen bir ters tanjant elde etmek için atanpi(a) * 180.f işlevini kullanın.

Ayrıca native_atanpi() işlevini de inceleyin.

cbrt : Küpkök

float cbrt(float v);
float2 cbrt(float2 v);
float3 cbrt(float3 v);
float4 cbrt(float4 v);
half cbrt(half v);	API düzeyi 24'te eklendi
half2 cbrt(half2 v);	API düzeyi 24'te eklendi
half3 cbrt(half3 v);	API düzeyi 24'te eklendi
half4 cbrt(half4 v);	API düzeyi 24'te eklendi

Küp kökü döndürür.

Ayrıca bkz. native_cbrt().

ceil : Bir değerden küçük olmayan en küçük tam sayı

kayan ceil(float v);
float2 ceil(float2 v);
float3 ceil(float3 v);
float4 ceil(float4 v);
yarım tavan(yarım v);	API düzeyi 24'te eklendi
half2 tavan(half2 v);	API düzeyi 24'te eklendi
yarım3 tavan(yarım3 v);	API düzeyi 24'te eklendi
half4 tavan(yarım 4 v);	API düzeyi 24'te eklendi

Bir değerden küçük olmayan en küçük tam sayıyı döndürür.

Örneğin, ceil(1.2f) değeri 2.f, ceil(-1.2f) değeri ise -1.f değerini döndürür.

Ayrıca floor() konusuna da bakın.

clamp : Bir değeri aralıkla sınırlandırın

char clamp(karakter değeri; char min_value; char max_value);	API düzeyi 19'da eklendi
char2 clamp(char2 değeri, karakter minimum_değeri, karakter maks._değeri);	API düzeyi 19'da eklendi
char2 clamp(char2 değeri, char2 min_value, char2 max_value);	API düzeyi 19'da eklendi
char3 clamp(char3 value, char min_value, char max_value);	API düzeyi 19'da eklendi
char3 clamp(char3 value, char3 min_value, char3 max_value);	API düzeyi 19'da eklendi
char4 clamp(char4 değeri, karakter minimum_değeri, karakter maks._değeri);	API düzeyi 19'da eklendi
char4 clamp(karakter4 değeri, char4 min_value, karakter4 maks_değer);	API düzeyi 19'da eklendi
kayan noktalı değer; kayan nokta değeri; kayan minimum_değer; kayan maksimum_değer);
float2 clamp(float2 değeri, kayan min_value, float max_value);
float2 clamp(float2 değeri, float2 min_value, float2 max_value);
float3 clamp(float3 değeri, kayan min_value, float max_value);
float3 clamp(float3 value, float3 min_value, float3 max_value);
float4 clamp(float4 değeri, kayan min_value, kayan maks_değer);
float4 clamp(float4 değeri, float4 min_value, float4 max_value);
half clamp(yarım değer, yarım min_value, yarım max_value);	API düzeyi 24'te eklendi
half2 clamp(yarım2 değer, yarım min_value, yarım maks_değer);	API düzeyi 24'te eklendi
half2 clamp(yarım2 değer, yarım2 min_değer, yarım2 maks_değer);	API düzeyi 24'te eklendi
half3 clamp(yarı3 değer, yarım min_value, yarım maks_değer);	API düzeyi 24'te eklendi
half3 clamp(yarı3 değer, yarım3 min_value, yarım3 maks_değer);	API düzeyi 24'te eklendi
half4 clamp(yarım4 değer, yarım min_value, yarım maks_değer);	API düzeyi 24'te eklendi
half4 clamp(yarım4 değer, yarım4 min_değer, yarım4 maks_değer);	API düzeyi 24'te eklendi
int clamp(int değeri, int min_value, int max_value);	API düzeyi 19'da eklendi
int2 clamp(int2 value, int min_value, int max_value);	API düzeyi 19'da eklendi
int2 clamp(int2 value, int2 min_value, int2 max_value);	API düzeyi 19'da eklendi
int3 clamp(int3 value, int min_value, int max_value);	API düzeyi 19'da eklendi
int3 clamp(int3 value, int3 min_value, int3 max_value);	API düzeyi 19'da eklendi
int4 clamp(int4 value, int min_value, int max_value);	API düzeyi 19'da eklendi
int4 clamp(int4 value, int4 min_value, int4 max_value);	API düzeyi 19'da eklendi
long clamp(long value, long min_value, long max_value);	API düzeyi 19'da eklendi
long2 clamp(long2 value, long min_value, long max_value);	API düzeyi 19'da eklendi
long2 clamp(long2 value, long2 min_value, long2 max_value);	API düzeyi 19'da eklendi
long3 clamp(long3 value, long min_value, long max_value);	API düzeyi 19'da eklendi
long3 clamp(long3 value, long3 min_value, long3 max_value);	API düzeyi 19'da eklendi
long4 clamp(long4 value, long min_value, long max_value);	API düzeyi 19'da eklendi
long4 clamp(long4 value, long4 min_value, long4 max_value);	API düzeyi 19'da eklendi
kısa clamp(kısa değer, kısa min_değer, kısa maks_değer);	API düzeyi 19'da eklendi
short2 clamp(short2 value, kısa min_value, short max_value);	API düzeyi 19'da eklendi
short2 clamp(short2 değeri, short2 min_value, short2 max_value);	API düzeyi 19'da eklendi
short3 clamp(short3 value, short min_value, short max_value);	API düzeyi 19'da eklendi
short3 clamp(short3 value, short3 min_value, short3 max_value);	API düzeyi 19'da eklendi
short4 clamp(short4 value, kısa min_value, short max_value);	API düzeyi 19'da eklendi
short4 clamp(short4 değeri, short4 min_value, short4 max_value);	API düzeyi 19'da eklendi
uchar clamp(uchar değeri, uchar min_value, uchar max_value);	API düzeyi 19'da eklendi
uchar2 clamp(uchar2 değeri, uchar min_value, uchar max_value);	API düzeyi 19'da eklendi
uchar2 clamp(uchar2 değeri, uchar2 min_value, uchar2 max_value);	API düzeyi 19'da eklendi
uchar3 clamp(uchar3 değeri, uchar min_value, uchar max_value);	API düzeyi 19'da eklendi
uchar3 clamp(uchar3 değeri, uchar3 min_value, uchar3 max_value);	API düzeyi 19'da eklendi
uchar4 clamp(uchar4 değeri, uchar min_value, uchar max_value);	API düzeyi 19'da eklendi
uchar4 clamp(uchar4 değeri, uchar4 min_value, uchar4 max_value);	API düzeyi 19'da eklendi
uint clamp(uint değeri, uint min_value, uint max_value);	API düzeyi 19'da eklendi
uint2 clamp(uint2 değeri, uint min_value, uint max_value);	API düzeyi 19'da eklendi
uint2 clamp(uint2 değeri, uint2 min_value, uint2 max_value);	API düzeyi 19'da eklendi
uint3 clamp(uint3 değeri, uint min_value, uint max_value);	API düzeyi 19'da eklendi
uint3 clamp(uint3 değeri, uint3 min_value, uint3 max_value);	API düzeyi 19'da eklendi
uint4 clamp(uint4 değeri, uint min_value, uint max_value);	API düzeyi 19'da eklendi
uint4 clamp(uint4 değeri, uint4 min_value, uint4 max_value);	API düzeyi 19'da eklendi
ulong clamp(ulong değeri, ulong min_value, ulong max_value);	API düzeyi 19'da eklendi
ulong2 clamp(ulong2 değeri, ulong min_value, ulong max_value);	API düzeyi 19'da eklendi
ulong2 clamp(ulong2 değeri, ulong2 min_value, ulong2 max_value);	API düzeyi 19'da eklendi
ulong3 clamp(ulong3 value, ulong min_value, ulong max_value);	API düzeyi 19'da eklendi
ulong3 clamp(ulong3 value, ulong3 min_value, ulong3 max_value);	API düzeyi 19'da eklendi
ulong4 clamp(ulong4 değeri, ulong min_value, ulong max_value);	API düzeyi 19'da eklendi
ulong4 clamp(ulong4 değeri, ulong4 min_value, ulong4 max_value);	API düzeyi 19'da eklendi
ushort clamp(ushort değeri, ushort min_value, ushort max_value);	API düzeyi 19'da eklendi
ushort2 clamp(ushort2 değeri, ushort min_value, ushort max_value);	API düzeyi 19'da eklendi
ushort2 clamp(ushort2 değeri, ushort2 min_value, ushort2 max_value);	API düzeyi 19'da eklendi
ushort3 clamp(ushort3 value, ushort min_value, ushort maks_value);	API düzeyi 19'da eklendi
ushort3 clamp(ushort3 value, ushort3 min_value, ushort3 max_value);	API düzeyi 19'da eklendi
ushort4 clamp(ushort4 değeri, ushort min_value, ushort max_value);	API düzeyi 19'da eklendi
ushort4 clamp(ushort4 değeri, ushort4 min_value, ushort4 max_value);	API düzeyi 19'da eklendi

Parametreler

value	Sabitlenecek değer.
min_değer	Alt sınır, skaler veya eşleşen vektör.
maks_değer	Yüksek sınır, düşük türüyle eşleşmelidir.

Değeri, belirtilen bir yüksek ve düşük sınıra sabitler. clamp(), değer < min_value ise min_value, değer > max_value ise maks.değer, aksi takdirde değer döndürür.

Kısıtlayıcının iki varyantı vardır: Bunlardan birinde minimum ve maksimum değerler tüm değer girişlerine skaler değerlerdir, diğeri minimum ve maksimum değerler de vektördür.

min_value (min_değeri) maksimum_değerden büyükse sonuçlar tanımsız olur.

clz : Baştaki 0 bit sayısı

char clz(karakter değeri);
char2 clz(char2 değeri);
char3 clz(char3 value);
char4 clz(char4 value);
int clz(int value);
int2 clz(int2 value);
int3 clz(int3 value);
int4 clz(int4 value);
kısa clz(kısa değer);
short2 clz(short2 value);
short3 clz(short3 value);
short4 clz(short4 value);
uchar clz(uchar value);
uchar2 clz(uchar2 değeri);
uchar3 clz(uchar3 value);
uchar4 clz(uchar4 value);
uint clz(uint value);
uint2 clz(uint2 değeri);
uint3 clz(uint3 value);
uint4 clz(uint4 value);
ushort clz(ushort değeri);
ushort2 clz(ushort2 değeri);
ushort3 clz(ushort3 value);
ushort4 clz(ushort4 değeri);

Bir değerin başındaki 0 bit sayısını döndürür.

Örneğin clz((char)0x03), 6 değerini döndürür.

copysign : Bir sayının işaretini başka bir sayıya kopyalar

float copysign(float magnitude_value, float sign_value);
float2 copysign(float2 magnitude_value, float2 sign_value);
float3 copysign(float3 magnitude_value, float3 sign_value);
float4 copysign(float4 magnitude_value, float4 sign_value);
half copysign(half magnitude_value, perf sign_value);	API düzeyi 24'te eklendi
half2 copysign(half2 magnitude_value, perf2 sign_value);	API düzeyi 24'te eklendi
half3 copysign(half3 magnitude_value, perf3 sign_value);	API düzeyi 24'te eklendi
half4 copysign(half4 magnitude_value, perf4 sign_value);	API düzeyi 24'te eklendi

İşaretini sign_value değerinden büyüklük_değerine kopyalar.

Döndürülen değer büyüklük_değeri veya -magnitude_değeridir.

Örneğin, copysign(4.0f, -2.7f) değeri -4.0f, copysign(-4.0f, 2.7f) değeri ise 4.0f değerini döndürür.

cos : Kosinüs

float cos(float v);
float2 cos(float2 v);
float3 cos(float3 v);
float4 cos(float4 v);
yarım cos(yarım v);	API düzeyi 24'te eklendi
half2 cos(half2 v);	API düzeyi 24'te eklendi
half3 cos(half3 v);	API düzeyi 24'te eklendi
half4 cos(half4 v);	API düzeyi 24'te eklendi

Açının kosinüsünü radyan cinsinden döndürür.

Ayrıca bkz. native_cos().

cosh : Hipebolik kosinüs

float cosh(float v);
float2 cosh(float2 v);
float3 cosh(float3 v);
float4 cosh(float4 v);
half cosh(half v);	API düzeyi 24'te eklendi
half2 cosh(half2 v);	API düzeyi 24'te eklendi
half3 cosh(half3 v);	API düzeyi 24'te eklendi
half4 cosh(half4 v);	API düzeyi 24'te eklendi

v'nin hipebolik kosinüsünü döndürür. Burada v, radyan cinsinden ölçülür.

Ayrıca bkz. native_cosh().

cospi : Sayının kosinüsü ile pi sayısının çarpımı

float cospi(float v);
float2 cospi(float2 v);
float3 cospi(float3 v);
float4 cospi(float4 v);
yarım cospi(yarım v);	API düzeyi 24'te eklendi
half2 cospi(half2 v);	API düzeyi 24'te eklendi
half3 cospi(half3 v);	API düzeyi 24'te eklendi
half4 cospi(half4 v);	API düzeyi 24'te eklendi

(v * pi) işlevinin kosinüsünü döndürür. (v * pi) değeri radyan cinsinden ölçülür.

Derece cinsinden ölçülen bir değerin kosinüsünü öğrenmek için cospi(v / 180.f) aramasını yapın.

Ayrıca bkz. native_cospi().

derece : Radyanları dereceye dönüştürür

kayan derece(kayan v);
float2 derece(float2 v);
float3 derece(float3 v);
float4 derece(float4 v);
yarım derece(yarım v);	API düzeyi 24'te eklendi
yarım2 derece(yarım2 v);	API düzeyi 24'te eklendi
yarım3 derece(yarım3 v);	API düzeyi 24'te eklendi
yarım4 derece(yarım4 v);	API düzeyi 24'te eklendi

Radyandan dereceye dönüştürür.

erf : Matematiksel hata işlevi

float erf(float v);
float2 erf(float2 v);
float3 erf(float3 v);
float4 erf(float4 v);
half erf(half v);	API düzeyi 24'te eklendi
half2 erf(half2 v);	API düzeyi 24'te eklendi
half3 erf(half3 v);	API düzeyi 24'te eklendi
half4 erf(half4 v);	API düzeyi 24'te eklendi

Hata işlevini döndürür.

erfc : Matematiksel tamamlayıcı hata işlevi

float erfc(float v);
float2 erfc(float2 v);
float3 erfc(float3 v);
float4 erfc(float4 v);
half erfc(yarım v);	API düzeyi 24'te eklendi
half2 erfc(half2 v);	API düzeyi 24'te eklendi
half3 erfc(half3 v);	API düzeyi 24'te eklendi
half4 erfc(half4 v);	API düzeyi 24'te eklendi

Tamamlayıcı hata işlevini döndürür.

exp : bir sayıya yükseltilen e

float exp(float v);
float2 exp(float2 v);
float3 exp(float3 v);
float4 exp(float4 v);
half exp(half v);	API düzeyi 24'te eklendi
half2 exp(half2 v);	API düzeyi 24'te eklendi
half3 exp(half3 v);	API düzeyi 24'te eklendi
half4 exp(half4 v);	API düzeyi 24'te eklendi

e'yi v'ye yükseltilmiş halde döndürür, ör. e ^ v.

Ayrıca bkz. native_exp().

exp10 : Bir sayıya yükseltilen 10

float exp10(float v);
float2 exp10(float2 v);
float3 exp10(float3 v);
float4 exp10(float4 v);
yarım exp10(yarım v);	API düzeyi 24'te eklendi
half2 exp10(yarım2 v);	API düzeyi 24'te eklendi
half3 exp10(yarım3 v);	API düzeyi 24'te eklendi
half4 exp10(yarım4 v);	API düzeyi 24'te eklendi

10'u v'ye yükseltilmiş şekilde döndürür, ör. 10.f ^ v.

Ayrıca bkz. native_exp10().

exp2 : bir sayıya yükseltilen 2

float exp2(float v);
float2 exp2(float2 v);
float3 exp2(float3 v);
float4 exp2(float4 v);
half exp2(yarım v);	API düzeyi 24'te eklendi
half2 exp2(half2 v);	API düzeyi 24'te eklendi
half3 exp2(yarım3 v);	API düzeyi 24'te eklendi
half4 exp2(yarım4 v);	API düzeyi 24'te eklendi

2'yi v'ye yükseltilmiş şekilde döndürür, ör. 2.f ^ v.

Ayrıca bkz. native_exp2().

expm1 : e bir sayıya eksi bire yükseltilir

float expm1(float v);
float2 expm1(float2 v);
float3 expm1(float3 v);
float4 expm1(float4 v);
half expm1(half v);	API düzeyi 24'te eklendi
half2 expm1(half2 v);	API düzeyi 24'te eklendi
half3 expm1(half3 v);	API düzeyi 24'te eklendi
half4 expm1(half4 v);	API düzeyi 24'te eklendi

e'yi v eksi 1'e yükseltilmiş halde döndürür, ör. (e ^ v) - 1.

Ayrıca bkz. native_expm1().

fabs : Kayan öğenin mutlak değeri

float fabs(float v);
float2 fabs(float2 v);
float3 fabs(float3 v);
float4 fabs(float4 v);
yarım fabs(yarım v);	API düzeyi 24'te eklendi
yarım2 fabs(yarım2 v);	API düzeyi 24'te eklendi
yarım3 fabs(yarım3 v);	API düzeyi 24'te eklendi
yarım4 fabs(yarım4 v);	API düzeyi 24'te eklendi

Kayan noktalı v'nin mutlak değerini döndürür.

Tam sayılar için abs() işlevini kullanın.

fdim : İki değer arasındaki pozitif fark

float fdim(float a, float b);
float2 fdim(float2 a, float2 b);
float3 fdim(float3 a, float3 b);
float4 fdim(float4 a, float4 b);
half fdim(yarım a, yarım b);	API düzeyi 24'te eklendi
half2 fdim(yarım2 a, yarım2 b);	API düzeyi 24'te eklendi
half3 fdim(half3 a, half3 b);	API düzeyi 24'te eklendi
half4 fdim(half4 a, yarım4 b);	API düzeyi 24'te eklendi

İki değer arasındaki pozitif farkı döndürür.

a > b ise (a - b) değerini, aksi takdirde 0f değerini döndürür.

Taban : Bir değerden büyük olmayan en küçük tam sayı

kayan zemin(float v);
float2 floor(float2 v);
float3 floor(float3 v);
float4 floor(float4 v);
half floor(yarım v);	API düzeyi 24'te eklendi
half2 floor(yarım2 v);	API düzeyi 24'te eklendi
half3 floor(half3 v);	API düzeyi 24'te eklendi
half4 floor(half4 v);	API düzeyi 24'te eklendi

Bir değerden büyük olmayan en küçük tam sayıyı döndürür.

Örneğin, floor(1.2f) işlevi 1.f değerini, floor(-1.2f) değeri ise -2.f değerini döndürür.

Ayrıca bkz. ceil().

fma : Çarpma ve toplama

float fma(float çarpma1, float çarpma2, float ofset);
float2 fma(float2 çarpılan1, float2 çarpılan2, float2 ofset);
float3 fma(float3 çarpılan1, float3 çarpılan2, float3 ofset);
float4 fma(float4 çarpılan1, float4 çarpılan2, float4 ofset);
yarım fma(yarım çarpılan1, yarım çarpılan2, yarım ofset);	API düzeyi 24'te eklendi
yarım2 fma(yarım2 çarpılan1, yarım2 çarpılan2, yarım2 ofset);	API düzeyi 24'te eklendi
yarım3 fma(yarım3 çarpma1, yarım3 çarpma2, yarım3 ofset);	API düzeyi 24'te eklendi
yarım4 fma(yarım4 çarpılmış1, yarım4 çarpım2, yarım4 ofset);	API düzeyi 24'te eklendi

Çoğaltma ve toplama. (multiplicand1 * multiplicand2) + offset değerini döndürür.

Bu işlev mad() işlevine benzer. fma(), çarpılan sonucun tam hassasiyetini korur ve yalnızca toplamadan sonra yuvarlanır. mad(), çarpma ve toplama işleminden sonra yuvarlanır. rs_fp_relaxed modunda bu ek hassasiyet garanti edilmez.

fmax : Maksimum iki kayan noktalı

kayan fmax(kayan a, kayan b);
float2 fmax(float2 a, kayan b);
float2 fmax(float2 a, float2 b);
float3 fmax(float3 a, kayan b);
float3 fmax(float3 a, float3 b);
float4 fmax(float4 a, kayan b);
float4 fmax(float4 a, float4 b);
yarım fmax(yarım a, yarım b);	API düzeyi 24'te eklendi
yarım2 fmax(yarım2 a, yarım b);	API düzeyi 24'te eklendi
yarım2 fmax(yarım2 a, yarım2 b);	API düzeyi 24'te eklendi
yarım3 fmax(yarı3 a, yarım b);	API düzeyi 24'te eklendi
yarım3 fmax(yarım3 a, yarım3 b);	API düzeyi 24'te eklendi
yarım4 fmax(yarım a, yarım b);	API düzeyi 24'te eklendi
yarım4 fmax(yarım a, yarım4 b);	API düzeyi 24'te eklendi

A ve b'nin maksimum değerini döndürür (ör. (a < b ? b : a)).

max() işlevi aynı sonuçları döndürür ancak daha fazla veri türüne uygulanabilir.

fmin : En az iki kayan noktalı

float fmin(float a, float b);
float2 fmin(float2 a, kayan b);
float2 fmin(float2 a, float2 b);
float3 fmin(float3 a, float b);
float3 fmin(float3 a, float3 b);
float4 fmin(float4 a, kayan b);
float4 fmin(float4 a, float4 b);
yarım fmin(yarım a, yarım b);	API düzeyi 24'te eklendi
yarım2 fmin(yarım2 a, yarım b);	API düzeyi 24'te eklendi
yarım2 fmin(yarım2 a, yarım2 b);	API düzeyi 24'te eklendi
yarım3 fmin(yarım a, yarım b);	API düzeyi 24'te eklendi
yarım3 fmin(yarım3 a, yarım3 b);	API düzeyi 24'te eklendi
yarım 4 fmin(yarım a, yarım b);	API düzeyi 24'te eklendi
yarım 4 fmin(yarım a, yarım4 b);	API düzeyi 24'te eklendi

Minimum a ve b değerini döndürür (ör. (a > b ? b : a)).

min() işlevi aynı sonuçları döndürür ancak daha fazla veri türüne uygulanabilir.

fmod : Modlo

kayan noktalı fmod(kayan pay, kayan payda);
float2 fmod(float2 pay, float2 payda);
float3 fmod(float3 pay, float3 payda);
float4 fmod(float4 pay, float4 payda);
half fmod(yarım pay, yarım payda);	API düzeyi 24'te eklendi
half2 fmod(yarım2 pay, yarım2 payda);	API düzeyi 24'te eklendi
half3 fmod(yarım3 pay, yarım3 payda);	API düzeyi 24'te eklendi
half4 fmod(yarım4 payı, yarım4 payda);	API düzeyi 24'te eklendi

Bölmenin sıfıra doğru yuvarlandığı kalan kısmını (pay / payda) döndürür.

remainder() işlevi benzerdir ancak en yakın tam sayıya yuvarlanır. Örneğin, fmod(-3.8f, 2.f) değeri -1.8f (-3.8f - -1.f * 2.f) değerini, remainder(-3.8f, 2.f) değeri ise 0.2f (-3.8f - -2.f * 2.f) değerini döndürür.

frakt : Pozitif kesirli bölüm

float fract(float v);
kayan noktalı(float v, float* taban);
float2 fract(float2 v);
float2 fract(float2 v, float2* floor);
float3 fract(float3 v);
float3 fract(float3 - float3* floor);
float4 fract(float4 v);
float4 fract(float4 - float4* taban);
yarım frakt(yarım v);	API düzeyi 24'te eklendi
yarım frakt(yarım v, yarım* taban);	API düzeyi 24'te eklendi
half2 fract(half2 v);	API düzeyi 24'te eklendi
yarım2 frakt(yarım2 v, yarım2* taban);	API düzeyi 24'te eklendi
yarım3 frakt(yarım3 v);	API düzeyi 24'te eklendi
yarım3 frakt(yarım3 v, yarım3* taban);	API düzeyi 24'te eklendi
yarım4 frakt(yarım4 v);	API düzeyi 24'te eklendi
yarım4 frakt(yarım4 - yarım4* taban);	API düzeyi 24'te eklendi

Parametreler

v	Giriş değeri.
kat	Taban değer null değilse *kat, v'nin tabanı olarak ayarlanır.

v'nin pozitif kesirli kısmını döndürür, ör. v - floor(v).

Örneğin, fract(1.3f, &val) değeri 0.3f değerini döndürür ve val'i 1.f olarak ayarlar. fract(-1.3f, &val) değeri 0.7f değerini döndürür ve val değerini -2.f olarak ayarlar.

frexp : İkili mantis ve üs

float frexp(float v, int* üs);
float2 frexp(float2 v, int2* üs);
float3 frexp(float3 v, int3* üs);
float4 frexp(float4 v, int4* üs);
yarım frexp(half v, int* üs);	API düzeyi 24'te eklendi
half2 frexp(half2 v, int2* üs);	API düzeyi 24'te eklendi
half3 frexp(half3 v, int3* üs);	API düzeyi 24'te eklendi
half4 frexp(half4 v, int4* üs);	API düzeyi 24'te eklendi

Parametreler

v	Giriş değeri.
üs	Üs null değilse *üs, v'nin üssü olarak ayarlanır.

v'nin ikili mantisini ve üssünü döndürür, ör. v == mantissa * 2 ^ exponent.

Mantissa her zaman 0,5 (dahil) ile 1,0 (hariç) arasındadır.

Ters işlem için ldexp() öğesine bakın. Ayrıca bkz. logb() ve ilogb().

half_recip : 16 bit hassasiyetle ters hesaplanan

Float_recip(float v);	API düzeyi 17'de eklendi
float2 well_recip(float2 v);	API düzeyi 17'de eklendi
float3 center_recip(float3 v);	API düzeyi 17'de eklendi
float4 well_recip(float4 v);	API düzeyi 17'de eklendi

Bir değerin yaklaşık tersini döndürür.

Hassasiyet, 16 bitlik bir kayan nokta değeridir.

Ayrıca native_recip() işlevini de inceleyin.

half_rsqrt : 16 bit hassasiyete hesaplanan bir karekökün tersi

float full_rsqrt(float v);	API düzeyi 17'de eklendi
float2 center_rsqrt(float2 v);	API düzeyi 17'de eklendi
float3 well_rsqrt(float3 v);	API düzeyi 17'de eklendi
float4 Near_rsqrt(float4 v);	API düzeyi 17'de eklendi

(1.f / sqrt(value)) değerinin yaklaşık değerini döndürür.

Hassasiyet, 16 bitlik bir kayan nokta değeridir.

Ayrıca bkz. rsqrt(), native_rsqrt().

half_sqrt : Karekök 16 bit hassasiyetle hesaplanır

float_sqrt(float v);	API düzeyi 17'de eklendi
float2 well_sqrt(float2 v);	API düzeyi 17'de eklendi
float3 center_sqrt(float3 v);	API düzeyi 17'de eklendi
float4 center_sqrt(float4 v);	API düzeyi 17'de eklendi

Bir değerin yaklaşık karekökünü döndürür.

Hassasiyet, 16 bitlik bir kayan nokta değeridir.

Ayrıca bkz. sqrt(), native_sqrt().

hipot : Hipotenüs

kayan hipotez(float a, kayan b);
float2 hipot(float2 a, float2 b);
float3 hypot(float3 a, float3 b);
float4 hipot(float4 a, float4 b);
yarım hipot(yarım a, yarım b);	API düzeyi 24'te eklendi
yarım2 hipot(yarım2 a, yarım2 b);	API düzeyi 24'te eklendi
yarım3 hipot(yarım3 a, yarım3 b);	API düzeyi 24'te eklendi
yarım4 hipot(yarım4 a, yarım4 b);	API düzeyi 24'te eklendi

Hipotenüsü döndürür (ör. sqrt(a * a + b * b)).

Ayrıca native_hypot() işlevini de inceleyin.

ilogb : İki üs tabanı

int ilogb(float v);
int ilogb(yarım v);	API düzeyi 24'te eklendi
int2 ilogb(float2 v);
int2 ilogb(half2 v);	API düzeyi 24'te eklendi
int3 ilogb(float3 v);
int3 ilogb(half3 v);	API düzeyi 24'te eklendi
int4 ilogb(float4 v);
int4 ilogb(half4 v);	API düzeyi 24'te eklendi

Bir değerin iki tabanındaki üssünü döndürür. Burada mantis 1.f (dahil) ile 2.f (hariç) arasındadır.

Örneğin, ilogb(8.5f), 3 değerini döndürür.

Mantissadaki fark nedeniyle, bu sayı frexp() tarafından döndürülen değerden bir küçüktür.

logb() benzerdir ancak bir ondalık değer döndürür.

ldexp : Mantis ve üssten bir kayan nokta oluşturur

float ldexp(float mantissa, int üs);
float2 ldexp(float2 mantissa, int üs);
float2 ldexp(float2 mantissa, int2 üs);
float3 ldexp(float3 mantissa, int üs);
float3 ldexp(float3 mantissa, int3 üs);
float4 ldexp(float4 mantissa, int üs);
float4 ldexp(float4 mantissa, int4 üs);
half ldexp(half mantissa, int üs);	API düzeyi 24'te eklendi
half2 ldexp(half2 mantissa, int üs);	API düzeyi 24'te eklendi
half2 ldexp(half2 mantissa, int2 üs);	API düzeyi 24'te eklendi
half3 ldexp(half3 mantissa, int üs);	API düzeyi 24'te eklendi
half3 ldexp(half3 mantissa, int3 üs);	API düzeyi 24'te eklendi
half4 ldexp(half4 mantissa, int üs);	API düzeyi 24'te eklendi
half4 ldexp(half4 mantissa, int4 üs);	API düzeyi 24'te eklendi

Parametreler

Mantissa	Mantissa.
üs	Üs, tek bileşen veya eşleşen vektör.

Mantissa ve üstelden (mantissa * 2 ^ üs) oluşturulan kayan noktayı döndürür.

Ters işlem için frexp() konusuna bakın.

lgamma : Gama işlevinin doğal logaritması

float lgamma(float v);
kayan 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);
yarım lgamma(yarım v);	API düzeyi 24'te eklendi
yarım lgamma(half v, int* sign_of_gamma);	API düzeyi 24'te eklendi
half2 lgamma(half2 v);	API düzeyi 24'te eklendi
half2 lgamma(half2 - int2* sign_of_gamma);	API düzeyi 24'te eklendi
half3 lgamma(half3 v);	API düzeyi 24'te eklendi
half3 lgamma(half3 - int3* sign_of_gamma);	API düzeyi 24'te eklendi
half4 lgamma(half4 v);	API düzeyi 24'te eklendi
half4 lgamma(half4 - int4* sign_of_gamma);	API düzeyi 24'te eklendi

Parametreler

v
gama_işareti	Gama_işareti null değilse v_işareti, v'nin gamı negatifse gam_işareti -1.f, aksi takdirde 1.f olarak ayarlanır.

Gama işlevinin mutlak değerinin doğal logaritmasını döndürür (ör. log(fabs(tgamma(v)))).

Ayrıca bkz. tgamma().

log : Doğal logaritma

kayan log(float v);
float2 log(float2 v);
float3 log(float3 v);
float4 log(float4 v);
half log(half v);	API düzeyi 24'te eklendi
half2 log(half2 v);	API düzeyi 24'te eklendi
half3 log(half3 v);	API düzeyi 24'te eklendi
half4 log(half4 v);	API düzeyi 24'te eklendi

Doğal logaritmayı döndürür.

Ayrıca bkz. native_log().

log10 : 10 tabanındaki logaritma

kayan log10(float v);
float2 log10(float2 v);
float3 log10(float3 v);
float4 log10(float4 v);
yarım log10(yarım v);	API düzeyi 24'te eklendi
half2 log10(half2 v);	API düzeyi 24'te eklendi
half3 log10(half3 v);	API düzeyi 24'te eklendi
half4 log10(half4 v);	API düzeyi 24'te eklendi

10 tabanındaki logaritmayı döndürür.

Ayrıca bkz. native_log10().

log1p : Değer artı 1'in doğal logaritması

float log1p(float v);
float2 log1p(float2 v);
float3 log1p(float3 v);
float4 log1p(float4 v);
half log1p(yarım v);	API düzeyi 24'te eklendi
half2 log1p(half2 v);	API düzeyi 24'te eklendi
half3 log1p(half3 v);	API düzeyi 24'te eklendi
half4 log1p(half4 v);	API düzeyi 24'te eklendi

(v + 1.f) ifadesinin doğal logaritmasını döndürür.

Ayrıca bkz. native_log1p().

log2 : 2. baz logaritması

kayan log2(float v);
float2 log2(float2 v);
float3 log2(float3 v);
float4 log2(float4 v);
half log2(half v);	API düzeyi 24'te eklendi
half2 log2(half2 v);	API düzeyi 24'te eklendi
half3 log2(half3 v);	API düzeyi 24'te eklendi
half4 log2(half4 v);	API düzeyi 24'te eklendi

2 tabanındaki logaritmayı döndürür.

Ayrıca bkz. native_log2().

logb : İki üs tabanı

kayan logb(float v);
float2 logb(float2 v);
float3 logb(float3 v);
float4 logb(float4 v);
half logb(half v);	API düzeyi 24'te eklendi
half2 logb(half2 v);	API düzeyi 24'te eklendi
half3 logb(half3 v);	API düzeyi 24'te eklendi
half4 logb(half4 v);	API düzeyi 24'te eklendi

Bir değerin iki tabanındaki üssünü döndürür. Burada mantis 1.f (dahil) ile 2.f (hariç) arasındadır.

Örneğin, logb(8.5f) 3.f değerini döndürür.

Bu sayı, mantisteki farktan dolayı frexp() tarafından döndürülen değerden bir küçüktür.

ilogb() işlevi benzerdir ancak bir tam sayı döndürür.

mad : Çarpma ve toplama

float mad(float çarpma1, float çarpma2, float ofset);
float2 mad(float2 çarpılan1, float2 çarpılan2, float2 ofset);
float3 mad(float3 multiplicand1, float3 multiplicand2, float3 ofset);
float4 mad(float4 çarpılan1, float4 çarpılan2, float4 ofset);
half mad(half çarpılan1, yarım çarpılan2, yarım ofset);	API düzeyi 24'te eklendi
half2 mad(half2 çarpılan1, yarım2 çarpılan2, yarım2 ofset);	API düzeyi 24'te eklendi
half3 mad(half3 çarpılan1, yarım3 çarpım2, yarım3 göreli konum);	API düzeyi 24'te eklendi
half4 mad(half4 çarpılan1, yarım4 çarpım2, yarım4 ofset);	API düzeyi 24'te eklendi

Çoğaltma ve toplama. (multiplicand1 * multiplicand2) + offset değerini döndürür.

Bu işlev fma() işlevine benzer. fma(), çarpılan sonucun tam hassasiyetini korur ve yalnızca toplamadan sonra yuvarlanır. mad(), çarpma ve toplama işleminden sonra yuvarlanır. rs_fp_relaxed modunda mad(), çarpma işleminden sonra yuvarlama işlemini yapamaz.

max : Maksimum

karakter maks(karakter a; karakter b);
char2 max(char2 a, char2 b);
char3 max(char3 a, char3 b);
char4 max(char4 a, char4 b);
float max(float a, float b);
float2 max(float2 a, kayan b);
float2 max(float2 a, float2 b);
float3 max(float3 a, kayan b);
float3 max(float3 a, float3 b);
float4 max(float4 a, kayan b);
float4 max(float4 a, float4 b);
yarım max(yarım a, yarım b);	API düzeyi 24'te eklendi
yarım2 max(yarım2 a, yarım b);	API düzeyi 24'te eklendi
yarım2 max(yarım2 a, yarım2 b);	API düzeyi 24'te eklendi
yarım3 max(yarım3 a, yarım b);	API düzeyi 24'te eklendi
yarım3 max(yarım3 a, yarım3 b);	API düzeyi 24'te eklendi
yarım4 max(yarım4 a, yarım b);	API düzeyi 24'te eklendi
yarım4 max(yarım4 a, yarım4 b);	API düzeyi 24'te eklendi
int max(int a, int b);
int2 max(int2 a, int2 b);
int3 max(int3 a, int3 b);
int4 max(int4 a, int4 b);
long max(long a, long b);	API düzeyi 21'de eklendi
long2 max(long2 a, long2 b);	API düzeyi 21'de eklendi
long3 max(long3 a, long3 b);	API düzeyi 21'de eklendi
long4 max(long4 a, long4 b);	API düzeyi 21'de eklendi
kısa max(short a, short b);
short2 max(short2 a, short2 b);
short3 max(short3 a, short3 b);
short4 max(short4 a, short4 b);
uchar max(uchar a, uchar b);
uchar2 max(uchar2 a, uchar2 b);
uchar3 max(uchar3 a, uchar3 b);
uchar4 max(uchar4 a, uchar4 b);
uint max(uint a, uint b);
uint2 max(uint2 a, uint2 b);
uint3 max(uint3 a, uint3 b);
uint4 max(uint4 a, uint4 b);
ulong max(ulong a, ulong b);	API düzeyi 21'de eklendi
ulong2 max(ulong2 a, ulong2 b);	API düzeyi 21'de eklendi
ulong3 max(ulong3 a, ulong3 b);	API düzeyi 21'de eklendi
ulong4 max(ulong4 a, ulong4 b);	API düzeyi 21'de eklendi
ushort max(ushort a, ushort b);
ushort2 max(ushort2 a, ushort2 b);
ushort3 max(ushort3 a, ushort3 b);
ushort4 max(ushort4 a, ushort4 b);

İki bağımsız değişkenin maksimum değerini döndürür.

min : Minimum

karakter min(karakter a; karakter b);
char2 min(char2 a, char2 b);
char3 min(char3 a, char3 b);
char4 min(char4 a, char4 b);
kayan noktalı min(kayan a, kayan b);
float2 min(float2 a, kayan b);
float2 min(float2 a, float2 b);
float3 min(float3 a, kayan b);
float3 min(float3 a, float3 b);
float4 min(float4 a, kayan b);
float4 min(float4 a, float4 b);
yarım dakika(yarım a, yarım b);	API düzeyi 24'te eklendi
yarım 2 dk(yarım2 a, yarım b);	API düzeyi 24'te eklendi
yarım 2 dk(yarım2 a, yarım2 b);	API düzeyi 24'te eklendi
yarım 3 dk(30 a, yarım b);	API düzeyi 24'te eklendi
yarım 3 dakika(yarım3 a, yarım3 b);	API düzeyi 24'te eklendi
yarım 4 dakika(yarım a, yarım b);	API düzeyi 24'te eklendi
yarım 4 dk(yarım 4 a, yarım4 b);	API düzeyi 24'te eklendi
int min(int a, int b);
int2 min(int2 a, int2 b);
int3 min(int3 a, int3 b);
int4 min(int4 a, int4 b);
uzun min(uzun a, uzun b);	API düzeyi 21'de eklendi
long2 min(long2 a, long2 b);	API düzeyi 21'de eklendi
long3 min(long3 a, long3 b);	API düzeyi 21'de eklendi
long4 min(long4 a, long4 b);	API düzeyi 21'de eklendi
kısa min(kısa a, kısa b);
short2 min(short2 a, short2 b);
short3 min(short3 a, short3 b);
short4 min(short4 a, short4 b);
uchar min(uchar a, uchar b);
uchar2 min(uchar2 a, uchar2 b);
uchar3 min(uchar3 a, uchar3 b);
uchar4 min(uchar4 a, uchar4 b);
uint min(uint a, uint b);
uint2 min(uint2 a, uint2 b);
uint3 min(uint3 a, uint3 b);
uint4 min(uint4 a, uint4 b);
ulong min(ulong a, ulong b);	API düzeyi 21'de eklendi
ulong2 min(ulong2 a, ulong2 b);	API düzeyi 21'de eklendi
ulong3 min(ulong3 a, ulong3 b);	API düzeyi 21'de eklendi
ulong4 min(ulong4 a, ulong4 b);	API düzeyi 21'de eklendi
ushort min(ushort a, ushort b);
ushort2 min(ushort2 a, ushort2 b);
ushort3 min(ushort3 a, ushort3 b);
ushort4 min(ushort4 a, ushort4 b);

İki bağımsız değişkenin minimum değerini döndürür.

mix : İki değeri karıştırır

kayma mix'i(kayan noktalı başlangıç, kayma durdurma, kayma oranı);
float2 mix(float2 start, float2 durdurma, bolluk oranı);
float2 mix(float2 start, float2 durdurma, float2 kesir);
float3 mix(float3 start, float3 durdurma, bolluk oranı);
float3 mix(float3 start, float3 durdurma, float3 kesir);
float4 mix(float4 start, float4 durdurma, bolluk oranı);
float4 mix(float4 start, float4 durdurma, float4 kesir);
yarım mix(yarım başlangıç, yarım durak, yarım kesir);	API düzeyi 24'te eklendi
half2 mix(yarım2 başlangıç, yarım2 durak, yarım kesir);	API düzeyi 24'te eklendi
half2 mix(yarım2 başlangıç, yarım2 durak, yarım2 kesir);	API düzeyi 24'te eklendi
half3 mix(yarım3 başlangıç, yarım3 durak, yarım kesir);	API düzeyi 24'te eklendi
half3 mix(yarı3 başlangıç, yarım3 durak, yarım3 kesir);	API düzeyi 24'te eklendi
half4 mix(yarım4 başlangıç, yarım4 durak, yarım kesir);	API düzeyi 24'te eklendi
half4 mix(yarım4 başlangıç, yarım4 durak, yarım4 kesir);	API düzeyi 24'te eklendi

Başlangıcı + ((durdur - başlangıç) * kesiri döndürür.

Bu, iki değerin karıştırılması için yararlı olabilir. Örneğin, %40 renk1 ve% 60 renk2 olan yeni bir renk oluşturmak için mix(color1, color2, 0.6f) değerini kullanın.

modf : İntegral ve kesirli bileşenler

kayan 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);
yarım modf(yarım v, yarım* integral_part);	API düzeyi 24'te eklendi
half2 modf(half2 v, half2* integral_part);	API düzeyi 24'te eklendi
half3 modf(half3 - half3* integral_part);	API düzeyi 24'te eklendi
half4 modf(half4 - half4* integral_part);	API düzeyi 24'te eklendi

Parametreler

v	Kaynak değeri.
integral_parça	*integral_part, sayının integral bölümüne ayarlanır.

İlerlemeler

Değerin kayan nokta kısmı.

Bir sayının integral ve kesir bileşenlerini döndürür.

Her iki bileşenin de x ile aynı işareti olacaktır. Örneğin, -3.72f girdisi için *integral_part değeri, -3.f olarak ayarlanır ve .72f döndürülür.

nan : Sayı Değil

kayan nokta nan(uint v);

Parametreler

v	Kullanılmıyor.

NaN değeri döndürür (Sayı Değil).

nan_half : Sayı Değil

half nan_half();

API düzeyi 24'te eklendi

Yarı duyarlıklı kayan nokta NaN değeri döndürür (Sayı Değil).

native_acos : Yaklaşık ters kosinüs

kayan yerel_acos(float v);	API düzeyi 21'de eklendi
float2 Native_acos(float2 v);	API düzeyi 21'de eklendi
float3 Native_acos(float3 v);	API düzeyi 21'de eklendi
float4 Native_acos(float4 v);	API düzeyi 21'de eklendi
yarı yerel_acos(yarım v);	API düzeyi 24'te eklendi
half2 Native_acos(half2 v);	API düzeyi 24'te eklendi
half3 Native_acos(half3 v);	API düzeyi 24'te eklendi
half4 Native_acos(half4 v);	API düzeyi 24'te eklendi

Yaklaşık ters kosinüsü radyan cinsinden döndürür.

Bu işlev, -1'den küçük veya 1'den büyük giriş değerlerinden tanımlanmamış sonuçlar verir.

Ayrıca bkz. acos().

native_acosh : Yaklaşık ters hiperbolik kosinüs

kayan yerel_acosh(float v);	API düzeyi 21'de eklendi
float2 Native_acosh(float2 v);	API düzeyi 21'de eklendi
float3 Native_acosh(float3 v);	API düzeyi 21'de eklendi
float4 Native_acosh(float4 v);	API düzeyi 21'de eklendi
yarı yerel_acosh(yarım v);	API düzeyi 24'te eklendi
half2 Native_acosh(half2 v);	API düzeyi 24'te eklendi
half3 Native_acosh(half3 v);	API düzeyi 24'te eklendi
half4 Native_acosh(half4 v);	API düzeyi 24'te eklendi

Yaklaşık ters hiperbolik kosinüsü radyan cinsinden döndürür.

Ayrıca bkz. acosh().

native_acospi : Yaklaşık ters kosinüs değerinin pi sayısına bölümü

float Native_acospi(float v);	API düzeyi 21'de eklendi
float2 Native_acospi(float2 v);	API düzeyi 21'de eklendi
float3 Native_acospi(float3 v);	API düzeyi 21'de eklendi
float4 Native_acospi(float4 v);	API düzeyi 21'de eklendi
yarı yerel_acospi(yarım v);	API düzeyi 24'te eklendi
half2 Native_acospi(half2 v);	API düzeyi 24'te eklendi
half3 Native_acospi(yarım3 v);	API düzeyi 24'te eklendi
half4 Native_acospi(half4 v);	API düzeyi 24'te eklendi

Ters kosinüsün pi sayısına bölünmesiyle elde edilen yaklaşık ters kosinüsü radyan cinsinden döndürür.

Derece olarak ölçülen bir ters kosinüsü elde etmek için acospi(a) * 180.f işlevini kullanın.

Bu işlev, -1'den küçük veya 1'den büyük giriş değerlerinden tanımlanmamış sonuçlar verir.

Ayrıca acospi() işlevini de inceleyin.

native_asin : Yaklaşık ters sinüs

yerel_asin(float v); kayan nokta;	API düzeyi 21'de eklendi
float2 Native_asin(float2 v);	API düzeyi 21'de eklendi
float3 Native_asin(float3 v);	API düzeyi 21'de eklendi
float4 Native_asin(float4 v);	API düzeyi 21'de eklendi
yarı yerel_asin(yarım v);	API düzeyi 24'te eklendi
half2 Native_asin(half2 v);	API düzeyi 24'te eklendi
half3 Native_asin(half3 v);	API düzeyi 24'te eklendi
half4 Native_asin(half4 v);	API düzeyi 24'te eklendi

Yaklaşık ters sinüsü radyan cinsinden döndürür.

Bu işlev, -1'den küçük veya 1'den büyük giriş değerlerinden tanımlanmamış sonuçlar verir.

Ayrıca bkz. asin().

native_asinh : Yaklaşık ters hiperbolik sinüs

kayan yerel_asinh(float v);	API düzeyi 21'de eklendi
float2 Native_asinh(float2 v);	API düzeyi 21'de eklendi
float3 Native_asinh(float3 v);	API düzeyi 21'de eklendi
float4 Native_asinh(float4 v);	API düzeyi 21'de eklendi
yarı yerel_asinh(yarım v);	API düzeyi 24'te eklendi
half2 Native_asinh(half2 v);	API düzeyi 24'te eklendi
half3 Native_asinh(half3 v);	API düzeyi 24'te eklendi
half4 Native_asinh(half4 v);	API düzeyi 24'te eklendi

Yaklaşık ters hiperbolik sinüsü radyan cinsinden döndürür.

Ayrıca bkz. asinh().

native_asinpi : Yaklaşık ters sinüsün pi sayısına bölümü

kayan yerel_asinpi(kayan v);	API düzeyi 21'de eklendi
float2 Native_asinpi(float2 v);	API düzeyi 21'de eklendi
float3 Native_asinpi(float3 v);	API düzeyi 21'de eklendi
float4 Native_asinpi(float4 v);	API düzeyi 21'de eklendi
yarı yerel_asinpi(yarım v);	API düzeyi 24'te eklendi
half2 Native_asinpi(yarım2 v);	API düzeyi 24'te eklendi
half3 Native_asinpi(yarım3 v);	API düzeyi 24'te eklendi
half4 Native_asinpi(half4 v);	API düzeyi 24'te eklendi

Yaklaşık ters sinüsün pi sayısına bölünmesiyle elde edilen değeri radyan cinsinden döndürür.

Derece cinsinden ters sinüsü ölçmek için asinpi(a) * 180.f işlevini kullanın.

Bu işlev, -1'den küçük veya 1'den büyük giriş değerlerinden tanımlanmamış sonuçlar verir.

Ayrıca bkz. asinpi().

native_atan : Yaklaşık ters tanjant

kayan yerel_atan(float v);	API düzeyi 21'de eklendi
float2 Native_atan(float2 v);	API düzeyi 21'de eklendi
float3 Native_atan(float3 v);	API düzeyi 21'de eklendi
float4 Native_atan(float4 v);	API düzeyi 21'de eklendi
yarı yerel_atan(yarım v);	API düzeyi 24'te eklendi
half2 Native_atan(half2 v);	API düzeyi 24'te eklendi
half3 Native_atan(half3 v);	API düzeyi 24'te eklendi
half4 Native_atan(half4 v);	API düzeyi 24'te eklendi

Yaklaşık ters tanjantı radyan cinsinden döndürür.

Ayrıca bkz. atan().

native_atan2 : Oranın yaklaşık ters tanjantı

kayan yerel_atan2(kayan noktalı pay; kayan payda);	API düzeyi 21'de eklendi
float2 Native_atan2(float2 pay, float2 payda);	API düzeyi 21'de eklendi
float3 Native_atan2(float3 pay, float3 payda);	API düzeyi 21'de eklendi
float4 Native_atan2(float4 pay, float4 payda);	API düzeyi 21'de eklendi
yarı yerel_atan2(yarım pay, yarım payda);	API düzeyi 24'te eklendi
half2 Native_atan2(yarım2 pay, yarım2 payda);	API düzeyi 24'te eklendi
half3 Native_atan2(yarım3 pay, yarım3 payda);	API düzeyi 24'te eklendi
half4 Native_atan2(yarım4 pay, yarım4 payda);	API düzeyi 24'te eklendi

Parametreler

pay	Pay.
payda	Payda. 0 olabilir.

(numerator / denominator) değerinin yaklaşık ters tanjantını radyan cinsinden döndürür.

Ayrıca bkz. atan2().

native_atan2pi : Oranın yaklaşık ters tanjantının pi sayısına bölümü

kayan yerel_atan2pi(kayan noktalı pay, kayan payda);	API düzeyi 21'de eklendi
float2 Native_atan2pi(float2 pay, float2 payda);	API düzeyi 21'de eklendi
float3 Native_atan2pi(float3 pay, float3 payda);	API düzeyi 21'de eklendi
float4 Native_atan2pi(float4 pay, float4 payda);	API düzeyi 21'de eklendi
yarım yerel_atan2pi(yarım pay, yarım payda);	API düzeyi 24'te eklendi
half2 Native_atan2pi(yarım2 pay, yarım2 payda);	API düzeyi 24'te eklendi
half3 Native_atan2pi(yarım3 pay, yarım3 payda);	API düzeyi 24'te eklendi
half4 Native_atan2pi(yarım4 pay, yarım4 payda);	API düzeyi 24'te eklendi

Parametreler

pay	Pay.
payda	Payda. 0 olabilir.

(numerator / denominator) işlevinin yaklaşık ters tanjantını radyan cinsinden pi sayısına bölerek döndürür.

Derece olarak ölçülen bir ters tanjant elde etmek için atan2pi(n, d) * 180.f işlevini kullanın.

Ayrıca bkz. atan2pi().

native_atanh : Yaklaşık ters hiperbolik tanjant

kayan yerel_atanh(float v);	API düzeyi 21'de eklendi
float2 Native_atanh(float2 v);	API düzeyi 21'de eklendi
float3 Native_atanh(float3 v);	API düzeyi 21'de eklendi
float4 Native_atanh(float4 v);	API düzeyi 21'de eklendi
yarı yerel_atanh(yarım v);	API düzeyi 24'te eklendi
half2 Native_atanh(half2 v);	API düzeyi 24'te eklendi
half3 Native_atanh(half3 v);	API düzeyi 24'te eklendi
half4 Native_atanh(half4 v);	API düzeyi 24'te eklendi

Yaklaşık ters hiperbolik tanjantı radyan cinsinden döndürür.

Ayrıca bkz. atanh().

native_atanpi : Yaklaşık ters tanjantın pi sayısına bölümü

kayan yerel_atanpi(float v);	API düzeyi 21'de eklendi
float2 Native_atanpi(float2 v);	API düzeyi 21'de eklendi
float3 Native_atanpi(float3 v);	API düzeyi 21'de eklendi
float4 Native_atanpi(float4 v);	API düzeyi 21'de eklendi
yarı yerel_atanpi(yarım v);	API düzeyi 24'te eklendi
half2 Native_atanpi(half2 v);	API düzeyi 24'te eklendi
half3 Native_atanpi(half3 v);	API düzeyi 24'te eklendi
half4 Native_atanpi(half4 v);	API düzeyi 24'te eklendi

Yaklaşık ters tanjantı radyan cinsinden, pi sayısına bölerek döndürür.

Derece olarak ölçülen bir ters tanjant elde etmek için atanpi(a) * 180.f işlevini kullanın.

Ayrıca bkz. atanpi().

native_cbrt : Yaklaşık küp kök

kayan yerel_cbrt(float v);	API düzeyi 21'de eklendi
float2 Native_cbrt(float2 v);	API düzeyi 21'de eklendi
float3 Native_cbrt(float3 v);	API düzeyi 21'de eklendi
float4 Native_cbrt(float4 v);	API düzeyi 21'de eklendi
yarı yerel_cbrt(yarım v);	API düzeyi 24'te eklendi
half2 Native_cbrt(half2 v);	API düzeyi 24'te eklendi
half3 Native_cbrt(half3 v);	API düzeyi 24'te eklendi
half4 Native_cbrt(half4 v);	API düzeyi 24'te eklendi

Yaklaşık kübik kökü döndürür.

Ayrıca bkz. cbrt().

native_cos : Yaklaşık kosinüs

float Native_cos(float v);	API düzeyi 21'de eklendi
float2 Native_cos(float2 v);	API düzeyi 21'de eklendi
float3 Native_cos(float3 v);	API düzeyi 21'de eklendi
float4 Native_cos(float4 v);	API düzeyi 21'de eklendi
half Native_cos(half v);	API düzeyi 24'te eklendi
half2 Native_cos(half2 v);	API düzeyi 24'te eklendi
half3 Native_cos(half3 v);	API düzeyi 24'te eklendi
half4 Native_cos(half4 v);	API düzeyi 24'te eklendi

Açının radyan cinsinden yaklaşık kosinüsünü döndürür.

Ayrıca bkz. cos().

native_cosh : Yaklaşık hipbolik kosinüs

float Native_cosh(float v);	API düzeyi 21'de eklendi
float2 Native_cosh(float2 v);	API düzeyi 21'de eklendi
float3 Native_cosh(float3 v);	API düzeyi 21'de eklendi
float4 Native_cosh(float4 v);	API düzeyi 21'de eklendi
yarı yerel_cosh(yarım v);	API düzeyi 24'te eklendi
half2 Native_cosh(half2 v);	API düzeyi 24'te eklendi
half3 Native_cosh(half3 v);	API düzeyi 24'te eklendi
half4 Native_cosh(half4 v);	API düzeyi 24'te eklendi

Yaklaşık hipbolik kosinüsü döndürür.

Ayrıca bkz. cosh().

native_cospi : Sayının yaklaşık kosinüsünün pi sayısıyla çarpımı

float Native_cospi(float v);	API düzeyi 21'de eklendi
float2 Native_cospi(float2 v);	API düzeyi 21'de eklendi
float3 Native_cospi(float3 v);	API düzeyi 21'de eklendi
float4 Native_cospi(float4 v);	API düzeyi 21'de eklendi
half Native_cospi(yarım v);	API düzeyi 24'te eklendi
half2 Native_cospi(half2 v);	API düzeyi 24'te eklendi
half3 Native_cospi(half3 v);	API düzeyi 24'te eklendi
half4 Native_cospi(half4 v);	API düzeyi 24'te eklendi

(v * pi) değerinin yaklaşık kosinüsünü döndürür. Burada (v * pi), radyan cinsinden ölçülür.

Derece cinsinden ölçülen bir değerin kosinüsünü öğrenmek için cospi(v / 180.f) aramasını yapın.

Ayrıca bkz. cospi().

native_divide : Yaklaşık bölüm

float Native_divide(float sol_Vektör, float sağ_Vektör);	API düzeyi 21'de eklendi
float2 Native_divide(float2 sol_vektör, float2 sağ_vektör);	API düzeyi 21'de eklendi
float3 Native_divide(float3 left_Vektör, float3 right_Vektör);	API düzeyi 21'de eklendi
float4 Native_divide(float4 sol_Vektör, float4 right_Vektör);	API düzeyi 21'de eklendi
yarı yerel_divide(yarım sol_vektör, yarım sağ_vektör);	API düzeyi 24'te eklendi
half2 yerel_divide(yarım2 sol_vektör, yarım2 sağ_vektör);	API düzeyi 24'te eklendi
half3 Native_divide(half3 left_Vektör, half3 right_Vektör);	API düzeyi 24'te eklendi
half4 Native_divide(yarım4 sol_vektör, yarım4 sağ_vektör);	API düzeyi 24'te eklendi

İki değerin yaklaşık bölümünü hesaplar.

native_exp : Bir sayıya yükseltilen yaklaşık e değeri

kayan yerel_exp(float v);	API düzeyi 18'de eklendi
float2 Native_exp(float2 v);	API düzeyi 18'de eklendi
float3 Native_exp(float3 v);	API düzeyi 18'de eklendi
float4 Native_exp(float4 v);	API düzeyi 18'de eklendi
yarı yerel_exp(yarım v);	API düzeyi 24'te eklendi
half2 Native_exp(half2 v);	API düzeyi 24'te eklendi
half3 Native_exp(half3 v);	API düzeyi 24'te eklendi
half4 Native_exp(half4 v);	API düzeyi 24'te eklendi

Hızlı yaklaşık deneme

-86.f ile 86.f arasındaki girişler için geçerlidir. Hassasiyet, 16 bit kayan nokta değerlerinin kullanılması durumundan daha kötü değildir.

Ayrıca bkz. exp().

native_exp10 : Bir sayıya yükseltilen yaklaşık 10 sayısı

kayan yerel_exp10(kayan v);	API düzeyi 18'de eklendi
float2 Native_exp10(float2 v);	API düzeyi 18'de eklendi
float3 Native_exp10(float3 v);	API düzeyi 18'de eklendi
float4 Native_exp10(float4 v);	API düzeyi 18'de eklendi
yarı yerel_exp10(yarım v);	API düzeyi 24'te eklendi
half2 Native_exp10(yarım2 v);	API düzeyi 24'te eklendi
half3 Native_exp10(yarım3 v);	API düzeyi 24'te eklendi
half4 Native_exp10(yarım4 v);	API düzeyi 24'te eklendi

Hızlı yaklaşık ifade10.

-37.f ile 37.f arasındaki girişler için geçerlidir. Hassasiyet, 16 bit kayan nokta değerlerinin kullanılması durumundan daha kötü değildir.

Ayrıca bkz. exp10().

native_exp2 : Bir sayıya yükseltilen yaklaşık 2 öğe

kayan yerel_exp2(kayan v);	API düzeyi 18'de eklendi
float2 Native_exp2(float2 v);	API düzeyi 18'de eklendi
float3 Native_exp2(float3 v);	API düzeyi 18'de eklendi
float4 Native_exp2(float4 v);	API düzeyi 18'de eklendi
half Native_exp2(yarım v);	API düzeyi 24'te eklendi
half2 Native_exp2(yarım2 v);	API düzeyi 24'te eklendi
half3 Native_exp2(yarım3 v);	API düzeyi 24'te eklendi
half4 Native_exp2(yarım4 v);	API düzeyi 24'te eklendi

Hızlı yaklaşık ifade2.

-125.f ile 125.f arasındaki girişler için geçerlidir. Hassasiyet, 16 bit kayan nokta değerlerinin kullanılması durumundan daha kötü değildir.

Ayrıca bkz. exp2().

native_expm1 : Bir sayıya yükseltilmiş yaklaşık e değeri eksi bir

kayan yerel_expm1(kayan v);	API düzeyi 21'de eklendi
float2 Native_expm1(float2 v);	API düzeyi 21'de eklendi
float3 Native_expm1(float3 v);	API düzeyi 21'de eklendi
float4 Native_expm1(float4 v);	API düzeyi 21'de eklendi
half Native_expm1(yarım v);	API düzeyi 24'te eklendi
half2 Native_expm1(yarım2 v);	API düzeyi 24'te eklendi
half3 Native_expm1(yarım3 v);	API düzeyi 24'te eklendi
half4 Native_expm1(yarım4 v);	API düzeyi 24'te eklendi

(e ^ v) - 1 yaklaşık değerini döndürür.

Ayrıca bkz. expm1().

native_hypot : Yaklaşık hipotenüs

float Native_hypot(float a, float b);	API düzeyi 21'de eklendi
float2 Native_hypot(float2 a, float2 b);	API düzeyi 21'de eklendi
float3 Native_hypot(float3 a, float3 b);	API düzeyi 21'de eklendi
float4 Native_hypot(float4 a, float4 b);	API düzeyi 21'de eklendi
yarı yerel_hypot(yarım a, yarım b);	API düzeyi 24'te eklendi
half2 Native_hypot(yarım2 a, yarım2 b);	API düzeyi 24'te eklendi
half3 Native_hypot(yarım3 a, yarım3 b);	API düzeyi 24'te eklendi
half4 Native_hypot(yarım a, yarım4 b);	API düzeyi 24'te eklendi

Yaklaşık yerel_sqrt değerini döndürür(a * a + b * b)

hypot() işlevini de inceleyin.

native_log : Yaklaşık doğal logaritma

float Native_log(float v);	API düzeyi 18'de eklendi
float2 Native_log(float2 v);	API düzeyi 18'de eklendi
float3 Native_log(float3 v);	API düzeyi 18'de eklendi
float4 Native_log(float4 v);	API düzeyi 18'de eklendi
yarı yerel_log(yarım v);	API düzeyi 24'te eklendi
half2 Native_log(half2 v);	API düzeyi 24'te eklendi
half3 Native_log(half3 v);	API düzeyi 24'te eklendi
half4 local_log(half4 v);	API düzeyi 24'te eklendi

Hızlı yaklaşık günlük kaydı.

Sıfıra çok yakın değerler için doğru değildir.

Ayrıca bkz. log().

native_log10 : Yaklaşık 10 tabanında logaritma

float Native_log10(float v);	API düzeyi 18'de eklendi
float2 Native_log10(float2 v);	API düzeyi 18'de eklendi
float3 Native_log10(float3 v);	API düzeyi 18'de eklendi
float4 Native_log10(float4 v);	API düzeyi 18'de eklendi
yarı yerel_log10(yarım v);	API düzeyi 24'te eklendi
half2 Native_log10(half2 v);	API düzeyi 24'te eklendi
half3 Native_log10(half3 v);	API düzeyi 24'te eklendi
half4 Native_log10(half4 v);	API düzeyi 24'te eklendi

Hızlı yaklaşık günlük10.

Sıfıra çok yakın değerler için doğru değildir.

Ayrıca bkz. log10().

native_log1p : Değerin yaklaşık doğal logaritması artı 1

kayan yerel_log1p(float v);	API düzeyi 21'de eklendi
float2 Native_log1p(float2 v);	API düzeyi 21'de eklendi
float3 Native_log1p(float3 v);	API düzeyi 21'de eklendi
float4 Native_log1p(float4 v);	API düzeyi 21'de eklendi
yarı yerel_log1p(yarım v);	API düzeyi 24'te eklendi
half2 Native_log1p(half2 v);	API düzeyi 24'te eklendi
half3 Native_log1p(half3 v);	API düzeyi 24'te eklendi
half4 Native_log1p(half4 v);	API düzeyi 24'te eklendi

(v + 1.0f) değerinin yaklaşık doğal logaritmasını döndürür

Ayrıca bkz. log1p().

native_log2 : Yaklaşık 2 taban logaritma

kayan yerel_log2(float v);	API düzeyi 18'de eklendi
float2 Native_log2(float2 v);	API düzeyi 18'de eklendi
float3 Native_log2(float3 v);	API düzeyi 18'de eklendi
float4 Native_log2(float4 v);	API düzeyi 18'de eklendi
half Native_log2(yarım v);	API düzeyi 24'te eklendi
half2 Native_log2(half2 v);	API düzeyi 24'te eklendi
half3 Native_log2(half3 v);	API düzeyi 24'te eklendi
half4 Native_log2(half4 v);	API düzeyi 24'te eklendi

Hızlı yaklaşık günlük2.

Sıfıra çok yakın değerler için doğru değildir.

Ayrıca bkz. log2().

native_powr : Üsse yükseltilen yaklaşık pozitif taban

kayan yerel_powr(kayan taban, kayan üs);	API düzeyi 18'de eklendi
float2 Native_powr(float2 base, float2 üs);	API düzeyi 18'de eklendi
float3 Native_powr(float3 base, float3 üs);	API düzeyi 18'de eklendi
float4 Native_powr(float4 base, float4 üs);	API düzeyi 18'de eklendi
yarı yerel_powr(yarım taban, yarım üs);	API düzeyi 24'te eklendi
half2 Native_powr(yarım2 taban, yarım2 üs);	API düzeyi 24'te eklendi
half3 Native_powr(yarım3 taban, yarım3 üs);	API düzeyi 24'te eklendi
half4 Native_powr(yarım4 taban, yarım4 üs);	API düzeyi 24'te eklendi

Parametreler

gövde	0.f ile 256.f arasında olmalıdır. Fonksiyon, sıfıra çok yakın değerler için doğru değildir.
üs	-15.f ile 15.f arasında olmalıdır.

Hızlı yaklaşık (taban ^ üs).

Ayrıca powr() konusuna da bakın.

native_recip : Yaklaşık tersi

kayan yerel_recip(kayan v);	API düzeyi 21'de eklendi
float2 Native_recip(float2 v);	API düzeyi 21'de eklendi
float3 Native_recip(float3 v);	API düzeyi 21'de eklendi
float4 Native_recip(float4 v);	API düzeyi 21'de eklendi
yarı yerel_recip(yarım v);	API düzeyi 24'te eklendi
half2 Native_recip(yarım2 v);	API düzeyi 24'te eklendi
half3 Native_recip(yarım3 v);	API düzeyi 24'te eklendi
half4 Native_recip(half4 v);	API düzeyi 24'te eklendi

Bir değerin yaklaşık tersini döndürür.

Ayrıca bkz. half_recip().

native_rootn : Yaklaşık n'inci kök

float Native_rootn(float v, int n);	API düzeyi 21'de eklendi
float2 Native_rootn(float2 v, int2 n);	API düzeyi 21'de eklendi
float3 Native_rootn(float3 v, int3 n);	API düzeyi 21'de eklendi
float4 Native_rootn(float4 v, int4 n);	API düzeyi 21'de eklendi
half Native_rootn(half v, int n);	API düzeyi 24'te eklendi
half2 Native_rootn(half2 v, int2 n);	API düzeyi 24'te eklendi
half3 Native_rootn(half3 v, int3 n);	API düzeyi 24'te eklendi
half4 Native_rootn(half4 - int4 n);	API düzeyi 24'te eklendi

Değerin yaklaşık N. kökünü hesaplayın.

Ayrıca bkz. rootn().

native_rsqrt : Karekökün yaklaşık tersi

float Native_rsqrt(float v);	API düzeyi 21'de eklendi
float2 Native_rsqrt(float2 v);	API düzeyi 21'de eklendi
float3 Native_rsqrt(float3 v);	API düzeyi 21'de eklendi
float4 Native_rsqrt(float4 v);	API düzeyi 21'de eklendi
half Native_rsqrt(half v);	API düzeyi 24'te eklendi
half2 Native_rsqrt(half2 v);	API düzeyi 24'te eklendi
half3 Native_rsqrt(half3 v);	API düzeyi 24'te eklendi
half4 Native_rsqrt(half4 v);	API düzeyi 24'te eklendi

Yaklaşık döndürür (1 / karektör(v)).

Ayrıca bkz. rsqrt(), half_rsqrt().

native_sin : Yaklaşık sinüs

yerel_sin(float v); kayan nokta;	API düzeyi 21'de eklendi
float2 Native_sin(float2 v);	API düzeyi 21'de eklendi
float3 Native_sin(float3 v);	API düzeyi 21'de eklendi
float4 Native_sin(float4 v);	API düzeyi 21'de eklendi
yarı yerel_sin(yarım v);	API düzeyi 24'te eklendi
half2 Native_sin(half2 v);	API düzeyi 24'te eklendi
half3 Native_sin(half3 v);	API düzeyi 24'te eklendi
half4 Native_sin(half4 v);	API düzeyi 24'te eklendi

Açının radyan cinsinden ölçülen yaklaşık sinüsünü döndürür.

Ayrıca bkz. sin().

native_sincos : Yaklaşık sinüs ve kosinüs

float Native_sincos(float v, float* cos);	API düzeyi 21'de eklendi
float2 Native_sincos(float2 v, float2* cos);	API düzeyi 21'de eklendi
float3 Native_sincos(float3 v, float3* cos);	API düzeyi 21'de eklendi
float4 Native_sincos(float4 v, float4* cos);	API düzeyi 21'de eklendi
half Native_sincos(half v, half* cos);	API düzeyi 24'te eklendi
half2 Native_sincos(half2 v, half2* cos);	API düzeyi 24'te eklendi
half3 Native_sincos(half3 v, half3* cos);	API düzeyi 24'te eklendi
half4 Native_sincos(half4 v, half4* cos);	API düzeyi 24'te eklendi

Parametreler

v	Radyan cinsinden gelen değer.
cos	*cos, kosinüs değerine ayarlanır.

İlerlemeler

Sinüs.

Bir değerin yaklaşık sinüsü ve kosinüsünü döndürür.

Ayrıca bkz. sincos().

native_sinh : Yaklaşık hiperbolik sinüs

yerel_sinh(float v); kayan nokta;	API düzeyi 21'de eklendi
float2 Native_sinh(float2 v);	API düzeyi 21'de eklendi
float3 Native_sinh(float3 v);	API düzeyi 21'de eklendi
float4 Native_sinh(float4 v);	API düzeyi 21'de eklendi
yarı yerel_sinh(yarım v);	API düzeyi 24'te eklendi
half2 Native_sinh(half2 v);	API düzeyi 24'te eklendi
half3 Native_sinh(half3 v);	API düzeyi 24'te eklendi
half4 Native_sinh(yarım4 v);	API düzeyi 24'te eklendi

Radyan cinsinden belirtilen bir değerin yaklaşık hiperbolik sinüsünü döndürür.

Ayrıca bkz. sinh().

native_sinpi : Sayının yaklaşık sinüsünün pi ile çarpımı

yerel_sinpi(kayan v);	API düzeyi 21'de eklendi
float2 Native_sinpi(float2 v);	API düzeyi 21'de eklendi
float3 Native_sinpi(float3 v);	API düzeyi 21'de eklendi
float4 Native_sinpi(float4 v);	API düzeyi 21'de eklendi
yarı yerel_sinpi(yarım v);	API düzeyi 24'te eklendi
half2 yerel_sinpi(yarım2 v);	API düzeyi 24'te eklendi
half3 Native_sinpi(yarım3 v);	API düzeyi 24'te eklendi
half4 Native_sinpi(yarım4 v);	API düzeyi 24'te eklendi

(v * pi) değerinin yaklaşık sinüsünü döndürür. Burada (v * pi), radyan cinsinden ölçülür.

Derece cinsinden ölçülen bir değerin sinüsünü öğrenmek için sinpi(v / 180.f) çağrısı yapın.

Ayrıca bkz. sinpi().

native_sqrt : Yaklaşık karekök

kayan yerel_sqrt(float v);	API düzeyi 21'de eklendi
float2 Native_sqrt(float2 v);	API düzeyi 21'de eklendi
float3 Native_sqrt(float3 v);	API düzeyi 21'de eklendi
float4 Native_sqrt(float4 v);	API düzeyi 21'de eklendi
yarı yerel_sqrt(yarım v);	API düzeyi 24'te eklendi
half2 Native_sqrt(half2 v);	API düzeyi 24'te eklendi
half3 Native_sqrt(half3 v);	API düzeyi 24'te eklendi
half4 Native_sqrt(half4 v);	API düzeyi 24'te eklendi

Yaklaşık karekri(v) döndürür.

Ayrıca bkz. sqrt(), half_sqrt().

native_tan : Yaklaşık tanjant

float Native_tan(float v);	API düzeyi 21'de eklendi
float2 Native_tan(float2 v);	API düzeyi 21'de eklendi
float3 Native_tan(float3 v);	API düzeyi 21'de eklendi
float4 Native_tan(float4 v);	API düzeyi 21'de eklendi
yarı yerel_tan(yarım v);	API düzeyi 24'te eklendi
half2 Native_tan(half2 v);	API düzeyi 24'te eklendi
half3 Native_tan(half3 v);	API düzeyi 24'te eklendi
half4 Native_tan(half4 v);	API düzeyi 24'te eklendi

Açının radyan cinsinden ölçülen yaklaşık tanjantını döndürür.

native_tanh : Yaklaşık hiperbolik tanjant

kayan Native_tanh(float v);	API düzeyi 21'de eklendi
float2 Native_tanh(float2 v);	API düzeyi 21'de eklendi
float3 Native_tanh(float3 v);	API düzeyi 21'de eklendi
float4 Native_tanh(float4 v);	API düzeyi 21'de eklendi
half Native_tanh(half v);	API düzeyi 24'te eklendi
half2 Native_tanh(half2 v);	API düzeyi 24'te eklendi
half3 Native_tanh(half3 v);	API düzeyi 24'te eklendi
half4 Native_tanh(half4 v);	API düzeyi 24'te eklendi

Değerin yaklaşık hiperbolik tanjantını döndürür.

Ayrıca bkz. tanh().

native_tanpi : Sayının yaklaşık tanjantı ile pi sayısının çarpımı

kayan yerel_tanpi(float v);	API düzeyi 21'de eklendi
float2 Native_tanpi(float2 v);	API düzeyi 21'de eklendi
float3 Native_tanpi(float3 v);	API düzeyi 21'de eklendi
float4 Native_tanpi(float4 v);	API düzeyi 21'de eklendi
yarı yerel_tanpi(yarım v);	API düzeyi 24'te eklendi
half2 Native_tanpi(half2 v);	API düzeyi 24'te eklendi
half3 Native_tanpi(half3 v);	API düzeyi 24'te eklendi
half4 Native_tanpi(half4 v);	API düzeyi 24'te eklendi

(v * pi) değerinin yaklaşık tanjantını döndürür. Burada (v * pi), radyan cinsinden ölçülür.

Derece cinsinden ölçülen bir değerin tanjantını öğrenmek için tanpi(v / 180.f) işlevini çağırın.

Ayrıca tanpi() konusuna da bakın.

nextnext : Sonraki kayan nokta sayısı

float next(float v, kayan hedef);
float2 nextafter(float2 v, float2 target);
float3 nextafter(float3 v, float3 target);
float4 nextafter(float4 v, float4 target);
half nextafter(half v, half target);	API düzeyi 24'te eklendi
half2 nextafter(half2 v, half2 target);	API düzeyi 24'te eklendi
half3 nextafter(half3 v, half3 target);	API düzeyi 24'te eklendi
half4 nextnext(half4 - half4 hedef);	API düzeyi 24'te eklendi

v'den hedefe doğru bir sonraki temsil edilebilir kayan nokta sayısını döndürür.

rs_fp_relaxed modunda normal dışı bırakılmış bir giriş değeri, rahat modda normal dışı bırakılmış değerlerin desteklenmesi isteğe bağlı olduğundan bir sonraki denormalize edilmiş değeri vermeyebilir.

güç : Taban, üs seviyesine yükseldi

float(float(float) taban, float üs);
float2 pow(float2 base, float2 üs);
float3 pow(float3 base, float3 üs);
float4 pow(float4 base, float4 üs);
yarım pow(yarım taban, yarım üs);	API düzeyi 24'te eklendi
yarım2 pow(yarım2 taban, yarım2 üs);	API düzeyi 24'te eklendi
yarım3 pow(yarım3 taban, yarım3 üs);	API düzeyi 24'te eklendi
yarım4 pow(yarım4 taban, yarım4 üs);	API düzeyi 24'te eklendi

Kuvvet üsse (yani ^ tabanı üssü) yükseltilen tabanı döndürür.

pown() ve powr() işlevleri benzerdir. pown(), bir tam sayı üssü alır. powr(), tabanın negatif olmadığını varsayar.

pown : Taban, bir tam sayı üs değerine yükseltilmiştir

kayan pown(float (kayan taban), int üs);
float2 pown(float2 base, int2 üs);
float3 pown(float3 base, int3 üs);
float4 pown(float4 base, int4 üs);
yarım pown(yarım taban, int üs);	API düzeyi 24'te eklendi
half2 pown(half2 base, int2 üs);	API düzeyi 24'te eklendi
half3 pown(half3 base, int3 üs);	API düzeyi 24'te eklendi
half4 pown(half4 base, int4 üs);	API düzeyi 24'te eklendi

Kuvvet üsse (yani ^ tabanı üssü) yükseltilen tabanı döndürür.

pow() ve powr() benzerdir. Her ikisi de bir kayan üs alır. powr(), tabanın negatif olmadığını da varsayar.

powr : Üsse yükseltilen pozitif taban

yüzen powr(kayan taban, bolluk üs);
float2 powr(float2 base, float2 üs);
float3 powr(float3 base, float3 üs);
float4 powr(float4 base, float4 üs);
yarım güç(yarım taban, yarım üs);	API düzeyi 24'te eklendi
yarım2 güç(yarım2 taban, yarım2 üs);	API düzeyi 24'te eklendi
yarım3 güç(yarım3 taban, yarım3 üs);	API düzeyi 24'te eklendi
yarım4 powr(yarım4 taban, yarım4 üs);	API düzeyi 24'te eklendi

Kuvvet üsse (yani ^ tabanı üssü) yükseltilen tabanı döndürür. taban >= 0 olmalıdır.

pow() ve pown() benzerdir. İkisi de taban hakkında herhangi bir varsayımda bulunmaz. pow(), bir kayan üs alırken, pown() bir tam sayı alır.

Ayrıca bkz. native_powr().

radyan : Dereceleri radyana dönüştürür

kayan radyan(float v);
float2 radyan(float2 v);
float3 radyan(float3 v);
float4 radyan(float4 v);
yarım radyan(yarım v);	API düzeyi 24'te eklendi
yarım2 radyan(yarım2 v);	API düzeyi 24'te eklendi
yarım3 radyan(yarım3 v);	API düzeyi 24'te eklendi
yarım4 radyan(yarım4 v);	API düzeyi 24'te eklendi

Dereceden radyana dönüştürür.

remainder : Bir bölümün kalanları

kayan noktalı payda(kayan noktalı pay; kayan payda);
float2 kalan(float2 pay, float2 payda);
float3 kalan(float3 pay, float3 payda);
float4 kalan(float4 pay, float4 payda);
yarım kalan(yarım pay, yarım payda);	API düzeyi 24'te eklendi
yarım2 kalan(yarım2 pay, yarım2 payda);	API düzeyi 24'te eklendi
yarım3 kalan(yarım3 pay, yarım3 payda);	API düzeyi 24'te eklendi
yarım4 kalan(4. yarı pay, 4.4 payda);	API düzeyi 24'te eklendi

Kalan kısmını (pay / payda) döndürür. Bölme, en yakın tam sayıya yuvarlanır.

fmod() işlevi benzerdir ancak en yakın tam sayıya yuvarlanır. Örneğin, fmod(-3.8f, 2.f) değeri -1.8f (-3.8f - -1.f * 2.f) değerini, remainder(-3.8f, 2.f) değeri ise 0.2f (-3.8f - -2.f * 2.f) değerini döndürür.

remquo : Bir bölümden kalan ve bölme işlemi

float remquo(float pay, float payda, int* quotient);
float2 remquo(float2 pay, float2 payda, int2* bölme);
float3 remquo(float3 pay, float3 payda, int3* quotient);
float4 remquo(float4 pay, float4 payda, int4* quotient);
half remquo(yarım pay, yarım payda, int* bölme);	API düzeyi 24'te eklendi
half2 remquo(half2 pay, half2 payda, int2* quotient);	API düzeyi 24'te eklendi
half3 remquo(half3 pay, half3 payda, int3* quotient);	API düzeyi 24'te eklendi
half4 remquo(half4 pay, half4 payda, int4* quotient);	API düzeyi 24'te eklendi

Parametreler

pay	Pay.
payda	Payda.
bölüm	*parça, tam sayı bölümüne ayarlanacaktır.

İlerlemeler

Yalnızca düşük üç bit için kalan, hassastır.

Bölmeyi ve (pay / payda) değerinin kalanını döndürür.

Bölümün yalnızca işareti ve en düşük üç bitinin doğru olduğu garanti edilir.

Bu işlev, periyodik işlevlerin uygulanması için yararlıdır. Bölümün düşük olan üç biti, çeyreği ve kare içindeki kalan mesafeyi verir. Örneğin, sin(x)'in uygulanması, x'in çok büyük değerini sınırlı bir aralıktaki bir değere indirmek için remquo(x, PI / 2.f, &quadrant) işlevini çağırabilir.

Örnek: remquo(-23.5f, 8.f, &quot), tırnak işaretinin en düşük üç bitini 3 ve eksi işaretini ayarlar. 0.5f değerini döndürür.

rint : Eşit'e yuvarlar

kayan rint(float v);
float2 rint(float2 v);
float3 rint(float3 v);
float4 rint(float4 v);
yarım rint(half v);	API düzeyi 24'te eklendi
half2 rint(half2 v);	API düzeyi 24'te eklendi
half3 rint(half3 v);	API düzeyi 24'te eklendi
half4 rint(half4 v);	API düzeyi 24'te eklendi

En yakın integral değerine yuvarlar.

rint(), yarı değerleri çifte yuvarlar. Örneğin rint(0.5f), 0.f değerini ve rint(1.5f), 2.f değerini döndürür. Benzer şekilde rint(-0.5f), -0.f değerini ve rint(-1.5f), -2.f değerini döndürür.

round() işlevi benzerdir ancak sıfırdan uzağa yuvarlanır. trunc() ondalık kesri kısaltır.

rootn : N. kök

float rootn(float v, int n);
float2 rootn(float2 v, int2 n);
float3 rootn(float3 v, int3 n);
float4 rootn(float4 v, int4 n);
half rootn(half v, int n);	API düzeyi 24'te eklendi
half2 rootn(half2 v, int2 n);	API düzeyi 24'te eklendi
half3 rootn(half3 v, int3 n);	API düzeyi 24'te eklendi
half4 rootn(half4 v, int4 n);	API düzeyi 24'te eklendi

Değerin N. kökünü hesaplayın.

Ayrıca native_rootn() işlevini de inceleyin.

round : Sıfırdan uzağa yuvarlama

float(float v);
float2 round(float2 v);
float3 round(float3 v);
float4 round(float4 v);
yarım tur(yarım v);	API düzeyi 24'te eklendi
half2 round(half2 v);	API düzeyi 24'te eklendi
half3 round(half3 v);	API düzeyi 24'te eklendi
half4 round(half4 v);	API düzeyi 24'te eklendi

En yakın integral değerine yuvarlayın.

round(), yarım değerleri sıfırdan uzağa yuvarlar. Örneğin, round(0.5f) 1.f değerini, round(1.5f) ise 2.f değerini döndürür. Benzer şekilde, round(-0.5f) işlevi -1.f değerini, round(-1.5f) de -2.f değerini döndürür.

rint() benzerdir ancak yarım değerleri çifte yuvarlar. trunc() ondalık kesri kısaltır.

rsClamp : Bir değeri aralığa getirin

char rsClamp(karakter miktarı, karakter düşük, karakter yüksek);
int rsClamp(int amount, int low, int high);
kısa rsClamp(kısa miktar, kısa düşük, kısa yüksek);
uchar rsClamp(uchar tutarı, uchar low, uchar yüksek);
uint rsClamp(uint tutarı, uint düşük, uint yüksek);
ushort rsClamp(ushort tutarı, ushort düşük, ushort yüksek);

Parametreler

tutar	Sabitlenecek değer.
düşük	Alt sınır.
yüksek	Üst sınır.

Kullanımdan kaldırıldı. Bunun yerine clamp() işlevini kullanın.

Düşük ve yüksek arasında bir değer belirleyin.

rsFrac : Kayan öğenin kesirli kısmını döndürür

float rsFrac(float v);

Kullanımdan kaldırıldı. Bunun yerine fract() işlevini kullanın.

Kayan öğenin kesirli kısmını döndürür

rsRand : Sözde rastgele sayı

kayan noktalı rsRand(kayan maksimum_değer);
kayan nokta rsRand(kayan min_value, kayan maks_değer);
int rsRand(int max_value);
int rsRand(int min_value, int max_value);

0 (veya min_value) ile max_malue arasında rastgele bir değer döndürün.

rsqrt : Karekökün tersi

float rsqrt(float v);
float2 rsqrt(float2 v);
float3 rsqrt(float3 v);
float4 rsqrt(float4 v);
half rsqrt(half v);	API düzeyi 24'te eklendi
half2 rsqrt(half2 v);	API düzeyi 24'te eklendi
half3 rsqrt(half3 v);	API düzeyi 24'te eklendi
half4 rsqrt(half4 v);	API düzeyi 24'te eklendi

(1 / sqrt(v)) değerini döndürür.

Ayrıca bkz. half_rsqrt(), native_rsqrt().

sign : Bir değerin işareti

kayan işareti(kayan v);
float2 sign(float2 v);
float3 sign(float3 v);
float4 işareti(float4 v);
yarım işareti(yarım v);	API düzeyi 24'te eklendi
half2 işareti(half2 v);	API düzeyi 24'te eklendi
yarım3 işareti(half3 v);	API düzeyi 24'te eklendi
half4 işareti(yarım4 v);	API düzeyi 24'te eklendi

Bir değerin işaretini döndürür.

if (v < 0)return -1.f; else if (v > 0)return 1.f; else $0.f döndürülür;

sin : Sinüs

float sin(float v);
float2 sin(float2 v);
float3 sin(float3 v);
float4 sin(float4 v);
yarım sin(yarım v);	API düzeyi 24'te eklendi
half2 sin(half2 v);	API düzeyi 24'te eklendi
half3 sin(half3 v);	API düzeyi 24'te eklendi
half4 sin(half4 v);	API düzeyi 24'te eklendi

Açının sinüsünü radyan cinsinden döndürür.

Ayrıca bkz. native_sin().

sincos : Sinüs ve kosinüs

float sincos(float v, float* cos);
float2 sincos(float2 - float2* cos);
float3 sincos(float3 - float3* cos);
float4 sincos(float4 - float4* cos);
half sincos(half - half* cos);	API düzeyi 24'te eklendi
half2 sincos(half2 - half2* cos);	API düzeyi 24'te eklendi
half3 sincos(half3 - half3* cos);	API düzeyi 24'te eklendi
half4 sincos(half4 - half4* cos);	API düzeyi 24'te eklendi

Parametreler

v	Radyan cinsinden gelen değer.
cos	*cos, kosinüs değerine ayarlanır.

İlerlemeler

v.'nin sinüsü

Bir değerin sinüsü ve kosinüsünü döndürür.

Ayrıca bkz. native_sincos().

sinh : Hiperbolik sinüs

float sinh(float v);
float2 sinh(float2 v);
float3 sinh(float3 v);
float4 sinh(float4 v);
half sinh(half v);	API düzeyi 24'te eklendi
half2 sinh(half2 v);	API düzeyi 24'te eklendi
half3 sinh(half3 v);	API düzeyi 24'te eklendi
half4 sinh(half4 v);	API düzeyi 24'te eklendi

v'nin hiperbolik sinüsünü döndürür. Burada v, radyan cinsinden ölçülür.

Ayrıca bkz. native_sinh().

sinpi : Sayının sinüsü pi ile çarpılır

float sinpi(float v);
float2 sinpi(float2 v);
float3 sinpi(float3 v);
float4 sinpi(float4 v);
half sinpi(yarım v);	API düzeyi 24'te eklendi
half2 sinpi(half2 v);	API düzeyi 24'te eklendi
half3 sinpi(half3 v);	API düzeyi 24'te eklendi
half4 sinpi(half4 v);	API düzeyi 24'te eklendi

(v * pi) değeri radyan cinsinden ölçülür (v * pi) değerinin sinüsünü döndürür.

Derece cinsinden ölçülen bir değerin sinüsünü öğrenmek için sinpi(v / 180.f) çağrısı yapın.

Ayrıca bkz. native_sinpi().

sqrt : Karekök

kayan sqrt(float v);
float2 sqrt(float2 v);
float3 sqrt(float3 v);
float4 sqrt(float4 v);
yarım sqrt(yarım v);	API düzeyi 24'te eklendi
yarım2 sqrt(half2 v);	API düzeyi 24'te eklendi
yarım3 sqrt(half3 v);	API düzeyi 24'te eklendi
half4 sqrt(half4 v);	API düzeyi 24'te eklendi

Bir değerin karekökünü döndürür.

Ayrıca bkz. half_sqrt(), native_sqrt().

step : Değerden küçükse 0, aksi takdirde 1

kayan adım(kayan kenar, kayan v);
float2 adımı(kayan kenar, float2 v);	API düzeyi 21'de eklendi
float2 adımı(float2 kenar, kayan v);
float2 adımı(float2 kenar, float2 v);
float3 adımı(kayan kenar, float3 v);	API düzeyi 21'de eklendi
float3 adımı(float3 kenar, kayan v);
float3 adımı(float3 kenar, float3 v);
float4 adımı(kayan kenar, float4 v);	API düzeyi 21'de eklendi
float4 adımı(float4 kenar, kayan v);
float4 adımı(float4 kenar, float4 v);
yarım adım(yarım kenar, yarım v);	API düzeyi 24'te eklendi
half2 adım(yarım kenar, yarım2 v);	API düzeyi 24'te eklendi
half2 adım(yarım2 kenar, yarım v);	API düzeyi 24'te eklendi
half2 adım(yarım2 kenar, yarım2 v);	API düzeyi 24'te eklendi
half3 adım(yarım kenar, yarım3 v);	API düzeyi 24'te eklendi
half3 adım(yarım3 kenar, yarım v);	API düzeyi 24'te eklendi
half3 adım(yarım3 kenar, yarım3 v);	API düzeyi 24'te eklendi
half4 adım(yarım kenar, yarım4 v);	API düzeyi 24'te eklendi
half4 adım(yarım4 kenar, yarım v);	API düzeyi 24'te eklendi
half4 adım(yarım4 kenar, yarım4 v);	API düzeyi 24'te eklendi

v < Edge ise 0.f, aksi takdirde 1.f sonucunu döndürür.

Bu, döngüler ve kollara ayırma talimatları kullanmadan koşullu hesaplamalar oluşturmak için yararlı olabilir. Örneğin, bir vektörün karşılık gelen öğeleri için (a[i] < b[i]) ? 0.f : atan2(a[i], b[i]) hesaplamak yerine step(a, b) * atan2(a, b) kullanabilirsiniz.

tan : Tanjant

float tan(float v);
float2 tan(float2 v);
float3 tan(float3 v);
float4 tan(float4 v);
yarım tan(yarım v);	API düzeyi 24'te eklendi
half2 tan(half2 v);	API düzeyi 24'te eklendi
yarı 3 tan(yarı3 v);	API düzeyi 24'te eklendi
half4 tan(half4 v);	API düzeyi 24'te eklendi

Açının tanjantını radyan cinsinden döndürür.

Ayrıca bkz. native_tan().

tanh : Hiperbolik tanjant

float tanh(float v);
float2 tanh(float2 v);
float3 tanh(float3 v);
float4 tanh(float4 v);
half tanh(half v);	API düzeyi 24'te eklendi
half2 tanh(half2 v);	API düzeyi 24'te eklendi
half3 tanh(half3 v);	API düzeyi 24'te eklendi
half4 tanh(half4 v);	API düzeyi 24'te eklendi

Değerin hiperbolik tanjantını döndürür.

Ayrıca bkz. native_tanh().

tanpi : Sayının pi ile çarpımının tanjantı

float tanpi(float v);
float2 tanpi(float2 v);
float3 tanpi(float3 v);
float4 tanpi(float4 v);
half tanpi(yarım v);	API düzeyi 24'te eklendi
half2 tanpi(half2 v);	API düzeyi 24'te eklendi
half3 tanpi(half3 v);	API düzeyi 24'te eklendi
half4 tanpi(half4 v);	API düzeyi 24'te eklendi

(v * pi) değerinin tanjantını döndürür. Burada (v * pi), radyan cinsinden ölçülür.

Derece cinsinden ölçülen bir değerin tanjantını öğrenmek için tanpi(v / 180.f) işlevini çağırın.

Ayrıca bkz. native_tanpi().

tgamma : Gama işlevi

kayan tgamma(kayan v);
float2 tgamma(float2 v);
float3 tgamma(float3 v);
float4 tgamma(float4 v);
yarım tgamma(yarım v);	API düzeyi 24'te eklendi
half2 tgamma(half2 v);	API düzeyi 24'te eklendi
half3 tgamma(half3 v);	API düzeyi 24'te eklendi
half4 tgamma(half4 v);	API düzeyi 24'te eklendi

Bir değerin gama işlevini döndürür.

Ayrıca bkz. lgamma().

trunc : Kayan noktayı kısaltır

float trunc(float v);
float2 trunc(float2 v);
float3 trunc(float3 v);
float4 trunc(float4 v);
half trunc(half v);	API düzeyi 24'te eklendi
half2 trunc(half2 v);	API düzeyi 24'te eklendi
half3 trunc(half3 v);	API düzeyi 24'te eklendi
half4 trunc(half4 v);	API düzeyi 24'te eklendi

Kesilme kullanarak integrale yuvarlar.

Örneğin, trunc(1.7f) işlevi 1.f değerini, trunc(-1.7f) değeri ise -1.f değerini döndürür.

Diğer yuvarlama seçenekleri için rint() ve round() özelliklerine bakın.