Partilhar via

Regras de ponto flutuante (Direct3D 10)

  • Artigo

O Direct3D 10 suporta várias representações de ponto flutuante diferentes. Todos os cálculos de ponto flutuante operam sob um subconjunto definido do comportamento de ponto flutuante de precisão única IEEE 754 de 32 bits.

Regras de Floating-Point de 32 bits

Existem dois conjuntos de regras: as que estão em conformidade com o IEEE-754 e as que se desviam da norma.

Regras IEEE-754 honradas

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

  • Dividir por 0 produz +/- INF, exceto 0/0 que resulta em NaN.
  • log de (+/-) 0 produz -INF. 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
  • NaN (qualquer OP) qualquer-valor = NaN
  • As comparações EQ, GT, GE, LT e LE, quando um ou ambos os operandos é NaN retorna FALSE.
  • As comparações ignoram o sinal de 0 (portanto, +0 é igual a -0).
  • A comparação NE, quando um ou ambos os operandos é NaN retorna TRUE.
  • As comparações de qualquer valor não-NaN com +/- INF retornam o resultado correto.

Desvios ou requisitos adicionais das regras IEEE-754

  • O IEEE-754 requer operações de ponto flutuante para produzir um resultado que seja o valor representável mais próximo de um resultado infinitamente preciso, conhecido como arredondado para mais próximo-par. O Direct3D 10, no entanto, define um requisito mais flexível: operações de ponto flutuante de 32 bits produzem um resultado que está dentro de uma unidade-último-lugar (1 ULP) do resultado infinitamente preciso. Isso significa que, por exemplo, o hardware pode truncar os resultados para 32 bits em vez de executar round-to-nearest-even, pois isso resultaria em erro de no máximo um ULP.
  • Não há suporte para exceções de ponto flutuante, bits de status ou traps.
  • As denormas são liberadas para zero preservado no sinal de entrada e saída de qualquer operação matemática de ponto flutuante. Exceções são feitas para qualquer operação de E/S ou movimentação de dados que não manipule os dados.
  • Estados que contêm valores de ponto flutuante, como Viewport MinDepth/MaxDepth, valores BorderColor etc., podem ser fornecidos como valores denorm e podem ou não ser liberados antes do uso pelo hardware.
  • Operações mínimas ou máximas desnivelam desnormas para comparação, mas o resultado pode ou não ser desnormado.
  • 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 movimento bruto - que não altera os dados em tudo.)
  • Operações mínimas ou máximas para as quais apenas um operando é NaN retornam o outro operando como resultado (contrariamente às regras de comparação acima). Esta é uma nova regra IEEE (IEEE 754R), necessária no Direct3D 10.
  • Outra nova regra IEEE 754R é que min(-0,+0) == min(+0,-0) == -0, e max(-0,+0) == max(+0,-0) == +0, que honram o sinal, em contraste com as regras de comparação para zero assinado (indicado acima). O Direct3D 10 recomenda o comportamento IEEE 754R aqui, mas ele não será imposto; É admissível 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 denorm flushed).
  • x/1.0f sempre resulta em x (exceto denorm flushed).
  • x +/- 0,0f sempre resulta em x (exceto denorm flushed). Mas -0 + 0 = +0.
  • Operações fundidas (como mad, dp3) produzem resultados que não são menos precisos do que a pior ordem serial possível de avaliação da expansão não fundida da operação. Note-se que a definição do pior ordenamento possível, para efeitos de tolerância, não é uma definição fixa para uma dada operação fundida; depende dos valores particulares dos inputs. As etapas individuais na expansão não fundida são permitidas cada uma 1 tolerância ULP (ou para quaisquer instruções Direct3D 10 chama com uma tolerância mais lax do que 1 ULP, a tolerância mais lax é permitida).
  • As operações fundidas seguem as mesmas regras NaN que as operações não fundidas.
  • Multiplique e divida cada operação no nível de precisão de ponto flutuante de 32 bits (precisão de 1 ULP).

Regras de Floating-Point de 16 bits

O Direct3D 10 também suporta representações de 16 bits de números de vírgula flutuante.

Formato:

  • 1 bit de sinal (s) na posição de bit MSB
  • 5 bits de expoente tendencioso (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 independentemente de s
  • se e == 31 e f == 0, então v = (-1)s*infinito (infinito assinado)
  • se e estiver entre 0 e 31, então v = (-1)s*2(e-15)*(1.f)
  • se e == 0 e f != 0, então v = (-1)s*2(e-14)*(0.f) (números desnormalizados)
  • se e == 0 e f == 0, então v = (-1)s*0 (zero assinado)

As regras de ponto flutuante de 32 bits também são válidas para números de ponto flutuante de 16 bits, ajustadas para o layout de bits descrito acima. As exceções incluem:

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

Regras de Floating-Point de 11 bits e 10 bits

O Direct3D 10 também suporta formatos de ponto flutuante de 11 bits e 10 bits.

Formato:

  • Sem sinal bit
  • 5 bits de expoente tendencioso (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 float11/float10 (v) segue as seguintes regras:

  • se e == 31 e f != 0, então v é NaN
  • se e == 31 e f == 0, então v = +infinito
  • se e estiver entre 0 e 31, então 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 valem para números de ponto flutuante de 11 bits e 10 bits, ajustados para o layout de bits 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 as desnormas.
  • Qualquer operação que resulte em um número menor que zero, é presa a zero.

Recursos (Direct3D 10)