Se usó la API de Cloud Translation para traducir esta página.

Funciones y constantes matemáticas de RenderScript

Descripción general

Las funciones matemáticas que aparecen a continuación se pueden aplicar a escalares y vectores. Cuando se aplica a los vectores, el valor que se muestra es un vector de la función aplicada a cada entrada de la entrada.

Por ejemplo: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);

Consulta las Funciones matemáticas de vector para ver funciones como distance() y length(), que interpretan la entrada como un solo vector en un espacio n-dimensional.

La precisión de las operaciones matemáticas en flotantes de 32 bits se ve afectada por los pragmas rs_fp_relaxed y rs_fp_full. Bajo rs_fp_relaxed, los valores subnormales pueden pasarse a cero y se puede redondear hacia cero. En comparación, rs_fp_full requiere el manejo correcto de valores subnormales, es decir, menores que 1.17549435e-38f. rs_fp_rull también requiere redondear al más cercano con empate.

Se pueden lograr diferentes concesiones entre la velocidad y la precisión mediante el uso de variantes de las funciones matemáticas comunes. Funciones cuyo nombre comienza con

native_: Es posible que tenga implementaciones de hardware personalizadas con una precisión más débil. Además, los valores subnormales pueden pasarse a cero y se puede usar el redondeo hacia cero, y es posible que la entrada infinita y NaN no se manejen de forma correcta.
mitad_: Puede realizar cómputos internos con flotantes de 16 bits. Además, los valores subnormales pueden descartarse a cero y se puede usar el redondeo hacia cero.

Resumen

Constantes
M_1_PI	1 / pi, como un número de punto flotante de 32 bits
M_2_PI	2 / pi, como un número de punto flotante de 32 bits
M_2_RAIZ2PI	2 / sqrt(pi), como un número de punto flotante de 32 bits
M_E	e, como un número de punto flotante de 32 bits
M_LN10	log_e(10), como un número de punto flotante de 32 bits
M_LN2	log_e(2), como un número de punto flotante de 32 bits
M_LOG10E	log_10(e), como un número de punto flotante de 32 bits
M_LOG2E	log_2(e), como un número de punto flotante de 32 bits
M_PI	pi, como un número de punto flotante de 32 bits.
M_PI_2	pi / 2, como un número de punto flotante de 32 bits
M_PI_4	pi / 4, como un número de punto flotante de 32 bits
M_SQRT1_2	1 / sqrt(2), como un número de punto flotante de 32 bits
M_SQRT2	cuadrado(2), como número de punto flotante de 32 bits

Funciones
absoluto	Valor absoluto de un número entero
acos	Coseno inverso
acosador	Coseno hiperbólico inverso
acospi	Coseno inverso dividido por pi
asen	Seno inverso
asinh	Seno hiperbólico inverso
asinpi	Seno inverso dividido por pi
atán	Tangente inversa
atan2	Tangente inversa de una proporción
atan2pi	Tangente inversa de una proporción, dividida por el valor pi
atán	Tangente hiperbólica inversa
atanpi	Tangente inversa dividida por pi
CTR	Raíz cúbica
ceil	Número entero más pequeño no menor que un valor
restringir	Restringe un valor a un rango
clz	Cantidad de 0 bits iniciales
copysign	Copia el signo de un número a otro
cos	Coseno
coge	Coseno hiperbólico
cospi	Coseno de un número multiplicado por pi
grados	Convierte radianes en grados.
erf	Función de error matemático
EFC	Función de error complementario matemático
exp.	elevado a un número
exp.10	10 elevado a un número
exp.2	2 elevado a un número
expm1	e elevado a un número menos uno
fabulosos	Valor absoluto de un número de punto flotante
fdim	Diferencia positiva entre dos valores
piso	Número entero más pequeño que no sea mayor que un valor
mujer	Multiplica y agrega
campaña de máx. rendimiento	Máximo de dos números de punto flotante
juan	Mínimo de dos números de punto flotante
fmod	Módulo
fracta	Parte fraccionaria positiva
frexp	Mantisa binaria y exponente
half_recip	Calculado recíproco con una precisión de 16 bits
medio_rsqrt	Recíproco de una raíz cuadrada calculada con una precisión de 16 bits
medio_sqrt	Raíz cuadrada calculada con una precisión de 16 bits
hipoteo	Hipotenusa
ilogb	Exponente base dos
exp. ldexp	Crea un punto flotante a partir de la mantisa y el exponente.
lgamma	Logaritmo natural de la función gamma
registro	Logaritmo natural
Registro10	Logaritmo en base 10
log1p	Logaritmo natural de un valor más 1
Registro2	Logaritmo en base 2
logb	Exponente base dos
enfadado	Multiplica y agrega
máx.	Máxima
min	Mínima
mezcla	Combina dos valores
modf	Componentes integrales y fraccionarios
nan	No es un número
nan_half	No es un número
native_acos	Coseno inverso aproximado
nativo_acosh	Coseno hiperbólico inverso aproximado
native_acospi	Coseno inverso aproximado dividido por pi
native_asin	Seno inverso aproximado
native_asinh	Seno hiperbólico inverso aproximado
native_asinpi	Seno inverso aproximado dividido por pi
native_atan	Tangente inversa aproximada
native_atan2	Tangente inversa aproximada de una proporción
native_atan2pi	Tangente inversa aproximada de una proporción, dividida por el valor pi
nativo_atanh	Tangente hiperbólica inversa aproximada
native_atanpi	Tangente inversa aproximada dividida por pi
native_cbrt	Raíz cúbica aproximada
native_cos	Coseno aproximado
native_cosh	Coseno hipobólico aproximado
native_cospi	Coseno aproximado de un número multiplicado por pi
native_divide	División aproximada
nativo_exp.	E aproximadamente elevado a un número
nativo_exp10	Aproximadamente 10 elevado a un número
native_exp2	Aproximadamente 2 se elevado a un número
native_expm1	E aproximadamente elevado a un número menos uno
native_hypot	Hipotenusa aproximada
native_log	Logaritmo natural aproximado
native_log10;	Logaritmo en base 10 aproximado
native_log1p;	Logaritmo natural aproximado de un valor más 1
native_log2	Logaritmo aproximado en base 2
native_powr	Base positiva aproximada elevada a un exponente
native_recip	Recíproco aproximado
native_rootn	Raíz enésima aproximada
native_rsqrt	Recíproco aproximado de una raíz cuadrada
native_sen	Seno aproximado
native_sincos	Seno y coseno aproximados
native_sinh	Seno hiperbólico aproximado
native_sinpi	Seno aproximado de un número multiplicado por pi
native_sqrt	Raíz cuadrada aproximada
native_tan	Tangente aproximada
native_tanh	Tangente hiperbólica aproximada
native_tanpi	Tangente aproximada de un número multiplicado por pi
nextafter	Siguiente número de punto flotante
pistolas	Se eleva la base a un exponente
polo	Base elevada a un exponente de número entero
pulso	Base positiva elevada a un exponente
radianes	Convierte grados en radianes.
resto	El resto de una división
remo	Resto y cociente de una división
rint	Redondear a par
raíz	Raíz enésima
redondo	Redondear desde cero
rsRand	Número pseudoaleatorio
rsqrt	Recíproco de una raíz cuadrada
signo	Signo de un valor
sen	Seno
sincos	Seno y coseno
sena	Seno hiperbólico
sinpi	Seno de un número multiplicado por pi
sqrt	Raíz cuadrada
paso	0 si es menor que un valor, 1 de lo contrario
bronce	Tangente
juan	Tangente hiperbólica
tanpi	Tangente de un número multiplicado por pi
tgamma	Función gamma
truco	Trunca un punto flotante

Funciones obsoletas
rsClamp.	Obsoleto. Restringe un valor a un rango
rsFrac	Obsoleto. Devuelve la parte fraccionaria de un número de punto flotante

Constantes

M_1_PI : 1 / pi, como un número de punto flotante de 32 bits

Valor: 0.318309886183790671537767526745028724f

El inverso de pi, como un número de punto flotante de 32 bits.

M_2_PI : 2 / pi, como un número de punto flotante de 32 bits

Valor: 0.636619772367581343075535053490057448f

2 dividido por pi, como un número de punto flotante de 32 bits.

M_2_SQRTPI : 2 / sqrt(pi), como un número de punto flotante de 32 bits

Valor: 1.128379167095512573896158903121545172f

2 dividido por la raíz cuadrada de pi, como un número de punto flotante de 32 bits.

M_E : e, como un número de punto flotante de 32 bits

Valor: 2.718281828459045235360287471352662498f

El número e, la base del logaritmo natural, como un número de punto flotante de 32 bits.

M_LN10 : log_e(10), como un número de punto flotante de 32 bits

Valor: 2.302585092994045684017991454684364208f

Logaritmo natural de 10, como un número de punto flotante de 32 bits.

M_LN2 : log_e(2), como un número de punto flotante de 32 bits

Valor: 0.693147180559945309417232121458176568f

Logaritmo natural de 2, como un número de punto flotante de 32 bits.

M_LOG10E : log_10(e), como un número de punto flotante de 32 bits

Valor: 0.434294481903251827651128918916605082f

Logaritmo en base 10 de e, como un número de punto flotante de 32 bits.

M_LOG2E : log_2(e), como un número de punto flotante de 32 bits

Valor: 1.442695040888963407359924681001892137f

Logaritmo en base 2 de e, como un número de punto flotante de 32 bits.

M_PI : pi, como un número de punto flotante de 32 bits

Valor: 3.141592653589793238462643383279502884f

El pi constante, como un número de punto flotante de 32 bits.

M_PI_2 : pi / 2, como un número de punto flotante de 32 bits

Valor: 1.570796326794896619231321691639751442f

Pi dividido por 2, como un número de punto flotante de 32 bits.

M_PI_4 : pi / 4, como un número de punto flotante de 32 bits

Valor: 0.785398163397448309615660845819875721f

Pi dividido por 4, como un número de punto flotante de 32 bits.

M_SQRT1_2 : 1 / sqrt(2), como un número de punto flotante de 32 bits

Valor: 0.707106781186547524400844362104849039f

Inverso de la raíz cuadrada de 2, como un número de punto flotante de 32 bits.

M_SQRT2 : sqrt(2), como número de punto flotante de 32 bits

Valor: 1.414213562373095048801688724209698079f

Raíz cuadrada de 2, como un número de punto flotante de 32 bits.

Funciones

abs : Valor absoluto de un número entero

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

Muestra el valor absoluto de un número entero.

Para los números de punto flotante, usa fabs().

acos : coseno inverso

float acos(float v);
float2 acos(float2 v);
float3 acos(float3 v);
float4 acos(float4 v);
mitad acos(mitad v);	Se agregó en el nivel de API 24.
half2 acos(half2 v);	Se agregó en el nivel de API 24.
half3 acos(half3 v);	Se agregó en el nivel de API 24.
half4 acos(half4 v);	Se agregó en el nivel de API 24.

Muestra el coseno inverso, en radianes.

Consulta también native_acos().

acosh : coseno hiperbólico inverso

float acosh(float v);
float2 acosh(float2 v);
float3 acosh(float3 v);
float4 acosh(float4 v);
medio acosh(medio v);	Se agregó en el nivel de API 24.
half2 acosh(half2 v);	Se agregó en el nivel de API 24.
mitad3 acosh(mitad3 v);	Se agregó en el nivel de API 24.
mitad4 acosh(medio4 v);	Se agregó en el nivel de API 24.

Muestra el coseno hiperbólico inverso, en radianes.

Consulta también native_acosh().

acospi : coseno inverso dividido por pi

float acospi(float v);
float2 acospi(float2 v);
float3 acospi(float3 v);
float4 acospi(float4 v);
medio acospi(medio v);	Se agregó en el nivel de API 24.
half2 acospi(half2 v);	Se agregó en el nivel de API 24.
half3 acospi(half3 v);	Se agregó en el nivel de API 24.
half4 acospi(half4 v);	Se agregó en el nivel de API 24.

Muestra el coseno inverso en radianes, dividido por pi.

Para obtener un coseno inverso medido en grados, usa acospi(a) * 180.f.

Consulta también native_acospi().

asin : seno inverso

float asin(float v);
float2 asin(float2 v);
float3 asin(float3 v);
float4 asin(float4 v);
mitad asin(mitad v);	Se agregó en el nivel de API 24.
mitad2 asin(mitad2 v);	Se agregó en el nivel de API 24.
half3 asin(half3 v);	Se agregó en el nivel de API 24.
mitad4 asin(mitad4 v);	Se agregó en el nivel de API 24.

Muestra el seno inverso, en radianes.

Consulta también native_asin().

asinh : seno hiperbólico inverso

float asinh(float v);
float2 asinh(float2 v);
float3 asinh(float3 v);
float4 asinh(float4 v);
mitad asinh(mitad v);	Se agregó en el nivel de API 24.
half2 asinh(half2 v);	Se agregó en el nivel de API 24.
half3 asinh(mitad3 v);	Se agregó en el nivel de API 24.
mitad4 asinh(mitad4 v);	Se agregó en el nivel de API 24.

Muestra el seno hiperbólico inverso, en radianes.

Consulta también native_asinh().

asinpi : seno inverso dividido por pi

float asinpi(float v);
float2 asinpi(float2 v);
float3 asinpi(float3 v);
float4 asinpi(float4 v);
mitad asinpi(media v);	Se agregó en el nivel de API 24.
half2 asinpi(half2 v);	Se agregó en el nivel de API 24.
half3 asinpi(half3 v);	Se agregó en el nivel de API 24.
half4 asinpi(half4 v);	Se agregó en el nivel de API 24.

Muestra el seno inverso en radianes, dividido por pi.

Para obtener un seno inverso medido en grados, usa asinpi(a) * 180.f.

Consulta también native_asinpi().

atan : tangente inversa

float atan(float v);
float2 atan(float2 v);
float3 atan(float3 v);
float4 atan(float4 v);
medio atan(mitad v);	Se agregó en el nivel de API 24.
mitad2 atan(mitad2 v);	Se agregó en el nivel de API 24.
half3 atan(mitad3 v);	Se agregó en el nivel de API 24.
half4 atan(mitad4 v);	Se agregó en el nivel de API 24.

Muestra la tangente inversa, en radianes.

Consulta también native_atan().

atan2 : Tangente inversa de una proporción

float atan2(numerador flotante, denominador de número de punto flotante);
float2 atan2(float2 numerador, float2 denominador);
float3 atan2(float3 numerador, float3 denominador);
float4 atan2(float4 numerador, float4 denominador);
medio atan2(mitad numerador, medio denominador);	Se agregó en el nivel de API 24.
half2 atan2(mitad2 numerador, medio2 denominador);	Se agregó en el nivel de API 24.
half3 atan2(mitad3 numerador, mitad3 denominador);	Se agregó en el nivel de API 24.
half4 atan2(mitad4 numerador, medio4 denominador);	Se agregó en el nivel de API 24.

Parámetros

numerador	Numerador.
denominador	Denominador Puede ser 0.

Muestra la tangente inversa de (numerator / denominator), en radianes.

Consulta también native_atan2().

atan2pi : Tangente inversa de una proporción, dividida por pi

float atan2pi(numerador flotante, denominador de número de punto flotante);
float2 atan2pi(float2 numerador, float2 denominador);
float3 atan2pi(float3 numerador, float3 denominador);
float4 atan2pi(float4 numerador, float4 denominador);
medio atan2pi(mitad numerador, medio denominador);	Se agregó en el nivel de API 24.
mitad2 atan2pi(numerador mitad2, denominador medio2);	Se agregó en el nivel de API 24.
half3 atan2pi(mitad3 numerador, medio3 denominador);	Se agregó en el nivel de API 24.
half4 atan2pi(mitad4 numerador, medio4 denominador);	Se agregó en el nivel de API 24.

Parámetros

numerador	Numerador.
denominador	Denominador Puede ser 0.

Muestra la tangente inversa de (numerator / denominator), en radianes, dividida por pi.

Para obtener una tangente inversa medida en grados, usa atan2pi(n, d) * 180.f.

Consulta también native_atan2pi().

atanh : tangente hiperbólica inversa

float atanh(float v);
float2 atanh(float2 v);
float3 atanh(float3 v);
float4 atanh(float4 v);
mitad atanh(mitad v);	Se agregó en el nivel de API 24.
mitad2 atanh(mitad2 v);	Se agregó en el nivel de API 24.
mitad3 atanh(mitad3 v);	Se agregó en el nivel de API 24.
mitad4 atanh(mitad4 v);	Se agregó en el nivel de API 24.

Muestra la tangente hiperbólica inversa, en radianes.

Consulta también native_atanh().

atanpi : tangente inversa dividida por pi

float atanpi(float v);
float2 atanpi(float2 v);
float3 atanpi(float3 v);
float4 atanpi(float4 v);
mitad atanpi(mitad v);	Se agregó en el nivel de API 24.
half2 atanpi(mitad2 v);	Se agregó en el nivel de API 24.
half3 atanpi(mitad3 v);	Se agregó en el nivel de API 24.
mitad4 atanpi(medio4 v);	Se agregó en el nivel de API 24.

Muestra la tangente inversa en radianes, dividida por el valor de pi.

Para obtener una tangente inversa medida en grados, usa atanpi(a) * 180.f.

Consulta también native_atanpi().

cbrt : Raíz cúbica

cbrt(float v);
float2 cbrt(float2 v);
float3 cbrt(float3 v);
float4 cbrt(float4 v);
mitad brt(mitad v);	Se agregó en el nivel de API 24.
mitad2 cbrt(mitad2 v);	Se agregó en el nivel de API 24.
mitad3 cbrt(mitad3 v);	Se agregó en el nivel de API 24.
mitad4 cbrt(mitad4 v);	Se agregó en el nivel de API 24.

Muestra la raíz cúbica.

Consulta también native_cbrt().

ceil : El número entero más pequeño, no menor que un valor

float ceil(float v);
float2 ceil(float2 v);
float3 ceil(float3 v);
float4 ceil(float4 v);
mitad ceil(media v);	Se agregó en el nivel de API 24.
mitad2 ceil(medio2 v);	Se agregó en el nivel de API 24.
mitad3 ceil(mitad3 v);	Se agregó en el nivel de API 24.
mitad 4 ceil(media 4 v);	Se agregó en el nivel de API 24.

Muestra el número entero más pequeño no menor que un valor.

Por ejemplo, ceil(1.2f) muestra 2.f y ceil(-1.2f) muestra -1.f.

Consulta también floor().

clamp : Restringe un valor a un rango

char clamp(valor de carácter, valor_mín_caracter, valor_máx_caracter);	Se agregó en el nivel de API 19.
char2 clamp(char2 value, char min_value, char max_value)	Se agregó en el nivel de API 19.
char2 clamp(char2 value, char2 min_value, char2 max_value)	Se agregó en el nivel de API 19.
char3 clamp(char3 value, char min_value, char max_value)	Se agregó en el nivel de API 19.
char3 clamp(char3 value, char3 min_value, char3 max_value)	Se agregó en el nivel de API 19.
char4 clamp(char4 value, char min_value, char max_value);	Se agregó en el nivel de API 19.
char4 clamp(char4 value, char4 min_value, char4 max_value)	Se agregó en el nivel de API 19.
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);
float3 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);
mitad restricción(medio valor, medio valor_mín., medio valor_máx.);	Se agregó en el nivel de API 24.
mitad2 clamp(valor medio2, medio valor_mín., medio valor_máx.);	Se agregó en el nivel de API 24.
half2 clamp(valor half2, half2 valor_mín., half2 max_value);	Se agregó en el nivel de API 24.
mitad3 clamp(valor medio3, valor_mín. medio, medio valor_máx.);	Se agregó en el nivel de API 24.
half3 clamp(half3 valor, half3 min_value, half3 max_value);	Se agregó en el nivel de API 24.
mitad4 clamp(valor medio4, medio valor_mín., medio valor_máx.);	Se agregó en el nivel de API 24.
mitad4 clamp(valor medio4, valor_mín. medio4, medio4 valor_máx.);	Se agregó en el nivel de API 24.
int clamp(valor int, valor_mín int, valor_máx_int);	Se agregó en el nivel de API 19.
int2 clamp(valor int2, int min_value, int max_value);	Se agregó en el nivel de API 19.
int2 clamp(valor int2, int2 min_value, int2 max_value);	Se agregó en el nivel de API 19.
int3 clamp(valor int3, int min_value, int max_value);	Se agregó en el nivel de API 19.
int3 clamp(valor int3, int3 min_value, int3 max_value);	Se agregó en el nivel de API 19.
int4 clamp(valor int4, int min_value, int max_value);	Se agregó en el nivel de API 19.
int4 clamp(valor int4, int4 min_value, int4 max_value);	Se agregó en el nivel de API 19.
long clamp(long value, long min_value, long max_value);	Se agregó en el nivel de API 19.
long2 clamp(valor long2, long min_value, long max_value);	Se agregó en el nivel de API 19.
clamp long2(valor long2, long2 min_value, long2 max_value);	Se agregó en el nivel de API 19.
long3 clamp(valor long3, valor min_largo, valor máx_largo);	Se agregó en el nivel de API 19.
Sujeto a la restricción long3(valor long3, long3 min_value, long3 max_value);	Se agregó en el nivel de API 19.
long4 clamp(long4 value, long min_value, long max_value);	Se agregó en el nivel de API 19.
Fijar long4(valor long4, long4 min_value, long4 max_value);	Se agregó en el nivel de API 19.
short clamp(short value, short min_value, short max_value);	Se agregó en el nivel de API 19.
Restricción short2(valor short2, valor_mín_corto, valor_max_corto);	Se agregó en el nivel de API 19.
clamp short2(valor short2, short2 min_value, short2 max_value);	Se agregó en el nivel de API 19.
Restricción short3(valor short3, valor_mín_corto, valor_max_corto);	Se agregó en el nivel de API 19.
Restricción short3(valor short3, short3 min_value, short3 max_value);	Se agregó en el nivel de API 19.
Restricción short4(valor short4, valor_mín_corto, valor_max_corto);	Se agregó en el nivel de API 19.
Restricción short4(valor short4, short4 min_value, short4 max_value);	Se agregó en el nivel de API 19.
uchar clamp(valor uchar, uchar min_value, uchar max_value);	Se agregó en el nivel de API 19.
uchar2 clamp(valor uchar2, uchar min_value, uchar max_value);	Se agregó en el nivel de API 19.
uchar2 clamp(valor uchar2, uchar2 valor_mín., uchar2 max_value);	Se agregó en el nivel de API 19.
Fijar uchar3(valor uchar3, valor mínimo uchar, uchar max_value)	Se agregó en el nivel de API 19.
uchar3 clamp(valor uchar3, uchar3 valor_mín., uchar3 max_value);	Se agregó en el nivel de API 19.
uchar4 clamp(valor uchar4, uchar min_value, uchar max_value)	Se agregó en el nivel de API 19.
uchar4 clamp(valor uchar4, uchar4 valor_mín., uchar4 max_value);	Se agregó en el nivel de API 19.
uint clamp(valor uint, uint valor_mín., uint max_value);	Se agregó en el nivel de API 19.
uint2 clamp(valor uint2, uint min_value, uint max_value);	Se agregó en el nivel de API 19.
uint2 clamp(valor uint2, uint2 valor_mín., uint2 max_value);	Se agregó en el nivel de API 19.
Fijar uint3(valor uint3, uint valor_mín., uint max_value);	Se agregó en el nivel de API 19.
uint3 clamp(valor uint3, uint3 valor_mín., uint3 max_value);	Se agregó en el nivel de API 19.
uint4 clamp(valor uint4, uint min_value, uint max_value);	Se agregó en el nivel de API 19.
uint4 clamp(valor uint4, uint4 valor_mín., uint4 max_value);	Se agregó en el nivel de API 19.
Restricción ulong(valor ulong, valor_mín_ulong, valor_máx_ulong);	Se agregó en el nivel de API 19.
ulong2 clamp(valor ulong2, ulong min_value, ulong max_value);	Se agregó en el nivel de API 19.
ulong2 clamp(valor ulong2, ulong2 min_value, ulong2 max_value);	Se agregó en el nivel de API 19.
Fijar ulong3(valor ulong3, ulong min_value, ulong max_value);	Se agregó en el nivel de API 19.
ulong3 clamp(valor ulong3, ulong3 min_value, ulong3 max_value);	Se agregó en el nivel de API 19.
Fijar ulong4(valor ulong4, ulong min_value, ulong max_value);	Se agregó en el nivel de API 19.
Fijar ulong4(valor ulong4, ulong4 min_value, ulong4 max_value);	Se agregó en el nivel de API 19.
Fijar ushort(valor ushort, ushort min_value, ushort max_value);	Se agregó en el nivel de API 19.
Fijar ushort2(valor ushort2, ushort min_value, ushort max_value);	Se agregó en el nivel de API 19.
ushort2 clamp(valor ushort2, ushort2 min_value, ushort2 max_value);	Se agregó en el nivel de API 19.
Fijar ushort3(valor ushort3, ushort min_value, ushort max_value);	Se agregó en el nivel de API 19.
ushort3 clamp(valor ushort3, ushort3 min_value, ushort3 max_value);	Se agregó en el nivel de API 19.
Fijar ushort4(valor ushort4, ushort min_value, ushort max_value);	Se agregó en el nivel de API 19.
Fijar ushort4(valor ushort4, ushort4 min_value, ushort4 max_value);	Se agregó en el nivel de API 19.

Parámetros

valor	Valor que se debe restringir.
valor_mín.	Límite inferior, un vector escalar o coincidente.
valor_máx.	Límite alto; debe coincidir con el tipo de bajo.

Fija un valor a un límite alto y bajo especificado. clamp() muestra min_value si value < min_value, max_value si value > max_value; de lo contrario, value.

Hay dos variantes de restricción: una en la que el valor mínimo y máximo son escalares aplicados a todas las entradas del valor, y la otra en la que el valor mínimo y máximo también son vectores.

Si min_value es mayor que max_value, los resultados son indefinidos.

clz : Número de bits 0 iniciales

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

Muestra el número de 0 bits iniciales de un valor.

Por ejemplo, clz((char)0x03) muestra 6.

copysign : Copia el signo de un número a otro

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(mitad magnitude_value, half sign_value);	Se agregó en el nivel de API 24.
half2 copysign(half2 magnitude_value, half2 sign_value);	Se agregó en el nivel de API 24.
half3 copysign(half3 magnitude_value, half3 sign_value);	Se agregó en el nivel de API 24.
half4 copysign(half4 magnitude_value, half4 sign_value);	Se agregó en el nivel de API 24.

Copia el signo de sign_value a magnitude_value.

El valor que se muestra es magnitude_value o -magnitude_value.

Por ejemplo, copysign(4.0f, -2.7f) muestra -4.0f y copysign(-4.0f, 2.7f) muestra 4.0f.

cos : coseno

float cos(float v);
float2 cos(float2 v);
float3 cos(float3 v);
float4 cos(float4 v);
half cos(mitad v);	Se agregó en el nivel de API 24.
half2 cos(half2 v);	Se agregó en el nivel de API 24.
half3 cos(half3 v);	Se agregó en el nivel de API 24.
half4 cos(half4 v);	Se agregó en el nivel de API 24.

Muestra el coseno de un ángulo medido en radianes.

Consulta también native_cos().

cosh : coseno hiperbólico

float cosh(float v);
float2 cosh(float2 v);
float3 cosh(float3 v);
float4 cosh(float4 v);
mitad cosh(mitad v);	Se agregó en el nivel de API 24.
mitad2 cosh(mitad2 v);	Se agregó en el nivel de API 24.
mitad3 cosh(mitad3 v);	Se agregó en el nivel de API 24.
mitad4 cosh(medio4 v);	Se agregó en el nivel de API 24.

Muestra el coseno hipobólico de v, donde v se mide en radianes.

Consulta también native_cosh().

cospi : Coseno de un número multiplicado por pi

float cospi(float v);
float2 cospi(float2 v);
float3 cospi(float3 v);
float4 cospi(float4 v);
mitad cospi(mitad v);	Se agregó en el nivel de API 24.
half2 cospi(media2 v);	Se agregó en el nivel de API 24.
mitad3 cospi(mitad3 v);	Se agregó en el nivel de API 24.
mitad4 cospi(medio4 v);	Se agregó en el nivel de API 24.

Muestra el coseno de (v * pi), donde (v * pi) se mide en radianes.

Para obtener el coseno de un valor medido en grados, llama a cospi(v / 180.f).

Consulta también native_cospi().

grados : Convierte radianes en grados.

float grados(float v);
float2 grados(float2 v);
float3 grados(float3 v);
float4 grados(float4 v);
medio grados(medio v);	Se agregó en el nivel de API 24.
medio2 grados(medio2 v);	Se agregó en el nivel de API 24.
medio3 grados(medio3 v);	Se agregó en el nivel de API 24.
medio4 grados(medio4 v);	Se agregó en el nivel de API 24.

Convierte radianes en grados.

erf : Función de error matemático

float erf(float v);
float2 erf(float2 v);
float3 erf(float3 v);
float4 erf(float4 v);
mitad erf(mitad v);	Se agregó en el nivel de API 24.
mitad2 erf(mitad2 v);	Se agregó en el nivel de API 24.
mitad3 erf(mitad3 v);	Se agregó en el nivel de API 24.
mitad4 erf(mitad4 v);	Se agregó en el nivel de API 24.

Muestra la función de error.

erfc : función de error complementario matemático

float erfc(float v);
float2 erfc(float2 v);
float3 erfc(float3 v);
float4 erfc(float4 v);
half erfc(half v);	Se agregó en el nivel de API 24.
half2 erfc(half2 v);	Se agregó en el nivel de API 24.
half3 erfc(half3 v);	Se agregó en el nivel de API 24.
half4 erfc(half4 v);	Se agregó en el nivel de API 24.

Muestra la función de error complementaria.

exp : e elevado a un número

float exp(float v);
float2 exp(float2 v);
float3 exp(float3 v);
float4 exp(float4 v);
mitad exp(mitad v);	Se agregó en el nivel de API 24.
half2 exp(half2 v);	Se agregó en el nivel de API 24.
half3 exp(half3 v);	Se agregó en el nivel de API 24.
half4 exp(half4 v);	Se agregó en el nivel de API 24.

Muestra e elevado a v, es decir, e ^ v.

Consulta también native_exp().

exp10 : 10 elevado a un número

float exp10(float v);
float2 exp10(float2 v);
float3 exp10(float3 v);
float4 exp10(float4 v);
mitad exp10(mitad v);	Se agregó en el nivel de API 24.
half2 exp10(half2 v);	Se agregó en el nivel de API 24.
half3 exp10(mitad3 v);	Se agregó en el nivel de API 24.
half4 exp10(mitad4 v);	Se agregó en el nivel de API 24.

Muestra 10 elevado a v, es decir, 10.f ^ v.

Consulta también native_exp10().

exp2 : 2 elevado a un número

float exp2(float v);
float2 exp2(float2 v);
float3 exp2(float3 v);
float4 exp2(float4 v);
mitad exp2(mitad v);	Se agregó en el nivel de API 24.
half2 exp2(half2 v);	Se agregó en el nivel de API 24.
half3 exp2(mitad3 v);	Se agregó en el nivel de API 24.
half4 exp2(mitad4 v);	Se agregó en el nivel de API 24.

Muestra 2 elevado a v, es decir, 2.f ^ v.

Consulta también native_exp2().

expm1 : e elevado a un número menos uno

float expm1(float v);
float2 expm1(float2 v);
float3 expm1(float3 v);
float4 expm1(float4 v);
mitad expm1(mitad v);	Se agregó en el nivel de API 24.
half2 expm1(mitad2 v);	Se agregó en el nivel de API 24.
half3 expm1(mitad3 v);	Se agregó en el nivel de API 24.
half4 expm1(mitad4 v);	Se agregó en el nivel de API 24.

Muestra e elevado a v menos 1, es decir, (e ^ v) - 1.

Consulta también native_expm1().

fabs : Valor absoluto de un número de punto flotante

BAF flotante(float v);
float2 fabs(float2 v);
float3 fabs(float3 v);
float4 fabs(float4 v);
mitad fabs(mitad v);	Se agregó en el nivel de API 24.
mitad2 BAF(mitad2 v);	Se agregó en el nivel de API 24.
mitad 3 fabs(mitad 3 v);	Se agregó en el nivel de API 24.
mitad 4 BAF(mitad 4 v);	Se agregó en el nivel de API 24.

Muestra el valor absoluto de la v.

Para números enteros, usa abs().

fdim : Diferencia positiva entre dos valores

float fdim(float a, float b);
float2 fdim(float2 a, float2 b);
float3 fdim(float3 a, float3 b);
float4 fdim(float4 a, float4 b);
mitad fdim(media a, media b);	Se agregó en el nivel de API 24.
half2 fdim(half2 a, half2 b);	Se agregó en el nivel de API 24.
half3 fdim(half3 a, half3 b);	Se agregó en el nivel de API 24.
half4 fdim(media4 a, medio4 b);	Se agregó en el nivel de API 24.

Muestra la diferencia positiva entre dos valores.

Si a > b, muestra (a - b), de lo contrario, muestra 0f.

floor : número entero más pequeño que no sea mayor que un valor

float piso(float v);
float2 pisos(float2 v);
float3 pisos(float3 v);
float4 piso(float4 v);
medio piso(medio v);	Se agregó en el nivel de API 24.
medio2 piso(medio2 v);	Se agregó en el nivel de API 24.
medio3 piso(medio3 v);	Se agregó en el nivel de API 24.
medio4 piso(medio4 v);	Se agregó en el nivel de API 24.

Muestra el número entero más pequeño que no sea mayor que un valor.

Por ejemplo, floor(1.2f) muestra 1.f y floor(-1.2f) muestra -2.f.

Consulta también ceil().

fma : Multiplicar y sumar

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);
media fma(media multiplicando1, medio multiplicando2, media compensación);	Se agregó en el nivel de API 24.
half2 fma(media2 multiplicando1, medio2 multiplicando2, medio2 de compensación);	Se agregó en el nivel de API 24.
half3 fma(mitad3 multiplicando1, medio3 multiplicando2, mitad3 de compensación);	Se agregó en el nivel de API 24.
half4 fma(media4 multiplicando1, medio4 multiplicando2, medio4 de compensación);	Se agregó en el nivel de API 24.

Multiplica y agrega Muestra (multiplicand1 * multiplicand2) + offset.

Esta función es similar a mad(). fma() conserva la precisión total del resultado multiplicado y se redondea solo después de la suma. mad() redondea después de la multiplicación y la suma. Esta precisión adicional no se garantiza en el modo rs_fp_relaxed.

fmax : Máximo de dos números de punto flotante

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);
mitad fmax(media a, media b);	Se agregó en el nivel de API 24.
mitad2 fmax(mitad2 a, mitad b);	Se agregó en el nivel de API 24.
mitad2 fmax(mitad2 a, mitad 2 b);	Se agregó en el nivel de API 24.
mitad3 fmax(mitad 3 a, mitad b);	Se agregó en el nivel de API 24.
mitad3 fmax(mitad 3 a, mitad 3 b);	Se agregó en el nivel de API 24.
mitad 4 fmax(mitad 4 a, mitad b);	Se agregó en el nivel de API 24.
mitad 4 fmax(mitad 4 a, medio 4 b);	Se agregó en el nivel de API 24.

Muestra el máximo de a y b, es decir, (a < b ? b : a).

La función max() muestra resultados idénticos, pero puede aplicarse a más tipos de datos.

fmin : Mínimo de dos números de punto flotante

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);
media fmin(media a, media b);	Se agregó en el nivel de API 24.
media2 fmin(media2 a, media b);	Se agregó en el nivel de API 24.
media2 fmin(media2 a, medio2 b);	Se agregó en el nivel de API 24.
media3 fmin(media3 a, media b);	Se agregó en el nivel de API 24.
media3 fmin(media3 a, medio3 b);	Se agregó en el nivel de API 24.
media4 fmin(media4 a, media b);	Se agregó en el nivel de API 24.
media4 fmin(media4 a, medio4 b);	Se agregó en el nivel de API 24.

Muestra el mínimo de a y b, es decir, (a > b ? b : a).

La función min() muestra resultados idénticos, pero puede aplicarse a más tipos de datos.

fmod : Módulo

float fmod(numerador flotante, denominador de número de punto flotante);
float2 fmod(float2 numerador, float2 denominador);
float3 fmod(numerador float3, denominador float3);
float4 fmod(float4 numerador, float4 denominador);
mitad fmod(mitad numerador, medio denominador);	Se agregó en el nivel de API 24.
mitad2 fmod(numerador mitad2, denominador medio2);	Se agregó en el nivel de API 24.
mitad3 fmod(numerador mitad3, denominador medio3);	Se agregó en el nivel de API 24.
half4 fmod(mitad4 numerador, medio4 denominador);	Se agregó en el nivel de API 24.

Muestra el resto de (numerador / denominador), donde el cociente se redondea hacia cero.

La función remainder() es similar, pero se redondea hacia el número entero más cercano. Por ejemplo, fmod(-3.8f, 2.f) muestra -1.8f (-3.8f - -1.f * 2.f), mientras que remainder(-3.8f, 2.f) muestra 0.2f (-3.8f - -2.f * 2.f).

fract : Parte fraccionaria positiva

float fract(float v);
float fract(float v, float* Floor);
float2 fract(float2 v);
float2 fract(float2 v, float2* window);
float3 fract(float3 v);
float3 fract(float3 v, float3* window);
float4 fract(float4 v);
float4 fract(float4 v, float4* window);
media fract(media v);	Se agregó en el nivel de API 24.
media fract(media v, media* piso);	Se agregó en el nivel de API 24.
mitad2 fract(media2 v);	Se agregó en el nivel de API 24.
media2 fract(media2 v, media2* piso);	Se agregó en el nivel de API 24.
mitad3 fract(media3 v);	Se agregó en el nivel de API 24.
mitad3 fract(media3 v, media3* piso);	Se agregó en el nivel de API 24.
mitad4 fract(media4 v);	Se agregó en el nivel de API 24.
mitad4 fract(mitad 4 v, media 4* piso);	Se agregó en el nivel de API 24.

Parámetros

v	Valor de entrada.
piso	Si el piso no es nulo, *se fijará en el piso de v.

Muestra la parte fraccionaria positiva de v, es decir, v - floor(v).

Por ejemplo, fract(1.3f, &val) muestra 0.3f y establece el valor en 1.f. fract(-1.3f, &val) muestra 0.7f y establece el valor en -2.f.

frexp : Mantisa binaria y exponente

frexp float(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* exponente);	Se agregó en el nivel de API 24.
half2 frexp(half2 v, int2* exponente);	Se agregó en el nivel de API 24.
half3 frexp(half3 v, int3* exponente);	Se agregó en el nivel de API 24.
half4 frexp(half4 v, int4* exponente);	Se agregó en el nivel de API 24.

Parámetros

v	Valor de entrada.
exponente	Si el exponente no es nulo, *se establecerá el exponente de v.

Muestra la mantisa binaria y el exponente de v, es decir, v == mantissa * 2 ^ exponent.

La mantisa siempre está entre 0.5 (inclusive) y 1.0 (excluido).

Consulta ldexp() para ver la operación inversa. Consulta también logb() y ilogb().

half_recip : recíproco calculado con una precisión de 16 bits

float half_recip(float v);	Se agregó en el nivel de API 17.
float2 half_recip(float2 v);	Se agregó en el nivel de API 17.
float3 half_recip(float3 v);	Se agregó en el nivel de API 17.
float4 half_recip(float4 v);	Se agregó en el nivel de API 17.

Muestra el recíproco aproximado de un valor.

La precisión es la de un valor de punto flotante de 16 bits.

Consulta también native_recip().

half_rsqrt : Recíproco de una raíz cuadrada calculada con una precisión de 16 bits

float half_rsqrt(float v);	Se agregó en el nivel de API 17.
float2 half_rsqrt(float2 v);	Se agregó en el nivel de API 17.
float3 half_rsqrt(float3 v);	Se agregó en el nivel de API 17.
float4 half_rsqrt(float4 v);	Se agregó en el nivel de API 17.

Muestra el valor aproximado de (1.f / sqrt(value)).

La precisión es la de un valor de punto flotante de 16 bits.

Consulta también rsqrt(), native_rsqrt().

half_sqrt : raíz cuadrada calculada con una precisión de 16 bits

float half_sqrt(float v);	Se agregó en el nivel de API 17.
float2 half_sqrt(float2 v);	Se agregó en el nivel de API 17.
float3 half_sqrt(float3 v);	Se agregó en el nivel de API 17.
float4 half_sqrt(float4 v);	Se agregó en el nivel de API 17.

Muestra la raíz cuadrada aproximada de un valor.

La precisión es la de un valor de punto flotante de 16 bits.

Consulta también sqrt(), native_sqrt().

hipot : Hipotenusa

float hypot(float a, float b);
float2 hipot(float2 a, float2 b);
float3 hipot(float3 a, float3 b);
float4 hypot(float4 a, float4 b);
medio hipo(media a, media b);	Se agregó en el nivel de API 24.
mitad2 hipo(media2 a, medio2 b);	Se agregó en el nivel de API 24.
mitad3 hipot(mitad3 a, medio3 b);	Se agregó en el nivel de API 24.
mitad4 hipot(mitad4 a, medio4 b);	Se agregó en el nivel de API 24.

Muestra la hipotenusa, es decir, sqrt(a * a + b * b).

Consulta también native_hypot().

ilogb : exponente de base dos

int ilogb(flotante v);
int ilogb(mitad v);	Se agregó en el nivel de API 24.
int2 ilogb(float2 v);
int2 ilogb(mitad2 v);	Se agregó en el nivel de API 24.
int3 ilogb(float3 v);
int3 ilogb(mitad3 v);	Se agregó en el nivel de API 24.
int4 ilogb(float4 v);
int4 ilogb(medio4 v);	Se agregó en el nivel de API 24.

Muestra el exponente base dos de un valor, donde la mantisa está entre 1.f (inclusive) y 2.f (exclusivo).

Por ejemplo, ilogb(8.5f) muestra 3.

Debido a la diferencia en mantisa, este número es uno menos que el que muestra frexp().

logb() es similar, pero muestra un número de punto flotante.

ldexp : Crea un punto flotante a partir de mantisa y exponente.

float ldexp(float mantissa, int exponent);
float2 ldexp(float2 mantissa, int exponent);
float2 ldexp(float2 mantissa, int2 exponent);
float3 ldexp(float3 mantissa, int exponent);
float3 ldexp(float3 mantissa, int3 exponent);
float4 ldexp(float4 mantissa, int exponent);
float4 ldexp(float4 mantissa, int4 exponent);
half ldexp(mitad mantisa, exponente int);	Se agregó en el nivel de API 24.
half2 ldexp(half2 mantisa, exponente int);	Se agregó en el nivel de API 24.
half2 ldexp(half2 mantisa, exponente int2);	Se agregó en el nivel de API 24.
half3 ldexp(half3 mantisa, exponente int);	Se agregó en el nivel de API 24.
half3 ldexp(half3 mantisa, exponente int3);	Se agregó en el nivel de API 24.
half4 ldexp(half4 mantisa, exponente int);	Se agregó en el nivel de API 24.
half4 ldexp(half4 mantisa, exponente int4);	Se agregó en el nivel de API 24.

Parámetros

mantisa	Mantisa.
exponente	Exponente, un solo componente o vector coincidente.

Muestra el punto flotante creado a partir de la mantisa y el exponente, es decir, (mantisa * 2 ^ exponente).

Consulta frexp() para obtener la operación inversa.

lgamma : Logaritmo natural de la función gamma

float lgamma(float v);
lgamma(flotante v, int* signo_de_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);
mitad lgamma(mitad v);	Se agregó en el nivel de API 24.
mitad lgamma(mitad v, int* signo_de_gamma);	Se agregó en el nivel de API 24.
half2 lgamma(half2 v);	Se agregó en el nivel de API 24.
half2 lgamma(half2 v, int2* sign_of_gamma);	Se agregó en el nivel de API 24.
half3 lgamma(half3 v);	Se agregó en el nivel de API 24.
half3 lgamma(half3 v, int3* sign_of_gamma);	Se agregó en el nivel de API 24.
half4 lgamma(half4 v);	Se agregó en el nivel de API 24.
half4 lgamma(half4 v, int4* sign_of_gamma);	Se agregó en el nivel de API 24.

Parámetros

v
signo_de_gamma	Si el signo_de_gamma no es nulo, *sign_of_gamma se fijará en -1.f si el gamma de v es negativo, de lo contrario, se fijará en 1.f.

Muestra el logaritmo natural del valor absoluto de la función gamma, es decir, log(fabs(tgamma(v))).

Consulta también tgamma().

log : Logaritmo natural

float log(float v);
float2 log(float2 v);
float3 log(float3 v);
float4 log(float4 v);
mitad log(mitad v);	Se agregó en el nivel de API 24.
half2 log(half2 v);	Se agregó en el nivel de API 24.
half3 log(half3 v);	Se agregó en el nivel de API 24.
half4 log(half4 v);	Se agregó en el nivel de API 24.

Muestra el logaritmo natural.

Consulta también native_log().

log10 : Logaritmo en base 10

float log10(float v);
float2 log10(float2 v);
float3 log10(float3 v);
float4 log10(float4 v);
mitad log10(mitad v);	Se agregó en el nivel de API 24.
half2 log10(mitad2 v);	Se agregó en el nivel de API 24.
half3 log10(mitad3 v);	Se agregó en el nivel de API 24.
mitad4 log10(mitad4 v);	Se agregó en el nivel de API 24.

Muestra el logaritmo en base 10.

Consulta también native_log10().

log1p : Logaritmo natural de un valor más 1

float log1p(float v);
float2 log1p(float2 v);
float3 log1p(float3 v);
float4 log1p(float4 v);
mitad log1p(mitad v);	Se agregó en el nivel de API 24.
half2 log1p(half2 v);	Se agregó en el nivel de API 24.
half3 log1p(half3 v);	Se agregó en el nivel de API 24.
half4 log1p(mitad4 v);	Se agregó en el nivel de API 24.

Muestra el logaritmo natural de (v + 1.f).

Consulta también native_log1p().

log2 : Logaritmo en base 2

float log2(float v);
float2 log2(float2 v);
float3 log2(float3 v);
float4 log2(float4 v);
mitad log2(mitad v);	Se agregó en el nivel de API 24.
half2 log2(half2 v);	Se agregó en el nivel de API 24.
half3 log2(mitad3 v);	Se agregó en el nivel de API 24.
mitad4 log2(mitad4 v);	Se agregó en el nivel de API 24.

Muestra el logaritmo en base 2.

Consulta también native_log2().

logb : Exponente de base dos

float logb(float v);
float2 logb(float2 v);
float3 logb(float3 v);
float4 logb(float4 v);
mitad logb(mitad v);	Se agregó en el nivel de API 24.
half2 logb(half2 v);	Se agregó en el nivel de API 24.
half3 logb(half3 v);	Se agregó en el nivel de API 24.
half4 logb(medio4 v);	Se agregó en el nivel de API 24.

Muestra el exponente base dos de un valor, donde la mantisa está entre 1.f (inclusive) y 2.f (exclusivo).

Por ejemplo, logb(8.5f) muestra 3.f.

Debido a la diferencia en mantisa, este número es uno menos que el que devuelve frexp().

ilogb() es similar, pero muestra un número entero.

mad : Multiplicar y sumar

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);
medio loco(mediano multiplicando1, medio multiplicando2, medio desplazamiento);	Se agregó en el nivel de API 24.
half2 mad(media2 multiplicando1, medio2 multiplicando2, medio2 de compensación);	Se agregó en el nivel de API 24.
half3 mad(medio3 multiplicando1, medio3 multiplicando2, medio3 de compensación);	Se agregó en el nivel de API 24.
half4 loco(media4 multiplicando1, medio4 multiplicando2, medio4 de compensación);	Se agregó en el nivel de API 24.

Multiplica y agrega Muestra (multiplicand1 * multiplicand2) + offset.

Esta función es similar a fma(). fma() conserva la precisión total del resultado multiplicado y se redondea solo después de la suma. mad() redondea después de la multiplicación y la suma. En el modo rs_fp_relaxed, mad() no puede hacer el redondeo después del multiplicación.

max : Máximo

char max(char a, char b);
char2 máx.(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 máx.(float4 a, float b);
float4 max(float4 a, float4 b);
media máx.(media a, media b);	Se agregó en el nivel de API 24.
medio2 máx.(medio2 a, medio b);	Se agregó en el nivel de API 24.
medio2 máx.(medio2 a, medio2 b);	Se agregó en el nivel de API 24.
medio3 máx.(medio3 a, medio b);	Se agregó en el nivel de API 24.
medio3 máx.(medio3 a, medio3 b);	Se agregó en el nivel de API 24.
medio4 máx.(medio4 a, medio b);	Se agregó en el nivel de API 24.
medio4 máx.(medio4 a, medio4 b);	Se agregó en el nivel de 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);
largo max(long a, long b);	Se agregó en el nivel de API 21.
long2 máx.(long2 a, long2 b);	Se agregó en el nivel de API 21.
long3 max(long3 a, long3 b);	Se agregó en el nivel de API 21.
long4 máx.(long4 a, long4 b);	Se agregó en el nivel de API 21.
short max(short a, short b);
short2 máx.(short2 a, short2 b);
short3 máx.(short3 a, short3 b);
short4 máx.(short4 a, short4 b);
uchar máx.(uchar a, uchar b);
uchar2 máx.(uchar2 a, uchar2 b);
uchar3 max(uchar3 a, uchar3 b);
uchar4 max(uchar4 a, uchar4 b);
uint max(uint a, uint b);
uint2 máx.(uint2 a, uint2 b);
uint3 máx.(uint3 a, uint3 b);
uint4 máx.(uint4 a, uint4 b);
ulong máx.(ulong a, ulong b);	Se agregó en el nivel de API 21.
ulong2 máx.(ulong2 a, ulong2 b);	Se agregó en el nivel de API 21.
ulong3 max(ulong3 a, ulong3 b);	Se agregó en el nivel de API 21.
ulong4 max(ulong4 a, ulong4 b);	Se agregó en el nivel de 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);

Muestra el valor máximo de dos argumentos.

min : Mínimo

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);
media min(media a, media b);	Se agregó en el nivel de API 24.
media2 min(media2 a, media b);	Se agregó en el nivel de API 24.
media2 min(media2 a, medio2 b);	Se agregó en el nivel de API 24.
media3 min(media3 a, media b);	Se agregó en el nivel de API 24.
media3 min(media3 a, medio3 b);	Se agregó en el nivel de API 24.
media4 min(media4 a, media b);	Se agregó en el nivel de API 24.
media4 min(media4 a, medio4 b);	Se agregó en el nivel de 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);	Se agregó en el nivel de API 21.
long2 min(long2 a, long2 b);	Se agregó en el nivel de API 21.
long3 min(long3 a, long3 b);	Se agregó en el nivel de API 21.
long4 min(long4 a, long4 b);	Se agregó en el nivel de API 21.
short min(short a, short b);
short2 min(short2 a, short2 b);
short3 min(short3 a, short3 b);
short4 min(short4 a, short4 b);
uchar min(uchar a, uchar b);
uchar2 min(uchar2 a, uchar2 b);
uchar3 min(uchar3 a, uchar3 b);
uchar4 min(uchar4 a, uchar4 b);
uint min(uint a, uint b);
uint2 min(uint2 a, uint2 b);
uint3 min(uint3 a, uint3 b);
uint4 min(uint4 a, uint4 b);
ulong min(ulong a, ulong b);	Se agregó en el nivel de API 21.
ulong2 min(ulong2 a, ulong2 b);	Se agregó en el nivel de API 21.
ulong3 min(ulong3 a, ulong3 b);	Se agregó en el nivel de API 21.
ulong4 min(ulong4 a, ulong4 b);	Se agregó en el nivel de 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);

Muestra el valor mínimo de dos argumentos.

mix : Combina dos valores

mezcla flotante(inicio de número de punto flotante, parada de número de punto flotante, fracción de punto flotante);
float2 mix(float2 start, float2 stop, float fracción);
float2 mix(float2 start, float2 stop, float2 fracción);
float3 mix(float3 start, float3 stop, float fracción);
float3 mix(float3 start, float3 stop, float3 fracción);
float4 mix(float4 start, float4 stop, float fracción);
float4 mix(float4 start, float4 stop, float4)
media mezcla(mitad inicio, media parada, media fracción);	Se agregó en el nivel de API 24.
mitad2 mix(mitad2 inicio, media 2 parada, mitad fracción);	Se agregó en el nivel de API 24.
mitad2 mix(mitad2 inicio, media 2 parada, mitad2 fracción);	Se agregó en el nivel de API 24.
mitad 3 mix(mitad 3 inicio, media 3 parada, mitad fracción);	Se agregó en el nivel de API 24.
mitad 3 mix(mitad 3 inicio, media 3 parada, media 3 fracción);	Se agregó en el nivel de API 24.
mitad 4 mix(mitad 4 inicio, media 4 parada, mitad fracción);	Se agregó en el nivel de API 24.
mitad 4 mix(mitad 4 inicio, media 4 parada, mitad 4 fracción);	Se agregó en el nivel de API 24.

Muestra inicio + ((parada - inicio) * fracción).

Esto puede ser útil para combinar dos valores. Por ejemplo, para crear un color nuevo que sea un 40% color1 y un 60% color2, usa mix(color1, color2, 0.6f).

modf : Componentes integrales y fraccionarios

modf float(float v, float* integral_part);
float2 modf(float2 v, float2* integral_part);
float3 modf(float3 v, float3* integral_part);
float4 modf(float4 v, float4* integral_part);
mitad modf(mitad v, mitad* parte_integral);	Se agregó en el nivel de API 24.
half2 modf(half2 v, half2* integral_part);	Se agregó en el nivel de API 24.
half3 modf(half3 v, half3* integral_part);	Se agregó en el nivel de API 24.
half4 modf(half4 v, half4* integral_part);	Se agregó en el nivel de API 24.

Parámetros

v	Valor de origen.
parte_integral	*parte_integral_se establecerá como la parte integral del número.

Devoluciones

Parte de punto flotante del valor.

Muestra los componentes integrales y fraccionarios de un número.

Ambos componentes tendrán el mismo signo que x. Por ejemplo, para una entrada de -3.72f, *integral_part se establecerá en -3.f y se mostrará .72f.

nan : No es un número

float nan(uint v);

Parámetros

v	No se usa.

Muestra un valor NaN (No es un número).

nan_half : No es un número

half nan_half();

Se agregó en el nivel de API 24.

Muestra un valor NaN de punto flotante de precisión media (no es un número).

native_acos : Coseno inverso aproximado

float native_acos(float v);	Se agregó en el nivel de API 21.
float2 native_acos(float2 v);	Se agregó en el nivel de API 21.
float3 native_acos(float3 v);	Se agregó en el nivel de API 21.
float4 native_acos(float4 v);	Se agregó en el nivel de API 21.
mitad native_acos(mitad v);	Se agregó en el nivel de API 24.
half2 native_acos(half2 v);	Se agregó en el nivel de API 24.
half3 native_acos(half3 v);	Se agregó en el nivel de API 24.
half4 native_acos(half4 v);	Se agregó en el nivel de API 24.

Muestra el coseno inverso aproximado, en radianes.

Esta función produce resultados indefinidos de valores de entrada menores que -1 o mayores que 1.

Consulta también acos().

native_acosh : Coseno hiperbólico inverso aproximado

float native_acosh(float v);	Se agregó en el nivel de API 21.
float2 native_acosh(float2 v);	Se agregó en el nivel de API 21.
float3 native_acosh(float3 v);	Se agregó en el nivel de API 21.
float4 native_acosh(float4 v);	Se agregó en el nivel de API 21.
medio nativo_acosh(mitad v);	Se agregó en el nivel de API 24.
half2 native_acosh(half2 v);	Se agregó en el nivel de API 24.
half3 native_acosh(half3 v);	Se agregó en el nivel de API 24.
half4 native_acosh(medio4 v);	Se agregó en el nivel de API 24.

Muestra el coseno hiperbólico inverso aproximado, en radianes.

Consulta también acosh().

native_acospi : Coseno inverso aproximado dividido por pi

float native_acospi(float v);	Se agregó en el nivel de API 21.
float2 native_acospi(float2 v);	Se agregó en el nivel de API 21.
float3 native_acospi(float3 v);	Se agregó en el nivel de API 21.
float4 native_acospi(float4 v);	Se agregó en el nivel de API 21.
mitad native_acospi(mitad v);	Se agregó en el nivel de API 24.
half2 native_acospi(mitad2 v);	Se agregó en el nivel de API 24.
half3 native_acospi(half3 v);	Se agregó en el nivel de API 24.
half4 native_acospi(half4 v);	Se agregó en el nivel de API 24.

Muestra el coseno inverso aproximado en radianes, dividido por pi.

Para obtener un coseno inverso medido en grados, usa acospi(a) * 180.f.

Esta función produce resultados indefinidos de valores de entrada menores que -1 o mayores que 1.

Consulta también acospi().

native_asin : Seno inverso aproximado

float native_asin(float v);	Se agregó en el nivel de API 21.
float2 native_asin(float2 v);	Se agregó en el nivel de API 21.
float3 native_asin(float3 v);	Se agregó en el nivel de API 21.
float4 native_asin(float4 v);	Se agregó en el nivel de API 21.
mitad native_assin(mitad v);	Se agregó en el nivel de API 24.
half2 native_assin(mitad2 v);	Se agregó en el nivel de API 24.
half3 native_assin(half3 v);	Se agregó en el nivel de API 24.
half4 native_assin(mitad4 v);	Se agregó en el nivel de API 24.

Muestra el seno inverso aproximado, en radianes.

Esta función produce resultados indefinidos de valores de entrada menores que -1 o mayores que 1.

Consulta también asin().

native_asinh : Seno hiperbólico inverso aproximado

float native_asinh(float v);	Se agregó en el nivel de API 21.
float2 native_asinh(float2 v);	Se agregó en el nivel de API 21.
float3 native_asinh(float3 v);	Se agregó en el nivel de API 21.
float4 native_asinh(float4 v);	Se agregó en el nivel de API 21.
mitad native_asinh(mitad v);	Se agregó en el nivel de API 24.
half2 native_asinh(mitad2 v);	Se agregó en el nivel de API 24.
half3 native_asinh(mitad3 v);	Se agregó en el nivel de API 24.
half4 native_asinh(mitad4 v);	Se agregó en el nivel de API 24.

Muestra el seno hiperbólico inverso aproximado, en radianes.

Consulta también asinh().

native_asinpi : Seno inverso aproximado dividido por pi

float native_asinpi(float v);	Se agregó en el nivel de API 21.
float2 native_asinpi(float2 v);	Se agregó en el nivel de API 21.
float3 native_asinpi(float3 v);	Se agregó en el nivel de API 21.
float4 native_asinpi(float4 v);	Se agregó en el nivel de API 21.
mitad native_asinpi(mitad v);	Se agregó en el nivel de API 24.
half2 native_asinpi(half2 v);	Se agregó en el nivel de API 24.
half3 native_asinpi(half3 v);	Se agregó en el nivel de API 24.
half4 native_asinpi(half4 v);	Se agregó en el nivel de API 24.

Muestra el seno inverso aproximado en radianes, dividido por pi.

Para obtener un seno inverso medido en grados, usa asinpi(a) * 180.f.

Esta función produce resultados indefinidos de valores de entrada menores que -1 o mayores que 1.

Consulta también asinpi().

native_atan : Tangente inversa aproximada

float native_atan(float v);	Se agregó en el nivel de API 21.
float2 native_atan(float2 v);	Se agregó en el nivel de API 21.
float3 native_atan(float3 v);	Se agregó en el nivel de API 21.
float4 native_atan(float4 v);	Se agregó en el nivel de API 21.
medio nativo_atan(mitad v);	Se agregó en el nivel de API 24.
half2 native_atan(mitad2 v);	Se agregó en el nivel de API 24.
half3 native_atan(mitad3 v);	Se agregó en el nivel de API 24.
half4 native_atan(mitad4 v);	Se agregó en el nivel de API 24.

Muestra la tangente inversa aproximada, en radianes.

Consulta también atan().

native_atan2 : Tangente inversa aproximada de una proporción

float native_atan2(numerador flotante, denominador de número de punto flotante);	Se agregó en el nivel de API 21.
float2 native_atan2(float2 numerador, float2 denominador);	Se agregó en el nivel de API 21.
float3 native_atan2(float3 numerador, float3 denominador);	Se agregó en el nivel de API 21.
float4 native_atan2(float4 numerador, float4 denominador);	Se agregó en el nivel de API 21.
mitad native_atan2(mitad numerador, medio denominador);	Se agregó en el nivel de API 24.
mitad2 native_atan2(numerador mitad2, denominador medio2);	Se agregó en el nivel de API 24.
half3 native_atan2(mitad3 numerador, medio3 denominador);	Se agregó en el nivel de API 24.
half4 native_atan2(mitad4 numerador, medio4 denominador);	Se agregó en el nivel de API 24.

Parámetros

numerador	Numerador.
denominador	Denominador Puede ser 0.

Muestra la tangente inversa aproximada de (numerator / denominator), en radianes.

Consulta también atan2().

native_atan2pi : Tangente inversa aproximada de una proporción, dividida por pi

float native_atan2pi(numerador flotante, denominador de número de punto flotante);	Se agregó en el nivel de API 21.
float2 native_atan2pi(numerador float2, denominador float2);	Se agregó en el nivel de API 21.
float3 native_atan2pi(numerador float3, denominador float3);	Se agregó en el nivel de API 21.
float4 native_atan2pi(numerador float4, denominador float4);	Se agregó en el nivel de API 21.
mitad native_atan2pi(mitad numerador, medio denominador);	Se agregó en el nivel de API 24.
half2 native_atan2pi(mitad2 numerador, medio2 denominador);	Se agregó en el nivel de API 24.
half3 native_atan2pi(mitad3 numerador, medio3 denominador);	Se agregó en el nivel de API 24.
half4 native_atan2pi(mitad 4 numerador, medio4 denominador);	Se agregó en el nivel de API 24.

Parámetros

numerador	Numerador.
denominador	Denominador Puede ser 0.

Muestra la tangente inversa aproximada de (numerator / denominator), en radianes, dividida por pi.

Para obtener una tangente inversa medida en grados, usa atan2pi(n, d) * 180.f.

Consulta también atan2pi().

native_atanh : Tangente hiperbólica inversa aproximada

float native_atanh(float v);	Se agregó en el nivel de API 21.
float2 native_atanh(float2 v);	Se agregó en el nivel de API 21.
float3 native_atanh(float3 v);	Se agregó en el nivel de API 21.
float4 native_atanh(float4 v);	Se agregó en el nivel de API 21.
mitad native_atanh(mitad v);	Se agregó en el nivel de API 24.
half2 native_atanh(mitad2 v);	Se agregó en el nivel de API 24.
half3 native_atanh(mitad3 v);	Se agregó en el nivel de API 24.
half4 native_atanh(mitad4 v);	Se agregó en el nivel de API 24.

Muestra la tangente hiperbólica inversa aproximada, en radianes.

Consulta también atanh().

native_atanpi : Tangente inversa aproximada dividida por el valor pi

float native_atanpi(float v);	Se agregó en el nivel de API 21.
float2 native_atanpi(float2 v);	Se agregó en el nivel de API 21.
float3 native_atanpi(float3 v);	Se agregó en el nivel de API 21.
float4 native_atanpi(float4 v);	Se agregó en el nivel de API 21.
mitad native_atanpi(mitad v);	Se agregó en el nivel de API 24.
half2 native_atanpi(mitad2 v);	Se agregó en el nivel de API 24.
half3 native_atanpi(half3 v);	Se agregó en el nivel de API 24.
half4 native_atanpi(mitad4 v);	Se agregó en el nivel de API 24.

Muestra la tangente inversa aproximada en radianes, dividida por pi.

Para obtener una tangente inversa medida en grados, usa atanpi(a) * 180.f.

Consulta también atanpi().

native_cbrt : raíz cúbica aproximada

float native_cbrt(float v);	Se agregó en el nivel de API 21.
float2 native_cbrt(float2 v);	Se agregó en el nivel de API 21.
float3 native_cbrt(float3 v);	Se agregó en el nivel de API 21.
float4 native_cbrt(float4 v);	Se agregó en el nivel de API 21.
mitad native_cbrt(mitad v);	Se agregó en el nivel de API 24.
half2 native_cbrt(mitad2 v);	Se agregó en el nivel de API 24.
half3 native_cbrt(mitad3 v);	Se agregó en el nivel de API 24.
half4 native_cbrt(mitad4 v);	Se agregó en el nivel de API 24.

Muestra la raíz cúbica aproximada.

Consulta también cbrt().

native_cos : Coseno aproximado

float native_cos(float v);	Se agregó en el nivel de API 21.
float2 native_cos(float2 v);	Se agregó en el nivel de API 21.
float3 native_cos(float3 v);	Se agregó en el nivel de API 21.
float4 native_cos(float4 v);	Se agregó en el nivel de API 21.
mitad native_cos(mitad v);	Se agregó en el nivel de API 24.
half2 native_cos(half2 v);	Se agregó en el nivel de API 24.
half3 native_cos(half3 v);	Se agregó en el nivel de API 24.
half4 native_cos(half4 v);	Se agregó en el nivel de API 24.

Muestra el coseno aproximado de un ángulo medido en radianes.

Consulta también cos().

native_cosh : Coseno hipobólico aproximado

float native_cosh(float v);	Se agregó en el nivel de API 21.
float2 native_cosh(float2 v);	Se agregó en el nivel de API 21.
float3 native_cosh(float3 v);	Se agregó en el nivel de API 21.
float4 native_cosh(float4 v);	Se agregó en el nivel de API 21.
mitad native_cosh(mitad v);	Se agregó en el nivel de API 24.
half2 native_cosh(mitad2 v);	Se agregó en el nivel de API 24.
half3 native_cosh(half3 v);	Se agregó en el nivel de API 24.
half4 native_cosh(medio4 v);	Se agregó en el nivel de API 24.

Muestra el coseno hipobólico aproximado.

Consulta también cosh().

native_cospi : Coseno aproximado de un número multiplicado por pi

float native_cospi(float v);	Se agregó en el nivel de API 21.
float2 native_cospi(float2 v);	Se agregó en el nivel de API 21.
float3 native_cospi(float3 v);	Se agregó en el nivel de API 21.
float4 native_cospi(float4 v);	Se agregó en el nivel de API 21.
mitad native_cospi(mitad v);	Se agregó en el nivel de API 24.
half2 native_cospi(half2 v);	Se agregó en el nivel de API 24.
half3 native_cospi(mitad3 v);	Se agregó en el nivel de API 24.
half4 native_cospi(mitad4 v);	Se agregó en el nivel de API 24.

Muestra el coseno aproximado de (v * pi), donde (v * pi) se mide en radianes.

Para obtener el coseno de un valor medido en grados, llama a cospi(v / 180.f).

Consulta también cospi().

native_divide : División aproximada

float native_divide(float left_vector, float right_vector);	Se agregó en el nivel de API 21.
float2 native_divide(float2 left_vector, float2 right_vector);	Se agregó en el nivel de API 21.
float3 native_divide(float3 left_vector, float3 right_vector);	Se agregó en el nivel de API 21.
float4 native_divide(float4 left_vector, float4 right_vector);	Se agregó en el nivel de API 21.
half native_divide(medio vector_izquierda, medio vector_derecho);	Se agregó en el nivel de API 24.
half2 native_divide(half2 vector_izquierda, half2 vector_derecho);	Se agregó en el nivel de API 24.
half3 native_divide(half3 vector_izquierda, half3 vector_derecho);	Se agregó en el nivel de API 24.
half4 native_divide(half4 vector_izquierda, half4 vector_derecho);	Se agregó en el nivel de API 24.

Calcula la división aproximada de dos valores.

native_exp : E aproximada aumentada a un número

float native_exp(float v);	Se agregó en el nivel de API 18.
float2 native_exp(float2 v);	Se agregó en el nivel de API 18.
float3 native_exp(float3 v);	Se agregó en el nivel de API 18.
float4 native_exp(float4 v);	Se agregó en el nivel de API 18.
half native_exp(mitad v);	Se agregó en el nivel de API 24.
half2 native_exp(half2 v);	Se agregó en el nivel de API 24.
half3 native_exp(half3 v);	Se agregó en el nivel de API 24.
half4 native_exp(half4 v);	Se agregó en el nivel de API 24.

Exp. aprox. rápida

Es válida para entradas de -86.f a 86.f. La precisión no es peor que la que se esperaría si se usaran valores de punto flotante de 16 bits.

Consulta también exp().

native_exp10 : Alrededor de 10 elevado a un número

float native_exp10(float v);	Se agregó en el nivel de API 18.
float2 native_exp10(float2 v);	Se agregó en el nivel de API 18.
float3 native_exp10(float3 v);	Se agregó en el nivel de API 18.
float4 native_exp10(float4 v);	Se agregó en el nivel de API 18.
half native_exp10(mitad v);	Se agregó en el nivel de API 24.
half2 native_exp10(half2 v);	Se agregó en el nivel de API 24.
half3 native_exp10(half3 v);	Se agregó en el nivel de API 24.
half4 native_exp10(half4 v);	Se agregó en el nivel de API 24.

Experiencia rápida aproximada 10

Es válido para entradas de -37.f a 37.f. La precisión no es peor que la que se esperaría si se usaran valores de punto flotante de 16 bits.

Consulta también exp10().

native_exp2 : Aproximadamente 2 se elevan a un número

float native_exp2(float v);	Se agregó en el nivel de API 18.
float2 native_exp2(float2 v);	Se agregó en el nivel de API 18.
float3 native_exp2(float3 v);	Se agregó en el nivel de API 18.
float4 native_exp2(float4 v);	Se agregó en el nivel de API 18.
half native_exp2(mitad v);	Se agregó en el nivel de API 24.
half2 native_exp2(half2 v);	Se agregó en el nivel de API 24.
half3 native_exp2(half3 v);	Se agregó en el nivel de API 24.
half4 native_exp2(half4 v);	Se agregó en el nivel de API 24.

Experiencia aproximada 2 rápida

Es válido para entradas de -125.f a 125.f. La precisión no es peor que la que se esperaría si se usaran valores de punto flotante de 16 bits.

Consulta también exp2().

native_expm1 : E aproximada aumentada a un número menos uno

float native_expm1(float v);	Se agregó en el nivel de API 21.
float2 native_expm1(float2 v);	Se agregó en el nivel de API 21.
float3 native_expm1(float3 v);	Se agregó en el nivel de API 21.
float4 native_expm1(float4 v);	Se agregó en el nivel de API 21.
half native_expm1(mitad v);	Se agregó en el nivel de API 24.
half2 native_expm1(half2 v);	Se agregó en el nivel de API 24.
half3 native_expm1(half3 v);	Se agregó en el nivel de API 24.
half4 native_expm1(half4 v);	Se agregó en el nivel de API 24.

Muestra el valor aproximado (e ^ v) - 1.

Consulta también expm1().

native_hypot : Hipotenusa aproximada

float native_hypot(float a, float b);	Se agregó en el nivel de API 21.
float2 native_hypot(float2 a, float2 b);	Se agregó en el nivel de API 21.
float3 native_hypot(float3 a, float3 b);	Se agregó en el nivel de API 21.
float4 native_hypot(float4 a, float4 b);	Se agregó en el nivel de API 21.
half native_hypot(media a, media b);	Se agregó en el nivel de API 24.
half2 native_hypot(mitad2 a, medio2 b);	Se agregó en el nivel de API 24.
half3 native_hypot(mitad3 a, medio3 b);	Se agregó en el nivel de API 24.
half4 native_hypot(mitad4 a, medio4 b);	Se agregó en el nivel de API 24.

Muestra el native_sqrt(a * a + b * b) aproximado

Consulta también hypot().

native_log : Logaritmo natural aproximado

float native_log(float v);	Se agregó en el nivel de API 18.
float2 native_log(float2 v);	Se agregó en el nivel de API 18.
float3 native_log(float3 v);	Se agregó en el nivel de API 18.
float4 native_log(float4 v);	Se agregó en el nivel de API 18.
half native_log(mitad v);	Se agregó en el nivel de API 24.
half2 native_log(half2 v);	Se agregó en el nivel de API 24.
half3 native_log(half3 v);	Se agregó en el nivel de API 24.
half4 native_log(mitad4 v);	Se agregó en el nivel de API 24.

Registro aproximado rápido.

No es exacta para valores muy cercanos a cero.

Consulta también log().

native_log10 : Logaritmo en base 10 aproximado

float native_log10(float v);	Se agregó en el nivel de API 18.
float2 native_log10(float2 v);	Se agregó en el nivel de API 18.
float3 native_log10(float3 v);	Se agregó en el nivel de API 18.
float4 native_log10(float4 v);	Se agregó en el nivel de API 18.
mitad native_log10(mitad v);	Se agregó en el nivel de API 24.
half2 native_log10(mitad2 v);	Se agregó en el nivel de API 24.
half3 native_log10(mitad3 v);	Se agregó en el nivel de API 24.
half4 native_log10(mitad4 v);	Se agregó en el nivel de API 24.

Log10 aproximado rápido.

No es exacta para valores muy cercanos a cero.

Consulta también log10().

native_log1p : Logaritmo natural aproximado de un valor más 1

float native_log1p(float v);	Se agregó en el nivel de API 21.
float2 native_log1p(float2 v);	Se agregó en el nivel de API 21.
float3 native_log1p(float3 v);	Se agregó en el nivel de API 21.
float4 native_log1p(float4 v);	Se agregó en el nivel de API 21.
half native_log1p(mitad v);	Se agregó en el nivel de API 24.
half2 native_log1p(mitad2 v);	Se agregó en el nivel de API 24.
half3 native_log1p(half3 v);	Se agregó en el nivel de API 24.
half4 native_log1p(mitad4 v);	Se agregó en el nivel de API 24.

Muestra el logaritmo natural aproximado de (v + 1.0f).

Consulta también log1p().

native_log2 : Logaritmo en base 2 aproximado

float native_log2(float v);	Se agregó en el nivel de API 18.
float2 native_log2(float2 v);	Se agregó en el nivel de API 18.
float3 native_log2(float3 v);	Se agregó en el nivel de API 18.
float4 native_log2(float4 v);	Se agregó en el nivel de API 18.
mitad native_log2(mitad v);	Se agregó en el nivel de API 24.
half2 native_log2(mitad2 v);	Se agregó en el nivel de API 24.
half3 native_log2(mitad3 v);	Se agregó en el nivel de API 24.
half4 native_log2(mitad4 v);	Se agregó en el nivel de API 24.

Log2 aproximado rápido.

No es exacta para valores muy cercanos a cero.

Consulta también log2().

native_powr : Base positiva aproximada elevada a un exponente

float native_powr(base flotante, exponente de punto flotante);	Se agregó en el nivel de API 18.
float2 native_powr(float2 base, exponente float2);	Se agregó en el nivel de API 18.
float3 native_powr(float3 base, exponente float3);	Se agregó en el nivel de API 18.
float4 native_powr(float4 base, exponente float4);	Se agregó en el nivel de API 18.
half native_powr(mitad base, medio exponente);	Se agregó en el nivel de API 24.
half2 native_powr(mitad2 base, exponente half2);	Se agregó en el nivel de API 24.
half3 native_powr(mitad3 base, exponente half3);	Se agregó en el nivel de API 24.
half4 native_powr(mitad4 base, exponente half4);	Se agregó en el nivel de API 24.

Parámetros

base	Debe estar comprendido entre 0.f y 256.f. La función no es exacta para valores muy cercanos a cero.
exponente	Debe ser un valor entre -15.f y 15.f.

Valor aproximado rápido (exponente de base ^).

Consulta también powr().

native_recip : Recíproco aproximado

float native_recip(float v);	Se agregó en el nivel de API 21.
float2 native_recip(float2 v);	Se agregó en el nivel de API 21.
float3 native_recip(float3 v);	Se agregó en el nivel de API 21.
float4 native_recip(float4 v);	Se agregó en el nivel de API 21.
half native_recip(mitad v);	Se agregó en el nivel de API 24.
half2 native_recip(half2 v);	Se agregó en el nivel de API 24.
half3 native_recip(half3 v);	Se agregó en el nivel de API 24.
half4 native_recip(half4 v);	Se agregó en el nivel de API 24.

Muestra el recíproco aproximado aproximado de un valor.

Consulta también half_recip().

native_rootn : raíz enésima aproximada

float native_rootn(float v, int n);	Se agregó en el nivel de API 21.
float2 native_rootn(float2 v, int2 n);	Se agregó en el nivel de API 21.
float3 native_rootn(float3 v, int3 n);	Se agregó en el nivel de API 21.
float4 native_rootn(float4 v, int4 n);	Se agregó en el nivel de API 21.
half native_rootn(mitad v, int n);	Se agregó en el nivel de API 24.
half2 native_rootn(half2 v, int2 n);	Se agregó en el nivel de API 24.
half3 native_rootn(half3 v, int3 n);	Se agregó en el nivel de API 24.
half4 native_rootn(half4 v, int4 n);	Se agregó en el nivel de API 24.

Calcula la raíz enésima aproximada de un valor.

Consulta también rootn().

native_rsqrt : Recíproco aproximado de una raíz cuadrada

float native_rsqrt(float v);	Se agregó en el nivel de API 21.
float2 native_rsqrt(float2 v);	Se agregó en el nivel de API 21.
float3 native_rsqrt(float3 v);	Se agregó en el nivel de API 21.
float4 native_rsqrt(float4 v);	Se agregó en el nivel de API 21.
half native_rsqrt(mitad v);	Se agregó en el nivel de API 24.
half2 native_rsqrt(half2 v);	Se agregó en el nivel de API 24.
half3 native_rsqrt(half3 v);	Se agregó en el nivel de API 24.
half4 native_rsqrt(half4 v);	Se agregó en el nivel de API 24.

El resultado es aproximado (1 / sqrt(v)).

Consulta también rsqrt(), half_rsqrt().

native_sin : Seno aproximado

float native_sin(float v);	Se agregó en el nivel de API 21.
float2 native_sin(float2 v);	Se agregó en el nivel de API 21.
float3 native_sin(float3 v);	Se agregó en el nivel de API 21.
float4 native_sin(float4 v);	Se agregó en el nivel de API 21.
mitad native_sen(mitad v);	Se agregó en el nivel de API 24.
half2 native_sen(half2 v);	Se agregó en el nivel de API 24.
half3 native_sen(half3 v);	Se agregó en el nivel de API 24.
half4 native_sen(half4 v);	Se agregó en el nivel de API 24.

Muestra el seno aproximado de un ángulo medido en radianes.

Consulta también sin().

native_sincos : Seno y coseno aproximados

float native_sincos(float v, float* cos);	Se agregó en el nivel de API 21.
float2 native_sincos(float2 v, float2* cos);	Se agregó en el nivel de API 21.
float3 native_sincos(float3 v, float3* cos);	Se agregó en el nivel de API 21.
float4 native_sincos(float4 v, float4* cos);	Se agregó en el nivel de API 21.
half native_sincos(mitad v, media* cos);	Se agregó en el nivel de API 24.
half2 native_sincos(half2 v, half2* cos);	Se agregó en el nivel de API 24.
half3 native_sincos(half3 v, half3* cos);	Se agregó en el nivel de API 24.
half4 native_sincos(half4 v, half4* cos);	Se agregó en el nivel de API 24.

Parámetros

v	Valor entrante en radianes.
cos	*cos se establecerá en el valor coseno.

Devoluciones

Seno.

Muestra el seno y el coseno aproximados de un valor.

Consulta también sincos().

native_sinh : Seno hiperbólico aproximado

float native_sinh(float v);	Se agregó en el nivel de API 21.
float2 native_sinh(float2 v);	Se agregó en el nivel de API 21.
float3 native_sinh(float3 v);	Se agregó en el nivel de API 21.
float4 native_sinh(float4 v);	Se agregó en el nivel de API 21.
mitad native_sinh(mitad v);	Se agregó en el nivel de API 24.
half2 native_sinh(mitad2 v);	Se agregó en el nivel de API 24.
half3 native_sinh(half3 v);	Se agregó en el nivel de API 24.
half4 native_sinh(half4 v);	Se agregó en el nivel de API 24.

Muestra el seno hiperbólico aproximado de un valor especificado en radianes.

Consulta también sinh().

native_sinpi : Seno aproximado de un número multiplicado por pi

float native_sinpi(float v);	Se agregó en el nivel de API 21.
float2 native_sinpi(float2 v);	Se agregó en el nivel de API 21.
float3 native_sinpi(float3 v);	Se agregó en el nivel de API 21.
float4 native_sinpi(float4 v);	Se agregó en el nivel de API 21.
mitad native_sinpi(mitad v);	Se agregó en el nivel de API 24.
half2 native_sinpi(half2 v);	Se agregó en el nivel de API 24.
half3 native_sinpi(half3 v);	Se agregó en el nivel de API 24.
half4 native_sinpi(half4 v);	Se agregó en el nivel de API 24.

Muestra el seno aproximado de (v * pi), donde (v * pi) se mide en radianes.

Para obtener el seno de un valor medido en grados, llama a sinpi(v / 180.f).

Consulta también sinpi().

native_sqrt : Raíz cuadrada aproximada

float native_sqrt(float v);	Se agregó en el nivel de API 21.
float2 native_sqrt(float2 v);	Se agregó en el nivel de API 21.
float3 native_sqrt(float3 v);	Se agregó en el nivel de API 21.
float4 native_sqrt(float4 v);	Se agregó en el nivel de API 21.
half native_sqrt(mitad v);	Se agregó en el nivel de API 24.
half2 native_sqrt(half2 v);	Se agregó en el nivel de API 24.
half3 native_sqrt(half3 v);	Se agregó en el nivel de API 24.
half4 native_sqrt(half4 v);	Se agregó en el nivel de API 24.

Muestra el cuadrado(v) aproximado.

Consulta también sqrt(), half_sqrt().

native_tan : Tangente aproximada

float native_tan(float v);	Se agregó en el nivel de API 21.
float2 native_tan(float2 v);	Se agregó en el nivel de API 21.
float3 native_tan(float3 v);	Se agregó en el nivel de API 21.
float4 native_tan(float4 v);	Se agregó en el nivel de API 21.
mitad native_tan(mitad v);	Se agregó en el nivel de API 24.
half2 native_tan(mitad2 v);	Se agregó en el nivel de API 24.
half3 native_tan(mitad3 v);	Se agregó en el nivel de API 24.
half4 native_tan(mitad4 v);	Se agregó en el nivel de API 24.

Muestra la tangente aproximada de un ángulo medida en radianes.

native_tanh : Tangente hiperbólica aproximada

float native_tanh(float v);	Se agregó en el nivel de API 21.
float2 native_tanh(float2 v);	Se agregó en el nivel de API 21.
float3 native_tanh(float3 v);	Se agregó en el nivel de API 21.
float4 native_tanh(float4 v);	Se agregó en el nivel de API 21.
mitad native_tanh(mitad v);	Se agregó en el nivel de API 24.
half2 native_tanh(mitad2 v);	Se agregó en el nivel de API 24.
half3 native_tanh(mitad3 v);	Se agregó en el nivel de API 24.
half4 native_tanh(mitad4 v);	Se agregó en el nivel de API 24.

Muestra la tangente hiperbólica aproximada de un valor.

Consulta también tanh().

native_tanpi : Tangente aproximada de un número multiplicado por pi

float native_tanpi(float v);	Se agregó en el nivel de API 21.
float2 native_tanpi(float2 v);	Se agregó en el nivel de API 21.
float3 native_tanpi(float3 v);	Se agregó en el nivel de API 21.
float4 native_tanpi(float4 v);	Se agregó en el nivel de API 21.
mitad native_tanpi(mitad v);	Se agregó en el nivel de API 24.
half2 native_tanpi(mitad2 v);	Se agregó en el nivel de API 24.
half3 native_tanpi(mitad3 v);	Se agregó en el nivel de API 24.
half4 native_tanpi(mitad4 v);	Se agregó en el nivel de API 24.

Muestra la tangente aproximada de (v * pi), donde (v * pi) se mide en radianes.

Para obtener la tangente de un valor medido en grados, llama a tanpi(v / 180.f).

Consulta también tanpi().

nextafter : siguiente número de punto flotante

float nextafter(float v, float target);
float2 nextafter(float2 v, float2 target);
float3 nextafter(float3 v, float3 target);
float4 nextafter(float4 v, float4 target);
mitad siguiente después(objetivo mitad v, mitad);	Se agregó en el nivel de API 24.
half2 nextafter(media2 vs, half2 objetivo);	Se agregó en el nivel de API 24.
mitad3 nextafter(mitad 3 v, objetivo medio3);	Se agregó en el nivel de API 24.
mitad 4 nextafter(media 4 vs, medio4 objetivo);	Se agregó en el nivel de API 24.

Muestra el siguiente número de punto flotante representable de la v hacia el objetivo.

En el modo rs_fp_relaxed, es posible que un valor de entrada desnormalizado no genere el siguiente valor desnormalizado, ya que la compatibilidad con valores desnormalizados es opcional en el modo relajado.

pow : La base se eleva a un exponente

float pow(base flotante, exponente flotante);
float2 pow(float2 base, exponente float2);
float3 pow(float3 base, exponente float3);
float4 pow(float4 base, exponente float4);
medio pow(mitad base, medio exponente);	Se agregó en el nivel de API 24.
half2 pow(base half2, exponente half2);	Se agregó en el nivel de API 24.
half3 pow(base half3, exponente half3);	Se agregó en el nivel de API 24.
mitad4 pow(mitad 4 base, exponente medio4);	Se agregó en el nivel de API 24.

Muestra la base elevada al exponente de potencia, es decir, el exponente base ^.

pown() y powr() son similares. pown() toma un exponente de número entero. powr() supone que la base no es negativa.

pown : la base se eleva a un exponente de número entero

float pown(base flotante, exponente int);
float2 pown(float2 base, exponente int2);
float3 pown(float3 base, exponente int3);
float4 pown(float4 base, exponente int4);
medio pown(mitad base, exponente int);	Se agregó en el nivel de API 24.
half2 pown(base half2, exponente int2);	Se agregó en el nivel de API 24.
half3 pown(base half3, exponente int3);	Se agregó en el nivel de API 24.
half4 pown(base half4, exponente int4);	Se agregó en el nivel de API 24.

Muestra la base elevada al exponente de potencia, es decir, el exponente base ^.

pow() y powr() son similares. Ambos toman un exponente de número de punto flotante. powr() también supone que la base no es negativa.

powr : base positiva elevada a un exponente

float powr(base flotante, exponente de punto flotante);
float2 powr(float2 base, exponente float2);
float3 powr(float3 base, exponente float3);
float4 powr(float4 base, exponente float4);
mitad potencia(mitad base, medio exponente);	Se agregó en el nivel de API 24.
half2 powr(mitad2 base, exponente half2);	Se agregó en el nivel de API 24.
half3 powr(mitad3 base, exponente half3);	Se agregó en el nivel de API 24.
mitad4 powr(mitad4 base, exponente medio4);	Se agregó en el nivel de API 24.

Muestra la base elevada al exponente de potencia, es decir, el exponente base ^. la base debe ser >= 0.

pow() y pown() son similares. Ambos no hacen suposiciones sobre la base. pow() toma un exponente de punto flotante, mientras que pown() toma un número entero.

Consulta también native_powr().

radianes : Convierte grados en radianes.

radianes flotantes(float v);
float2 radianes(float2 v);
float3 radianes(float3 v);
float4 radianes(float4 v);
medio radianes(medio v);	Se agregó en el nivel de API 24.
medio2 radianes(medio2 v);	Se agregó en el nivel de API 24.
medio3 radianes(medio3 v);	Se agregó en el nivel de API 24.
medio4 radianes(medio4 v);	Se agregó en el nivel de API 24.

Convierte grados en radianes.

remainder : El resto de una división

float resto(numerador flotante, denominador de número de punto flotante);
float2rest(float2 numerator, float2 denominador);
float3rest(float3 numerador, float3 denominador);
float4rest(float4 numerador, float4 denominador);
medio resto(medio numerador, medio denominador);	Se agregó en el nivel de API 24.
mitad2restante(mitad2 numerador, mitad2 denominador);	Se agregó en el nivel de API 24.
medio3 restante(mitad3 numerador, mitad3 denominador);	Se agregó en el nivel de API 24.
medio4 restante(mitad4 numerador, medio4 denominador);	Se agregó en el nivel de API 24.

Muestra el resto de (numerador / denominador), donde el cociente se redondea hacia el número entero más cercano.

La función fmod() es similar, pero se redondea hacia el número entero más cercano. Por ejemplo, fmod(-3.8f, 2.f) muestra -1.8f (-3.8f - -1.f * 2.f), mientras que remainder(-3.8f, 2.f) muestra 0.2f (-3.8f - -2.f * 2.f).

Reemquo : Resto y cociente de una división

remquo flotante(numerador flotante, denominador de número de punto flotante, cociente int*);
float2 remquo(float2 numerador, float2 denominador, int2* cotient);
float3 remquo(float3, denominador float3, cotient int3*);
float4 remquo(float4 numerator, float4 denominador, int4* cotient);
mitad remquo(mitad numerador, medio denominador, cociente int*);	Se agregó en el nivel de API 24.
half2 remquo(mitad2 numerador, half2 denominador, cociente int2*);	Se agregó en el nivel de API 24.
half3 remquo(mitad3 numerador, half3 denominador, cociente int3*);	Se agregó en el nivel de API 24.
half4 remquo(mitad4 numerador, medio4 denominador, cociente int4*);	Se agregó en el nivel de API 24.

Parámetros

numerador	Numerador.
denominador	Denominador
cociente	*El cociente se establecerá en el cociente de número entero.

Devoluciones

El resto, preciso solo para los tres bits bajos.

Muestra el cociente y el resto de (numerador / denominador).

Solo se garantiza que el signo y los tres bits más bajos del cociente sean precisos.

Esta función es útil para implementar funciones periódicas. Los tres bits bajos del cociente le dan al cuadrante y al resto la distancia dentro del cuadrante. Por ejemplo, una implementación de sen(x) podría llamar a remquo(x, PI / 2.f, &quadrant) para reducir un valor muy grande de x a un valor dentro de un rango limitado.

Ejemplo: remquo(-23.5f, 8.f, &quot) establece los tres bits más bajos de quot en 3 y el signo negativo. Muestra 0.5f.

rint : Redondear al par

float rint(float v);
float2 rint(float2 v);
float3 rint(float3 v);
float4 rint(float4 v);
mitad rint(mitad v);	Se agregó en el nivel de API 24.
half2 rint(half2 v);	Se agregó en el nivel de API 24.
half3 rint(half3 v);	Se agregó en el nivel de API 24.
half4 rint(half4 v);	Se agregó en el nivel de API 24.

Redondea al valor integral más cercano.

rint() redondea los valores medios a pares. Por ejemplo, rint(0.5f) muestra 0.f y rint(1.5f) muestra 2.f. De manera similar, rint(-0.5f) muestra -0.f y rint(-1.5f) muestra -2.f.

round() es similar, pero se redondea desde cero. trunc() trunca la fracción decimal.

rootn : raíz enésima

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(mitad v, int n);	Se agregó en el nivel de API 24.
half2 rootn(half2 v, int2 n);	Se agregó en el nivel de API 24.
half3 rootn(half3 v, int3 n);	Se agregó en el nivel de API 24.
half4 rootn(half4 v, int4 n);	Se agregó en el nivel de API 24.

Calcula la raíz enésima de un valor.

Consulta también native_rootn().

round : redondear desde cero

float round(float v);
float2 round(float2 v);
float3 round(float3 v);
float4 round(float4 v);
media ronda(media v);	Se agregó en el nivel de API 24.
mitad2 redonda(mitad2 v);	Se agregó en el nivel de API 24.
mitad3 redonda(mitad3 v);	Se agregó en el nivel de API 24.
mitad 4 redonda(media 4 v);	Se agregó en el nivel de API 24.

Redondea al valor integral más cercano.

round() redondea los valores medios en dirección contraria a cero. Por ejemplo, round(0.5f) muestra 1.f y round(1.5f) muestra 2.f. De manera similar, round(-0.5f) muestra -1.f y round(-1.5f) muestra -2.f.

rint() es similar, pero redondea los valores medios hacia par. trunc() trunca la fracción decimal.

rsClamp : Restringe un valor a un rango

char rsClamp(cantidad de caracteres, carácter bajo, caracteres altos);
int rsClamp(cantidad int, int baja, int alta);
rsClamp corto(poco corto, corto bajo, corto alto);
uchar rsClamp(cantidad uchar, uchar baja, uchar alta);
uint rsClamp(uint cantidad, uint baja, uint alta);
ushort rsClamp(ushort cantidad, ushort baja, ushort alta);

Parámetros

importe	Valor que se debe restringir.
bajo	Límite inferior.
alto	Límite superior.

Obsoleto. En su lugar, usa clamp().

Fija un valor entre bajo y alto.

rsFrac : Muestra la parte fraccionaria de un número de punto flotante

float rsFrac(float v);

Obsoleto. En su lugar, usa fract().

Devuelve la parte fraccionaria de un número de punto flotante

rsRand : Número pseudoaleatorio

rsRand flotante(valor_máx_flotante);
rsRand flotante(valor_mín_flotante, valor_máx_flotante);
int rsRand(int max_value);
int rsRand(valor_mín. int, valor_máx_int);

Muestra un valor aleatorio entre 0 (o min_value) y max_malue.

rsqrt : Recíproco de una raíz cuadrada

float rsqrt(float v);
float2 rsqrt(float2 v);
float3 rsqrt(float3 v);
float4 rsqrt(float4 v);
mitad rsqrt(mitad v);	Se agregó en el nivel de API 24.
half2 rsqrt(half2 v);	Se agregó en el nivel de API 24.
half3 rsqrt(half3 v);	Se agregó en el nivel de API 24.
half4 rsqrt(half4 v);	Se agregó en el nivel de API 24.

Muestra (1 / sqrt(v)).

Consulta también half_rsqrt(), native_rsqrt().

sign : Signo de un valor

float sign(float v);
signo float2(float2 v);
signo float3(float3v);
signo float4(float4 v);
signo medio(mitad v);	Se agregó en el nivel de API 24.
signo mitad2(medio2 v);	Se agregó en el nivel de API 24.
signo mitad3(mitad3 v);	Se agregó en el nivel de API 24.
signo mitad4(mitad4 v);	Se agregó en el nivel de API 24.

Muestra el signo de un valor.

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

sen : Seno

float sin(float v);
float2 sin(float2 v);
float3 sin(float3 v);
float4 sin(float4 v);
mitad sen(mitad v);	Se agregó en el nivel de API 24.
half2 sin(half2 v);	Se agregó en el nivel de API 24.
half3 sen(half3 v);	Se agregó en el nivel de API 24.
half4 sen(half4 v);	Se agregó en el nivel de API 24.

Muestra el seno de un ángulo medido en radianes.

Consulta también native_sin().

sincos : Seno y coseno

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(medio v, medio* cos);	Se agregó en el nivel de API 24.
half2 sincos(half2 v, half2* cos);	Se agregó en el nivel de API 24.
half3 sincos(half3 v, half3* cos);	Se agregó en el nivel de API 24.
half4 sincos(half4 v, half4* cos);	Se agregó en el nivel de API 24.

Parámetros

v	Valor entrante en radianes.
cos	*cos se establecerá en el valor coseno.

Devoluciones

Seno de v.

Muestra el seno y el coseno de un valor.

Consulta también native_sincos().

sinh : Seno hiperbólico

float senh(float v);
float2 sinh(float2 v);
float3 sinh(float3 v);
float4 sinh(float4 v);
medio sinh(medio v);	Se agregó en el nivel de API 24.
half2 sinh(half2 v);	Se agregó en el nivel de API 24.
half3 sinh(half3 v);	Se agregó en el nivel de API 24.
medio4 sinh(medio4 v);	Se agregó en el nivel de API 24.

Muestra el seno hiperbólico de v, donde v se mide en radianes.

Consulta también native_sinh().

sinpi : Seno de un número multiplicado por pi

float sinpi(float v);
float2 sinpi(float2 v);
float3 sinpi(float3 v);
float4 sinpi(float4 v);
mitad sinpi(mitad v);	Se agregó en el nivel de API 24.
half2 sinpi(half2 v);	Se agregó en el nivel de API 24.
half3 sinpi(half3 v);	Se agregó en el nivel de API 24.
half4 sinpi(half4 v);	Se agregó en el nivel de API 24.

Muestra el seno de (v * pi), donde (v * pi) se mide en radianes.

Para obtener el seno de un valor medido en grados, llama a sinpi(v / 180.f).

Consulta también native_sinpi().

sqrt : Raíz cuadrada

float sqrt(float v);
float2 sqrt(float2 v);
float3 sqrt(float3 v);
float4 sqrt(float4 v);
medio cuadrado(mitad v);	Se agregó en el nivel de API 24.
half2 cuadrado(mitad2 v);	Se agregó en el nivel de API 24.
medio3 cuadrado(mitad3 v);	Se agregó en el nivel de API 24.
mitad4 cuadrada(mitad 4 v);	Se agregó en el nivel de API 24.

Muestra la raíz cuadrada de un valor.

Consulta también half_sqrt(), native_sqrt().

step : 0 si es menor que un valor, 1 de lo contrario

float step(float perimetral, float v);
float2 step(float perimetral, float2 v);	Se agregó en el nivel de API 21.
float2 paso(float2 borde, float v);
float2 paso(float2 borde, float2 v);
float3 step(float perimetral, float3 v);	Se agregó en el nivel de API 21.
float3 step(float3 Edge, float v);
float3(arista float3, float3 v);
float4 paso(borde flotante, float4 v);	Se agregó en el nivel de API 21.
float4(arista float4, float v);
float4 paso(float4 perimetral, float4 v);
medio paso(medio borde, mitad v);	Se agregó en el nivel de API 24.
medio2 paso(medio borde, medio2 v);	Se agregó en el nivel de API 24.
medio2 paso(medio2 borde, mitad v);	Se agregó en el nivel de API 24.
medio2 paso(medio2 borde, medio2 v);	Se agregó en el nivel de API 24.
medio3 paso(medio borde, medio3 v);	Se agregó en el nivel de API 24.
medio3 paso(medio3 borde, mitad v);	Se agregó en el nivel de API 24.
medio3 paso(mitad3 borde, medio3 v);	Se agregó en el nivel de API 24.
medio4 paso(medio borde, medio4 v);	Se agregó en el nivel de API 24.
medio4 paso(medio4 borde, media v);	Se agregó en el nivel de API 24.
medio4 paso(medio4 borde, medio4 v);	Se agregó en el nivel de API 24.

Muestra 0.f si v < Edge, 1.f de lo contrario.

Esto puede ser útil para crear cálculos condicionales sin usar bucles ni instrucciones de ramificación. Por ejemplo, en lugar de calcular (a[i] < b[i]) ? 0.f : atan2(a[i], b[i]) para los elementos correspondientes de un vector, puedes usar step(a, b) * atan2(a, b).

tan : Tangente

float tan(float v);
float2 tan(float2 v);
float3 tan(float3 v);
float4 tan(float4 v);
medio tan(medio v);	Se agregó en el nivel de API 24.
mitad2 tan(medio2 v);	Se agregó en el nivel de API 24.
mitad3 tan(mitad3 v);	Se agregó en el nivel de API 24.
medio4 tan(medio4 v);	Se agregó en el nivel de API 24.

Muestra la tangente de un ángulo medida en radianes.

Consulta también native_tan().

tanh : tangente hiperbólica

float tanh(float v);
float2 tanh(float2 v);
float3 tanh(float3 v);
float4 tanh(float4 v);
mitad tanh(mitad v);	Se agregó en el nivel de API 24.
half2 tanh(half2 v);	Se agregó en el nivel de API 24.
half3 tanh(half3 v);	Se agregó en el nivel de API 24.
half4 tanh(half4 v);	Se agregó en el nivel de API 24.

Muestra la tangente hiperbólica de un valor.

Consulta también native_tanh().

tanpi : Tangente de un número multiplicado por pi

float tanpi(float v);
float2 tanpi(float2 v);
float3 tanpi(float3 v);
float4 tanpi(float4 v);
mitad tanpi(media v);	Se agregó en el nivel de API 24.
half2 tanpi(half2 v);	Se agregó en el nivel de API 24.
half3 tanpi(half3 v);	Se agregó en el nivel de API 24.
half4 tanpi(half4 v);	Se agregó en el nivel de API 24.

Muestra la tangente de (v * pi), en la que (v * pi) se mide en radianes.

Para obtener la tangente de un valor medido en grados, llama a tanpi(v / 180.f).

Consulta también native_tanpi().

tgamma : función gamma

float tgamma(float v);
float2 tgamma(float2 v);
float3 tgamma(float3 v);
float4 tgamma(float4 v);
mitad tgamma(mitad v);	Se agregó en el nivel de API 24.
half2 tgamma(half2 v);	Se agregó en el nivel de API 24.
half3 tgamma(half3 v);	Se agregó en el nivel de API 24.
half4 tgamma(half4 v);	Se agregó en el nivel de API 24.

Muestra la función gamma de un valor.

Consulta también lgamma().

trunc : trunca un punto flotante

float trunc(float v);
float2 trunc(float2 v);
float3 trunc(float3 v);
float4 trunc(float4 v);
mitad trunc(mitad v);	Se agregó en el nivel de API 24.
mitad2 trunc(mitad2 v);	Se agregó en el nivel de API 24.
half3 trunc(half3 v);	Se agregó en el nivel de API 24.
mitad4 trunc(mitad4 v);	Se agregó en el nivel de API 24.

Redondea a integrales usando el truncamiento.

Por ejemplo, trunc(1.7f) muestra 1.f y trunc(-1.7f) muestra -1.f.

Consulta rint() y round() para ver otras opciones de redondeo.