Constantes e funções matemáticas do RenderScript

Visão geral

As funções matemáticas abaixo podem ser aplicadas a escalares e vetores. Quando aplicado a vetores, o valor retornado é um vetor da função aplicada a cada entrada da entrada.

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

Consulte Funções matemáticas de vetores para funções como distance() e length() que interpretam a entrada como um único vetor em um espaço n-dimensional.

A precisão das operações matemáticas em flutuações de 32 bits é afetada pelos pragmas rs_fp_relaxed e rs_fp_full. Em rs_fp_relaxed, os valores subnormais podem ser reduzidos a zero e o arredondamento pode ser feito em direção a zero. Em comparação, rs_fp_full requer o processamento correto de valores subnormais, ou seja, menores que 1,17549435e-38f. O rs_fp_rull também requer arredondamento para o mais próximo com vínculos a par.

Diferentes compensações de precisão/velocidade podem ser feitas usando variantes das funções matemáticas comuns. Funções com um nome que começa com

  • native_: pode ter implementações de hardware personalizadas com precisão mais fraca. Além disso, valores subnormais podem ser desviados para zero, arredondamentos para zero podem ser usados e a entrada de NaN e infinito pode não ser tratada corretamente.
  • half_: pode realizar cálculos internos usando flutuações de 16 bits. Além disso, valores subnormais podem ser desviados para zero e arredondamentos até zero podem ser usados.

Resumo

Constantes
M_1_PI (link em inglês) 1 / pi, como um ponto flutuante de 32 bits
M_2_PI (link em inglês) 2 / pi, como um flutuante de 32 bits
M_2_RAIZPI 2 / sqrt(pi), como um flutuante de 32 bits
M_E e, como um ponto flutuante de 32 bits
M_LN10 (link em inglês) log_e(10), como um ponto flutuante de 32 bits
M_LN2 (link em inglês) log_e(2), como um ponto flutuante de 32 bits
M_LOG10E (link em inglês) log_10(e), como um ponto flutuante de 32 bits
M_LOG2E (link em inglês) log_2(e), como um ponto flutuante de 32 bits
M_PI (link em inglês) pi, como um ponto flutuante de 32 bits
M_PI_2 (link em inglês) pi / 2, como um ponto flutuante de 32 bits
M_PI_4 (link em inglês) pi / 4, como um ponto flutuante de 32 bits
M_RAIZ1_2 1 / sqrt(2), como um flutuante de 32 bits
M_RAIZ2 sqrt(2), como um flutuante de 32 bits
Funções
abs Valor absoluto de um número inteiro
acos (link em inglês) Cosseno inverso
acosh (link em inglês) Cosseno hiperbólico inverso
Acospi (link em inglês) Cosseno inverso dividido por Pi
asin Seno inverso
asinh (link em inglês) Seno hiperbólico inverso
asinpi (em inglês) Seno inverso dividido por Pi
atan (em inglês) Tangente inversa
atan2 (link em inglês) Tangente inversa de uma razão
atan2pi (em inglês) Tangente inversa de uma razão dividida por Pi
atanh Tangente hiperbólica inversa
atanpi (em inglês) Tangente inversa dividida por Pi
cbrt (em inglês) Raiz cúbica
ceil (link em inglês) O menor número inteiro não é menor que um valor
braçadeira Restringir um valor a um intervalo
clz (link em inglês) Número de 0 bits iniciais
copysign Copia o sinal de um número para outro
cos (link em inglês) Cosseno
cosh (link em inglês) Cosseno hipobólico
cospi (link em inglês) Cosseno de um número multiplicado por pi
graus Converte radianos em graus
erf (link em inglês) Função de erro matemático
erfc Função de erro matemático complementar
exp "e" elevado a um número
exp10 10 elevado a um número
exp2 2 elevados a um número
expm1 (em inglês) e elevado a um número menos um
fabs (link em inglês) Valor absoluto de um ponto flutuante
Fdim (link em inglês) Diferença positiva entre dois valores
andar O menor número inteiro não é maior que um valor
fma (link em inglês) Multiplicar e adicionar
fmax (em inglês) Máximo de dois flutuantes
fmin (link em inglês) Mínimo de dois flutuantes
fmod (link em inglês) Módulo
fract (em inglês) Parte fracionária positiva
frexp (em inglês) Mantissa binária e expoente
half_recip (em inglês) Recíproco calculado com precisão de 16 bits
half_rsqrt (em inglês) Recíproco de uma raiz quadrada calculada com precisão de 16 bits
half_sqrt (em inglês) Raiz quadrada calculada com precisão de 16 bits
hipoteto Hipotenusa
ilogb (link em inglês) Expoente da base dois
ldexp (em inglês) Cria um ponto flutuante com base na mantissa e no expoente
lgamma (link em inglês) Logaritmo natural da função gama
registro Logaritmo natural
log10 (em inglês) Logaritmo de base 10
log1p (em inglês) Logaritmo natural de um valor mais 1
log2 Logaritmo de base 2
logb (em inglês) Expoente da base dois
mad Multiplicar e adicionar
máx. Máxima
min Mínima
mix Mistura dois valores
modf (link em inglês) Componentes integrais e fracionários
nan (link em inglês) Não é um número
nan_half (em inglês) Não é um número
native_acos (em inglês) Cosseno inverso aproximado
native_acosh (em inglês) Cosseno hiperbólico inverso aproximado
native_acospi (link em inglês) Cosseno inverso aproximado dividido por Pi
native_asin (em inglês) Seno inverso aproximado
native_asinh (em inglês) Seno hiperbólico aproximado
native_asinpi (em inglês) Seno inverso aproximado dividido por Pi
native_atan (em inglês) Tangente inversa aproximada
native_atan2 (em inglês) Tangente inversa aproximada de uma razão
native_atan2pi (em inglês) Tangente inversa aproximada de uma razão dividida por Pi
native_atanh (em inglês) Tangente hiperbólica inversa aproximada
native_atanpi (em inglês) Tangente inversa aproximada dividida por Pi
native_cbrt (em inglês) Raiz cúbica aproximada
native_cos (em inglês) Cosseno aproximado
native_cosh (link em inglês) Cosseno hipobólico aproximado
native_cospi (link em inglês) Cosseno aproximado de um número multiplicado por Pi
native_divide (em inglês) Divisão aproximada
native_exp (em inglês) "E" aproximado elevado a um número
native_exp10 (em inglês) Aproximadamente 10 elevados a um número
native_exp2 (em inglês) Aproximação de 2 elevadas a um número
native_expm1 (em inglês) E aproximado elevado para um número menos um
native_hypot (em inglês) Hipotenusa aproximada
native_log (em inglês) Logaritmo natural aproximado
native_log10 (em inglês) Logaritmo de base 10 aproximada
native_log1p (em inglês) Logaritmo natural aproximado de um valor mais 1
native_log2 (em inglês) Logaritmo de base 2 aproximado
native_powr (em inglês) Base positiva aproximada elevada a um expoente
native_recip (em inglês) Recíproco aproximado
native_rootn (link em inglês) Raiz enésima aproximada
native_rsqrt (em inglês) Recíproco aproximado de uma raiz quadrada
native_sin (em inglês) Seno aproximado
native_sincos (em inglês) Seno e cosseno aproximados
native_sinh (em inglês) Seno hiperbólico aproximado
native_sinpi (em inglês) Seno aproximado de um número multiplicado por Pi
native_sqrt (em inglês) Raiz quadrada aproximada
native_tan (link em inglês) Tangente aproximada
native_tanh (em inglês) Tangente hiperbólica aproximada
native_tanpi (em inglês) Tangente aproximada de um número multiplicado por Pi
nextafter Próximo número de ponto flutuante
pow Base elevada a um expoente
pown Base elevada em um expoente inteiro.
powr Base positiva elevada a um expoente
radianos Converte graus em radianos
restante Restante de uma divisão
remquo Restante e quociente de uma divisão
rint (em inglês) Arredondar para par
rootn (em inglês) Raiz enésima
rodada Arredondar a partir de zero
rsRand (link em inglês) Número pseudoaleatório
rsqrt (link em inglês) Recíproco de uma raiz quadrada
sinal Sinal de um valor
sin Seno
sincos (link em inglês) Seno e cosseno
sinh (link em inglês) Seno hiperbólico
sinpi (em inglês) Seno de um número multiplicado por pi
sqrt (link em inglês) Raiz quadrada
etapa 0 se for menor que um valor. Caso contrário, 1
marrom Tangente
tanh (link em inglês) Tangente hiperbólica
tanpi (em inglês) Tangente de um número multiplicado por pi
Gama Função gama
trunc (link em inglês) Trunca um ponto flutuante
Funções descontinuadas
rsClamp (em inglês) Descontinuado. Restringir um valor a um intervalo
rsFrac (em inglês) Descontinuado. Retorna a parte fracionária de um ponto flutuante

Constantes

M_1_PI : 1 / pi, como um flutuante de 32 bits


Valor: 0,318309886183790671537767526745028724f

O inverso de pi, como um flutuante de 32 bits.

M_2_PI : 2 / pi, como um flutuante de 32 bits


Valor: 0.636619772367581343075535053490057448f

2 dividido por pi, como um flutuante de 32 bits.

M_2_SQRTPI : 2 / sqrt(pi), como um flutuante de 32 bits


Valor: 1.128379167095512573896158903121545172f

2 dividido pela raiz quadrada de pi, como um flutuante de 32 bits.

M_E : "e", como um flutuante de 32 bits


Valor: 2.718281828459045235360287471352662498f

O número e, a base do logaritmo natural, como um flutuante de 32 bits.

M_LN10 : log_e(10), como um flutuante de 32 bits


Valor: 2.302585092994045684017991454684364208f

O logaritmo natural de 10, como um flutuante de 32 bits.

M_LN2 : log_e(2), como um flutuante de 32 bits


Valor: 0,693147180559945309417232121458176568f

O logaritmo natural de 2, como um flutuante de 32 bits.

M_LOG10E : log_10(e), como um flutuante de 32 bits


Valor: 0,434294481903251827651128918916605082f

A base de logaritmo 10 de e, como um flutuante de 32 bits.

M_LOG2E : log_2(e), como um flutuante de 32 bits


Valor: 1,442695040888963407359924681001892137f

A base de logaritmo 2 de e, como um flutuante de 32 bits.

M_PI : pi, como um flutuante de 32 bits


Valor: 3,141592653589793238462643383279502884f

O pi constante, como um flutuante de 32 bits.

M_PI_2 : pi / 2, como um flutuante de 32 bits


Valor: 1.570796326794896619231321691639751442f

Pi dividido por 2, como um flutuante de 32 bits.

M_PI_4 : pi / 4, como um flutuante de 32 bits


Valor: 0,785398163397448309615660845819875721f

Pi dividido por 4, como um flutuante de 32 bits.

M_SQRT1_2 : 1 / sqrt(2), como um flutuante de 32 bits


Valor: 0,707106781186547524400844362104849039f

O inverso da raiz quadrada de 2, como um flutuante de 32 bits.

M_SQRT2 : sqrt(2), como um flutuante de 32 bits


Valor: 1.414213562373095048801688724209698079f

A raiz quadrada de 2, como um flutuante de 32 bits.

Funções

abs : valor absoluto de um número inteiro

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

Retorna o valor absoluto de um número inteiro.

Para pontos flutuantes, use fabs().

acos : cosseno inverso

float acos(float v);
float2 acos(float2 v);
float3 acos(float3 v);
float4 acos(float4 v);
half acos(metade v); Adicionado no nível 24 da API.
half2 acos(half2 v); Adicionado no nível 24 da API.
half3 acos(half3 v); Adicionado no nível 24 da API.
half4 acos(half4 v); Adicionado no nível 24 da API.

Retorna o cosseno inverso, em radianos.

Consulte também native_acos().

acosh : cosseno hiperbólico inverso

float acosh(float v);
float2 acosh(float2 v);
float3 acosh(float3 v);
float4 acosh(float4 v);
half acosh(half v); Adicionado no nível 24 da API.
half2 acosh(half2 v); Adicionado no nível 24 da API.
half3 acosh(half3 v); Adicionado no nível 24 da API.
half4 acosh(half4 v); Adicionado no nível 24 da API.

Retorna o cosseno hiperbólico inverso, em radianos.

Consulte também native_acosh().

acospi : cosseno inverso dividido por pi

float acospi(float v);
float2 acospi(float2 v);
float3 acospi(float3 v);
float4 acospi(float4 v);
half acospi(half v); Adicionado no nível 24 da API.
half2 acospi(half2 v); Adicionado no nível 24 da API.
half3 acospi(half3 v); Adicionado no nível 24 da API.
half4 acospi(half4 v); Adicionado no nível 24 da API.

Retorna o cosseno inverso em radianos dividido por pi.

Para conseguir um cosseno inverso medido em graus, use acospi(a) * 180.f.

Consulte também native_acospi().

asin : seno inverso

float asin(float v);
float2 asin(float2 v);
float3 asin(float3 v);
float4 asin(float4 v);
half asin(metade v); Adicionado no nível 24 da API.
half2 asin(half2 v); Adicionado no nível 24 da API.
half3 asin(half3 v); Adicionado no nível 24 da API.
half4 asin(half4 v); Adicionado no nível 24 da API.

Retorna o seno inverso, em radianos.

Consulte também native_asin().

asinh : seno hiperbólico inverso

float asinh(float v);
float2 asinh(float2 v);
float3 asinh(float3 v);
float4 asinh(float4 v);
half asinh(metade v); Adicionado no nível 24 da API.
half2 asinh(half2 v); Adicionado no nível 24 da API.
half3 asinh(half3 v); Adicionado no nível 24 da API.
half4 asinh(half4 v); Adicionado no nível 24 da API.

Retorna o seno hiperbólico inverso, em radianos.

Veja também native_asinh().

asinpi : seno inverso dividido por pi

float asinpi(float v);
float2 asinpi(float2 v);
float3 asinpi(float3 v);
float4 asinpi(float4 v);
half asinpi(metade v); Adicionado no nível 24 da API.
half2 asinpi(half2 v); Adicionado no nível 24 da API.
half3 asinpi(half3 v); Adicionado no nível 24 da API.
half4 asinpi(half4 v); Adicionado no nível 24 da API.

Retorna o seno inverso em radianos, dividido por pi.

Para ter um seno inverso medido em graus, use asinpi(a) * 180.f.

Consulte também native_asinpi().

atan : tangente inversa

float atan(float v);
float2 atan(float2 v);
float3 atan(float3 v);
float4 atan(float4 v);
half atan(metade v); Adicionado no nível 24 da API.
half2 atan(half2 v); Adicionado no nível 24 da API.
half3 atan(half3 v); Adicionado no nível 24 da API.
half4 atan(half4 v); Adicionado no nível 24 da API.

Retorna a tangente inversa, em radianos.

Consulte também native_atan().

atan2 : tangente inversa de uma proporção

float atan2(numerador flutuante, denominador flutuante);
float2 atan2(numerador float2, denominador float2);
float3 atan2(numerador float3, denominador float3);
float4 atan2(numerador float4, denominador float4);
meio atan2(meio numerador, meio denominador); Adicionado no nível 24 da API.
half2 atan2(metade2 numerador, metade2 denominador); Adicionado no nível 24 da API.
half3 atan2(metade3 numerador, metade3 denominador); Adicionado no nível 24 da API.
half4 atan2(metade4 numerador, metade4 denominador); Adicionado no nível 24 da API.
Parâmetros
numeradorNumerador.
denominadorDenominador. Pode ser 0.

Retorna a tangente inversa de (numerator / denominator), em radianos.

Consulte também native_atan2().

atan2pi : tangente inversa de uma proporção dividida por pi

float atan2pi(numerador flutuante, denominador flutuante);
float2 atan2pi(numerador float2, denominador float2);
float3 atan2pi(numerador float3, denominador float3);
float4 atan2pi(numerador float4, denominador float4);
metade atan2pi(meio numerador, meio denominador); Adicionado no nível 24 da API.
half2 atan2pi(metade2 numerador, metade2 denominador); Adicionado no nível 24 da API.
half3 atan2pi(metade3 numerador, half3 denominador); Adicionado no nível 24 da API.
half4 atan2pi(metade4 numerador, metade4 denominador); Adicionado no nível 24 da API.
Parâmetros
numeradorNumerador.
denominadorDenominador. Pode ser 0.

Retorna a tangente inversa de (numerator / denominator), em radianos, dividida por pi.

Para ter uma tangente inversa medida em graus, use atan2pi(n, d) * 180.f.

Consulte também native_atan2pi().

atanh : tangente hiperbólica inversa

float atanh(float v);
float2 atanh(float2 v);
float3 atanh(float3 v);
float4 atanh(float4 v);
half atanh(metade v); Adicionado no nível 24 da API.
half2 atanh(half2 v); Adicionado no nível 24 da API.
half3 atanh(half3 v); Adicionado no nível 24 da API.
half4 atanh(half4 v); Adicionado no nível 24 da API.

Retorna a tangente hiperbólica inversa, em radianos.

Consulte também native_atanh().

atanpi : tangente inversa dividida por pi

float atanpi(float v);
float2 atanpi(float2 v);
float3 atanpi(float3 v);
float4 atanpi(float4 v);
half atanpi(metade v); Adicionado no nível 24 da API.
half2 atanpi(half2 v); Adicionado no nível 24 da API.
half3 atanpi(half3 v); Adicionado no nível 24 da API.
half4 atanpi(half4 v); Adicionado no nível 24 da API.

Retorna a tangente inversa em radianos, dividida por pi.

Para ter uma tangente inversa medida em graus, use atanpi(a) * 180.f.

Consulte também native_atanpi().

cbrt : raiz cúbica

float cbrt(float v);
float2 cbrt(float2 v);
float3 cbrt(float3 v);
float4 cbrt(float4 v);
half cbrt(half v); Adicionado no nível 24 da API.
half2 cbrt(half2 v); Adicionado no nível 24 da API.
half3 cbrt(half3 v); Adicionado no nível 24 da API.
half4 cbrt(half4 v); Adicionado no nível 24 da API.

Retorna a raiz cúbica.

Consulte também native_cbrt().

ceil : o menor número inteiro não inferior a um valor

float ceil(float v);
float2 ceil(float2 v);
float3 ceil(float3 v);
float4 ceil(float4 v);
half ceil(half v); Adicionado no nível 24 da API.
half2 ceil(half2 v); Adicionado no nível 24 da API.
half3 ceil(half3 v); Adicionado no nível 24 da API.
half4 ceil(half4 v); Adicionado no nível 24 da API.

Retorna o menor número inteiro não inferior a um valor.

Por exemplo, ceil(1.2f) retorna 2.f e ceil(-1.2f) retorna -1.f.

Consulte também floor().

clamp : restringir um valor a um intervalo

char clamp(char value, char min_value, char max_value); Adicionado no nível 19 da API.
char2 clamp(valor de char2, char min_value, char max_value); Adicionado no nível 19 da API.
char2 clamp(valor de char2, valor mínimo de char2, valor de char2 max_value); Adicionado no nível 19 da API.
char3 clamp(valor de char3, char min_value, char max_value); Adicionado no nível 19 da API.
char3 clamp(valor de char3, min_value de char3, char3 max_value); Adicionado no nível 19 da API.
char4 clamp(valor de char4, char min_value, char max_value); Adicionado no nível 19 da API.
char4 clamp(valor de char4, valor mínimo de char4, valor de char4 max_value); Adicionado no nível 19 da API.
float clamp(float value, float min_value, float max_value);
float2 clamp(valor float2, float min_value, float max_value);
float2 clamp(valor float2, float2 min_value, float2 max_value);
float3 clamp(valor float3, float min_value, float max_value);
float3 clamp(valor float3, float3 min_value, float3 max_value);
float4 clamp(valor float4, float min_value, float max_value);
float4 clamp(valor float4, float4 min_value, float4 max_value);
half clamp(half value, half min_value, half max_value); Adicionado no nível 24 da API.
half2 clamp(half2 value, half min_value, half max_value); Adicionado no nível 24 da API.
half2 clamp(half2 value, half2 min_value, half2 max_value); Adicionado no nível 24 da API.
half3 clamp(half3 value, half min_value, half max_value); Adicionado no nível 24 da API.
half3 clamp(half3 value, half3 min_value, half3 max_value); Adicionado no nível 24 da API.
half4 clamp(half4 value, half min_value, half max_value); Adicionado no nível 24 da API.
half4 clamp(half4 value, half4 min_value, half4 max_value); Adicionado no nível 24 da API.
int clamp(int value, int min_value, int max_value); Adicionado no nível 19 da API.
int2 clamp(valor int2, int min_value, int max_value); Adicionado no nível 19 da API.
int2 clamp(valor int2, int2 min_value, int2 max_value); Adicionado no nível 19 da API.
int3 clamp(valor int3, int min_value, int max_value); Adicionado no nível 19 da API.
int3 clamp(valor int3, int3 min_value, int3 max_value); Adicionado no nível 19 da API.
int4 clamp(valor int4, int min_value, int max_value); Adicionado no nível 19 da API.
int4 clamp(valor int4, int4 min_value, int4 max_value); Adicionado no nível 19 da API.
long clamp(long value, long min_value, long max_value); Adicionado no nível 19 da API.
long2 clamp(valor long2, long min_value, long max_value); Adicionado no nível 19 da API.
long2 clamp(valor long2, min_value long2, long2 max_value); Adicionado no nível 19 da API.
long3 clamp(valor long3, long min_value, long max_value); Adicionado no nível 19 da API.
long3 clamp(valor long3, min_value long3, long3 max_value); Adicionado no nível 19 da API.
long4 clamp(valor long4, long min_value, long max_value); Adicionado no nível 19 da API.
long4 clamp(valor long4, min_value long4, long4 max_value); Adicionado no nível 19 da API.
short clamp(short value, short min_value, short max_value); Adicionado no nível 19 da API.
short2 clamp(valor short2, short min_value, short max_value); Adicionado no nível 19 da API.
short2 clamp(valor de short2, min_value de short2, short2 max_value); Adicionado no nível 19 da API.
short3 clamp(short3 value, short min_value, short max_value); Adicionado no nível 19 da API.
short3 clamp(valor short3, min_value short3, short3 max_value); Adicionado no nível 19 da API.
short4 clamp(valor short4, short min_value, short max_value); Adicionado no nível 19 da API.
short4 clamp(valor short4, min_value short4, short4 max_value); Adicionado no nível 19 da API.
uchar clamp(valor de uchar, min_value de uchar, uchar max_value); Adicionado no nível 19 da API.
uchar2 clamp(valor de uchar2, min_value de uchar, uchar max_value); Adicionado no nível 19 da API.
uchar2 clamp(valor de uchar2, min_value de uchar2, uchar2 max_value); Adicionado no nível 19 da API.
uchar3 clamp(valor de uchar3, min_value de uchar, uchar max_value); Adicionado no nível 19 da API.
uchar3 clamp(valor de uchar3, min_value de uchar3, uchar3 max_value); Adicionado no nível 19 da API.
uchar4 clamp(valor uchar4, min_value uchar, uchar max_value); Adicionado no nível 19 da API.
uchar4 clamp(valor uchar4, min_value uchar4, uchar4 max_value); Adicionado no nível 19 da API.
uint clamp(uint value, uint min_value, uint max_value); Adicionado no nível 19 da API.
uint2 clamp(valor de uint2, uint min_value, uint max_value); Adicionado no nível 19 da API.
uint2 clamp(valor de uint2, uint2 min_value, uint2 max_value); Adicionado no nível 19 da API.
uint3 clamp(valor uint3, uint min_value, uint max_value); Adicionado no nível 19 da API.
uint3 clamp(valor uint3, uint3 min_value, uint3 max_value); Adicionado no nível 19 da API.
uint4 clamp(valor uint4, uint min_value, uint max_value); Adicionado no nível 19 da API.
uint4 clamp(valor de uint4, uint4 min_value, uint4 max_value); Adicionado no nível 19 da API.
ulong clamp(valor de ulong, min_value de ulong, ulong max_value); Adicionado no nível 19 da API.
ulong2 clamp(valor de ulong2, ulong min_value, ulong max_value); Adicionado no nível 19 da API.
ulong2 clamp(valor de ulong2, ulong2 min_value, ulong2 max_value); Adicionado no nível 19 da API.
ulong3 clamp(valor de ulong3, ulong min_value, ulong max_value); Adicionado no nível 19 da API.
ulong3 clamp(valor de ulong3, ulong3 min_value, ulong3 max_value); Adicionado no nível 19 da API.
ulong4 clamp(valor de ulong4, min_value ulong, ulong max_value); Adicionado no nível 19 da API.
ulong4 clamp(valor de ulong4, ulong4 min_value, ulong4 max_value); Adicionado no nível 19 da API.
ushort clamp(valor ushort, min_value ushort, ushort max_value); Adicionado no nível 19 da API.
ushort2 clamp(valor de ushort2, ushort min_value, ushort max_value); Adicionado no nível 19 da API.
ushort2 clamp(valor de ushort2, min_value de ushort2, ushort2 max_value); Adicionado no nível 19 da API.
ushort3 clamp(valor de ushort3, min_value de ushort, ushort max_value); Adicionado no nível 19 da API.
ushort3 clamp(valor de ushort3, ushort3 min_value, ushort3 max_value); Adicionado no nível 19 da API.
ushort4 clamp(valor ushort4, min_value ushort, ushort max_value); Adicionado no nível 19 da API.
ushort4 clamp(valor de ushort4, min_value de ushort4, ushort4 max_value); Adicionado no nível 19 da API.
Parâmetros
valueValor a ser fixado.
valor_mínimoLimite inferior, um vetor escalar ou correspondente.
valor_máximoLimite máximo; precisa corresponder ao tipo de valor baixo.

Fixa um valor a um limite máximo e mínimo especificado. clamp() retorna min_value se valor < min_value, max_value se valor > max_value. Caso contrário, value.

Há duas variantes de clamp: uma em que os valores mínimo e máximo são escalares aplicados a todas as entradas do valor e a outra em que os valores mínimo e máximo também são vetores.

Se min_value for maior que max_value, os resultados serão indefinidos.

clz : número de 0 bits iniciais

char clz(char value);
char2 clz(valor char2);
char3 clz(valor char3);
char4 clz(valor char4);
int clz(int value);
int2 clz(valor int2);
int3 clz(valor int3);
int4 clz(valor int4);
short clz(short value);
short2 clz(valor short2);
short3 clz(valor short3);
short4 clz(valor short4);
uchar clz(uchar value);
uchar2 clz(valor uchar2);
uchar3 clz(valor uchar3);
uchar4 clz(valor uchar4);
uint clz(uint value);
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);

Retorna o número de 0 bits no início de um valor.

Por exemplo, clz((char)0x03) retorna 6.

copysign : copia o sinal de um número para outro

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(half magnitude_value, half sign_value); Adicionado no nível 24 da API.
half2 copysign(half2 magnitude_value, half2 sign_value); Adicionado no nível 24 da API.
half3 copysign(half3 magnitude_value, half3 sign_value); Adicionado no nível 24 da API.
half4 copysign(half4 magnitude_value, half4 sign_value); Adicionado no nível 24 da API.

Copia o sinal de sign_value para magnitude_value.

O valor retornado é magnitude_value ou -magnitude_value.

Por exemplo, copysign(4.0f, -2.7f) retorna -4,0f e copysign(-4.0f, 2.7f) retorna 4,0f.

cos : cosseno

float cos(float v);
float2 cos(float2 v);
float3 cos(float3 v);
float4 cos(float4 v);
half cos(half v); Adicionado no nível 24 da API.
half2 cos(half2 v); Adicionado no nível 24 da API.
half3 cos(half3 v); Adicionado no nível 24 da API.
half4 cos(half4 v); Adicionado no nível 24 da API.

Retorna o cosseno de um ângulo medido em radianos.

Consulte também native_cos().

cosh : cosseno hipobólico

float cosh(float v);
float2 cosh(float2 v);
float3 cosh(float3 v);
float4 cosh(float4 v);
half cosh(half v); Adicionado no nível 24 da API.
half2 cosh(half2 v); Adicionado no nível 24 da API.
half3 cosh(half3 v); Adicionado no nível 24 da API.
half4 cosh(half4 v); Adicionado no nível 24 da API.

Retorna o cosseno hipobólico de v, em que v é medido em radianos.

Consulte também native_cosh().

cospi : cosseno de um número multiplicado por pi

float cospi(float v);
float2 cospi(float2 v);
float3 cospi(float3 v);
float4 cospi(float4 v);
half cospi(metade v); Adicionado no nível 24 da API.
half2 cospi(half2 v); Adicionado no nível 24 da API.
half3 cospi(half3 v); Adicionado no nível 24 da API.
half4 cospi(half4 v); Adicionado no nível 24 da API.

Retorna o cosseno de (v * pi), em que (v * pi) é medido em radianos.

Para conseguir o cosseno de um valor medido em graus, chame cospi(v / 180.f).

Consulte também native_cospi().

degrees : converte radianos em graus

float graus(float v);
float2 graus(float2 v);
float3 graus(float3 v);
float4 graus(float4 v);
meio graus(metade v); Adicionado no nível 24 da API.
half2 graus(half2 v); Adicionado no nível 24 da API.
half3 graus(half3 v); Adicionado no nível 24 da API.
half4 graus(half4 v); Adicionado no nível 24 da API.

Converte de radianos para graus.

erf : função de erro matemático

float erf(float v);
float2 erf(float2 v);
float3 erf(float3 v);
float4 erf(float4 v);
half erf(half v); Adicionado no nível 24 da API.
half2 erf(half2 v); Adicionado no nível 24 da API.
half3 erf(half3 v); Adicionado no nível 24 da API.
half4 erf(half4 v); Adicionado no nível 24 da API.

Retorna a função de erro.

erfc : função de erro matemática complementar

float erfc(float v);
float2 erfc(float2 v);
float3 erfc(float3 v);
float4 erfc(float4 v);
half erfc(half v); Adicionado no nível 24 da API.
half2 erfc(half2 v); Adicionado no nível 24 da API.
half3 erfc(half3 v); Adicionado no nível 24 da API.
half4 erfc(half4 v); Adicionado no nível 24 da API.

Retorna a função de erro complementar.

exp : "e" elevado a um número

float exp(float v);
float2 exp(float2 v);
float3 exp(float3 v);
float4 exp(float4 v);
half exp(half v); Adicionado no nível 24 da API.
half2 exp(half2 v); Adicionado no nível 24 da API.
half3 exp(half3 v); Adicionado no nível 24 da API.
half4 exp(half4 v); Adicionado no nível 24 da API.

Retorna e elevado para v, ou seja, e ^ v.

Consulte também native_exp().

exp10 : 10 elevado a um número

float exp10(float v);
float2 exp10(float2 v);
float3 exp10(float3 v);
float4 exp10(float4 v);
half exp10(metade v); Adicionado no nível 24 da API.
half2 exp10(half2 v); Adicionado no nível 24 da API.
half3 exp10(half3 v); Adicionado no nível 24 da API.
half4 exp10(half4 v); Adicionado no nível 24 da API.

Retorna 10 elevado para v, ou seja, 10.f ^ v.

Consulte também native_exp10().

exp2 : 2 elevado a um número

float exp2(float v);
float2 exp2(float2 v);
float3 exp2(float3 v);
float4 exp2(float4 v);
half exp2(metade v); Adicionado no nível 24 da API.
half2 exp2(half2 v); Adicionado no nível 24 da API.
half3 exp2(half3 v); Adicionado no nível 24 da API.
half4 exp2(half4 v); Adicionado no nível 24 da API.

Retorna 2 elevado para v, ou seja, 2.f ^ v.

Consulte também native_exp2().

expm1 : "e" elevado a um número menos um

float expm1(float v);
float2 expm1(float2 v);
float3 expm1(float3 v);
float4 expm1(float4 v);
half expm1(metade v); Adicionado no nível 24 da API.
half2 expm1(half2 v); Adicionado no nível 24 da API.
half3 expm1(half3 v); Adicionado no nível 24 da API.
half4 expm1(half4 v); Adicionado no nível 24 da API.

Retorna e elevado para v menos 1, ou seja, (e ^ v) - 1.

Consulte também native_expm1().

fabs : valor absoluto de um flutuante

float fabs(float v);
float2 fabs(float2 v);
float3 fabs(float3 v);
float4 fabs(float4 v);
half fabs(half v); Adicionado no nível 24 da API.
half2 fabs(half2 v); Adicionado no nível 24 da API.
half3 fabs(half3 v); Adicionado no nível 24 da API.
half4 fabs(half4 v); Adicionado no nível 24 da API.

Retorna o valor absoluto do flutuante v.

Para números inteiros, use abs().

fdim : diferença positiva entre dois 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);
half fdim(metade a, metade b); Adicionado no nível 24 da API.
half2 fdim(half2 a, half2 b); Adicionado no nível 24 da API.
half3 fdim(half3 a, half3 b); Adicionado no nível 24 da API.
half4 fdim(half4 a, half4 b); Adicionado no nível 24 da API.

Retorna a diferença positiva entre dois valores.

Se a > b, retorna (a - b), caso contrário, retorna 0f.

floor : o menor número inteiro não é maior que um valor

float floor(float v);
float2 floor(float2 v);
float3 floor(float3 v);
float4 floor(float4 v);
half floor(half v); Adicionado no nível 24 da API.
half2 floor(half2 v); Adicionado no nível 24 da API.
half3 floor(half3 v); Adicionado no nível 24 da API.
half4 floor(half4 v); Adicionado no nível 24 da API.

Retorna o menor número inteiro não maior que um valor.

Por exemplo, floor(1.2f) retorna 1.f e floor(-1.2f) retorna -2.f.

Consulte também ceil().

fma : multiplicar e adicionar

float fma(float multiplicand1, float multiplicand2, deslocamento de ponto flutuante);
float2 fma(float2 multiplicand1, float2 multiplicand2, deslocamento de float2);
float3 fma(float3 multiplicand1, float3 multiplicand2, deslocamento de float3);
float4 fma(float4 multiplicand1, float4 multiplicand2, deslocamento de float4);
metade fma(metade multiplicando1, meio multiplicando2, deslocamento de meio) Adicionado no nível 24 da API.
half2 fma(half2 multiplicand1, half2 multiplicand2, deslocamento de half2); Adicionado no nível 24 da API.
half3 fma(half3 multiplicand1, half3 multiplicand2, deslocamento de half3); Adicionado no nível 24 da API.
half4 fma(half4 multiplicand1, half4 multiplicand2, deslocamento de half4); Adicionado no nível 24 da API.

Multiplique e adicione. Retorna (multiplicand1 * multiplicand2) + offset.

Essa função é semelhante a mad(). fma() mantém a precisão total do resultado multiplicado e arredonda apenas após a adição. mad() arredonda após a multiplicação e a adição. Essa precisão extra não é garantida no modo rs_fp_relaxed.

fmax : máximo de dois flutuantes

float fmax(float a, float b);
float2 fmax(float2 a, float b);
float2 fmax(float2 a, float2 b);
float3 fmax(float3 a, float b);
float3 fmax(float3 a, float3 b);
float4 fmax(float4 a, float b);
float4 fmax(float4 a, float4 b);
half fmax(half a, half b); Adicionado no nível 24 da API.
half2 fmax(half2 a, half b); Adicionado no nível 24 da API.
half2 fmax(half2 a, half2 b); Adicionado no nível 24 da API.
half3 fmax(half3 a, half b); Adicionado no nível 24 da API.
half3 fmax(half3 a, half3 b); Adicionado no nível 24 da API.
half4 fmax(half4 a, half b); Adicionado no nível 24 da API.
half4 fmax(half4 a, half4 b); Adicionado no nível 24 da API.

Retorna o máximo de a e b, ou seja, (a < b ? b : a).

A função max() retorna resultados idênticos, mas pode ser aplicada a mais tipos de dados.

fmin : mínimo de dois flutuantes

float fmin(float a, float b);
float2 fmin(float2 a, float b);
float2 fmin(float2 a, float2 b);
float3 fmin(float3 a, float b);
float3 fmin(float3 a, float3 b);
float4 fmin(float4 a, float b);
float4 fmin(float4 a, float4 b);
half fmin(metade a, metade b); Adicionado no nível 24 da API.
half2 fmin(metade2 a, metade b); Adicionado no nível 24 da API.
half2 fmin(half2 a, half2 b); Adicionado no nível 24 da API.
half3 fmin(metade3 a, metade b); Adicionado no nível 24 da API.
half3 fmin(half3 a, half3 b); Adicionado no nível 24 da API.
half4 fmin(metade4 a, metade b); Adicionado no nível 24 da API.
half4 fmin(metade4 a, half4 b); Adicionado no nível 24 da API.

Retorna o mínimo de a e b, ou seja, (a > b ? b : a).

A função min() retorna resultados idênticos, mas pode ser aplicada a mais tipos de dados.

fmod : módulo

float fmod(numerador de ponto flutuante, denominador de ponto flutuante);
float2 fmod(numerador float2, denominador float2);
float3 fmod(numerador float3, denominador float3);
float4 fmod(numerador float4, denominador float4);
metade fmod(meio numerador, meio denominador); Adicionado no nível 24 da API.
half2 fmod(half2 numerador, half2 denominador); Adicionado no nível 24 da API.
half3 fmod(half3 numerador, half3 denominador); Adicionado no nível 24 da API.
half4 fmod(half4 numerador, half4 denominador); Adicionado no nível 24 da API.

Retorna o restante de (numerador / denominador), onde o quociente é arredondado até zero.

A função remainder() é semelhante, mas é arredondada para o número inteiro mais próximo. Por exemplo, fmod(-3.8f, 2.f) retorna -1,8f (-3,8f - -1.f * 2.f), enquanto remainder(-3.8f, 2.f) retorna 0,2f (-3,8f - -2.f * 2.f).

fract : parte fracionária positiva

float fract(float v);
float fract(float v, float* floor);
float2 fract(float2 v);
float2 fract(float2 v, float2* floor);
float3 fract(float3 v);
float3 fract(float3 v, float3* floor);
float4 fract(float4 v);
float4 fract(float4 v, float4* floor);
half fract(half v); Adicionado no nível 24 da API.
half fract(metade v, meio* andar); Adicionado no nível 24 da API.
half2 fract(half2 v); Adicionado no nível 24 da API.
half2 fract(half2 v, half2* floor); Adicionado no nível 24 da API.
half3 fract(half3 v); Adicionado no nível 24 da API.
half3 fract(half3 v, half3* floor); Adicionado no nível 24 da API.
half4 fract(half4 v); Adicionado no nível 24 da API.
half4 fract(half4 v, half4* floor); Adicionado no nível 24 da API.
Parâmetros
vValor de entrada.
andarSe floor não for nulo, *floor será definido como o preço mínimo de v.

Retorna a parte fracionária positiva de v, ou seja, v - floor(v).

Por exemplo, fract(1.3f, &val) retorna 0,3f e define val como 1.f. fract(-1.3f, &val) retorna 0,7f e define val como -2.f.

frexp : mantissa e expoente binários

flutuação frexp(flutuante v, int* expoente);
float2 frexp(float2 v, expoente int2*);
float3 frexp(float3 v, expoente int3*);
float4 frexp(float4 v, expoente int4*);
metade frexp(metade v, int* expoente); Adicionado no nível 24 da API.
half2 frexp(half2 v, expoente int2*); Adicionado no nível 24 da API.
half3 frexp(metade3 v, expoente int3*); Adicionado no nível 24 da API.
half4 frexp(metade4 v, expoente int4*); Adicionado no nível 24 da API.
Parâmetros
vValor de entrada.
expoenteSe o expoente não for nulo, o *expoente será definido como o expoente de v.

Retorna a mantissa e o expoente binários de v, ou seja, v == mantissa * 2 ^ exponent.

A mantissa está sempre entre 0,5 (inclusiva) e 1,0 (exclusivo).

Consulte ldexp() para a operação inversa. Veja também logb() e ilogb().

half_recip : recíproca calculada com precisão de 16 bits

float half_recip(float v); Adicionado no nível 17 da API.
float2 half_recip(float2 v); Adicionado no nível 17 da API.
float3 half_recip(float3 v); Adicionado no nível 17 da API.
float4 half_recip(float4 v); Adicionado no nível 17 da API.

Retorna o recíproco aproximado de um valor.

A precisão é de um valor de ponto flutuante de 16 bits.

Consulte também native_recip().

half_rsqrt : recíproco de uma raiz quadrada calculada com precisão de 16 bits

float half_rsqrt(float v); Adicionado no nível 17 da API.
float2 half_rsqrt(float2 v); Adicionado no nível 17 da API.
float3 half_rsqrt(float3 v); Adicionado no nível 17 da API.
float4 half_rsqrt(float4 v); Adicionado no nível 17 da API.

Retorna o valor aproximado de (1.f / sqrt(value)).

A precisão é de um valor de ponto flutuante de 16 bits.

Consulte também rsqrt(), native_rsqrt().

half_sqrt : raiz quadrada calculada com precisão de 16 bits

float half_sqrt(float v); Adicionado no nível 17 da API.
float2 half_sqrt(float2 v); Adicionado no nível 17 da API.
float3 half_sqrt(float3 v); Adicionado no nível 17 da API.
float4 half_sqrt(float4 v); Adicionado no nível 17 da API.

Retorna a raiz quadrada aproximada de um valor.

A precisão é de um valor de ponto flutuante de 16 bits.

Consulte também sqrt(), native_sqrt().

hypot : hipotenusa

float hypot(float a, float b);
float2 hypot(float2 a, float2 b);
float3 hypot(float3 a, float3 b);
float4 hypot(float4 a, float4 b);
metade hypot(metade a, metade b); Adicionado no nível 24 da API.
half2 hypot(half2 a, half2 b); Adicionado no nível 24 da API.
half3 hypot(half3 a, half3 b); Adicionado no nível 24 da API.
half4 hypot(half4 a, half4 b); Adicionado no nível 24 da API.

Retorna a hipotenusa, ou seja, sqrt(a * a + b * b).

Consulte também native_hypot().

ilogb : expoente de base dois

int ilogb(float v);
int ilogb(half v); Adicionado no nível 24 da API.
int2 ilogb(float2 v);
int2 ilogb(half2 v); Adicionado no nível 24 da API.
int3 ilogb(float3 v);
int3 ilogb(half3 v); Adicionado no nível 24 da API.
int4 ilogb(float4 v);
int4 ilogb(half4 v); Adicionado no nível 24 da API.

Retorna os dois expoentes da base de um valor, em que a mantissa está entre 1,f (inclusive) e 2,f (exclusivo).

Por exemplo, ilogb(8.5f) retorna 3.

Por causa da diferença em mantissa, esse número é um a menos do que é retornado por frexp().

logb() é semelhante, mas retorna um ponto flutuante.

ldexp : cria um ponto flutuante com base em mantissa e expoente.

float ldexp(flutuante mantissa, int expoente);
float2 ldexp(float2 mantissa, expoente int);
float2 ldexp(float2 mantissa, expoente int2);
float3 ldexp(float3 mantissa, expoente int);
float3 ldexp(float3 mantissa, expoente int3);
float4 ldexp(float4 mantissa, expoente int);
float4 ldexp(float4 mantissa, expoente int4);
metade ldexp(metade mantissa, int expoente); Adicionado no nível 24 da API.
metade2 ldexp(metade2 mantissa, expoente int); Adicionado no nível 24 da API.
metade2 ldexp(metade2 mantissa, expoente int2); Adicionado no nível 24 da API.
half3 ldexp(metade3 mantissa, expoente int); Adicionado no nível 24 da API.
half3 ldexp(metade3 mantissa, expoente int3); Adicionado no nível 24 da API.
half4 ldexp(metade4 mantissa, expoente int); Adicionado no nível 24 da API.
half4 ldexp(metade4 mantissa, expoente int4); Adicionado no nível 24 da API.
Parâmetros
MantissaMantissa.
expoenteExpoente, um único componente ou vetor correspondente.

Retorna o ponto flutuante criado a partir da mantissa e do expoente, ou seja, (mantissa * 2 ^ expoente).

Consulte frexp() para a operação inversa.

lgamma : logaritmo natural da função gama

float lgamma(float v);
float lgamma(flutuante v, int* sign_of_gamma);
float2 lgamma(float2 v);
float2 lgamma(float2 v, int2* sign_of_gamma);
float3 lgamma(float3 v);
float3 lgamma(float3 v, int3* sign_of_gamma);
float4 lgamma(float4 v);
float4 lgamma(float4 v, int4* sign_of_gamma);
metade lgamma(metade v); Adicionado no nível 24 da API.
metade lgamma(metade v, int* sign_of_gamma); Adicionado no nível 24 da API.
half2 lgamma(half2 v); Adicionado no nível 24 da API.
half2 lgamma(half2 v, int2* sign_of_gamma); Adicionado no nível 24 da API.
half3 lgamma(half3 v); Adicionado no nível 24 da API.
half3 lgamma(half3 v, int3* sign_of_gamma); Adicionado no nível 24 da API.
half4 lgamma(half4 v); Adicionado no nível 24 da API.
half4 lgamma(half4 v, int4* sign_of_gamma); Adicionado no nível 24 da API.
Parâmetros
v
sinal_de_gamaSe o sinal_de_gama não for nulo, ele será definido como -1,f se a gama de v for negativa. Caso contrário, será 1,f.

Retorna o logaritmo natural do valor absoluto da função gama, ou seja, log(fabs(tgamma(v))).

Veja também tgamma().

log : logaritmo natural

float log(float v);
float2 log(float2 v);
float3 log(float3 v);
float4 log(float4 v);
half log(half v); Adicionado no nível 24 da API.
half2 log(half2 v); Adicionado no nível 24 da API.
half3 log(half3 v); Adicionado no nível 24 da API.
half4 log(half4 v); Adicionado no nível 24 da API.

Retorna o logaritmo natural.

Consulte também native_log().

log10 : logaritmo de base 10

float log10(float v);
float2 log10(float2 v);
float3 log10(float3 v);
float4 log10(float4 v);
half log10(metade v); Adicionado no nível 24 da API.
half2 log10(half2 v); Adicionado no nível 24 da API.
half3 log10(half3 v); Adicionado no nível 24 da API.
half4 log10(half4 v); Adicionado no nível 24 da API.

Retorna o logaritmo de base 10.

Consulte também native_log10().

log1p : logaritmo natural de um valor mais 1

float log1p(float v);
float2 log1p(float2 v);
float3 log1p(float3 v);
float4 log1p(float4 v);
half log1p(half v); Adicionado no nível 24 da API.
half2 log1p(half2 v); Adicionado no nível 24 da API.
half3 log1p(half3 v); Adicionado no nível 24 da API.
half4 log1p(half4 v); Adicionado no nível 24 da API.

Retorna o logaritmo natural de (v + 1.f).

Consulte também native_log1p().

log2 : logaritmo de base 2

float log2(float v);
float2 log2(float2 v);
float3 log2(float3 v);
float4 log2(float4 v);
half log2(metade v); Adicionado no nível 24 da API.
half2 log2(half2 v); Adicionado no nível 24 da API.
half3 log2(half3 v); Adicionado no nível 24 da API.
half4 log2(half4 v); Adicionado no nível 24 da API.

Retorna o logaritmo de base 2.

Consulte também native_log2().

logb : expoente de base dois

float logb(float v);
float2 logb(float2 v);
float3 logb(float3 v);
float4 logb(float4 v);
half logb(half v); Adicionado no nível 24 da API.
half2 logb(half2 v); Adicionado no nível 24 da API.
half3 logb(half3 v); Adicionado no nível 24 da API.
half4 logb(half4 v); Adicionado no nível 24 da API.

Retorna os dois expoentes da base de um valor, em que a mantissa está entre 1,f (inclusive) e 2,f (exclusivo).

Por exemplo, logb(8.5f) retorna 3.f.

Por causa da diferença em mantissa, esse número é um a menos do que é retornado por frexp().

ilogb() é semelhante, mas retorna um número inteiro.

mad : multiplicar e somar

float mad(float multiplicand1, float multiplicand2, float offset);
float2 mad(float2 multiplicand1, float2 multiplicand2, deslocamento de float2);
float3 mad(float3 multiplicand1, float3 multiplicand2, deslocamento de float3);
float4 mad(float4 multiplicand1, float4 multiplicand2, deslocamento de float4);
half mad(metade multiplicand1, metade multiplicando2, deslocamento de metade); Adicionado no nível 24 da API.
half2 mad(half2 multiplicand1, half2 multiplicand2, deslocamento de half2); Adicionado no nível 24 da API.
half3 mad(half3 multiplicand1, half3 multiplicand2, deslocamento de half3); Adicionado no nível 24 da API.
half4 mad(half4 multiplicand1, half4 multiplicand2, deslocamento de half4); Adicionado no nível 24 da API.

Multiplique e adicione. Retorna (multiplicand1 * multiplicand2) + offset.

Essa função é semelhante a fma(). fma() mantém a precisão total do resultado multiplicado e arredonda apenas após a adição. mad() arredonda após a multiplicação e a adição. No modo rs_fp_relaxed, o mad() não pode fazer o arredondamento após o multiplicaiton.

max : máximo

char max(char a, char b);
char2 max(char2 a, char2 b);
char3 max(char3 a, char3 b);
char4 max(char4 a, char4 b);
float max(float a, float b);
float2 max(float2 a, float b);
float2 max(float2 a, float2 b);
float3 max(float3 a, float b);
float3 max(float3 a, float3 b);
float4 max(float4 a, float b);
float4 max(float4 a, float4 b);
half max(half a, half b); Adicionado no nível 24 da API.
half2 max(half2 a, half b); Adicionado no nível 24 da API.
half2 max(half2 a, half2 b); Adicionado no nível 24 da API.
half3 max(half3 a, half b); Adicionado no nível 24 da API.
half3 max(half3 a, half3 b); Adicionado no nível 24 da API.
half4 max(half4 a, half b); Adicionado no nível 24 da API.
half4 max(half4 a, half4 b); Adicionado no nível 24 da API.
int max(int a, int b);
int2 max(int2 a, int2 b);
int3 max(int3 a, int3 b);
int4 max(int4 a, int4 b);
long max(long a, long b); Adicionado no nível 21 da API.
long2 max(long2 a, long2 b); Adicionado no nível 21 da API.
long3 max(long3 a, long3 b); Adicionado no nível 21 da API.
long4 max(long4 a, long4 b); Adicionado no nível 21 da API.
short max(short a, short b);
short2 max(short2 a, short2 b);
short3 max(short3 a, short3 b);
short4 max(short4 a, short4 b);
uchar max(uchar a, uchar b);
uchar2 max(uchar2 a, uchar2 b);
uchar3 max(uchar3 a, uchar3 b);
uchar4 max(uchar4 a, uchar4 b);
uint max(uint a, uint b);
uint2 max(uint2 a, uint2 b);
uint3 max(uint3 a, uint3 b);
uint4 max(uint4 a, uint4 b);
ulong max(ulong a, ulong b); Adicionado no nível 21 da API.
ulong2 max(ulong2 a, ulong2 b); Adicionado no nível 21 da API.
ulong3 max(ulong3 a, ulong3 b); Adicionado no nível 21 da API.
ulong4 max(ulong4 a, ulong4 b); Adicionado no nível 21 da API.
ushort max(ushort a, ushort b);
ushort2 max(ushort2 a, ushort2 b);
ushort3 max(ushort3 a, ushort3 b);
ushort4 max(ushort4 a, ushort4 b);

Retorna o valor máximo de dois 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);
metade min(metade a, metade b); Adicionado no nível 24 da API.
half2 min(metade2 a, metade b); Adicionado no nível 24 da API.
half2 min(metade2 a, half2 b); Adicionado no nível 24 da API.
half3 min(metade3 a, metade b); Adicionado no nível 24 da API.
half3 min(metade3 a, half3 b); Adicionado no nível 24 da API.
half4 min(metade4 a, metade b); Adicionado no nível 24 da API.
half4 min(metade4 a, half4 b); Adicionado no nível 24 da API.
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); Adicionado no nível 21 da API.
long2 min(long2 a, long2 b); Adicionado no nível 21 da API.
long3 min(long3 a, long3 b); Adicionado no nível 21 da API.
long4 min(long4 a, long4 b); Adicionado no nível 21 da API.
curto min(a curto, b curto);
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); Adicionado no nível 21 da API.
ulong2 min(ulong2 a, ulong2 b); Adicionado no nível 21 da API.
ulong3 min(ulong3 a, ulong3 b); Adicionado no nível 21 da API.
ulong4 min(ulong4 a, ulong4 b); Adicionado no nível 21 da API.
ushort min(ushort a, ushort b);
ushort2 min(ushort2 a, ushort2 b);
ushort3 min(ushort3 a, ushort3 b);
ushort4 min(ushort4 a, ushort4 b);

Retorna o valor mínimo de dois argumentos.

mix : combina dois valores

float mix(ponto de flutuação, parada de flutuação, fração de ponto flutuante);
float2 mix(início de float2, float2 para parada, fração de ponto flutuante);
mix float2(início float2, float2 parada, fração float2);
float3 mix(início de float3, parada float3, fração de ponto flutuante);
mix float3(início de float3, parada float3, fração float3);
mix float4(início de float4, parada float4, fração de ponto flutuante);
mix float4(início de float4, parada float4, fração float4)
metade mix(metade início, metade parada, metade fração); Adicionado no nível 24 da API.
half2 mix(metade2 início, metade2 parada, metade fração); Adicionado no nível 24 da API.
half2 mix(metade2 início, metade2 parada, fração half2); Adicionado no nível 24 da API.
half3 mix(half3 início, metade3 parada, metade fração); Adicionado no nível 24 da API.
half3 mix(half3 início, metade3 parada, fração half3); Adicionado no nível 24 da API.
half4 mix(metade4 início, metade parada, metade fração); Adicionado no nível 24 da API.
half4 mix(half4 início, metade parada, fração half4); Adicionado no nível 24 da API.

Retorna início + ((parada - início) * fração).

Isso pode ser útil para misturar dois valores. Por exemplo, para criar uma nova cor que seja 40% color1 e 60% color2, use mix(color1, color2, 0.6f).

modf : componentes integrais e fracionários

float modf(float v, float* integral_part);
float2 modf(float2 v, float2* integral_part);
float3 modf(float3 v, float3* integral_part);
float4 modf(float4 v, float4* integral_part);
half modf(half v, half* integral_part); Adicionado no nível 24 da API.
half2 modf(half2 v, half2* integral_part); Adicionado no nível 24 da API.
half3 modf(half3 v, half3* integral_part); Adicionado no nível 24 da API.
half4 modf(half4 v, half4* integral_part); Adicionado no nível 24 da API.
Parâmetros
vValor de origem.
parte_integral*integral_part será definido como a parte integral do número.
Returns
Parte de ponto flutuante do valor.

Retorna os componentes integrais e fracionários de um número.

Ambos os componentes terão o mesmo sinal que x. Por exemplo, para uma entrada de -3,72f, *integral_part será definido como -3.f e .72f será retornado.

nan : não é um número

float nan(uint v);
Parâmetros
vNão usado.

Retorna um valor NaN (não um número).

nan_half : não é um número

half nan_half() Adicionado no nível 24 da API.

Retorna um valor NaN de ponto flutuante de meia precisão (não é um número).

native_acos : cosseno inverso aproximado

float native_acos(float v); Adicionado no nível 21 da API.
float2 native_acos(float2 v); Adicionado no nível 21 da API.
float3 native_acos(float3 v); Adicionado no nível 21 da API.
float4 native_acos(float4 v); Adicionado no nível 21 da API.
half native_acos(half v); Adicionado no nível 24 da API.
half2 native_acos(half2 v); Adicionado no nível 24 da API.
half3 native_acos(half3 v); Adicionado no nível 24 da API.
half4 native_acos(half4 v); Adicionado no nível 24 da API.

Retorna o cosseno inverso aproximado, em radianos.

Essa função gera resultados indefinidos de valores de entrada menores que -1 ou maiores que 1.

Consulte também acos().

native_acosh : cosseno hiperbólico inverso aproximado

float native_acosh(float v); Adicionado no nível 21 da API.
float2 native_acosh(float2 v); Adicionado no nível 21 da API.
float3 native_acosh(float3 v); Adicionado no nível 21 da API.
float4 native_acosh(float4 v); Adicionado no nível 21 da API.
half native_acosh(half v); Adicionado no nível 24 da API.
half2 native_acosh(half2 v); Adicionado no nível 24 da API.
half3 native_acosh(half3 v); Adicionado no nível 24 da API.
half4 native_acosh(half4 v); Adicionado no nível 24 da API.

Retorna o cosseno hiperbólico inverso aproximado, em radianos.

Veja também acosh().

native_acospi : cosseno inverso aproximado dividido por pi

float native_acospi(float v); Adicionado no nível 21 da API.
float2 native_acospi(float2 v); Adicionado no nível 21 da API.
float3 native_acospi(float3 v); Adicionado no nível 21 da API.
float4 native_acospi(float4 v); Adicionado no nível 21 da API.
half native_acospi(half v); Adicionado no nível 24 da API.
half2 native_acospi(half2 v); Adicionado no nível 24 da API.
half3 native_acospi(half3 v); Adicionado no nível 24 da API.
half4 native_acospi(half4 v); Adicionado no nível 24 da API.

Retorna o cosseno inverso aproximado em radianos, dividido por pi.

Para conseguir um cosseno inverso medido em graus, use acospi(a) * 180.f.

Essa função gera resultados indefinidos de valores de entrada menores que -1 ou maiores que 1.

Consulte também acospi().

native_asin : seno inverso aproximado

float native_asin(float v); Adicionado no nível 21 da API.
float2 native_asin(float2 v); Adicionado no nível 21 da API.
float3 native_asin(float3 v); Adicionado no nível 21 da API.
float4 native_asin(float4 v); Adicionado no nível 21 da API.
half native_asin(half v); Adicionado no nível 24 da API.
half2 native_asin(half2 v); Adicionado no nível 24 da API.
half3 native_asin(half3 v); Adicionado no nível 24 da API.
half4 native_asin(half4 v); Adicionado no nível 24 da API.

Retorna o seno inverso aproximado, em radianos.

Essa função gera resultados indefinidos de valores de entrada menores que -1 ou maiores que 1.

Consulte também asin().

native_asinh : seno hiperbólico inverso aproximado

float native_asinh(float v); Adicionado no nível 21 da API.
float2 native_asinh(float2 v); Adicionado no nível 21 da API.
float3 native_asinh(float3 v); Adicionado no nível 21 da API.
float4 native_asinh(float4 v); Adicionado no nível 21 da API.
half native_asinh(half v); Adicionado no nível 24 da API.
half2 native_asinh(half2 v); Adicionado no nível 24 da API.
half3 native_asinh(half3 v); Adicionado no nível 24 da API.
half4 native_asinh(half4 v); Adicionado no nível 24 da API.

Retorna o seno hiperbólico inverso aproximado, em radianos.

Veja também asinh().

native_asinpi : seno inverso aproximado dividido por pi

float native_asinpi(float v); Adicionado no nível 21 da API.
float2 native_asinpi(float2 v); Adicionado no nível 21 da API.
float3 native_asinpi(float3 v); Adicionado no nível 21 da API.
float4 native_asinpi(float4 v); Adicionado no nível 21 da API.
half native_asinpi(half v); Adicionado no nível 24 da API.
half2 native_asinpi(half2 v); Adicionado no nível 24 da API.
half3 native_asinpi(half3 v); Adicionado no nível 24 da API.
half4 native_asinpi(half4 v); Adicionado no nível 24 da API.

Retorna o seno inverso aproximado em radianos, dividido por pi.

Para ter um seno inverso medido em graus, use asinpi(a) * 180.f.

Essa função gera resultados indefinidos de valores de entrada menores que -1 ou maiores que 1.

Veja também asinpi().

native_atan : tangente inversa aproximada

float native_atan(float v); Adicionado no nível 21 da API.
float2 native_atan(float2 v); Adicionado no nível 21 da API.
float3 native_atan(float3 v); Adicionado no nível 21 da API.
float4 native_atan(float4 v); Adicionado no nível 21 da API.
half native_atan(half v); Adicionado no nível 24 da API.
half2 native_atan(half2 v); Adicionado no nível 24 da API.
half3 native_atan(half3 v); Adicionado no nível 24 da API.
half4 native_atan(half4 v); Adicionado no nível 24 da API.

Retorna a tangente inversa aproximada, em radianos.

Consulte também atan().

native_atan2 : tangente inversa aproximada de uma proporção

float native_atan2(numerador do ponto flutuante, denominador do ponto flutuante); Adicionado no nível 21 da API.
float2 native_atan2(numerador float2, denominador float2); Adicionado no nível 21 da API.
float3 native_atan2(numerador float3, denominador float3); Adicionado no nível 21 da API.
float4 native_atan2(numerador float4, denominador float4); Adicionado no nível 21 da API.
metade native_atan2(meio numerador, meio denominador); Adicionado no nível 24 da API.
half2 native_atan2(metade2 numerador, metade2 denominador); Adicionado no nível 24 da API.
half3 native_atan2(metade3 numerador, metade3 denominador); Adicionado no nível 24 da API.
half4 native_atan2(metade numerador, metade4 denominador); Adicionado no nível 24 da API.
Parâmetros
numeradorNumerador.
denominadorDenominador. Pode ser 0.

Retorna a tangente inversa aproximada de (numerator / denominator), em radianos.

Consulte também atan2().

native_atan2pi : tangente inversa aproximada de uma proporção, dividida por pi

float native_atan2pi(numerador do ponto flutuante, denominador do ponto flutuante); Adicionado no nível 21 da API.
float2 native_atan2pi(numerador float2, denominador float2); Adicionado no nível 21 da API.
float3 native_atan2pi(numerador float3, denominador float3); Adicionado no nível 21 da API.
float4 native_atan2pi(numerador float4, denominador float4); Adicionado no nível 21 da API.
half native_atan2pi(meio numerador, meio denominador); Adicionado no nível 24 da API.
half2 native_atan2pi(half2 numerador, half2 denominador); Adicionado no nível 24 da API.
half3 native_atan2pi(half3 numerador, half3 denominador); Adicionado no nível 24 da API.
half4 native_atan2pi(half4 numerador, half4 denominador); Adicionado no nível 24 da API.
Parâmetros
numeradorNumerador.
denominadorDenominador. Pode ser 0.

Retorna a tangente inversa aproximada de (numerator / denominator), em radianos, dividida por pi.

Para ter uma tangente inversa medida em graus, use atan2pi(n, d) * 180.f.

Consulte também atan2pi().

native_atanh : tangente hiperbólica inversa aproximada

float native_atanh(float v); Adicionado no nível 21 da API.
float2 native_atanh(float2 v); Adicionado no nível 21 da API.
float3 native_atanh(float3 v); Adicionado no nível 21 da API.
float4 native_atanh(float4 v); Adicionado no nível 21 da API.
half native_atanh(half v); Adicionado no nível 24 da API.
half2 native_atanh(half2 v); Adicionado no nível 24 da API.
half3 native_atanh(half3 v); Adicionado no nível 24 da API.
half4 native_atanh(half4 v); Adicionado no nível 24 da API.

Retorna a tangente hiperbólica inversa aproximada, em radianos.

Veja também atanh().

native_atanpi : tangente inversa aproximada dividida por pi

float native_atanpi(float v); Adicionado no nível 21 da API.
float2 native_atanpi(float2 v); Adicionado no nível 21 da API.
float3 native_atanpi(float3 v); Adicionado no nível 21 da API.
float4 native_atanpi(float4 v); Adicionado no nível 21 da API.
half native_atanpi(half v); Adicionado no nível 24 da API.
half2 native_atanpi(half2 v); Adicionado no nível 24 da API.
half3 native_atanpi(half3 v); Adicionado no nível 24 da API.
half4 native_atanpi(half4 v); Adicionado no nível 24 da API.

Retorna a tangente inversa aproximada em radianos, dividida por pi.

Para ter uma tangente inversa medida em graus, use atanpi(a) * 180.f.

Consulte também atanpi().

native_cbrt : raiz cúbica aproximada

float native_cbrt(float v); Adicionado no nível 21 da API.
float2 native_cbrt(float2 v); Adicionado no nível 21 da API.
float3 native_cbrt(float3 v); Adicionado no nível 21 da API.
float4 native_cbrt(float4 v); Adicionado no nível 21 da API.
half native_cbrt(half v); Adicionado no nível 24 da API.
half2 native_cbrt(half2 v); Adicionado no nível 24 da API.
half3 native_cbrt(half3 v); Adicionado no nível 24 da API.
half4 native_cbrt(half4 v); Adicionado no nível 24 da API.

Retorna a raiz cúbica aproximada.

Consulte também cbrt().

native_cos : cosseno aproximado

float native_cos(float v); Adicionado no nível 21 da API.
float2 native_cos(float2 v); Adicionado no nível 21 da API.
float3 native_cos(float3 v); Adicionado no nível 21 da API.
float4 native_cos(float4 v); Adicionado no nível 21 da API.
half native_cos(half v); Adicionado no nível 24 da API.
half2 native_cos(half2 v); Adicionado no nível 24 da API.
half3 native_cos(half3 v); Adicionado no nível 24 da API.
half4 native_cos(half4 v); Adicionado no nível 24 da API.

Retorna o cosseno aproximado de um ângulo medido em radianos.

Consulte também cos().

native_cosh : cosseno hipobólico aproximado

float native_cosh(float v); Adicionado no nível 21 da API.
float2 native_cosh(float2 v); Adicionado no nível 21 da API.
float3 native_cosh(float3 v); Adicionado no nível 21 da API.
float4 native_cosh(float4 v); Adicionado no nível 21 da API.
half native_cosh(half v); Adicionado no nível 24 da API.
half2 native_cosh(half2 v); Adicionado no nível 24 da API.
half3 native_cosh(half3 v); Adicionado no nível 24 da API.
half4 native_cosh(half4 v); Adicionado no nível 24 da API.

Retorna o cosseno hipobólico aproximado.

Consulte também cosh().

native_cospi : cosseno aproximado de um número multiplicado por pi

float native_cospi(float v); Adicionado no nível 21 da API.
float2 native_cospi(float2 v); Adicionado no nível 21 da API.
float3 native_cospi(float3 v); Adicionado no nível 21 da API.
float4 native_cospi(float4 v); Adicionado no nível 21 da API.
half native_cospi(half v); Adicionado no nível 24 da API.
half2 native_cospi(half2 v); Adicionado no nível 24 da API.
half3 native_cospi(half3 v); Adicionado no nível 24 da API.
half4 native_cospi(half4 v); Adicionado no nível 24 da API.

Retorna o cosseno aproximado de (v * pi), em que (v * pi) é medido em radianos.

Para conseguir o cosseno de um valor medido em graus, chame cospi(v / 180.f).

Consulte também cospi().

native_divide : divisão aproximada

float native_divide(float left_vector, float right_vector); Adicionado no nível 21 da API.
float2 native_divide(float2 left_vector, float2 right_vector); Adicionado no nível 21 da API.
float3 native_divide(float3 left_vector, float3 right_vector); Adicionado no nível 21 da API.
float4 native_divide(float4 left_vector, float4 right_vector); Adicionado no nível 21 da API.
half native_divide(half left_vector, half right_vector); Adicionado no nível 24 da API.
half2 native_divide(half2 left_vector, half2 right_vector); Adicionado no nível 24 da API.
half3 native_divide(half3 left_vector, half3 right_vector); Adicionado no nível 24 da API.
half4 native_divide(half4 left_vector, half4 right_vector); Adicionado no nível 24 da API.

Calcula a divisão aproximada de dois valores.

native_exp : "e" aproximado aumentado para um número

float native_exp(float v); Adicionado no nível 18 da API.
float2 native_exp(float2 v); Adicionado no nível 18 da API.
float3 native_exp(float3 v); Adicionado no nível 18 da API.
float4 native_exp(float4 v); Adicionado no nível 18 da API.
half native_exp(half v); Adicionado no nível 24 da API.
half2 native_exp(half2 v); Adicionado no nível 24 da API.
half3 native_exp(half3 v); Adicionado no nível 24 da API.
half4 native_exp(half4 v); Adicionado no nível 24 da API.

Exp. aproximada rápida

É válido para entradas de -86.f a 86.f. A precisão não é pior do que o esperado com o uso de valores de ponto flutuante de 16 bits.

Consulte também exp().

native_exp10 : aproximadamente 10 elevados para um número

float native_exp10(float v); Adicionado no nível 18 da API.
float2 native_exp10(float2 v); Adicionado no nível 18 da API.
float3 native_exp10(float3 v); Adicionado no nível 18 da API.
float4 native_exp10(float4 v); Adicionado no nível 18 da API.
half native_exp10(half v); Adicionado no nível 24 da API.
half2 native_exp10(half2 v); Adicionado no nível 24 da API.
half3 native_exp10(half3 v); Adicionado no nível 24 da API.
half4 native_exp10(half4 v); Adicionado no nível 24 da API.

Exp10 aproximado rápido.

É válido para entradas de -37.f a 37.f. A precisão não é pior do que o esperado com o uso de valores de ponto flutuante de 16 bits.

Consulte também exp10().

native_exp2 : aproximadamente 2 elevados a um número

float native_exp2(float v); Adicionado no nível 18 da API.
float2 native_exp2(float2 v); Adicionado no nível 18 da API.
float3 native_exp2(float3 v); Adicionado no nível 18 da API.
float4 native_exp2(float4 v); Adicionado no nível 18 da API.
half native_exp2(half v); Adicionado no nível 24 da API.
half2 native_exp2(half2 v); Adicionado no nível 24 da API.
half3 native_exp2(half3 v); Adicionado no nível 24 da API.
half4 native_exp2(half4 v); Adicionado no nível 24 da API.

Exp2 aproximado rápido.

É válido para entradas de -125.f a 125.f. A precisão não é pior do que o esperado com o uso de valores de ponto flutuante de 16 bits.

Consulte também exp2().

native_expm1 : "e" aproximado elevado para um número menos um

float native_expm1(float v); Adicionado no nível 21 da API.
float2 native_expm1(float2 v); Adicionado no nível 21 da API.
float3 native_expm1(float3 v); Adicionado no nível 21 da API.
float4 native_expm1(float4 v); Adicionado no nível 21 da API.
half native_expm1(half v); Adicionado no nível 24 da API.
half2 native_expm1(half2 v); Adicionado no nível 24 da API.
half3 native_expm1(half3 v); Adicionado no nível 24 da API.
half4 native_expm1(half4 v); Adicionado no nível 24 da API.

Retorna a aproximação (e ^ v) - 1.

Consulte também expm1().

native_hypot : hipotenusa aproximada

float native_hypot(float a, float b); Adicionado no nível 21 da API.
float2 native_hypot(float2 a, float2 b); Adicionado no nível 21 da API.
float3 native_hypot(float3 a, float3 b); Adicionado no nível 21 da API.
float4 native_hypot(float4 a, float4 b); Adicionado no nível 21 da API.
half native_hypot(half a, half b); Adicionado no nível 24 da API.
half2 native_hypot(half2 a, half2 b); Adicionado no nível 24 da API.
half3 native_hypot(half3 a, half3 b); Adicionado no nível 24 da API.
half4 native_hypot(half4 a, half4 b); Adicionado no nível 24 da API.

Retorna o native_sqrt(a * a + b * b) aproximado

Consulte também hypot().

native_log : logaritmo natural aproximado

float native_log(float v); Adicionado no nível 18 da API.
float2 native_log(float2 v); Adicionado no nível 18 da API.
float3 native_log(float3 v); Adicionado no nível 18 da API.
float4 native_log(float4 v); Adicionado no nível 18 da API.
half native_log(half v); Adicionado no nível 24 da API.
half2 native_log(half2 v); Adicionado no nível 24 da API.
half3 native_log(half3 v); Adicionado no nível 24 da API.
half4 native_log(half4 v); Adicionado no nível 24 da API.

Registro aproximado rápido.

Não é preciso para valores muito próximos de zero.

Consulte também log().

native_log10 : logaritmo aproximado de base 10

float native_log10(float v); Adicionado no nível 18 da API.
float2 native_log10(float2 v); Adicionado no nível 18 da API.
float3 native_log10(float3 v); Adicionado no nível 18 da API.
float4 native_log10(float4 v); Adicionado no nível 18 da API.
half native_log10(half v); Adicionado no nível 24 da API.
half2 native_log10(half2 v); Adicionado no nível 24 da API.
half3 native_log10(half3 v); Adicionado no nível 24 da API.
half4 native_log10(half4 v); Adicionado no nível 24 da API.

Log10 rápido aproximado.

Não é preciso para valores muito próximos de zero.

Consulte também log10().

native_log1p : logaritmo natural aproximado de um valor mais 1

float native_log1p(float v); Adicionado no nível 21 da API.
float2 native_log1p(float2 v); Adicionado no nível 21 da API.
float3 native_log1p(float3 v); Adicionado no nível 21 da API.
float4 native_log1p(float4 v); Adicionado no nível 21 da API.
half native_log1p(half v); Adicionado no nível 24 da API.
half2 native_log1p(half2 v); Adicionado no nível 24 da API.
half3 native_log1p(half3 v); Adicionado no nível 24 da API.
half4 native_log1p(half4 v); Adicionado no nível 24 da API.

Retorna o logaritmo natural aproximado de (v + 1,0f)

Consulte também log1p().

native_log2 : logaritmo aproximado de base 2

float native_log2(float v); Adicionado no nível 18 da API.
float2 native_log2(float2 v); Adicionado no nível 18 da API.
float3 native_log2(float3 v); Adicionado no nível 18 da API.
float4 native_log2(float4 v); Adicionado no nível 18 da API.
half native_log2(half v); Adicionado no nível 24 da API.
half2 native_log2(half2 v); Adicionado no nível 24 da API.
half3 native_log2(half3 v); Adicionado no nível 24 da API.
half4 native_log2(half4 v); Adicionado no nível 24 da API.

Log2 rápido aproximado.

Não é preciso para valores muito próximos de zero.

Consulte também log2().

native_powr : base positiva aproximada elevada a um expoente

float native_powr(base flutuante, expoente de ponto flutuante); Adicionado no nível 18 da API.
float2 native_powr(float2 base, expoente float2); Adicionado no nível 18 da API.
float3 native_powr(float3 base, expoente float3); Adicionado no nível 18 da API.
float4 native_powr(float4 base, expoente float4); Adicionado no nível 18 da API.
metade native_powr(metade base, meio expoente); Adicionado no nível 24 da API.
half2 native_powr(metade2 base, metade2 expoente); Adicionado no nível 24 da API.
half3 native_powr(half3 base, half3 expoent); Adicionado no nível 24 da API.
half4 native_powr(half4 base, half4 expoente); Adicionado no nível 24 da API.
Parâmetros
basePrecisa estar entre 0,f e 256,f. A função não é precisa para valores muito próximos de zero.
expoentePrecisa estar entre -15,f e 15,f.

Estimativa rápida (base ^ expoente).

Consulte também powr().

native_recip : recíproco aproximado

float native_recip(float v); Adicionado no nível 21 da API.
float2 native_recip(float2 v); Adicionado no nível 21 da API.
float3 native_recip(float3 v); Adicionado no nível 21 da API.
float4 native_recip(float4 v); Adicionado no nível 21 da API.
half native_recip(half v); Adicionado no nível 24 da API.
half2 native_recip(half2 v); Adicionado no nível 24 da API.
half3 native_recip(half3 v); Adicionado no nível 24 da API.
half4 native_recip(half4 v); Adicionado no nível 24 da API.

Retorna o recíproco aproximado aproximado de um valor.

Veja também half_recip().

native_rootn : raiz enésima aproximada

float native_rootn(float v, int n); Adicionado no nível 21 da API.
float2 native_rootn(float2 v, int2 n); Adicionado no nível 21 da API.
float3 native_rootn(float3 v, int3 n); Adicionado no nível 21 da API.
float4 native_rootn(float4 v, int4 n); Adicionado no nível 21 da API.
half native_rootn(half v, int n); Adicionado no nível 24 da API.
half2 native_rootn(half2 v, int2 n); Adicionado no nível 24 da API.
half3 native_rootn(half3 v, int3 n); Adicionado no nível 24 da API.
half4 native_rootn(half4 v, int4 n); Adicionado no nível 24 da API.

Calcule a raiz N aproximada de um valor.

Consulte também rootn().

native_rsqrt : recíproco aproximado de uma raiz quadrada

float native_rsqrt(float v); Adicionado no nível 21 da API.
float2 native_rsqrt(float2 v); Adicionado no nível 21 da API.
float3 native_rsqrt(float3 v); Adicionado no nível 21 da API.
float4 native_rsqrt(float4 v); Adicionado no nível 21 da API.
half native_rsqrt(half v); Adicionado no nível 24 da API.
half2 native_rsqrt(half2 v); Adicionado no nível 24 da API.
half3 native_rsqrt(half3 v); Adicionado no nível 24 da API.
half4 native_rsqrt(half4 v); Adicionado no nível 24 da API.

Retorna aproximado (1 / sqrt(v)).

Consulte também rsqrt(), half_rsqrt().

native_sin : seno aproximado

float native_sin(float v); Adicionado no nível 21 da API.
float2 native_sin(float2 v); Adicionado no nível 21 da API.
float3 native_sin(float3 v); Adicionado no nível 21 da API.
float4 native_sin(float4 v); Adicionado no nível 21 da API.
half native_sin(half v); Adicionado no nível 24 da API.
half2 native_sin(half2 v); Adicionado no nível 24 da API.
half3 native_sin(half3 v); Adicionado no nível 24 da API.
half4 native_sin(half4 v); Adicionado no nível 24 da API.

Retorna o seno aproximado de um ângulo medido em radianos.

Consulte também sin().

native_sincos : seno e cosseno aproximados

float native_sincos(float v, float* cos); Adicionado no nível 21 da API.
float2 native_sincos(float2 v, float2* cos); Adicionado no nível 21 da API.
float3 native_sincos(float3 v, float3* cos); Adicionado no nível 21 da API.
float4 native_sincos(float4 v, float4* cos); Adicionado no nível 21 da API.
half native_sincos(half v, half* cos); Adicionado no nível 24 da API.
half2 native_sincos(half2 v, half2* cos); Adicionado no nível 24 da API.
half3 native_sincos(half3 v, half3* cos); Adicionado no nível 24 da API.
half4 native_sincos(half4 v, half4* cos); Adicionado no nível 24 da API.
Parâmetros
vValor de entrada em radianos.
cos*cos será definido como o valor do cosseno.
Returns
Seno.

Retorna o seno e o cosseno aproximados de um valor.

Consulte também sincos().

native_sinh : seno hiperbólico aproximado

float native_sinh(float v); Adicionado no nível 21 da API.
float2 native_sinh(float2 v); Adicionado no nível 21 da API.
float3 native_sinh(float3 v); Adicionado no nível 21 da API.
float4 native_sinh(float4 v); Adicionado no nível 21 da API.
half native_sinh(half v); Adicionado no nível 24 da API.
half2 native_sinh(half2 v); Adicionado no nível 24 da API.
half3 native_sinh(half3 v); Adicionado no nível 24 da API.
half4 native_sinh(half4 v); Adicionado no nível 24 da API.

Retorna o seno hiperbólico aproximado de um valor especificado em radianos.

Consulte também sinh().

native_sinpi : seno aproximado de um número multiplicado por pi

float native_sinpi(float v); Adicionado no nível 21 da API.
float2 native_sinpi(float2 v); Adicionado no nível 21 da API.
float3 native_sinpi(float3 v); Adicionado no nível 21 da API.
float4 native_sinpi(float4 v); Adicionado no nível 21 da API.
half native_sinpi(half v); Adicionado no nível 24 da API.
half2 native_sinpi(half2 v); Adicionado no nível 24 da API.
half3 native_sinpi(half3 v); Adicionado no nível 24 da API.
half4 native_sinpi(half4 v); Adicionado no nível 24 da API.

Retorna o seno aproximado de (v * pi), em que (v * pi) é medido em radianos.

Para encontrar o seno de um valor medido em graus, chame sinpi(v / 180.f).

Veja também sinpi().

native_sqrt : raiz quadrada aproximada

float native_sqrt(float v); Adicionado no nível 21 da API.
float2 native_sqrt(float2 v); Adicionado no nível 21 da API.
float3 native_sqrt(float3 v); Adicionado no nível 21 da API.
float4 native_sqrt(float4 v); Adicionado no nível 21 da API.
half native_sqrt(half v); Adicionado no nível 24 da API.
half2 native_sqrt(half2 v); Adicionado no nível 24 da API.
half3 native_sqrt(half3 v); Adicionado no nível 24 da API.
half4 native_sqrt(half4 v); Adicionado no nível 24 da API.

Retorna a sqrt(v) aproximada.

Consulte também sqrt(), half_sqrt().

native_tan : tangente aproximada

float native_tan(float v); Adicionado no nível 21 da API.
float2 native_tan(float2 v); Adicionado no nível 21 da API.
float3 native_tan(float3 v); Adicionado no nível 21 da API.
float4 native_tan(float4 v); Adicionado no nível 21 da API.
half native_tan(half v); Adicionado no nível 24 da API.
half2 native_tan(half2 v); Adicionado no nível 24 da API.
half3 native_tan(half3 v); Adicionado no nível 24 da API.
half4 native_tan(half4 v); Adicionado no nível 24 da API.

Retorna a tangente aproximada de um ângulo medido em radianos.

native_tanh : tangente hiperbólica aproximada

float native_tanh(float v); Adicionado no nível 21 da API.
float2 native_tanh(float2 v); Adicionado no nível 21 da API.
float3 native_tanh(float3 v); Adicionado no nível 21 da API.
float4 native_tanh(float4 v); Adicionado no nível 21 da API.
half native_tanh(half v); Adicionado no nível 24 da API.
half2 native_tanh(half2 v); Adicionado no nível 24 da API.
half3 native_tanh(half3 v); Adicionado no nível 24 da API.
half4 native_tanh(half4 v); Adicionado no nível 24 da API.

Retorna a tangente hiperbólica aproximada de um valor.

Consulte também tanh().

native_tanpi : tangente aproximada de um número multiplicada por pi

float native_tanpi(float v); Adicionado no nível 21 da API.
float2 native_tanpi(float2 v); Adicionado no nível 21 da API.
float3 native_tanpi(float3 v); Adicionado no nível 21 da API.
float4 native_tanpi(float4 v); Adicionado no nível 21 da API.
half native_tanpi(half v); Adicionado no nível 24 da API.
half2 native_tanpi(half2 v); Adicionado no nível 24 da API.
half3 native_tanpi(half3 v); Adicionado no nível 24 da API.
half4 native_tanpi(half4 v); Adicionado no nível 24 da API.

Retorna a tangente aproximada de (v * pi), em que (v * pi) é medido em radianos.

Para descobrir a tangente de um valor medido em graus, chame tanpi(v / 180.f).

Consulte também tanpi().

nextafter : próximo número de ponto flutuante

float nextafter(float v, float target);
float2 nextafter(float2 v, float2 target);
float3 nextafter(float3 v, float3 target);
float4 nextafter(float4 v, float4 target);
half nextafter(half v, half target); Adicionado no nível 24 da API.
half2 nextafter(half2 v, half2 target); Adicionado no nível 24 da API.
half3 nextafter(half3 v, half3 target); Adicionado no nível 24 da API.
half4 nextafter(half4 v, half4 target); Adicionado no nível 24 da API.

Retorna o próximo número de ponto flutuante representável de v em direção à meta.

No modo rs_fp_relaxed, um valor de entrada desnormalizado pode não produzir o próximo valor desnormalizado, já que o suporte a valores desnormalizados é opcional no modo relaxado.

pow : base elevada a um expoente

flutuação pow(base flutuante, expoente de ponto flutuante);
float2 pow(float2 base, expoente float2);
float3 pow(float3 base, expoente float3);
float4 pow(base float4, expoente float4);
meio pow(meio base, meio expoente); Adicionado no nível 24 da API.
metade2 pow(metade2 base, metade2 expoente); Adicionado no nível 24 da API.
half3 pow(metade3 base, metade3 expoente); Adicionado no nível 24 da API.
metade4 pow(metade4 base, metade4 expoente); Adicionado no nível 24 da API.

Retorna a base elevada ao expoente da potência, ou seja, expoente base ^.

pown() e powr() são semelhantes. pown() recebe um expoente de número inteiro. powr() supõe que a base não seja negativa.

pown : base elevada em um expoente inteiro

float pown(base flutuante, int expoente);
float2 pown(float2 base, expoente int2);
float3 pown(float3 base, expoente int3);
float4 pown(float4 base, expoente int4);
metade pown(metade base, int expoente); Adicionado no nível 24 da API.
half2 pown(half2 base, expoente int2); Adicionado no nível 24 da API.
half3 pown(half3 base, expoente int3); Adicionado no nível 24 da API.
half4 pown(half4 base, expoente int4); Adicionado no nível 24 da API.

Retorna a base elevada ao expoente da potência, ou seja, expoente base ^.

pow() e powr() são semelhantes. Ambos usam um expoente flutuante. powr() também pressupõe que a base não seja negativa.

powr : base positiva elevada a um expoente

flutuação powr(base flutuante, expoente de ponto flutuante);
float2 powr(float2 base, expoente float2);
float3 powr(float3 base, expoente float3);
powr float4(base float4, expoente float4);
meio powr(meio da base, meio expoente); Adicionado no nível 24 da API.
metade2 powr(metade2 base, metade2 expoente); Adicionado no nível 24 da API.
metade3 powr(metade3 base, metade3 expoente); Adicionado no nível 24 da API.
half4 powr(meio4 base, meio4 expoente); Adicionado no nível 24 da API.

Retorna a base elevada ao expoente da potência, ou seja, expoente base ^. a base precisa ser >= 0.

pow() e pown() são semelhantes. Ambos não fazem suposições sobre a base. pow() recebe um expoente flutuante, enquanto pown() recebe um número inteiro.

Consulte também native_powr().

radianos : converte graus em radianos

float radians(float v);
float2 radianos(float2 v);
float3 radianos(float3 v);
float4 radianos(float4 v);
metade radianos(metade v); Adicionado no nível 24 da API.
half2 radianos(half2 v); Adicionado no nível 24 da API.
half3 radianos(half3 v); Adicionado no nível 24 da API.
half4 radianos(half4 v); Adicionado no nível 24 da API.

Converte de graus para radianos.

restante : restante de uma divisão

float restante(flutuante numerador, float denominador);
float2 restante(numerador float2, denominador float2);
float3 restante(numerador float3, denominador float3);
float4 restante(numerador float4, denominador float4);
meio restante(meio numerador, meio denominador); Adicionado no nível 24 da API.
half2 restante(metade2 numerador, metade2 denominador) Adicionado no nível 24 da API.
half3 restante(metade3 numerador, half3 denominador); Adicionado no nível 24 da API.
half4 restante(metade4 numerador, metade4 denominador); Adicionado no nível 24 da API.

Retorna o restante de (numerador / denominador), em que o quociente é arredondado para o número inteiro mais próximo.

A função fmod() é semelhante, mas é arredondada para o número inteiro mais próximo. Por exemplo, fmod(-3.8f, 2.f) retorna -1,8f (-3,8f - -1.f * 2.f), enquanto remainder(-3.8f, 2.f) retorna 0,2f (-3,8f - -2.f * 2.f).

remquo : restante e quociente de uma divisão

float remquo(flutuante numerador, float denominador, int* quociente);
float2 remquo(numerador float2, denominador float2, quociente int2*);
float3 remquo(numerador float3, denominador float3, quociente int3*);
float4 remquo(numerador float4, denominador float4, quociente int4*);
meio remquo(meio numerador, meio denominador, int* quociente); Adicionado no nível 24 da API.
half2 remquo(metade2 numerador, half2 denominador, int2* quociente); Adicionado no nível 24 da API.
half3 remquo(metade3 numerador, half3 denominador, int3* quociente); Adicionado no nível 24 da API.
half4 remquo(metade4 numerador, half4 denominador, int4* quociente); Adicionado no nível 24 da API.
Parâmetros
numeradorNumerador.
denominadorDenominador.
quociente*quociente será definido como o quociente inteiro.
Returns
Restante, preciso apenas para os três bits mais baixos.

Retorna o quociente e o restante de (numerador / denominador).

Somente o sinal e os três menores três bits do quociente têm garantia de precisão.

Ela é útil para implementar funções periódicas. Os três bits baixos do quociente dão ao quadrante e o restante a distância dentro dele. Por exemplo, uma implementação de sin(x) pode chamar remquo(x, PI / 2.f, &quadrant) para reduzir um valor muito grande de x a algo dentro de um intervalo limitado.

Exemplo: remquo(-23.5f, 8.f, &quot) define os três bits mais baixos de quot para 3 e o sinal negativo. Ela retorna 0,5f.

rint : arredondar para par

float rint(float v);
float2 rint(float2 v);
float3 rint(float3 v);
float4 rint(float4 v);
half rint(half v); Adicionado no nível 24 da API.
half2 rint(half2 v); Adicionado no nível 24 da API.
half3 rint(half3 v); Adicionado no nível 24 da API.
half4 rint(half4 v); Adicionado no nível 24 da API.

Arredonda para o valor integral mais próximo.

rint() arredonda meios valores para par. Por exemplo, rint(0.5f) retorna 0.f e rint(1.5f) retorna 2.f. Da mesma forma, rint(-0.5f) retorna -0.f e rint(-1.5f) retorna -2.f.

round() é semelhante, mas arredonda o valor de zero. trunc() trunca a fração decimal.

rootn : raiz 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(half v, int n); Adicionado no nível 24 da API.
half2 rootn(half2 v, int2 n); Adicionado no nível 24 da API.
half3 rootn(half3 v, int3 n); Adicionado no nível 24 da API.
half4 rootn(half4 v, int4 n); Adicionado no nível 24 da API.

Calcular a raiz N de um valor.

Consulte também native_rootn().

round : arredondamento a partir de zero

float round(float v);
float2 round(float2 v);
float3 round(float3 v);
float4 round(float4 v);
half round(half v); Adicionado no nível 24 da API.
half2 round(half2 v); Adicionado no nível 24 da API.
half3 round(half3 v); Adicionado no nível 24 da API.
half4 round(half4 v); Adicionado no nível 24 da API.

Arredonde para o valor integral mais próximo.

round() arredonda metades de valores para longe de zero. Por exemplo, round(0.5f) retorna 1.f e round(1.5f) retorna 2.f. Da mesma forma, round(-0.5f) retorna -1.f e round(-1.5f) retorna -2.f.

rint() é semelhante, mas arredonda metade dos valores para par. trunc() trunca a fração decimal.

rsClamp : restringir um valor a um intervalo

char rsClamp(quantidade de caracteres, caracteres baixos, altos caracteres);
int rsClamp(int amount, int low, int high);
short rsClamp(curto, baixo, baixo alto);
uchar rsClamp(quantidade de uchar, uchar baixo, uchar alto);
uint rsClamp(valor de uint, uint baixo, uint alto);
ushort rsClamp(valor ushort, ushort baixo, ushort alto);
Parâmetros
valorValor a ser fixado.
baixoLimite inferior.
altoLimite superior.

Obsoleto. Use clamp().

Defina um valor entre baixo e alto.

rsFrac : retorna a parte fracionária de um ponto flutuante

float rsFrac(float v);

Obsoleto. Use fract().

Retorna a parte fracionária de um ponto flutuante

rsRand : número pseudoaleatório

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

Retorne um valor aleatório entre 0 (ou min_value) e max_malue.

rsqrt : recíproco de uma raiz quadrada

float rsqrt(float v);
float2 rsqrt(float2 v);
float3 rsqrt(float3 v);
float4 rsqrt(float4 v);
half rsqrt(half v); Adicionado no nível 24 da API.
half2 rsqrt(half2 v); Adicionado no nível 24 da API.
half3 rsqrt(half3 v); Adicionado no nível 24 da API.
half4 rsqrt(half4 v); Adicionado no nível 24 da API.

Retorna (1 / sqrt(v)).

Veja também half_rsqrt(), native_rsqrt().

sign : sinal de um valor

float sign(float v);
Sinal float2(float2 v);
Sinal float3(float3 v);
Sinal float4(float4 v);
half sinal(half v); Adicionado no nível 24 da API.
half2 sign(half2 v); Adicionado no nível 24 da API.
half3 sign(half3 v); Adicionado no nível 24 da API.
half4 sign(half4 v); Adicionado no nível 24 da API.

Retorna o sinal de um valor.

if (v < 0) Return -1.f; else if (v > 0) retornará 1.f; else retornará 0.f;

sin : seno

float sin(float v);
float2 sin(float2 v);
float3 sin(float3 v);
float4 sin(float4 v);
half sin(half v); Adicionado no nível 24 da API.
half2 sin(half2 v); Adicionado no nível 24 da API.
half3 sin(half3 v); Adicionado no nível 24 da API.
half4 sin(half4 v); Adicionado no nível 24 da API.

Retorna o seno de um ângulo medido em radianos.

Consulte também native_sin().

sincos : seno e cosseno

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(metade v, metade* cos); Adicionado no nível 24 da API.
half2 sincos(half2 v, half2* cos); Adicionado no nível 24 da API.
half3 sincos(half3 v, half3* cos); Adicionado no nível 24 da API.
half4 sincos(half4 v, half4* cos); Adicionado no nível 24 da API.
Parâmetros
vValor de entrada em radianos.
cos*cos será definido como o valor do cosseno.
Returns
Seno de v.

Retorna o seno e o cosseno de um valor.

Consulte também native_sincos().

sinh : seno hiperbólico

float sinh(float v);
float2 sinh(float2 v);
float3 sinh(float3 v);
float4 sinh(float4 v);
half sinh(half v); Adicionado no nível 24 da API.
half2 sinh(half2 v); Adicionado no nível 24 da API.
half3 sinh(half3 v); Adicionado no nível 24 da API.
half4 sinh(half4 v); Adicionado no nível 24 da API.

Retorna o seno hiperbólico de v, em que v é medido em radianos.

Veja também native_sinh().

sinpi : seno de um número multiplicado por pi

float sinpi(float v);
float2 sinpi(float2 v);
float3 sinpi(float3 v);
float4 sinpi(float4 v);
half sinpi(half v); Adicionado no nível 24 da API.
half2 sinpi(half2 v); Adicionado no nível 24 da API.
half3 sinpi(half3 v); Adicionado no nível 24 da API.
half4 sinpi(half4 v); Adicionado no nível 24 da API.

Retorna o seno de (v * pi), em que (v * pi) é medido em radianos.

Para encontrar o seno de um valor medido em graus, chame sinpi(v / 180.f).

Consulte também native_sinpi().

sqrt : raiz quadrada

float sqrt(float v);
float2 sqrt(float2 v);
float3 sqrt(float3 v);
float4 sqrt(float4 v);
half sqrt(half v); Adicionado no nível 24 da API.
half2 sqrt(half2 v); Adicionado no nível 24 da API.
half3 sqrt(half3 v); Adicionado no nível 24 da API.
half4 sqrt(half4 v); Adicionado no nível 24 da API.

Retorna a raiz quadrada de um valor.

Consulte também half_sqrt(), native_sqrt().

step : 0 se for menor que um valor. Caso contrário, 1

float step(float Edge, float v);
float2 passo(flutuação, float2 v); Adicionado no nível 21 da API.
float2 passo(float2 borda, flutuação v);
float2 passo(float2 borda, float2 v);
float3 passo(flutuação, float3 v); Adicionado no nível 21 da API.
float3 passo(float3 borda, flutuação v);
float3 etapa(float3 borda, float3 v);
float4 passo(flutuação, float4 v); Adicionado no nível 21 da API.
float4 passo(float4 borda, flutuação v);
float4 etapa(float4 borda, float4 v);
half passo(meia borda, metade v); Adicionado no nível 24 da API.
half2 step(metade borda, half2 v); Adicionado no nível 24 da API.
half2 passo(half2 borda, half v); Adicionado no nível 24 da API.
half2 passo(half2 borda, half2 v); Adicionado no nível 24 da API.
half3 step(metade borda, half3 v); Adicionado no nível 24 da API.
half3 step(half3 Edge, half v); Adicionado no nível 24 da API.
half3 passo(half3 borda, half3 v); Adicionado no nível 24 da API.
half4 step(metade borda, half4 v); Adicionado no nível 24 da API.
half4 step(half4 Edge, half v); Adicionado no nível 24 da API.
half4 step(half4 Edge, half4 v); Adicionado no nível 24 da API.

Retorna 0.f se v < borda. Caso contrário, retorna 1.f.

Isso pode ser útil para criar cálculos condicionais sem usar loops e instruções de ramificação. Por exemplo, em vez de calcular (a[i] < b[i]) ? 0.f : atan2(a[i], b[i]) para os elementos correspondentes de um vetor, use step(a, b) * atan2(a, b).

tan : Tangente

float tan(float v);
float2 tan(float2 v);
float3 tan(float3 v);
float4 tan(float4 v);
half tan(metade v); Adicionado no nível 24 da API.
half2 tan(half2 v); Adicionado no nível 24 da API.
half3 tan(half3 v); Adicionado no nível 24 da API.
half4 tan(half4 v); Adicionado no nível 24 da API.

Retorna a tangente de um ângulo medido em radianos.

Consulte também native_tan().

tanh : tangente hiperbólica

float tanh(float v);
float2 tanh(float2 v);
float3 tanh(float3 v);
float4 tanh(float4 v);
half tanh(metade v); Adicionado no nível 24 da API.
half2 tanh(half2 v); Adicionado no nível 24 da API.
half3 tanh(half3 v); Adicionado no nível 24 da API.
half4 tanh(half4 v); Adicionado no nível 24 da API.

Retorna a tangente hiperbólica de um valor.

Consulte também native_tanh().

tanpi : tangente de um número multiplicado por pi

float tanpi(float v);
float2 tanpi(float2 v);
float3 tanpi(float3 v);
float4 tanpi(float4 v);
half tanpi(half v); Adicionado no nível 24 da API.
half2 tanpi(half2 v); Adicionado no nível 24 da API.
half3 tanpi(half3 v); Adicionado no nível 24 da API.
half4 tanpi(half4 v); Adicionado no nível 24 da API.

Retorna a tangente de (v * pi), em que (v * pi) é medido em radianos.

Para descobrir a tangente de um valor medido em graus, chame tanpi(v / 180.f).

Consulte também native_tanpi().

tgamma : função gama

float tgamma(float v);
float2 tgamma(float2 v);
float3 tgamma(float3 v);
float4 tgamma(float4 v);
metade tgamma(metade v); Adicionado no nível 24 da API.
half2 tgamma(half2 v); Adicionado no nível 24 da API.
half3 tgamma(half3 v); Adicionado no nível 24 da API.
half4 tgamma(half4 v); Adicionado no nível 24 da API.

Retorna a função gama de um valor.

Veja também lgamma().

trunc : trunca um ponto flutuante

float trunc(float v);
float2 trunc(float2 v);
float3 trunc(float3 v);
float4 trunc(float4 v);
half trunc(metade v); Adicionado no nível 24 da API.
half2 trunc(half2 v); Adicionado no nível 24 da API.
half3 trunc(half3 v); Adicionado no nível 24 da API.
half4 trunc(half4 v); Adicionado no nível 24 da API.

Arredonda para integral usando truncamento.

Por exemplo, trunc(1.7f) retorna 1.f e trunc(-1.7f) retorna -1.f.

Consulte rint() e round() para ver outras opções de arredondamento.