Floating points (kommagetallen)

Floating point getallen zijn kommagetallen. Je zou je kunnen afvragen waarom er meer dan één data type is om getallen op te slaan (met of zonder komma), maar dat is omdat een computer veel sneller met gehele getallen kan werken dan met kommagetallen. Daarom dat er een onderscheid tussen de beide wordt gemaakt. Als je weet dat je enkel met gehele getallen zal werken gebruik je een integer data type, als je met kommagetallen gaat werken gebruik je een floating point data type, zoals beschreven in dit artikel.

Een floating point variabele gebruiken is even simpel als een integer gebruiken, maar er zijn wel een aantal extra zaken waar je rekening mee moet houden die we later bespreken. Laat ons nu even kijken hoe we een van de meest gebruikte floating point data types declareren: de double.

double number;

Net als bij een integer kan je ook hier onmiddelijk een waarde toekennen aan de variabele tijdens het declareren:

double number = 42.0;

Hetzelfde is ook waar voor de types float en decimal, die we dadelijk verder bekijken. De notatie van de de waarde is hier wel iets anders:

double doubleVal = 42.0;
float floatVal = 42.0f;
decimal decimalVal = 42.0m;

Zie je de "f" en "m" op het einde van de waarden - deze maken de compiler duidelijk dat we een float of een decimal waarde ingeven. Zonder de letter op het einde zal C# de getallen als double interpreteren en die kan niet automatisch omgezet worden naar een float of decimal.

float, double of decimal?

Werken met floating point waarden tijdens het programmeren heeft altijd al voor veel vragen en bezorgdheid geleid. Zo heeft C# minstens 3 data types om te werken met kommagetallen:

• float (een alias voor System.Single)
• double (een alias voor System.Double)
• decimal (een alias voor System.Decimal)

Het onderliggende verschil is moeilijk te begrijpen, tenzij je een grote kennis hebt over hoe een computer dit intern verwerkt, wij concentreren ons op de meer praktische zaken.

Het grote verschil tussen de float, double en decimal data types zit hem in de precisie en daar aan gekoppeld ook hoeveel geheugen nodig is om de waarden op te slaan. De float is de kleinste van de 3, je kan er een getal in opslaan met 7 cijfers. Bij de double zijn dit 16 cijfers en bij de decimal zijn het er maximaal 29.

Deze precisie is vaak belangrijk bij wiskundige berekeningen. Het klassieke voorbeeld om het verschil te begrijpen is 10 delen door 3. De meesten van ons zullen dit in ons hoofd berekenen en zeggen dat het resultaat 3,33 is, maar eigenlijk is dit niet volledig accuraat. Het echte antwoord is 3,33 gevolgd door een aantal extra 3'en. Hoeveel extra 3'en (als je de berekening uitvoert met C#) wordt bepaald door het data type. Kijk even naar dit voorbeeld:

float a = 10f / 3;
Console.WriteLine(a);
double b = 10d / 3;
Console.WriteLine(b);
decimal c = 10m / 3;
Console.WriteLine(c);

Ik doe 3 keer dezelfde berekening, maar met verschillende data types. Het resultaat ziet er als volgt uit:

a: 3.333333
b: 3.33333333333333
c: 3.3333333333333333333333333333

Het verschil is duidelijk, maar hoeveel precisie heb je nu juist nodig voor de meeste berekeningen?

Hoe te kiezen

Allereerst moet je in rekening brengen hoeveel cijfers je moet opslaan. Een float kan slecht 7 cijfers bevatten, dus als een groter getal nodig hebt dan dat, kan je een double of een float gebruiken.

Ten tweede zullen zowel de float en de double een waarde bij benadering weergeven, het kan dus zijn dat deze waarden niet tot op het laatste cijfer vergelijkbaar zijn. Hoe meer berekeningen je dus doet met deze variabelen, hoe groter de kans dat er afwijkingen ontstaan. Dit kan er toe leiden dat 2 waarden die eigenlijk hetzelfde zouden moeten zijn plots niet meer hetzelfde zijn.

In gevallen waar precisie van groot belang is, gebruik je best altijd het decimal type. Een goed voorbeeld hiervan is bij de weergave van financiële cijfers (geld). Je wil geen 10 hoeveelheden toevoegen aan je boekhouding om dan achteraf te concluderen dat het resultaat niet is wat je verwachtte. Als performantie echter belangrijker is, gebruik je beter de float (voor kleine getallen) of de double (voor grotere getallen). Een decimal is (door de extre precisie) veel trager dan een float om berekening meet uit te voeren. Sommige testen tonen aan dat dit tot 20 keer trager kan zijn.

Samenvatting

Als je werkt met floating point waarden, gebruik je best een float of een double data type als snelheid belangrijker is dan precisie. Als je echter maximale precisie wenst gebruik je best het decimal type, zeker als je werkt met financiële data.

Als je meer wil weten over de onderliggende verschillen tussen deze data types kan altijd het volgende artikel even lezen: What Every Computer Scientist Should Know About Floating-Point Arithmetic