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
numerador | Numerador. |
---|---|
denominador | Denominador. 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
numerador | Numerador. |
---|---|
denominador | Denominador. 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
value | Valor a ser fixado. |
---|---|
valor_mínimo | Limite inferior, um vetor escalar ou correspondente. |
valor_máximo | Limite 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
v | Valor de entrada. |
---|---|
andar | Se 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
v | Valor de entrada. |
---|---|
expoente | Se o expoente não for nulo, o *expoente será definido como o expoente de v. |
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. |
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
Mantissa | Mantissa. |
---|---|
expoente | Expoente, 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_gama | Se 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. |
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
v | Valor 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
v | Nã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
numerador | Numerador. |
---|---|
denominador | Denominador. 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
numerador | Numerador. |
---|---|
denominador | Denominador. 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. |
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
base | Precisa estar entre 0,f e 256,f. A função não é precisa para valores muito próximos de zero. |
---|---|
expoente | Precisa 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
v | Valor 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. |
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. |
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. |
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
numerador | Numerador. |
---|---|
denominador | Denominador. |
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, ")
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
valor | Valor a ser fixado. |
---|---|
baixo | Limite inferior. |
alto | Limite 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
v | Valor 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. |
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. |