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. |
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. |
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. |
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
Zwraca maksymalną wartość dwóch argumentów.
min : wartość minimalna
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. |
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. |
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. |
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, ") 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
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. |