kB naar KiB omrekenen

Een kilobyte is 1.000 bytes als een normalisatie-instituut hem definieert en 1.024 als een besturingssysteem dat doet. Deze pagina rekent met 1.000; de eenheid van 1.024 heet kibibyte.

Een kibibyte is precies 1.024 bytes. De naam is in 1998 ingevoerd zodat «kilobyte» weer 1.000 kon betekenen, al is de gewoonte nooit helemaal aangeslagen.

De factor is 0,976563, en die draagt vrijwel niemand met zich mee. Afgerond op 0,98 zit hij er 0,35 % naast — bij kleine getallen onzichtbaar, en rond 1.000 kB een hele eenheid.

Dat is het getal dat je vóór het afronden wilt weten: niet de fout zelf, maar vanaf waar hij ophoudt verwaarloosbaar te zijn. Daaronder is de korte factor de verstandige; daarboven gebruik je het veld hierboven, dat pas afrondt op het moment van afdrukken.

Eén KiB is 1.024 van de eenheid eronder; één kB is 1.000. Op deze pagina is dat het verschil tussen 1,024 kB en 1 kB — 2,4 % — en het gat groeit bij elke stap omhoog: op een foto een verwaarloosbare afronding, op een harde schijf een zichtbaar stuk.

Hierin zit het raadsel van de verdwenen opslag volledig. Een schijf die als terabyte verkocht wordt bevat in decimale eenheden precies wat erop staat; Windows telt hem daarna in binaire eenheden maar houdt de decimale naam aan, en daar krimpt het getal zonder dat er iets weg is. macOS telt deze eenheden sinds 10.6 decimaal, en daarom kan dezelfde schijf op twee computers twee maten lijken.

Een kilobyte is duizend bytes als je het prefix serieus neemt, en 1.024 als je het neemt zoals software het sinds de jaren zestig gebruikt. Beide lezingen zijn nog in omloop, soms in dezelfde zin documentatie, en geen enkele kant heeft toegegeven. Het resultaat is dat een bestand van 500 kB door een zorgvuldig gereedschap wordt gerapporteerd als 488 KiB en door een onzorgvuldig als "488 KB", en geen van de drie cijfers is op eigen voorwaarden fout.

De omvang van het meningsverschil is wat dit paar lastig te merken maakt. Twaalf bytes hier, vierentwintig daar — het oogt als een afrondingsartefact, dus nemen mensen aan dat het ene gereedschap afkapt en stoppen ze met onderzoeken. Het is geen afronding. Elke byte is verantwoord; de twee gereedschappen delen gewoon door verschillende getallen, en die keuze is de hele inhoud van deze pagina.

1.024 is 2 tot de tiende macht. Geheugen wordt binair geadresseerd, dus ligt het aantal locaties dat een chip kan bereiken vast door hoeveel adreslijnen hij heeft: tien lijnen bereiken 1.024 locaties en er is geen bedrading die er 1.000 bereikt. Een geheugenonderdeel wordt daarom gebouwd en verkocht in machten van twee omdat dat de enige grootte is die het kan zijn, en dezelfde logica loopt door pagina-, blok- en buffergroottes doorheen een heel systeem.

Toen die hoeveelheden in de jaren zestig een naam nodig hadden, lag 1.024 binnen 2,4 procent van duizend en werd "kilo" geleend in plaats van uitgevonden. Dat was een redelijke keuze op een schaal waar de fout twee procent was en de machines een paar duizend woorden geheugen hadden. Het hield op redelijk te zijn toen hetzelfde geleende prefix de giga- en tera-stap bereikte, waar dezelfde redenering een kloof van 7,4 en 10 procent oplevert.

Vermenigvuldig de kilobytes met 1.000 om bytes te krijgen, deel dan door 1.024. 500 kB is 500.000 bytes, en 500.000 ÷ 1.024 is 488,28 KiB. In één stap is het een vermenigvuldiging met 0,9765625, wat exact is — het is 1.000 ÷ 1.024 en eindigt, dus hoeft geen omzetter af te ronden en komen twee correct werkende overeen tot zoveel cijfers als je wilt afdrukken.

De sanity check is dat het KiB-getal altijd het kleinere moet zijn. Elke kibibyte bevat meer bytes, dus zijn er minder nodig om hetzelfde bestand te bevatten. Is een omzetting in deze richting groter geworden, dan zijn de twee eenheden ergens verwisseld, wat de meest voorkomende fout in deze categorie is en de reden dat de omgekeerde pagina’s apart bestaan.

Het duidelijkste bewijs dat de twee systemen nooit netjes gescheiden zijn geweest, is een schijfje dat miljoenen mensen gebruikten. Een high-density diskette van 3,5 inch bevatte 1.474.560 bytes. Dat is 1.440 KiB, en iemand deelde nog eens door 1.000 om bij de "1,44 MB" te komen die op de doos stond — dus gebruikte het label een binaire kilobyte en een decimaal duizendtal in hetzelfde getal.

Volgens elke consistente meetlat is het cijfer fout: de schijf is 1,47 MB decimaal of 1,41 MiB binair, en 1,44 is geen van beide. Niemand loog; de twee conventies waren toen al zo verstrengeld dat een gemengde eenheid op tientallen miljoenen dozen gedrukt kon worden zonder dat iemand bezwaar maakte. Dat is de toestand waar de IEC-prefixen voor geschreven werden om te beëindigen.

In 1998 wijzigde de International Electrotechnical Commission IEC 60027-2 om kibi, mebi, gibi en tebi te definiëren, elk een samentrekking van het SI-prefix met "binary". De symbolen dragen een kleine i — KiB, MiB, GiB, TiB — en betekenen exact 1.024 en zijn machten. De definities leven nu in IEC 80000-13 en worden onderschreven door de betrokken nationale standaardenorganisaties.

De adoptie ging maar één kant op. Linux-tooling, verschillende buildsystemen en documentatie geschreven door wie ooit gebeten was, namen de prefixen aan; Windows niet, en veel consumentensoftware volgde Windows. De standaard slaagde er dus in de binaire eenheden een naam te geven en faalde in zijn eigenlijke doel, wat was "kilobyte" ondubbelzinnig duizend te laten betekenen. Zo’n twintig jaar later is de veiligste aanname bij het lezen van kB nog steeds geen aanname.

Opslag en netwerken zijn vrijwel zonder uitzondering decimaal: schijfcapaciteiten, overdrachtssnelheden en opgegeven abonnementsgroottes zijn allemaal machten van tien, en macOS rapporteert bestandsgroottes al decimaal sinds 2009. Geheugen is zonder uitzondering binair, vanwege de adressering hierboven. Al het andere is een muntworp beslist door wie het gereedschap schreef, en de eerlijke laten je weten wat ze kozen door KiB af te drukken in plaats van KB.

Een snelle manier om erachter te komen is iets om te zetten waarvan je de bytentelling al kent. Neem een bestand, lees de exacte grootte, en kijk wat het gereedschap rapporteert: toont het 10.240 bytes als 10, dan is het gereedschap binair; toont het 10.000 bytes als 10, dan is het decimaal. Dat kost een minuut en beslecht de vraag voor dat gereedschap permanent, wat meer waard is dan elke algemene regel over wie wat gebruikt.

Op één klein bestand is het verschil oprecht verwaarloosbaar, en het als ruis behandelen is het juiste technische oordeel. Het houdt op ruis te zijn in twee situaties: als het cijfer een limiet is, en als het vermenigvuldigd wordt. Een quotum van "500 kB per upload" afgedwongen als 500.000 bytes weigert een bestand waarvan de gebruiker te horen kreeg dat het 488 KiB was en dat 500.224 bytes is, en niets in beide getallen verklaart de weigering.

Vermenigvuldiging is de grotere valkuil omdat de fout mee de schaal op reist in plaats van te blijven staan. Dezelfde substitutie van 1.024 tegen 1.000 tweemaal toegepast is 4,9 procent, driemaal 7,4, viermaal 10. Een capaciteitsschatting opgebouwd door kilobytes te tellen en gerapporteerd in terabytes draagt de volle 10 procent, en tegen die tijd is het geen afrondingsfout meer maar het verschil tussen genoeg opslag bestellen en niet. De regel die het volledig vermijdt is de bytentelling als werkcijfer te bewaren en pas op het moment van weergave om te zetten, want een bytentelling die vier stappen van de ladder oversteekt kan geen percentagefout oplopen die er nooit op is toegepast.