Übersicht
Die unten aufgeführten mathematischen Funktionen können auf Skalare und Vektoren angewendet werden. Bei Anwendung auf Vektoren ist der zurückgegebene Wert ein Vektor der Funktion, die auf jeden Eintrag der Eingabe angewendet wird.
Beispiel:
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);
Unter Mathematische Vektorfunktionen finden Sie Informationen zu Funktionen wie distance() und length(), die stattdessen die Eingabe als einzelnen Vektor im n-dimensionalen Bereich interpretieren.
Die Genauigkeit der mathematischen Operationen in 32-Bit-Gleitkommazahlen wird von den Pragmas rs_fp_relaxed und rs_fp_full beeinflusst. Unter rs_fp_relaxed können subnormale Werte auf null geleert und gegen null gerundet werden. Im Gegensatz dazu erfordert rs_fp_full eine korrekte Verarbeitung von subnormalen Werten, d. h. kleiner als 1, 17549435e-38f. erfordert rs_fp_rull außerdem eine Rundung auf die nächste und eine gleichmäßige Aufstellung.
Mithilfe von Varianten gängiger mathematischer Funktionen können unterschiedliche Kompromisse bei Genauigkeit und Geschwindigkeit erreicht werden. Funktionen mit einem Namen, der mit
- native_: Kann benutzerdefinierte Hardwareimplementierungen mit geringerer Genauigkeit haben. Darüber hinaus können subnormale Werte auf null bereinigt werden, eine Rundung in Richtung Null kann verwendet werden und die Eingabe von NaN und Unendlichkeit wird möglicherweise nicht korrekt verarbeitet.
- halb_: Kann interne Berechnungen mit 16-Bit-Gleitkommazahlen durchführen. Darüber hinaus können subnormale Werte auf null bereinigt und gegen null gerundet werden.
Zusammenfassung
| Konstanten | |
|---|---|
| M_1_PI | 1 / Pi als 32-Bit-Gleitkommazahl |
| M_2_PI | 2 / Pi als 32-Bit-Gleitkommazahl |
| M_2_WURZEL | 2 / Qrt(Pi) als 32-Bit-Gleitkommazahl |
| M_E | e als 32-Bit-Gleitkommazahl |
| M_LN10 | log_e(10), als 32-Bit-Gleitkommazahl |
| M_LN2 | log_e(2) als 32-Bit-Gleitkommazahl |
| M_LOG10E | log_10(e) als 32-Bit-Gleitkommazahl |
| M_LOG2E | log_2(e) als 32-Bit-Gleitkommazahl |
| M_PI | Pi als 32-Bit-Gleitkommazahl |
| M_PI_2 | Pi / 2 als 32-Bit-Gleitkommazahl |
| M_PI_4 | Pi / 4 als 32-Bit-Gleitkommazahl |
| M_SQRT1_2 | 1 / QRT(2) als 32-Bit-Gleitkommazahl |
| M_WURZEL2 | QRT(2) als 32-Bit-Gleitkommazahl |
| Funktionen | |
|---|---|
| Bauchmuskeln | Absoluter Wert einer Ganzzahl |
| acos | Inverser Kosinus |
| acosh | Inverser hyperbolischer Kosinus |
| Acospi | Inverser Kosinus geteilt durch Pi |
| assinen | Inverser Sinus |
| Asinh | Inverser hyperbolischer Sinus |
| Asinpi | Umkehrsinus geteilt durch Pi |
| Atan | Umgekehrter Tangens |
| atan2 | Umgekehrter Tangens eines Verhältnisses |
| atan2pi | Umgekehrter Tangens eines Verhältnisses, geteilt durch Pi |
| Atanh | Umgekehrter hyperbolischer Tangens |
| Atanpi | Umgekehrter Tangens geteilt durch Pi |
| cbrt | Kubikwurzel |
| Ceil | Kleinste Ganzzahl, die nicht kleiner als ein Wert ist |
| Klemme | Wert auf einen Bereich beschränken |
| clz | Anzahl der führenden 0-Bits |
| Kopierzeichen | Kopiert das Vorzeichen einer Zahl auf eine andere |
| cos | Kosinus |
| Cosh | Hypebolischer Kosinus |
| cospi | Kosinus einer Zahl multipliziert mit Pi |
| Grad | Wandelt Bogenmaß (Radiant) in Grad um |
| erf | Mathematische Fehlerfunktion |
| erFC | Mathematische komplementäre Fehlerfunktion |
| test | e auf eine Zahl erhöht |
| Test 10 | 10 als Zahl erhöht |
| Test 2 | 2 ist eine Zahl |
| expm1: | e wird auf eine Zahl minus eins erhöht |
| Fabs | Absoluter Wert einer Gleitkommazahl |
| FDIM | Positive Differenz zwischen zwei Werten |
| Etage | Kleinste Ganzzahl, die nicht größer als ein Wert ist |
| FMA | Multiplizieren und addieren |
| fmax | Maximal zwei Gleitkommazahlen |
| FMIN | Mindestens zwei Gleitkommazahlen |
| Fmod | Modulo |
| Fakt | Positiver Bruchteil |
| frexp | Binäre Mantisse und Exponent |
| half_recip | Gegenseitig berechnet, berechnet auf 16-Bit-Genauigkeit |
| half_rsqrt | Kehrwert einer Quadratwurzel, berechnet auf 16-Bit-Genauigkeit |
| half_sqrt | Quadratwurzel, berechnet auf 16-Bit-Genauigkeit |
| Hypot | Hypotenuse |
| ilogb | Basis 2-Exponent |
| ldexp | Erstellt einen Gleitkommawert aus Mantissen und Exponenten |
| Lgamma | Natürlicher Logarithmus der Gammafunktion |
| log | Natürlicher Logarithmus |
| log10 | Logarithmus zur Basis 10 |
| log1p | Natürlicher Logarithmus eines Werts plus 1 |
| log2 | Logarithmus zur Basis 2 |
| Logb | Basis 2-Exponent |
| verrückt | Multiplizieren und addieren |
| max. | Maximum |
| Min. | Minimum |
| Mix | Es vermischt zwei Werte |
| modf | Integral- und Bruchkomponenten |
| Nan | Keine Zahl |
| nan_half | Keine Zahl |
| native_acos | Ungefährer Arkuskosinus |
| native_acosh | Ungefährer umgekehrter hyperbolischer Kosinus |
| native_acospi | Ungefährer Arkuskosinus geteilt durch Pi |
| native_asin | Ungefährer Arkussinus |
| native_asinh | Ungefährer umgekehrter hyperbolischer Sinus |
| native_asinpi | Ungefährer Arkussinus geteilt durch Pi |
| native_atan | Ungefährer inverser Tangens |
| native_atan2 | Ungefährer inverser Tangens eines Verhältnisses |
| native_atan2pi | Ungefährer inverser Tangens eines Verhältnisses, geteilt durch Pi |
| native_atanh | Ungefährer umgekehrter hyperbolischer Tangens |
| native_atanpi | Ungefährer umgekehrter Tangens geteilt durch Pi |
| native_cbrt | Ungefähre Kubikwurzel |
| native_cos | Ungefährer Kosinus |
| native_cosh | Ungefährer hypebolischer Kosinus |
| native_cospi | Ungefährer Kosinus einer Zahl multipliziert mit Pi |
| native_divide | Ungefähre Division |
| native_exp | Ungefähre Zahl, e |
| native_exp10 | Ungefähr 10 erhöht auf eine Zahl |
| native_exp2 | Ungefähr 2 erhöht auf eine Zahl |
| native_expm1 | Geschätzter e-Wert auf eine Zahl minus eins erhöht |
| native_Hypot | Ungefähre Hypotenuse |
| native_log | Ungefährer natürlicher Logarithmus |
| native_log10 | Logarithmus zur Basis 10 |
| native_log1p | Ungefährer natürlicher Logarithmus eines Werts plus 1 |
| native_log2 | Logarithmus zur Basis 2 |
| native_powr | Ungefähre positive Basis mit einem Exponenten potenziert |
| native_Rezepte | Annähernd reziprok |
| native_rootn | Ungefähre n-te Wurzel |
| native_rsqrt | Ungefähre Kehrzahl einer Quadratwurzel |
| native_sin | Ungefährer Sinus |
| native_sincos | Ungefährer Sinus und Kosinus |
| native_sinh | Ungefährer hyperbolischer Sinus |
| native_sinpi | Ungefährer Sinus einer Zahl multipliziert mit Pi |
| native_sqrt | Ungefähre Quadratwurzel |
| native_Hellbraun | Ungefährer Tangens |
| native_tanh | Ungefährer hyperbolischer Tangens |
| native_tanpi | Ungefährer Tangens einer Zahl multipliziert mit Pi |
| Weiternach | Nächste Gleitkommazahl |
| pow | Die Basis wird mit einem Exponenten potenziert. |
| Pown | Die Basis wird auf einen ganzzahligen Exponenten potenziert. |
| Powr | Positive Basis mit einem Exponenten potenziert |
| Radiant | Wandelt Grad in Bogenmaß um |
| Rest | Rest einer Division |
| Remquo | Rest und Quotient einer Division |
| RRT | Runden auf gleichmäßig |
| Rooten | N-te Wurzel |
| rund | Von null aufrunden |
| RSRand | Pseudozufallszahl |
| RSQRT | Kehrwert einer Quadratwurzel |
| Zeichen | Vorzeichen eines Werts |
| Sin | Sinus |
| Sincos | Sinus und Kosinus |
| Sinh | Hyperbolischer Sinus |
| Sinpi | Sinus einer Zahl multipliziert mit Pi |
| SQRT | Quadratwurzel |
| Schritt | 0, falls kleiner als ein Wert, andernfalls 1 |
| Hellbraun | Tangens |
| Tanh | Hyperbolischer Tangens |
| Tanpi | Tangens einer Zahl mit Pi |
| Tgamma | Gammafunktion |
| Trunk | Kürzt einen Gleitkommawert |
| Verworfene Funktionen | |
|---|---|
| RSClamp | Eingestellt. Wert auf einen Bereich beschränken |
| RSFrac | Eingestellt. Gibt den Bruchteil einer Gleitkommazahl zurück |
Konstanten
M_1_PI : 1 / Pi als 32-Bit-Gleitkommazahl
| Wert: 0,318309886183790671537767526745028724f |
Der Kehrwert von Pi als 32-Bit-Gleitkommazahl.
M_2_PI : 2 / Pi als 32-Bit-Gleitkommazahl
| Wert: 0,636619772367581343075535053490057448f |
2 geteilt durch Pi als 32-Bit-Gleitkommazahl.
M_2_SQRTPI : 2 / Qrt(pi) als 32-Bit-Gleitkommazahl
| Wert: 1,128379167095512573896158903121545172f |
2 geteilt durch die Quadratwurzel aus Pi als 32-Bit-Gleitkommazahl.
M_E : e als 32-Bit-Gleitkommazahl
| Wert: 2,718281828459045235360287471352662498f |
Die Zahl e, die Basis des natürlichen Logarithmus, als 32-Bit-Gleitkommazahl.
M_LN10 : log_e(10), als 32-Bit-Gleitkommazahl
| Wert: 2,302585092994045684017991454684364208f |
Der natürliche Logarithmus von 10 als 32-Bit-Gleitkommazahl.
M_LN2 : log_e(2) als 32-Bit-Gleitkommazahl
| Wert: 0,693147180559945309417232121458176568f |
Der natürliche Logarithmus von 2 als 32-Bit-Gleitkommazahl.
M_LOG10E : log_10(e) als 32-Bit-Gleitkommazahl
| Wert: 0,434294481903251827651128918916605082f |
Die Logarithmusbasis 10 von e als 32-Bit-Gleitkommazahl.
M_LOG2E : log_2(e) als 32-Bit-Gleitkommazahl
| Wert: 1,442695040888963407359924681001892137f |
Die Logarithmusbasis 2 von e als 32-Bit-Gleitkommazahl.
M_PI : Pi als 32-Bit-Gleitkommazahl
| Wert: 3,141592653589793238462643383279502884f |
Die Konstante Pi als 32-Bit-Gleitkommazahl.
M_PI_2 : Pi / 2 als 32-Bit-Gleitkommazahl
| Wert: 1,570796326794896619231321691639751442f |
Pi geteilt durch 2 als 32-Bit-Gleitkommazahl.
M_PI_4 : Pi / 4 als 32-Bit-Gleitkommazahl
| Wert: 0,785398163397448309615660845819875721f |
Pi geteilt durch 4 als 32-Bit-Gleitkommazahl.
M_SQRT1_2 : 1 / sqrt(2) als 32-Bit-Gleitkommazahl
| Wert: 0,707106781186547524400844362104849039f |
Die Umkehr der Quadratwurzel von 2 als 32-Bit-Gleitkommazahl.
M_SQRT2 : Quadratwurzel(2) als 32-Bit-Gleitkommazahl
| Wert: 1,414213562373095048801688724209698079f |
Die Quadratwurzel von 2 als 32-Bit-Gleitkommazahl.
Funktionen
abs : Absoluter Wert einer Ganzzahl
| 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); |
Gibt den Absolutwert einer Ganzzahl zurück.
Verwenden Sie für Gleitkommazahlen fabs().
acos : Inverser Kosinus
| float acos(float v); | |
| float2 acos(float2 v); | |
| float3 acos(float3 v); | |
| float4 acos(float4 v); | |
| half acos(half v); | In API-Level 24 hinzugefügt |
| half2 acos(half2 v); | In API-Level 24 hinzugefügt |
| half3 acos(half3 v); | In API-Level 24 hinzugefügt |
| half4 acos(half4 v); | In API-Level 24 hinzugefügt |
Gibt den Arkuskosinus im Bogenmaß zurück.
Siehe auch native_acos().
acosh : Inverser hyperbolischer Kosinus
| float acosh(float v); | |
| float2 acosh(float2 v); | |
| float3 acosh(float3 v); | |
| float4 acosh(float4 v); | |
| half acosh(half v); | In API-Level 24 hinzugefügt |
| half2 acosh(half2 v); | In API-Level 24 hinzugefügt |
| half3 acosh(half3 v); | In API-Level 24 hinzugefügt |
| half4 acosh(half4 v); | In API-Level 24 hinzugefügt |
Gibt den umgekehrten hyperbolischen Kosinus in Radiant zurück.
Siehe auch native_acosh().
acospi : Inverser Kosinus geteilt durch Pi
| float acospi(float v); | |
| float2 acospi(float2 v); | |
| float3 acospi(float3 v); | |
| float4 acospi(float4 v); | |
| half acospi(half v); | In API-Level 24 hinzugefügt |
| half2 acospi(half2 v); | In API-Level 24 hinzugefügt |
| half3 acospi(half3 v); | In API-Level 24 hinzugefügt |
| half4 acospi(half4 v); | In API-Level 24 hinzugefügt |
Gibt den Arkuskosinus im Bogenmaß geteilt durch Pi zurück.
Um einen in Grad gemessenen Arkuskosinus zu erhalten, verwenden Sie acospi(a) * 180.f.
Siehe auch native_acospi().
asin : Umkehrsinus
| float asin(float v); | |
| float2 asin(float2 v); | |
| float3 asin(float3 v); | |
| float4 asin(float4 v); | |
| half asin(half v); | In API-Level 24 hinzugefügt |
| half2 asin(half2 v); | In API-Level 24 hinzugefügt |
| half3 asin(half3 v); | In API-Level 24 hinzugefügt |
| half4 asin(half4 v); | In API-Level 24 hinzugefügt |
Gibt den Arkussinus im Bogenmaß zurück.
Siehe auch native_asin().
asinh : Inverser hyperbolischer Sinus
| float asinh(float v); | |
| float2 asinh(float2 v); | |
| float3 asinh(float3 v); | |
| float4 asinh(float4 v); | |
| half asinh(half v); | In API-Level 24 hinzugefügt |
| half2 asinh(half2 v); | In API-Level 24 hinzugefügt |
| half3 asinh(half3 v); | In API-Level 24 hinzugefügt |
| half4 asinh(half4 v); | In API-Level 24 hinzugefügt |
Gibt den umgekehrten hyperbolischen Sinus in Radiant zurück.
Siehe auch native_asinh().
asinpi : Inverser Sinus geteilt durch Pi
| float asinpi(Gleitkommazahl v); | |
| float2 asinpi(float2 v); | |
| float3 asinpi(float3 v); | |
| float4 asinpi(float4 v); | |
| half asinpi(halb V); | In API-Level 24 hinzugefügt |
| half2 asinpi(half2 v); | In API-Level 24 hinzugefügt |
| half3 asinpi(half3 v); | In API-Level 24 hinzugefügt |
| half4 asinpi(half4 v); | In API-Level 24 hinzugefügt |
Gibt den Arkussinus im Bogenmaß geteilt durch Pi zurück.
Um einen umgekehrten Sinus in Grad zu erhalten, verwenden Sie asinpi(a) * 180.f.
Siehe auch native_asinpi().
atan : Umgekehrter Tangens
| float atan(float v); | |
| float2 atan(float2 v); | |
| float3 atan(float3 v); | |
| float4 atan(float4 v); | |
| half atan(halb v); | In API-Level 24 hinzugefügt |
| half2 atan(half2 v); | In API-Level 24 hinzugefügt |
| half3 atan(half3 v); | In API-Level 24 hinzugefügt |
| half4 atan(half4 v); | In API-Level 24 hinzugefügt |
Gibt den umgekehrten Tangens in Radiant zurück.
Siehe auch native_atan().
atan2 : Umkehrter Tangens eines Verhältnisses
| float atan2(Gleitkommazahl, Gleitkommazahl; Nenner); | |
| Gleitkommazahl2 atan2(Gleitkomma2-Zähler, Nenner Gleitkomma2); | |
| FLOAT3 atan2(Gleitkommazahl3-Zähler, Nenner Gleitkomma3); | |
| Gleitkommazahl4 atan2(Gleitkommazahl4-Zähler, Nenner Gleitkomma4); | |
| half atan2(halber Zähler, halbe Nenner); | In API-Level 24 hinzugefügt |
| half2 atan2(half2 Zähler, half2 Nenner); | In API-Level 24 hinzugefügt |
| half3 atan2(half3-Zähler, half3 im Nenner); | In API-Level 24 hinzugefügt |
| half4 atan2(half4 Zähler, half4 Nenner); | In API-Level 24 hinzugefügt |
Parameter
| Zähler | Zähler. |
|---|---|
| Nenner | Nenner. Kann 0 sein. |
Gibt den umgekehrten Tangens von (numerator / denominator) in Radiant zurück.
Siehe auch native_atan2().
atan2pi : Umkehrter Tangens eines Verhältnisses, geteilt durch Pi
| float atan2pi(Gleitkommazahl, Gleitkommazahl; Nenner); | |
| Gleitkommazahl2 atan2pi(Gleitkomma2-Zähler, Nenner Gleitkomma2); | |
| Gleitkommazahl3 atan2pi(Gleitkommazahl3-Zähler, Nenner Gleitkomma3); | |
| Gleitkommazahl4 atan2pi(Gleitkommazahl4-Zähler, Nenner Gleitkomma4); | |
| half atan2pi(halber Zähler, halbe Nenner); | In API-Level 24 hinzugefügt |
| half2 atan2pi(half2 Zähler, half2 Nenner); | In API-Level 24 hinzugefügt |
| half3 atan2pi(half3 Zähler, half3 im Nenner); | In API-Level 24 hinzugefügt |
| half4 atan2pi(half4 Zähler, half4 Nenner); | In API-Level 24 hinzugefügt |
Parameter
| Zähler | Zähler. |
|---|---|
| Nenner | Nenner. Kann 0 sein. |
Gibt den umgekehrten Tangens von (numerator / denominator) im Bogenmaß geteilt durch Pi zurück.
Um einen in Grad gemessenen umgekehrten Tangens zu erhalten, verwenden Sie atan2pi(n, d) * 180.f.
Siehe auch native_atan2pi().
atanh : Umgekehrter hyperbolischer Tangens
| float atanh(float v); | |
| float2 atanh(float2 v); | |
| FLOAT3 atanh(FLOAT3 v); | |
| float4 atanh(float4 v); | |
| half atanh(half v); | In API-Level 24 hinzugefügt |
| half2 atanh(half2 v); | In API-Level 24 hinzugefügt |
| half3 atanh(half3 v); | In API-Level 24 hinzugefügt |
| half4 atanh(half4 v); | In API-Level 24 hinzugefügt |
Gibt den umgekehrten hyperbolischen Tangens in Radiant zurück.
Siehe auch native_atanh().
atanpi : Umgekehrter Tangens geteilt durch Pi
| float atanpi(float v); | |
| float2 atanpi(float2 v); | |
| float3 atanpi(float3 v); | |
| float4 Atanpi(float4 v); | |
| half atanpi(half v); | In API-Level 24 hinzugefügt |
| half2 atanpi(half2 v); | In API-Level 24 hinzugefügt |
| half3 Atanpi(half3 v); | In API-Level 24 hinzugefügt |
| half4 Atanpi(half4 v); | In API-Level 24 hinzugefügt |
Gibt den umgekehrten Tangens im Bogenmaß geteilt durch Pi zurück.
Um einen in Grad gemessenen umgekehrten Tangens zu erhalten, verwenden Sie atanpi(a) * 180.f.
Siehe auch native_atanpi().
cbrt: : Kubikwurzel
| float cbrt(float v); | |
| float2 cbrt(float2 v); | |
| float3 cbrt(float3 v); | |
| float4 cbrt(float4 v); | |
| half cbrt(halb V); | In API-Level 24 hinzugefügt |
| half2 cbrt(half2 v); | In API-Level 24 hinzugefügt |
| half3 cbrt(half3 v); | In API-Level 24 hinzugefügt |
| half4 cbrt(half4 v); | In API-Level 24 hinzugefügt |
Gibt die Kubikwurzel zurück.
Siehe auch native_cbrt().
ceil: Kleinste Ganzzahl, die nicht kleiner als ein Wert ist
| float ceil(float v); | |
| float2 ceil(float2 v); | |
| float3 ceil(float3 v); | |
| float4 ceil(float4 v); | |
| half ceil(half v); | In API-Level 24 hinzugefügt |
| half2 ceil(half2 v); | In API-Level 24 hinzugefügt |
| half3 ceil(half3 v); | In API-Level 24 hinzugefügt |
| half4 ceil(half4 v); | In API-Level 24 hinzugefügt |
Gibt die kleinste Ganzzahl zurück, die nicht kleiner als ein Wert ist.
Beispiel: ceil(1.2f) gibt 2.f zurück und ceil(-1.2f) gibt -1.f zurück.
Siehe auch floor().
clamp : Einen Wert auf einen Bereich beschränken
| char clamp(char value, char min_value, char max_value); | In API-Level 19 hinzugefügt |
| char2 clamp(char2 value, char min_value, char max_value); | In API-Level 19 hinzugefügt |
| char2 clamp(char2 value, char2 min_value, char2 max_value); | In API-Level 19 hinzugefügt |
| char3 clamp(char3 value, char min_value, char max_value); | In API-Level 19 hinzugefügt |
| char3 clamp(char3 value, char3 min_value, char3 max_value); | In API-Level 19 hinzugefügt |
| char4 clamp(char4 value, char min_value, char max_value); | In API-Level 19 hinzugefügt |
| char4 clamp(char4 value, char4 min_value, char4 max_value); | In API-Level 19 hinzugefügt |
| float clamp(float value, float min_value, float max_value); | |
| float2 clamp(float2 value, float min_value, float max_value); | |
| float2 clamp(float2 value, float2 min_value, float2 max_value); | |
| Gleitkommazahl clamp(float3 value, float min_value, float max_value); | |
| float3 clamp(float3 value, float3 min_value, float3 max_value); | |
| float4 clamp(float4 value, float min_value, float max_value); | |
| float4 clamp(float4 value, float4 min_value, float4 max_value); | |
| half clamp(halb Wert, half min_value, half max_value); | In API-Level 24 hinzugefügt |
| half2 clamp(half2 value, half min_value, half max_value); | In API-Level 24 hinzugefügt |
| half2 clamp(half2 value, half2 min_value, half2 max_value); | In API-Level 24 hinzugefügt |
| half3 clamp(half3 value, half min_value, half max_value); | In API-Level 24 hinzugefügt |
| half3 clamp(half3 value, half3 min_value, half3 max_value); | In API-Level 24 hinzugefügt |
| half4 clamp(half4 value, half min_value, half max_value); | In API-Level 24 hinzugefügt |
| half4 clamp(half4 value, half4 min_value, half4 max_value); | In API-Level 24 hinzugefügt |
| int clamp(int value, int min_value, int max_value); | In API-Level 19 hinzugefügt |
| int2 clamp(int2 value, int min_value, int max_value); | In API-Level 19 hinzugefügt |
| int2 clamp(int2 value, int2 min_value, int2 max_value); | In API-Level 19 hinzugefügt |
| int3 clamp(int3 value, int min_value, int max_value); | In API-Level 19 hinzugefügt |
| int3 clamp(int3 value, int3 min_value, int3 max_value); | In API-Level 19 hinzugefügt |
| int4 clamp(int4 value, int min_value, int max_value); | In API-Level 19 hinzugefügt |
| int4 clamp(int4 value, int4 min_value, int4 max_value); | In API-Level 19 hinzugefügt |
| long clamp(long value, long min_value, long max_value); | In API-Level 19 hinzugefügt |
| long2 clamp(long2 value, long min_value, long max_value); | In API-Level 19 hinzugefügt |
| long2 clamp(long2 value, long2 min_value, long2 max_value); | In API-Level 19 hinzugefügt |
| long3 clamp(long3 value, long min_value, long max_value); | In API-Level 19 hinzugefügt |
| long3 clamp(long3 value, long3 min_value, long3 max_value); | In API-Level 19 hinzugefügt |
| long4 clamp(long4 value, long min_value, long max_value); | In API-Level 19 hinzugefügt |
| long4 clamp(long4 value, long4 min_value, long4 max_value); | In API-Level 19 hinzugefügt |
| short clamp(short value, short min_value, short max_value); | In API-Level 19 hinzugefügt |
| short2 clamp(short2 value, short min_value, kurz max_value); | In API-Level 19 hinzugefügt |
| short2 clamp(short2 value, short2 min_value, short2 max_value); | In API-Level 19 hinzugefügt |
| short3 clamp(short3 value, short min_value, short max_value); | In API-Level 19 hinzugefügt |
| short3 clamp(short3 value, short3 min_value, short3 max_value); | In API-Level 19 hinzugefügt |
| short4 clamp(short4-Wert, kurzer min_Wert, kurzer max_Wert); | In API-Level 19 hinzugefügt |
| short4 clamp(short4 value, short4 min_value, short4 max_value); | In API-Level 19 hinzugefügt |
| uchar clamp(uchar value, uchar min_value, uchar max_value); | In API-Level 19 hinzugefügt |
| uchar2 clamp(uchar2 value, uchar min_value, uchar max_value); | In API-Level 19 hinzugefügt |
| uchar2 clamp(uchar2 value, uchar2 min_value, uchar2 max_value); | In API-Level 19 hinzugefügt |
| uchar3 clamp(uchar3 value, uchar min_value, uchar max_value); | In API-Level 19 hinzugefügt |
| uchar3 clamp(uchar3 value, uchar3 min_value, uchar3 max_value); | In API-Level 19 hinzugefügt |
| uchar4 clamp(uchar4 value, uchar min_value, uchar max_value); | In API-Level 19 hinzugefügt |
| uchar4 clamp(uchar4 value, uchar4 min_value, uchar4 max_value); | In API-Level 19 hinzugefügt |
| uint clamp(uint value, uint min_value, uint max_value); | In API-Level 19 hinzugefügt |
| uint2 clamp(uint2 value, uint min_value, uint max_value); | In API-Level 19 hinzugefügt |
| uint2 clamp(uint2 value, uint2 min_value, uint2 max_value); | In API-Level 19 hinzugefügt |
| uint3 clamp(uint3 value, uint min_value, uint max_value); | In API-Level 19 hinzugefügt |
| uint3 clamp(uint3 value, uint3 min_value, uint3 max_value); | In API-Level 19 hinzugefügt |
| uint4 clamp(uint4 value, uint min_value, uint max_value); | In API-Level 19 hinzugefügt |
| uint4 clamp(uint4 value, uint4 min_value, uint4 max_value); | In API-Level 19 hinzugefügt |
| ulong clamp(ulong value, ulong min_value, ulong max_value); | In API-Level 19 hinzugefügt |
| ulong2 clamp(ulong2 value, ulong min_value, ulong max_value); | In API-Level 19 hinzugefügt |
| ulong2 clamp(ulong2 value, ulong2 min_value, ulong2 max_value); | In API-Level 19 hinzugefügt |
| ulong3 clamp(ulong3 value, ulong min_value, ulong max_value); | In API-Level 19 hinzugefügt |
| ulong3 clamp(ulong3 value, ulong3 min_value, ulong3 max_value); | In API-Level 19 hinzugefügt |
| ulong4 clamp(ulong4 value, ulong min_value, ulong max_value); | In API-Level 19 hinzugefügt |
| ulong4 clamp(ulong4 value, ulong4 min_value, ulong4 max_value); | In API-Level 19 hinzugefügt |
| ushort clamp(ushort value, ushort min_value, ushort max_value); | In API-Level 19 hinzugefügt |
| ushort2 clamp(ushort2 value, ushort min_value, ushort max_value); | In API-Level 19 hinzugefügt |
| ushort2 clamp(ushort2 value, ushort2 min_value, ushort2 max_value); | In API-Level 19 hinzugefügt |
| ushort3 clamp(ushort3 value, ushort min_value, ushort max_value); | In API-Level 19 hinzugefügt |
| ushort3 clamp(ushort3 value, ushort3 min_value, ushort3 max_value); | In API-Level 19 hinzugefügt |
| ushort4 clamp(ushort4 value, ushort min_value, ushort max_value); | In API-Level 19 hinzugefügt |
| ushort4 clamp(ushort4 value, ushort4 min_value, ushort4 max_value); | In API-Level 19 hinzugefügt |
Parameter
| value | Wert, der begrenzt werden soll. |
|---|---|
| Minimalwert | Untergrenze, ein skalarer oder übereinstimmender Vektor. |
| Maximalwert | Obergrenze, muss dem Typ „Niedrig“ entsprechen. |
Bindet einen Wert an eine angegebene Höchst- und Untergrenze. clamp() gibt min_value zurück, wenn Wert < min_value, max_value wenn Wert > max_value, andernfalls Wert.
Es gibt zwei Varianten von Clamp: In der einen sind Minimal- und Maximalwert Skalare, die auf alle Einträge des Werts angewendet werden. In der anderen sind Minimal- und Maximalwert ebenfalls Vektoren.
Wenn „min_value“ größer als „max_value“ ist, sind die Ergebnisse nicht definiert.
clz : Anzahl der führenden 0 Bit
| char clz(char value); | |
| char2 clz(char2-Wert); | |
| char3 clz(char3-Wert); | |
| char4 clz(char4-Wert); | |
| int clz(int value); | |
| int2 clz(int2-Wert); | |
| int3 clz(int3-Wert); | |
| int4 clz(int4-Wert); | |
| short clz(short value); | |
| short2 clz(short2-Wert); | |
| short3 clz(short3-Wert); | |
| short4 clz(short4-Wert); | |
| uchar clz(uchar-Wert); | |
| uchar2 clz(uchar2-Wert); | |
| uchar3 clz(uchar3-Wert); | |
| uchar4 clz(uchar4-Wert); | |
| uint clz(uint-Wert); | |
| uint2 clz(uint2-Wert); | |
| uint3 clz(uint3-Wert); | |
| uint4 clz(uint4-Wert); | |
| ushort clz(ushort-Wert); | |
| ushort2 clz(ushort2-Wert); | |
| ushort3 clz(ushort3-Wert); | |
| ushort4 clz(ushort4-Wert); |
Gibt die Anzahl der führenden 0-Bits in einem Wert zurück.
clz((char)0x03) gibt beispielsweise 6 zurück.
copysign : Hiermit wird das Vorzeichen einer Zahl in eine andere kopiert.
| float copysign(float magnitude_value, float_value); | |
| float2 copysign(float2 magnitude_value, float2 Vorzeichenwert); | |
| float3 copysign(float3 magnitude_value, Gleitkommazahl3 sign_value); | |
| Gleitkommazahl4 copysign(float4 magnitude_value, float4 sign_value); | |
| half copysign(half magnitude_value, half sign_value); | In API-Level 24 hinzugefügt |
| half2 copysign(half2 magnitude_value, half2 sign_value); | In API-Level 24 hinzugefügt |
| half3 copysign(half3 magnitude_value, half3 sign_value); | In API-Level 24 hinzugefügt |
| half4 copysign(half4 magnitude_value, half4 sign_value); | In API-Level 24 hinzugefügt |
Kopiert das Vorzeichen von sign_value in magnitude_value.
Der zurückgegebene Wert ist entweder „magnitude_value“ oder „-magnitude_value“.
Beispiel: copysign(4.0f, -2.7f) gibt -4.0f und copysign(-4.0f, 2.7f) 4.0f zurück.
cos: Kosinus
| float cos(float v); | |
| float2 cos(float2 v); | |
| float3 cos(float3 v); | |
| float4 cos(float4 v); | |
| half cos(half v); | In API-Level 24 hinzugefügt |
| half2 cos(half2 v); | In API-Level 24 hinzugefügt |
| half3 cos(half3 v); | In API-Level 24 hinzugefügt |
| half4 cos(half4 v); | In API-Level 24 hinzugefügt |
Gibt den Kosinus eines Winkels zurück, gemessen im Bogenmaß.
Siehe auch native_cos().
cosh : Hypebolischer Kosinus
| float cosh(float v); | |
| float2 cosh(float2 v); | |
| float3 cosh(float3 v); | |
| float4 cosh(float4 v); | |
| half cosh(half v); | In API-Level 24 hinzugefügt |
| half2 cosh(half2 v); | In API-Level 24 hinzugefügt |
| half3 cosh(half3 v); | In API-Level 24 hinzugefügt |
| half4 cosh(half4 v); | In API-Level 24 hinzugefügt |
Gibt den hypebolischen Kosinus von v zurück, wobei v in Radiant gemessen wird.
Siehe auch native_cosh().
cospi : Kosinus einer Zahl multipliziert mit Pi
| float cospi(float v); | |
| float2 cospi(float2 v); | |
| float3 cospi(float3 v); | |
| float4 cospi(float4 v); | |
| half cospi(half v); | In API-Level 24 hinzugefügt |
| half2 cospi(half2 v); | In API-Level 24 hinzugefügt |
| half3 cospi(half3 v); | In API-Level 24 hinzugefügt |
| half4 cospi(half4 v); | In API-Level 24 hinzugefügt |
Gibt den Kosinus von (v * pi) zurück, wobei (v * pi) in Radiant gemessen wird.
Um den Kosinus eines in Grad gemessenen Werts zu erhalten, rufen Sie cospi(v / 180.f) auf.
Siehe auch native_cospi().
Grad : Wandelt Bogenmaß in Grad um
| float Grad(float v); | |
| float2 Grad(float2 v); | |
| Gleitkommazahl3 Grad(Gleitkommazahl3 v); | |
| float4 Grad(float4 v); | |
| half degrees(halb v); | In API-Level 24 hinzugefügt |
| half2 Grad(half2 v); | In API-Level 24 hinzugefügt |
| half3 Grad(half3 v); | In API-Level 24 hinzugefügt |
| half4 Grad(half4 v); | In API-Level 24 hinzugefügt |
Wandelt von Radianten in Grad um.
erf : Mathematische Fehlerfunktion
| float erf(float v); | |
| float2 erf(float2 v); | |
| float3 erf(float3 v); | |
| float4 erf(float4 v); | |
| half erf(half v); | In API-Level 24 hinzugefügt |
| half2 erf(half2 v); | In API-Level 24 hinzugefügt |
| half3 erf(half3 v); | In API-Level 24 hinzugefügt |
| half4 erf(half4 v); | In API-Level 24 hinzugefügt |
Gibt die Fehlerfunktion zurück.
erfc: Mathematische komplementäre Fehlerfunktion
| float erfc(float v); | |
| float2 erfc(float2 v); | |
| float3 erfc(float3 v); | |
| float4 erfc(float4 v); | |
| half erfc(halb V); | In API-Level 24 hinzugefügt |
| half2 erfc(half2 v); | In API-Level 24 hinzugefügt |
| half3 erfc(half3 v); | In API-Level 24 hinzugefügt |
| half4 erfc(half4 v); | In API-Level 24 hinzugefügt |
Gibt die komplementäre Fehlerfunktion zurück.
exp : e wird mit einer Zahl erhöht
| float exp(float v); | |
| float2 exp(float2 v); | |
| float3 exp(float3 v); | |
| float4 exp(float4 v); | |
| half exp(half v); | In API-Level 24 hinzugefügt |
| half2 exp(half2 v); | In API-Level 24 hinzugefügt |
| half3 exp(half3 v); | In API-Level 24 hinzugefügt |
| half4 exp(half4 v); | In API-Level 24 hinzugefügt |
Gibt e auf v an, d.h. e ^ v.
Siehe auch native_exp().
exp10 : 10 zu einer Zahl erhöht
| Gleitkommazahl exp10(Gleitkommazahl v); | |
| float2 exp10(float2 v); | |
| float3 exp10(float3 v); | |
| float4 exp10(float4 v); | |
| half exp10(halb v); | In API-Level 24 hinzugefügt |
| half2 exp10(half2 v); | In API-Level 24 hinzugefügt |
| half3 exp10(half3 v); | In API-Level 24 hinzugefügt |
| half4 exp10(half4 v); | In API-Level 24 hinzugefügt |
Gibt 10 auf v angehoben zurück, zum Beispiel 10.f ^ v.
Siehe auch native_exp10().
exp2 : 2 zu einer Zahl erhöht
| Gleitkommazahl exp2(Gleitkommazahl v); | |
| float2 exp2(float2 v); | |
| float3 exp2(float3 v); | |
| float4 exp2(float4 v); | |
| half exp2(halb v); | In API-Level 24 hinzugefügt |
| half2 exp2(half2 v); | In API-Level 24 hinzugefügt |
| half3 exp2(half3 v); | In API-Level 24 hinzugefügt |
| half4 exp2(half4 v); | In API-Level 24 hinzugefügt |
Gibt 2 auf v an, d.h. 2.f ^ v.
Siehe auch native_exp2().
expm1 : e wird auf eine Zahl minus eins erhöht
| float expm1(float v); | |
| float2 expm1(float2 v); | |
| float3 expm1(float3 v); | |
| float4 expm1(float4 v); | |
| half expm1(halb V); | In API-Level 24 hinzugefügt |
| half2 expm1(half2 v); | In API-Level 24 hinzugefügt |
| half3 expm1(half3 v); | In API-Level 24 hinzugefügt |
| half4 expm1(half4 v); | In API-Level 24 hinzugefügt |
Gibt e zurück, die auf v minus 1 angehoben wird, d.h. (e ^ v) - 1.
Siehe auch native_expm1().
fabs : Absoluter Wert einer Gleitkommazahl
| float fabs(float v); | |
| float2 fabs(float2 v); | |
| float3 fabs(float3 v); | |
| float4 fabs(float4 v); | |
| half fabs(halb V); | In API-Level 24 hinzugefügt |
| half2 fabs(half2 v); | In API-Level 24 hinzugefügt |
| half3 fabs(half3 v); | In API-Level 24 hinzugefügt |
| half4 fabs(half4 v); | In API-Level 24 hinzugefügt |
Gibt den absoluten Wert der Gleitkommazahl v zurück.
Verwenden Sie für Ganzzahlen abs().
fdim : Positive Differenz zwischen zwei Werten
| 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(halb a, halb b); | In API-Level 24 hinzugefügt |
| half2 fdim(half2 a, hälf2 b); | In API-Level 24 hinzugefügt |
| half3 fdim(half3 a, half3 b); | In API-Level 24 hinzugefügt |
| half4 fdim(half4 a, hälf4 b); | In API-Level 24 hinzugefügt |
Gibt die positive Differenz zwischen zwei Werten zurück.
Wenn a > b, wird (a - b) zurückgegeben, andernfalls 0f.
floor : Kleinste Ganzzahl, die nicht größer als ein Wert ist
| Gleitkommazahl(Gleitkommazahl v); | |
| float2 floor(float2 v); | |
| float3 floor(float3 v); | |
| float4 floor(float4 v); | |
| halffloor(halb V); | In API-Level 24 hinzugefügt |
| half2 floor(half2 v); | In API-Level 24 hinzugefügt |
| half3 floor(half3 v); | In API-Level 24 hinzugefügt |
| half4 floor(half4 v); | In API-Level 24 hinzugefügt |
Gibt die kleinste Ganzzahl zurück, die nicht größer als ein Wert ist.
Beispiel: floor(1.2f) gibt 1.f zurück und floor(-1.2f) gibt -2.f zurück.
Siehe auch ceil().
fma : Multiplizieren und addieren
| float fma(float multiplicand1, float multiplicand2, float offset); | |
| float2 fma(float2 multiplicand1, float2 multiplicand2, float2 offset); | |
| float3 fma(float3 multiplicand1, float3 multiplicand2, float3 offset); | |
| float4 fma(float4 multiplicand1, float4 multiplicand2, float4 offset); | |
| half fma(halb multiplicand1, halb multiplicand2, halb Offset); | In API-Level 24 hinzugefügt |
| half2 fma(half2 multiplicand1, half2 multiplicand2, half2 offset); | In API-Level 24 hinzugefügt |
| half3 fma(half3 multiplicand1, half3 multiplicand2, half3 Offset); | In API-Level 24 hinzugefügt |
| half4 fma(half4 multiplicand1, half4 multiplicand2, half4 offset); | In API-Level 24 hinzugefügt |
Multiplizieren und addieren. Gibt (multiplicand1 * multiplicand2) + offset zurück.
Diese Funktion ähnelt der Funktion mad(). „fma()“ behält die volle Genauigkeit des multiplizierten Ergebnisses bei und rundet nur nach der Addition. mad() rundet nach der Multiplikation und Addition. Diese zusätzliche Genauigkeit wird im Modus „rs_fp_relaxed“ nicht garantiert.
fmax : Maximal zwei Gleitkommazahlen
| Gleitkommazahl fmax(Gleitkommazahl a, Gleitkommazahl b); | |
| Gleitkommazahl2 fmax(Gleitkommazahl2 a, Gleitkommazahl b); | |
| float2 fmax(float2 a, float2 b); | |
| Gleitkommazahl3 fmax(Gleitkommazahl3 a, Gleitkommazahl b); | |
| float3 fmax(float3 a, float3 b); | |
| Gleitkommazahl4 fmax(FLOAT4 a, Gleitkommazahl b); | |
| float4 fmax(float4 a, float4 b); | |
| half fmax(halb a, halb b); | In API-Level 24 hinzugefügt |
| half2 fmax(half2 a, halb b); | In API-Level 24 hinzugefügt |
| half2 fmax(half2 a, hälf2 b); | In API-Level 24 hinzugefügt |
| half3 fmax(half3 a, halb b); | In API-Level 24 hinzugefügt |
| half3 fmax(half3 a, hälf3 b); | In API-Level 24 hinzugefügt |
| half4 fmax(half4 a, halb b); | In API-Level 24 hinzugefügt |
| half4 fmax(half4 a, half4 b); | In API-Level 24 hinzugefügt |
Gibt das Maximum von a und b zurück, also (a < b ? b : a).
Die Funktion max() gibt identische Ergebnisse zurück, kann aber auf mehr Datentypen angewendet werden.
fmin : mindestens zwei Gleitkommazahlen
| Gleitkommazahl fmin(Gleitkommazahl a, Gleitkommazahl b); | |
| float2 fmin(float2 a, float b); | |
| float2 fmin(float2 a, float2 b); | |
| float3 fmin(float3 a, float b); | |
| float3 fmin(float3 a, float3 b); | |
| float4 fmin(float4 a, float b); | |
| float4 fmin(float4 a, float4 b); | |
| half fmin(halb a, halb b); | In API-Level 24 hinzugefügt |
| half2 fmin(half2 a, halb b); | In API-Level 24 hinzugefügt |
| half2 fmin(half2 a, hälf2 b); | In API-Level 24 hinzugefügt |
| half3 fmin(half3 a, halb b); | In API-Level 24 hinzugefügt |
| half3 fmin(half3 a, hälf3 b); | In API-Level 24 hinzugefügt |
| half4 fmin(half4 a, halb b); | In API-Level 24 hinzugefügt |
| half4 fmin(half4 a, hälf4 b); | In API-Level 24 hinzugefügt |
Gibt das Minimum von a und b zurück, also (a > b ? b : a).
Die Funktion min() gibt identische Ergebnisse zurück, kann aber auf mehr Datentypen angewendet werden.
fmod: Modulo
| float fmod(Gleitkommazahl, Gleitkommazahl) | |
| float2 fmod(float2 Zähler, float2 Nenner); | |
| float3 fmod(float3 Zähler, float3 Nenner); | |
| float4 fmod(float4 Zähler, float4 Nenner); | |
| half fmod(Half Zähler, Half Nenner); | In API-Level 24 hinzugefügt |
| half2 fmod(half2 Zähler, half2 Nenner); | In API-Level 24 hinzugefügt |
| half3 fmod(half3 Zähler, half3 Nenner); | In API-Level 24 hinzugefügt |
| half4 fmod(half4 Zähler, half4 Nenner); | In API-Level 24 hinzugefügt |
Gibt den Rest von (Zähler / Nenner) zurück, wobei der Quotient gegen null gerundet wird.
Die Funktion remainder() ist ähnlich, rundet aber in Richtung der nächsten Ganzzahl.
Beispiel: fmod(-3.8f, 2.f) gibt -1.8f (-3.8f - -1.f * 2.f) zurück, während remainder(-3.8f, 2.f) 0.2f (-3.8f - -2.f * 2.f) zurückgibt.
fract : Positiver Bruchteil
| float fract(float v); | |
| Float fract(FLOAT v, Gleitkommazahl* Etage); | |
| 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(half v); | In API-Level 24 hinzugefügt |
| halb Bruch(halb V, Hälft* Stock); | In API-Level 24 hinzugefügt |
| half2 fract(half2 v); | In API-Level 24 hinzugefügt |
| half2 Bruch(half2 V, half2* Stock); | In API-Level 24 hinzugefügt |
| half3 fract(half3 v); | In API-Level 24 hinzugefügt |
| half3 Fakt(half3 v, half3* floor); | In API-Level 24 hinzugefügt |
| half4 fract(half4 v); | In API-Level 24 hinzugefügt |
| half4 Fakt(half4 v, half4* floor); | In API-Level 24 hinzugefügt |
Parameter
| v | Eingabewert. |
|---|---|
| Stockw. | Wenn der Wert nicht null ist, wird *floor auf den Mindestpreis von v gesetzt. |
Gibt den positiven Bruchteil von v zurück, also v - floor(v).
fract(1.3f, &val) gibt beispielsweise 0.3f zurück und setzt val auf 1.f.
fract(-1.3f, &val) gibt 0.7f zurück und setzt val auf -2.f.
frexp : Binäre Mantisse und Exponent
| float frexp(float v, int* Exponent); | |
| float2 frexp(float2 v, int2*-Exponent); | |
| float3 frexp(float3 v, int3*-Exponent); | |
| float4 frexp(float4 v, int4*-Exponent); | |
| half frexp(half v, int* Exponent); | In API-Level 24 hinzugefügt |
| half2 frexp(half2 v, int2*-Exponent); | In API-Level 24 hinzugefügt |
| half3 frexp(half3 v, int3* Exponent); | In API-Level 24 hinzugefügt |
| half4 frexp(half4 v, int4* Exponent); | In API-Level 24 hinzugefügt |
Parameter
| v | Eingabewert. |
|---|---|
| Exponent | Wenn der Exponent nicht null ist, wird *Exponent auf den Exponent von v gesetzt. |
half_recip : Reziprok, berechnet auf 16-Bit-Genauigkeit
| float half_recip(float v); | In API-Level 17 hinzugefügt |
| float2 halb_recip(float2 v); | In API-Level 17 hinzugefügt |
| float3 half_recip(float3 v); | In API-Level 17 hinzugefügt |
| float4 half_recip(float4 v); | In API-Level 17 hinzugefügt |
Gibt die ungefähre Kehrzahl eines Werts zurück.
Die Genauigkeit entspricht der eines 16-Bit-Gleitkommawerts.
Siehe auch native_recip().
half_rsqrt : Kehrwert einer Quadratwurzel, berechnet auf 16-Bit-Genauigkeit
| float half_rsqrt(float v); | In API-Level 17 hinzugefügt |
| float2 half_rsqrt(float2 v); | In API-Level 17 hinzugefügt |
| float3 half_rsqrt(float3 v); | In API-Level 17 hinzugefügt |
| float4 half_rsqrt(float4 v); | In API-Level 17 hinzugefügt |
Gibt den ungefähren Wert von (1.f / sqrt(value)) zurück.
Die Genauigkeit entspricht der eines 16-Bit-Gleitkommawerts.
Siehe auch rsqrt(), native_rsqrt().
half_sqrt : Quadratwurzel, berechnet auf 16-Bit-Genauigkeit
| float Half_sqrt(float v); | In API-Level 17 hinzugefügt |
| float2 half_sqrt(float2 v); | In API-Level 17 hinzugefügt |
| float3 half_sqrt(float3 v); | In API-Level 17 hinzugefügt |
| float4 half_sqrt(float4 v); | In API-Level 17 hinzugefügt |
Gibt die ungefähre Quadratwurzel eines Werts zurück.
Die Genauigkeit entspricht der eines 16-Bit-Gleitkommawerts.
Siehe auch sqrt(), native_sqrt().
hypot: : Hypotenuse
| float hypot(float a, float b); | |
| float2 hypot(float2 a, float2 b); | |
| float3 hypot(float3 a, float3 b); | |
| float4 hypot(float4 a, float4 b); | |
| half Hypot(half a, half b); | In API-Level 24 hinzugefügt |
| half2 hypot(half2 a, half2 b); | In API-Level 24 hinzugefügt |
| half3 Hypot(half3 a, half3 b); | In API-Level 24 hinzugefügt |
| half4 hypot(half4 a, half4 b); | In API-Level 24 hinzugefügt |
Gibt die Hypotenuse zurück, d.h. sqrt(a * a + b * b).
Siehe auch native_hypot().
ilogb : Basis-2-Exponent
| int ilogb(float v); | |
| int ilogb(halb v); | In API-Level 24 hinzugefügt |
| int2 ilogb(float2 v); | |
| int2 ilogb(half2 v); | In API-Level 24 hinzugefügt |
| int3 ilogb(float3 v); | |
| int3 ilogb(half3 v); | In API-Level 24 hinzugefügt |
| int4 ilogb(float4 v); | |
| int4 ilogb(half4 v); | In API-Level 24 hinzugefügt |
Gibt den Basis-2-Exponenten eines Werts zurück, wobei die Mantis zwischen 1.f (einschließlich) und 2.f (ausschließlich) liegt.
Beispiel: ilogb(8.5f) gibt 3 zurück.
Aufgrund des Unterschieds in der Mantis ist diese Zahl um eins kleiner als von frexp() zurückgegeben.
logb() ist ähnlich, gibt aber eine Gleitkommazahl zurück.
ldexp : Erstellt einen Gleitkommawert aus Mantissen und Exponenten
| float ldexp(Gleitkommazahl-Mantisse, inter Exponent); | |
| FLOAT2 ldexp(FLOAT2 Mantissen, int. Exponent); | |
| float2 ldexp(float2 Mantis, int2-Exponent); | |
| FLOAT3 ldexp(FLOAT3-Mantissen, int. Exponent); | |
| float3 ldexp(float3 Mantis, int3-Exponent); | |
| FLOAT4 ldexp(FLOAT4 Mantis, int. Exponent); | |
| float4 ldexp(float4 Mantis, int4-Exponent); | |
| half ldexp(halbe Mantis, inter Exponent); | In API-Level 24 hinzugefügt |
| half2 ldexp(half2 mantissa, int exponent); | In API-Level 24 hinzugefügt |
| half2 ldexp(half2 mantissa, int2-Exponent); | In API-Level 24 hinzugefügt |
| half3 ldexp(half3 Mistisse, int. Exponent); | In API-Level 24 hinzugefügt |
| half3 ldexp(half3 Mantissa, int3-Exponent); | In API-Level 24 hinzugefügt |
| half4 ldexp(half4 Mistisse, int. Exponent); | In API-Level 24 hinzugefügt |
| half4 ldexp(half4 Mantisen, int4-Exponent); | In API-Level 24 hinzugefügt |
Parameter
| Mantis | Mantissa. |
|---|---|
| Exponent | Exponent, eine einzelne Komponente oder ein übereinstimmender Vektor. |
Gibt den Gleitkommawert zurück, der aus der Mantissen und dem Exponenten erstellt wurde, d.h. (Mantisse * 2 ^ Exponent).
Für den umgekehrten Vorgang siehe frexp().
Ligamma : Natürlicher Logarithmus der Gammafunktion
| float lgamma(float v); | |
| float lgamma(float v, int* sign_of_gamma); | |
| float2 LGamma(float2 v); | |
| float2 lgamma(float2 v, int2* sign_of_gamma); | |
| float3 LGamma(float3 v); | |
| float3 lgamma(float3 v, int3* sign_of_gamma); | |
| float4 Lgamma(float4 v); | |
| float4 lgamma(float4 v, int4* sign_of_gamma); | |
| half LGamma(halb V); | In API-Level 24 hinzugefügt |
| half lgamma(half v, int* sign_of_gamma); | In API-Level 24 hinzugefügt |
| half2 LGamma(half2 v); | In API-Level 24 hinzugefügt |
| half2 lgamma(half2 v, int2* sign_of_gamma); | In API-Level 24 hinzugefügt |
| half3 LGamma(half3 v); | In API-Level 24 hinzugefügt |
| half3 lgamma(half3 v, int3* sign_of_gamma); | In API-Level 24 hinzugefügt |
| half4 LGamma(half4 v); | In API-Level 24 hinzugefügt |
| half4 lgamma(half4 v, int4* sign_of_gamma); | In API-Level 24 hinzugefügt |
Parameter
| v | |
|---|---|
| Gammazeichen | Wenn Vorzeichen von Gamma nicht null ist, wird *sign_of_gamma auf -1,f gesetzt, wenn Gamma von v negativ ist, andernfalls auf 1,f. |
log : Natürlicher Logarithmus
| float log(float v); | |
| float2 log(float2 v); | |
| float3 log(float3 v); | |
| float4 log(float4 v); | |
| half log(half v); | In API-Level 24 hinzugefügt |
| half2 log(half2 v); | In API-Level 24 hinzugefügt |
| half3 log(half3 v); | In API-Level 24 hinzugefügt |
| half4 log(half4 v); | In API-Level 24 hinzugefügt |
Gibt den natürlichen Logarithmus zurück.
Siehe auch native_log().
log10 : Logarithmus zur Basis 10
| float log10(float v); | |
| float2 log10(float2 v); | |
| float3 log10(float3 v); | |
| float4 log10(float4 v); | |
| half log10(half v); | In API-Level 24 hinzugefügt |
| half2 log10(half2 v); | In API-Level 24 hinzugefügt |
| half3 log10(half3 v); | In API-Level 24 hinzugefügt |
| half4 log10(half4 v); | In API-Level 24 hinzugefügt |
Gibt den Logarithmus zur Basis 10 zurück.
Siehe auch native_log10().
log1p : Natürlicher Logarithmus eines Werts plus 1
| float log1p(float v); | |
| float2 log1p(float2 v); | |
| float3 log1p(float3 v); | |
| float4 log1p(float4 v); | |
| half log1p(half v); | In API-Level 24 hinzugefügt |
| half2 log1p(half2 v); | In API-Level 24 hinzugefügt |
| half3 log1p(half3 v); | In API-Level 24 hinzugefügt |
| half4 log1p(half4 v); | In API-Level 24 hinzugefügt |
Gibt den natürlichen Logarithmus von (v + 1.f) zurück.
Siehe auch native_log1p().
log2 : Logarithmus zur Basis 2
| float log2(float v); | |
| float2 log2(float2 v); | |
| float3 log2(float3 v); | |
| float4 log2(float4 v); | |
| half log2(half v); | In API-Level 24 hinzugefügt |
| half2 log2(half2 v); | In API-Level 24 hinzugefügt |
| half3 log2(half3 v); | In API-Level 24 hinzugefügt |
| half4 log2(half4 v); | In API-Level 24 hinzugefügt |
Gibt den Logarithmus zur Basis 2 zurück.
Siehe auch native_log2().
logb : Basis-2-Exponent
| float logb(float v); | |
| float2 logb(float2 v); | |
| float3 logb(float3 v); | |
| float4 logb(float4 v); | |
| half logb(half v); | In API-Level 24 hinzugefügt |
| half2 logb(half2 v); | In API-Level 24 hinzugefügt |
| half3 logb(half3 v); | In API-Level 24 hinzugefügt |
| half4 logb(half4 v); | In API-Level 24 hinzugefügt |
Gibt den Basis-2-Exponenten eines Werts zurück, wobei die Mantis zwischen 1.f (einschließlich) und 2.f (ausschließlich) liegt.
Beispiel: logb(8.5f) gibt 3.f zurück.
Aufgrund des Unterschieds in der Mantis ist diese Zahl um eins kleiner als der Wert, der von frexp() zurückgegeben wird.
ilogb() ist ähnlich, gibt aber eine Ganzzahl zurück.
mad : Multiplizieren und hinzufügen
| float mad(float multiplicand1, float multiplicand2, float offset); | |
| float2 mad(float2 multiplicand1, float2 multiplicand2, float2 offset); | |
| float3 mad(float3 multiplicand1, float3 multiplicand2, float3 offset); | |
| float4 mad(float4 multiplicand1, float4 multiplicand2, float4 offset); | |
| half mad(halb multiplicand1, halb multiplicand2, halb Offset); | In API-Level 24 hinzugefügt |
| half2 mad(half2 multiplicand1, half2 multiplicand2, half2 offset); | In API-Level 24 hinzugefügt |
| half3 mad(half3 multiplicand1, half3 multiplicand2, half3 offset); | In API-Level 24 hinzugefügt |
| half4 mad(half4 multiplicand1, half4 multiplicand2, half4 offset); | In API-Level 24 hinzugefügt |
Multiplizieren und addieren. Gibt (multiplicand1 * multiplicand2) + offset zurück.
Diese Funktion ähnelt fma(). fma() behält die volle Genauigkeit des multiplizierten Ergebnisses bei und rundet nur nach der Addition. „mad()“ rundet nach der Multiplikation und Addition. Im Modus „rs_fp_relaxed“ führt „mad()“ möglicherweise keine Rundung nach der Multiplikation durch.
max : Maximum
| char max(char a, char b); | |
| char2 max(char2 a, char2 b); | |
| char3 max(char3 a, char3 b); | |
| char4 max(char4 a, char4 b); | |
| float max(Gleitkomma a, Gleitkommazahl b); | |
| FLOAT2 max(FLOAT2 a, Gleitkommazahl b); | |
| float2 max(float2 a, float2 b); | |
| FLOAT3 max(FLOAT3 a, Gleitkommazahl b); | |
| float3 max(float3 a, float3 b); | |
| FLOAT4 max(FLOAT4 a, Gleitkommazahl b); | |
| float4 max(float4 a, float4 b); | |
| half max(half a, hälf b); | In API-Level 24 hinzugefügt |
| half2 max(half2 a, hälf b); | In API-Level 24 hinzugefügt |
| half2 max(half2 a, hälf2 b); | In API-Level 24 hinzugefügt |
| half3 max(half3 a, hälfte b); | In API-Level 24 hinzugefügt |
| half3 max(half3 a, hälf3 b); | In API-Level 24 hinzugefügt |
| half4 max(half4 a, hälf b); | In API-Level 24 hinzugefügt |
| half4 max(half4 a, half4 b); | In API-Level 24 hinzugefügt |
| int max(int a, int b); | |
| int2 max(int2 a, int2 b); | |
| int3 max(int3 a, int3 b); | |
| int4 max(int4 a, int4 b); | |
| long max(long a, long b); | In API-Level 21 hinzugefügt |
| long2 max(long2 a, long2 b); | In API-Level 21 hinzugefügt |
| long3 max(long3 a, long3 b); | In API-Level 21 hinzugefügt |
| long4 max(long4 a, long4 b); | In API-Level 21 hinzugefügt |
| short max(short a, kurz b); | |
| short2 max(short2 a, short2 b); | |
| short3 max(short3 a, short3 b); | |
| short4 max(short4 a, short4 b); | |
| uchar max(uchar a, uchar b); | |
| uchar2 max(uchar2 a, uchar2 b); | |
| uchar3 max(uchar3 a, uchar3 b); | |
| uchar4 max(uchar4 a, uchar4 b); | |
| uint max(uint a, uint b); | |
| uint2 max(uint2 a, uint2 b); | |
| uint3 max(uint3 a, uint3 b); | |
| uint4 max(uint4 a, uint4 b); | |
| ulong max(ulong a, ulong b); | In API-Level 21 hinzugefügt |
| ulong2 max(ulong2 a, ulong2 b); | In API-Level 21 hinzugefügt |
| ulong3 max(ulong3 a, ulong3 b); | In API-Level 21 hinzugefügt |
| ulong4 max(ulong4 a, ulong4 b); | In API-Level 21 hinzugefügt |
| ushort max(ushort a, ushort b); | |
| ushort2 max(ushort2 a, ushort2 b); | |
| ushort3 max(ushort3 a, ushort3 b); | |
| ushort4 max(ushort4 a, ushort4 b); |
Gibt den Maximalwert von zwei Argumenten zurück.
min : Minimum
| char min(char a, char b); | |
| char2 min(char2 a, char2 b); | |
| char3 min(char3 a, char3 b); | |
| char4 min(char4 a, char4 b); | |
| float min(Gleitkommazahl a, Gleitkommazahl b); | |
| FLOAT2 Min.(FLOAT2 a, Gleitkommazahl b); | |
| float2 min(float2 a, float2 b); | |
| FLOAT3 min(FLOAT3 a, Gleitkommazahl b); | |
| float3 min(float3 a, float3 b); | |
| FLOAT4 Min.(FLOAT4 a, Gleitkommazahl b); | |
| float4 min(float4 a, float4 b); | |
| half min(half a, half b); | In API-Level 24 hinzugefügt |
| half2 Min.(half2 a, halb b); | In API-Level 24 hinzugefügt |
| half2 Min.(half2 a, hälf2 b); | In API-Level 24 hinzugefügt |
| half3 Min.(half3 a, halb b); | In API-Level 24 hinzugefügt |
| half3 Min.(half3 a, hälf3 b); | In API-Level 24 hinzugefügt |
| half4 Min.(half4 a, halb b); | In API-Level 24 hinzugefügt |
| half4 Min.(half4 a, hälf4 b); | In API-Level 24 hinzugefügt |
| int min(int a, int b); | |
| int2 min(int2 a, int2 b); | |
| int3 min(int3 a, int3 b); | |
| int4 min(int4 a, int4 b); | |
| long min(long a, long b); | In API-Level 21 hinzugefügt |
| long2 min(long2 a, long2 b); | In API-Level 21 hinzugefügt |
| long3 min(long3 a, long3 b); | In API-Level 21 hinzugefügt |
| long4 min(long4 a, long4 b); | In API-Level 21 hinzugefügt |
| short min(short a, short b); | |
| short2 Min.(short2 a, short2 b); | |
| short3 Min.(short3 a, short3 b); | |
| short4 Min.(short4 a, short4 b); | |
| uchar min(uchar a, uchar b); | |
| uchar2 min(uchar2 a, uchar2 b); | |
| uchar3 min(uchar3 a, uchar3 b); | |
| uchar4 min(uchar4 a, uchar4 b); | |
| uint min(uint a, uint b); | |
| uint2 min(uint2 a, uint2 b); | |
| uint3 min(uint3 a, uint3 b); | |
| uint4 min(uint4 a, uint4 b); | |
| ulong min(ulong a, ulong b); | In API-Level 21 hinzugefügt |
| ulong2 min(ulong2 a, ulong2 b); | In API-Level 21 hinzugefügt |
| ulong3 min(ulong3 a, ulong3 b); | In API-Level 21 hinzugefügt |
| ulong4 min(ulong4 a, ulong4 b); | In API-Level 21 hinzugefügt |
| ushort min(ushort a, ushort b); | |
| ushort2 min(ushort2 a, ushort2 b); | |
| ushort3 Min.(ushort3 a, ushort3 b); | |
| ushort4 min(ushort4 a, ushort4 b); |
Gibt den Minimalwert von zwei Argumenten zurück.
mix : kombiniert zwei Werte
| Float Mix(Gleitkommazahl Start, Float stop, Float Bruch); | |
| FLOAT2-Mix(FLOAT2 Start, FLOAT2 Stopp, Gleitkomma-Anteil); | |
| FLOAT2-Mix(FLOAT2 Start, FLOAT2 Stopp, Gleitkomma2-Anteil); | |
| FLOAT3-Mix(FLOAT3 Start, FLOAT3 stop, Gleitkomma-Anteil); | |
| FLOAT3mix(FLOAT3 start, float3 stop, FLOAT3-Anteil); | |
| float4mix(float4 start, float4 stop, float4); | |
| FLOAT4-Mix(FLOAT4 Start, FLOAT4 Stopp, FLOAT4-Anteil); | |
| half mix(half Start, halb stopp, halb Bruch); | In API-Level 24 hinzugefügt |
| half2 Mix(half2 Start, half2 stop, halb Bruch); | In API-Level 24 hinzugefügt |
| half2 Mix(half2 Start, half2 Stop, half2 Bruch); | In API-Level 24 hinzugefügt |
| half3 Mix(half3 Start, halb3 Stop, halb Bruch); | In API-Level 24 hinzugefügt |
| half3 Mix(half3 Start, half3 stopp, half3 Bruch); | In API-Level 24 hinzugefügt |
| half4 Mix(half4 Start, half4 Stop, halb Bruch); | In API-Level 24 hinzugefügt |
| half4 Mix(half4 Start, half4 stop, half4 Bruch); | In API-Level 24 hinzugefügt |
Gibt start + ((Haltestelle - Start) * Bruch) zurück.
Dies kann hilfreich sein, wenn Sie zwei Werte vermischen. Wenn Sie beispielsweise eine neue Farbe mit 40% color1 und 60% color2 erstellen möchten, verwenden Sie mix(color1, color2, 0.6f).
modf: Integral- und Bruchkomponenten
| float modf(float v, float* Integral_part); | |
| float2 modf(float2 v, float2* Integral_part); | |
| float3 modf(float3 v, float3* integraler_part); | |
| float4 modf(float4 v, float4* Integral_part); | |
| half modf(halb v, half* integral_part); | In API-Level 24 hinzugefügt |
| half2 modf(half2 v, half2* integral_part); | In API-Level 24 hinzugefügt |
| half3 modf(half3 v, half3* integral_part); | In API-Level 24 hinzugefügt |
| half4 modf(half4 v, half4* integral_part); | In API-Level 24 hinzugefügt |
Parameter
| v | Quellwert. |
|---|---|
| Integralteil | *integral_part wird auf den ganzzahligen Teil der Zahl festgelegt. |
Returns
| Der Gleitkommateil des Werts. |
Gibt die Integral- und Bruchkomponenten einer Zahl zurück.
Beide Komponenten haben dasselbe Vorzeichen wie x. Bei einer Eingabe von -3.72f wird *integral_part beispielsweise auf -3.f festgelegt und .72f wird zurückgegeben.
nan : Keine Zahl
| float nan(uint v); |
Parameter
| v | Nicht verwendet. |
|---|
Gibt einen NaN-Wert zurück (keine Zahl).
nan_half : Keine Zahl
| half nan_half() | In API-Level 24 hinzugefügt |
Gibt einen Gleitkommawert mit halber Genauigkeit zurück (keine Zahl).
native_acos : Ungefährer Arkuskosinus
| float native_acos(float v); | In API-Level 21 hinzugefügt |
| float2 native_acos(float2 v); | In API-Level 21 hinzugefügt |
| float3 native_acos(float3 v); | In API-Level 21 hinzugefügt |
| float4 native_acos(float4 v); | In API-Level 21 hinzugefügt |
| half native_acos(halb v); | In API-Level 24 hinzugefügt |
| half2 native_acos(half2 v); | In API-Level 24 hinzugefügt |
| half3 native_acos(half3 v); | In API-Level 24 hinzugefügt |
| half4 native_acos(half4 v); | In API-Level 24 hinzugefügt |
Gibt den ungefähren Arkuskosinus in Radiant zurück.
Diese Funktion liefert undefinierte Ergebnisse aus Eingabewerten, die kleiner als -1 oder größer als 1 sind.
Siehe auch acos().
native_acosh : Ungefährer umgekehrter hyperbolischer Kosinus
| float native_acosh(float v); | In API-Level 21 hinzugefügt |
| float2 native_acosh(float2 v); | In API-Level 21 hinzugefügt |
| float3 native_acosh(float3 v); | In API-Level 21 hinzugefügt |
| float4 native_acosh(float4 v); | In API-Level 21 hinzugefügt |
| half native_acosh(halb v); | In API-Level 24 hinzugefügt |
| half2 native_acosh(half2 v); | In API-Level 24 hinzugefügt |
| half3 native_acosh(half3 v); | In API-Level 24 hinzugefügt |
| half4 native_acosh(half4 v); | In API-Level 24 hinzugefügt |
Gibt den ungefähren inversen hyperbolischen Kosinus in Radiant zurück.
Siehe auch acosh().
native_acospi : Ungefährer inverser Kosinus geteilt durch Pi
| float native_acospi(float v); | In API-Level 21 hinzugefügt |
| float2 native_acospi(float2 v); | In API-Level 21 hinzugefügt |
| float3 native_acospi(float3 v); | In API-Level 21 hinzugefügt |
| float4 native_acospi(float4 v); | In API-Level 21 hinzugefügt |
| half native_acospi(halb V); | In API-Level 24 hinzugefügt |
| half2 native_acospi(half2 v); | In API-Level 24 hinzugefügt |
| half3 native_acospi(half3 v); | In API-Level 24 hinzugefügt |
| half4 native_acospi(half4 v); | In API-Level 24 hinzugefügt |
Gibt den ungefähren Arkuskosinus im Bogenmaß geteilt durch Pi zurück.
Um einen in Grad gemessenen Arkuskosinus zu erhalten, verwenden Sie acospi(a) * 180.f.
Diese Funktion liefert undefinierte Ergebnisse aus Eingabewerten, die kleiner als -1 oder größer als 1 sind.
Siehe auch acospi().
native_asin : Ungefährer umgekehrter Sinus
| float native_asin(float v); | In API-Level 21 hinzugefügt |
| float2 native_asin(float2 v); | In API-Level 21 hinzugefügt |
| float3 native_asin(float3 v); | In API-Level 21 hinzugefügt |
| float4 native_asin(float4 v); | In API-Level 21 hinzugefügt |
| half native_asin(halb V); | In API-Level 24 hinzugefügt |
| half2 native_asin(half2 v); | In API-Level 24 hinzugefügt |
| half3 native_asin(half3 v); | In API-Level 24 hinzugefügt |
| half4 native_asin(half4 v); | In API-Level 24 hinzugefügt |
Gibt den ungefähren Arkussinus in Radiant zurück.
Diese Funktion liefert undefinierte Ergebnisse aus Eingabewerten, die kleiner als -1 oder größer als 1 sind.
Siehe auch asin().
native_asinh : Ungefährer umgekehrter hyperbolischer Sinus
| float native_asinh(float v); | In API-Level 21 hinzugefügt |
| float2 native_asinh(float2 v); | In API-Level 21 hinzugefügt |
| float3 native_asinh(float3 v); | In API-Level 21 hinzugefügt |
| float4 native_asinh(float4 v); | In API-Level 21 hinzugefügt |
| half native_asinh(halb V); | In API-Level 24 hinzugefügt |
| half2 native_asinh(half2 v); | In API-Level 24 hinzugefügt |
| half3 native_asinh(half3 v); | In API-Level 24 hinzugefügt |
| half4 native_asinh(half4 v); | In API-Level 24 hinzugefügt |
Gibt den ungefähren inversen Hyperbelsinus in Radiant zurück.
Siehe auch asinh().
native_asinpi : Ungefährer umgekehrter Sinus geteilt durch Pi
| float native_asinpi(float v); | In API-Level 21 hinzugefügt |
| float2 native_asinpi(float2 v); | In API-Level 21 hinzugefügt |
| float3 native_asinpi(float3 v); | In API-Level 21 hinzugefügt |
| float4 native_asinpi(float4 v); | In API-Level 21 hinzugefügt |
| half native_asinpi(halb V); | In API-Level 24 hinzugefügt |
| half2 native_asinpi(half2 v); | In API-Level 24 hinzugefügt |
| half3 native_asinpi(half3 v); | In API-Level 24 hinzugefügt |
| half4 native_asinpi(half4 v); | In API-Level 24 hinzugefügt |
Gibt den ungefähren Arkussinus im Bogenmaß geteilt durch Pi zurück.
Um einen umgekehrten Sinus in Grad zu erhalten, verwenden Sie asinpi(a) * 180.f.
Diese Funktion liefert undefinierte Ergebnisse aus Eingabewerten, die kleiner als -1 oder größer als 1 sind.
Siehe auch asinpi().
native_atan : Ungefährer inverser Tangens
| float native_atan(float v); | In API-Level 21 hinzugefügt |
| float2 native_atan(float2 v); | In API-Level 21 hinzugefügt |
| float3 native_atan(float3 v); | In API-Level 21 hinzugefügt |
| float4 native_atan(float4 v); | In API-Level 21 hinzugefügt |
| half native_atan(halb V); | In API-Level 24 hinzugefügt |
| half2 native_atan(half2 v); | In API-Level 24 hinzugefügt |
| half3 native_atan(half3 v); | In API-Level 24 hinzugefügt |
| half4 native_atan(half4 v); | In API-Level 24 hinzugefügt |
Gibt den ungefähren inversen Tangens in Radiant zurück.
Siehe auch atan().
native_atan2 : Ungefährer inverser Tangens eines Verhältnisses
| float native_atan2(Gleitkommazahl, Gleitkommazahl; Nenner); | In API-Level 21 hinzugefügt |
| float2 native_atan2(Gleitkomma2-Zähler, Gleitkomma2-Zähler); | In API-Level 21 hinzugefügt |
| float3 native_atan2(float3 Zähler, Gleitkomma3 Nenner); | In API-Level 21 hinzugefügt |
| float4 native_atan2(float4 Zähler, float4 Nenner); | In API-Level 21 hinzugefügt |
| half native_atan2(halber Zähler, halbe Nenner); | In API-Level 24 hinzugefügt |
| half2 native_atan2(half2 Zähler, half2 Nenner); | In API-Level 24 hinzugefügt |
| half3 native_atan2(half3 Zähler, half3 Nenner); | In API-Level 24 hinzugefügt |
| half4 native_atan2(half4 Zähler, half4 Nenner); | In API-Level 24 hinzugefügt |
Parameter
| Zähler | Zähler. |
|---|---|
| Nenner | Nenner. Kann 0 sein. |
Gibt den ungefähren inversen Tangens von (numerator / denominator) in Radiant zurück.
Siehe auch atan2().
native_atan2pi : Ungefährer inverser Tangens eines Verhältnisses, geteilt durch Pi
| float native_atan2pi(Gleitkommazahl, Gleitkommazahl); | In API-Level 21 hinzugefügt |
| float2 native_atan2pi(Gleitkomma2-Zähler, Gleitkomma2-Zähler); | In API-Level 21 hinzugefügt |
| float3 native_atan2pi(Gleitkomma3-Zähler, Gleitkomma3-Zähler); | In API-Level 21 hinzugefügt |
| float4 native_atan2pi(Gleitkomma4-Zähler, Gleitkomma4-Zähler); | In API-Level 21 hinzugefügt |
| half native_atan2pi(halber Zähler, halbe Nenner); | In API-Level 24 hinzugefügt |
| half2 native_atan2pi(half2 Zähler, half2 Nenner); | In API-Level 24 hinzugefügt |
| half3 native_atan2pi(half3 Zähler, half3 Nenner); | In API-Level 24 hinzugefügt |
| half4 native_atan2pi(half4 Zähler, half4 Nenner); | In API-Level 24 hinzugefügt |
Parameter
| Zähler | Zähler. |
|---|---|
| Nenner | Nenner. Kann 0 sein. |
Gibt den ungefähren inversen Tangens von (numerator / denominator) im Bogenmaß geteilt durch Pi zurück.
Um einen in Grad gemessenen umgekehrten Tangens zu erhalten, verwenden Sie atan2pi(n, d) * 180.f.
Siehe auch atan2pi().
native_atanh : Ungefährer umgekehrter hyperbolischer Tangens
| float native_atanh(float v); | In API-Level 21 hinzugefügt |
| float2 native_atanh(float2 v); | In API-Level 21 hinzugefügt |
| float3 native_atanh(float3 v); | In API-Level 21 hinzugefügt |
| float4 native_atanh(float4 v); | In API-Level 21 hinzugefügt |
| half native_atanh(halb V); | In API-Level 24 hinzugefügt |
| half2 native_atanh(half2 v); | In API-Level 24 hinzugefügt |
| half3 native_atanh(half3 v); | In API-Level 24 hinzugefügt |
| half4 native_atanh(half4 v); | In API-Level 24 hinzugefügt |
Gibt den ungefähren inversen hyperbolischen Tangens in Radiant zurück.
Siehe auch atanh().
native_atanpi : Ungefährer inverser Tangens geteilt durch Pi
| float native_atanpi(float v); | In API-Level 21 hinzugefügt |
| float2 native_atanpi(float2 v); | In API-Level 21 hinzugefügt |
| float3 native_atanpi(float3 v); | In API-Level 21 hinzugefügt |
| float4 native_atanpi(float4 v); | In API-Level 21 hinzugefügt |
| half native_atanpi(halb V); | In API-Level 24 hinzugefügt |
| half2 native_atanpi(half2 v); | In API-Level 24 hinzugefügt |
| half3 native_atanpi(half3 v); | In API-Level 24 hinzugefügt |
| half4 native_atanpi(half4 v); | In API-Level 24 hinzugefügt |
Gibt den ungefähren inversen Tangens in Radiant geteilt durch Pi zurück.
Um einen in Grad gemessenen umgekehrten Tangens zu erhalten, verwenden Sie atanpi(a) * 180.f.
Siehe auch atanpi().
native_cbrt: Ungefähre Kubikwurzel
| float native_cbrt(float v); | In API-Level 21 hinzugefügt |
| float2 native_cbrt(float2 v); | In API-Level 21 hinzugefügt |
| float3 native_cbrt(float3 v); | In API-Level 21 hinzugefügt |
| float4 native_cbrt(float4 v); | In API-Level 21 hinzugefügt |
| half native_cbrt(halb V); | In API-Level 24 hinzugefügt |
| half2 native_cbrt(half2 v); | In API-Level 24 hinzugefügt |
| half3 native_cbrt(half3 v); | In API-Level 24 hinzugefügt |
| half4 native_cbrt(half4 v); | In API-Level 24 hinzugefügt |
Gibt die ungefähre Kubikwurzel zurück.
Siehe auch cbrt().
native_cos : Näherungskosinus
| float native_cos(float v); | In API-Level 21 hinzugefügt |
| float2 native_cos(float2 v); | In API-Level 21 hinzugefügt |
| float3 native_cos(float3 v); | In API-Level 21 hinzugefügt |
| float4 native_cos(float4 v); | In API-Level 21 hinzugefügt |
| half native_cos(half v); | In API-Level 24 hinzugefügt |
| half2 native_cos(half2 v); | In API-Level 24 hinzugefügt |
| half3 native_cos(half3 v); | In API-Level 24 hinzugefügt |
| half4 native_cos(half4 v); | In API-Level 24 hinzugefügt |
Gibt den ungefähren Kosinus eines Winkels zurück, gemessen im Bogenmaß.
Siehe auch cos().
native_cosh : Ungefährer hypebolischer Kosinus
| float native_cosh(float v); | In API-Level 21 hinzugefügt |
| float2 native_cosh(float2 v); | In API-Level 21 hinzugefügt |
| float3 native_cosh(float3 v); | In API-Level 21 hinzugefügt |
| float4 native_cosh(float4 v); | In API-Level 21 hinzugefügt |
| half native_cosh(half v); | In API-Level 24 hinzugefügt |
| half2 native_cosh(half2 v); | In API-Level 24 hinzugefügt |
| half3 native_cosh(half3 v); | In API-Level 24 hinzugefügt |
| half4 native_cosh(half4 v); | In API-Level 24 hinzugefügt |
Gibt den ungefähren hypebolischen Kosinus zurück.
Siehe auch cosh().
native_cospi : Ungefährer Kosinus einer Zahl multipliziert mit Pi
| float native_cospi(float v); | In API-Level 21 hinzugefügt |
| float2 native_cospi(float2 v); | In API-Level 21 hinzugefügt |
| float3 native_cospi(float3 v); | In API-Level 21 hinzugefügt |
| float4 native_cospi(float4 v); | In API-Level 21 hinzugefügt |
| half native_cospi(halb v); | In API-Level 24 hinzugefügt |
| half2 native_cospi(half2 v); | In API-Level 24 hinzugefügt |
| half3 native_cospi(half3 v); | In API-Level 24 hinzugefügt |
| half4 native_cospi(half4 v); | In API-Level 24 hinzugefügt |
Gibt den ungefähren Kosinus von (v * pi) zurück, wobei (v * pi) in Radiant gemessen wird.
Um den Kosinus eines in Grad gemessenen Werts zu erhalten, rufen Sie cospi(v / 180.f) auf.
Siehe auch cospi().
native_divide : ungefähre Division
| float native_divide(float link_vector, float right_vector); | In API-Level 21 hinzugefügt |
| float2 native_divide(float2 left_vector, float2 right_vector); | In API-Level 21 hinzugefügt |
| float3 native_divide(float3 left_vector, float3 right_vector); | In API-Level 21 hinzugefügt |
| float4 native_divide(float4 left_vector, float4 right_vector); | In API-Level 21 hinzugefügt |
| half native_divide(half left_vector, half right_vector); | In API-Level 24 hinzugefügt |
| half2 native_divide(half2 left_vector, half2 right_vector); | In API-Level 24 hinzugefügt |
| half3 native_divide(half3 left_vector, half3 right_vector); | In API-Level 24 hinzugefügt |
| half4 native_divide(half4 left_vector, half4 right_vector); | In API-Level 24 hinzugefügt |
Berechnet die ungefähre Division zweier Werte.
native_exp : Ungefähre Angabe von e, erhöht auf eine Zahl
| float native_exp(float v); | In API-Level 18 hinzugefügt |
| float2 native_exp(float2 v); | In API-Level 18 hinzugefügt |
| float3 native_exp(float3 v); | In API-Level 18 hinzugefügt |
| float4 native_exp(float4 v); | In API-Level 18 hinzugefügt |
| half native_exp(half v); | In API-Level 24 hinzugefügt |
| half2 native_exp(half2 v); | In API-Level 24 hinzugefügt |
| half3 native_exp(half3 v); | In API-Level 24 hinzugefügt |
| half4 native_exp(half4 v); | In API-Level 24 hinzugefügt |
Schnelle ungefähre Erscheinung
Er gilt für Eingaben von -86.f bis 86.f. Die Genauigkeit ist nicht schlechter als bei Verwendung von 16-Bit-Gleitkommawerten zu erwarten wäre.
Siehe auch exp().
native_exp10 : ca. 10 erhöht zu einer Zahl
| float native_exp10(float v); | In API-Level 18 hinzugefügt |
| float2 native_exp10(float2 v); | In API-Level 18 hinzugefügt |
| float3 native_exp10(float3 v); | In API-Level 18 hinzugefügt |
| float4 native_exp10(float4 v); | In API-Level 18 hinzugefügt |
| half native_exp10(halb V); | In API-Level 24 hinzugefügt |
| half2 native_exp10(half2 v); | In API-Level 24 hinzugefügt |
| half3 native_exp10(half3 v); | In API-Level 24 hinzugefügt |
| half4 native_exp10(half4 v); | In API-Level 24 hinzugefügt |
Schneller ungefährer Test 10.
Er gilt für Eingaben von -37.f bis 37.f. Die Genauigkeit ist nicht schlechter als bei Verwendung von 16-Bit-Gleitkommawerten zu erwarten wäre.
Siehe auch exp10().
native_exp2 : Ca. 2 zu einer Zahl erhöht
| float native_exp2(float v); | In API-Level 18 hinzugefügt |
| float2 native_exp2(float2 v); | In API-Level 18 hinzugefügt |
| float3 native_exp2(float3 v); | In API-Level 18 hinzugefügt |
| float4 native_exp2(float4 v); | In API-Level 18 hinzugefügt |
| half native_exp2(halb V); | In API-Level 24 hinzugefügt |
| half2 native_exp2(half2 v); | In API-Level 24 hinzugefügt |
| half3 native_exp2(half3 v); | In API-Level 24 hinzugefügt |
| half4 native_exp2(half4 v); | In API-Level 24 hinzugefügt |
Schneller ungefährer Test 2.
Er gilt für Eingaben von -125.f bis 125.f. Die Genauigkeit ist nicht schlechter als bei Verwendung von 16-Bit-Gleitkommawerten zu erwarten wäre.
Siehe auch exp2().
native_expm1 : Ungefähre Angabe von e auf eine Zahl minus eins
| float native_expm1(float v); | In API-Level 21 hinzugefügt |
| float2 native_expm1(float2 v); | In API-Level 21 hinzugefügt |
| float3 native_expm1(float3 v); | In API-Level 21 hinzugefügt |
| float4 native_expm1(float4 v); | In API-Level 21 hinzugefügt |
| half native_expm1(halb V); | In API-Level 24 hinzugefügt |
| half2 native_expm1(half2 v); | In API-Level 24 hinzugefügt |
| half3 native_expm1(half3 v); | In API-Level 24 hinzugefügt |
| half4 native_expm1(half4 v); | In API-Level 24 hinzugefügt |
Gibt den Näherungswert (e ^ v) - 1 zurück.
Siehe auch expm1().
native_hypot : Ungefähre Hypotenuse
| float native_hypot(float a, float b); | In API-Level 21 hinzugefügt |
| float2 native_hypot(float2 a, float2 b); | In API-Level 21 hinzugefügt |
| float3 native_hypot(float3 a, float3 b); | In API-Level 21 hinzugefügt |
| float4 native_hypot(float4 a, float4 b); | In API-Level 21 hinzugefügt |
| half native_hypot(half a, hälfte b); | In API-Level 24 hinzugefügt |
| half2 native_hypot(half2 a, half2 b); | In API-Level 24 hinzugefügt |
| half3 native_hypot(half3 a, half3 b); | In API-Level 24 hinzugefügt |
| half4 native_hypot(half4 a, half4 b); | In API-Level 24 hinzugefügt |
Gibt den ungefähren "native_sqrt"-Wert(a * a + b * b) zurück
Siehe auch hypot().
native_log : Ungefährer natürlicher Logarithmus
| float native_log(float v); | In API-Level 18 hinzugefügt |
| float2 native_log(float2 v); | In API-Level 18 hinzugefügt |
| float3 native_log(float3 v); | In API-Level 18 hinzugefügt |
| float4 native_log(float4 v); | In API-Level 18 hinzugefügt |
| half native_log(halb V); | In API-Level 24 hinzugefügt |
| half2 native_log(half2 v); | In API-Level 24 hinzugefügt |
| half3 native_log(half3 v); | In API-Level 24 hinzugefügt |
| half4 native_log(half4 v); | In API-Level 24 hinzugefügt |
Schnelles ungefähres Protokoll.
Sie ist nicht genau für Werte, die sehr nahe bei Null liegen.
Siehe auch log().
native_log10 : Ungefährer Logarithmus zur Basis 10
| float native_log10(float v); | In API-Level 18 hinzugefügt |
| float2 native_log10(float2 V); | In API-Level 18 hinzugefügt |
| float3 native_log10(float3 v); | In API-Level 18 hinzugefügt |
| float4 native_log10(float4 v); | In API-Level 18 hinzugefügt |
| half native_log10(halb V); | In API-Level 24 hinzugefügt |
| half2 native_log10(half2 v); | In API-Level 24 hinzugefügt |
| half3 native_log10(half3 v); | In API-Level 24 hinzugefügt |
| half4 native_log10(half4 v); | In API-Level 24 hinzugefügt |
Schneller ungefährer log10.
Sie ist nicht genau für Werte, die sehr nahe bei Null liegen.
Siehe auch log10().
native_log1p : Ungefährer natürlicher Logarithmus eines Werts plus 1
| float native_log1p(float v); | In API-Level 21 hinzugefügt |
| float2 native_log1p(float2 v); | In API-Level 21 hinzugefügt |
| float3 native_log1p(float3 v); | In API-Level 21 hinzugefügt |
| float4 native_log1p(float4 v); | In API-Level 21 hinzugefügt |
| half native_log1p(halb V); | In API-Level 24 hinzugefügt |
| half2 native_log1p(half2 v); | In API-Level 24 hinzugefügt |
| half3 native_log1p(half3 v); | In API-Level 24 hinzugefügt |
| half4 native_log1p(half4 v); | In API-Level 24 hinzugefügt |
Gibt den ungefähren natürlichen Logarithmus von (v + 1,0f) zurück
Siehe auch log1p().
native_log2 : Ungefährer Logarithmus zur Basis 2
| float native_log2(float v); | In API-Level 18 hinzugefügt |
| float2 native_log2(float2 v); | In API-Level 18 hinzugefügt |
| float3 native_log2(float3 v); | In API-Level 18 hinzugefügt |
| float4 native_log2(float4 v); | In API-Level 18 hinzugefügt |
| half native_log2(halb V); | In API-Level 24 hinzugefügt |
| half2 native_log2(half2 v); | In API-Level 24 hinzugefügt |
| half3 native_log2(half3 v); | In API-Level 24 hinzugefügt |
| half4 native_log2(half4 v); | In API-Level 24 hinzugefügt |
Schnelle ungefähre log2.
Sie ist nicht genau für Werte, die sehr nahe bei Null liegen.
Siehe auch log2().
native_powr : Ungefähre positive Basis mit einem Exponenten
| float native_powr(float-Basis, Gleitkomma-Exponent); | In API-Level 18 hinzugefügt |
| float2 native_powr(float2 Basis, float2 Exponent); | In API-Level 18 hinzugefügt |
| float3 native_powr(float3-Basis, float3-Exponent); | In API-Level 18 hinzugefügt |
| float4 native_powr(float4-Basis, float4-Exponent); | In API-Level 18 hinzugefügt |
| half native_powr(halb Base, halb Exponent); | In API-Level 24 hinzugefügt |
| half2 native_powr(half2 Base, half2 Exponent); | In API-Level 24 hinzugefügt |
| half3 native_powr(half3 Base, half3 Exponent); | In API-Level 24 hinzugefügt |
| half4 native_powr(half4 Basis, half4 Exponent); | In API-Level 24 hinzugefügt |
Parameter
| Basis | Muss zwischen 0,f und 256,f liegen. Die Funktion ist nicht genau für Werte, die sehr nahe bei Null liegen. |
|---|---|
| Exponent | Der Wert muss zwischen -15.f und 15.f liegen. |
Schnelle Näherung (Basis ^-Exponent).
Siehe auch powr().
native_recip : Ungefähre Reziproke
| float native_recip(float v); | In API-Level 21 hinzugefügt |
| float2 native_recip(float2 v); | In API-Level 21 hinzugefügt |
| float3 native_recip(float3 v); | In API-Level 21 hinzugefügt |
| float4 native_recip(float4 v); | In API-Level 21 hinzugefügt |
| half native_recip(half v); | In API-Level 24 hinzugefügt |
| half2 native_recip(half2 v); | In API-Level 24 hinzugefügt |
| half3 native_recip(half3 v); | In API-Level 24 hinzugefügt |
| half4 native_recip(half4 v); | In API-Level 24 hinzugefügt |
Gibt die ungefähre Kehrzahl eines Werts zurück.
Siehe auch half_recip().
native_rootn : Ungefährer n-ter Stamm
| float native_rootn(float v, int n); | In API-Level 21 hinzugefügt |
| float2 native_rootn(float2 v, int2 n); | In API-Level 21 hinzugefügt |
| float3 native_rootn(float3 v, int3 n); | In API-Level 21 hinzugefügt |
| float4 native_rootn(float4 v, int4 n); | In API-Level 21 hinzugefügt |
| half native_rootn(half v, int n); | In API-Level 24 hinzugefügt |
| half2 native_rootn(half2 v, int2 n); | In API-Level 24 hinzugefügt |
| half3 native_rootn(half3 v, int3 n); | In API-Level 24 hinzugefügt |
| half4 native_rootn(half4 v, int4 n); | In API-Level 24 hinzugefügt |
Die ungefähre n-te Wurzel eines Werts berechnen.
Siehe auch rootn().
native_rsqrt : Ungefähre Kehrwertzahl einer Quadratwurzel
| float native_rsqrt(float v); | In API-Level 21 hinzugefügt |
| float2 native_rsqrt(float2 v); | In API-Level 21 hinzugefügt |
| float3 native_rsqrt(float3 v); | In API-Level 21 hinzugefügt |
| float4 native_rsqrt(float4 v); | In API-Level 21 hinzugefügt |
| half native_rsqrt(halb V); | In API-Level 24 hinzugefügt |
| half2 native_rsqrt(half2 v); | In API-Level 24 hinzugefügt |
| half3 native_rsqrt(half3 v); | In API-Level 24 hinzugefügt |
| half4 native_rsqrt(half4 v); | In API-Level 24 hinzugefügt |
Gibt den Näherungswert zurück (1 / sqrt(v)).
Siehe auch rsqrt(), half_rsqrt().
native_sin : ungefährer Sinus
| float native_sin(float v); | In API-Level 21 hinzugefügt |
| float2 native_sin(float2 v); | In API-Level 21 hinzugefügt |
| float3 native_sin(float3 v); | In API-Level 21 hinzugefügt |
| float4 native_sin(float4 v); | In API-Level 21 hinzugefügt |
| half native_sin(halb V); | In API-Level 24 hinzugefügt |
| half2 native_sin(half2 v); | In API-Level 24 hinzugefügt |
| half3 native_sin(half3 v); | In API-Level 24 hinzugefügt |
| half4 native_sin(half4 v); | In API-Level 24 hinzugefügt |
Gibt den ungefähren Sinus eines Winkels zurück, gemessen im Bogenmaß.
Siehe auch sin().
native_sincos : Ungefährer Sinus und Kosinus
| float native_sincos(float v, float* cos); | In API-Level 21 hinzugefügt |
| float2 native_sincos(float2 v, float2* cos); | In API-Level 21 hinzugefügt |
| float3 native_sincos(float3 v, float3* cos); | In API-Level 21 hinzugefügt |
| float4 native_sincos(float4 v, float4* cos); | In API-Level 21 hinzugefügt |
| half native_sincos(halb v, half* cos); | In API-Level 24 hinzugefügt |
| half2 native_sincos(half2 v, half2* cos); | In API-Level 24 hinzugefügt |
| half3 native_sincos(half3 v, half3* cos); | In API-Level 24 hinzugefügt |
| half4 native_sincos(half4 v, half4* cos); | In API-Level 24 hinzugefügt |
Parameter
| v | Eingehender Wert in Radiant. |
|---|---|
| cos | *cos wird auf den Kosinuswert gesetzt. |
Returns
| Sinus. |
Gibt den ungefähren Sinus und Kosinus eines Werts zurück.
Siehe auch sincos().
native_sinh : Ungefährer hyperbolischer Sinus
| float native_sinh(float v); | In API-Level 21 hinzugefügt |
| float2 native_sinh(float2 v); | In API-Level 21 hinzugefügt |
| float3 native_sinh(float3 v); | In API-Level 21 hinzugefügt |
| float4 native_sinh(float4 v); | In API-Level 21 hinzugefügt |
| half native_sinh(halb V); | In API-Level 24 hinzugefügt |
| half2 native_sinh(half2 v); | In API-Level 24 hinzugefügt |
| half3 native_sinh(half3 v); | In API-Level 24 hinzugefügt |
| half4 native_sinh(half4 v); | In API-Level 24 hinzugefügt |
Gibt den ungefähren hyperbolischen Sinus eines Werts in Radiant zurück.
Siehe auch sinh().
native_sinpi : Ungefährer Sinus einer Zahl multipliziert mit Pi
| float native_sinpi(float v); | In API-Level 21 hinzugefügt |
| float2 native_sinpi(float2 v); | In API-Level 21 hinzugefügt |
| float3 native_sinpi(float3 v); | In API-Level 21 hinzugefügt |
| float4 native_sinpi(float4 v); | In API-Level 21 hinzugefügt |
| half native_sinpi(halb V); | In API-Level 24 hinzugefügt |
| half2 native_sinpi(half2 v); | In API-Level 24 hinzugefügt |
| half3 native_sinpi(half3 v); | In API-Level 24 hinzugefügt |
| half4 native_sinpi(half4 v); | In API-Level 24 hinzugefügt |
Gibt den ungefähren Sinus von (v * pi) zurück, wobei (v * pi) in Radiant gemessen wird.
Um den Sinus eines in Grad gemessenen Werts zu erhalten, rufen Sie sinpi(v / 180.f) auf.
Siehe auch sinpi().
native_sqrt : Ungefähre Quadratwurzel
| float native_sqrt(float v); | In API-Level 21 hinzugefügt |
| float2 native_sqrt(float2 v); | In API-Level 21 hinzugefügt |
| float3 native_sqrt(float3 v); | In API-Level 21 hinzugefügt |
| float4 native_sqrt(float4 v); | In API-Level 21 hinzugefügt |
| half native_sqrt(halb V); | In API-Level 24 hinzugefügt |
| half2 native_sqrt(half2 v); | In API-Level 24 hinzugefügt |
| half3 native_sqrt(half3 v); | In API-Level 24 hinzugefügt |
| half4 native_sqrt(half4 v); | In API-Level 24 hinzugefügt |
native_tan : Ungefährer Tangens
| float native_tan(float v); | In API-Level 21 hinzugefügt |
| float2 native_tan(float2 v); | In API-Level 21 hinzugefügt |
| float3 native_tan(float3 v); | In API-Level 21 hinzugefügt |
| float4 native_tan(float4 v); | In API-Level 21 hinzugefügt |
| half native_tan(halb V); | In API-Level 24 hinzugefügt |
| half2 native_tan(half2 v); | In API-Level 24 hinzugefügt |
| half3 native_tan(half3 v); | In API-Level 24 hinzugefügt |
| half4 native_tan(half4 v); | In API-Level 24 hinzugefügt |
Gibt den ungefähren Tangens eines Winkels zurück, gemessen im Bogenmaß.
native_tanh : Ungefährer hyperbolischer Tangens
| float native_tanh(float v); | In API-Level 21 hinzugefügt |
| float2 native_tanh(float2 v); | In API-Level 21 hinzugefügt |
| float3 native_tanh(float3 v); | In API-Level 21 hinzugefügt |
| float4 native_tanh(float4 v); | In API-Level 21 hinzugefügt |
| half native_tanh(halb v); | In API-Level 24 hinzugefügt |
| half2 native_tanh(half2 v); | In API-Level 24 hinzugefügt |
| half3 native_tanh(half3 v); | In API-Level 24 hinzugefügt |
| half4 native_tanh(half4 v); | In API-Level 24 hinzugefügt |
Gibt den ungefähren hyperbolischen Tangens eines Werts zurück.
Siehe auch tanh().
native_tanpi : Ungefährer Tangens einer Zahl multipliziert mit Pi
| float native_tanpi(float v); | In API-Level 21 hinzugefügt |
| float2 native_tanpi(float2 v); | In API-Level 21 hinzugefügt |
| float3 native_tanpi(float3 v); | In API-Level 21 hinzugefügt |
| float4 native_tanpi(float4 v); | In API-Level 21 hinzugefügt |
| half native_tanpi(halb V); | In API-Level 24 hinzugefügt |
| half2 native_tanpi(half2 v); | In API-Level 24 hinzugefügt |
| half3 native_tanpi(half3 v); | In API-Level 24 hinzugefügt |
| half4 native_tanpi(half4 v); | In API-Level 24 hinzugefügt |
Gibt den ungefähren Tangens von (v * pi) zurück, wobei (v * pi) in Radiant gemessen wird.
Um den Tangens eines in Grad gemessenen Werts zu erhalten, rufen Sie tanpi(v / 180.f) auf.
Siehe auch tanpi().
nextafter : nächste Gleitkommazahl
| float nextafter(float v, float target); | |
| float2 nextafter(float2 v, float2 target); | |
| float3 nextafter(float3 v, float3 target); | |
| float4 nextafter(float4 v, float4 target); | |
| half nextafter(halb v, half target); | In API-Level 24 hinzugefügt |
| half2 nextafter(half2 v, half2 target); | In API-Level 24 hinzugefügt |
| half3 nextafter(half3 v, half3 target); | In API-Level 24 hinzugefügt |
| half4 nextafter(half4 v, half4 target); | In API-Level 24 hinzugefügt |
Gibt die nächste darstellbare Gleitkommazahl von v in Richtung des Ziels zurück.
Im rs_fp_relaxed-Modus liefert ein denormalisierter Eingabewert möglicherweise nicht den nächsten denormalisierten Wert, da die Unterstützung denormalisierter Werte im Entspannungsmodus optional ist.
pow : Die Basis ist mit einem Exponenten potenziert.
| float pow(Gleitkommazahl, Gleitkommazahl; Exponent); | |
| Gleitkommazahl2 pow(Fließkommazahl2-Basis, Gleitkomma2-Exponent); | |
| float3 pow(float3 Base, float3 Exponent); | |
| float4 pow(float4-Basis, float4-Exponent); | |
| half pow(halb Base, halb Exponent); | In API-Level 24 hinzugefügt |
| half2 pow(half2 Base, half2 Exponent); | In API-Level 24 hinzugefügt |
| half3 pow(half3 Base, half3 Exponent); | In API-Level 24 hinzugefügt |
| half4 pow(half4 Base, half4 Exponent); | In API-Level 24 hinzugefügt |
pown: : Die Basis wird auf einen ganzzahligen Exponenten potenziert.
| float pown(float base, int exponent); | |
| float2 pown(float2-Basis, int2-Exponent); | |
| float3 pown(float3 base, int3-Exponent); | |
| float4 pown(float4 Basis, int4-Exponent); | |
| half(halbe Basis, int. Exponent) | In API-Level 24 hinzugefügt |
| half2 pown(half2 Base, int2-Exponent); | In API-Level 24 hinzugefügt |
| half3 pown(half3 Base, int3-Exponent); | In API-Level 24 hinzugefügt |
| half4 pown(half4 Base, int4-Exponent); | In API-Level 24 hinzugefügt |
powr : Positive Basis mit einem Exponenten potenziert
| float powr(Gleitkommazahl, Gleitkommazahl; Exponent); | |
| Gleitkommazahl2 powr(Fließ2-Basis, Gleitkomma2-Exponent); | |
| float3 powr(FLOAT3-Basis, FLOAT3-Exponent); | |
| FLOAT4 powr(FLOAT4-Basis, FLOAT4-Exponent); | |
| half powr(halb Base, halb Exponent); | In API-Level 24 hinzugefügt |
| half2 powr(half2 Base, half2 Exponent); | In API-Level 24 hinzugefügt |
| half3 powr(half3 Base, half3 Exponent); | In API-Level 24 hinzugefügt |
| half4 powr(half4 Base, half4 Exponent); | In API-Level 24 hinzugefügt |
Gibt die Basis ^-Exponent an, d.h. die Basis ^ ist hoch. Die Basis muss >= 0 sein.
pow() und pown() sind ähnlich. Beide stellen keine Annahmen zur Basis dar. pow() nimmt einen Gleitkomma-Exponenten, pown() eine Ganzzahl.
Siehe auch native_powr().
Radiant : Wandelt Grad in Bogenmaß um
| Gleitkommazahl mit Radiant(Gleitkommazahl v); | |
| float2 Radiant(float2 v); | |
| float3 Radiant(float3 v); | |
| float4 Radiant(float4 v); | |
| halb Radiant(halb V); | In API-Level 24 hinzugefügt |
| half2 Radiant(half2 v); | In API-Level 24 hinzugefügt |
| half3 Radiant(half3 V); | In API-Level 24 hinzugefügt |
| half4 Radiant(half4 V); | In API-Level 24 hinzugefügt |
Wandelt von Grad in Bogenmaß um.
remainder : Rest einer Division
| Gleitkommazahl Rest(Gleitkommazahler, Gleitkommazahler); | |
| Fließkommazahl2 rest(Gleitkommazahl2-Zähler, Gleitkomma2-Zähler); | |
| FLOAT3 Rest(Zähler FLOAT3, Nenner FLOAT3); | |
| FLOAT4 rest(Gleitkommazahl4-Zähler, Gleitkommazahl4-Zähler); | |
| half rest(halb Zähler, halb Nenner); | In API-Level 24 hinzugefügt |
| half2 Rest(half2 Zähler, half2 Nenner); | In API-Level 24 hinzugefügt |
| half3 Rest(half3 Zähler, half3 Nenner); | In API-Level 24 hinzugefügt |
| half4 Rest(half4 Zähler, half4 Nenner); | In API-Level 24 hinzugefügt |
Gibt den Rest von (Zähler / Nenner) zurück, wobei der Quotient auf die nächste Ganzzahl gerundet wird.
Die Funktion fmod() ist ähnlich, rundet aber in Richtung der nächsten Ganzzahl.
Beispiel: fmod(-3.8f, 2.f) gibt -1.8f (-3.8f - -1.f * 2.f) zurück, während remainder(-3.8f, 2.f) 0.2f (-3.8f - -2.f * 2.f) zurückgibt.
remquo : Restplatz und Quotient einer Division
| Gleitkommazahl remquo(Gleitkommazahl, Gleitkommazahl, Int*-Quotient); | |
| float2 remquo(float2 Zähler, Gleitkomma2 Nenner, int2*-Quotient); | |
| FLOAT3 remquo(FLOAT3 Zähler, Gleitkomma3 Nenner, int3*-Quotient); | |
| FLOAT4 remquo(FLOAT4 Zähler, Gleitkomma4 Nenner, int4*-Quotient); | |
| half remquo(halb Zähler, halb Nenner, Int*-Quotient); | In API-Level 24 hinzugefügt |
| half2 remquo(half2 Zähler, half2 Nenner, int2*-Quotient); | In API-Level 24 hinzugefügt |
| half3 remquo(half3 Zähler, half3 Nenner, int3*-Quotient); | In API-Level 24 hinzugefügt |
| half4 remquo(half4 Zähler, half4 Nenner, int4*-Quotient); | In API-Level 24 hinzugefügt |
Parameter
| Zähler | Zähler. |
|---|---|
| Nenner | Nenner. |
| Quotient | *Quotient wird auf den ganzzahligen Quotienten festgelegt. |
Returns
| Rest, präzise nur für die unteren drei Bits. |
Gibt den Quotienten und den Rest von (Zähler / Nenner) zurück.
Nur das Vorzeichen und die niedrigsten drei Bit des Quotienten sind garantiert genau.
Diese Funktion ist nützlich, um regelmäßige Funktionen zu implementieren. Die unteren drei Bits des Quotienten ergeben den Quadranten und der Rest die Entfernung innerhalb des Quadranten.
Eine Implementierung von sin(x) könnte beispielsweise remquo(x, PI / 2.f, &quadrant) aufrufen, um einen sehr großen Wert von x auf etwas innerhalb eines begrenzten Bereichs zu reduzieren.
Beispiel: remquo(-23.5f, 8.f, ") setzt die niedrigsten drei Bits des Quots auf 3 und das Vorzeichen negativ. Sie gibt 0.5f zurück.
rint : Runden auf gleichmäßig
| float rint(float v); | |
| float2 rint(float2 v); | |
| float3 rint(float3 v); | |
| float4 rint(float4 v); | |
| half rint(half v); | In API-Level 24 hinzugefügt |
| half2 rint(half2 v); | In API-Level 24 hinzugefügt |
| half3 rint(half3 v); | In API-Level 24 hinzugefügt |
| half4 rint(half4 v); | In API-Level 24 hinzugefügt |
rootn : N-te Wurzel
| float rootn(float v, int n); | |
| float2 rootn(float2 v, int2 n); | |
| float3 rootn(float3 v, int3 n); | |
| float4 rootn(float4 v, int4 n); | |
| half rootn(half v, int n); | In API-Level 24 hinzugefügt |
| half2 rootn(half2 v, int2 n); | In API-Level 24 hinzugefügt |
| half3 rootn(half3 v, int3 n); | In API-Level 24 hinzugefügt |
| half4 rootn(half4 v, int4 n); | In API-Level 24 hinzugefügt |
Berechnet die n-te Wurzel eines Werts.
Siehe auch native_rootn().
round : von null abrunden
| float round(float v); | |
| float2 round(float2 v); | |
| float3 round(float3 v); | |
| float4 round(float4 v); | |
| halfround(halb V); | In API-Level 24 hinzugefügt |
| half2 Round(half2 v); | In API-Level 24 hinzugefügt |
| half3 Round(half3 v); | In API-Level 24 hinzugefügt |
| half4 round(half4 v); | In API-Level 24 hinzugefügt |
Auf den nächsten ganzzahligen Wert runden.
„round()“ rundet halbe Werte von null weg. Beispielsweise gibt round(0.5f) 1.f und round(1.5f) 2.f zurück. Entsprechend gibt round(-0.5f) -1.f und round(-1.5f) -2.f zurück.
rint() ist ähnlich, rundet aber halbe Werte in Richtung gleichmäßig. trunc() kürzt den Dezimalbruch.
rsClamp : Einen Wert auf einen Bereich beschränken
| char rsClamp(char amount, char low, char high); | |
| int rsClamp(int amount, int low, int high); | |
| short rsClamp(short amount, short low, short high); | |
| uchar rsClamp(uchar amount, uchar low, uchar high); | |
| uint rsClamp(uint amount, uint low, uint high); | |
| ushort rsClamp(ushort amount, ushort low, ushort high); |
Parameter
| Betrag | Wert, der begrenzt werden soll. |
|---|---|
| gering | Untergrenze. |
| hoch | Obergrenze. |
Eingestellt. Verwenden Sie stattdessen clamp().
Setzen Sie einen Wert zwischen niedrigem und hohem Wert fest.
rsFrac : Gibt den Bruchteil einer Gleitkommazahl zurück
| float rsFrac(float v); |
Eingestellt. Verwenden Sie stattdessen fract().
Gibt den Bruchteil einer Gleitkommazahl zurück
rsRand : Pseudozufallszahl
| float rsRand(float max_value); | |
| float rsRand(float min_value, float max_value); | |
| int rsRand(int max_value); | |
| int rsRand(int min_value, int max_value); |
Gibt einen Zufallswert zwischen 0 (oder min_value) und max_malue zurück.
rsqrt : Kehrwert einer Quadratwurzel
| float rsqrt(float v); | |
| float2 rsqrt(float2 v); | |
| float3 rsqrt(float3 v); | |
| float4 rsqrt(float4 v); | |
| half rsqrt(half v); | In API-Level 24 hinzugefügt |
| half2 rsqrt(half2 v); | In API-Level 24 hinzugefügt |
| half3 rsqrt(half3 v); | In API-Level 24 hinzugefügt |
| half4 rsqrt(half4 v); | In API-Level 24 hinzugefügt |
Gibt (1 / sqrt(v)) zurück.
Siehe auch half_rsqrt(), native_rsqrt().
sign : Zeichen eines Werts
| float sign(float v); | |
| float2-Zeichen(float2 v); | |
| Gleitkommazahl-Zeichen(Gleitkommazahl3 v); | |
| float4-Zeichen(float4 v); | |
| half-Zeichen(halb v); | In API-Level 24 hinzugefügt |
| half2-Zeichen(half2 v); | In API-Level 24 hinzugefügt |
| half3-Zeichen(half3 v); | In API-Level 24 hinzugefügt |
| half4-Zeichen(half4 v); | In API-Level 24 hinzugefügt |
Gibt das Vorzeichen eines Werts zurück.
if (v < 0)return -1.f; else if (v > 0) Return 1.f; else zurück 0.f;
sin : Sinus
| float sin(float v); | |
| float2 sin(float2 v); | |
| float3 sin(float3 v); | |
| float4 sin(float4 v); | |
| half sin(half v); | In API-Level 24 hinzugefügt |
| half2 sin(half2 v); | In API-Level 24 hinzugefügt |
| half3 sin(half3 v); | In API-Level 24 hinzugefügt |
| half4 sin(half4 v); | In API-Level 24 hinzugefügt |
Gibt den Sinus eines Winkels zurück, gemessen im Bogenmaß.
Siehe auch native_sin().
sincos : Sinus und Kosinus
| 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(halb v, half* cos); | In API-Level 24 hinzugefügt |
| half2 sincos(half2 v, half2* cos); | In API-Level 24 hinzugefügt |
| half3 sincos(half3 v, half3* cos); | In API-Level 24 hinzugefügt |
| half4 sincos(half4 v, half4* cos); | In API-Level 24 hinzugefügt |
Parameter
| v | Eingehender Wert in Radiant. |
|---|---|
| cos | *cos wird auf den Kosinuswert gesetzt. |
Returns
| Sinus von v |
Gibt den Sinus und den Kosinus eines Werts zurück.
Siehe auch native_sincos.
sinh : Hyperbolischer Sinus
| float sinh(float v); | |
| float2 sinh(float2 v); | |
| float3 sinh(float3 v); | |
| float4 sinh(float4 v); | |
| half sinh(halb V); | In API-Level 24 hinzugefügt |
| half2 sinh(half2 v); | In API-Level 24 hinzugefügt |
| half3 sinh(half3 v); | In API-Level 24 hinzugefügt |
| half4 sinh(half4 v); | In API-Level 24 hinzugefügt |
Gibt den hyperbolischen Sinus von v zurück, wobei v in Radiant gemessen wird.
Siehe auch native_sinh().
sinpi : Sinus einer Zahl multipliziert mit Pi
| Gleitkommazahl sinpi(Gleitkommazahl v); | |
| float2 sinpi(float2 v); | |
| float3 sinpi(float3 v); | |
| float4 sinpi(float4 v); | |
| half sinpi(halb V); | In API-Level 24 hinzugefügt |
| half2 sinpi(half2 v); | In API-Level 24 hinzugefügt |
| half3 sinpi(half3 v); | In API-Level 24 hinzugefügt |
| half4 sinpi(half4 v); | In API-Level 24 hinzugefügt |
Gibt den Sinus von (v * pi) zurück, wobei (v * pi) in Radiant gemessen wird.
Um den Sinus eines in Grad gemessenen Werts zu erhalten, rufen Sie sinpi(v / 180.f) auf.
Siehe auch native_sinpi().
sqrt : Quadratwurzel
| Gleitkommazahl mit der Fließgröße(Gleitkommazahl v); | |
| Gleitkommazahl2(Gleitkomma2 v); | |
| FLOAT3-QRT(FLOAT3 v); | |
| FLOAT4 QRT(FLOAT4 v); | |
| half sqrt(hälfte V); | In API-Level 24 hinzugefügt |
| half2 sqrt(half2 v); | In API-Level 24 hinzugefügt |
| half3 sqrt(half3 v); | In API-Level 24 hinzugefügt |
| half4 sqrt(half4 v); | In API-Level 24 hinzugefügt |
Gibt die Quadratwurzel eines Werts zurück.
Weitere Informationen finden Sie unter half_sqrt(), native_sqrt().
step : 0, wenn kleiner als ein Wert ist, andernfalls 1
| Gleitkommazahl(Gleitkommazahl, Gleitkommazahl v); | |
| Schritt float2(Gleitkommazahl, Gleitkommazahl2 v); | In API-Level 21 hinzugefügt |
| Schritt float2(float2 Edge, float v); | |
| Schritt float2(float2 Edge, float2 v); | |
| Schritt Gleitkommazahl3(Gleitkommazahl, Gleitkommazahl3 v); | In API-Level 21 hinzugefügt |
| Schritt float3(float3 Edge, float v); | |
| Schritt float3(float3 Edge, float3 v); | |
| Schritt FLOAT4(Gleitkommazahl, Gleitkommazahl4v); | In API-Level 21 hinzugefügt |
| Schritt float4(float4 Edge, float v); | |
| Schritt float4(float4 Edge, float4 v); | |
| half Step(half Edge, half V); | In API-Level 24 hinzugefügt |
| half2 Schritt(halbe Kante, half2 V); | In API-Level 24 hinzugefügt |
| half2 Schritt(half2 Edge, halb V); | In API-Level 24 hinzugefügt |
| half2 Schritt(half2 Edge, half2 v); | In API-Level 24 hinzugefügt |
| half3 Schritt(halbe Kante, half3 V); | In API-Level 24 hinzugefügt |
| half3 Schritt(half3 Edge, halb V); | In API-Level 24 hinzugefügt |
| half3 Schritt(half3 Edge, half3 v); | In API-Level 24 hinzugefügt |
| half4 Schritt(halbe Kante, half4 V); | In API-Level 24 hinzugefügt |
| half4 Schritt(half4 Edge, halb v); | In API-Level 24 hinzugefügt |
| half4 Schritt(half4 Edge, half4 v); | In API-Level 24 hinzugefügt |
Gibt 0.f zurück, wenn v < Edge, ansonsten 1.f.
Dies kann nützlich sein, um bedingte Berechnungen ohne Schleifen und Verzweigungsanweisungen zu erstellen. Anstatt (a[i] < b[i]) ? 0.f : atan2(a[i], b[i]) für die entsprechenden Elemente eines Vektors zu berechnen, können Sie beispielsweise step(a, b) * atan2(a, b) verwenden.
tan : Tangens
| float tan(float v); | |
| float2 tan(float2 v); | |
| float3 tan(float3 v); | |
| float4 tan(float4 v); | |
| half tan(half v); | In API-Level 24 hinzugefügt |
| half2 tan(half2 v); | In API-Level 24 hinzugefügt |
| half3 tan(half3 v); | In API-Level 24 hinzugefügt |
| half4 tan(half4 v); | In API-Level 24 hinzugefügt |
Gibt den Tangens eines Winkels zurück, gemessen im Bogenmaß.
Siehe auch native_tan().
tanh : Hyperbolischer Tangens
| float tanh(float v); | |
| float2 tanh(float2 v); | |
| float3 tanh(float3 v); | |
| float4 tanh(float4 v); | |
| half tanh(halb v); | In API-Level 24 hinzugefügt |
| half2 tanh(half2 v); | In API-Level 24 hinzugefügt |
| half3 tanh(half3 v); | In API-Level 24 hinzugefügt |
| half4 tanh(half4 v); | In API-Level 24 hinzugefügt |
Gibt den hyperbolischen Tangens eines Werts zurück.
Siehe auch native_tanh().
tanpi : Tangens einer Zahl multipliziert mit Pi
| float tanpi(float v); | |
| float2 tanpi(float2 v); | |
| float3 tanpi(float3 v); | |
| float4 tanpi(float4 v); | |
| half tanpi(halb v); | In API-Level 24 hinzugefügt |
| half2 tanpi(half2 v); | In API-Level 24 hinzugefügt |
| half3 tanpi(half3 v); | In API-Level 24 hinzugefügt |
| half4 tanpi(half4 v); | In API-Level 24 hinzugefügt |
Gibt den Tangens von (v * pi) zurück, wobei (v * pi) in Radiant gemessen wird.
Um den Tangens eines in Grad gemessenen Werts zu erhalten, rufen Sie tanpi(v / 180.f) auf.
Siehe auch native_tanpi().
tgamma : Gammafunktion
| Gleitkommazahl tgamma(Gleitkommazahl v); | |
| FLOAT2 tgamma(FLOAT2 v); | |
| float3 tgamma(float3 v); | |
| float4 tgamma(float4 v); | |
| half tgamma(halb V); | In API-Level 24 hinzugefügt |
| half2 tgamma(half2 v); | In API-Level 24 hinzugefügt |
| half3 tgamma(half3 v); | In API-Level 24 hinzugefügt |
| half4 tgamma(half4 v); | In API-Level 24 hinzugefügt |
Gibt die Gammafunktion eines Werts zurück.
Siehe auch lgamma().
trunc : Kürzt einen Gleitkommawert
| float trunc(float v); | |
| float2 trunc(float2 v); | |
| float3 trunc(float3 v); | |
| float4 trunc(float4 v); | |
| half trunc(half v); | In API-Level 24 hinzugefügt |
| half2 trunc(half2 v); | In API-Level 24 hinzugefügt |
| half3 trunc(half3 v); | In API-Level 24 hinzugefügt |
| half4 trunc(half4 v); | In API-Level 24 hinzugefügt |