Cette page a été traduite par l'API Cloud Translation.

Constantes et fonctions mathématiques RenderScript

Présentation

Les fonctions mathématiques ci-dessous peuvent être appliquées aux scalaires et aux vecteurs. Lorsqu'elle est appliquée à des vecteurs, la valeur renvoyée est un vecteur de la fonction appliquée à chaque entrée de l'entrée.

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

Consultez la section Fonctions de mathématiques vectorielles pour obtenir des fonctions telles que distance() et length() qui interprètent plutôt l'entrée comme un vecteur unique dans un espace à N dimensions.

La précision des opérations mathématiques sur les floats 32 bits est affectée par les pragmas rs_fp_relaxed et rs_fp_full. Sous rs_fp_relaxed, les valeurs subnormales peuvent être vidées à zéro et les valeurs arrondies peuvent être arrondies vers zéro. En comparaison, rs_fp_full nécessite de traiter correctement les valeurs subnormales, c'est-à-dire inférieures à 1,17549435e-38f. rs_fp_rull nécessite également d'arrondir au plus proche avec des relations égales à pair.

Différents compromis de précision/vitesse peuvent être obtenus en utilisant des variantes des fonctions mathématiques courantes. Fonctions dont le nom commence par

native_: peut disposer d'implémentations matérielles personnalisées avec une précision plus faible. En outre, les valeurs subnormales peuvent être vidées à zéro, les valeurs arrondies vers zéro peuvent être utilisées, et les valeurs NaN et infinies peuvent ne pas être gérées correctement.
Half_: peut effectuer des calculs internes à l'aide de floats 16 bits. En outre, les valeurs inférieures à zéro peuvent être arrondies à zéro.

Résumé

Constantes
M_1_PI	1 / pi, en tant que valeur flottante de 32 bits
M_2_PI	2 / pi, en tant que float 32 bits
M_2_RACINE.PI	2 / carrée(pi), en tant que float 32 bits
M_E	e, sous la forme d'une valeur flottante de 32 bits
M_LN10	log_e(10), sous forme de float 32 bits
M_LN2	log_e(2), sous forme de float 32 bits
M_LOG10E	log_10(e), sous forme de float 32 bits
LOG2E_M	log_2(e), sous forme de float 32 bits
M_PI	pi, sous la forme d'une valeur flottante de 32 bits
M_PI_2	pi / 2, en tant que valeur flottante de 32 bits
M_PI_4	pi / 4, en tant que float 32 bits
M_RACINE1_2	1 / carrée(2), en tant que float 32 bits
M_RACINE2	sqrt(2), en tant que valeur flottante de 32 bits

Fonctions
abdos	Valeur absolue d'un entier
Acos	Cosinus inverse
Acosh	Cosinus hyperbolique inverse
Acospi	Cosinus inverse divisé par pi
asin	Sinus inverse
Asinh	Sinus hyperbolique inverse
Asinpi	Sinus inverse divisé par pi
TAtan	Tangente inversée
Atan2	Tangente inverse d'un ratio
atan2pi	Tangente inverse d'un ratio, divisée par Pi
Atanh	Tangente hyperbolique inverse
Atanpi	Tangente inverse divisée par Pi
cbrt	Racine cubique
ceil	Le plus petit nombre entier supérieur ou égal à une valeur
pincer	Limiter une valeur à une plage
clz	Nombre de 0 bits au début
copier	Copie le signe d'un nombre dans un autre
Cs	Cosinus
cosh	Cosinus hypobolique
Cospi	Cosinus d'un nombre multiplié par pi
degrés	Convertit des radians en degrés
erf	Fonction d'erreur mathématique
ERFC	Fonction d'erreur mathématique complémentaire
expérience	e élevé à un nombre
"exp10"	10 élevé à un nombre
Exp2	2 élevé à un nombre
expm1	e élevé à un chiffre moins un
fabricants de café	Valeur absolue d'un float
FID	Différence positive entre deux valeurs
étage	Le plus petit nombre entier inférieur à une valeur
FMA	Multiplier et ajouter
FMax	Deux valeurs flottantes au maximum
Fmin	Minimum de deux nombres à virgule flottante
Fmod	Module
fracter	Partie fractionnaire positive
frexp	Mantisse binaire et exposant
demi-récip	Calcul réciproque avec une précision de 16 bits
half_rsqrt	Réciproque d'une racine carrée calculée avec une précision de 16 bits
half_sqrt	Racine carrée calculée avec une précision de 16 bits
hypot	Hypoténuse
Ilogb	Exposant de base deux
ldexp	Crée une valeur à virgule flottante à partir d'une mantisse et de l'exposant
Lgamma	Logarithme naturel de la fonction gamma
journal	Logarithme naturel
Journal10	Logarithme de base 10
log1p	Logarithme naturel d'une valeur plus 1
Journal2	Logarithme de base 2
Logb	Exposant de base deux
fou	Multiplier et ajouter
max.	Maximum
min	Minimum
mix	Mélange deux valeurs
modf	Composants intégraux et fractionnaires
Nan	N'est pas un nombre
nan_half	N'est pas un nombre
native_acos	Cosinus inverse approximatif
native_acosh	Cosinus hyperbolique inverse approximatif
native_acospi	Cosinus inverse approximatif divisé par pi
native_asin [asin_native]	Sinus inverse approximatif
native_asinh	Sinus hyperbolique inverse approximatif
native_asinpi	Sinus inverse approximatif divisé par pi
native_atan	Tangente inverse approximative
native_atan2	Tangente inverse approximative d'un ratio
native_atan2pi	Tangente inverse approximative d'un ratio, divisée par Pi
native_atanh	Tangente hyperbolique inverse approximative
native_atanpi	Tangente inverse approximative divisée par Pi
native_cbrt	Racine cubique approximative
native_cos	Cosinus approximatif
native_cosh	Cosinus hypébolique approximatif
native_cospi	Cosinus approximatif d'un nombre multiplié par pi
native_divide	Division approximative
native_exp.	e approximatif élevé à un nombre
native_exp10.	Environ 10 remontées à un nombre donné
native_exp2	Environ 2 élevé à un nombre
native_expm1.	E approximatif élevé à un chiffre moins un
native_hypot (hypothèse_native)	Hypoténuse approximatif
native_log	Logarithme naturel approximatif
log10_native	Logarithme en base 10 approximatif
native_log1p	Logarithme naturel approximatif d'une valeur plus 1
log_native_2	Logarithme approximatif en base 2
native_powr	Base positive approximative élevée à un exposant
native_recip	Réciproque approximatif
native_rootn	Racine n-ième approximative
native_rsqrt.	Réciproque approximatif d'une racine carrée
native_sin (sin_natif)	Sinus approximatif
native_sincos	Sinus et cosinus approximatifs
native_sinh	Sinus hyperbolique approximatif
native_sinpi	Sinus approximatif d'un nombre multiplié par pi
native_sqrt.	Racine carrée approximative
native_tan	Tangente approximative
native_tanh	Tangente hyperbolique approximative
native_tanpi	Tangente approximative d'un nombre multiplié par pi
Suivant	Nombre à virgule flottante suivant
mouve	Base élevée à un exposant
	Base élevée à un exposant entier
powr	Base positive élevée à un exposant
radians	Convertit des degrés en radians
reste	Reste d'une division
Remquo	Reste et quotient d'une division
rincer	Arrondir au nombre pair
rootn	Racine n-ième
arrondi	Arrondi à zéro
rsRand	Nombre pseudo-aléatoire
	Réciproque d'une racine carrée
signe	Signe d'une valeur
sin	Sinus
sincos	Sinus et cosinus
sinh	Sinus hyperbolique
Sinpi	Sinus d'un nombre multiplié par Pi
raccourci	Racine carrée
pas	0 si inférieur à une valeur, 1 dans le cas contraire
brun clair	Tangente
Tanh	Tangente hyperbolique
tanpi	Tangente d'un nombre multiplié par Pi
tgamma	Fonction gamma
tronc	Tronque une valeur à virgule flottante

Fonctions obsolètes
Scrampe rs	Obsolète. Limiter une valeur à une plage
RSFrac	Obsolète. Affiche la partie fractionnaire d'un nombre à virgule flottante.

Constantes

M_1_PI : 1 / pi, en tant que valeur flottante de 32 bits

Valeur: 0.318309886183790671537767526745028724f

Inversement de pi, sous forme de float 32 bits.

M_2_PI : 2 / pi, en tant que valeur flottante de 32 bits

Valeur: 0.636619772367581343075535053490057448f

2 divisé par pi, sous la forme d'une valeur flottante de 32 bits.

M_2_SQRTPI : 2 / carré(pi), en tant que float 32 bits

Valeur: 1.128379167095512573896158903121545172f

2 divisé par la racine carrée de pi, sous la forme d'une valeur flottante de 32 bits.

M_E : e, en tant que float 32 bits

Valeur: 2.718281828459045235360287471352662498f

Nombre e, base du logarithme naturel, sous forme de nombre à virgule flottante de 32 bits.

M_LN10 : log_e(10), en tant que float 32 bits

Valeur: 2.302585092994045684017991454684364208f

Logarithme naturel de 10, en tant que float 32 bits.

M_LN2 : log_e(2), en tant que float 32 bits

Valeur: 0.693147180559945309417232121458176568f

Logarithme naturel de 2, sous forme de float 32 bits.

M_LOG10E : log_10(e), en tant que valeur flottante de 32 bits

Valeur: 0.434294481903251827651128918916605082f

Logarithme base 10 de e, sous forme de nombre à virgule flottante de 32 bits.

M_LOG2E : log_2(e), sous forme de nombre décimal 32 bits

Valeur: 1.442695040888963407359924681001892137f

Logarithme en base 2 de e, sous forme de nombre à virgule flottante de 32 bits.

M_PI : pi, sous forme de float 32 bits

Valeur: 3.141592653589793238462643383279502884f

Constante pi, sous forme de float 32 bits

M_PI_2 : pi / 2, sous forme de valeur flottante de 32 bits

Valeur: 1.570796326794896619231321691639751442f

Pi divisé par 2, sous la forme d'une valeur flottante de 32 bits.

M_PI_4 : pi / 4, sous forme de valeur flottante de 32 bits

Valeur: 0.785398163397448309615660845819875721f

Pi divisé par 4, sous la forme d'une valeur flottante de 32 bits.

M_SQRT1_2 : 1 / carré(2), en tant que float 32 bits

Valeur: 0.707106781186547524400844362104849039f

Inversé de la racine carrée de 2, exprimée en nombre à virgule flottante de 32 bits.

M_SQRT2 : sqrt(2), sous forme de nombre décimal 32 bits

Valeur: 1.414213562373095048801688724209698079f

Racine carrée de 2, en tant que float 32 bits.

Fonctions

abs : valeur absolue d'un entier

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

Renvoie la valeur absolue d'un entier.

Pour les flottants, utilisez fabs().

acos : cosinus inverse

float acos(float v);
float2 acos(float2 v);
float3 acos(float3 v);
float4 acos(float4 v);
half acos(moitié v);	Ajouté au niveau d'API 24
half2 acos(half2 v);	Ajouté au niveau d'API 24
half3 acos(half3 v);	Ajouté au niveau d'API 24
half4 acos(half4 v);	Ajouté au niveau d'API 24

Renvoie le cosinus inverse, en radians.

Voir aussi native_acos().

acosh : cosinus hyperbolique inverse

float acosh(float v);
float2 acosh(float2 v);
float3 acosh(float3 v);
float4 acosh(float4 v);
half acosh(moitié v);	Ajouté au niveau d'API 24
half2 acosh(half2 v);	Ajouté au niveau d'API 24
half3 acosh(half3 v);	Ajouté au niveau d'API 24
half4 acosh(half4 v);	Ajouté au niveau d'API 24

Renvoie le cosinus hyperbolique inverse, en radians.

Voir aussi native_acosh().

acospi : cosinus inverse divisé par pi

float acospi(float v);
float2 acospi(float2 v);
float3 acospi(float3 v);
float4 acospi(float4 v);
half acospi(moitié v);	Ajouté au niveau d'API 24
half2 acospi(half2 v);	Ajouté au niveau d'API 24
half3 acospi(half3 v);	Ajouté au niveau d'API 24
half4 acospi(half4 v);	Ajouté au niveau d'API 24

Renvoie le cosinus inverse en radians, divisé par Pi.

Pour obtenir un cosinus inverse mesuré en degrés, utilisez acospi(a) * 180.f.

Voir aussi native_acospi().

asin : sinus inverse

float asin(float v);
float2 asin(float2 v);
float3 asin(float3 v);
float4 asin(float4 v);
half asin(moitié v);	Ajouté au niveau d'API 24
half2 asin(half2 v);	Ajouté au niveau d'API 24
half3 asin(half3 v);	Ajouté au niveau d'API 24
half4 asin(half4 v);	Ajouté au niveau d'API 24

Renvoie le sinus inverse, en radians.

Voir aussi native_asin().

asinh : sinus hyperbolique inverse

float asinh(float v);
float2 asinh(float2 v);
float3 asinh(float3 v);
float4 asinh(float4 v);
half asinh(moitié v);	Ajouté au niveau d'API 24
half2 asinh(half2 v);	Ajouté au niveau d'API 24
half3 asinh(half3 v);	Ajouté au niveau d'API 24
half4 asinh(half4 v);	Ajouté au niveau d'API 24

Renvoie le sinus hyperbolique inverse, en radians.

Voir aussi native_asinh().

asinpi : sinus inverse divisé par pi

float asinpi(float v);
float2 asinpi(float2 v);
float3 asinpi(float3 v);
float4 asinpi(float4 v);
half asinpi(moitié v);	Ajouté au niveau d'API 24
half2 asinpi(half2 v);	Ajouté au niveau d'API 24
half3 asinpi(half3 v);	Ajouté au niveau d'API 24
half4 asinpi(half4 v);	Ajouté au niveau d'API 24

Renvoie le sinus inverse en radians, divisé par Pi.

Pour obtenir un sinus inverse mesuré en degrés, utilisez asinpi(a) * 180.f.

Voir aussi native_asinpi().

atan : tangente inversée

float atan(float v);
float2 atan(float2 v);
float3 atan(float3 v);
float4 atan(float4 v);
half atan(moitié v);	Ajouté au niveau d'API 24
half2 atan(half2 v);	Ajouté au niveau d'API 24
half3 atan(half3 v);	Ajouté au niveau d'API 24
half4 atan(half4 v);	Ajouté au niveau d'API 24

Renvoie la tangente inverse, en radians.

Voir aussi native_atan().

atan2 : tangente inverse d'un ratio

float atan2(numérateur à virgule flottante, dénominateur à virgule flottante);
float2 atan2(numérateur float2, dénominateur float2);
float3 atan2(numérateur float3, dénominateur float3);
float4 atan2(numérateur float4, dénominateur float4);
half atan2(moiti numérateur, demi dénominateur);	Ajouté au niveau d'API 24
half2 atan2(numérateur half2, moitié2 dénominateur);	Ajouté au niveau d'API 24
half3 atan2(numérateur moitié3, dénominateur moitié3);	Ajouté au niveau d'API 24
half4 atan2(numérateur moitié4, dénominateur moitié4);	Ajouté au niveau d'API 24

Paramètres

numérateur	Numérateur.
dénominateur	dénominateur. Peut être égal à 0.

Renvoie la tangente inverse de (numerator / denominator), en radians.

Voir aussi native_atan2().

atan2pi : tangente inverse d'un ratio, divisée par pi

float atan2pi(numérateur flottant, dénominateur à virgule flottante)
float2 atan2pi(numérateur float2, dénominateur float2);
float3 atan2pi(numérateur float3, dénominateur float3);
float4 atan2pi(numérateur float4, dénominateur float4);
half atan2pi(demi numérateur, demi dénominateur);	Ajouté au niveau d'API 24
half2 atan2pi(numérateur half2, dénominateur half2);	Ajouté au niveau d'API 24
half3 atan2pi(numérateur half3, dénominateur half3);	Ajouté au niveau d'API 24
half4 atan2pi(numérateur half4, dénominateur half4);	Ajouté au niveau d'API 24

Paramètres

numérateur	Numérateur.
dénominateur	dénominateur. Peut être égal à 0.

Renvoie la tangente inverse de (numerator / denominator), en radians, divisée par Pi.

Pour obtenir la tangente inverse, mesurée en degrés, utilisez atan2pi(n, d) * 180.f.

Voir aussi native_atan2pi().

atanh : tangente hyperbolique inverse

float atanh(float v);
float2 atanh(float2 v);
float3 atanh(float3 v);
float4 atanh(float4 v);
half atanh(moitié v);	Ajouté au niveau d'API 24
half2 atanh(half2 v);	Ajouté au niveau d'API 24
half3 atanh(half3 v);	Ajouté au niveau d'API 24
half4 atanh(half4 v);	Ajouté au niveau d'API 24

Renvoie la tangente hyperbolique inverse, en radians.

Voir aussi native_atanh().

atanpi : tangente inverse divisée par pi

float atanpi(float v);
float2 atanpi(float2 v);
float3 atanpi(float3 v);
float4 atanpi(float4 v);
half atanpi(moitié v);	Ajouté au niveau d'API 24
half2 atanpi(half2 v);	Ajouté au niveau d'API 24
half3 atanpi(half3 v);	Ajouté au niveau d'API 24
half4 atanpi(half4 v);	Ajouté au niveau d'API 24

Renvoie la tangente inverse en radians, divisée par Pi.

Pour obtenir la tangente inverse, mesurée en degrés, utilisez atanpi(a) * 180.f.

Voir aussi native_atanpi().

cbrt : racine cubique

float cbrt(float v);
float2 cbrt(float2 v);
float3 cbrt(float3 v);
float4 cbrt(float4 v);
half cbrt(moitié v);	Ajouté au niveau d'API 24
half2 cbrt(half2 v);	Ajouté au niveau d'API 24
half3 cbrt(half3 v);	Ajouté au niveau d'API 24
half4 cbrt(half4 v);	Ajouté au niveau d'API 24

Renvoie la racine cubique.

Voir aussi native_cbrt().

ceil : entier le plus petit inférieur ou supérieur à une valeur

float ceil(float v);
float2 ceil(float2 v);
float3 ceil(float3 v);
float4 ceil(float4 v);
demi plafond(moitié v);	Ajouté au niveau d'API 24
half2 ceil(half2 v);	Ajouté au niveau d'API 24
half3 ceil(half3 v);	Ajouté au niveau d'API 24
half4 ceil(half4 v);	Ajouté au niveau d'API 24

Renvoie le plus petit nombre entier supérieur ou égal à une valeur.

Par exemple, ceil(1.2f) renvoie 2.f, et ceil(-1.2f) renvoie -1.f.

Voir aussi floor().

clamp : restreignez une valeur à une plage.

char clamp(char value, char min_value, char max_value);	Ajouté au niveau d'API 19
char2 clamp(valeur char2, char min_value, char max_value);	Ajouté au niveau d'API 19
char2 clamp(valeur char2, char2 min_value, char2 max_value);	Ajouté au niveau d'API 19
char3 clamp(valeur char3, char min_value, char max_value);	Ajouté au niveau d'API 19
char3 clamp(valeur char3, char3 min_value, char3 max_value);	Ajouté au niveau d'API 19
char4 clamp(valeur char4, char min_value, char max_value);	Ajouté au niveau d'API 19
char4 clamp(valeur char4, valeur_min char4, valeur_max_char4);	Ajouté au niveau d'API 19
float clamp(valeur flottante, valeur min_float, valeur_max_float),
float2 clamp(valeur float2, valeur_min_flottante, valeur_max_float),
float2 clamp(valeur float2, valeur min_float2, valeur_max_float2),
float3 clamp(valeur float3, valeur_min_flottante, valeur_max_float),
float3 clamp(valeur float3, valeur min_float3, valeur max_max float3);
float4 clamp(valeur float4, valeur_min_flottante, valeur_max_float),
float4 clamp(valeur float4, valeur_min float4, valeur_max_float4);
half clamp(demi valeur, moitié min_value, moitié max_value);	Ajouté au niveau d'API 24
half2 clamp(valeur half2, moitié min_value, moitié max_value);	Ajouté au niveau d'API 24
half2 clamp(valeur half2, half2 min_value, half2 max_value);	Ajouté au niveau d'API 24
half3 clamp(valeur half3, moitié min_value, moitié max_value);	Ajouté au niveau d'API 24
half3 clamp(valeur half3, half3 min_value, half3 max_value);	Ajouté au niveau d'API 24
half4 clamp(valeur half4, moitié min_value, moitié max_value);	Ajouté au niveau d'API 24
half4 clamp(valeur half4, half4 min_value, half4 max_value);	Ajouté au niveau d'API 24
int clamp(int value, int min_value, int max_value);	Ajouté au niveau d'API 19
int2 clamp(valeur int2, int min_value, int max_value);	Ajouté au niveau d'API 19
int2 clamp(valeur int2, valeur min_int2, valeur_max int2);	Ajouté au niveau d'API 19
int3 clamp(valeur int3, int min_value, int max_value);	Ajouté au niveau d'API 19
int3 clamp(valeur int3, int3 min_value, int3 max_value);	Ajouté au niveau d'API 19
int4 clamp(valeur int4, int min_value, int max_value);	Ajouté au niveau d'API 19
int4 clamp(valeur int4, valeur min_int4, valeur_max int4);	Ajouté au niveau d'API 19
long clamp(long value, long min_value, long max_value);	Ajouté au niveau d'API 19
long2 clamp(valeur long2, long min_value, long max_value);	Ajouté au niveau d'API 19
long2 clamp(valeur long2, long2 min_value, long2 max_value);	Ajouté au niveau d'API 19
long3 clamp(valeur long3, long min_value, long max_value);	Ajouté au niveau d'API 19
long3 clamp(valeur long3, long3 min_value, long3 max_value);	Ajouté au niveau d'API 19
long4 clamp(valeur long4, long min_value, long max_value);	Ajouté au niveau d'API 19
long4 clamp(valeur long4, long4 min_value, long4 max_value);	Ajouté au niveau d'API 19
short clamp(short value, short min_value, short max_value);	Ajouté au niveau d'API 19
short2 clamp(valeur short2, short min_value, short max_value);	Ajouté au niveau d'API 19
short2 clamp(valeur short2, short2 min_value, short2 max_value);	Ajouté au niveau d'API 19
short3 clamp(valeur short3, short min_value, short max_value);	Ajouté au niveau d'API 19
short3 clamp(valeur short3, short3 min_value, short3 max_value);	Ajouté au niveau d'API 19
short4 clamp(valeur short4, short min_value, short max_value);	Ajouté au niveau d'API 19
short4 clamp(valeur short4, short4 min_value, short4 max_value);	Ajouté au niveau d'API 19
uchar clamp(valeur uchar, valeur_min uchar, valeur_max_uchar);	Ajouté au niveau d'API 19
uchar2 clamp(valeur uchar2, valeur min_uchar, valeur_max_uchar);	Ajouté au niveau d'API 19
uchar2 clamp(valeur uchar2, valeur_min uchar2, valeur_max_uchar2);	Ajouté au niveau d'API 19
uchar3 clamp(valeur uchar3, valeur min_uchar, valeur_max_uchar);	Ajouté au niveau d'API 19
uchar3 clamp(valeur uchar3, valeur_min uchar3, valeur_max_uchar3);	Ajouté au niveau d'API 19
uchar4 clamp(valeur uchar4, valeur_min uchar, valeur_max_uchar);	Ajouté au niveau d'API 19
uchar4 clamp(valeur uchar4, valeur_min uchar4, valeur_max_uchar4);	Ajouté au niveau d'API 19
uint clamp(valeur uint, uint min_value, uint max_value);	Ajouté au niveau d'API 19
uint2 clamp(valeur uint2, uint min_value, uint max_value);	Ajouté au niveau d'API 19
uint2 clamp(valeur uint2, valeur min_uint2, valeur_max uint2);	Ajouté au niveau d'API 19
uint3 clamp(valeur uint3, uint min_value, uint max_value);	Ajouté au niveau d'API 19
uint3 clamp(valeur uint3, uint3 min_value, uint3 max_value);	Ajouté au niveau d'API 19
uint4 clamp(valeur uint4, uint min_value, uint max_value);	Ajouté au niveau d'API 19
uint4 clamp(valeur uint4, valeur min_uint4, valeur_max. uint4);	Ajouté au niveau d'API 19
ulong clamp(valeur ulong, ulong min_value, ulong max_value);	Ajouté au niveau d'API 19
ulong2 clamp(valeur ulong2, ulong min_value, ulong max_value);	Ajouté au niveau d'API 19
ulong2 clamp(valeur ulong2, ulong2 min_value, ulong2 max_value);	Ajouté au niveau d'API 19
ulong3 clamp(valeur ulong3, ulong min_value, ulong max_value);	Ajouté au niveau d'API 19
ulong3 clamp(valeur ulong3, ulong3 min_value, ulong3 max_value);	Ajouté au niveau d'API 19
ulong4 clamp(valeur ulong4, ulong min_value, ulong max_value);	Ajouté au niveau d'API 19
ulong4 clamp(valeur ulong4, ulong4 min_value, ulong4 max_value);	Ajouté au niveau d'API 19
ushort clamp(valeur ushort, ushort min_value, ushort max_value);	Ajouté au niveau d'API 19
ushort2 clamp(valeur ushort2, ushort min_value, ushort max_value);	Ajouté au niveau d'API 19
ushort2 clamp(valeur ushort2, ushort2 min_value, ushort2 max_value);	Ajouté au niveau d'API 19
ushort3 clamp(valeur ushort3, ushort min_value, ushort max_value);	Ajouté au niveau d'API 19
ushort3 clamp(valeur ushort3, ushort3 min_value, ushort3 max_value);	Ajouté au niveau d'API 19
ushort4 clamp(valeur ushort4, valeur min_ushort, ushort max_value);	Ajouté au niveau d'API 19
ushort4 clamp(valeur ushort4, ushort4 min_value, ushort4 max_value);	Ajouté au niveau d'API 19

Paramètres

value	Valeur à limiter.
valeur_min	Limite inférieure, un vecteur scalaire ou correspondant.
valeur_max	Limite supérieure, doit correspondre au type de valeur basse.

Fixe une valeur à une limite supérieure et inférieure spécifiée. clamp() renvoie min_value si valeur < min_value, max_value if value > max_value, sinon valeur.

Il existe deux variantes de limitation: l'une où les valeurs minimale et maximale sont des scalaires appliquées à toutes les entrées de la valeur, l'autre où les valeurs minimale et maximale sont également des vecteurs.

Si min_value est supérieure à max_value, les résultats ne sont pas définis.

clz : nombre de 0 bits au début

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

Renvoie le nombre de 0 bits du début d'une valeur.

Par exemple, clz((char)0x03) renvoie 6.

copysign Copie le signe d'un nombre dans un autre

float copysign(float magnitude_value, float sign_value);
float2 copysign(float2 magnitude_value, float2 sign_value);
float3 copysign(float3 magnitude_value, float3 sign_value);
float4 copysign(float4 magnitude_value, float4 sign_value);
half copysign(demi magnitude_value, demi sign_value);	Ajouté au niveau d'API 24
half2 copysign(half2 magnitude_value, half2 sign_value);	Ajouté au niveau d'API 24
half3 copysign(half3 magnitude_value, half3 sign_value);	Ajouté au niveau d'API 24
half4 copysign(half4 magnitude_value, half4 sign_value);	Ajouté au niveau d'API 24

Copie le signe de "sign_value" vers "magnitude_value".

La valeur renvoyée est magnitude_value ou -magnitude_value.

Par exemple, copysign(4.0f, -2.7f) renvoie -4.0f et copysign(-4.0f, 2.7f) renvoie 4.0f.

cos : cosinus

float cos(float v);
float2 cos(float2 v);
float3 cos(float3 v);
float4 cos(float4 v);
half cos(moitié v);	Ajouté au niveau d'API 24
half2 cos(half2 v);	Ajouté au niveau d'API 24
half3 cos(half3 v);	Ajouté au niveau d'API 24
half4 cos(half4 v);	Ajouté au niveau d'API 24

Renvoie le cosinus d'un angle mesuré en radians.

Voir aussi native_cos().

cosh : cosinus hyperbolique

float cosh(float v);
float2 cosh(float2 v);
float3 cosh(float3 v);
float4 cosh(float4 v);
half cosh(moitié v);	Ajouté au niveau d'API 24
half2 cosh(half2 v);	Ajouté au niveau d'API 24
half3 cosh(half3 v);	Ajouté au niveau d'API 24
half4 cosh(half4 v);	Ajouté au niveau d'API 24

Renvoie le cosinus hypébolique de v, où v est mesuré en radians.

Voir aussi native_cosh().

cospi : cosinus d'un nombre multiplié par pi

float cospi(float v);
float2 cospi(float2 v);
float3 cospi(float3 v);
float4 cospi(float4 v);
half cospi(moitié v);	Ajouté au niveau d'API 24
half2 cospi(half2 v);	Ajouté au niveau d'API 24
half3 cospi(half3 v);	Ajouté au niveau d'API 24
half4 cospi(half4 v);	Ajouté au niveau d'API 24

Renvoie le cosinus de (v * pi), où (v * pi) est mesuré en radians.

Pour obtenir le cosinus d'une valeur mesurée en degrés, appelez cospi(v / 180.f).

Voir aussi native_cospi().

degrés : convertit des radians en degrés

float degrés(float v);
float2 degrees(float2 v);
float3 degrees(float3 v);
float4 degrees(float4 v);
demidegrés(moitié v);	Ajouté au niveau d'API 24
half2 degrees(half2 v);	Ajouté au niveau d'API 24
half3 degrees(half3 v);	Ajouté au niveau d'API 24
half4 degrees(half4 v);	Ajouté au niveau d'API 24

Convertit des radians en degrés.

erf : fonction d'erreur mathématique

float erf(float v);
float2 erf(float2 v);
float3 erf(float3 v);
float4 erf(float4 v);
half erf(moitié v);	Ajouté au niveau d'API 24
half2 erf(half2 v);	Ajouté au niveau d'API 24
half3 erf(half3 v);	Ajouté au niveau d'API 24
half4 erf(half4 v);	Ajouté au niveau d'API 24

Renvoie la fonction d'erreur.

erfc : fonction d'erreur mathématique complémentaire

float erfc(float v);
float2 erfc(float2 v);
float3 erfc(float3 v);
float4 erfc(float4 v);
half erfc(moitié v);	Ajouté au niveau d'API 24
half2 erfc(half2 v);	Ajouté au niveau d'API 24
half3 erfc(half3 v);	Ajouté au niveau d'API 24
half4 erfc(half4 v);	Ajouté au niveau d'API 24

Renvoie la fonction d'erreur complémentaire.

exp : e élevé à un nombre

float exp(float v);
float2 exp(float2 v);
float3 exp(float3 v);
float4 exp(float4 v);
half exp(moitié v);	Ajouté au niveau d'API 24
half2 exp(half2 v);	Ajouté au niveau d'API 24
half3 exp(half3 v);	Ajouté au niveau d'API 24
half4 exp(half4 v);	Ajouté au niveau d'API 24

Renvoie e élevé à v, c'est-à-dire e ^ v.

Voir aussi native_exp().

exp10 : 10 élevé à un nombre

float exp10(float v);
float2 exp10(float2 v);
float3 exp10(float3 v);
float4 exp10(float4 v);
half exp10(moitié v);	Ajouté au niveau d'API 24
half2 exp10(half2 v);	Ajouté au niveau d'API 24
half3 exp10(half3 v);	Ajouté au niveau d'API 24
half4 exp10(half4 v);	Ajouté au niveau d'API 24

Renvoie 10 élevé à v, c'est-à-dire 10.f ^ v.

Voir aussi native_exp10().

exp2 : 2 élevé à un nombre

float exp2(float v);
float2 exp2(float2 v);
float3 exp2(float3 v);
float4 exp2(float4 v);
half exp2(moitié v);	Ajouté au niveau d'API 24
half2 exp2(half2 v);	Ajouté au niveau d'API 24
half3 exp2(half3 v);	Ajouté au niveau d'API 24
half4 exp2(half4 v);	Ajouté au niveau d'API 24

Renvoie 2 élevé à v, c'est-à-dire 2.f ^ v.

Voir aussi native_exp2().

expm1 : e élevé à un nombre moins un

float expm1(float v);
float2 expm1(float2 v);
float3 expm1(float3 v);
float4 expm1(float4 v);
half expm1(moitié v);	Ajouté au niveau d'API 24
half2 expm1(half2 v);	Ajouté au niveau d'API 24
half3 expm1(half3 v);	Ajouté au niveau d'API 24
half4 expm1(half4 v);	Ajouté au niveau d'API 24

Renvoie e élevé à v moins 1, c'est-à-dire (e ^ v) - 1.

Voir aussi native_expm1().

fabs : valeur absolue d'un float

float fabs(float v);
fabs float2(float2 v);
fabs float3(float3 v);
fabs float4(float4 v);
half fabs(moitié v);	Ajouté au niveau d'API 24
half2 fabs(half2 v);	Ajouté au niveau d'API 24
half3 fabs(half3 v);	Ajouté au niveau d'API 24
half4 fabs(half4 v);	Ajouté au niveau d'API 24

Renvoie la valeur absolue de "float v".

Pour les entiers, utilisez abs().

fdim : différence positive entre deux valeurs

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(moitié a, moiti b);	Ajouté au niveau d'API 24
half2 fdim(half2 a, half2 b);	Ajouté au niveau d'API 24
half3 fdim(half3 a, half3 b);	Ajouté au niveau d'API 24
half4 fdim(half4 a, half4 b);	Ajouté au niveau d'API 24

Renvoie la différence positive entre deux valeurs.

Si a > b, renvoie (a - b) autrement renvoie 0f.

floor : entier le plus petit inférieur à une valeur

float floor(float v);
float2 floor(float2 v);
float3 floor(float3 v);
float4 floor(float4 v);
moitié étage(moitié v);	Ajouté au niveau d'API 24
half2 floor(half2 v);	Ajouté au niveau d'API 24
half3 floor(half3 v);	Ajouté au niveau d'API 24
half4 floor(half4 v);	Ajouté au niveau d'API 24

Renvoie le plus petit nombre entier inférieur à une valeur.

Par exemple, floor(1.2f) renvoie 1.f, et floor(-1.2f) renvoie -2.f.

Voir aussi ceil().

fma : multiplier et ajouter

float fma(float multiplicand1, float multiplicand2, float offset);
float2 fma(float2 multiplicand1, float2 multiplicand2, décalage de float2) ;
float3 fma(float3 multiplicand1, float3 multiplicand2, décalage float3) ;
float4 fma(float4 multiplicand1, float4 multiplicand2, décalage de float4) ;
half fma(demi multiplicande1, demi multiplicande2, moitié décalage);	Ajouté au niveau d'API 24
half2 fma(half2 multiplicande1, half2 multiplicande2, half2)	Ajouté au niveau d'API 24
half3 fma(half3 multiplicande1, half3 multiplicande2, half3)	Ajouté au niveau d'API 24
500 m	Ajouté au niveau d'API 24

Multipliez et ajoutez. Renvoie (multiplicand1 * multiplicand2) + offset.

Cette fonction est semblable à mad(). fma() conserve la précision complète du résultat multiplié et n'arrondit qu'après l'addition. mad() arrondit les nombres après la multiplication et l'addition. Cette précision supplémentaire n'est pas garantie en mode rs_fp_relaxed.

fmax : deux nombres à virgule flottante maximum

float fmax(float a, float b);
float2 fmax(float2 a, float b);
float2 fmax(float2 a, float2 b);
float3 fmax(float3 a, float b);
float3 fmax(float3 a, float3 b);
float4 fmax(float4 a, float b);
float4 fmax(float4 a, float4 b);
half fmax(moitié a, moitié b);	Ajouté au niveau d'API 24
half2 fmax(half2 a, moitié b);	Ajouté au niveau d'API 24
half2 fmax(half2 a, half2 b);	Ajouté au niveau d'API 24
half3 fmax(half3 a, moitié b);	Ajouté au niveau d'API 24
half3 fmax(half3 a, half3 b);	Ajouté au niveau d'API 24
half4 fmax(half4 a, moitié b);	Ajouté au niveau d'API 24
half4 fmax(half4 a, half4 b);	Ajouté au niveau d'API 24

Renvoie la valeur maximale de a et b, c'est-à-dire (a < b ? b : a).

La fonction max() renvoie des résultats identiques, mais peut être appliquée à davantage de types de données.

fmin : nombre minimal de deux nombres à virgule flottante

float fmin(float a, float b);
float2 fmin(float2 a, float b);
float2 fmin(float2 a, float2 b);
float3 fmin(float3 a, float b);
float3 fmin(float3 a, float3 b);
float4 fmin(float4 a, float b);
float4 fmin(float4 a, float4 b);
half fmin(moitié a, moiti b);	Ajouté au niveau d'API 24
half2 fmin(half2 a, half b);	Ajouté au niveau d'API 24
half2 fmin(half2 a, half2 b);	Ajouté au niveau d'API 24
half3 fmin(half3 a, moitié b);	Ajouté au niveau d'API 24
half3 fmin(half3 a, half3 b);	Ajouté au niveau d'API 24
half4 fmin(half4 a, moitié b);	Ajouté au niveau d'API 24
half4 fmin(half4 a, half4 b);	Ajouté au niveau d'API 24

Renvoie le minimum de a et b, c'est-à-dire (a > b ? b : a).

La fonction min() renvoie des résultats identiques, mais peut être appliquée à davantage de types de données.

fmod : module

float fmod(numérateur à virgule flottante, dénominateur flottant);
float2 fmod(numérateur float2, dénominateur float2);
float3 fmod(numérateur float3, dénominateur float3);
float4 fmod(numérateur float4, dénominateur float4);
half fmod(moiti numérateur, demi dénominateur);	Ajouté au niveau d'API 24
half2 fmod(numérateur moitié2, dénominateur moitié2);	Ajouté au niveau d'API 24
half3 fmod(numérateur moitié3, dénominateur moitié3);	Ajouté au niveau d'API 24
half4 fmod(numérateur half4, dénominateur half4);	Ajouté au niveau d'API 24

Renvoie le reste de (numérateur / dénominateur), où le quotient est arrondi en s'approchant de zéro.

La fonction remainder() est similaire, mais arrondit en fonction de l'entier le plus proche. Par exemple, fmod(-3.8f, 2.f) renvoie -1.8f (-3.8f - -1.f * 2.f) tandis que remainder(-3.8f, 2.f) renvoie 0.2f (-3.8f - -2.f * 2.f).

fract : partie fractionnaire positive

float fract(float v);
float fract(float v, float* fract(float v, float* plancher);
float2 fract(float2 v);
float2 fract(float2 v, float2* floor);
float3 fract(float3 v);
float3 fract(float3 v, float3* floor);
float4 fract(float4 v);
fract float4(float4 v, float4* floor);
demi fract(moitié v);	Ajouté au niveau d'API 24
demi fract(moitié v, demi* étage);	Ajouté au niveau d'API 24
half2 fract(half2 v);	Ajouté au niveau d'API 24
half2 fract(half2 v, half2* étage);	Ajouté au niveau d'API 24
half3 fract(half3 v);	Ajouté au niveau d'API 24
half3 fract(half3 v, half3* étage);	Ajouté au niveau d'API 24
half4 fract(half4 v);	Ajouté au niveau d'API 24
half4 fract(half4 v, half4* étage);	Ajouté au niveau d'API 24

Paramètres

v	Valeur d'entrée.
étage	Si le prix plancher n'est pas nul, la valeur *floor sera définie sur le prix plancher de v.

Renvoie la partie fractionnaire positive de v, c'est-à-dire v - floor(v).

Par exemple, fract(1.3f, &val) renvoie 0.3f et définit val sur 1.f. fract(-1.3f, &val) renvoie 0.7f et définit val sur -2.f.

frexp : mantisse binaire et exposant

float frexp(float v, int* exposant);
float2 frexp(float2 v, int2* exposant);
float3 frexp(float3 v, int3* exposant);
float4 frexp(float4 v, int4* exposant);
half frexp(moitié v, int* exposant);	Ajouté au niveau d'API 24
half2 frexp(moitié2 v, int2* exposant);	Ajouté au niveau d'API 24
half3 frexp(half3 v, int3* exposant);	Ajouté au niveau d'API 24
half4 frexp(half4 v, int4* exposant);	Ajouté au niveau d'API 24

Paramètres

v	Valeur d'entrée.
exposant	Si l'exposant n'est pas nul, *exposant sera défini sur l'exposant de v.

Renvoie la mantissa binaire et l'exposant de v, c'est-à-dire v == mantissa * 2 ^ exponent.

La mantissa est toujours comprise entre 0,5 (inclus) et 1,0 (exclue).

Consultez ldexp() pour effectuer l'opération inverse. Voir aussi logb() et ilogb().

half_recip : réciproque calculé avec une précision de 16 bits

float half_recip(float v);	Ajouté au niveau d'API 17
float2 half_recip(float2 v);	Ajouté au niveau d'API 17
float3 half_recip(float3 v);	Ajouté au niveau d'API 17
float4 half_recip(float4 v);	Ajouté au niveau d'API 17

Renvoie l'inverse approximatif d'une valeur.

La précision est celle d'une valeur à virgule flottante de 16 bits.

Voir aussi native_recip().

half_rsqrt : valeur inverse d'une racine carrée calculée avec une précision de 16 bits

float half_rsqrt(float v);	Ajouté au niveau d'API 17
float2 half_rsqrt(float2 v);	Ajouté au niveau d'API 17
float3 half_rsqrt(float3 v);	Ajouté au niveau d'API 17
float4 half_rsqrt(float4 v);	Ajouté au niveau d'API 17

Renvoie la valeur approximative de (1.f / sqrt(value)).

La précision est celle d'une valeur à virgule flottante de 16 bits.

Voir aussi rsqrt(), native_rsqrt().

half_sqrt : racine carrée calculée avec une précision de 16 bits

float half_sqrt(float v);	Ajouté au niveau d'API 17
float2 half_sqrt(float2 v);	Ajouté au niveau d'API 17
float3 half_sqrt(float3 v);	Ajouté au niveau d'API 17
float4 half_sqrt(float4 v);	Ajouté au niveau d'API 17

Renvoie la racine carrée approximative d'une valeur.

La précision est celle d'une valeur à virgule flottante de 16 bits.

Voir aussi sqrt() et 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(moitié a, moitié b);	Ajouté au niveau d'API 24
half2 hypot(half2 a, half2 b);	Ajouté au niveau d'API 24
half3 hypot(half3 a, half3 b);	Ajouté au niveau d'API 24
half4 hypot(half4 a, half4 b);	Ajouté au niveau d'API 24

Renvoie l'hypoténuse, c'est-à-dire sqrt(a * a + b * b).

Voir aussi native_hypot().

ilogb : exposant de base deux

int ilogb(float v);
int ilogb(moitié v);	Ajouté au niveau d'API 24
int2 ilogb(float2 v);
int2 ilogb(half2 v);	Ajouté au niveau d'API 24
int3 ilogb(float3 v);
int3 ilogb(half3 v);	Ajouté au niveau d'API 24
int4 ilogb(float4 v);
int4 ilogb(half4 v);	Ajouté au niveau d'API 24

Renvoie l'exposant de base deux d'une valeur, où la mantisse est comprise entre 1.f (inclus) et 2.f (exclu).

Par exemple, ilogb(8.5f) renvoie 3.

En raison de la différence au niveau de la mantissa, ce nombre est inférieur de un à celui renvoyé par frexp().

La fonction logb() est similaire, mais renvoie une valeur flottante.

ldexp : crée une valeur à virgule flottante à partir d'une mantisse et de l'exposant

float ldexp(mantissa à virgule flottante, exposant int);
float2 ldexp(float2 mantissa, int exponentiel);
float2 ldexp(float2 mantisse, int2 exposant);
float3 ldexp(float3 mantisse, exposant entier);
float3 ldexp(float3 mantissa, int3 exposant);
float4 ldexp(float4 mantisse, exposant entier);
float4 ldexp(float4 mantissa, int4 exposant) ;
half ldexp(demi mantissa, exposant int);	Ajouté au niveau d'API 24
half2 ldexp(half2 mantisse, exposant entier);	Ajouté au niveau d'API 24
half2 ldexp(half2 mantissa, int2 exposant;	Ajouté au niveau d'API 24
half3 ldexp(half3 mantisse, exposant entier);	Ajouté au niveau d'API 24
half3 ldexp(half3 mantissa, int3 exposant;	Ajouté au niveau d'API 24
half4 ldexp(half4 mantisse, exposant entier);	Ajouté au niveau d'API 24
half4 ldexp(half4 mantissa, int4 exposant)	Ajouté au niveau d'API 24

Paramètres

mantisse	Mantissa.
exposant	Exposant, composant unique ou vecteur correspondant.

Renvoie la valeur à virgule flottante créée à partir de la mantisse et de l'exposant, c'est-à-dire (mantisse * 2 ^ exposant).

Consultez frexp() pour effectuer l'opération inverse.

lgamma : logarithme naturel de la fonction gamma

float lgamma(float v);
float lgamma(float v, int* sign_of_gamma);
float2 lgamma(float2 v);
float2 lgamma(float2 v, int2* sign_of_gamma);
float3 lgamma(float3 v);
float3 lgamma(float3 v, int3* sign_of_gamma);
float4 lgamma(float4 v);
float4 lgamma(float4 v, int4* sign_of_gamma);
half lgamma(demi v);	Ajouté au niveau d'API 24
demi lgamma(demi v, signe_int* de_gamma);	Ajouté au niveau d'API 24
half2 lgamma(half2 v);	Ajouté au niveau d'API 24
half2 lgamma(half2 v, int2* sign_of_gamma);	Ajouté au niveau d'API 24
half3 lgamma(half3 v);	Ajouté au niveau d'API 24
half3 lgamma(half3 v, int3* sign_of_gamma);	Ajouté au niveau d'API 24
half4 lgamma(half4 v);	Ajouté au niveau d'API 24
half4 lgamma(half4 v, int4* sign_of_gamma);	Ajouté au niveau d'API 24

Paramètres

v
signe_de_gamma	Si signe_of_gamma n'est pas nul, *sign_of_gamma sera défini sur -1.f si le gamma de v est négatif, sinon sur 1.f.

Renvoie le logarithme naturel de la valeur absolue de la fonction gamma, c'est-à-dire log(fabs(tgamma(v))).

Voir aussi tgamma().

log : logarithme naturel

float log(float v);
float2 log(float2 v);
float3 log(float3 v);
float4 log(float4 v);
half log(moitié v);	Ajouté au niveau d'API 24
half2 log(half2 v);	Ajouté au niveau d'API 24
half3 log(half3 v);	Ajouté au niveau d'API 24
half4 log(half4 v);	Ajouté au niveau d'API 24

Renvoie le logarithme naturel.

Voir aussi native_log().

log10 : logarithme de base 10

float log10(float v);
float2 log10(float2 v);
float3 log10(float3 v);
float4 log10(float4 v);
half log10(moitié v);	Ajouté au niveau d'API 24
half2 log10(half2 v);	Ajouté au niveau d'API 24
half3 log10(half3 v);	Ajouté au niveau d'API 24
half4 log10(half4 v);	Ajouté au niveau d'API 24

Renvoie le logarithme en base 10.

Voir aussi native_log10().

log1p : logarithme naturel d'une valeur plus 1

float log1p(float v);
float2 log1p(float2 v);
float3 log1p(float3 v);
float4 log1p(float4 v);
half log1p(moitié v);	Ajouté au niveau d'API 24
half2 log1p(half2 v);	Ajouté au niveau d'API 24
half3 log1p(half3 v);	Ajouté au niveau d'API 24
half4 log1p(half4 v);	Ajouté au niveau d'API 24

Renvoie le logarithme naturel de (v + 1.f).

Voir aussi native_log1p().

log2 : logarithme en base 2

float log2(float v);
float2 log2(float2 v);
float3 log2(float3 v);
float4 log2(float4 v);
half log2(moitié v);	Ajouté au niveau d'API 24
half2 log2(half2 v);	Ajouté au niveau d'API 24
half3 log2(half3 v);	Ajouté au niveau d'API 24
half4 log2(half4 v);	Ajouté au niveau d'API 24

Renvoie le logarithme en base 2.

Voir aussi native_log2().

logb : exposant de base 2

float logb(float v);
float2 logb(float2 v);
float3 logb(float3 v);
float4 logb(float4 v);
half logb(moitié v);	Ajouté au niveau d'API 24
half2 logb(half2 v);	Ajouté au niveau d'API 24
half3 logb(half3 v);	Ajouté au niveau d'API 24
half4 logb(half4 v);	Ajouté au niveau d'API 24

Renvoie l'exposant de base deux d'une valeur, où la mantisse est comprise entre 1.f (inclus) et 2.f (exclu).

Par exemple, logb(8.5f) renvoie 3.f.

En raison de la différence de mantissa, ce nombre est inférieur de 1 à celui renvoyé par frexp().

ilogb() est similaire, mais renvoie un nombre entier.

mad : multiplier et ajouter

float mad(float multiplicand1, float multiplicand2, float offset);
float2 mad(float2 multiplicand1, float2 multiplicand2, décalage de float2) ;
float3 mad(float3 multiplicand1, float3 multiplicand2, décalage float3) ;
float4 mad(float4 multiplicand1, float4 multiplicand2, décalage de float4)
moitié mad(moitié multiplicande1, moitié multiplicande2, moitié décalage);	Ajouté au niveau d'API 24
half2 mad(moitié2 multiplicande1, moitié2 multiplicande2, décalage moitié2) ;	Ajouté au niveau d'API 24
half3 mad(moitié3 multiplicande1, moitié3 multiplicande2, décalage demi-3) ;	Ajouté au niveau d'API 24
half4 mad(moitié4 multiplicande1, moitié4 multiplicande2, décalage moitié4)	Ajouté au niveau d'API 24

Multipliez et ajoutez. Renvoie (multiplicand1 * multiplicand2) + offset.

Cette fonction est semblable à fma(). fma() conserve la précision complète du résultat multiplié et n'arrondit qu'après l'addition. mad() arrondit après la multiplication et l'addition. En mode rs_fp_relaxed, mad() ne peut pas effectuer l'arrondi après la multiplication.

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(float a, float b);
float2 max(float2 a, float b);
float2 max(float2 a, float2 b);
float3 max(float3 a, float b);
float3 max(float3 a, float3 b);
float4 max(float4 a, float b);
float4 max(float4 a, float4 b);
half max(moitié a, moitié b);	Ajouté au niveau d'API 24
half2 max(half2 a, half b);	Ajouté au niveau d'API 24
half2 max(half2 a, half2 b);	Ajouté au niveau d'API 24
half3 max(half3 a, moitié b);	Ajouté au niveau d'API 24
half3 max(half3 a, half3 b);	Ajouté au niveau d'API 24
half4 max(half4 a, moitié b);	Ajouté au niveau d'API 24
half4 max(half4 a, half4 b);	Ajouté au niveau d'API 24
int max(int a, int b);
int2 max(int2 a, int2 b);
int3 max(int3 a, int3 b);
int4 max(int4 a, int4 b);
long max(long a, long b);	Ajouté au niveau d'API 21
long2 max(long2 a, long2 b);	Ajouté au niveau d'API 21
long3 max(long3 a, long3 b);	Ajouté au niveau d'API 21
long4 max(long4 a, long4 b);	Ajouté au niveau d'API 21
court max(short a, court 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);	Ajouté au niveau d'API 21
ulong2 max(ulong2 a, ulong2 b);	Ajouté au niveau d'API 21
ulong3 max(ulong3 a, ulong3 b);	Ajouté au niveau d'API 21
ulong4 max(ulong4 a, ulong4 b);	Ajouté au niveau d'API 21
ushort max(ushort a, ushort b);
ushort2 max(ushort2 a, ushort2 b);
ushort3 max(ushort3 a, ushort3 b);
ushort4 max(ushort4 a, ushort4 b);

Renvoie la valeur maximale de deux arguments.

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(float a, float b);
float2 min(float2 a, float b);
float2 min(float2 a, float2 b);
float3 min(float3 a, float b);
float3 min(float3 a, float3 b);
float4 min(float4 a, float b);
float4 min(float4 a, float4 b);
demi min(moitié a, moiti b);	Ajouté au niveau d'API 24
half2 min(half2 a, moitié b);	Ajouté au niveau d'API 24
half2 min(half2 a, half2 b);	Ajouté au niveau d'API 24
half3 min(moitié3 a, moitié b) ;	Ajouté au niveau d'API 24
half3 min(half3 a, half3 b);	Ajouté au niveau d'API 24
half4 min(half4 a, moitié b);	Ajouté au niveau d'API 24
half4 min(half4 a, half4 b);	Ajouté au niveau d'API 24
int min(int a, int b);
int2 min(int2 a, int2 b);
int3 min(int3 a, int3 b);
int4 min(int4 a, int4 b);
long min(long a, long b);	Ajouté au niveau d'API 21
long2 min(long2 a, long2 b);	Ajouté au niveau d'API 21
long3 min(long3 a, long3 b);	Ajouté au niveau d'API 21
long4 min(long4 a, long4 b);	Ajouté au niveau d'API 21
courte min(short a, court 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);	Ajouté au niveau d'API 21
ulong2 min(ulong2 a, ulong2 b);	Ajouté au niveau d'API 21
ulong3 min(ulong3 a, ulong3 b);	Ajouté au niveau d'API 21
ulong4 min(ulong4 a, ulong4 b);	Ajouté au niveau d'API 21
ushort min(ushort a, ushort b);
ushort2 min(ushort2 a, ushort2 b);
ushort3 min(ushort3 a, ushort3 b);
ushort4 min(ushort4 a, ushort4 b);

Renvoie la valeur minimale de deux arguments.

mix : associe deux valeurs

float mix(début de création flottante, arrêt flottant, fraction flottante);
float2 mix(début de float2, arrêt de float2, fraction float);
mix float2(début de float2, arrêt de float2, fraction float2) ;
float3 mix(début float3, arrêt float3, fraction float);
float3 mix(début float3, arrêt float3, fraction float3) ;
mix float4(début de float4, arrêt de float4, fraction flottante) ;
Mix float4(début de float4, arrêt de float4, fraction float4)
Mix demi(moitié début, moitié arrêt, moitié fraction) ;	Ajouté au niveau d'API 24
Mix moitié2(début de moitié2, moitié2 arrêt, moitié fraction);	Ajouté au niveau d'API 24
Mix half2(début de moitié2, moitié2 arrêt, fraction moitié2) ;	Ajouté au niveau d'API 24
Mix half3(début pour moitié3, moitié 3 arrêt, moitié fraction) ;	Ajouté au niveau d'API 24
Mix half3(début pour moitié3, moitié 3 arrêt, moitié 3 fraction);	Ajouté au niveau d'API 24
Mix moitié4(début de moitié4, moitié arrêt, moitié fraction) ;	Ajouté au niveau d'API 24
Mix moitié4(début de la moitié, moitié des 4 arrêts, fraction moitié 4) ;	Ajouté au niveau d'API 24

Renvoie start + ((stop - start) * fraction).

Cela peut être utile pour mélanger deux valeurs. Par exemple, pour créer une couleur à 40% color1 et 60% color2, utilisez mix(color1, color2, 0.6f).

modf : composants intégraux et fractionnaires

float modf(float v, float* partie_intégrale);
float2 modf(float2 v, float2* integral_part);
float3 modf(float3 v, float3* integral_part);
float4 modf(float4 v, float4* integral_part);
demi modf(moitié v, moitié* integral_part);	Ajouté au niveau d'API 24
half2 modf(half2 v, half2* integral_part);	Ajouté au niveau d'API 24
half3 modf(half3 v, half3* integral_part);	Ajouté au niveau d'API 24
half4 modf(half4 v, half4* integral_part);	Ajouté au niveau d'API 24

Paramètres

v	Valeur source.
partie_intégrale	*integral_part correspond à la partie intégrale du nombre.

Renvoie

Partie de la valeur à virgule flottante.

Affiche les composantes entières et fractionnaires d'un nombre.

Les deux composants auront le même signe que x. Par exemple, pour une entrée de -3.72f, *integral_part sera défini sur -3.f, et .72f sera renvoyé.

nan : n'est pas un nombre

float nan(uint v);

Paramètres

v	Non utilisé

Renvoie une valeur NaN (non un nombre).

nan_half : n'est pas un nombre

half nan_half()

Ajouté au niveau d'API 24

Renvoie une valeur NaN à virgule flottante à demi-précision (pas un nombre).

native_acos : cosinus inverse approximatif

float native_acos(float v);	Ajouté au niveau d'API 21
float2 native_acos(float2 v);	Ajouté au niveau d'API 21
float3 native_acos(float3 v);	Ajouté au niveau d'API 21
float4 native_acos(float4 v);	Ajouté au niveau d'API 21
half native_acos(moitié v);	Ajouté au niveau d'API 24
half2 native_acos(half2 v);	Ajouté au niveau d'API 24
half3 native_acos(half3 v);	Ajouté au niveau d'API 24
half4 native_acos(half4 v);	Ajouté au niveau d'API 24

Renvoie le cosinus inverse approximatif, en radians.

Cette fonction produit des résultats non définis à partir de valeurs d'entrée inférieures à -1 ou supérieures à 1.

Voir aussi acos().

native_acosh : cosinus hyperbolique inverse approximatif

float native_acosh(float v);	Ajouté au niveau d'API 21
float2 native_acosh(float2 v);	Ajouté au niveau d'API 21
float3 native_acosh(float3 v);	Ajouté au niveau d'API 21
float4 native_acosh(float4 v);	Ajouté au niveau d'API 21
half native_acosh(moitié v);	Ajouté au niveau d'API 24
half2 native_acosh(half2 v);	Ajouté au niveau d'API 24
half3 native_acosh(half3 v);	Ajouté au niveau d'API 24
half4 native_acosh(half4 v);	Ajouté au niveau d'API 24

Renvoie le cosinus hyperbolique inverse approximatif, en radians.

Voir aussi acosh().

native_acospi : cosinus inverse approximatif divisé par pi

float native_acospi(float v);	Ajouté au niveau d'API 21
float2 native_acospi(float2 v);	Ajouté au niveau d'API 21
float3 native_acospi(float3 v);	Ajouté au niveau d'API 21
float4 native_acospi(float4 v);	Ajouté au niveau d'API 21
half native_acospi(moitié v);	Ajouté au niveau d'API 24
half2 native_acospi(half2 v);	Ajouté au niveau d'API 24
half3 native_acospi(half3 v);	Ajouté au niveau d'API 24
half4 native_acospi(54 v);	Ajouté au niveau d'API 24

Renvoie le cosinus inverse approximatif en radians, divisé par Pi.

Pour obtenir un cosinus inverse mesuré en degrés, utilisez acospi(a) * 180.f.

Cette fonction produit des résultats non définis à partir de valeurs d'entrée inférieures à -1 ou supérieures à 1.

Voir aussi acospi().

native_asin : sinus inverse approximatif

float native_asin(float v);	Ajouté au niveau d'API 21
float2 native_asin(float2 v);	Ajouté au niveau d'API 21
float3 native_asin(float3 v);	Ajouté au niveau d'API 21
float4 native_asin(float4 v);	Ajouté au niveau d'API 21
half native_asin(moitié v);	Ajouté au niveau d'API 24
half2 native_asin(half2 v);	Ajouté au niveau d'API 24
half3 native_asin(half3 v);	Ajouté au niveau d'API 24
half4 native_asin(half4 v);	Ajouté au niveau d'API 24

Renvoie le sinus inverse approximatif, en radians.

Cette fonction produit des résultats non définis à partir de valeurs d'entrée inférieures à -1 ou supérieures à 1.

Voir aussi asin().

native_asinh : sinus hyperbolique inverse approximatif

float native_asinh(float v);	Ajouté au niveau d'API 21
float2 native_asinh(float2 v);	Ajouté au niveau d'API 21
float3 native_asinh(float3 v);	Ajouté au niveau d'API 21
float4 native_asinh(float4 v);	Ajouté au niveau d'API 21
half native_asinh(moitié v);	Ajouté au niveau d'API 24
half2 native_asinh(half2 v);	Ajouté au niveau d'API 24
half3 native_asinh(half3 v);	Ajouté au niveau d'API 24
half4 native_asinh(half4 v);	Ajouté au niveau d'API 24

Renvoie le sinus hyperbolique inverse approximatif, en radians.

Voir aussi asinh().

native_asinpi : sinus inverse approximatif divisé par pi

float native_asinpi(float v);	Ajouté au niveau d'API 21
float2 native_asinpi(float2 v);	Ajouté au niveau d'API 21
float3 native_asinpi(float3 v);	Ajouté au niveau d'API 21
float4 native_asinpi(float4 v);	Ajouté au niveau d'API 21
half native_asinpi(moitié v);	Ajouté au niveau d'API 24
half2 native_asinpi(half2 v);	Ajouté au niveau d'API 24
half3 native_asinpi(half3 v);	Ajouté au niveau d'API 24
half4 native_asinpi(half4 v);	Ajouté au niveau d'API 24

Renvoie le sinus inverse approximatif en radians, divisé par Pi.

Pour obtenir un sinus inverse mesuré en degrés, utilisez asinpi(a) * 180.f.

Cette fonction produit des résultats non définis à partir de valeurs d'entrée inférieures à -1 ou supérieures à 1.

Voir aussi asinpi().

native_atan : tangente inverse approximative

float native_atan(float v);	Ajouté au niveau d'API 21
float2 native_atan(float2 v);	Ajouté au niveau d'API 21
float3 native_atan(float3 v);	Ajouté au niveau d'API 21
float4 native_atan(float4 v);	Ajouté au niveau d'API 21
half native_atan(moitié v);	Ajouté au niveau d'API 24
half2 native_atan(half2 v);	Ajouté au niveau d'API 24
half3 native_atan(half3 v);	Ajouté au niveau d'API 24
half4 native_atan(half4 v);	Ajouté au niveau d'API 24

Renvoie la tangente inverse approximative, en radians.

Voir aussi atan().

native_atan2 : tangente inverse approximative d'un ratio

float native_atan2(numérateur à virgule flottante, dénominateur à virgule flottante);	Ajouté au niveau d'API 21
float2 native_atan2(numérateur float2, dénominateur float2);	Ajouté au niveau d'API 21
float3 native_atan2(numérateur float3, dénominateur float3);	Ajouté au niveau d'API 21
float4 native_atan2(numérateur float4, dénominateur float4);	Ajouté au niveau d'API 21
half native_atan2(demi numérateur, demi dénominateur);	Ajouté au niveau d'API 24
half2 native_atan2(numérateur half2, dénominateur half2);	Ajouté au niveau d'API 24
half3 native_atan2(numérateur half3, dénominateur half3);	Ajouté au niveau d'API 24
half4 native_atan2(numérateur half4, dénominateur half4);	Ajouté au niveau d'API 24

Paramètres

numérateur	Numérateur.
dénominateur	dénominateur. Peut être égal à 0.

Renvoie la tangente inverse approximative de (numerator / denominator), en radians.

Voir aussi atan2().

native_atan2pi : tangente inverse approximative d'un ratio, divisée par pi

float native_atan2pi(numérateur à virgule flottante, dénominateur à virgule flottante);	Ajouté au niveau d'API 21
float2 native_atan2pi(numérateur float2, dénominateur float2);	Ajouté au niveau d'API 21
float3 native_atan2pi(numérateur float3, dénominateur float3);	Ajouté au niveau d'API 21
float4 native_atan2pi(numérateur float4, dénominateur float4);	Ajouté au niveau d'API 21
half native_atan2pi(demi numérateur, demi dénominateur);	Ajouté au niveau d'API 24
half2 native_atan2pi(numérateur half2, dénominateur half2);	Ajouté au niveau d'API 24
half3 native_atan2pi(numérateur half3, dénominateur half3);	Ajouté au niveau d'API 24
half4 native_atan2pi(numérateur half4, dénominateur half4);	Ajouté au niveau d'API 24

Paramètres

numérateur	Numérateur.
dénominateur	dénominateur. Peut être égal à 0.

Renvoie la tangente inverse approximative de (numerator / denominator), en radians, divisée par Pi.

Pour obtenir la tangente inverse, mesurée en degrés, utilisez atan2pi(n, d) * 180.f.

Voir aussi atan2pi().

native_atanh : tangente hyperbolique inverse approximative

float native_atanh(float v);	Ajouté au niveau d'API 21
float2 native_atanh(float2 v);	Ajouté au niveau d'API 21
float3 native_atanh(float3 v);	Ajouté au niveau d'API 21
float4 native_atanh(float4 v);	Ajouté au niveau d'API 21
half native_atanh(moitié v);	Ajouté au niveau d'API 24
half2 native_atanh(half2 v);	Ajouté au niveau d'API 24
half3 native_atanh(half3 v);	Ajouté au niveau d'API 24
half4 native_atanh(half4 v);	Ajouté au niveau d'API 24

Renvoie la tangente hyperbolique inverse approximative, en radians.

Voir aussi atanh().

native_atanpi : tangente inverse approximative divisée par pi

float native_atanpi(float v);	Ajouté au niveau d'API 21
float2 native_atanpi(float2 v);	Ajouté au niveau d'API 21
float3 native_atanpi(float3 v);	Ajouté au niveau d'API 21
float4 native_atanpi(float4 v);	Ajouté au niveau d'API 21
half native_atanpi(moiti v);	Ajouté au niveau d'API 24
half2 native_atanpi(half2 v);	Ajouté au niveau d'API 24
half3 native_atanpi(half3 v);	Ajouté au niveau d'API 24
half4 native_atanpi(half4 v);	Ajouté au niveau d'API 24

Renvoie la tangente inverse approximative en radians, divisée par Pi.

Pour obtenir la tangente inverse, mesurée en degrés, utilisez atanpi(a) * 180.f.

Voir aussi atanpi().

native_cbrt : racine cubique approximative

float native_cbrt(float v);	Ajouté au niveau d'API 21
float2 native_cbrt(float2 v);	Ajouté au niveau d'API 21
float3 native_cbrt(float3 v);	Ajouté au niveau d'API 21
float4 native_cbrt(float4 v);	Ajouté au niveau d'API 21
half native_cbrt(moitié v);	Ajouté au niveau d'API 24
half2 native_cbrt(half2 v);	Ajouté au niveau d'API 24
half3 native_cbrt(half3 v);	Ajouté au niveau d'API 24
half4 native_cbrt(half4 v);	Ajouté au niveau d'API 24

Renvoie la racine cubique approximative.

Voir aussi cbrt().

native_cos : cosinus approximatif

float native_cos(float v);	Ajouté au niveau d'API 21
float2 native_cos(float2 v);	Ajouté au niveau d'API 21
float3 native_cos(float3 v);	Ajouté au niveau d'API 21
float4 native_cos(float4 v);	Ajouté au niveau d'API 21
half native_cos(moitié v);	Ajouté au niveau d'API 24
half2 native_cos(half2 v);	Ajouté au niveau d'API 24
half3 native_cos(half3 v);	Ajouté au niveau d'API 24
half4 native_cos(half4 v);	Ajouté au niveau d'API 24

Renvoie le cosinus approximatif d'un angle mesuré en radians.

Voir aussi cos().

native_cosh : cosinus hypébolique approximatif

float native_cosh(float v);	Ajouté au niveau d'API 21
float2 native_cosh(float2 v);	Ajouté au niveau d'API 21
float3 native_cosh(float3 v);	Ajouté au niveau d'API 21
float4 native_cosh(float4 v);	Ajouté au niveau d'API 21
half native_cosh(moitié v);	Ajouté au niveau d'API 24
half2 native_cosh(half2 v);	Ajouté au niveau d'API 24
half3 native_cosh(half3 v);	Ajouté au niveau d'API 24
half4 native_cosh(half4 v);	Ajouté au niveau d'API 24

Renvoie le cosinus hypébolique approximatif.

Voir aussi cosh().

native_cospi : cosinus approximatif d'un nombre multiplié par pi

float native_cospi(float v);	Ajouté au niveau d'API 21
float2 native_cospi(float2 v);	Ajouté au niveau d'API 21
float3 native_cospi(float3 v);	Ajouté au niveau d'API 21
float4 native_cospi(float4 v);	Ajouté au niveau d'API 21
half native_cospi(moitié v);	Ajouté au niveau d'API 24
half2 native_cospi(half2 v);	Ajouté au niveau d'API 24
half3 native_cospi(half3 v);	Ajouté au niveau d'API 24
half4 native_cospi(half4 v);	Ajouté au niveau d'API 24

Renvoie le cosinus approximatif de (v * pi), où (v * pi) est mesuré en radians.

Pour obtenir le cosinus d'une valeur mesurée en degrés, appelez cospi(v / 180.f).

Voir aussi cospi().

native_divide : division approximative

float native_divide(float left_vector, float_right_vector);	Ajouté au niveau d'API 21
float2 native_divide(float2 vecteur_gauche, float2 vecteur_droite);	Ajouté au niveau d'API 21
float3 native_divide(float3 vecteur_gauche, float3 vecteur_droite);	Ajouté au niveau d'API 21
float4 native_divide(float4 vecteur_gauche, float4 vecteur_droite);	Ajouté au niveau d'API 21
half native_divide(demi vecteur_gauche, demi vecteur_droite);	Ajouté au niveau d'API 24
half2 native_divide(moitié2 à vecteur_gauche, moitié2 à vecteur_droite);	Ajouté au niveau d'API 24
half3 native_divide(moitié3 à vecteur_gauche, moitié3 à vecteur_droite);	Ajouté au niveau d'API 24
half4 native_divide(moitié4 à vecteur_gauche, moitié4 à vecteur_droite);	Ajouté au niveau d'API 24

Calcule la division approximative de deux valeurs.

native_exp : valeur approximative élevée à un nombre

float native_exp(float v);	Ajouté au niveau d'API 18
float2 native_exp(float2 v);	Ajouté au niveau d'API 18
float3 native_exp(float3 v);	Ajouté au niveau d'API 18
float4 native_exp(float4 v);	Ajouté au niveau d'API 18
half native_exp(moitié v);	Ajouté au niveau d'API 24
half2 native_exp(half2 v);	Ajouté au niveau d'API 24
half3 native_exp(half3 v);	Ajouté au niveau d'API 24
half4 native_exp(half4 v);	Ajouté au niveau d'API 24

Exp. approximative rapide

Il est valide pour les entrées comprises entre -86,f et 86,f. La précision n'est pas inférieure à ce que l'on attendait d'utiliser des valeurs à virgule flottante 16 bits.

Voir aussi exp().

native_exp10 : environ 10 élevé à un nombre

float native_exp10(float v);	Ajouté au niveau d'API 18
float2 native_exp10(float2 v);	Ajouté au niveau d'API 18
float3 native_exp10(float3 v);	Ajouté au niveau d'API 18
float4 native_exp10(float4 v);	Ajouté au niveau d'API 18
half native_exp10(moitié v);	Ajouté au niveau d'API 24
half2 native_exp10(half2 v);	Ajouté au niveau d'API 24
half3 native_exp10(half3 v);	Ajouté au niveau d'API 24
half4 native_exp10(54 v);	Ajouté au niveau d'API 24

Exp10 approximative.

Il est valide pour les entrées comprises entre -37,f et 37,f. La précision n'est pas inférieure à ce que l'on attendait d'utiliser des valeurs à virgule flottante 16 bits.

Voir aussi exp10().

native_exp2 : environ 2 élevé à un nombre

float native_exp2(float v);	Ajouté au niveau d'API 18
float2 native_exp2(float2 v);	Ajouté au niveau d'API 18
float3 native_exp2(float3 v);	Ajouté au niveau d'API 18
float4 native_exp2(float4 v);	Ajouté au niveau d'API 18
half native_exp2(moitié v);	Ajouté au niveau d'API 24
half2 native_exp2(half2 v);	Ajouté au niveau d'API 24
half3 native_exp2(half3 v);	Ajouté au niveau d'API 24
half4 native_exp2(half4 v);	Ajouté au niveau d'API 24

Exp2 approximative rapide.

Il est valide pour les entrées comprises entre -125.f et 125.f. La précision n'est pas inférieure à ce que l'on attendait d'utiliser des valeurs à virgule flottante 16 bits.

Voir aussi exp2().

native_expm1 : valeur approximative élevée à un nombre moins un

float native_expm1(float v);	Ajouté au niveau d'API 21
float2 native_expm1(float2 v);	Ajouté au niveau d'API 21
float3 native_expm1(float3 v);	Ajouté au niveau d'API 21
float4 native_expm1(float4 v);	Ajouté au niveau d'API 21
half native_expm1(moitié v);	Ajouté au niveau d'API 24
half2 native_expm1(half2 v);	Ajouté au niveau d'API 24
half3 native_expm1(half3 v);	Ajouté au niveau d'API 24
half4 native_expm1(half4 v);	Ajouté au niveau d'API 24

Renvoie la valeur approximative (e ^ v) - 1.

Voir aussi expm1().

native_hypot : hypoténuse approximative

float native_hypot(float a, float b);	Ajouté au niveau d'API 21
float2 native_hypot(float2 a, float2 b);	Ajouté au niveau d'API 21
float3 native_hypot(float3 a, float3 b);	Ajouté au niveau d'API 21
float4 native_hypot(float4 a, float4 b);	Ajouté au niveau d'API 21
half native_hypot(moitié a, moiti b);	Ajouté au niveau d'API 24
half2 native_hypot(half2 a, half2 b);	Ajouté au niveau d'API 24
half3 native_hypot(half3 a, half3 b);	Ajouté au niveau d'API 24
half4 native_hypot(half4 a, half4 b);	Ajouté au niveau d'API 24

Renvoie la valeur approximative native_sqrt(a * a + b * b)

Voir aussi hypot().

native_log : logarithme naturel approximatif

float native_log(float v);	Ajouté au niveau d'API 18
float2 native_log(float2 v);	Ajouté au niveau d'API 18
float3 native_log(float3 v);	Ajouté au niveau d'API 18
float4 native_log(float4 v);	Ajouté au niveau d'API 18
half native_log(moitié v);	Ajouté au niveau d'API 24
half2 native_log(half2 v);	Ajouté au niveau d'API 24
half3 native_log(half3 v);	Ajouté au niveau d'API 24
half4 native_log(half4 v);	Ajouté au niveau d'API 24

Consignation approximative rapide.

Elle n'est pas précise pour les valeurs très proches de zéro.

Voir aussi log().

native_log10 : logarithme approximatif en base 10

float native_log10(float v);	Ajouté au niveau d'API 18
float2 native_log10(float2 v);	Ajouté au niveau d'API 18
float3 native_log10(float3 v);	Ajouté au niveau d'API 18
float4 native_log10(float4 v);	Ajouté au niveau d'API 18
half native_log10(moitié v);	Ajouté au niveau d'API 24
half2 native_log10(half2 v);	Ajouté au niveau d'API 24
half3 native_log10(half3 v);	Ajouté au niveau d'API 24
half4 native_log10(half4 v);	Ajouté au niveau d'API 24

Rapidité approximative, log10.

Elle n'est pas précise pour les valeurs très proches de zéro.

Voir aussi log10().

native_log1p : logarithme naturel approximatif d'une valeur plus 1

float native_log1p(float v);	Ajouté au niveau d'API 21
float2 native_log1p(float2 v);	Ajouté au niveau d'API 21
float3 native_log1p(float3 v);	Ajouté au niveau d'API 21
float4 native_log1p(float4 v);	Ajouté au niveau d'API 21
half native_log1p(moitié v);	Ajouté au niveau d'API 24
half2 native_log1p(half2 v);	Ajouté au niveau d'API 24
half3 native_log1p(half3 v);	Ajouté au niveau d'API 24
half4 native_log1p(half4 v);	Ajouté au niveau d'API 24

Affiche le logarithme naturel approximatif de (v + 1.0f)

Consultez également log1p().

native_log2 : logarithme approximatif de base 2

float native_log2(float v);	Ajouté au niveau d'API 18
float2 native_log2(float2 v);	Ajouté au niveau d'API 18
float3 native_log2(float3 v);	Ajouté au niveau d'API 18
float4 native_log2(float4 v);	Ajouté au niveau d'API 18
half native_log2(moitié v);	Ajouté au niveau d'API 24
half2 native_log2(half2 v);	Ajouté au niveau d'API 24
half3 native_log2(half3 v);	Ajouté au niveau d'API 24
half4 native_log2(half4 v);	Ajouté au niveau d'API 24

Rapidité approximative log2.

Elle n'est pas précise pour les valeurs très proches de zéro.

Consultez également log2().

native_powr : base positive approximative élevée à un exposant

float native_powr(base flottante, exposant flottant)	Ajouté au niveau d'API 18
float2 native_powr(base float2, exposant float2);	Ajouté au niveau d'API 18
float3 native_powr(float3 base, exposant float3));	Ajouté au niveau d'API 18
float4 native_powr(base float4, exposant float4);	Ajouté au niveau d'API 18
half native_powr(moitié base, moitié exposant);	Ajouté au niveau d'API 24
half2 native_powr(moitié2 base, moitié2 exposants);	Ajouté au niveau d'API 24
half3 native_powr(moitié3 base, moitié3 exposants);	Ajouté au niveau d'API 24
half4 native_powr(moitié4 base, moitié4 exposants);	Ajouté au niveau d'API 24

Paramètres

base	La valeur doit être comprise entre 0 et 256 f. La fonction n'est pas fiable pour les valeurs très proches de zéro.
exposant	Doit être comprise entre -15 f et 15 f.

Estimation rapide (exposant ^ de base).

Voir aussi powr().

native_recip : réciproque approximatif

float native_recip(float v);	Ajouté au niveau d'API 21
float2 native_recip(float2 v);	Ajouté au niveau d'API 21
float3 native_recip(float3 v);	Ajouté au niveau d'API 21
float4 native_recip(float4 v);	Ajouté au niveau d'API 21
half native_recip(moitié v);	Ajouté au niveau d'API 24
half2 native_recip(half2 v);	Ajouté au niveau d'API 24
half3 native_recip(half3 v);	Ajouté au niveau d'API 24
half4 native_recip(half4 v);	Ajouté au niveau d'API 24

Renvoie la valeur réciproque approximative d'une valeur.

Voir aussi half_recip().

native_rootn : racine n-ième approximative

float native_rootn(float v, int n);	Ajouté au niveau d'API 21
float2 native_rootn(float2 v, int2 n);	Ajouté au niveau d'API 21
float3 native_rootn(float3 v, int3 n);	Ajouté au niveau d'API 21
float4 native_rootn(float4 v, int4 n);	Ajouté au niveau d'API 21
half native_rootn(moitié v, int n);	Ajouté au niveau d'API 24
half2 native_rootn(half2 v, int2 n);	Ajouté au niveau d'API 24
half3 native_rootn(half3 v, int3 n);	Ajouté au niveau d'API 24
half4 native_rootn(half4 v, int4 n);	Ajouté au niveau d'API 24

Calculez la racine n-ième approximative d'une valeur.

Voir aussi rootn().

native_rsqrt : réciproque approximatif d'une racine carrée

float native_rsqrt(float v);	Ajouté au niveau d'API 21
float2 native_rsqrt(float2 v);	Ajouté au niveau d'API 21
float3 native_rsqrt(float3 v);	Ajouté au niveau d'API 21
float4 native_rsqrt(float4 v);	Ajouté au niveau d'API 21
half native_rsqrt(moitié v);	Ajouté au niveau d'API 24
half2 native_rsqrt(half2 v);	Ajouté au niveau d'API 24
half3 native_rsqrt(half3 v);	Ajouté au niveau d'API 24
half4 native_rsqrt(half4 v);	Ajouté au niveau d'API 24

Renvoie une valeur approximative (1 / sqrt(v)).

Voir aussi rsqrt() et half_rsqrt().

native_sin : sinus approximatif

float native_sin(float v);	Ajouté au niveau d'API 21
float2 native_sin(float2 v);	Ajouté au niveau d'API 21
float3 native_sin(float3 v);	Ajouté au niveau d'API 21
float4 native_sin(float4 v);	Ajouté au niveau d'API 21
half native_sin(moitié v);	Ajouté au niveau d'API 24
half2 native_sin(half2 v);	Ajouté au niveau d'API 24
half3 native_sin(half3 v);	Ajouté au niveau d'API 24
half4 native_sin(half4 v);	Ajouté au niveau d'API 24

Renvoie le sinus approximatif d'un angle, mesuré en radians.

Voir aussi sin().

native_sincos : sinus et cosinus approximatifs

float native_sincos(float v, float* cos);	Ajouté au niveau d'API 21
float2 native_sincos(float2 v, float2* cos);	Ajouté au niveau d'API 21
float3 native_sincos(float3 v, float3* cos);	Ajouté au niveau d'API 21
float4 native_sincos(float4 v, float4* cos);	Ajouté au niveau d'API 21
moitié native_sincos(moitié v, moitié* cos);	Ajouté au niveau d'API 24
half2 native_sincos(half2 v, half2* cos);	Ajouté au niveau d'API 24
half3 native_sincos(half3 v, half3* cos);	Ajouté au niveau d'API 24
half4 native_sincos(half4 v, half4* cos);	Ajouté au niveau d'API 24

Paramètres

v	Valeur entrante en radians.
cos	*cos a la valeur cosinus.

Renvoie

Sinus.

Renvoie le sinus et le cosinus approximatifs d'une valeur.

Voir aussi sincos().

native_sinh : sinus hyperbolique approximatif

float native_sinh(float v);	Ajouté au niveau d'API 21
float2 native_sinh(float2 v);	Ajouté au niveau d'API 21
float3 native_sinh(float3 v);	Ajouté au niveau d'API 21
float4 native_sinh(float4 v);	Ajouté au niveau d'API 21
half native_sinh(moitié v);	Ajouté au niveau d'API 24
half2 native_sinh(moitié2 v);	Ajouté au niveau d'API 24
half3 native_sinh(half3 v);	Ajouté au niveau d'API 24
half4 native_sinh(half4 v);	Ajouté au niveau d'API 24

Renvoie le sinus hyperbolique approximatif d'une valeur spécifiée en radians.

Voir aussi sinh().

native_sinpi : sinus approximatif d'un nombre multiplié par pi

float native_sinpi(float v);	Ajouté au niveau d'API 21
float2 native_sinpi(float2 v);	Ajouté au niveau d'API 21
float3 native_sinpi(float3 v);	Ajouté au niveau d'API 21
float4 native_sinpi(float4 v);	Ajouté au niveau d'API 21
half native_sinpi(moitié v);	Ajouté au niveau d'API 24
half2 native_sinpi(half2 v);	Ajouté au niveau d'API 24
half3 native_sinpi(half3 v);	Ajouté au niveau d'API 24
half4 native_sinpi(half4 v);	Ajouté au niveau d'API 24

Renvoie le sinus approximatif de (v * pi), où (v * pi) est mesuré en radians.

Pour obtenir le sinus d'une valeur mesurée en degrés, appelez sinpi(v / 180.f).

Voir aussi sinpi().

native_sqrt : racine carrée approximative

float native_sqrt(float v);	Ajouté au niveau d'API 21
float2 native_sqrt(float2 v);	Ajouté au niveau d'API 21
float3 native_sqrt(float3 v);	Ajouté au niveau d'API 21
float4 native_sqrt(float4 v);	Ajouté au niveau d'API 21
half native_sqrt(moitié v);	Ajouté au niveau d'API 24
half2 native_sqrt(half2 v);	Ajouté au niveau d'API 24
half3 native_sqrt(half3 v);	Ajouté au niveau d'API 24
half4 native_sqrt(half4 v);	Ajouté au niveau d'API 24

Renvoie la valeur carrée(v) approximative.

Voir aussi sqrt() et half_sqrt().

native_tan : tangente approximative

float native_tan(float v);	Ajouté au niveau d'API 21
float2 native_tan(float2 v);	Ajouté au niveau d'API 21
float3 native_tan(float3 v);	Ajouté au niveau d'API 21
float4 native_tan(float4 v);	Ajouté au niveau d'API 21
half native_tan(moitié v);	Ajouté au niveau d'API 24
half2 native_tan(half2 v);	Ajouté au niveau d'API 24
half3 native_tan(half3 v);	Ajouté au niveau d'API 24
half4 native_tan(half4 v);	Ajouté au niveau d'API 24

Renvoie la tangente approximative d'un angle mesuré en radians.

native_tanh : tangente hyperbolique approximative

float native_tanh(float v);	Ajouté au niveau d'API 21
float2 native_tanh(float2 v);	Ajouté au niveau d'API 21
float3 native_tanh(float3 v);	Ajouté au niveau d'API 21
float4 native_tanh(float4 v);	Ajouté au niveau d'API 21
half native_tanh(moitié v);	Ajouté au niveau d'API 24
half2 native_tanh(half2 v);	Ajouté au niveau d'API 24
half3 native_tanh(half3 v);	Ajouté au niveau d'API 24
half4 native_tanh(half4 v);	Ajouté au niveau d'API 24

Affiche la tangente hyperbolique approximative d'une valeur.

Voir aussi tanh().

native_tanpi : tangente approximative d'un nombre multiplié par pi

float native_tanpi(float v);	Ajouté au niveau d'API 21
float2 native_tanpi(float2 v);	Ajouté au niveau d'API 21
float3 native_tanpi(float3 v);	Ajouté au niveau d'API 21
float4 native_tanpi(float4 v);	Ajouté au niveau d'API 21
half native_tanpi(moitié v);	Ajouté au niveau d'API 24
half2 native_tanpi(half2 v);	Ajouté au niveau d'API 24
half3 native_tanpi(half3 v);	Ajouté au niveau d'API 24
half4 native_tanpi(half4 v);	Ajouté au niveau d'API 24

Renvoie la tangente approximative de (v * pi), où (v * pi) est mesuré en radians.

Pour obtenir la tangente d'une valeur mesurée en degrés, appelez tanpi(v / 180.f).

Voir aussi tanpi().

nextafter : nombre à virgule flottante suivant

float nextafter(float v, float target);
float2 nextafter(float2 v, cible float2);
float3 nextafter(float3 v, cible float3);
float4 nextafter(float4 v, cible float4);
moitié nextafter(moitié v, moitié cible);	Ajouté au niveau d'API 24
half2 nextafter(half2 v, half2 cible);	Ajouté au niveau d'API 24
moitié3 nextafter(demi-3 v, moitié3 cible);	Ajouté au niveau d'API 24
half4 Nextafter(54 v, 504 cible);	Ajouté au niveau d'API 24

Renvoie le prochain nombre à virgule flottante représentable de v vers la cible.

En mode rs_fp_relaxed, une valeur d'entrée dénormalisée peut ne pas donner la valeur dénormalisée suivante, car la prise en charge des valeurs dénormalisées est facultative en mode flexible.

pow : base élevée à un exposant

float pow(base flottante, exposant flottant)
float2 pow(base float2, exposant float2) ;
float3 pow(base float3, exposant float3) ;
float4 pow(base float4, exposant float4);
half pow(demi base, moitié exposant);	Ajouté au niveau d'API 24
half2 pow(moitié2 base, moitié2 exposants);	Ajouté au niveau d'API 24
half3 pow(moitié3 de base, moitié3 exposants);	Ajouté au niveau d'API 24
half4 pow(moitié4 base, moitié4 exposants);	Ajouté au niveau d'API 24

Renvoie la base élevée à l'exposant de puissance, c'est-à-dire l'exposant ^ de base.

pown() et powr() sont similaires. pown() prend un exposant entier. powr() suppose que la base est non négative.

pown : base élevée à un exposant entier

float pown(base flottante, exposant int);
float2 pown(base float2, exposant int2);
float3 pown(base float3, exposant int3);
float4 pown(base float4, exposant int4);
demi pown(demi base, exposant entier);	Ajouté au niveau d'API 24
half2 pown(moitié2 base, int2 exposant)	Ajouté au niveau d'API 24
half3 pown(moitié3 base, int3 exposant)	Ajouté au niveau d'API 24
half4 pown(moitié4 base, int4 exposant)	Ajouté au niveau d'API 24

Renvoie la base élevée à l'exposant de puissance, c'est-à-dire l'exposant ^ de base.

pow() et powr() sont similaires. Les deux acceptent un exposant flottant. powr() suppose également que la base est non négative.

powr : base positive élevée à un exposant

float powr(base flottante, exposant flottant)
float2 powr(float2 base, float2 exposant));
float3 powr(float3 base, float3 explicatif);
float4 powr(base float4, exposant float4);
half powr(demi base, moitié exposant);	Ajouté au niveau d'API 24
half2 powr(moitié2 base, moitié2 exposants);	Ajouté au niveau d'API 24
half3 powr(moitié3 base, moitié3 exposant);	Ajouté au niveau d'API 24
half4 powr(moitié4 base, moitié4 exposants);	Ajouté au niveau d'API 24

Renvoie la base élevée à l'exposant de puissance, c'est-à-dire l'exposant ^ de base. la valeur de base doit être >= 0.

pow() et pown() sont similaires. Elles ne font aucune hypothèse concernant la base. La fonction pow() prend un exposant flottant et pown() prend un entier.

Voir aussi native_powr().

radians : convertit les degrés en radians

float radians(float v);
float2 radians(float2 v);
float3 radians(float3 v);
float4 radians(float4 v);
demi radians(moitié v);	Ajouté au niveau d'API 24
half2 radians(half2 v);	Ajouté au niveau d'API 24
half3 radians(half3 v);	Ajouté au niveau d'API 24
half4 radians(half4 v);	Ajouté au niveau d'API 24

Convertit des degrés en radians.

reste : reste d'une division

float rest(e) (numérateur à virgule flottante, dénominateur à virgule flottante) ;
float2 restantes(numérateur float2, dénominateur float2) ;
float3 restante(numérateur float3, dénominateur float3) ;
float4 rest(e) (numérateur float4, dénominateur float4) ;
demi reste(moiti numérateur, demi dénominateur);	Ajouté au niveau d'API 24
half2 restant(numérateur moitié2, moitié2 dénominateur) ;	Ajouté au niveau d'API 24
half3 remain(le) (numérateur moitié3, dénominateur moitié3) ;	Ajouté au niveau d'API 24
half4 remain(le numérateur moitié-4, dénominateur moitié4) ;	Ajouté au niveau d'API 24

Renvoie le reste de (numérateur / dénominateur), où le quotient est arrondi par rapport à l'entier le plus proche.

La fonction fmod() est similaire, mais arrondit en fonction de l'entier le plus proche. Par exemple, fmod(-3.8f, 2.f) renvoie -1.8f (-3.8f - -1.f * 2.f) tandis que remainder(-3.8f, 2.f) renvoie 0.2f (-3.8f - -2.f * 2.f).

remquo : reste et quotient d'une division

float remquo(numérateur à virgule flottante, dénominateur à virgule flottante, quotient entier*)
float2 remquo(numérateur float2, dénominateur float2, quotient int2*);
float3 remquo(numérateur float3, dénominateur float3, quotient int3*);
float4 remquo(numérateur float4, dénominateur float4, quotient int4*);
demi remquo(demi numérateur, demi dénominateur, quotient int*);	Ajouté au niveau d'API 24
half2 remquo(numérateur moitié2, dénominateur moitié2, quotient int2*) ;	Ajouté au niveau d'API 24
half3 remquo(numérateur moitié3, dénominateur moitié3, quotient int3*) ;	Ajouté au niveau d'API 24
remquo half4(numérateur moitié-4, dénominateur moitié-4, quotient int4*) ;	Ajouté au niveau d'API 24

Paramètres

numérateur	Numérateur.
dénominateur	dénominateur.
quotient	*quotient est défini sur le quotient entier.

Renvoie

Reste, précis uniquement pour les trois bits les plus bas.

Renvoie le quotient et le reste de (numérateur / dénominateur).

La précision du signe et des trois bits les plus bas du quotient est garantie.

Cette fonction est utile pour implémenter des fonctions périodiques. Les trois bits de faible valeur du quotient donnent au quadrant et au reste la distance à l'intérieur de celui-ci. Par exemple, une implémentation de sin(x) peut appeler remquo(x, PI / 2.f, &quadrant) pour réduire la valeur très élevée de x à un élément situé dans une plage limitée.

Exemple: remquo(-23.5f, 8.f, &quot) définit les trois bits les plus bas du quot sur 3 et le signe négatif. Elle renvoie 0.5f.

rint : arrondi au nombre pair

float rint(float v);
float2 rint(float2 v);
float3 rint(float3 v);
float4 rint(float4 v);
half rint(moitié v);	Ajouté au niveau d'API 24
half2 rint(half2 v);	Ajouté au niveau d'API 24
half3 rint(half3 v);	Ajouté au niveau d'API 24
half4 rint(half4 v);	Ajouté au niveau d'API 24

Arrondit à la valeur intégrale la plus proche.

rint() arrondit les demi-valeurs au nombre pair. Par exemple, rint(0.5f) renvoie 0.f et rint(1.5f) renvoie 2.f. De même, rint(-0.5f) renvoie -0.f et rint(-1.5f) renvoie -2.f.

round() est similaire, mais arrondit la valeur à zéro. trunc() tronque la fraction décimale.

rootn : racine n-ième

float rootn(float v, int n);
racine float2(float2 v, int2 n);
racine float3(float3 v, int3 n);
racine float4(float4 v, int4 n);
half rootn(moitié v, int n);	Ajouté au niveau d'API 24
half2 rootn(half2 v, int2 n);	Ajouté au niveau d'API 24
half3 rootn(half3 v, int3 n);	Ajouté au niveau d'API 24
half4 rootn(half4 v, int4 n);	Ajouté au niveau d'API 24

Calcule la racine n-ième d'une valeur.

Voir aussi native_rootn().

round : arrondi à zéro

float round(float v);
float2 round(float2 v);
float3 round(float3 v);
float4 round(float4 v);
demi tour(demi v);	Ajouté au niveau d'API 24
half2 round(half2 v);	Ajouté au niveau d'API 24
half3 round(half3 v);	Ajouté au niveau d'API 24
half4 round(half4 v);	Ajouté au niveau d'API 24

Arrondissez à la valeur intégrale la plus proche.

round() arrondit les demi-valeurs à zéro. Par exemple, round(0.5f) renvoie 1.f, et round(1.5f) renvoie 2.f. De même, round(-0.5f) renvoie -1.f et round(-1.5f) renvoie -2.f.

rint() est similaire, mais arrondit la moitié des valeurs à pair. trunc() tronque la fraction décimale.

rsClamp : restreindre une valeur à une plage

char rsClamp(char amount, char low, char high);
int rsClamp(int amount, int low, int high);
courte rsClamp(short amount, short low, short high);
uchar rsClamp(quantité de uchar, faible de uchar, uchar de;
uint rsClamp(quantité de uint, uint faible, uint élevée);
ushort rsClamp(montant ushort, ushort low, ushort high);

Paramètres

montant	Valeur à limiter.
faible	Limite inférieure.
élevée	Limite supérieure.

Obsolète. Utilisez plutôt clamp().

Fixer une valeur entre faible et élevé.

rsFrac : renvoie la partie fractionnaire d'un float

float rsFrac(float v);

Obsolète. Utilisez plutôt fract().

Affiche la partie fractionnaire d'un nombre à virgule flottante.

rsRand : nombre pseudo-aléatoire

float rsRand(float max_value);
float rsRand(valeur_min_flottante, valeur_max_float);
int rsRand(int max_value);
int rsRand(int min_value, int max_value);

Renvoie une valeur aléatoire comprise entre 0 (ou min_value) et max_malue.

rsqrt : réciproque d'une racine carrée

float rsqrt(float v);
float2 rsqrt(float2 v);
float3 rsqrt(float3 v);
float4 rsqrt(float4 v);
half rsqrt(moitié v);	Ajouté au niveau d'API 24
half2 rsqrt(half2 v);	Ajouté au niveau d'API 24
half3 rsqrt(half3 v);	Ajouté au niveau d'API 24
half4 rsqrt(half4 v);	Ajouté au niveau d'API 24

Renvoie (1 / squarert(v)).

Voir aussi half_rsqrt(), native_rsqrt().

sign : signe d'une valeur

signe float(float v);
Signe float2(float2 v);
Signe float3(float3 v);
Signe float4(float4 v);
signe demi(moitié v);	Ajouté au niveau d'API 24
Signe half2(half2 v);	Ajouté au niveau d'API 24
signe half3(half3 v);	Ajouté au niveau d'API 24
Signe half4(half4 v);	Ajouté au niveau d'API 24

Renvoie le signe d'une valeur.

if (v < 0) return -1.f; else if (v > 0) return 1.f; else return 0.f;

sin : sinus

float sin(float v);
float2 sin(float2 v);
float3 sin(float3 v);
float4 sin(float4 v);
half sin(moitié v);	Ajouté au niveau d'API 24
half2 sin(half2 v);	Ajouté au niveau d'API 24
half3 sin(half3 v);	Ajouté au niveau d'API 24
half4 sin(half4 v);	Ajouté au niveau d'API 24

Renvoie le sinus d'un angle mesuré en radians.

Voir aussi native_sin().

sincos : sinus et cosinus

float sincos(float v, float* cos);
float2 sincos(float2 v, float2* cos);
float3 sincos(float3 v, float3* cos);
float4 sincos(float4 v, float4* cos);
demi sincos(moitié v, moitié* cos);	Ajouté au niveau d'API 24
half2 sincos(half2 v, half2* cos);	Ajouté au niveau d'API 24
half3 sincos(half3 v, half3* cos);	Ajouté au niveau d'API 24
half4 sincos(half4 v, half4* cos);	Ajouté au niveau d'API 24

Paramètres

v	Valeur entrante en radians.
cos	*cos a la valeur cosinus.

Renvoie

Sinus de v.

Renvoie le sinus et le cosinus d'une valeur.

Voir aussi native_sincos().

sinh : sinus hyperbolique

float sinh(float v);
float2 sinh(float2 v);
float3 sinh(float3 v);
float4 sinh(float4 v);
half sinh(moitié v);	Ajouté au niveau d'API 24
half2 sinh(moitié2 v);	Ajouté au niveau d'API 24
half3 sinh(half3 v);	Ajouté au niveau d'API 24
half4 sinh(half4 v);	Ajouté au niveau d'API 24

Renvoie le sinus hyperbolique de v, où v est mesuré en radians.

Voir aussi native_sinh().

sinpi : sinus d'un nombre multiplié par pi

float sinpi(float v);
float2 sinpi(float2 v);
float3 sinpi(float3 v);
float4 sinpi(float4 v);
half sinpi(moitié v);	Ajouté au niveau d'API 24
half2 sinpi(half2 v);	Ajouté au niveau d'API 24
half3 sinpi(half3 v);	Ajouté au niveau d'API 24
half4 sinpi(half4 v);	Ajouté au niveau d'API 24

Renvoie le sinus de (v * pi), où (v * pi) est mesuré en radians.

Pour obtenir le sinus d'une valeur mesurée en degrés, appelez sinpi(v / 180.f).

Voir aussi native_sinpi().

sqrt : racine carrée

float sqrt(float v);
float2 sqrt(float2 v);
float3 sqrt(float3 v);
float4 sqrt(float4 v);
half sqrt(moitié v);	Ajouté au niveau d'API 24
half2 sqrt(half2 v);	Ajouté au niveau d'API 24
half3 sqrt(half3 v);	Ajouté au niveau d'API 24
half4 squarert(half4 v);	Ajouté au niveau d'API 24

Renvoie la racine carrée d'une valeur.

Voir aussi half_sqrt(), native_sqrt().

step : 0 si elle est inférieure à une valeur, 1 dans le cas contraire

float step(float edge, float v);
float2 step(bord flottant, float2 v);	Ajouté au niveau d'API 21
float2 step(float2 bord, float v);
étape float2(bord float2, float2 v);
étape float3(bord float, float3 v);	Ajouté au niveau d'API 21
float3 step(float3 bord, float v);
étape float3(bord float3, float3 v);
étape float4(bord float, float4 v);	Ajouté au niveau d'API 21
step float4(bord float4, float v);
step float4(bord float4, float4 v);
demi pas(moitié bord, moitié v);	Ajouté au niveau d'API 24
half2 pas(moitié bord, moitié2 v);	Ajouté au niveau d'API 24
demi2 pas(moitié2 bord, moitié v);	Ajouté au niveau d'API 24
half2 pas(moitié2 bord, moitié2v);	Ajouté au niveau d'API 24
demi3 pas(moitié bord, moitié3 v) ;	Ajouté au niveau d'API 24
demi3 pas(moitié3 bord, moitié v) ;	Ajouté au niveau d'API 24
demi3 pas(moitié3 bord, moitié3 v) ;	Ajouté au niveau d'API 24
half4 pas(moitié bord, moitié4 v) ;	Ajouté au niveau d'API 24
half4(moitié-4 bord, moitié v) ;	Ajouté au niveau d'API 24
half4(moitié-4 bord, moitié4 v) ;	Ajouté au niveau d'API 24

Renvoie 0.f si v < bord, 1.f dans le cas contraire.

Cela peut être utile pour créer des calculs conditionnels sans utiliser de boucles ni d'instructions d'embranchement. Par exemple, au lieu de calculer (a[i] < b[i]) ? 0.f : atan2(a[i], b[i]) pour les éléments correspondants d'un vecteur, vous pouvez utiliser step(a, b) * atan2(a, b).

tan : tangente

float tan(float v);
float2 tan(float2 v);
float3 tan(float3 v);
float4 tan(float4 v);
half tan(moitié v);	Ajouté au niveau d'API 24
half2 tan(half2 v);	Ajouté au niveau d'API 24
half3 tan(half3 v);	Ajouté au niveau d'API 24
half4 tan(half4 v);	Ajouté au niveau d'API 24

Renvoie la tangente d'un angle mesuré en radians.

Voir aussi native_tan().

tanh : tangente hyperbolique

float tanh(float v);
float2 tanh(float2 v);
float3 tanh(float3 v);
float4 tanh(float4 v);
half tanh(moitié v);	Ajouté au niveau d'API 24
half2 tanh(half2 v);	Ajouté au niveau d'API 24
half3 tanh(half3 v);	Ajouté au niveau d'API 24
half4 tanh(half4 v);	Ajouté au niveau d'API 24

Affiche la tangente hyperbolique d'une valeur.

Voir aussi native_tanh().

tanpi : tangente d'un nombre multiplié par pi

float tanpi(float v);
float2 tanpi(float2 v);
float3 tanpi(float3 v);
float4 tanpi(float4 v);
half tanpi(moitié v);	Ajouté au niveau d'API 24
half2 tanpi(half2 v);	Ajouté au niveau d'API 24
half3 tanpi(half3 v);	Ajouté au niveau d'API 24
half4 tanpi(half4 v);	Ajouté au niveau d'API 24

Renvoie la tangente de (v * pi), où (v * pi) est mesuré en radians.

Pour obtenir la tangente d'une valeur mesurée en degrés, appelez tanpi(v / 180.f).

Voir aussi native_tanpi().

tgamma : fonction Gamma

float tgamma(float v);
float2 tgamma(float2 v);
float3 tgamma(float3 v);
float4 tgamma(float4 v);
half tgamma(moitié v);	Ajouté au niveau d'API 24
half2 tgamma(half2 v);	Ajouté au niveau d'API 24
half3 tgamma(half3 v);	Ajouté au niveau d'API 24
half4 tgamma(half4 v);	Ajouté au niveau d'API 24

Affiche la fonction gamma d'une valeur.

Consultez également lgamma().

trunc : tronque une valeur à virgule flottante

float trunc(float v);
float2 trunc(float2 v);
float3 trunc(float3 v);
float4 trunc(float4 v);
half trunc(moitié v);	Ajouté au niveau d'API 24
half2 trunc(half2 v);	Ajouté au niveau d'API 24
half3 trunc(half3 v);	Ajouté au niveau d'API 24
half4 trunc(half4 v);	Ajouté au niveau d'API 24

Arrondit à l'intégrale en utilisant la troncation.

Par exemple, trunc(1.7f) renvoie 1.f, et trunc(-1.7f) renvoie -1.f.

Consultez rint() et round() pour connaître les autres options d'arrondi.