Ta strona została przetłumaczona przez Cloud Translation API.

Stałe i funkcje matematyczne RenderScript

Przegląd

Poniższe funkcje matematyczne można stosować do skalarów i wektorów. Gdy zwracana wartość jest stosowana do wektorów, jest wektorem funkcji stosowanej do każdego wpisu danych wejściowych.

Przykład: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);

W sekcji Funkcje matematyczne wektorowe znajdziesz funkcje takie jak distance() i length(), które interpretują dane wejściowe jako pojedynczy wektor w przestrzeni n-wymiarowej.

Na dokładność działań matematycznych na 32-bitowych liczbach zmiennoprzecinkowych wpływają wartości pragmas rs_fp_relaxed i rs_fp_full. W parametrze rs_fp_relaxed wartości nienormalne mogą być opróżniane do zera i można je zaokrąglać do zera. Dla porównania parametr rs_fp_full wymaga prawidłowej obsługi wartości podrzędnych, tj. mniejszych niż 1.17549435e-38f. Parametr rs_fp_rull wymaga też zaokrąglania do najbliższej z parzystymi wartościami.

Za pomocą wariantów typowych funkcji matematycznych można osiągnąć różne zmiany w zakresie precyzji i szybkości. Funkcje, których nazwy zaczynają się od

natywne_: mogą mieć niestandardowe implementacje sprzętowe o niższej dokładności. Dodatkowo wartości nienormalne mogą być opróżniane do zera, można zaokrąglać do zera, a dane wejściowe NaN i nieskończoności mogą nie być prawidłowo obsługiwane.
połowy_: umożliwia wykonywanie wewnętrznych obliczeń przy użyciu 16-bitowych liczb zmiennoprzecinkowych. Dodatkowo wartości podrzędne mogą być opróżniane do zera i można je zaokrąglać do zera.

Podsumowanie

Stałe
M_1_PI	1 / pi w postaci 32-bitowej liczby zmiennoprzecinkowej.
M_2_PI	2 / pi w postaci 32-bitowej liczby zmiennoprzecinkowej.
M_2_PIERW.PI	2 / sqrt(pi) w postaci 32-bitowej liczby zmiennoprzecinkowej.
M_E	e, w postaci 32-bitowej liczby zmiennoprzecinkowej.
M_LN10	log_e(10), w postaci 32-bitowej liczby zmiennoprzecinkowej.
M_LN2	log_e(2), w postaci 32-bitowej liczby zmiennoprzecinkowej.
M_LOG10E	log_10(e), jako 32-bitowa liczba zmiennoprzecinkowa
M_LOG2E	log_2(e), jako 32-bitowa liczba zmiennoprzecinkowa,
M_PI	pi w postaci 32-bitowej liczby zmiennoprzecinkowej.
M_PI_2	pi / 2 w postaci 32-bitowej liczby zmiennoprzecinkowej.
M_PI_4	pi / 4 w postaci 32-bitowej liczby zmiennoprzecinkowej.
M_PIERWIASTEK1_2	1 / sqrt(2), w postaci 32-bitowej liczby zmiennoprzecinkowej.
PIERWIASTEK_M_PIERWIASTEK	sqrt(2), w postaci 32-bitowej liczby zmiennoprzecinkowej.

Funkcje
absolut	Wartość bezwzględna liczby całkowitej
akos	Odwrotny cosinus
acosh	Odwrotny cosinus hiperboliczny
acospi	Odwrotny cosinus podzielony przez pi
asin	Odwrotny sinus
asinh	Odwrotny sinus hiperboliczny
asinpi	Odwrotny sinus podzielony przez pi
atan	Odwrotny tangens
atan2	Odwrotny tangens współczynnika
atan2pi	Odwrotny tangens współczynnika podzielony przez pi
atanh	Odwrotny tangens hiperboliczny
Atanpi	Odwrotny tangens podzielony przez pi
cbrt	Pierwiastek sześcienny
ceil	Najmniejsza liczba całkowita, nie mniejsza od wartości
ograniczyć	Ogranicz wartość do zakresu
clz	Liczba pierwszych 0 bitów
copysign.	Kopiuje znak liczby do innej
Cos	Cosinus
cosh	Cosinus hiperboliczny
Cospi	Cosinus liczby pomnożonej przez pi
stopnie	Przekształca radiany na stopnie
erf	Funkcja błędu matematycznego
erfc	Uzupełniająca funkcja matematyczna błędu
exp	e podniesiona do liczby
exp10	10 podniesiona do liczby
wyr2	2 podniesiona do liczby
expm1	e podniesiona do liczby minus jeden
pracowników	Wartość bezwzględna liczby zmiennoprzecinkowej
FDim	Różnica dodatnia między 2 wartościami
piętro	Najmniejsza liczba całkowita nie większa od wartości
FMA	Pomnóż i dodaj
FMax	Maksymalnie dwie liczby zmiennoprzecinkowe
min	Co najmniej dwie liczby zmiennoprzecinkowe
Fmod	Modulo
frakt	Dodatnia część ułamkowa
frexp,	Binarna mantysa i wykładnik
pół_recip	Wartość odwrotna obliczona z dokładnością do 16 bitów
half_rsqrt	Odwrotność pierwiastka kwadratowego obliczony z dokładnością 16-bitową
half_sqrt	Pierwiastek kwadratowy obliczony z 16-bitową precyzją
hipot	przeciwprostokątna
ilogb	Podstawa dwóch wykładników
lekcja ldexp	Tworzy punkt zmiennoprzecinkowy na podstawie mantysy i wykładnika
Lgamma	Logarytm naturalny funkcji gamma
dziennik	Logarytm naturalny
log10	Logarytm dziesiętny
log1p	Logarytm naturalny wartości plus 1
log2	Logarytm dziesiętny
logb	Podstawa dwóch wykładników
szalony	Pomnóż i dodaj
maks.	Wartość maksymalna
min	Wartość minimalna
mieszanka	Łączy 2 wartości
modf (modf)	Składniki całkowite i ułamkowe
nan	To nie jest liczba
nan_połowa	To nie jest liczba
natywne_acos	Przybliżony odwrotny cosinus
native_acosh	Przybliżony odwrotny odwrotny cosinus hiperboliczny
native_acospi	Przybliżony odwrotny cosinus podzielony przez pi
native_asin	Przybliżony odwrotny sinus
native_asinh	Przybliżony odwrotny odwrotny sinus hiperboliczny
natywny_asinpi	Przybliżony odwrotny sinus podzielony przez pi
native_atan	Przybliżony odwrotny tangens
natywny_atan2	Przybliżony odwrotny tangens współczynnika
native_atan2pi	Przybliżony odwrotny tangens współczynnika podzielony przez pi
native_atanh	Przybliżony odwrotny tangens hiperboliczny
natywny_atanpi	Przybliżony odwrotny tangens podzielony przez pi
natywny_cbrt	Przybliżony pierwiastek sześcienny
native_cos	Przybliżony cosinus
natywna_cosh	Przybliżony cosinus hipeboliczny
native_cospi	Przybliżony cosinus liczby pomnożonej przez pi
natywna_divide	Podział przybliżony
native_exp	Przybliżona liczba e podniesiona do określonej liczby
native_exp10	Podniesiona do określonej liczby około 10
natywna_wyrażenia2	Podniesiono ok. 2 do określonej liczby
native_expm1	Przybliżona liczba e podniesiona do liczby minus jeden
native_hypot	Przybliżona przeciwprostokątna
native_log	Przybliżony logarytm naturalny
native_log10	Logarytm dziesiętny w przybliżeniu
native_log1p	Przybliżony logarytm naturalny wartości plus 1
native_log2	Przybliżony logarytm dziesiętny
natywna_powr,	Przybliżona podstawa dodatnia podniesiona do wykładnika
natywny_recip	Przybliżona liczba odwrotna
native_rootn	Przybliżony n-ty pierwiastek
native_rsqrt	Przybliżony odwrotność pierwiastka kwadratowego
natywny_sin	Przybliżony sinus
native_sincos	Przybliżony sinus i cosinus
native_sinh	Przybliżony sinus hiperboliczny
natywny_sinpi	Przybliżony sinus liczby pomnożonej przez pi
native_sqrt	Przybliżony pierwiastek kwadratowy
natywny_jasnobrązowy	Przybliżona tangens
natywny_tanh	Przybliżony tangens hiperboliczny
natywna_tanpi	Przybliżony tangens liczby pomnożonej przez pi
nextafter	Następna liczba zmiennoprzecinkowa
pow	Podstawa podniesiona do wykładnika
pown	Podstawa podniesiona do wykładnika całkowitej
powr,	Dodatnia podstawa podniesiona do wykładnika
radiany	Konwertuje stopnie na radiany
reszta	Pozostała część oddziału
remquo	Reszta i iloraz dzielenia
Rint	Zaokrąglaj do parzystych
rootn	Pierwiastek stopnia n
round	Zaokrąglaj od zera
rsRand,	Pseudolosowa liczba
rsqrt	Odwrotność pierwiastka kwadratowego
podpisz	Znak wartości
sin	Sinus
Sincos	Sinus i cosinus
Sinh	Sinus hiperboliczny
Sinpi	Sinus liczby pomnożonej przez pi
sqrt	Pierwiastek kwadratowy
krok	Wartość 0, jeśli jest mniejsza niż wartość, 1 w przeciwnym razie
jasnobrązowy	Tangens
tanh	Tangens hiperboliczny
tanpi,	Tangens liczby pomnożonej przez pi
tgamma	Funkcja gamma
obcinanie	Przycina liczbę zmiennoprzecinkową

Funkcje wycofane
rsClamp,	Wycofano. Ogranicz wartość do zakresu
rsFrac	Wycofano. Zwraca część ułamkową liczby zmiennoprzecinkowej

Stałe

M_1_PI: 1 / pi w postaci 32-bitowej liczby zmiennoprzecinkowej.

Wartość: 0.318309886183790671537767526745028724f

Odwrotność liczby pi w postaci 32-bitowej liczby zmiennoprzecinkowej.

M_2_PI : 2 / pi w postaci 32-bitowej liczby zmiennoprzecinkowej

Wartość: 0.636619772367581343075535053490057448f

2 podzielone przez pi, w postaci 32-bitowej liczby zmiennoprzecinkowej.

M_2_SQRTPI : 2 / sqrt(pi), jako 32-bitowa liczba zmiennoprzecinkowa

Wartość: 1.128379167095512573896158903121545172f

2 podzielone przez pierwiastek kwadratowy z pi, w postaci 32-bitowej liczby zmiennoprzecinkowej.

M_E : e, jako 32-bitowa liczba zmiennoprzecinkowa

Wartość: 2.718281828459045235360287471352662498f

Liczba e, podstawa logarytmu naturalnego, w postaci 32-bitowej liczby zmiennoprzecinkowej.

M_LN10 : log_e(10), jako 32-bitowa liczba zmiennoprzecinkowa

Wartość: 2.302585092994045684017991454684364208f

Logarytm naturalny 10 w postaci 32-bitowej liczby zmiennoprzecinkowej.

M_LN2 : log_e(2), w postaci 32-bitowej liczby zmiennoprzecinkowej

Wartość: 0.693147180559945309417232121458176568f

Logarytm naturalny 2 w postaci 32-bitowej liczby zmiennoprzecinkowej.

M_LOG10E : log_10(e), jako 32-bitowa liczba zmiennoprzecinkowa

Wartość: 0.434294481903251827651128918916605082f

Logarytm dziesiętny o podstawie e w postaci 32-bitowej liczby zmiennoprzecinkowej.

M_LOG2E : log_2(e), jako 32-bitowa liczba zmiennoprzecinkowa

Wartość: 1.442695040888963407359924681001892137f

Logarytm dziesiętny o podstawie e w postaci 32-bitowej liczby zmiennoprzecinkowej.

M_PI : pi, w postaci 32-bitowej liczby zmiennoprzecinkowej.

Wartość: 3.141592653589793238462643383279502884f

Stała liczba pi w postaci 32-bitowej liczby zmiennoprzecinkowej.

M_PI_2 : pi / 2, w postaci 32-bitowej liczby zmiennoprzecinkowej.

Wartość: 1.570796326794896619231321691639751442f

Liczba pi podzielona przez 2, w postaci 32-bitowej liczby zmiennoprzecinkowej.

M_PI_4: pi / 4, w postaci 32-bitowej liczby zmiennoprzecinkowej.

Wartość: 0.785398163397448309615660845819875721f

Liczba pi podzielona przez 4, w postaci 32-bitowej liczby zmiennoprzecinkowej.

M_SQRT1_2 : 1 / sqrt(2), jako 32-bitowa liczba zmiennoprzecinkowa

Wartość: 0.707106781186547524400844362104849039f

Odwrotność pierwiastka kwadratowego z 2 w postaci 32-bitowej liczby zmiennoprzecinkowej.

M_SQRT2 : sqrt(2), w postaci 32-bitowej liczby zmiennoprzecinkowej

Wartość: 1.414213562373095048801688724209698079f

Pierwiastek kwadratowy z 2 w postaci 32-bitowej liczby zmiennoprzecinkowej.

Funkcje

abs : wartość bezwzględna liczby całkowitej

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

Zwraca wartość bezwzględną liczby całkowitej.

W przypadku liczb zmiennoprzecinkowych użyj funkcji fabs().

acos : odwrotny cosinus

float acos(float v);
float2 acos(float2 v);
float3 acos(float3 v);
float4 acos(float4 v);
half acos(half v);	Dodano do poziomu interfejsu API 24.
half2 acos(half2 v);	Dodano do poziomu interfejsu API 24.
half3 acos(half3 v);	Dodano do poziomu interfejsu API 24.
half4 acos(half4 v);	Dodano do poziomu interfejsu API 24.

Zwraca odwrotny cosinus w radianach.

Patrz też native_acos().

acosh : odwrotny cosinus hiperboliczny

float acosh(float v);
float2 acosh(float2 v);
float3 acosh(float3 v);
float4 acosh(float4 v);
half acosh(half v);	Dodano do poziomu interfejsu API 24.
half2 acosh(half2 v);	Dodano do poziomu interfejsu API 24.
half3 acosh(half3 v);	Dodano do poziomu interfejsu API 24.
half4 acosh(half4 v);	Dodano do poziomu interfejsu API 24.

Zwraca odwrotny cosinus hiperboliczny w radianach.

Patrz też native_acosh().

acospi : odwrotny cosinus podzielony przez pi

float acospi(float v);
float2 acospi(float2 v);
float3 acospi(float3 v);
float4 acospi(float4 v);
half acospi(half v);	Dodano do poziomu interfejsu API 24.
half2 acospi(half2 v);	Dodano do poziomu interfejsu API 24.
half3 acospi(half3 v);	Dodano do poziomu interfejsu API 24.
half4 acospi(pół4 v);	Dodano do poziomu interfejsu API 24.

Zwraca odwrotny cosinus w radianach podzielony przez pi.

Aby uzyskać odwrotny cosinus mierzony w stopniach, użyj funkcji acospi(a) * 180.f.

Patrz też native_acospi().

asin : odwrotny sinus

float asin(float v);
float2 asin(float2 v);
float3 asin(float3 v);
float4 asin(float4 v);
half asin(half v);	Dodano do poziomu interfejsu API 24.
half2 asin(half2 v);	Dodano do poziomu interfejsu API 24.
half3 asin(half3 v);	Dodano do poziomu interfejsu API 24.
half4 asin(pół4 v);	Dodano do poziomu interfejsu API 24.

Zwraca odwrotny sinus w radianach.

Zobacz też native_asin().

asinh : odwrotny sinus hiperboliczny

float asinh(float v);
float2 asinh(float2 v);
float3 asinh(float3 v);
float4 asinh(float4 v);
half asinh(połowa v);	Dodano do poziomu interfejsu API 24.
half2 asinh(pół2 v);	Dodano do poziomu interfejsu API 24.
half3 asinh(pół3 v);	Dodano do poziomu interfejsu API 24.
half4 asinh(połowa 4 v);	Dodano do poziomu interfejsu API 24.

Zwraca odwrotny sinus hiperboliczny w radianach.

Zobacz też native_asinh().

asinpi : odwrotny sinus podzielony przez pi

float asinpi(float v);
float2 asinpi(float2 v);
float3 asinpi(float3 v);
float4 asinpi(float4 v);
half asinpi(połowa v);	Dodano do poziomu interfejsu API 24.
half2 asinpi(połowa 2 v);	Dodano do poziomu interfejsu API 24.
half3 asinpi(pół3 v);	Dodano do poziomu interfejsu API 24.
pół4 asinpi(połowa 4 v);	Dodano do poziomu interfejsu API 24.

Zwraca odwrotny sinus w radianach podzielony przez pi.

Aby uzyskać odwrotny sinus mierzony w stopniach, użyj funkcji asinpi(a) * 180.f.

Zobacz też native_asinpi().

atan : odwrotny tangens

float atan(float v);
float2 atan(float2 v);
float3 atan(float3 v);
float4 atan(float4 v);
half atan(połowa v);	Dodano do poziomu interfejsu API 24.
half2 atan(pół2 v);	Dodano do poziomu interfejsu API 24.
half3 atan(pół3 v);	Dodano do poziomu interfejsu API 24.
half4 atan(połowa 4 v);	Dodano do poziomu interfejsu API 24.

Zwraca odwrotny tangens w radianach.

Patrz też native_atan().

atan2 : odwrotny tangens współczynnika

float atan2(licznik zmiennoprzecinkowy, mianownik zmiennoprzecinkowy);
float2 atan2(licznik zmiennoprzecinkowy2, mianownik zmiennoprzecinkowy2);
float3 atan2(licznik zmiennoprzecinkowy3, mianownik float3);
float4 atan2(licznik zmiennoprzecinkowy4, mianownik zmiennoprzecinkowy4);
połowa atan2(połowa licznika, połowa mianownika);	Dodano do poziomu interfejsu API 24.
half2 atan2(licznik połowu2; mianownik pół2);	Dodano do poziomu interfejsu API 24.
half3 atan2(licznik pół3; mianownik pół3);	Dodano do poziomu interfejsu API 24.
połowa 4 atan2(licznik połoowy 4, mianownik pół4);	Dodano do poziomu interfejsu API 24.

Parametry

licznik	Licznik.
mianownik	Mianownik. Wartość może wynosić 0.

Zwraca odwrotny tangens funkcji (numerator / denominator) w radianach.

Patrz też native_atan2().

atan2pi : odwrotny tangens współczynnika podzielony przez pi

float atan2pi(licznik zmiennoprzecinkowy, mianownik zmiennoprzecinkowy);
float2 atan2pi(licznik zmiennoprzecinkowy2, mianownik zmiennoprzecinkowy2);
float3 atan2pi(licznik float3, mianownik float3);
float4 atan2pi(licznik zmiennoprzecinkowy4, mianownik zmiennoprzecinkowy4);
half atan2pi(połowa licznika, połowa mianownika);	Dodano do poziomu interfejsu API 24.
połowa2 atan2pi(licznik połowa 2, mianownik połowa 2);	Dodano do poziomu interfejsu API 24.
half3 atan2pi(licznik pół3; mianownik pół3);	Dodano do poziomu interfejsu API 24.
połowa 4 atan2pi(licznik połowu 4, mianownik połowa 4);	Dodano do poziomu interfejsu API 24.

Parametry

licznik	Licznik.
mianownik	Mianownik. Wartość może wynosić 0.

Zwraca odwrotny tangens funkcji (numerator / denominator) w radianach podzielony przez pi.

Aby uzyskać odwrotny tangens mierzony w stopniach, użyj funkcji atan2pi(n, d) * 180.f.

Zobacz też native_atan2pi().

atanh : odwrotny tangens hiperboliczny

float atanh(float v);
float2 atanh(float2 v);
float3 atanh(float3 v);
float4 atanh(float4 v);
half atanh(połowa v);	Dodano do poziomu interfejsu API 24.
half2 atanh(pół2 v);	Dodano do poziomu interfejsu API 24.
half3 atanh(pół3 v);	Dodano do poziomu interfejsu API 24.
half4 atanh(połowa 4 v);	Dodano do poziomu interfejsu API 24.

Zwraca odwrotny tangens hiperboliczny w radianach.

Zobacz też native_atanh().

atanpi : odwrotny tangens podzielony przez pi

float atanpi(float v);
float2 atanpi(float2 v);
float3 atanpi(float3 v);
float4 atanpi(float4 v);
half atanpi(połowa v);	Dodano do poziomu interfejsu API 24.
half2 atanpi(połowa 2 v);	Dodano do poziomu interfejsu API 24.
pół3 atanpi(połowa 3 v);	Dodano do poziomu interfejsu API 24.
połowa 4 atanpi(połowa 4 v);	Dodano do poziomu interfejsu API 24.

Zwraca odwrotny tangens w radianach podzielony przez pi.

Aby uzyskać odwrotny tangens mierzony w stopniach, użyj funkcji atanpi(a) * 180.f.

Zobacz też native_atanpi().

cbrt : pierwiastek sześcienny

float cbrt(float v);
float2 cbrt(float2 v);
float3 cbrt(float3 v);
float4 cbrt(float4 v);
half cbrt(połowa v);	Dodano do poziomu interfejsu API 24.
half2 cbrt(połowa 2 v);	Dodano do poziomu interfejsu API 24.
half3 cbrt(pół3 v);	Dodano do poziomu interfejsu API 24.
half4 cbrt(połowa 4 v);	Dodano do poziomu interfejsu API 24.

Zwraca pierwiastek sześcienny.

Patrz też native_cbrt().

ceil : najmniejsza liczba całkowita, nie mniejsza od wartości

float ceil(float v);
float2 ceil(float2 v);
float3 ceil(float3 v);
float4 ceil(float4 v);
half ceil(pół v);	Dodano do poziomu interfejsu API 24.
half2 ceil(half2 v);	Dodano do poziomu interfejsu API 24.
half3 ceil(pół3 v);	Dodano do poziomu interfejsu API 24.
half4 ceil(pół4 v);	Dodano do poziomu interfejsu API 24.

Zwraca najmniejszą liczbę całkowitą, która nie jest mniejsza niż wartość.

Na przykład ceil(1.2f) zwraca 2.f, a ceil(-1.2f) zwraca -1.f.

Zobacz też floor().

clamp : ogranicza wartość do zakresu

char clamp(wartość znaku, minimalna_wartość_znaków, maksymalna_wartość_znaków);	Dodano do poziomu interfejsu API 19
char2 clamp(wartość char2, minimalna wartość znaku, maksymalna_wartość znaku);	Dodano do poziomu interfejsu API 19
char2 clamp(value char2, char2 min_value, char2 max_value);	Dodano do poziomu interfejsu API 19
char3 clamp(value char3, min_value, char max_value);	Dodano do poziomu interfejsu API 19
char3 clamp(value char3; minimalna wartość char3, char3 max_value);	Dodano do poziomu interfejsu API 19
char4 clamp(value char4, min_value, char max_value);	Dodano do poziomu interfejsu API 19
char4 clamp(value char4 value, char4 min_value, char4 max_value);	Dodano do poziomu interfejsu API 19
float clamp(wartość zmiennoprzecinkowa, minimalna wartość_zmiennoprzecinkowa, maksymalna_wartość_zmiennoprzecinkowa);
float2 clamp(wartość float2, minimalna_wartość_zmiennoprzecinkowa, maksymalna_wartość_zmiennoprzecinkowa);
float2 clamp(wartość float2, float2 min_value, float2 max_value);
float3 clamp(wartość float3, minimalna_wartość_zmiennoprzecinkowa, maksymalna_wartość_zmiennoprzecinkowa);
float3 clamp(wartość float3, float3 min_value, float3 max_value);
float4 clamp(wartość float4, minimalna_wartość_zmiennoprzecinkowa, maksymalna_wartość_zmiennoprzecinkowa);
float4 clamp(wartość float4, float4 min_value, float4 max_value);
half clamp(wartość połowa; wartość_minimalna połowa; połowa wartości maksymalnej);	Dodano do poziomu interfejsu API 24.
half2 clamp(wartość połowa2, wartość_minimalna połowa, wartość_minimalna połowa);	Dodano do poziomu interfejsu API 24.
half2 clamp(wartość połowa2, wartość_minimalna pół2; wartość_minimalna połowa_2);	Dodano do poziomu interfejsu API 24.
half3 clamp(wartość połowa3, wartość minimalna połowa, wartość_minimalna połowa);	Dodano do poziomu interfejsu API 24.
half3 clamp(wartość połowa3, wartość_minimalna pół3; wartość_minimalna połowa_3);	Dodano do poziomu interfejsu API 24.
half4 clamp(wartość połowa 4, wartość_minimalna połowa, wartość_minimalna połowa);	Dodano do poziomu interfejsu API 24.
half4 clamp(wartość połowa 4, wartość_minimalna pół4; wartość_minimalna połowa_4);	Dodano do poziomu interfejsu API 24.
int clamp(wartość int; minimalna_wartość int; wartość_maksymalna);	Dodano do poziomu interfejsu API 19
int2 clamp(wartość int2, min_value, int max_value);	Dodano do poziomu interfejsu API 19
int2 clamp(wartość int2, min_value int2, max_value int2);	Dodano do poziomu interfejsu API 19
int3 clamp(wartość int3, min_value, int max_value);	Dodano do poziomu interfejsu API 19
int3 clamp(wartość int3; minimalna wartość int3, int3 max_value);	Dodano do poziomu interfejsu API 19
int4 clamp(wartość int4, min_value, int max_value);	Dodano do poziomu interfejsu API 19
int4 clamp(wartość int4, min_value int4, max_value int4);	Dodano do poziomu interfejsu API 19
long clamp(long max_value, długa_wartość_minimalna, długa_wartość_maksymalna);	Dodano do poziomu interfejsu API 19
long2 clamp(wartość long2; długa wartość minimalna, długa maksymalna_wartość);	Dodano do poziomu interfejsu API 19
long2 clamp(wartość long2, long2 min_value, long2 max_value);	Dodano do poziomu interfejsu API 19
long3 clamp(value long3, long min_value, long max_value);	Dodano do poziomu interfejsu API 19
long3 clamp(wartość long3, long3 min_value, long3 max_value);	Dodano do poziomu interfejsu API 19
long4 clamp(value long4, long min_value, long max_value);	Dodano do poziomu interfejsu API 19
long4 clamp(wartość long4, long4 min_value, long4 max_value);	Dodano do poziomu interfejsu API 19
Short clamp(krótka wartość, krótka wartość_minimalna, krótka wartość_maksymalna);	Dodano do poziomu interfejsu API 19
short2 clamp(wartość short2, krótka wartość minimalna, krótka wartość maksymalna);	Dodano do poziomu interfejsu API 19
short2 clamp(wartość short2, wartość minimalna krótka2, krótka2 wartość maksymalna);	Dodano do poziomu interfejsu API 19
short3 clamp(wartość short3, krótka wartość minimalna, krótka wartość maksymalna);	Dodano do poziomu interfejsu API 19
short3 clamp(value short3, short3 min_value, short3 max_value);	Dodano do poziomu interfejsu API 19
short4 clamp(wartość short4, krótka wartość minimalna, krótka wartość maksymalna);	Dodano do poziomu interfejsu API 19
short4 clamp(wartość short4, short4 min_value, short4 max_value);	Dodano do poziomu interfejsu API 19
uchar clamp(wartość uchar, minimalna_wartość uchar, uchar max_value);	Dodano do poziomu interfejsu API 19
uchar2 clamp(wartość uchar2, wartość minimalna uchar, uchar max_value);	Dodano do poziomu interfejsu API 19
uchar2 clamp(wartość uchar2, uchar2 min_value, uchar2 max_value);	Dodano do poziomu interfejsu API 19
uchar3 clamp(wartość uchar3, uchar min_value, uchar max_value);	Dodano do poziomu interfejsu API 19
uchar3 clamp(wartość uchar3, uchar3 min_value, uchar3 max_value);	Dodano do poziomu interfejsu API 19
uchar4 clamp(wartość uchar4, wartość minimalna uchar, uchar max_value);	Dodano do poziomu interfejsu API 19
uchar4 clamp(wartość uchar4, uchar4 min_value, uchar4 max_value);	Dodano do poziomu interfejsu API 19
uint clamp(wartość uint, uint min_value, uint max_value);	Dodano do poziomu interfejsu API 19
uint2 clamp(wartość uint2, uint min_value, uint max_value);	Dodano do poziomu interfejsu API 19
uint2 clamp(wartość uint2, uint2 min_value, uint2 max_value);	Dodano do poziomu interfejsu API 19
uint3 clamp(wartość uint3, uint min_value, uint max_value);	Dodano do poziomu interfejsu API 19
uint3 clamp(wartość uint3, uint3 min_value, uint3 max_value);	Dodano do poziomu interfejsu API 19
uint4 clamp(wartość uint4, uint min_value, uint max_value);	Dodano do poziomu interfejsu API 19
uint4 clamp(wartość uint4, uint4 min_value, uint4 max_value);	Dodano do poziomu interfejsu API 19
ulong clamp(wartość ulong; minimalna wartość ulong; ulong max_value);	Dodano do poziomu interfejsu API 19
ulong2 clamp(wartość ulong2, ulong min_value, ulong max_value);	Dodano do poziomu interfejsu API 19
ulong2 clamp(wartość ulong2, ulong2 min_value, ulong2 max_value);	Dodano do poziomu interfejsu API 19
ulong3 clamp(wartość ulong3, ulong min_value, ulong max_value);	Dodano do poziomu interfejsu API 19
ulong3 clamp(wartość ulong3, ulong3 min_value, ulong3 max_value);	Dodano do poziomu interfejsu API 19
ulong4 clamp(wartość ulong4, ulong min_value, ulong max_value);	Dodano do poziomu interfejsu API 19
ulong4 clamp(wartość ulong4, ulong4 min_value, ulong4 max_value);	Dodano do poziomu interfejsu API 19
ushort clamp(wartość ushort, minimalna wartość ushort, ushort max_value);	Dodano do poziomu interfejsu API 19
ushort2 clamp(wartość ushort2, ushort min_value, ushort max_value);	Dodano do poziomu interfejsu API 19
ushort2 clamp(value ushort2, ushort2 min_value, ushort2 max_value);	Dodano do poziomu interfejsu API 19
ushort3 clamp(wartość ushort3, ushort min_value, ushort max_value);	Dodano do poziomu interfejsu API 19
ushort3 clamp(value ushort3, ushort3 min_value, ushort3 max_value);	Dodano do poziomu interfejsu API 19
ushort4 clamp(wartość ushort4, ushort min_value, ushort max_value);	Dodano do poziomu interfejsu API 19
ushort4 clamp(wartość ushort4, ushort4 min_value, ushort4 max_value);	Dodano do poziomu interfejsu API 19

Parametry

wartość	Wartość do ograniczenia.
wartość_minimalna	Dolna granica, skalarny lub pasujący wektor.
wartość_maksymalna	Górna granica – musi pasować do typu niskiego.

Utrzymuje wartość do określonej górnej i dolnej granicy. clamp() zwraca wartość min_value, jeśli wartość jest <min_value, max_value, jeśli wartość jest > max_value. W przeciwnym razie zwraca wartość.

Istnieją 2 warianty zakresu: jedna wartość minimalna i maksymalna to skalary stosowane do wszystkich pozycji wartości, a druga, w której wartość minimalna i maksymalna są również wektorami.

Jeśli wartość minimalna jest większa niż wartość maksymalna, wyniki są nieokreślone.

clz : liczba zerowych bitów na początku

char clz(wartość znaku);
char2 clz(wartość char2);
char3 clz(wartość char3);
char4 clz(wartość char4);
int clz(wartość int);
int2 clz(wartość int2);
int3 clz(wartość int3);
int4 clz(wartość int4);
short clz(short value);
short2 clz(wartość short2);
short3 clz(wartość short3);
short4 clz(wartość short4);
uchar clz(wartość uchar);
uchar2 clz(wartość uchar2);
uchar3 clz(wartość uchar3);
uchar4 clz(wartość uchar4);
uint clz(wartość uint);
uint2 clz(wartość uint2);
uint3 clz(wartość uint3);
uint4 clz(wartość uint4);
ushort clz(wartość ushort);
ushort2 clz(wartość ushort2);
ushort3 clz(wartość ushort3);
ushort4 clz(wartość ushort4);

Zwraca liczbę początkowych części 0 bitów wartości.

Na przykład clz((char)0x03) zwraca 6.

copysign : kopiuje znak liczby na inny

float copysign(wartość_zmiennoprzecinkowa, wartość_zmiennoprzecinkowa_zmiennoprzecinkowa);
float2 copysign(float2 magnitude_value, float2 wartość_znaku);
float3 copysign(float3 magnitude_value, float3 wartość_znaku);
float4 copysign(float4 magnitude_value, float4 wartość_znaku);
połowa copysign(połowa magnitude_value, połowa wartości_znaku);	Dodano do poziomu interfejsu API 24.
pół2 copysign(half2 magnitude_value, połowa_2 wartość_znaku);	Dodano do poziomu interfejsu API 24.
pół3 copysign(half3 magnitude_value, pół3 wartość_znaku);	Dodano do poziomu interfejsu API 24.
pół4 copysign(pół4 magnitude_value, pół4 wartość_znaku);	Dodano do poziomu interfejsu API 24.

Kopiuje znak z argumentu wartość_znaku do parametru wartość_wielkości.

Zwrócona wartość to wartość_magnitude lub -magnitude_value.

Na przykład copysign(4.0f, -2.7f) zwraca -4.0f, a copysign(-4.0f, 2.7f) zwraca 4.0f.

cos : Cosinus

float cos(float v);
float2 cos(float2 v);
float3 cos(float3 v);
float4 cos(float4 v);
half cos(half v);	Dodano do poziomu interfejsu API 24.
half2 cos(half2 v);	Dodano do poziomu interfejsu API 24.
half3 cos(pół3 v);	Dodano do poziomu interfejsu API 24.
half4 cos(pół4 v);	Dodano do poziomu interfejsu API 24.

Zwraca cosinus kąta mierzonego w radianach.

Zobacz też native_cos().

cosh : cosinus hiperboliczny

float cosh(float v);
float2 cosh(float2 v);
float3 cosh(float3 v);
float4 cosh(float4 v);
half cosh(half v);	Dodano do poziomu interfejsu API 24.
half2 cosh(half2 v);	Dodano do poziomu interfejsu API 24.
half3 cosh(half3 v);	Dodano do poziomu interfejsu API 24.
half4 cosh(pół4 v);	Dodano do poziomu interfejsu API 24.

Zwraca cosinus hiperboliczny liczby v, gdzie v jest mierzone w radianach.

Patrz też native_cosh().

cospi : cosinus liczby pomnożonej przez pi

float cospi(float v);
float2 cospi(float2 v);
float3 cospi(float3 v);
float4 cospi(float4 v);
połowę cospi(połowę v);	Dodano do poziomu interfejsu API 24.
half2 cospi(half2 v);	Dodano do poziomu interfejsu API 24.
half3 cospi(pół3 v);	Dodano do poziomu interfejsu API 24.
pół4 cospi(połowa 4 v);	Dodano do poziomu interfejsu API 24.

Zwraca cosinus funkcji (v * pi), gdzie (v * pi) jest mierzony w radianach.

Aby uzyskać cosinus dla wartości mierzonej w stopniach, wywołaj cospi(v / 180.f).

Zobacz też native_cospi().

stopnie : przekształca radiany na stopnie

stopnie zmiennoprzecinkowe(float v);
float2°(float2 v);
float3°(float3 v);
float4°(float4 v);
pół stopnia(pół V);	Dodano do poziomu interfejsu API 24.
pół2 stopni(pół 2 v);	Dodano do poziomu interfejsu API 24.
pół3 stopni(pół 3 v);	Dodano do poziomu interfejsu API 24.
pół4 stopni(pół 4 V);	Dodano do poziomu interfejsu API 24.

Konwertuje z radianów na stopnie.

erf : funkcja błędu matematycznego

float erf(float v);
float2 erf(float2 v);
float3 erf(float3 v);
float4 erf(float4 v);
half erf(pół v);	Dodano do poziomu interfejsu API 24.
half2 erf(pół2 v);	Dodano do poziomu interfejsu API 24.
half3 erf(pół3 v);	Dodano do poziomu interfejsu API 24.
half4 erf(pół4 v);	Dodano do poziomu interfejsu API 24.

Zwraca funkcję błędu.

erfc : uzupełniająca funkcja matematyczna zawierająca błąd

float erfc(float v);
float2 erfc(float2 v);
float3 erfc(float3 v);
float4 erfc(float4 v);
half erfc(połowa v);	Dodano do poziomu interfejsu API 24.
half2 erfc(half2 v);	Dodano do poziomu interfejsu API 24.
half3 erfc(half3 v);	Dodano do poziomu interfejsu API 24.
half4 erfc(half4 v);	Dodano do poziomu interfejsu API 24.

Zwraca uzupełniającą funkcję błędu.

exp : wartość e podniesiona do liczby

float exp(float v);
float2 exp(float2 v);
float3 exp(float3 v);
float4 exp(float4 v);
half exp(half v);	Dodano do poziomu interfejsu API 24.
half2 exp(pół2 v);	Dodano do poziomu interfejsu API 24.
half3 exp(pół3 v);	Dodano do poziomu interfejsu API 24.
half4 exp(pół4 v);	Dodano do poziomu interfejsu API 24.

Zwraca wartość e podniesioną do v, tj. e ^ v.

Patrz też native_exp().

exp10 : wartość 10 podniesiona do liczby

float exp10(float v);
float2 exp10(float2 v);
float3 exp10(float3 v);
float4 exp10(float4 v);
half exp10(połowa v);	Dodano do poziomu interfejsu API 24.
half2 exp10(połowa 2 v);	Dodano do poziomu interfejsu API 24.
half3 exp10(połowa 3 v);	Dodano do poziomu interfejsu API 24.
half4 exp10(połowa 4 v);	Dodano do poziomu interfejsu API 24.

Zwraca 10 podniesioną do v, tj. 10.f ^ v.

Zobacz też native_exp10().

exp2 : wartość 2 podniesiona do liczby

float exp2(float v);
float2 exp2(float2 v);
float3 exp2(float3 v);
float4 exp2(float4 v);
half exp2(połowa v);	Dodano do poziomu interfejsu API 24.
half2 exp2(połowa 2 v);	Dodano do poziomu interfejsu API 24.
half3 exp2(pół3 v);	Dodano do poziomu interfejsu API 24.
half4 exp2(połowa 4 v);	Dodano do poziomu interfejsu API 24.

Zwraca 2 podniesione do v, tj. 2.f ^ v.

Zobacz też native_exp2().

expm1 : wartość e podniesiona do liczby minus jeden

float expm1(float v);
float2 expm1(float2 v);
float3 expm1(float3 v);
float4 expm1(float4 v);
half expm1(połowa v);	Dodano do poziomu interfejsu API 24.
half2 expm1(połowa 2 v);	Dodano do poziomu interfejsu API 24.
half3 expm1(pół3 v);	Dodano do poziomu interfejsu API 24.
half4 expm1(połowa 4 v);	Dodano do poziomu interfejsu API 24.

Zwraca wartość e podniesioną do v minus 1, tj. (e ^ v) – 1.

Patrz też native_expm1().

fabs : wartość bezwzględna liczby zmiennoprzecinkowej

float fabs(float v);
float2 fabs(float2 v);
float3 fabs(float3 v);
float4 fabs(float4 v);
połowę fabs(połowę v);	Dodano do poziomu interfejsu API 24.
pół2 fabs(połowa 2 v);	Dodano do poziomu interfejsu API 24.
pół3 fabs(połowa 3 v);	Dodano do poziomu interfejsu API 24.
połowa 4 fabs(połowa 4 v);	Dodano do poziomu interfejsu API 24.

Zwraca wartość bezwzględną liczby zmiennoprzecinkowej v.

W przypadku liczb całkowitych użyj funkcji abs().

fdim : różnica dodatnia między 2 wartościami

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(pół a, połowa b);	Dodano do poziomu interfejsu API 24.
half2 fdim(pół2 a, połowa2 b);	Dodano do poziomu interfejsu API 24.
half3 fdim(pół3 a, pół3 b);	Dodano do poziomu interfejsu API 24.
half4 fdim(pół4 a, pół4 b);	Dodano do poziomu interfejsu API 24.

Zwraca dodatnią różnicę między dwiema wartościami.

Jeśli a > b, zwraca (a–b). W przeciwnym razie zwraca 0f.

floor : najmniejsza liczba całkowita, nie większa od wartości

float Floor(float v);
float2 Floor(float2 v);
float3 Floor(float3 v);
float4 Floor(float4 v);
half Floor(pół v);	Dodano do poziomu interfejsu API 24.
pół2 piętro(pół2 v);	Dodano do poziomu interfejsu API 24.
pół3 piętro(pół3 v);	Dodano do poziomu interfejsu API 24.
pół4 piętro(pół4 v);	Dodano do poziomu interfejsu API 24.

Zwraca najmniejszą liczbę całkowitą nie większą niż wartość.

Na przykład floor(1.2f) zwraca 1.f, a floor(-1.2f) zwraca -2.f.

Zobacz też ceil().

fma : mnożenie i dodawanie

float fma(float multiplicand1, floaticand2, floatiction scale);
float2 fma(float2 multiplicand1, float2 multiplicand2, float2 przesunięcie);
float3 fma(float3 multiplicand1, float3 multiplicand2, float3 przesunięcie);
float4 fma(float4 multiplicand1, float4 multiplicand2, float4 przesunięcie);
half fma(połowa multiplicand1, połowa multiplicand2, przesunięcie połowa);	Dodano do poziomu interfejsu API 24.
half2 fma(multiplicand1 połowa 2, mnożenie połowa 2, przesunięcie połowa 2);	Dodano do poziomu interfejsu API 24.
half3 fma(multiplicand1 połowa 3, mnożenie połowa 3, przesunięcie połowa 3);	Dodano do poziomu interfejsu API 24.
half4 fma(multiplicand1 połowa 4, mnożenie połowa 4, przesunięcie połowa 4);	Dodano do poziomu interfejsu API 24.

Mnożenie i dodawanie. Zwraca wartość (multiplicand1 * multiplicand2) + offset.

Ta funkcja jest podobna do mad(). fma() zachowuje pełną precyzję pomnożonego wyniku i zaokrąglenia tylko po dodaniu. mad() zaokrągla po mnożeniu i dodawaniu. Ta dodatkowa precyzja nie jest gwarantowana w trybie rs_fp_relaxed.

fmax : maksymalnie 2 liczba zmiennoprzecinkowa

float fmax(float a, float b);
float2 fmax(float2 a, float2 b);
float2 fmax(float2 a, float2 b);
float3 fmax(float3 a, float3 b);
float3 fmax(float3 a, float3 b);
float4 fmax(float4 a, float4 b);
float4 fmax(float4 a, float4 b);
half fmax(połowa a, połowa b);	Dodano do poziomu interfejsu API 24.
half2 fmax(pół2 a, połowa b);	Dodano do poziomu interfejsu API 24.
half2 fmax(połowa2 a, połowa2 b);	Dodano do poziomu interfejsu API 24.
half3 fmax(pół3 a, połowa b);	Dodano do poziomu interfejsu API 24.
half3 fmax(pół3 a, połowa3 b);	Dodano do poziomu interfejsu API 24.
half4 fmax(pół4 a, połowa b);	Dodano do poziomu interfejsu API 24.
half4 fmax(pół4 a, połowa 4 b);	Dodano do poziomu interfejsu API 24.

Zwraca wartość maksymalną a i b, tj. (a < b ? b : a).

Funkcja max() zwraca identyczne wyniki, ale można ją zastosować do większej liczby typów danych.

fmin : co najmniej 2 liczby zmiennoprzecinkowe

float fmin(float a, float b);
float2 fmin(float2 a, float2 b);
float2 fmin(float2 a, float2 b);
float3 fmin(float3 a, float3 b);
float3 fmin(float3 a, float3 b);
float4 fmin(float4 a, float4 b);
float4 fmin(float4 a, float4 b);
pół fmin(pół a, połowa b);	Dodano do poziomu interfejsu API 24.
pół2 fmin(połowa 2 a, połowa b);	Dodano do poziomu interfejsu API 24.
pół2 fmin(pół2 a, połowa 2 b);	Dodano do poziomu interfejsu API 24.
pół3 fmin(pół3 a, połowa b);	Dodano do poziomu interfejsu API 24.
pół3 fmin(pół3 a, pół3 b);	Dodano do poziomu interfejsu API 24.
pół4 fmin(pół4 a, połowa b);	Dodano do poziomu interfejsu API 24.
pół4 fmin(pół4 a, połowa 4 b);	Dodano do poziomu interfejsu API 24.

Zwraca minimalną wartość a i b, tj. (a > b ? b : a).

Funkcja min() zwraca identyczne wyniki, ale można ją zastosować do większej liczby typów danych.

fmod : modulo

float fmod(licznik zmiennoprzecinkowy, mianownik zmiennoprzecinkowy);
float2 fmod(licznik float2, float2 mianownik);
float3 fmod(licznik float3, float3 mianownik);
float4 fmod(licznik float4, float4 mianownik);
half fmod(pół licznika, połowa mianownika);	Dodano do poziomu interfejsu API 24.
half2 fmod(licznik pół2; mianownik pół2);	Dodano do poziomu interfejsu API 24.
half3 fmod(licznik pół3; mianownik pół3);	Dodano do poziomu interfejsu API 24.
half4 fmod(licznik pół4, mianownik pół4);	Dodano do poziomu interfejsu API 24.

Zwraca pozostałą część (licznik / mianownik), gdzie iloraz jest zaokrąglany do zera.

Funkcja remainder() jest podobna, ale zaokrągla ją do najbliższej liczby całkowitej. Na przykład fmod(-3.8f, 2.f) zwraca -1.8f (-3.8f - -1.f * 2.f), a remainder(-3.8f, 2.f) zwraca 0.2f (-3.8f - -2.f * 2.f).

fract : dodatnia część ułamkowa

float fract(float v);
float fract(float v, float* Floor);
float2 fract(float2 v);
float2 fract(float2 v, float2* Floor);
float3 fract(float3 v);
float3 fract(float3 v, float3* Floor);
float4 fract(float4 v);
float4 fract(float4 v, float4* Floor);
half fract(połowa v);	Dodano do poziomu interfejsu API 24.
half fract(połowa v, pół* piętra);	Dodano do poziomu interfejsu API 24.
half2 fract(half2 v);	Dodano do poziomu interfejsu API 24.
half2 fract(pół2 v, pół2* piętro);	Dodano do poziomu interfejsu API 24.
half3 fract(half3 v);	Dodano do poziomu interfejsu API 24.
half3 fract(pół3 v, pół3* piętro);	Dodano do poziomu interfejsu API 24.
half4 fract(half4 v);	Dodano do poziomu interfejsu API 24.
half4 fract(pół4 v, pół4* piętro);	Dodano do poziomu interfejsu API 24.

Parametry

v	Wartość wejściowa.
piętro	Jeśli piętro nie ma wartości null, *floor zostanie ustawione na wartość v.

Zwraca dodatnią część ułamkową liczby v, tj. v - floor(v).

Na przykład fract(1.3f, &val) zwraca wartość 0.3f i ustawia wartość na 1.f. fract(-1.3f, &val) zwraca wartość 0,7f i ustawia wartość na -2.f.

frexp : mantysa binarna i wykładnik

float frexp(float v, int* wykładnik);
float2 frexp(float2 v, int2* wykładnik);
float3 frexp(float3 v, int3* wykładnik);
float4 frexp(float4 v, int4* wykładnik);
half frexp(połowa v, int* wykładnik);	Dodano do poziomu interfejsu API 24.
half2 frexp(half2 v, int2* wykładnik);	Dodano do poziomu interfejsu API 24.
half3 frexp(half3 v, int3* wykładnik);	Dodano do poziomu interfejsu API 24.
half4 frexp(pół4 v, int4* wykładnik);	Dodano do poziomu interfejsu API 24.

Parametry

v	Wartość wejściowa.
wykładnik	Jeśli wykładnik nie ma wartości null, *wykładnik zostanie ustawiony na wykładnik v.

Zwraca binarną mantysę i wykładnik liczby v, tj. v == mantissa * 2 ^ exponent.

Mantisa ma zawsze wartość od 0,5 (włącznie) do 1,0 (bez tej wartości).

Odwrotną operację znajdziesz w sekcji ldexp(). Zobacz też funkcje logb() i ilogb().

half_recip: wartość odwrotna obliczona z dokładnością do 16 bitów

float połowy_recip(float v);	Dodano do poziomu interfejsu API 17
float2 mid_recip(float2 v);	Dodano do poziomu interfejsu API 17
float3 połowy_recip(float3 v);	Dodano do poziomu interfejsu API 17
float4 połowy_recip(float4 v);	Dodano do poziomu interfejsu API 17

Zwraca przybliżoną wartość odwrotną.

Dokładność jest taka sama jak w przypadku 16-bitowej wartości zmiennoprzecinkowej.

Zobacz też native_recip().

half_rsqrt : odwrotność pierwiastka kwadratowego obliczony z dokładnością do 16 bitów

float połowy_rsqrt(float v);	Dodano do poziomu interfejsu API 17
float2 połowy_rsqrt(float2 v);	Dodano do poziomu interfejsu API 17
float3 połowy_rsqrt(float3 v);	Dodano do poziomu interfejsu API 17
float4 połowy_rsqrt(float4 v);	Dodano do poziomu interfejsu API 17

Zwraca przybliżoną wartość funkcji (1.f / sqrt(value)).

Dokładność jest taka sama jak w przypadku 16-bitowej wartości zmiennoprzecinkowej.

Patrz też rsqrt(), native_rsqrt().

half_sqrt: pierwiastek kwadratowy obliczany z dokładnością do 16 bitów

float połowy_sqrt(float v);	Dodano do poziomu interfejsu API 17
float2 połowy_sqrt(float2 v);	Dodano do poziomu interfejsu API 17
float3 połowy_sqrt(float3 v);	Dodano do poziomu interfejsu API 17
float4 połowy_sqrt(float4 v);	Dodano do poziomu interfejsu API 17

Zwraca przybliżony pierwiastek kwadratowy wartości.

Dokładność jest taka sama jak w przypadku 16-bitowej wartości zmiennoprzecinkowej.

Patrz też sqrt(), native_sqrt().

hipot : przeciwprostokątna

float hypot(float a, float b);
float2 hypot(float2 a, float2 b);
float3 hypot(float3 a, float3 b);
float4 hypot(float4 a, float4 b);
połowa hypot(połowa a, połowa b);	Dodano do poziomu interfejsu API 24.
połowa 2 hypot(połowa 2 a, połowa2 b);	Dodano do poziomu interfejsu API 24.
połowa 3 hypot(pół3 a, połowa 3 b);	Dodano do poziomu interfejsu API 24.
pół4 hypot(połowa 4 a, połowa 4 b);	Dodano do poziomu interfejsu API 24.

Zwraca przeciwprostokątną, tj. sqrt(a * a + b * b).

Patrz też native_hypot().

ilogb : wykładnik podstawy

int ilogb(float v);
int ilogb(połowa v);	Dodano do poziomu interfejsu API 24.
int2 ilogb(float2 v);
int2 ilogb(half2 v);	Dodano do poziomu interfejsu API 24.
int3 ilogb(float3 v);
int3 ilogb(pół3 v);	Dodano do poziomu interfejsu API 24.
int4 ilogb(float4 v);
int4 ilogb(half4 v);	Dodano do poziomu interfejsu API 24.

Zwraca wykładnik podstawy wartości, przy czym mantysa ma wartość z zakresu od 1.f (włącznie) do 2.f (wyłącznie).

Na przykład ilogb(8.5f) zwraca 3.

Ze względu na różnicę w mantysie ta liczba jest o 1 mniejsza niż zwracana przez funkcję frexp().

Funkcja logb() jest podobna, ale zwraca liczbę zmiennoprzecinkową.

ldexp : tworzy liczbę zmiennoprzecinkową na podstawie mantysy i wykładnika

float ldexp(float mantissa, int exponent);
float2 ldexp(float2 mantissa, int exponent);
float2 ldexp(float2 mantissa, int2 wykładnik);
float3 ldexp(float3 mantissa, int exponent);
float3 ldexp(float3 mantissa, int3 exponent);
float4 ldexp(float4 mantissa, int exponent);
float4 ldexp(float4 mantissa, int4 exponent);
half ldexp(połowa mantissa, wykładnik int);	Dodano do poziomu interfejsu API 24.
half2 ldexp(half2 mantissa, int exponent);	Dodano do poziomu interfejsu API 24.
half2 ldexp(pół2 mantissa, int2 wykładnik);	Dodano do poziomu interfejsu API 24.
half3 ldexp(half3 mantissa, int exponent);	Dodano do poziomu interfejsu API 24.
half3 ldexp(half3 mantissa, int3 wykładnik);	Dodano do poziomu interfejsu API 24.
half4 ldexp(pół4 mantissa, int exponent);	Dodano do poziomu interfejsu API 24.
half4 ldexp(pół4 mantissa, int4 wykładnik);	Dodano do poziomu interfejsu API 24.

Parametry

mantissa	Mantisa.
wykładnik	Wykładnik: pojedynczy składnik lub wektor pasujący.

Zwraca liczbę zmiennoprzecinkową utworzoną z mantysy i wykładnika, tj. (mantysa * 2 ^ wykładnik).

Odwrotną operację znajdziesz w sekcji frexp().

lgamma : logarytm naturalny funkcji gamma

float lgamma(float v);
float lgamma(float v, int* znak_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);
half lgamma(połowa v);	Dodano do poziomu interfejsu API 24.
połowa lgamma(połowa v, int* znak_gamma);	Dodano do poziomu interfejsu API 24.
half2 lgamma(połowa 2 v);	Dodano do poziomu interfejsu API 24.
połowa2 lgamma(połowa2 v, int2* znak_gamma);	Dodano do poziomu interfejsu API 24.
half3 lgamma(pół3 v);	Dodano do poziomu interfejsu API 24.
half3 lgamma(połowa3 v, int3* znak_gamma);	Dodano do poziomu interfejsu API 24.
half4 lgamma(połowa 4 v);	Dodano do poziomu interfejsu API 24.
half4 lgamma(połowa 4 v, int4* znak_gamma);	Dodano do poziomu interfejsu API 24.

Parametry

v
znak_gamma	Jeśli parametr sign_of_gamma nie ma wartości null, parametr *sign_of_gamma będzie miał wartość -1.f, jeśli gamma v jest ujemna, a w przeciwnym razie – 1.f.

Zwraca logarytm naturalny wartości bezwzględnej funkcji gamma, tj. log(fabs(tgamma(v))).

Zobacz też tgamma().

log : logarytm naturalny

float log(float v);
float2 log(float2 v);
float3 log(float3 v);
float4 log(float4 v);
half log(pół v);	Dodano do poziomu interfejsu API 24.
half2 log(pół2 v);	Dodano do poziomu interfejsu API 24.
half3 log(pół3 v);	Dodano do poziomu interfejsu API 24.
half4 log(pół4 v);	Dodano do poziomu interfejsu API 24.

Zwraca logarytm naturalny.

Zobacz też native_log().

log10 : logarytm dziesiętny

float log10(float v);
float2 log10(float2 v);
float3 log10(float3 v);
float4 log10(float4 v);
half log10(pół v);	Dodano do poziomu interfejsu API 24.
half2 log10(pół2 v);	Dodano do poziomu interfejsu API 24.
half3 log10(pół3 v);	Dodano do poziomu interfejsu API 24.
half4 log10(połowa 4 v);	Dodano do poziomu interfejsu API 24.

Zwraca logarytm dziesiętny.

Zobacz też native_log10().

log1p : logarytm naturalny o wartości plus 1

float log1p(float v);
float2 log1p(float2 v);
float3 log1p(float3 v);
float4 log1p(float4 v);
half log1p(pół v);	Dodano do poziomu interfejsu API 24.
half2 log1p(pół2 v);	Dodano do poziomu interfejsu API 24.
half3 log1p(pół3 v);	Dodano do poziomu interfejsu API 24.
half4 log1p(pół4 v);	Dodano do poziomu interfejsu API 24.

Zwraca logarytm naturalny (v + 1.f).

Zobacz też native_log1p().

log2 : logarytm podstawowy 2

float log2(float v);
float2 log2(float2 v);
float3 log2(float3 v);
float4 log2(float4 v);
half log2(połowa v);	Dodano do poziomu interfejsu API 24.
half2 log2(pół2 v);	Dodano do poziomu interfejsu API 24.
half3 log2(pół3 v);	Dodano do poziomu interfejsu API 24.
half4 log2(pół4 v);	Dodano do poziomu interfejsu API 24.

Zwraca logarytm dziesiętny.

Zobacz też native_log2().

logb : wykładnik podstawy

float logb(float v);
float2 logb(float2 v);
float3 logb(float3 v);
float4 logb(float4 v);
half logb(pół v);	Dodano do poziomu interfejsu API 24.
half2 logb(pół2 v);	Dodano do poziomu interfejsu API 24.
half3 logb(pół3 v);	Dodano do poziomu interfejsu API 24.
half4 logb(pół4 v);	Dodano do poziomu interfejsu API 24.

Zwraca wykładnik podstawy wartości, przy czym mantysa ma wartość z zakresu od 1.f (włącznie) do 2.f (wyłącznie).

Na przykład logb(8.5f) zwraca 3.f.

Ze względu na różnicę w liczbie mantysa ta liczba jest o jeden mniejsza niż zwracana przez funkcję frexp().

Funkcja ilogb() jest podobna, ale zwraca liczbę całkowitą.

mad : mnożenie i dodawanie

float mad(float multiplicand1, floaticand2, floatcs przesunięcia);
float2 mad(float2 multiplicand1, float2 multiplicand2, float2 przesunięcie);
float3 mad(float3 multiplicand1, float3 multiplicand2, float3 przesunięcie);
float4 mad(float4 multiplicand1, float4 multiplicand2, float4 przesunięcie);
half mad(pół multiplicand1, połowa multiplicand2, przesunięcie);	Dodano do poziomu interfejsu API 24.
half2 mad(pół2 multiplicand1, połowa 2 multiplicand2, przesunięcie połowa 2);	Dodano do poziomu interfejsu API 24.
half3 mad(pół3 multiplicand1, pół3 multiplicand2, przesunięcie połowa 3);	Dodano do poziomu interfejsu API 24.
half4 mad(half4 multiplicand1, połowa 4 multiplicand2, przesunięcie połowa 4);	Dodano do poziomu interfejsu API 24.

Mnożenie i dodawanie. Zwraca wartość (multiplicand1 * multiplicand2) + offset.

Ta funkcja jest podobna do fma(). fma() zachowuje pełną precyzję powielonych wyników i zaokrąglenia tylko po dodaniu. zaokrąglenia mad() po mnożeniu i dodawaniu. W trybie rs_fp_relaxed funkcja mad() może nie zaokrąglać po mnożeniu.

max : maksimum

char max(znak a, char b);
char2 max(znak2 a, znak2 b);
char3 max(znak3 a, char3 b);
char4 max(znak4 a, znak4 b);
float max(float a, float b);
float2 max(float2a, float2 b);
float2 max(float2 a, float2 b);
float3 max(float3 a, liczba zmiennoprzecinkowa b);
float3 max(float3 a, float3 b);
float4 max(float4a, float4 b);
float4 max(float4 a, float4 b);
half max(połowa a, połowa b);	Dodano do poziomu interfejsu API 24.
half2 max(pół2 a, połowa b);	Dodano do poziomu interfejsu API 24.
half2 max(pół2 a, połowa 2 b);	Dodano do poziomu interfejsu API 24.
half3 max(pół3 a, połowa b);	Dodano do poziomu interfejsu API 24.
half3 max(pół3 a, połowa 3 b);	Dodano do poziomu interfejsu API 24.
połowa 4 max(połowa 4 a, połowa b);	Dodano do poziomu interfejsu API 24.
połowa 4 max(połowa 4 a, połowa 4 b);	Dodano do poziomu interfejsu API 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);	Dodano do poziomu interfejsu API 21
long2 max(long2 a, long2 b);	Dodano do poziomu interfejsu API 21
long3 max(long3 a, long3 b);	Dodano do poziomu interfejsu API 21
long4 max(long4 a, long4 b);	Dodano do poziomu interfejsu API 21
short max(short a, short b);
short2 max(short2 a, short2 b);
short3 max(short3 a, short3 b);
short4 max(short4 a, short4 b);
uchar max(uchar a, uchar b);
uchar2 max(uchar2 a, uchar2 b);
uchar3 max(uchar3 a, uchar3 b);
uchar4 max(uchar4 a, uchar4 b);
uint max(uint a, uint b);
uint2 max(uint2 a, uint2 b);
uint3 max(uint3 a, uint3 b);
uint4 max(uint4 a, uint4 b);
ulong max(ulong a, ulong b);	Dodano do poziomu interfejsu API 21
ulong2 max(ulong2 a, ulong2 b);	Dodano do poziomu interfejsu API 21
ulong3 max(ulong3 a, ulong3 b);	Dodano do poziomu interfejsu API 21
ulong4 max(ulong4 a, ulong4 b);	Dodano do poziomu interfejsu API 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);

Zwraca maksymalną wartość dwóch argumentów.

min : wartość minimalna

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(float2a, float2 b);
float2 min(float2 a, float2 b);
float3 min(float3 a, liczba zmiennoprzecinkowa b);
float3 min(float3 a, float3 b);
float4 min(float4 a, float4 b);
float4 min(float4 a, float4 b);
pół min(pół a, połowa b);	Dodano do poziomu interfejsu API 24.
pół2 min(połowa 2 a, połowa b);	Dodano do poziomu interfejsu API 24.
pół2 min(połowa 2 a, połowa 2 b);	Dodano do poziomu interfejsu API 24.
pół3 min(połowa 3 a, połowa b);	Dodano do poziomu interfejsu API 24.
pół3 min(połowa 3 a, połowa 3 b);	Dodano do poziomu interfejsu API 24.
pół4 min(połowa 4 a, połowa b);	Dodano do poziomu interfejsu API 24.
połowę 4 min(połowę a, połowa 4 b);	Dodano do poziomu interfejsu API 24.
int min(int a, int b);
int2 min(int2 a, int2 b);
int3 min(int3 a, int3 b);
int4 min(int4 a, int4 b);
long min(long a, long b);	Dodano do poziomu interfejsu API 21
long2 min(long2 a, long2 b);	Dodano do poziomu interfejsu API 21
long3 min(long3 a, long3 b);	Dodano do poziomu interfejsu API 21
long4 min(long4 a, long4 b);	Dodano do poziomu interfejsu API 21
short min(short a, short b);
short2 min(short2 a, short2 b);
short3 min(short3 a, short3 b);
short4 min(short4 a, short4 b);
uchar min(uchar a, uchar b);
uchar2 min(uchar2 a, uchar2 b);
uchar3 min(uchar3 a, uchar3 b);
uchar4 min(uchar4 a, uchar4 b);
uint min(uint a, uint b);
uint2 min(uint2 a, uint2 b);
uint3 min(uint3 a, uint3 b);
uint4 min(uint4 a, uint4 b);
ulong min(ulong a, ulong b);	Dodano do poziomu interfejsu API 21
ulong2 min(ulong2 a, ulong2 b);	Dodano do poziomu interfejsu API 21
ulong3 min(ulong3 a, ulong3 b);	Dodano do poziomu interfejsu API 21
ulong4 min(ulong4 a, ulong4 b);	Dodano do poziomu interfejsu API 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);

Zwraca minimalną wartość dwóch argumentów.

mix : łączy 2 wartości

float mix(rozpoczęcie zmiennoprzecinkowe, stopa zmiennoprzecinkowa, ułamek zmiennoprzecinkowy);
float2 Mix(start float2, float2 stop, ułamek zmiennoprzecinkowy);
float2 Mix(rozpoczęcie float2, float2 stop, float2 ułamek);
float3 Mix(start float3, float3 stop, ułamek zmiennoprzecinkowy);
float3 Mix(start float3, float3 stop, float3 ułamek);
float4 Mix(start float4, float4 stop, ułamek zmiennoprzecinkowy);
float4 Mix(rozpoczęcie float4, float4 stop, float4 ułamek);
pół Mix(rozpoczęcie połowa, połowa przystanku, połowa ułamka);	Dodano do poziomu interfejsu API 24.
half2 Mix(rozpoczęcie połowy 2, połowa 2, połowa części);	Dodano do poziomu interfejsu API 24.
half2 Mix(rozpoczęcie połowy 2, przesiadka w połowie 2, część połowa 2);	Dodano do poziomu interfejsu API 24.
half3 Mix(rozpoczęcie połowy 3, połowa 3 przerwy, połowa części);	Dodano do poziomu interfejsu API 24.
half3 Mix(rozpoczęcie połowy 3, przesiadka w połowie 3, część połowa 3);	Dodano do poziomu interfejsu API 24.
half4 Mix(rozpoczęcie połowy 4, przystanek w połowie 4, połowa części);	Dodano do poziomu interfejsu API 24.
half4 Mix(rozpoczęcie połowy 4, przesiadka w połowie 4, część połowa 4);	Dodano do poziomu interfejsu API 24.

Zwraca początek + ((stop - początek) * ułamek).

Jest to przydatne, gdy chcesz połączyć 2 wartości. Aby na przykład utworzyć nowy kolor, w którym jest 40% kolor1 i 60% kolor2, użyj właściwości mix(color1, color2, 0.6f).

modf : komponenty całkowite i ułamkowe

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);
half modf(połowa v, połowa* część_całkowita);	Dodano do poziomu interfejsu API 24.
half2 modf(połowa2 v, połowa2* część_całkowita);	Dodano do poziomu interfejsu API 24.
half3 modf(połowa3 v, połowa3* część_całkowita);	Dodano do poziomu interfejsu API 24.
half4 modf(połowa 4 v, połowa4* część_całkowita);	Dodano do poziomu interfejsu API 24.

Parametry

v	Wartość źródłowa.
część_całkowita	*część_całkowita będzie stanowiła integralną część liczby.

Zwroty

Część zmiennoprzecinkowa wartości.

Zwraca całkowite i ułamkowe składniki liczby.

Oba komponenty będą miały taki sam znak jako x. Na przykład w przypadku danych wejściowych -3.72f * integral_part zostanie ustawiony na -3.f, a .72f zostanie zwrócony.

nan : to nie jest liczba

float nan(uint v);

Parametry

v	Nieużywany.

Zwraca wartość NaN (nie jest liczbą).

nan_half : to nie jest liczba

połowa nan_half();

Dodano do poziomu interfejsu API 24.

Zwraca wartość zmiennoprzecinkową półprecyzji (naN) (nie jest liczbą).

native_acos: przybliżony odwrotny cosinus

float natywne_acos(float v);	Dodano do poziomu interfejsu API 21
float2 native_acos(float2 v);	Dodano do poziomu interfejsu API 21
float3 native_acos(float3 v);	Dodano do poziomu interfejsu API 21
float4 native_acos(float4 v);	Dodano do poziomu interfejsu API 21
połowa natywnego_akusu(połowa v);	Dodano do poziomu interfejsu API 24.
pół2 natywny_acos(połowa 2 v);	Dodano do poziomu interfejsu API 24.
połowa 3 natywny_acos(połowa 3 v);	Dodano do poziomu interfejsu API 24.
połowa 4 natywnych_acos(połowa 4 v);	Dodano do poziomu interfejsu API 24.

Zwraca przybliżony odwrotny cosinus w radianach.

Ta funkcja zwraca niezdefiniowane wyniki na podstawie wartości wejściowych poniżej -1 lub większych niż 1.

Zobacz też acos().

native_acosh: przybliżony odwrotny cosinus hiperboliczny

float natywne_acosh(float v);	Dodano do poziomu interfejsu API 21
float2 native_acosh(float2 v);	Dodano do poziomu interfejsu API 21
float3 native_acosh(float3 v);	Dodano do poziomu interfejsu API 21
float4 native_acosh(float4 v);	Dodano do poziomu interfejsu API 21
halfnative_acosh(połowa v);	Dodano do poziomu interfejsu API 24.
pół2 natywna_acosh(połowa 2 v);	Dodano do poziomu interfejsu API 24.
pół3 natywna_acosh(połowa 3 v);	Dodano do poziomu interfejsu API 24.
pół4 natywna_acosh(połowa 4 v);	Dodano do poziomu interfejsu API 24.

Zwraca przybliżony odwrotny odwrotny cosinus hiperboliczny w radianach.

Zobacz też acosh().

native_acospi: przybliżony odwrotny cosinus podzielony przez pi

float natywne_acospi(float v);	Dodano do poziomu interfejsu API 21
float2 native_acospi(float2 v);	Dodano do poziomu interfejsu API 21
float3 native_acospi(float3 v);	Dodano do poziomu interfejsu API 21
float4 native_acospi(float4 v);	Dodano do poziomu interfejsu API 21
pół natywna_acospi(połowa v);	Dodano do poziomu interfejsu API 24.
pół2 natywna_acospi(połowa 2 v);	Dodano do poziomu interfejsu API 24.
połowa 3 natywna_acospi(połowa 3 v);	Dodano do poziomu interfejsu API 24.
połowa 4 natywna_acospi(połowa 4 v);	Dodano do poziomu interfejsu API 24.

Zwraca przybliżony odwrotny cosinus w radianach podzielony przez pi.

Aby uzyskać odwrotny cosinus mierzony w stopniach, użyj funkcji acospi(a) * 180.f.

Ta funkcja zwraca niezdefiniowane wyniki na podstawie wartości wejściowych poniżej -1 lub większych niż 1.

Zobacz też acospi().

native_asin : przybliżony odwrotny sinus

float natywne_asin(float v);	Dodano do poziomu interfejsu API 21
float2 native_asin(float2 v);	Dodano do poziomu interfejsu API 21
float3 native_asin(float3 v);	Dodano do poziomu interfejsu API 21
float4 native_asin(float4 v);	Dodano do poziomu interfejsu API 21
halfnative_asin(połowa v);	Dodano do poziomu interfejsu API 24.
pół2 natywna_asin(połowa 2 v);	Dodano do poziomu interfejsu API 24.
pół3 natywna_asin(połowa 3 v);	Dodano do poziomu interfejsu API 24.
pół4 natywna_asin(połowa 4 v);	Dodano do poziomu interfejsu API 24.

Zwraca przybliżony odwrotny sinus w radianach.

Ta funkcja zwraca niezdefiniowane wyniki na podstawie wartości wejściowych poniżej -1 lub większych niż 1.

Zobacz też asin().

native_asinh : przybliżony odwrotny sinus hiperboliczny

float natywne_asinh(float v);	Dodano do poziomu interfejsu API 21
float2 native_asinh(float2 v);	Dodano do poziomu interfejsu API 21
float3 native_asinh(float3 v);	Dodano do poziomu interfejsu API 21
float4 native_asinh(float4 v);	Dodano do poziomu interfejsu API 21
halfnative_asinh(połowa v);	Dodano do poziomu interfejsu API 24.
pół2 natywna_asinh(połowa 2 v);	Dodano do poziomu interfejsu API 24.
pół3 natywna_asinh(połowa 3 v);	Dodano do poziomu interfejsu API 24.
pół4 natywna_asinh(połowa 4 v);	Dodano do poziomu interfejsu API 24.

Zwraca przybliżony odwrotny odwrotny sinus hiperboliczny w radianach.

Zobacz też asinh().

native_asinpi: przybliżony odwrotny sinus podzielony przez pi

float natywne_asinpi(float v);	Dodano do poziomu interfejsu API 21
float2 native_asinpi(float2 v);	Dodano do poziomu interfejsu API 21
float3 native_asinpi(float3 v);	Dodano do poziomu interfejsu API 21
float4 native_asinpi(float4 v);	Dodano do poziomu interfejsu API 21
połowa natywna_asinpi(połowa v);	Dodano do poziomu interfejsu API 24.
połowa_2 natywna_asinpi(połowa 2 v);	Dodano do poziomu interfejsu API 24.
połowa 3 natywna_asinpi(połowa 3 v);	Dodano do poziomu interfejsu API 24.
połowa 4 natywna_asinpi(połowa 4 v);	Dodano do poziomu interfejsu API 24.

Zwraca przybliżony odwrotny sinus w radianach podzielony przez pi.

Aby uzyskać odwrotny sinus mierzony w stopniach, użyj funkcji asinpi(a) * 180.f.

Ta funkcja zwraca niezdefiniowane wyniki na podstawie wartości wejściowych poniżej -1 lub większych niż 1.

Zobacz też asinpi().

native_atan : przybliżony odwrotny tangens

float native_atan(float v);	Dodano do poziomu interfejsu API 21
float2 native_atan(float2 v);	Dodano do poziomu interfejsu API 21
float3 native_atan(float3 v);	Dodano do poziomu interfejsu API 21
float4 native_atan(float4 v);	Dodano do poziomu interfejsu API 21
połowa natywnego_atana(połowa v);	Dodano do poziomu interfejsu API 24.
połowa 2 natywnego_atana(połowa 2 v);	Dodano do poziomu interfejsu API 24.
połowa 3 natywna_attan(połowa 3 v);	Dodano do poziomu interfejsu API 24.
połowa 4 natywna_attan(połowa 4 v);	Dodano do poziomu interfejsu API 24.

Zwraca przybliżony odwrotny tangens w radianach.

Zobacz też atan().

native_atan2: przybliżony odwrotny tangens współczynnika

liczba zmiennoprzecinkowa natywny_atan2(licznik zmiennoprzecinkowy, mianownik zmiennoprzecinkowy);	Dodano do poziomu interfejsu API 21
float2native_atan2(licznik zmiennoprzecinkowy2, mianownik float2);	Dodano do poziomu interfejsu API 21
float3 natywny_atan2(licznik zmiennoprzecinkowy3, mianownik float3);	Dodano do poziomu interfejsu API 21
float4native_atan2(licznik zmiennoprzecinkowy4, mianownik zmiennoprzecinkowy4);	Dodano do poziomu interfejsu API 21
połowa natywnego_rata2(połowa licznika, połowa mianownika);	Dodano do poziomu interfejsu API 24.
pół2 natywny_atan2(licznik połowa 2, mianownik połowa 2);	Dodano do poziomu interfejsu API 24.
pół3 natywny_atan2(licznik połowa 3, mianownik połowa 3);	Dodano do poziomu interfejsu API 24.
pół4 natywny_atan2(licznik połowa 4, mianownik połowa 4);	Dodano do poziomu interfejsu API 24.

Parametry

licznik	Licznik.
mianownik	Mianownik. Wartość może wynosić 0.

Zwraca przybliżony odwrotny tangens funkcji (numerator / denominator) w radianach.

Zobacz też atan2().

native_atan2pi: przybliżony odwrotny tangens współczynnika podzielony przez pi

float natywne_atan2pi(licznik zmiennoprzecinkowy, mianownik zmiennoprzecinkowy);	Dodano do poziomu interfejsu API 21
float2native_atan2pi(licznik zmiennoprzecinkowy2, mianownik zmiennoprzecinkowy2);	Dodano do poziomu interfejsu API 21
float3native_atan2pi(licznik zmiennoprzecinkowy3, mianownik zmiennoprzecinkowy3);	Dodano do poziomu interfejsu API 21
float4 natywne_atan2pi(licznik zmiennoprzecinkowy4, mianownik zmiennoprzecinkowy4);	Dodano do poziomu interfejsu API 21
halfnative_atan2pi(połowa licznika, połowa mianownika);	Dodano do poziomu interfejsu API 24.
pół2 natywny_atan2pi(licznik połowa2, mianownik połowa 2);	Dodano do poziomu interfejsu API 24.
pół3 natywny_atan2pi(licznik pół3, mianownik połowa 3);	Dodano do poziomu interfejsu API 24.
pół4 natywny_atan2pi(licznik połowa 4, mianownik połowa 4);	Dodano do poziomu interfejsu API 24.

Parametry

licznik	Licznik.
mianownik	Mianownik. Wartość może wynosić 0.

Zwraca przybliżony odwrotny tangens funkcji (numerator / denominator) w radianach podzielony przez pi.

Aby uzyskać odwrotny tangens mierzony w stopniach, użyj funkcji atan2pi(n, d) * 180.f.

Zobacz też atan2pi().

native_atanh : przybliżony odwrotny tangens hiperboliczny

float native_atanh(float v);	Dodano do poziomu interfejsu API 21
float2 native_atanh(float2 v);	Dodano do poziomu interfejsu API 21
float3 native_atanh(float3 v);	Dodano do poziomu interfejsu API 21
float4 native_atanh(float4 v);	Dodano do poziomu interfejsu API 21
połowa natywnego_atana(połowa v);	Dodano do poziomu interfejsu API 24.
pół2 natywna_attanh(połowa 2 v);	Dodano do poziomu interfejsu API 24.
pół3 natywna_attanh(połowa 3 v);	Dodano do poziomu interfejsu API 24.
pół4 natywna_attanh(połowa 4 v);	Dodano do poziomu interfejsu API 24.

Zwraca przybliżony odwrotny tangens hiperboliczny w radianach.

Zobacz też atanh().

native_atanpi: przybliżony odwrotny tangens podzielony przez pi

float natywnego_atanpi(float v);	Dodano do poziomu interfejsu API 21
float2 natywny_atanpi(float2 v);	Dodano do poziomu interfejsu API 21
float3 native_atanpi(float3 v);	Dodano do poziomu interfejsu API 21
float4 native_atanpi(float4 v);	Dodano do poziomu interfejsu API 21
połowa natywnego_atanpi(połowa v);	Dodano do poziomu interfejsu API 24.
połowa 2 natywna_tatanpi(połowa 2 v);	Dodano do poziomu interfejsu API 24.
połowa 3 natywny_atanpi(połowa 3 v);	Dodano do poziomu interfejsu API 24.
połowa 4 natywny_atanpi(połowa 4 v);	Dodano do poziomu interfejsu API 24.

Zwraca przybliżony odwrotny tangens w radianach podzielony przez pi.

Aby uzyskać odwrotny tangens mierzony w stopniach, użyj funkcji atanpi(a) * 180.f.

Zobacz też atanpi().

native_cbrt : przybliżony pierwiastek sześcienny

float natywne_cbrt(float v);	Dodano do poziomu interfejsu API 21
float2 native_cbrt(float2 v);	Dodano do poziomu interfejsu API 21
float3 native_cbrt(float3 v);	Dodano do poziomu interfejsu API 21
float4 native_cbrt(float4 v);	Dodano do poziomu interfejsu API 21
połowa natywnego_cbrt(połowa v);	Dodano do poziomu interfejsu API 24.
połowa_2 natywna_cbrt(połowa 2 v);	Dodano do poziomu interfejsu API 24.
pół3 natywna_cbrt(połowa 3 v);	Dodano do poziomu interfejsu API 24.
połowa_4 natywna_cbrt(połowa 4 v);	Dodano do poziomu interfejsu API 24.

Zwraca przybliżony pierwiastek sześcienny.

Zobacz też cbrt().

native_cos : przybliżony cosinus

float natywne_cos(float v);	Dodano do poziomu interfejsu API 21
float2 native_cos(float2 v);	Dodano do poziomu interfejsu API 21
float3 native_cos(float3 v);	Dodano do poziomu interfejsu API 21
float4 native_cos(float4 v);	Dodano do poziomu interfejsu API 21
half natywny_cos(połowa v);	Dodano do poziomu interfejsu API 24.
pół2 natywny_cos(połowa 2 v);	Dodano do poziomu interfejsu API 24.
pół3 natywny_cos(połowa 3 v);	Dodano do poziomu interfejsu API 24.
pół4 natywny_cos(połowa 4 v);	Dodano do poziomu interfejsu API 24.

Zwraca przybliżony cosinus kąta mierzonego w radianach.

Zobacz też cos().

native_cosh: przybliżony cosinus hipeboliczny

float natywne_cosh(float v);	Dodano do poziomu interfejsu API 21
float2 native_cosh(float2 v);	Dodano do poziomu interfejsu API 21
float3 native_cosh(float3 v);	Dodano do poziomu interfejsu API 21
float4 native_cosh(float4 v);	Dodano do poziomu interfejsu API 21
halfnative_cosh(połowa v);	Dodano do poziomu interfejsu API 24.
pół2 natywna_cosh(połowa 2 v);	Dodano do poziomu interfejsu API 24.
pół3 natywna_cosh(połowa 3 v);	Dodano do poziomu interfejsu API 24.
pół4 natywna_cosh(połowa 4 v);	Dodano do poziomu interfejsu API 24.

Zwraca przybliżony cosinus hipeboliczny.

Zobacz też cosh().

native_cospi: przybliżony cosinus liczby pomnożonej przez pi

float natywne_cospi(float v);	Dodano do poziomu interfejsu API 21
float2 native_cospi(float2 v);	Dodano do poziomu interfejsu API 21
float3 native_cospi(float3 v);	Dodano do poziomu interfejsu API 21
float4 native_cospi(float4 v);	Dodano do poziomu interfejsu API 21
połowa natywnego_cospi(połowa v);	Dodano do poziomu interfejsu API 24.
pół2 natywna_cospi(połowa 2 v);	Dodano do poziomu interfejsu API 24.
pół3 natywna_cospi(połowa 3 v);	Dodano do poziomu interfejsu API 24.
pół4 natywna_cospi(połowa 4 v);	Dodano do poziomu interfejsu API 24.

Zwraca przybliżony cosinus (v * pi), gdzie (v * pi) jest mierzony w radianach.

Aby uzyskać cosinus dla wartości mierzonej w stopniach, wywołaj cospi(v / 180.f).

Zobacz też cospi().

native_divide : przybliżony podział

float natywnego_divide(zmiennoprzecinkowy_wektor_zmiennoprzecinkowy, wektor_zmiennoprzecinkowy_prawo_zmiennoprzecinkowy);	Dodano do poziomu interfejsu API 21
float2native_divide(float2 left_vector, float2 po prawej);	Dodano do poziomu interfejsu API 21
float3native_divide(float3 left_vector, float3 po prawej);	Dodano do poziomu interfejsu API 21
float4 natywny_divide(float4 left_vector, float4 prawo_wektorowe);	Dodano do poziomu interfejsu API 21
połowa natywnego_dzielenia(połowa lewo_wektor, połowa prawego_wektora);	Dodano do poziomu interfejsu API 24.
połowa_2 natywnej(połowa2 lewo_wektor, połowa2 prawo_wektor);	Dodano do poziomu interfejsu API 24.
połowa_3 natywny_dzielenie_(połowa_3 lewo_wektor, połowa3 prawo_wektor);	Dodano do poziomu interfejsu API 24.
pół4 natywny_dzielenie_(pół4 lewo_wektor, połowa_4 prawo_wektor);	Dodano do poziomu interfejsu API 24.

Oblicza przybliżony podział dwóch wartości.

native_exp : przybliżona wartość e podniesiona do liczby

float natywne_exp(float v);	Dodano do poziomu interfejsu API 18
float2 native_exp(float2 v);	Dodano do poziomu interfejsu API 18
float3 native_exp(float3 v);	Dodano do poziomu interfejsu API 18
float4 native_exp(float4 v);	Dodano do poziomu interfejsu API 18
half natywny_exp(połowa v);	Dodano do poziomu interfejsu API 24.
pół2 natywna_wyrażenia(połowa 2 v);	Dodano do poziomu interfejsu API 24.
half3 natywny_exp(połowa3 v);	Dodano do poziomu interfejsu API 24.
pół4 natywna_wyrażenia(połowa 4 v);	Dodano do poziomu interfejsu API 24.

Szybkie przybliżone wyśw.

Dotyczy danych wejściowych od -86.f do 86.f. Dokładność nie jest mniejsza od tej, której można by oczekiwać po zastosowaniu 16-bitowych wartości zmiennoprzecinkowych.

Patrz też exp().

native_exp10 : wartość około 10 podniesiona do określonej liczby

float natywny_exp10(zmiennoprzecinkowy v);	Dodano do poziomu interfejsu API 18
float2 native_exp10(float2 v);	Dodano do poziomu interfejsu API 18
float3 native_exp10(float3 v);	Dodano do poziomu interfejsu API 18
float4 native_exp10(float4 v);	Dodano do poziomu interfejsu API 18
half natywny_exp10(połowa v);	Dodano do poziomu interfejsu API 24.
połowa 2 natywnej_wyrażenia_10(połowa 2 v);	Dodano do poziomu interfejsu API 24.
połowa_3 wyrażenia natywnego_10(połowa3 v);	Dodano do poziomu interfejsu API 24.
pół4 natywna_wyr_10(połowa 4 v);	Dodano do poziomu interfejsu API 24.

Szybka przybliżona wartość exp10.

Dotyczy danych wejściowych od -37.f do 37.f. Dokładność nie jest mniejsza od tej, której można by oczekiwać po zastosowaniu 16-bitowych wartości zmiennoprzecinkowych.

Zobacz też exp10().

native_exp2 : wartość około 2 podniesiona do określonej liczby

float natywny_exp2(zmiennoprzecinkowy v);	Dodano do poziomu interfejsu API 18
float2 native_exp2(float2 v);	Dodano do poziomu interfejsu API 18
float3 native_exp2(float3 v);	Dodano do poziomu interfejsu API 18
float4 native_exp2(float4 v);	Dodano do poziomu interfejsu API 18
połowa wyrażenia natywnego(połowa v);	Dodano do poziomu interfejsu API 24.
połowa2 wyrażenie_natywne_2(połowa2 v);	Dodano do poziomu interfejsu API 24.
połowa_3 wyrażenia natywnego_(połowa3 v);	Dodano do poziomu interfejsu API 24.
pół4 natywna_wyr_2(połowa 4 v);	Dodano do poziomu interfejsu API 24.

Szybkie przybliżone wyśw. 2.

Dotyczy danych wejściowych od -125.f do 125.f. Dokładność nie jest mniejsza od tej, której można by oczekiwać po zastosowaniu 16-bitowych wartości zmiennoprzecinkowych.

Zobacz też exp2().

native_expm1: przybliżona liczba e podniesiona do minus 1

float natywne_expm1(zmiennoprzecinkowy v);	Dodano do poziomu interfejsu API 21
float2 native_expm1(float2 v);	Dodano do poziomu interfejsu API 21
float3 native_expm1(float3 v);	Dodano do poziomu interfejsu API 21
float4 native_expm1(float4 v);	Dodano do poziomu interfejsu API 21
halfnative_expm1(połowa v);	Dodano do poziomu interfejsu API 24.
pół2 natywna_wyrażenia_1(połowa 2 v);	Dodano do poziomu interfejsu API 24.
połowa_3 natywna_wyrażenia1(połowa3 v);	Dodano do poziomu interfejsu API 24.
pół4 natywna_wyrażenia_1(połowa 4 v);	Dodano do poziomu interfejsu API 24.

Zwraca wartość przybliżoną (e ^ v) – 1.

Zobacz też expm1().

native_hypot : przybliżona przeciwprostokątna

float natywne_hypot(float a, float b);	Dodano do poziomu interfejsu API 21
float2 native_hypot(float2 a, float2 b);	Dodano do poziomu interfejsu API 21
float3 native_hypot(float3 a, float3 b);	Dodano do poziomu interfejsu API 21
float4 native_hypot(float4 a, float4 b);	Dodano do poziomu interfejsu API 21
połowa natywnego_hypot(połowa a, połowa b);	Dodano do poziomu interfejsu API 24.
połowa_2 natywna_hypot(połowa2 a, połowa2 b);	Dodano do poziomu interfejsu API 24.
połowa_3 natywna_hypot(połowa3 a, połowa3 b);	Dodano do poziomu interfejsu API 24.
pół4 natywna_hypota(połowa 4 a, połowa4 b);	Dodano do poziomu interfejsu API 24.

Zwraca przybliżoną wartość natywnego_sqrt(a * a + b * b)

Zobacz też hypot().

native_log : przybliżony logarytm naturalny

float natywne_log(float v);	Dodano do poziomu interfejsu API 18
float2 native_log(float2 v);	Dodano do poziomu interfejsu API 18
float3 native_log(float3 v);	Dodano do poziomu interfejsu API 18
float4 native_log(float4 v);	Dodano do poziomu interfejsu API 18
halfnative_log(połowa v);	Dodano do poziomu interfejsu API 24.
half2native_log(połowa2 v);	Dodano do poziomu interfejsu API 24.
half3native_log(pół3 v);	Dodano do poziomu interfejsu API 24.
half4native_log(połowa 4 v);	Dodano do poziomu interfejsu API 24.

Przybliżony czas w dzienniku.

Nie jest dokładny w przypadku wartości bliskich zeru.

Zobacz też log().

native_log10: : przybliżony logarytm dziesiętny

float natywne_log10(zmiennoprzecinkowy v);	Dodano do poziomu interfejsu API 18
float2 native_log10(float2 v);	Dodano do poziomu interfejsu API 18
float3 native_log10(float3 v);	Dodano do poziomu interfejsu API 18
float4 native_log10(float4 v);	Dodano do poziomu interfejsu API 18
halfnative_log10(połowa v);	Dodano do poziomu interfejsu API 24.
pół2 natywna_log10(połowa 2 v);	Dodano do poziomu interfejsu API 24.
pół3 natywna_log10(połowa 3 v);	Dodano do poziomu interfejsu API 24.
pół4 natywna_log10(połowa 4 v);	Dodano do poziomu interfejsu API 24.

Krótkie przybliżone log10.

Nie jest dokładny w przypadku wartości bliskich zeru.

Zobacz też log10().

native_log1p: przybliżony logarytm naturalny o wartości plus 1

float natywne_log1p(float v);	Dodano do poziomu interfejsu API 21
float2 native_log1p(float2 v);	Dodano do poziomu interfejsu API 21
float3 native_log1p(float3 v);	Dodano do poziomu interfejsu API 21
float4 native_log1p(float4 v);	Dodano do poziomu interfejsu API 21
halfnative_log1p(połowa v);	Dodano do poziomu interfejsu API 24.
half2native_log1p(połowa2 v);	Dodano do poziomu interfejsu API 24.
half3native_log1p(połowa3 v);	Dodano do poziomu interfejsu API 24.
pół4 natywna_log1p(połowa 4 v);	Dodano do poziomu interfejsu API 24.

Zwraca przybliżony logarytm naturalny (v + 1.0f)

Zobacz też log1p().

native_log2 : przybliżony logarytm o podstawie 2

float natywne_log2(zmiennoprzecinkowy v);	Dodano do poziomu interfejsu API 18
float2 native_log2(float2 v);	Dodano do poziomu interfejsu API 18
float3 native_log2(float3 v);	Dodano do poziomu interfejsu API 18
float4 native_log2(float4 v);	Dodano do poziomu interfejsu API 18
halfnative_log2(połowa v);	Dodano do poziomu interfejsu API 24.
half2native_log2(połowa2 v);	Dodano do poziomu interfejsu API 24.
half3native_log2(połowa3 v);	Dodano do poziomu interfejsu API 24.
half4native_log2(połowa 4 v);	Dodano do poziomu interfejsu API 24.

Przybliżone wartości log2 – szybkie.

Nie jest dokładny w przypadku wartości bliskich zeru.

Zobacz też log2().

native_powr: – przybliżona podstawa dodatnia podniesiona do wykładnika

float natywne_powr(podstawa zmiennoprzecinkowa, wykładnik;	Dodano do poziomu interfejsu API 18
float2 natywny_powr(float2 podstawa, float2 wykładnik);	Dodano do poziomu interfejsu API 18
float3native_powr(podstawa float3, float3 wykładnik);	Dodano do poziomu interfejsu API 18
float4 natywny_powr(float4 podstawa, float4 wykładnik);	Dodano do poziomu interfejsu API 18
połowa natywnego_powr(połowa podstawy, połowa wykładnika);	Dodano do poziomu interfejsu API 24.
połowa_2 natywnego_powr(połowa 2 podstawa; połowa 2 wykładnika);	Dodano do poziomu interfejsu API 24.
połowa_3 natywnego_powr(pół3 podstawa; połowa 3 wykładnika);	Dodano do poziomu interfejsu API 24.
pół4 natywny_powr(połowa 4 podstawa, połowa 4 wykładnika);	Dodano do poziomu interfejsu API 24.

Parametry

podstawa	Wartość musi mieścić się w zakresie od 0.f do 256.f. Funkcja nie jest dokładna dla wartości bliskich zeru.
wykładnik	Wartość musi mieścić się w przedziale od -15,f do 15,f.

Przybliżona szybko (podstawa ^ wykładnik).

Zobacz też powr().

native_recip : wartość przybliżona

float natywne_recip(float v);	Dodano do poziomu interfejsu API 21
float2 native_recip(float2 v);	Dodano do poziomu interfejsu API 21
float3 native_recip(float3 v);	Dodano do poziomu interfejsu API 21
float4 native_recip(float4 v);	Dodano do poziomu interfejsu API 21
połowa natywnego_recip(połowa v);	Dodano do poziomu interfejsu API 24.
pół2 natywny recip(połowa 2 v);	Dodano do poziomu interfejsu API 24.
pół3 natywny_recip(połowa 3 v);	Dodano do poziomu interfejsu API 24.
połowa_4 natywnego_recip(połowa 4 v);	Dodano do poziomu interfejsu API 24.

Zwraca przybliżoną przybliżoną odwrotność wartości.

Zobacz też half_recip().

native_rootn : przybliżony pierwiastek n-ty

float natywne_rootn(float v, int n);	Dodano do poziomu interfejsu API 21
float2 native_rootn(float2 v, int2 n);	Dodano do poziomu interfejsu API 21
float3 native_rootn(float3 v, int3 n);	Dodano do poziomu interfejsu API 21
float4 native_rootn(float4 v, int4 n);	Dodano do poziomu interfejsu API 21
halfnative_rootn(połowa v, int n);	Dodano do poziomu interfejsu API 24.
half2native_rootn(połowa2 v, int2 n);	Dodano do poziomu interfejsu API 24.
half3native_rootn(pół3 v, int3 n);	Dodano do poziomu interfejsu API 24.
half4native_rootn(połowa 4 v, int4 n);	Dodano do poziomu interfejsu API 24.

Oblicza przybliżony pierwiastek n-ty danej wartości.

Zobacz też rootn().

native_rsqrt : szacowany odwrotność pierwiastka kwadratowego

float natywne_rsqrt(float v);	Dodano do poziomu interfejsu API 21
float2 native_rsqrt(float2 v);	Dodano do poziomu interfejsu API 21
float3 native_rsqrt(float3 v);	Dodano do poziomu interfejsu API 21
float4 native_rsqrt(float4 v);	Dodano do poziomu interfejsu API 21
halfnative_rsqrt(połowa v);	Dodano do poziomu interfejsu API 24.
half2native_rsqrt(połowa2 v);	Dodano do poziomu interfejsu API 24.
half3native_rsqrt(połowa3 v);	Dodano do poziomu interfejsu API 24.
pół4 natywna_rsqrt(połowa 4 v);	Dodano do poziomu interfejsu API 24.

Zwraca przybliżone (1 / sqrt(v)).

Patrz też rsqrt(), half_rsqrt().

native_sin : przybliżony sinus

float natywne_sin(float v);	Dodano do poziomu interfejsu API 21
float2 native_sin(float2 v);	Dodano do poziomu interfejsu API 21
float3 native_sin(float3 v);	Dodano do poziomu interfejsu API 21
float4 native_sin(float4 v);	Dodano do poziomu interfejsu API 21
halfnative_sin(połowa v);	Dodano do poziomu interfejsu API 24.
pół2 natywna_sin(połowa 2 v);	Dodano do poziomu interfejsu API 24.
pół3 natywna_sin(połowa 3 v);	Dodano do poziomu interfejsu API 24.
pół4 natywna_sin(połowa 4 v);	Dodano do poziomu interfejsu API 24.

Zwraca przybliżony sinus kąta mierzonego w radianach.

Zobacz też sin().

native_sincos : przybliżone wartości sinus i cosinus

float natywne_sincos(float v, float* cos);	Dodano do poziomu interfejsu API 21
float2 native_sincos(float2 v, float2* cos);	Dodano do poziomu interfejsu API 21
float3 native_sincos(float3 v, float3* cos);	Dodano do poziomu interfejsu API 21
float4 native_sincos(float4 v, float4* cos);	Dodano do poziomu interfejsu API 21
halfnative_sincos(połowa v, połowa* cos);	Dodano do poziomu interfejsu API 24.
połowa_2 natywna_sincos(połowa2 v, połowa2* cos);	Dodano do poziomu interfejsu API 24.
połowa_3 natywna_sincos(połowa3 v, połowa3* cos);	Dodano do poziomu interfejsu API 24.
pół4 natywna_sincos(połowa 4 v, pół4* cos);	Dodano do poziomu interfejsu API 24.

Parametry

v	Wartość przychodząca w radianach.
cos	*cos zostanie ustawione na wartość cosinusa.

Zwroty

Sinus.

Zwraca przybliżony sinus i cosinus wartości.

Zobacz też sincos().

native_sinh : przybliżony sinus hiperboliczny

float natywne_sinh(float v);	Dodano do poziomu interfejsu API 21
float2 native_sinh(float2 v);	Dodano do poziomu interfejsu API 21
float3 native_sinh(float3 v);	Dodano do poziomu interfejsu API 21
float4 native_sinh(float4 v);	Dodano do poziomu interfejsu API 21
halfnative_sinh(połowa v);	Dodano do poziomu interfejsu API 24.
pół2 natywna_sinh(połowa 2 v);	Dodano do poziomu interfejsu API 24.
pół3 natywna_sinh(połowa 3 v);	Dodano do poziomu interfejsu API 24.
pół4 natywna_sinh(połowa 4 v);	Dodano do poziomu interfejsu API 24.

Zwraca przybliżony sinus hiperboliczny dla wartości określonej w radianach.

Zobacz też sinh().

native_sinpi : przybliżony sinus liczby pomnożonej przez pi

float natywne_sinpi(float v);	Dodano do poziomu interfejsu API 21
float2 native_sinpi(float2 v);	Dodano do poziomu interfejsu API 21
float3 native_sinpi(float3 v);	Dodano do poziomu interfejsu API 21
float4 native_sinpi(float4 v);	Dodano do poziomu interfejsu API 21
połowa natywnego_sinpi(połowa v);	Dodano do poziomu interfejsu API 24.
połowa_2 natywna_sinpi(połowa 2 v);	Dodano do poziomu interfejsu API 24.
połowa 3 natywna_sinpi(połowa 3 v);	Dodano do poziomu interfejsu API 24.
połowa 4 natywna_sinpi(połowa 4 v);	Dodano do poziomu interfejsu API 24.

Zwraca przybliżony sinus (v * pi), gdzie (v * pi) jest mierzony w radianach.

Aby uzyskać sinus wartości mierzonej w stopniach, wywołaj sinpi(v / 180.f).

Zobacz też sinpi().

native_sqrt : przybliżony pierwiastek kwadratowy

float natywne_sqrt(float v);	Dodano do poziomu interfejsu API 21
float2 native_sqrt(float2 v);	Dodano do poziomu interfejsu API 21
float3 native_sqrt(float3 v);	Dodano do poziomu interfejsu API 21
float4 native_sqrt(float4 v);	Dodano do poziomu interfejsu API 21
halfnative_sqrt(połowa v);	Dodano do poziomu interfejsu API 24.
połowa_2 natywna_sqrt(połowa2 v);	Dodano do poziomu interfejsu API 24.
połowa_3 natywna_sqrt(połowa3 v);	Dodano do poziomu interfejsu API 24.
pół4 natywna_sqrt(połowa 4 v);	Dodano do poziomu interfejsu API 24.

Zwraca przybliżoną wartość sqrt(v).

Patrz też sqrt(), half_sqrt().

native_tan : przybliżony tangens

float native_tan(float v);	Dodano do poziomu interfejsu API 21
float2 native_tan(float2 v);	Dodano do poziomu interfejsu API 21
float3 native_tan(float3 v);	Dodano do poziomu interfejsu API 21
float4 native_tan(float4 v);	Dodano do poziomu interfejsu API 21
half natywny_tan(połowa v);	Dodano do poziomu interfejsu API 24.
pół2 natywna_tan(połowa 2 v);	Dodano do poziomu interfejsu API 24.
połowa 3 natywna_tan(połowa3 v);	Dodano do poziomu interfejsu API 24.
pół4 natywny_tan(połowa 4 v);	Dodano do poziomu interfejsu API 24.

Zwraca przybliżony tangens kąta mierzonego w radianach.

native_tanh : przybliżony tangens hiperboliczny

float natywne_tanh(float v);	Dodano do poziomu interfejsu API 21
float2 native_tanh(float2 v);	Dodano do poziomu interfejsu API 21
float3 native_tanh(float3 v);	Dodano do poziomu interfejsu API 21
float4 native_tanh(float4 v);	Dodano do poziomu interfejsu API 21
halfnative_tanh(połowa v);	Dodano do poziomu interfejsu API 24.
pół2 natywna_tanh(połowa 2 v);	Dodano do poziomu interfejsu API 24.
pół3 natywna_tanh(połowa 3 v);	Dodano do poziomu interfejsu API 24.
pół4 natywna_tanh(połowa 4 v);	Dodano do poziomu interfejsu API 24.

Zwraca przybliżony tangens hiperboliczny danej wartości.

Zobacz też tanh().

native_tanpi: przybliżony tangens liczby pomnożonej przez pi

float natywne_tanpi(float v);	Dodano do poziomu interfejsu API 21
float2 native_tanpi(float2 v);	Dodano do poziomu interfejsu API 21
float3 native_tanpi(float3 v);	Dodano do poziomu interfejsu API 21
float4 native_tanpi(float4 v);	Dodano do poziomu interfejsu API 21
połowa natywnego_tanpi(połowa v);	Dodano do poziomu interfejsu API 24.
pół2 natywna_tanpi(połowa 2 v);	Dodano do poziomu interfejsu API 24.
pół3 natywna_tanpi(połowa 3 v);	Dodano do poziomu interfejsu API 24.
pół4 natywna_tanpi(połowa 4 v);	Dodano do poziomu interfejsu API 24.

Zwraca przybliżony tangens (v * pi), gdzie (v * pi) jest mierzony w radianach.

Aby uzyskać tangens dla wartości mierzonej w stopniach, wywołaj funkcję tanpi(v / 180.f).

Zobacz też tanpi().

nextafter : kolejna liczba zmiennoprzecinkowa

float nextafter(float v, cel zmiennoprzecinkowy);
float2 nextafter(float2 v, float2 target);
float3 nextafter(float3 v, float3 target);
float4 nextafter(float4 v, float4 target);
half nextafter(połowa v, połowa celu);	Dodano do poziomu interfejsu API 24.
half2 nextafter(pół2 v, cel połowa 2);	Dodano do poziomu interfejsu API 24.
pół3 nextafter(pół3 v, cel połowa 3);	Dodano do poziomu interfejsu API 24.
half4 nextafter(połowa 4 v, cel w połowie 4);	Dodano do poziomu interfejsu API 24.

Zwraca następną reprezentatywną liczbę zmiennoprzecinkową od v do wartości docelowej.

W trybie rs_fp_relaxed zdenormalizowana wartość wejściowa może nie zwracać kolejnej znormalizowanej wartości, ponieważ obsługa zdenormalizowanych wartości jest opcjonalna w trybie relaksacyjnym.

pow : podstawa podniesiona do wykładnika

float pow(podstawa zmiennoprzecinkowa, wykładnik liczby zmiennoprzecinkowej);
float2 pow(float2 base, float2 wykładnik);
float3 pow(float3 base, float3 exonent);
float4 pow(float4 base, float4 exonent);
połowa pow(połowa podstawy, połowa wykładnika);	Dodano do poziomu interfejsu API 24.
half2 pow(pół2 podstawa, połowa 2 wykładnik);	Dodano do poziomu interfejsu API 24.
half3 pow(pół3 podstawa, połowa 3 wykładnik);	Dodano do poziomu interfejsu API 24.
half4 pow(pół4 podstawa, połowa 4 wykładnika);	Dodano do poziomu interfejsu API 24.

Zwraca podstawę podniesioną do wykładnika potęgi, tj. podstawa ^ wykładnik.

pown() i powr() są podobne. Funkcja pown() przyjmuje wykładnik liczby całkowitej. Funkcja powr() zakłada, że podstawa jest nieujemna.

pown : podstawa podniesiona do wykładnika liczby całkowitej

float pown(podstawa zmiennoprzecinkowa, wykładnik int);
float2 pown(float2 podstawa, int2 wykładnik);
float3 pown(podstawa float3, wykładnik int3);
float4 pown(float4 podstawa, int4 wykładnik);
half pown(połowa podstawy, wykładnik int);	Dodano do poziomu interfejsu API 24.
half2 pown(pół2 podstawa, wykładnik wykładnika int2);	Dodano do poziomu interfejsu API 24.
half3 pown(pół3 podstawa, wykładnik wykładnika int3);	Dodano do poziomu interfejsu API 24.
half4 pown(pół4 podstawa, wykładnik wykładnika int4);	Dodano do poziomu interfejsu API 24.

Zwraca podstawę podniesioną do wykładnika potęgi, tj. podstawa ^ wykładnik.

pow() i powr() są podobne. Oba przyjmują wykładnik zmiennoprzecinkowy. Funkcja powr() zakłada też, że podstawa jest nieujemna.

powr : dodatnia podstawa podniesiona do wykładnika

float powr(podstawa zmiennoprzecinkowa, wykładnik liczby zmiennoprzecinkowej);
float2 powr(float2 base, float2 wykładnik);
float3 powr(float3 base, float3 exonent);
float4 powr(float4 base, float4 exonent);
half powr(połowa podstawy, połowa wykładnika);	Dodano do poziomu interfejsu API 24.
half2 powr(pół2 podstawa, pół2 wykładnik);	Dodano do poziomu interfejsu API 24.
half3 powr(pół3 podstawa, połowa 3 wykładnik);	Dodano do poziomu interfejsu API 24.
half4 powr(pół4 podstawa, połowa 4 wykładnik);	Dodano do poziomu interfejsu API 24.

Zwraca podstawę podniesioną do wykładnika potęgi, tj. podstawa ^ wykładnik. podstawa musi być >= 0.

pow() i pown() są podobne. Oba nie zakładają żadnych założeń dotyczących podstawy. pow() przyjmuje wykładnik liczby zmiennoprzecinkowej, a pown() przyjmuje liczbę całkowitą.

Zobacz też native_powr().

radiany : przekształca stopnie na radiany

radiany zmiennoprzecinkowe(zmiennoprzecinkowe v);
radiany float2(float2 v);
float3 radiana(float3 v);
float4 radiana(float4 v);
pół radianów(połowa v);	Dodano do poziomu interfejsu API 24.
radiany pół2(pół2 v);	Dodano do poziomu interfejsu API 24.
pół3 radnów(pół3 v);	Dodano do poziomu interfejsu API 24.
pół4 radianów(pół4 v);	Dodano do poziomu interfejsu API 24.

Konwertuje ze stopni na radiany.

remainder : reszta z działu

reszta zmiennoprzecinkowa(licznik zmiennoprzecinkowy, mianownik zmiennoprzecinkowy);
Liczba zmiennoprzecinkowa2(licznik float2, mianownik float2);
Liczba zmiennoprzecinkowa3(licznik float3, mianownik float3);
Liczba zmiennoprzecinkowa4(licznik float4, mianownik float4);
połowa reszty(licznik połowa, połowa mianownika);	Dodano do poziomu interfejsu API 24.
połowa 2 reszty(licznik pół2; mianownik połowa 2);	Dodano do poziomu interfejsu API 24.
połowa 3 reszty(licznik pół3, mianownik pół3);	Dodano do poziomu interfejsu API 24.
połowa 4 reszty(licznik pół4, mianownik pół4);	Dodano do poziomu interfejsu API 24.

Zwraca pozostałą część (licznik / mianownik), gdzie iloraz jest zaokrąglany w kierunku najbliższej liczby całkowitej.

Funkcja fmod() jest podobna, ale zaokrągla ją do najbliższej liczby całkowitej. Na przykład fmod(-3.8f, 2.f) zwraca -1.8f (-3.8f - -1.f * 2.f), a remainder(-3.8f, 2.f) zwraca 0.2f (-3.8f - -2.f * 2.f).

remquo : reszta i iloraz podziału

float remquo(licznik zmiennoprzecinkowy, mianownik zmiennoprzecinkowy, iloraz int*);
float2 remquo(licznik float2, mianownik float2, int2* iloraz);
float3 remquo(licznik float3, mianownik float3, int3* iloraz);
float4 remquo(licznik float4, float4 mianownik, int4* iloraz);
half remquo(połowę licznika, połowa mianownika, iloraz int*);	Dodano do poziomu interfejsu API 24.
half2 remquo(licznik pół2, mianownik pół2, iloraz int2*);	Dodano do poziomu interfejsu API 24.
half3 remquo(licznik pół3, mianownik pół3, iloraz int3*);	Dodano do poziomu interfejsu API 24.
pół4 remquo(licznik pół4, mianownik pół4, iloraz int4*);	Dodano do poziomu interfejsu API 24.

Parametry

licznik	Licznik.
mianownik	Mianownik.
iloraz	*iloraz zostanie ustawiony na iloraz liczby całkowitej.

Zwroty

Pozostało, precyzyjna tylko przy niskich 3 bitach.

Zwraca iloraz i resztę z (licznik / mianownik).

Dokładność zawsze obejmuje tylko znak i 3 najniższe bity ilorazu.

Przydaje się ona do implementowania funkcji okresowych. Niskie 3 bity ilorazu wyznaczają kwadrant, a pozostałą odległość – w obrębie kwadrantu. Na przykład implementacja sin(x) może wywołać funkcję remquo(x, PI / 2.f, &quadrant), aby zredukować bardzo dużą wartość x do wartości w wyznaczonym zakresie.

Przykład: remquo(-23.5f, 8.f, &quot) ustawia 3 najniższe bity cudzysłowu na 3 i znak ujemny. Zwraca 0.5f.

rint : zaokrąglone do parzystej

float rint(float v);
float2 rint(float2 v);
float3 rint(float3 v);
float4 rint(float4 v);
half rint(pół v);	Dodano do poziomu interfejsu API 24.
half2 rint(half2 v);	Dodano do poziomu interfejsu API 24.
half3 rint(half3 v);	Dodano do poziomu interfejsu API 24.
half4 rint(half4 v);	Dodano do poziomu interfejsu API 24.

Zaokrągla wartość do najbliższej całkowitej wartości.

rint() zaokrągla pół wartości do równomiernego. Na przykład rint(0.5f) zwraca wartość 0.f, a rint(1.5f) zwraca 2.f. Podobnie funkcja rint(-0.5f) zwraca wartość -0.f, a rint(-1.5f) zwraca wartość -2.f.

Funkcja round() jest podobna, ale zaokrągla od zera. Funkcja trunc() powoduje skrócenie ułamków dziesiętnych.

rootn : pierwiastek n-ty

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(połowa v, int n);	Dodano do poziomu interfejsu API 24.
half2 rootn(half2 v, int2 n);	Dodano do poziomu interfejsu API 24.
half3 rootn(half3 v, int3 n);	Dodano do poziomu interfejsu API 24.
half4 rootn(half4 v, int4 n);	Dodano do poziomu interfejsu API 24.

Oblicza n-ty pierwiastek wartości.

Zobacz też native_rootn().

round : zaokrąglanie od zera

float round(float v);
float2 round(float2 v);
float3 round(float3 v);
float4 round(float4 v);
half round(pół v);	Dodano do poziomu interfejsu API 24.
half2 round(half2 v);	Dodano do poziomu interfejsu API 24.
half3 round(half3 v);	Dodano do poziomu interfejsu API 24.
half4 round(half4 v);	Dodano do poziomu interfejsu API 24.

Zaokrąglaj do najbliższej wartości całkowitej.

Funkcja round() zaokrągla połowa wartości od zera. Na przykład round(0.5f) zwraca 1.f, a round(1.5f) zwraca 2.f. Podobnie round(-0.5f) zwraca -1.f, a round(-1.5f) zwraca -2.f.

Funkcja rint() jest podobna, ale zaokrągla połowy wartości do wartości parzystej. Funkcja trunc() powoduje skrócenie ułamków dziesiętnych.

rsClamp : ogranicz wartość do zakresu

char rsClamp(char amount, char low, char high);
int rsClamp(kwota int; niska int; int wysoka);
short rsClamp(short amount, krótko, niski, short high);
uchar rsClamp(kwota uchar, uchar niska, uchar wysoka);
uint rsClamp(ilość uint, uint niska, uint wysoka);
ushort rsClamp(ushort amount, ushort low, ushort high);

Parametry

kwota	Wartość do ograniczenia.
niskie	Dolna granica.
wysokie	Górna granica.

Wycofano. Użyj funkcji clamp().

Ogranicz wartość między niską a wysoką.

rsFrac : zwraca część ułamkową liczby zmiennoprzecinkowej

float rsFrac(float v);

Wycofano. Użyj w zamian funkcji fract().

Zwraca część ułamkową liczby zmiennoprzecinkowej

rsRand : Pseudolosowa liczba

float rsRand(maksymalna_wartość_zmiennoprzecinkowa);
float rsRand(minimalna_wartość_zmiennoprzecinkowa, maksymalna_wartość_zmiennoprzecinkowa);
int rsRand(int max_value);
int rsRand(wartość_minimalna, wartość_maksymalna);

Zwraca losową wartość z zakresu od 0 (lub wartość_minimalna) do max_malue.

rsqrt : odwrotność pierwiastka kwadratowego

float rsqrt(float v);
float2 rsqrt(float2 v);
float3 rsqrt(float3 v);
float4 rsqrt(float4 v);
half rsqrt(half v);	Dodano do poziomu interfejsu API 24.
half2 rsqrt(half2 v);	Dodano do poziomu interfejsu API 24.
half3 rsqrt(half3 v);	Dodano do poziomu interfejsu API 24.
half4 rsqrt(half4 v);	Dodano do poziomu interfejsu API 24.

Zwraca (1 / sqrt(v)).

Patrz też half_rsqrt(), native_rsqrt().

znak : znak wartości

znak zmiennoprzecinkowy(float v);
float2(float2 v);
float3(float3 v);
float4(float4 v);
pół(połowa v);	Dodano do poziomu interfejsu API 24.
half2(pół2 v);	Dodano do poziomu interfejsu API 24.
half3(pół3 v);	Dodano do poziomu interfejsu API 24.
half4(pół4 v);	Dodano do poziomu interfejsu API 24.

Zwraca znak wartości.

Jeśli (v < 0) zwraca -1.f; else jeśli (v > 0) zwraca 1.f; else zwraca 0.f;

sin : sinus

float sin(float v);
float2 sin(float2 v);
float3 sin(float3 v);
float4 sin(float4 v);
half sin(half v);	Dodano do poziomu interfejsu API 24.
half2 sin(half2 v);	Dodano do poziomu interfejsu API 24.
half3 sin(half3 v);	Dodano do poziomu interfejsu API 24.
half4 sin(half4 v);	Dodano do poziomu interfejsu API 24.

Zwraca sinus kąta mierzonego w radianach.

Zobacz też native_sin().

sincos : sinus i cosinus

float sincos(float v, float* cos);
float2 sincos(float2 v, float2* cos);
float3 sincos(float3 v, float3* cos);
float4 sincos(float4 v, float4* cos);
half sincos(half v, half* cos);	Dodano do poziomu interfejsu API 24.
half2 sincos(half2 v, half2* cos);	Dodano do poziomu interfejsu API 24.
half3 sincos(half3 v, half3* cos);	Dodano do poziomu interfejsu API 24.
half4 sincos(half4 v, half4* cos);	Dodano do poziomu interfejsu API 24.

Parametry

v	Wartość przychodząca w radianach.
cos	*cos zostanie ustawione na wartość cosinusa.

Zwroty

Sinus v.

Zwraca sinus i cosinus wartości.

Zobacz też native_sincos().

sinh : sinus hiperboliczny

float sinh(float v);
float2 sinh(float2 v);
float3 sinh(float3 v);
float4 sinh(float4 v);
half sinh(pół v);	Dodano do poziomu interfejsu API 24.
half2 sinh(pół2 v);	Dodano do poziomu interfejsu API 24.
half3 sinh(pół3 v);	Dodano do poziomu interfejsu API 24.
half4 sinh(połowa 4 v);	Dodano do poziomu interfejsu API 24.

Zwraca sinus hiperboliczny liczby v, gdzie v jest mierzone w radianach.

Zobacz też native_sinh().

sinpi : sinus liczby pomnożonej przez pi

float sinpi(float v);
float2 sinpi(float2 v);
float3 sinpi(float3 v);
float4 sinpi(float4 v);
half sinpi(połowa v);	Dodano do poziomu interfejsu API 24.
pół2 sinpi(połowa 2 v);	Dodano do poziomu interfejsu API 24.
pół3 sinpi(połowa 3 v);	Dodano do poziomu interfejsu API 24.
pół4 sinpi(połowa 4 v);	Dodano do poziomu interfejsu API 24.

Zwraca sinus (v * pi), gdzie (v * pi) jest mierzony w radianach.

Aby uzyskać sinus wartości mierzonej w stopniach, wywołaj sinpi(v / 180.f).

Zobacz też native_sinpi().

sqrt : pierwiastek kwadratowy

float sqrt(float v);
float2 sqrt(float2 v);
float3 sqrt(float3 v);
float4 sqrt(float4 v);
half sqrt(half v);	Dodano do poziomu interfejsu API 24.
half2 sqrt(pół2 v);	Dodano do poziomu interfejsu API 24.
half3 sqrt(half3 v);	Dodano do poziomu interfejsu API 24.
half4 sqrt(half4 v);	Dodano do poziomu interfejsu API 24.

Zwraca pierwiastek kwadratowy określonej wartości.

Patrz też half_sqrt() i native_sqrt().

step : 0, jeśli wartość jest mniejsza od wartości, 1, jeśli nie

float step(float krawędź, float v);
float2 step(float Edge, float2 v);	Dodano do poziomu interfejsu API 21
float2 step(float2 Edge, float2 v);
float2 step(float2 Edge, float2 v);
float3 step(float3, float3 v);	Dodano do poziomu interfejsu API 21
float3 step(float3 Edge, float3 v);
float3 step(float3 Edge, float3 v);
float4 step(float4, float4 v);	Dodano do poziomu interfejsu API 21
float4 step(float4 Edge, float4 v);
float4 step(float4 Edge, float4 v);
pół kroku(połowa krawędzi, połowa v);	Dodano do poziomu interfejsu API 24.
pół2 kroku(krawędzi połowa, połowa 2 v);	Dodano do poziomu interfejsu API 24.
half2 step(pół2 krawędzi, połowa v);	Dodano do poziomu interfejsu API 24.
half2 step(pół2 krawędzi, połowa 2 v);	Dodano do poziomu interfejsu API 24.
pół3 krok(połowa krawędzi, połowa 3 v);	Dodano do poziomu interfejsu API 24.
pół3 krok(pół3 krawędzi, połowa v);	Dodano do poziomu interfejsu API 24.
half3 step(pół3 krawędzi, połowa 3 v);	Dodano do poziomu interfejsu API 24.
pół4 kroku(pół Edge, połowa 4 v);	Dodano do poziomu interfejsu API 24.
pół4 kroku(pół4 krawędzi, połowa v);	Dodano do poziomu interfejsu API 24.
pół4 kroku(pół4 krawędź, połowa 4 v);	Dodano do poziomu interfejsu API 24.

Zwraca wartość 0.f, jeśli v < Edge lub 1.f w przeciwnym razie.

Może to być przydatne podczas tworzenia obliczeń warunkowych bez korzystania z pętli i instrukcji rozgałęziania. Na przykład zamiast obliczać (a[i] < b[i]) ? 0.f : atan2(a[i], b[i]) dla odpowiednich elementów wektora, możesz użyć funkcji step(a, b) * atan2(a, b).

tangens : tangens

float tan(float v);
float2 tan(float2 v);
float3 tan(float3 v);
float4 tan(float4 v);
pół tan(połowa v);	Dodano do poziomu interfejsu API 24.
half2 tan(pół2 v);	Dodano do poziomu interfejsu API 24.
half3 tan(pół3 v);	Dodano do poziomu interfejsu API 24.
pół4 tan(połowa 4 v);	Dodano do poziomu interfejsu API 24.

Zwraca tangens kąta mierzonego w radianach.

Patrz też native_tan().

tanh : tangens hiperboliczny

float tanh(float v);
float2 tanh(float2 v);
float3 tanh(float3 v);
float4 tanh(float4 v);
half tanh(pół v);	Dodano do poziomu interfejsu API 24.
half2 tanh(pół2 v);	Dodano do poziomu interfejsu API 24.
half3 tanh(pół3 v);	Dodano do poziomu interfejsu API 24.
half4 tanh(pół4 v);	Dodano do poziomu interfejsu API 24.

Zwraca tangens hiperboliczny danej wartości.

Patrz też native_tanh().

tanpi : tangens liczby pomnożonej przez pi

float tanpi(float v);
float2 tanpi(float2 v);
float3 tanpi(float3 v);
float4 tanpi(float4 v);
half tanpi(połowa v);	Dodano do poziomu interfejsu API 24.
half2 tanpi(połowa 2 v);	Dodano do poziomu interfejsu API 24.
half3 tanpi(pół3 v);	Dodano do poziomu interfejsu API 24.
pół4 tanpi(połowa 4 v);	Dodano do poziomu interfejsu API 24.

Zwraca tangens (v * pi), gdzie (v * pi) jest mierzony w radianach.

Aby uzyskać tangens dla wartości mierzonej w stopniach, wywołaj funkcję tanpi(v / 180.f).

Zobacz też native_tanpi().

tgamma : funkcja gamma

float tgamma(float v);
float2 tgamma(float2 v);
float3 tgamma(float3 v);
float4 tgamma(float4 v);
half tgamma(połowa v);	Dodano do poziomu interfejsu API 24.
half2 tgamma(połowa 2 v);	Dodano do poziomu interfejsu API 24.
half3 tgamma(połowa 3 v);	Dodano do poziomu interfejsu API 24.
half4 tgamma(połowa 4 v);	Dodano do poziomu interfejsu API 24.

Zwraca funkcję gamma dla wartości.

Zobacz też lgamma().

obcinanie : powoduje obcięcie liczby zmiennoprzecinkowej

float trunc(float v);
float2 trunc(float2 v);
float3 trunc(float3 v);
float4 trunc(float4 v);
half trunc(pół v);	Dodano do poziomu interfejsu API 24.
half2 trunc(pół2 v);	Dodano do poziomu interfejsu API 24.
half3 trunc(pół3 v);	Dodano do poziomu interfejsu API 24.
half4 trunc(połowa 4 v);	Dodano do poziomu interfejsu API 24.

Zaokrągla wartości do całki przy użyciu cięcia.

Na przykład trunc(1.7f) zwraca 1.f, a trunc(-1.7f) zwraca -1.f.

Inne opcje zaokrąglania znajdziesz w sekcjach rint() i round().