Compartilhar via

Regras de ponto flutuante (Direct3D 10)

  • Artigo

O Direct3D 10 dá suporte a várias representações de ponto flutuante diferentes. Todas as computações de ponto flutuante operam sob um subconjunto definido do comportamento de ponto flutuante de precisão única do IEEE 754 de 32 bits.

Regras de Floating-Point de 32 bits

Existem dois conjuntos de regras: aquele em conformidade com IEEE-754, e aquele que desvia do padrão.

Regras honradas do IEEE-754

Algumas dessas regras são uma única opção onde a IEEE-754 oferece opções.

  • Divisão por 0 produz + /-INF, exceto 0/0, o que resulta em NaN.
  • o log de (+/-) 0 produz -INF. o log de um valor negativo (diferente de -0) produz NaN.
  • A raiz quadrada recíproca (rsq) ou raiz quadrada (sqrt) de um número negativo produz NaN. A exceção é - 0; sqrt(-0) produz - 0 e rsq(-0) produz -INF.
  • INF - INF = NaN
  • (+/-)INF / (+/-)INF = NaN
  • (+/-) INF * 0 = NaN
  • Qualquer valor NaN (qualquer OP) = NaN
  • As comparações EQ, GT, GE, LT e LE, quando um ou ambos operandos for NaN retornará FALSE.
  • As comparações ignoram o sinal de 0 (sendo assim, +0 igual -0).
  • A comparação NE, quando um ou ambos operandos for NaN retornará TRUE.
  • As comparações de qualquer valor não NaN com +/-INF retornam o resultado correto.

Desvios ou requisitos adicionais de regras do IEEE-754

  • O IEEE-754 exibe que as operações de ponto flutuante produzam um resultado que seja o valor representável mais próximo a um resultado infinitamente preciso, conhecido como valor arredondado para o número par mais próximo. O Direct3D 10, no entanto, define um requisito mais flexível: as operações de ponto flutuante de 32 bits produzem um resultado que está dentro de uma ULP (unidade de último lugar) do resultado infinitamente preciso. Isso significa que, por exemplo, o hardware tem permissão de truncar resultados em 32 bits, em vez de executar o arredondamento para o número par mais próximo, uma vez que isso resultaria em um erro de no máximo 1 ULP.
  • Não há nenhum suporte para exceções de ponto flutuante, bits de status ou interrupções.
  • Denorms são liberadas para zero com sinal preservado na entrada e saída de qualquer operação matemática de ponto flutuante. Exceções são feitas para qualquer operação de movimentação de dados ou de E/S que não manipula os dados.
  • Estados que contêm valores de ponto flutuante, como Viewport MinDepth/MaxDepth, valores BorderColor etc., podem ser fornecidos como valores de desnorm e podem ou não ser liberados antes do uso pelo hardware.
  • As operações de mínimo ou máximo liberam denorms para a comparação, mas o resultado pode ou não ser um denorm liberado.
  • A entrada naN para uma operação sempre produz NaN na saída, no entanto, o padrão de bit exato do NaN não é necessário para permanecer o mesmo (a menos que a operação seja uma instrução de movimentação bruta - que não altera dados em tudo).)
  • Operações mínimas ou máximas para as quais apenas um operando é NaN retornam o outro operando como resultado (ao contrário das regras de comparação acima). Essa é uma nova regra IEEE (IEEE 754R), necessária no Direct3D 10.
  • Outra nova regra do IEEE 754R é que min(-0,+0) == min(+0,-0) == -0 e max(-0,+0) == max(+0,-0) == +0, que respeitam o sinal, em contraste com as regras de comparação para zero assinado (declarado acima). O Direct3D 10 recomenda o comportamento do IEEE 754R aqui, mas ele não será imposto; é permitido que o resultado da comparação de zeros dependa da ordem dos parâmetros, usando uma comparação que ignora os sinais.
  • x*1.0f sempre resulta em x (exceto desnorm liberado).
  • x/1.0f sempre resulta em x (exceto denorm liberados).
  • x +/- 0.0f sempre resulta em x (exceto denorm liberados). Mas -0 + 0 = +0.
  • As operações fundidas (como mad, dp3) produzem resultados que não são menos precisos do que a pior ordem serial possível da avaliação da expansão não fundida da operação. Observe que a definição da pior ordenação possível, para fins de tolerância, não é uma definição fixa para uma determinada operação fundida; depende dos valores específicos das entradas. As etapas individuais na expansão não infundida são permitidas 1 tolerância ulp (ou para qualquer instrução que o Direct3D 10 chama com uma tolerância mais frouxa do que 1 ULP, a tolerância mais frouxa é permitida).
  • As operações fundidas cumprem as mesmas regras NaN que as operações não fundidas.
  • Multiplicar e dividir cada operação no nível de precisão de ponto flutuante de 32 bits (precisão para 1 ULP).

Regras de Floating-Point de 16 bits

O Direct3D 10 também dá suporte a representações de 16 bits de números de ponto flutuante.

Formato:

  • Sinal de 1 bit (s) na posição MSB bit
  • 5 bits de expoente ajustado (e)
  • 10 bits de fração (f), com um bit oculto adicional

Um valor float16 (v) segue as seguintes regras:

  • Se e == 31 e f != 0, então v é NaN independente de s
  • if e == 31 and f == 0, then v = (-1)s*infinity (signed infinity)
  • se e estiver entre 0 e 31, v = (-1)s*2(e-15)*(1.f)
  • if e == 0 and f != 0, then v = (-1)s*2(e-14)*(0.f) (números desnormalizados)
  • if e == 0 and f == 0, then v = (-1)s*0 (signed zero)

As regras de ponto flutuante de 32 bits também são mantidas para números de ponto flutuante de 16 bits, ajustados para o layout de bit descrito acima. Algumas exceções:

  • Precisão: as operações não fundidas em números de ponto flutuante de 16 bits produzem um resultado que é o valor representável mais próximo de um resultado infinitamente preciso (arredondado para o número par mais próximo, de acordo com IEEE-754, aplicado aos valores de 16 bits). As regras de ponto flutuante de 32 bits aderem à tolerância de 1 ULP, as regras de ponto flutuante de 16 bits aderem a 0,5 ULP para as operações não fundidas e 0,6 ULP para operações fundidas.
  • Os números de ponto flutuante de 16 bits preservam denorms.

Regras de Floating-Point de 11 bits e 10 bits

O Direct3D 10 também dá suporte a formatos de ponto flutuante de 11 bits e 10 bits.

Formato:

  • Nenhum bit de sinal
  • 5 bits de expoente ajustado (e)
  • 6 bits de fração (f) para um formato de 11 bits, 5 bits de fração (f) para um formato de 10 bits, com um bit oculto adicional em ambos os casos.

Um valor de float11/float10 (v) segue as regras a seguir:

  • se e == 31 and f != 0, então v é NaN
  • se e == 31 e f == 0, então v = +infinito
  • se e estiver entre 0 e 31, v = 2(e-15)*(1.f)
  • se e == 0 e f != 0, então v = *2(e-14)*(0.f) (números desnormalizados)
  • se e == 0 e f == 0, então v = 0 (zero)

As regras de ponto flutuante de 32 bits também são mantidas para números de ponto flutuante de 11 bits e 10 bits, ajustados para o layout de bit descrito acima. As exceções incluem:

  • Precisão: as regras de ponto flutuante de 32 bits aderem a 0,5 ULP.
  • Os números de ponto flutuante de 10/11 bits preservam denorms.
  • Qualquer operação que resulte em um número menor que zero é fixada a zero.

Recursos (Direct3D 10)