Delen via

regels voor drijvende komma

Direct3D ondersteunt verschillende kommagetallenrepresentaties. Alle berekeningen met vouwensgetallen worden uitgevoerd onder een gedefinieerde subset van de IEEE 754 32-bits vouwensgetalregels voor enkelvoudige precisie.

32-bits regels voor drijvende komma

Er zijn twee sets regels: regels die voldoen aan IEEE-754 en regels die afwijken van de standaard.

Gehonoreerde IEEE-754-regels

Sommige van deze regels zijn één optie waarbij IEEE-754 opties biedt.

  • Delen door 0 produceert +/- INF, behalve 0/0, wat resulteert in NaN.

  • logaritme van (+/-) 0 geeft -INF.  

    De logaritme van een negatieve waarde (anders dan -0) resulteert in NaN.

  • Reciproque vierkantswortel (rsq) of vierkantswortel (sqrt) van een negatief getal resulteert in NaN.  

    De uitzondering is -0; sqrt(-0) produceert -0 en rsq(-0) produceert -INF.

  • INF - INF = NaN

  • (+/-)INF / (+/-)INF = NaN

  • (+/-)INF * 0 = NaN

  • NaN (any OP) elke waarde = NaN

  • De vergelijkingen EQ, GT, GE, LT en LE, wanneer één of beide operanden NaN zijn, retourneren FALSE.

  • Vergelijkingen negeren het teken van 0 (dus +0 is gelijk aan -0).

  • De vergelijking NE retourneert TRUEwanneer een of beide operanden NaN is.

  • Vergelijkingen van een niet-NaN-waarde ten opzichte van +/- INF retourneren het juiste resultaat.

Afwijkingen of aanvullende vereisten van IEEE-754-regels

  • IEEE-754 vereist drijvende-kommabewerkingen om een resultaat te produceren dat de dichtstbijzijnde vertegenwoordigbare waarde is voor een oneindig nauwkeurig resultaat, ook wel round-to-nearest-even genoemd.

    Direct3D 11 en hoger definiëren dezelfde vereiste als IEEE-754: 32-bits drijvende-komma-bewerkingen produceren een resultaat dat zich binnen 0,5 laatste-eenheidspositie (ULP) van het oneindig nauwkeurige resultaat bevindt. Dit betekent dat hardware bijvoorbeeld de resultaten mag afkappen tot 32-bits in plaats van round-to-nearest-even uit te voeren, omdat dit tot een fout van maximaal 0,5 ULP zou leiden. Deze regel geldt alleen voor optellen, aftrekken en vermenigvuldigen.

    Eerdere versies van Direct3D definiëren een lossere vereiste dan IEEE-754: 32-bits drijvendekommabewerkingen produceren een resultaat dat zich binnen één eenheid laatste plaats (1 ULP) van het oneindig nauwkeurige resultaat bevindt. Dit betekent dat hardware bijvoorbeeld resultaten mag afkappen tot 32-bits in plaats van round-to-nearest-even uit te voeren, omdat dit tot een fout van maximaal één ULP zou leiden.

  • Er is geen ondersteuning voor drijvendekomma-uitzonderingen, status-bits of traps.

  • Denormalisaties worden bij invoer en uitvoer van een zwevendekommabewerking teruggebracht naar nul met behoud van het teken. Er worden uitzonderingen gemaakt voor een I/O- of gegevensverplaatsingsbewerking die de gegevens niet bewerkt.

  • Statussen die waarden voor drijvende komma bevatten, zoals Viewport MinDepth-/MaxDepth- of BorderColor-waarden, kunnen worden opgegeven als denormwaarden en kunnen al dan niet worden leeggemaakt voordat de hardware ze gebruikt.

  • Min- of max-bewerkingen verwijderen denormalisaties voor vergelijking, maar het resultaat kan wel of niet gedenormaliseerd worden.

  • NaN-invoer voor een bewerking produceert altijd NaN op uitvoer. Maar het exacte bitpatroon van de NaN is niet vereist om hetzelfde te blijven (tenzij de bewerking een onbewerkte verplaatsingsinstructie is - die geen gegevens wijzigt.)

  • Minimale of maximale bewerkingen waarvoor slechts één operand NaN is, retourneert de andere operand als resultaat (in tegenstelling tot vergelijkingsregels die we eerder hebben bekeken). Dit is een IEEE 754R-regel.

    De IEEE-754R-specificatie voor drijvendekommamin- en max-bewerkingen geeft aan dat als een van de invoerwaarden tot min of max een stille QNaN-waarde is, het resultaat van de bewerking de andere parameter is. Voorbeeld:

    min(x,QNaN) == min(QNaN,x) == x (same for max)

    Een revisie van de IEEE-754R-specificatie heeft een ander gedrag aangenomen voor min en max wanneer één invoer een 'signaling' SNaN-waarde versus een QNaN-waarde is:

    min(x,SNaN) == min(SNaN,x) == QNaN (same for max)

    Over het algemeen volgt Direct3D de standaarden voor rekenkundige bewerkingen: IEEE-754 en IEEE-754R. Maar in dit geval hebben we een afwijking.

    De rekenkundige regels in Direct3D 10 en hoger maken geen onderscheid tussen stille en signalerende NaN-waarden (QNaN versus SNaN). Alle NaN-waarden worden op dezelfde manier verwerkt. In het geval van min en max is het Direct3D-gedrag voor elke NaN-waarde vergelijkbaar met de manier waarop QNaN wordt verwerkt in de IEEE-754R-definitie. (Voor volledigheid: als beide invoer NaN is, wordt een NaN-waarde geretourneerd.)

  • Een andere IEEE 754R-regel is dat min(-0,+0) == min(+0,-0) == -0 en max(-0,+0) == max(+0,-0) == +0, waarbij het teken wordt gerespecteerd, in tegenstelling tot de vergelijkingsregels voor genummerde nul (zoals we eerder hebben gezien). Direct3D raadt hier het gedrag van IEEE 754R aan, maar dwingt dit niet af; het is toegestaan dat het resultaat van het vergelijken van nullen afhankelijk is van de volgorde van parameters, met behulp van een vergelijking die de tekens negeert.

  • x*1,0f resulteert altijd in x (behalve denorm leeggemaakt).

  • x/1,0f resulteert altijd in x (behalve denorm leeggemaakt).

  • x +/- 0,0f resulteert altijd in x (behalve denorm leeggemaakt). Maar -0 + 0 = +0.

  • Gefuseerde operaties (zoals mad, dp3) leveren resultaten op die niet minder nauwkeurig zijn dan de slechtst mogelijke seriële volgorde van de evaluatie van de ongefuseerde uitbreiding van de bewerking. De definitie van de slechtst mogelijke volgorde, met het oog op tolerantie, is geen vaste definitie voor een bepaalde gefuseerde bewerking; dit hangt af van de specifieke waarden van de invoer. De afzonderlijke stappen in de niet-samengevoegde expansie hebben elk een tolerantie van 1 ULP toegestaan (of voor instructies waarvoor Direct3D een ruimere tolerantie dan 1 ULP toekent, geldt de ruimere tolerantie).

  • Gefuseerde bewerkingen houden zich aan dezelfde NaN-regels als niet-gefuseerde bewerkingen.

  • sqrt en rcp hebben 1 ULP-tolerantie. De shader-instructies voor reciprociteit en omgekeerde vierkantswortel, rcp en rsq, hebben hun eigen afzonderlijke gerelaxeerde precisievereiste.

  • Vermenigvuldigen en delen gebeuren op het 32-bits precisieniveau van drijvende-kommaprecisie (nauwkeurigheid tot 0,5 ULP voor vermenigvuldigen, 1,0 ULP voor de reciproque). Als x/y rechtstreeks wordt geïmplementeerd, moeten de resultaten groter of gelijk zijn aan de nauwkeurigheid dan een methode in twee stappen.

drijvendekommaregels 64-bits (dubbele precisie)

Hardware- en weergavestuurprogramma's bieden optioneel ondersteuning voor drijvende komma met dubbele precisie. Als u ondersteuning wilt aangeven, stelt het stuurprogramma de DoublePrecisionFloatShaderOps van D3D11_FEATURE_DATA_DOUBLES in op TRUE wanneer u ID3D11Device::CheckFeatureSupport aanroept met D3D11_FEATURE_DOUBLES. Het stuurprogramma en de hardware moeten vervolgens alle instructies voor drijvende komma's met dubbele precisie ondersteunen.

Dubbele precisie-instructies volgen de IEEE 754R-gedragsvereisten.

Ondersteuning voor het genereren van gedenormaliseerde getallen is vereist voor dubbele precisiegegevens (geen flush-to-zero-gedrag). Instructies lezen gedenormaliseerde gegevens niet als een getekende nul, ze respecteren de denormalisatie waarde.

16-bits regels voor drijvende komma

Direct3D ondersteunt ook 16-bits weergaven van drijvendekommagetallen.

Opmaak:

  • 1 tekenbit(s) in de MSB-bitpositie
  • 5 bits van vertekende exponent (e)
  • 10 bits van een fractiebits (f), met een extra verborgen bit

Een float16-waarde (v) volgt deze regels:

  • als e == 31 en f != 0, is v NaN, ongeacht s
  • Wanneer e == 31 en f == 0, dan v = (-1)s*oneindigheid (ondertekende oneindigheid)
  • als e tussen 0 en 31 ligt, dan v = (-1)s*2(e-15)*(1.f)
  • als e == 0 en f != 0, dan v = (-1)s*2(e-14)*(0.f) (gedenormaliseerde getallen)
  • als e == 0 en f == 0, dan v = (-1)s*0 (ondertekend nul)

32-bits drijvende-kommaregels gelden ook voor 16-bits drijvende-kommanummers, aangepast aan de eerder beschreven bitindeling. Uitzonderingen hierop zijn:

  • Precisie: Niet-samengevoegde bewerkingen op 16-bits drijvendekommanummers produceren een resultaat dat de dichtstbijzijnde vertegenwoordigbare waarde is voor een oneindig nauwkeurig resultaat (afgerond op dichtstbijzijnde even, per IEEE-754, toegepast op 16-bits waarden). 32-bits drijvende-komma-nummers voldoen aan 1 ULP-tolerantie, 16-bits drijvende-komma-nummers voldoen aan 0,5 ULP-tolerantie voor niet-gefuseerde bewerkingen en 0,6 ULP-tolerantie voor gefuseerde bewerkingen.
  • 16-bits halfprecisie getallen behouden denormalen.

11-bits en 10-bits regels voor drijvende komma

Direct3D ondersteunt ook 11-bits en 10-bits drijvende-komma-indelingen.

Opmaak:

  • Geen tekenbit
  • 5 bits van vertekende exponent (e)
  • 6 bits van de breuk (f) voor een 11-bits formaat, 5 bits van de breuk (f) voor een 10-bits formaat, met in beide gevallen een extra verborgen bit.

Een float11/float10-waarde (v) volgt de volgende regels:

  • als e == 31 en f != 0, is v NaN
  • als e == 31 en f == 0, dan v = +oneindig
  • als e tussen 0 en 31 ligt, dan v = 2(e-15)*(1.f)
  • als e == 0 en f != 0, dan v = *2(e-14)*(0,f) (gedenormaliseerde getallen)
  • als e == 0 en f == 0, dan v = 0 (nul)

32-bits drijvende komma regels zijn ook van toepassing op 11-bits en 10-bits drijvende komma getallen, aangepast voor de bitindeling die eerder is beschreven. Uitzonderingen zijn:

  • Precisie: 32-bits regels voor drijvende komma voldoen aan 0,5 ULP.
  • 10/11-bit drijvende-kommagetallen behouden denormen.
  • Elke bewerking die tot een getal kleiner dan nul zou leiden, wordt vastgeklemd tot nul.

Bijlagen

Middelen

Texturen

 

 

  • Last updated on