[Java] Wanneer geeft double NaN value?

[Verwijderd]

Ik heb hier een programma wat iets te groot is om te plaatsen. Het is iig een (economische) simulatie dat meerdere periodes afwerkt. Na een x aantal periodes geeft de output alleen geen getallen meer, maar NaN (not a number) waardes. De huidige periode maakt gebruik van de gegevens van voorgaande periodes en zou dus in principe alleen met doubles moeten werken. Het bereik van doubles is veel groter dan de getallen waar het hier om gaat (van ongeveer -300 tot +300), dus dat lijkt het niet te zijn.

Nu vroeg ik me dus af, wanneer geeft java een NaN value? Doet ie dat ook als er te veel getallen achter de komma staan (dus kapt ie dat niet gewoon af?)? Doet ie dat als er door nul gedeelt wordt (dan levert toch een exceptie op?)?

Kortom, waar komt NaN vandaan en waar moet ik dus naar gaan zoeken?

[curry684]

Java conformeert voor NaN's aan IEEE 754 met het onsubtiele verschil dat ie alle verschillende types NaN op 1 hoop gooit en tot 'NaN' bombardeert:

quote: http://research.microsoft...dex/coding/ieeefloat.html

Not A Number
The value NaN (Not a Number) is used to represent a value that does not represent a real number. NaN's are represented by a bit pattern with an exponent of all 1s and a non-zero fraction. There are two categories of NaN: QNaN (Quiet NaN) and SNaN (Signalling NaN).

A QNaN is a NaN with the most significant fraction bit set. QNaN's propagate freely through most arithmetic operations. These values pop out of an operation when the result is not mathematically defined.

An SNaN is a NaN with the most significant fraction bit clear. It is used to signal an exception when used in operations. SNaN's can be handy to assign to uninitialized variables to trap premature usage.

Semantically, QNaN's denote indeterminate operations, while SNaN's denote invalid operations.

Iets lager op die pagina staat ook een tabel met voorbeelden van wanneer NaN optreedt. 0/0 is theoretisch wel degelijk een geldige NaN afhankelijk van de context, maar infinity-infinity is ook een leuke

[ Voor 10% gewijzigd door curry684 op 27-02-2004 13:07 ]

[Verwijderd]

Ok bedankt, dat is dus de theorie . Maar wat is nu het praktijk verschil tussen een ondefineerbare en een ongeldige operatie? Kortom, waar moet ik aan denken? Toch delen door 0?

ah je edit al stiekem zie ik, ik ga nog ff lezen daar dan

[ Voor 15% gewijzigd door Verwijderd op 27-02-2004 13:13 ]

[curry684]

Verwijderd schreef op 27 februari 2004 @ 13:13:
Ok bedankt, dat is dus de theorie . Maar wat is nu het praktijk verschil tussen een ondefineerbare en een ongeldige operatie? Kortom, waar moet ik aan denken? Toch delen door 0?

ah je edit al stiekem zie ik, ik ga nog ff lezen daar dan

Delen door 0 en wortel -5 zijn ongeldig, terwijl bijvoorbeeld oneindig - oneindig ongedefinieerd is (als de eerste groter is is het plus oneindig, anders min oneindig, en dat schiet niet echt op )

[Verwijderd]

ah natuurlijk dat is vrij logisch .

edit: het probleem gevonden, het was inderdaad toch een deling door 0. Thanx!!

[ Voor 53% gewijzigd door Verwijderd op 27-02-2004 13:31 ]

[kasper_vk]

Inmiddels is deze opmerking niet echt meer van belang... .. maar toch:

Ik denk dat wortel -5 niet NaN opleverd, maar een IllegalArgumentException, waardoor bij

Java:

float a = -5;
float b= 0;

b = Math.rqrt( a );

de waarde van b ongewijzigd blijft.

[.oisyn]

curry684 schreef op 27 februari 2004 @ 13:24:
[...]

Delen door 0 en wortel -5 zijn ongeldig

correctie, een deling door 0 geeft oneindig, wat natuurlijk wat anders is dan een NaN
(daarmee verder rekenen resulteert vaak wel in een NaN, zoals je al zei)

[ Voor 25% gewijzigd door .oisyn op 27-02-2004 13:51 ]

[Robtimus]

kasper_vk schreef op 27 februari 2004 @ 13:34:
Inmiddels is deze opmerking niet echt meer van belang... .. maar toch:

Ik denk dat wortel -5 niet NaN opleverd, maar een IllegalArgumentException, waardoor bij

Java:

double a = -5;
double b= 0;
b = Math.sqrt( a );

de waarde van b ongewijzigd blijft.

Na een System.out.println(b) komt er gewoon NaN te staan. Eerst testen voordat je een bewering doet?

.oisyn schreef op 27 februari 2004 @ 13:50:
[...]


correctie, een deling door 0 geeft oneindig, wat natuurlijk wat anders is dan een NaN

Ja, maar welke oneindig?

[kasper_vk]

Ooops, je hebt helemaal gelijk.
Ondanks dat ik dat dus erg onlogisch vindt; de wortel van een nagatief getal wordt een complex getal; NaN dus.
Ik zou zeggen dat je dus verkeerde invoer geeft; door NaN terug te geven suggereert Java in mijn ogen dat er een CPU instructie is uitgevoerd die NaN als resultaat gaf; voor worteltrekken bestaat echter geen instructie en de wortel wordt dus door logica bepaald (Talylor reeksen ), waarin een negatief getal geen geldige invoer is.

Voor de voledigheid: API documenttatie Math.sqrt(double)

[MSalters]

CPU instructie of algoritme is een onzinnig verschil; als een CPU geen bitshift kent dan zou Java dus een NaN moeten opleveren voor <<i, terwijl het algoritme * 2ⁱ gewoon werkt? Lekker portable.

[RayNbow]

kasper_vk schreef op 27 februari 2004 @ 14:15:
Ooops, je hebt helemaal gelijk.
Ondanks dat ik dat dus erg onlogisch vindt; de wortel van een nagatief getal wordt een complex getal; NaN dus.
Ik zou zeggen dat je dus verkeerde invoer geeft; door NaN terug te geven suggereert Java in mijn ogen dat er een CPU instructie is uitgevoerd die NaN als resultaat gaf; voor worteltrekken bestaat echter geen instructie en de wortel wordt dus door logica bepaald (Talylor reeksen ), waarin een negatief getal geen geldige invoer is.

Voor de voledigheid: API documenttatie Math.sqrt(double)

De square root geeft gewoon NaN terug voor negatieve getallen, omdat deze functie alleen werkt met Reele getallen

Maar eh, voel je vrij om met de Math methoden een klasse te schrijven voor de Complexe getallen

[.oisyn]

IceManX schreef op 27 februari 2004 @ 13:52:
Ja, maar welke oneindig?

Het teken van de teller
Even ter aanvulling, een log (0) zou negatief oneindig moeten geven

kasper_vk schreef op 27 februari 2004 @ 14:15:
Ooops, je hebt helemaal gelijk.
Ondanks dat ik dat dus erg onlogisch vindt; de wortel van een nagatief getal wordt een complex getal; NaN dus.
Ik zou zeggen dat je dus verkeerde invoer geeft; door NaN terug te geven suggereert Java in mijn ogen dat er een CPU instructie is uitgevoerd die NaN als resultaat gaf; voor worteltrekken bestaat echter geen instructie en de wortel wordt dus door logica bepaald (Talylor reeksen ), waarin een negatief getal geen geldige invoer is.

oh, wat doet de assembly instructie fsqrt op de x87 dan volgens jou?
Overigens heeft dit helemaal niets te maken met of het wel of geen instructie is, dat doet er namelijk niet toe. Een negatieve wortel zou geen illegal argument moeten zijn, het kan namelijk wel degelijk. Complexe getallen zijn niet voor niets uitgevonden (en ja, dan is het dus Not a Number)