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. |
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. |
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. |
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. |
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. |
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. |
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. |
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. |
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. |
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, ")
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. |