Binaire getallen en gegevensrepresentatie

Een bit, een afkorting van binary digit, heeft een van twee waarden: 0 of 1. Hardware kan twee fysische toestanden betrouwbaar onderscheiden, zoals hoge en lage spanning, tegengestelde magnetisatierichtingen, of licht en geen licht. De geschreven cijfers beschrijven die toestanden; ze hoeven niet letterlijk in een apparaat voor te komen.

Tel de patronen

Elke nieuwe bit verdubbelt het aantal mogelijkheden. Twee bits hebben vier patronen: 00, 01, 10 en 11. Drie bits hebben er acht. In het algemeen geven $n$ bits $2^n$ patronen. Een nibble is 4 bits en een byte is 8 bits, dus heeft een byte 256 patronen. Een byte is op de meeste moderne computers ook de kleinste adresseerbare geheugeneenheid.

Om een verzameling waarden te coderen, kies je genoeg patronen voor elk element. Voor 26 letters geven vier bits maar 16 patronen; vijf bits geven er 32, dus zijn vijf bits genoeg. Voor 1.000 waarden geven negen bits 512 patronen en tien bits 1.024. Ongebruikte patronen zijn toegestaan. Met 16 bits zijn er 65.536 patronen en met 32 bits zijn er 4.294.967.296.

Het aantal patronen verschilt van het grootste getal zonder teken. Vier bits bieden 16 patronen, maar het tellen begint bij nul, dus lopen de waarden van 0 tot en met 15. Eén patroon wordt al voor nul gebruikt.

Om de minimale bitbreedte systematisch te bepalen, vergelijk je opeenvolgende machten van twee met het benodigde aantal mogelijkheden. Stop bij de eerste macht die groot genoeg is. De toets is $2^n\ge N$ voor N verschillende waarden. Precieze gelijkheid is toegestaan: acht mogelijkheden passen in drie bits, terwijl een negende mogelijkheid een vierde bit vereist. Een grotere breedte werkt ook, maar is niet meer het minimum.

Geef het patroon betekenis

De byte 01000001 kan het gehele getal 65 betekenen, de ASCII-letter “A” of een kleurkanaalintensiteit van 65 op een schaal van 0–255. De bits alleen bepalen niet welke interpretatie geldt. Het gegevenstype van een programma en het formaat van het bestand bepalen hoe je ze interpreteert.

Lees opslageenheden

Twee families van voorvoegsels zijn gangbaar:

De decimale voorvoegsels zijn SI-voorvoegsels; de binaire voorvoegsels zijn IEC-voorvoegsels. Bij elke decimale stap wordt de eenheid 1.000 keer zo groot; bij elke binaire stap wordt die 1.024 keer zo groot. Om bytes in een grotere eenheid uit te drukken, deel je door het aantal bytes in die eenheid.

Een schijf met het label 500 GB bevat 500.000.000.000 bytes. Gedeeld door 1.073.741.824 is dat ongeveer 465,66 GiB. Software kan die binaire hoeveelheid “GB” noemen, waardoor de weergegeven capaciteit kleiner lijkt. De verandering van eenheid zelf heeft geen bytes verwijderd; formattering en systeembestanden staan daar los van.

Maak onderscheid tussen bits en bytes

Een kleine letter b betekent bit; een hoofdletter B betekent byte. Een verbinding van 100 Mbit/s draagt elke seconde maximaal 100 miljoen bits over. Gedeeld door 8 is dat 12,5 miljoen bytes per seconde, oftewel 12,5 MB/s, vóór protocoloverhead. Als je die snelheid als 100 MB/s leest, maak je die acht keer te groot.

Het binaire talstelsel is een positiestelsel: de waarde van een cijfer hangt af van de plaats waar het staat. Het decimale stelsel gebruikt tien cijfers en machten van 10. Het binaire stelsel gebruikt twee cijfers, 0 en 1, en machten van 2. Om een binair getal te lezen, tel je de plaatswaarden op waar een 1 staat.

Lees een binair geheel getal

Van rechts naar links zijn de plaatswaarden 1, 2, 4, 8, 16, 32, 64, 128, enzovoort. Elke waarde is twee keer zo groot als de vorige, want $2^0=1$, $2^1=2$ en $2^2=4$.

Voor ${101101}_2$ zet je de zes bits onder hun plaatswaarden:

De waarde is $32+8+4+1=45$. Een nul draagt niets bij, maar houdt de andere cijfers op de juiste plaats. Voorloopnullen veranderen de waarde niet: 00101101 is ook 45.

De meest linkse bit is de meest significante bit, of MSB. De meest rechtse is de minst significante bit, of LSB. Elke plaatswaarde behalve de laatste is even, dus is een binair geheel getal precies dan oneven als de LSB 1 is.

Reken om door machten van twee af te trekken

Om 156 binair te schrijven, begin je met de grootste macht van twee die past: 128. Trek die af; er blijft 28 over. De plaatswaarden 64 en 32 passen niet, dus krijgen beide een 0. Neem 16, waarna 12 overblijft; neem 8, waarna 4 overblijft; neem 4, waarna 0 overblijft. De ongebruikte posities voor 2 en 1 krijgen een 0.

In de volgorde van de plaatswaarden is het resultaat $156={10011100}_2$. Controleer dit door de gekozen plaatswaarden op te tellen: $128+16+8+4=156$. Als je een ongebruikte kolom overslaat, verschuift elke volgende bit en verandert het getal.

De aftrekmethode werkt omdat elke binaire plaatswaarde maximaal één keer kan worden gebruikt. Nadat je de grootste passende macht hebt genomen, is de rest kleiner dan die macht. Ga in aflopende volgorde door alle plaatswaarden heen, ook de posities met een nul, totdat de positie voor de eenheden is gevuld. Zo komen de gekozen bits overeen met afzonderlijke machten in plaats van een lijst machten zonder posities.

Reken om door herhaald te delen

Een andere methode deelt herhaaldelijk door 2. Bewaar het quotiënt voor de volgende deling en noteer de rest:

Lees de resten van onder naar boven. Dat geeft 10011100. De eerste rest hoort bij de positie voor de eenheden, dus als je naar beneden leest, draai je de volgorde van de plaatswaarden om. Hier zou dat 00111001 opleveren, oftewel 57.

Houd het grondtal zichtbaar

Het subscript in ${10}_2$ betekent grondtal 2, dus is de waarde twee. Dezelfde cijfers in ${10}_{10}$ betekenen tien. Binaire getallen lees je meestal cijfer voor cijfer: “één nul”. Het tellen gaat 0, 1, 10, 11, 100, 101, 110, 111, 1000; bij 2 gaat er een overdracht naar de volgende kolom. Een reeks van acht enen is $2^8-1=255$. Als je een nul toevoegt, verschuift elke positie naar links en verdubbelt de waarde: 101 wordt 1010, waarbij vijf tien wordt.

Het hexadecimale talstelsel schrijft getallen met grondtal 16. De cijfers zijn 0–9 gevolgd door A, B, C, D, E en F, die 10 tot en met 15 betekenen. Eén hexadecimaal cijfer kan elke mogelijke groep van vier bits beschrijven, waardoor lange binaire patronen gemakkelijker te lezen zijn.

Koppel vier bits aan één cijfer

Omdat $16=2^4$, komt elke hexadecimale positie overeen met precies vier binaire posities:

Om van binair naar hexadecimaal te gaan, groepeer je vanaf rechts. Het patroon 10011100 wordt 1001 1100, oftewel 0x9C. Vul een kortere laatste groep links aan met voorloopnullen: 101101 wordt 0010 1101, oftewel 0x2D. Als je vanaf links zou groeperen als 1011 01, zouden de cijfers op de verkeerde plaatsen komen.

Om terug te rekenen, schrijf je elk cijfer als vier bits. Zo wordt 0x3E8 gelijk aan 0011 1110 1000. Behoud alle vier bits binnen elke groep, ook als een groep met nullen begint. Alleen nullen helemaal links van het hele getal kun je weglaten zonder de waarde te veranderen.

Gebruik plaatswaarden met grondtal 16

Van rechts naar links zijn de hexadecimale plaatswaarden 1, 16, 256 en 4.096. Vermenigvuldig de waarde van elk cijfer met de bijbehorende plaatswaarde en tel de uitkomsten op. Voor 0x2F is de berekening $2\times 16+15=47$. Voor 0x3E8:

Van decimaal naar hexadecimaal omrekenen werkt ook door herhaald te delen, nu door 16. Voor 1.000 is het eerste quotiënt 62 met rest 8. Als je 62 deelt, krijg je quotiënt 3 met rest 14, geschreven als E. Als je 3 deelt, krijg je quotiënt 0 met rest 3. Lees de resten van onder naar boven: 3, E, 8.

De groepering werkt door de plaatswaarde, niet alleen door een tabel met overeenkomsten. In een hexadecimaal getal van twee cijfers draagt de linkernibble zijn waarde maal 16 bij en de rechternibble zijn waarde maal 1. Binair vermenigvuldigt het vier plaatsen naar links verschuiven van een nibble de waarde ook met 16. Door die gemeenschappelijke factor kun je de twee groepen afzonderlijk lezen zonder eerst het hele getal naar decimaal om te rekenen.

Herken veelvoorkomende toepassingen

Eén byte is twee nibbles, dus precies twee hexadecimale cijfers, van 0x00 tot en met 0xFF. Een programma dat bytes weergeeft, kan een lang bestand hexadecimaal vier keer zo compact tonen als binair, terwijl de grenzen tussen de groepen zichtbaar blijven.

Webkleuren zoals #FF8000 gebruiken paren hexadecimale cijfers voor rood, groen en blauw. Ook geheugenadressen en Unicode-codepunten zoals U+00E9 gebruiken hexadecimale notatie. Een MAC-adres zoals 3C:22:FB:9A:01:7E schrijft zes bytes als twaalf hexadecimale cijfers, met scheidingstekens tussen de bytes.

Het voorvoegsel 0x, een subscript voor het grondtal zoals $2F_{16}$, of de # in een kleurcode geeft de notatie aan. De computer slaat dezelfde bits op, ongeacht de notatie die iemand gebruikt. Zo betekent 0x10 zestien. De waarde vijftien is het enkele cijfer F; als je “15” schrijft, gebruik je twee hexadecimale posities en betekent het eenentwintig.

Een geheel getal zonder teken geeft een niet-negatief geheel getal weer. Alle bits hebben gewone positieve binaire gewichten. De bitbreedte bepaalt hoeveel posities beschikbaar zijn, dus kan een byte geen negende bit krijgen alleen omdat een resultaat die nodig heeft.

Bepaal het bereik

Voor $n$ bits zijn er $2^n$ patronen. Als je bij nul begint, krijg je het bereik $0\text{ tot en met }{2}^n-1$. De grootste waarde heeft op elke positie een 1:

Het aantal beschikbare waarden en de maximale waarde verschillen één. Met acht bits zijn 256 mogelijkheden beschikbaar, maar 256 zelf heeft negen posities nodig, 1 0000 0000.

Een opgeslagen waarde vult de bitbreedte met voorloopnullen. Zo is 45 in 16 bits gelijk aan 0000000000101101, oftewel 0x002D. Die nullen geven de bitbreedte aan zonder de waarde te veranderen. Een negatief getal heeft geen representatie zonder teken, welke bitbreedte je ook kiest.

Kies genoeg posities

Een leeftijdsbereik van 0 tot en met 150 past in 8 bits omdat 150 kleiner is dan 255. Een telling van 0 tot en met 100.000 bevat 100.001 mogelijke waarden. Zestien bits bieden maar 65.536 patronen. Zeventien bieden er 131.072, dus is 17 de minimale wiskundige bitbreedte. Een programma dat de gangbare breedtes 8, 16, 32 en 64 gebruikt, zou 32 bits kiezen.

Dezelfde redenering geldt voor elke begrensde teller: controleer de grootste waarde die de teller daadwerkelijk moet bevatten, met inbegrip van beide grenzen. Een bereik van 0 tot en met 256 heeft 257 patronen nodig en past daarom niet in één byte.

Een nuttige grenscontrole vergelijkt opeenvolgende bitbreedtes. Het maximum zonder teken voor 8 bits is 255 en voor 9 bits is het 511. Een bit toevoegen verdubbelt het aantal patronen; het maximum wordt twee keer het oude maximum plus één. Dit onderscheid is van belang als een vereiste precies op een macht van twee uitkomt: die grenswaarde heeft een nieuwe positie nodig, ook al heeft de vorige bitbreedte zoveel patronen.

Volg een resultaat buiten het bereik

Overloop betekent dat een resultaat niet in de gekozen representatie past. Als een berekening met 8 bits alleen de laagste acht bits bewaart, levert 255 plus 1 de uitkomst 1 0000 0000 op en wordt 00000000 opgeslagen: nul. De extra positie wordt weggegooid.

Voor 200 plus 100 is het wiskundige resultaat 300. Bij deze bitbreedte wordt de rest na een volledige cyclus van 256 patronen bewaard: $300-256=44$. De opgeslagen byte is 00101100. Dit gedrag heet cyclische overloop (wraparound). Het verandert niets aan het rekenkundige feit dat 200 plus 100 gelijk is aan 300; het beschrijft wat de beperkte opslag bewaart.

Het gedrag bij overloop hangt af van het systeem. Sommige bewerkingen lopen cyclisch over, sommige melden een fout en sommige getaltypen worden groter. Bij een berekening over cyclische overloop moet dat gedrag vaststaan voordat je hoge bits weggooit.

Herken vaste bitbreedtes in gegevens

Een IPv4-adres heeft 32 bits, wat ongeveer 4,3 miljard mogelijke patronen geeft. Die eindige adresruimte droeg bij aan de behoefte aan een groter adresseringssysteem. Een gewoon RGB-kleurkanaal heeft 8 bits, wat de intensiteitsschaal van 0–255 verklaart. Het maximum volgt in beide gevallen uit de bitbreedte; een langere decimale schrijfwijze voegt geen opslagcapaciteit toe.

Een negatief geheel getal heeft een representatieregel nodig, niet alleen een minteken naast een byte. Tweecomplement geeft de hoogste bit een negatief gewicht. De overige posities behouden hun positieve gewicht, zodat elk patroon één waarde met teken heeft en nul één patroon heeft.

Vergelijk twee interpretaties met teken

Een eenvoudiger schema, de teken-grootterepresentatie, gebruikt de hoogste bit alleen voor het teken en de overige bits voor de grootte. In 8 bits is +5 gelijk aan 00000101 en −5 aan 10000101. Het schema heeft twee nullen, 00000000 en 10000000, en voor optellen met verschillende tekens zijn extra regels nodig.

In tweecomplement met 8 bits zijn de gewichten −128, 64, 32, 16, 8, 4, 2 en 1. Dus betekent 11010011 dat $-128+64+16+2+1=-45$. Als je de andere zeven bits als een grootte van 83 leest, krijg je −83, wat bij een andere representatie hoort.

In het algemeen is het bereik $-2^{n-1}\text{ tot en met }{2}^{n-1}-1$. Nul en positieve waarden zien eruit als gewone binaire getallen met een 0 vooraan. Alleen enen geven −1 weer.

Schrijf een negatieve waarde

Om het teken van een weergeefbare waarde om te keren, keer je elke bit om en tel je er 1 bij op, waarbij je de bitbreedte vast houdt. Om −45 in 8 bits te coderen:

1. Schrijf +45 als 00101101.
2. Keer alle acht bits om: 11010010.
3. Tel 1 op: 11010011, oftewel 0xD3.

Als je na het omkeren stopt, krijg je −46. Als je het hele proces op 11010011 toepast, krijg je weer 00101101 en daarmee +45.

Een andere manier codeert $-x$ als de waarde zonder teken $2^n-x$. Hier is $256-45=211$, waarvan de binaire vorm 11010011 is. De byte betekent dus 211 zonder teken of −45 met teken. De bits zijn niet veranderd; het type wel.

Voor omkeren gevolgd door optellen is ook een rekenkundige verklaring. Bij een positieve waarde x van n bits verandert omkeren die in de waarde zonder teken $2^n-1-x$. Als je daar één bij optelt, krijg je $2^n-x$, waarvan de interpretatie met teken −x is. Dit verbindt de bitmethode met de aftrekmethode en verklaart waarom het weglaten van de laatste 1 de verkeerde negatieve waarde geeft.

Behoud een waarde met teken in meer bits

Bij tekenuitbreiding kopieer je de hoogste bit naar de nieuwe posities links. −3 in vier bits is 1101; in 8 bits is dat 11111101. Het negatieve gewicht van de hoogste bit en de toegevoegde positieve gewichten zijn samen nog steeds −3. Als je met nullen zou aanvullen, kreeg je 00001101, oftewel +13. Positieve waarden worden met nullen uitgebreid: 0011 wordt 00000011.

Herken de grenswaarden

Tweecomplement ondersteunt gewone binaire optelling voor resultaten die passen. In 4 bits geeft 0101 plus 1101, oftewel 5 plus −3, de uitkomst 1 0010. Als je de laagste vier bits bewaart, krijg je 0010, oftewel 2. Zo kan dezelfde basishardware voor optellen waarden met en zonder teken verwerken.

Een resultaat buiten het bereik is anders: 127 plus 1 in 8 bits laat 10000000 over, wat als −128 wordt gelezen. Ook heeft −128 geen positieve tegenhanger in 8 bits. Als je 10000000 omkeert en er 1 bij optelt, krijg je 10000000 terug omdat +128 buiten het bereik ligt. Maak de representatie breder voordat je die positieve waarde vormt.

De eerste positie na de binaire komma is een half. Elke volgende positie is de helft van de vorige: een kwart, een achtste, een zestiende, enzovoort. Een 1 telt die breuk mee; een 0 laat die weg. De posities voor gehele getallen links behouden hun gebruikelijke machten van twee.

Lees en maak een binaire breuk

Voor ${\mathrm{101,101}}_2$ is het gehele deel 4 plus 1. Het breukdeel is een half plus een achtste, wat $4+1+\mathrm{0,5}+\mathrm{0,125}=\mathrm{5,625}$ geeft.

Om een decimale breuk om te rekenen, vermenigvuldig je die herhaaldelijk met 2. Het gehele deel van elk resultaat is het volgende binaire cijfer; bewaar alleen het breukdeel voor de volgende vermenigvuldiging. Voor 0,375:

1. $\mathrm{0,375}\times 2=\mathrm{0,75}$, dus is de eerste bit 0.
2. $\mathrm{0,75}\times 2=\mathrm{1,5}$, dus is de volgende bit 1; bewaar 0,5.
3. $\mathrm{0,5}\times 2=\mathrm{1,0}$, dus is de volgende bit 1 en stopt het proces.

Het resultaat is ${\mathrm{0,011}}_2$. De waarde is een kwart plus een achtste, oftewel 0,375. Deze bits lees je in de gevonden volgorde, anders dan de resten bij het delen van gehele getallen.

Bepaal of de ontwikkeling eindigt

Vereenvoudig de breuk volledig. Die heeft precies dan een eindige binaire ontwikkeling als de noemer een macht van 2 is. Waarden zoals 0,5, 0,25, 0,75 en 0,375 voldoen daaraan. Zo is 0,375 gelijk aan 3/8 en is acht een macht van twee.

Decimaal 0,1 is 1/10. De noemer bevat een factor 5, dus herhaalt de binaire ontwikkeling zich: $\mathrm{0,0001100110011}{\dots }_2$. Net zoals een derde niet kan eindigen in decimale notatie, kan een tiende niet eindigen in binaire notatie. De korte schrijfwijze “0,1” heeft daarom een benadering nodig als er slechts een beperkt aantal binaire posities beschikbaar is. Hetzelfde probleem geldt voor 0,2 en 0,3.

De noemerregel volgt uit de posities zelf. Een eindige reeks die bij de f-de positie van het breukdeel eindigt, kun je schrijven als een geheel getal gedeeld door $2^f$. Vereenvoudiging van die breuk kan factoren twee wegnemen, maar kan geen andere priemfactor in de noemer introduceren. Een vereenvoudigde noemer die vijf bevat, kan daarom niet gelijk zijn aan zo’n eindige binaire som.

Reserveer een vaste schaal

Een vastekommarepresentatie geeft een vast aantal bits aan het breukdeel. Met vier bits voor het gehele deel en vier voor het breukdeel betekent 0110,1000 de waarde 6,5. De kleinste stap is $2^{-4}=\mathrm{0,0625}$ en de grootste waarde zonder teken is 1111,1111, oftewel 15,9375.

Anders gezegd: het opgeslagen gehele getal van acht bits wordt geschaald met 1/16. Het patroon 01101000 heeft de waarde zonder teken 104; gedeeld door 16 geeft dat 6,5. De komma maakt deel uit van de interpretatie en hoeft dus niet als extra symbool te worden opgeslagen.

Als je in totaal acht bits houdt maar vijf bits voor het gehele deel en drie voor het breukdeel gebruikt, wordt de stap 0,125 en het maximum 31,875. Je wint bereik maar verliest fijne tussenstappen. Vastekommarepresentatie geeft veelvouden van de stap binnen het bereik exact weer.

Een exact aantal centen gebruikt een verwant schaalidee: 19,99 geldeenheden wordt het gehele getal 1999 cent. Voor metingen van zeer verschillende groottes slaat drijvendekommarepresentatie een verschuifbare schaal op, zodat dezelfde bitbreedte een veel groter bereik beslaat dan bij vastekommarepresentatie.

Drijvendekommarepresentatie schrijft een waarde in binaire wetenschappelijke notatie. Zo is 6,25 gelijk aan ${\mathrm{110,01}}_2={\mathrm{1,1001}}_2\times 2^2$. Het voorste deel is de mantisse en de exponent bepaalt de schaal. IEEE 754 definieert veelgebruikte formaten om deze delen op te slaan.

Ken de velden

Voor een normale waarde is de interpretatie $(-1{)}^s\times (\mathrm{1,}f{)}_2\times 2^{E-\text{verschuiving}}$. Hier is $s$ de tekenbit, $E$ de opgeslagen exponent zonder teken en $f$ het fractieveld. Een tekenbit van 0 betekent positief; 1 betekent negatief. Als je alleen de tekenbit verandert, keer je het teken van een drijvendekommawaarde om.

De opgeslagen exponent is gelijk aan de werkelijke exponent plus de exponentverschuiving. Bij enkele precisie wordt exponent 2 gelijk aan 129, oftewel 10000001; exponent −3 wordt 124, oftewel 01111100. Normale opgeslagen exponenten lopen van 1 tot en met 254 en geven −126 tot en met 127 weer.

Een normale binaire mantisse begint altijd met 1, dus laat het formaat die impliciete bit weg. Alleen de bits na de komma komen in het fractieveld. Dit geeft 24 significante binaire cijfers bij enkele precisie en 53 bij dubbele precisie.

Codeer −6,25 stap voor stap

Normaliseer eerst de grootte: ${\mathrm{110,01}}_2={\mathrm{1,1001}}_2\times 2^2$. Vul daarna de velden:

1. Negatieve waarde: teken 1.
2. Exponent 2: tel 127 op voor 129, geschreven als 10000001.
3. Fractie ,1001: sla 1001 op gevolgd door 19 nullen.

Het resultaat is 1 10000001 10010000000000000000000, oftewel 0xC0C80000. De fractie wordt rechts aangevuld omdat deze posities na de komma doorlopen. Als je de voorste 1 zou opslaan, zou de betekenis van de fractie verschuiven.

Een negatieve werkelijke exponent brengt de schaal onder één. Voor 0,15625 is de binaire vorm ${\mathrm{0,00101}}_2={\mathrm{1,01}}_2\times 2^{-3}$. De tekenbit in binary32 is 0 en de opgeslagen exponent is 124, oftewel 01111100. De fractie begint met 01 en wordt rechts aangevuld. De impliciete 1 hoort nog steeds bij de genormaliseerde mantisse, ook al is het volledige getal kleiner dan één.

Decodeer een patroon

Het patroon 0x41200000 met enkele precisie valt uiteen in 0 10000010 01000000000000000000000. Het teken is positief. Het exponentveld is 130, dus trek je 127 af om 3 te krijgen. Herstel de impliciete 1 om ${\mathrm{1,01}}_2=\mathrm{1,25}$ te krijgen. Tot slot is $\mathrm{1,25}\times 2^3=10$.

Controleer eerst gereserveerde exponenten

De formule voor normale waarden beschrijft niet elk patroon:

Subnormale waarden geven zeer kleine waarden weer zonder de impliciete 1. NaN kan het resultaat zijn van een ongeldige numerieke bewerking zoals 0 gedeeld door 0. IEEE 754-2019 definieert deze formaten.

Een formaat voor drijvendekommagetallen kan een enorm bereik bestrijken zonder elke waarde in dat bereik weer te geven. De exponent bepaalt de schaal; het fractieveld bepaalt hoeveel significante bits nabijgelegen waarden onderscheiden. Bereik en precisie beantwoorden verschillende vragen.

Vergelijk enkele en dubbele precisie

Enkele precisie reikt tot ongeveer $\mathrm{3,4}\times {10}^{38}$ en heeft ongeveer zeven significante decimale cijfers. De kleinste positieve normale waarde is ongeveer $\mathrm{1,18}\times {10}^{-38}$. Dubbele precisie reikt tot ongeveer $\mathrm{1,8}\times {10}^{308}$, heeft ongeveer 15–16 significante decimale cijfers en een kleinste positieve normale waarde van ongeveer $\mathrm{2,2}\times {10}^{-308}$. Subnormale waarden komen bij elk formaat onder het normale minimum.

Significante cijfers tel je vanaf het eerste betekenisvolle cijfer, niet vanaf de decimale komma. Een grote exponent levert niet meer fractiebits op. Bij enkele precisie is de afstand boven 1 gelijk aan $2^{-23}\approx \mathrm{1,19}\times {10}^{-7}$. Tussen $2^{24}$ en $2^{25}$ is de afstand 2, dus is het gehele getal 16.777.217 niet beschikbaar, hoewel het ver onder de maximale eindige waarde ligt.

Rond af op een waarde die past

De standaardregel van IEEE 754 is afronden naar de dichtstbijzijnde waarde, naar even bij gelijke afstand. Kies de dichtstbijzijnde weergeefbare waarde; kies bij een waarde precies halverwege de waarde waarvan de laatst behouden mantissebit even is. Zo wordt 16.777.217 bij enkele precisie afgerond op 16.777.216.

Het verschil tussen de bedoelde waarde en de opgeslagen waarde is de afrondingsfout. Bij enkele precisie wordt 0,1 opgeslagen als 0,100000001490116119384765625. Bij dubbele precisie is dat ongeveer 0,10000000000000000555. Meer precisie verkleint deze fout, maar kan een repeterende ontwikkeling niet laten eindigen.

Begrijp een bekend resultaat

Bij gewone berekeningen met dubbele precisie volgens IEEE 754 levert het optellen van 0,1 en 0,2 een opgeslagen resultaat op dat vaak wordt weergegeven als 0.30000000000000004. Het verschilt van de opgeslagen benadering van 0,3, dus is 0.1 + 0.2 == 0.3 onwaar in talen zoals Python en JavaScript. Vergelijk bij meetresultaten het verschil met een tolerantie die je kiest voor de schaal en het doel van de taak.

Veel waarden zijn exact. Dubbele precisie bevat elk geheel getal van $-2^{53}$ tot en met $2^{53}$ exact. Waarden zoals 0,5 en 0,375 hebben ook korte binaire vormen die zowel in de mantisse als binnen het exponentbereik passen.

Kies een geschikt getaltype

Voor tellingen en identificatiecodes zijn gehele getallen geschikt. Voor exacte geldbedragen zijn gehele aantallen kleinere geldeenheden, zoals centen, of een decimaal getaltype geschikt. Voor metingen en wetenschappelijke berekeningen is drijvendekommarepresentatie vaak geschikt. Een waarde die qua grootte buiten het formaat valt, kan door overloop oneindig worden; volgens de standaardafrondingsregel wordt ${10}^{39}$ bij enkele precisie positief oneindig. Zeer kleine resultaten kunnen subnormaal worden of op nul worden afgerond.

Weergaveconventies staan los van opslag. De schrijfwijzen “3.14” en “3,14” kunnen in verschillende landen hetzelfde getal aanduiden. Een programma dat tekst leest, moet die conventie kennen; anders kan het de komma afwijzen of de waarde als 314 lezen. Een ander afgedrukt scheidingsteken verbetert de binaire precisie niet.

Om tekst op te slaan, kent een systeem numerieke codes toe aan tekens en schrijft het die getallen als bits. Een tekencode werkt alleen als de lezer dezelfde afspraak gebruikt als de schrijver. De byte voor een letter is een gecodeerd label; het is geen piepklein plaatje van die letter.

Lees de ASCII-tabel

ASCII, de American Standard Code for Information Interchange, werd voor het eerst gepubliceerd in 1963. ASCII gebruikt 7 bits voor 128 codes, genummerd van 0–127. Bij opslag in bytes vult een ASCII-code meestal één byte met een 0 vooraan.

Leestekens vullen de tussenruimtes. Codes 32–126 vormen 95 afdrukbare tekens, inclusief de spatie. Besturingstekens beïnvloeden de tekstverwerking zonder een zichtbaar symbool af te drukken: tab is 9, regeldoorvoer is 10 en wagenretour is 13.

Codeer een korte tekenreeks

De tekst “Hi!” heeft drie tekens. Hun decimale codes zijn 72, 105 en 33; hexadecimaal zijn dat 0x48, 0x69 en 0x21. Als volledige bytes wordt de tekst 01001000 01101001 00100001. Het uitroepteken heeft net als de letters een code nodig.

De code van een kleine ASCII-letter ligt 32 hoger dan die van de bijbehorende hoofdletter. “A” is 65, oftewel 01000001, terwijl “a” 97 is, oftewel 01100001. Die ene veranderde bit verklaart het verschil. Door de volgorde komen ook alle hoofdletters vóór alle kleine letters. Een eenvoudige sortering op code zet “Zebra” daarom vóór “appel”; die volgt niet de gewone woordenboekvolgorde.

Maak onderscheid tussen een cijfer en een getal

Het teken “7” heeft decimale code 55 en byte 00110111. Het gehele getal 7 heeft byte 00000111. Om de numerieke waarde van een cijfer uit de ASCII-code terug te krijgen, trek je 48 af, de code voor “0”: $55-48=7$. Dit werkt omdat de tien cijfercodes opeenvolgend zijn.

De opslag hangt af van de gekozen representatie. De tekst “2026” heeft vier ASCII-bytes nodig, één per cijfer. Het gehele getal 2026 past in twee bytes als waarde zonder teken van 16 bits. Tekst bewaart de volgorde van de tekens; een geheel getal geeft de numerieke waarde weer. Zo kan een identificatiecode als tekst voorloopnullen bewaren die een geheel getal niet onderscheidt.

Om een langere tekenreeks te coderen, verwerk je elk teken op volgorde, inclusief spaties, leestekens en besturingstekens. Bij het decoderen zoek je met dezelfde tabel elke code één voor één in omgekeerde richting op. De volgorde is belangrijk: als je twee geldige codes verwisselt, kun je nog steeds geldige ASCII krijgen, maar wel andere tekst. Als codes worden herkend, bewijst dat niet dat ze de bedoelde volgorde of betekenis hebben.

Begrijp waarom codepagina’s problemen veroorzaakten

ASCII heeft geen letters met accenten zoals “é”, “ñ” of “ü”, en geen Griekse, Cyrillische, Arabische of Chinese tekens. Latere 8-bitscodepagina’s gebruikten waarden 128–255 voor extra symbolen, maar waren het niet eens over die toevoegingen.

Zo betekent byte 0xE9 “é” in Latin-1 maar “й” in Windows-1251. Windows-1252 is een andere veelgebruikte codepagina. Een bytewaarde kan een teken buiten ASCII daarom niet identificeren zonder dat de codering bekend is. De verkeerde tabel kan symbolen opleveren die leesbaar lijken, maar toch de verkeerde tekst vormen.

Unicode kent tekens uit schriftsystemen over de hele wereld getallen toe uit een gedeelde verzameling. Die getallen heten codepunten. “A” is U+0041, “é” is U+00E9, “Ж” is U+0416, “中” is U+4E2D en “😀” is U+1F600. De U+-notatie gebruikt hexadecimale cijfers met minstens vier posities.

Maak onderscheid tussen een codepunt en de bytes

De coderuimte loopt van U+0000 tot en met U+10FFFF, oftewel 1.114.112 posities, met meer dan 150.000 toegewezen tekens. Een codepunt duidt een teken of een gereserveerde positie aan; een tekencodering bepaalt de weergave in bytes.

Het surrogaatbereik U+D800–U+DFFF is gereserveerd voor het paarmechanisme van UTF-16; afzonderlijke surrogaten zijn geen geldige tekens om in deze vormen te coderen. Een paar UTF-16-code-eenheden geeft één aanvullend codepunt weer. Zo is “😀” in UTF-16 gelijk aan D83D DE00.

Lees de bytebereiken van UTF-8

UTF-8 behoudt ASCII: U+0000–U+007F gebruiken één byte. U+0080–U+07FF gebruiken er twee; geldige codepunten van tekens in U+0800–U+FFFF gebruiken er drie; U+10000–U+10FFFF gebruiken er vier. Daardoor is Engelse ASCII-tekst byte voor byte compatibel met UTF-8.

Een teken van één byte begint met 0. Langere tekens beginnen met 110, 1110 of 11110 voor respectievelijk twee, drie of vier bytes. Elke vervolgbyte begint met 10. De overige bits bevatten het codepunt.

Voor “é”, U+00E9, is de waarde in 11 bits 00011101001. Splits die in vijf bits en zes bits: 00011 en 101001. Vul die in op de plaatsen van 110xxxxx 10xxxxxx en je krijgt 11000011 10101001, oftewel C3 A9. Het codepunt 00E9 is niet zelf de UTF-8-bytereeks.

Bij coderen en decoderen moet je ook rekening houden met de voorvoegsels van de bytes. Een UTF-8-vervolgbyte is geen zelfstandige ASCII-byte: de eerste twee bits zijn 10, dus hoort die binnen een langere tekenreeks. Als je bij een bytelimiet een deel van een teken met meerdere bytes verwijdert, kan een onvolledige reeks overblijven. De opslaglengte en de grenzen waarop je tekst kunt splitsen, hangen dus samen.

Tel de juiste eenheden

“café” heeft vier weergegeven tekens maar vijf UTF-8-bytes: 63 61 66 C3 A9. “€” gebruikt E2 82 AC, drie bytes; “中” gebruikt E4 B8 AD, ook drie; “😀” gebruikt F0 9F 98 80, vier. Een bytelimiet kan dus minder tekens toelaten dan de numerieke grootte doet vermoeden.

Eén weergegeven teken kan ook meerdere codepunten bevatten. “é” kan U+00E9 zijn of “e” gevolgd door U+0301, een combinerend accent aigu. De tweede vorm gebruikt drie UTF-8-bytes, 65 CC 81. Normalisatie zet equivalente reeksen om naar een gemeenschappelijke vorm om ze te vergelijken. De weergegeven emoji “👍🏽” bevat twee codepunten, U+1F44D en U+1F3FD, samen acht UTF-8-bytes.

Onderzoek verminkte tekst

Als je “café” in UTF-8 als Windows-1252 leest, wordt het “café”: C3 en A9 worden als afzonderlijke tekens behandeld. Dit is verminkte tekst door verkeerde tekencodering, veroorzaakt door decoderen met de verkeerde codering. Met de juiste decodering kun je de tekst herstellen zolang de oorspronkelijke bytes intact blijven. Een webpagina kan de codering opgeven met <meta charset="utf-8">.

Een rasterafbeelding is een raster van pixels. Elke pixel bevat een kleurwaarde. De breedte en hoogte geven de resolutie van de afbeelding aan: 1920 bij 1080 betekent $1920\times 1080=\mathrm{2.073.600}$ pixels. Een pixelaantal beschrijft het raster, niet de afgedrukte grootte in meters.

Ken genoeg bits toe aan elke pixel

De kleurdiepte is het aantal bits dat voor de kleur van een pixel wordt gebruikt. Een diepte van $k$ bits maakt $2^k$ mogelijke codes mogelijk. Eén bit kan twee kleuren onderscheiden. Grijstinten met acht bits kunnen 256 intensiteiten onderscheiden, meestal van 0 voor zwart tot en met 255 voor wit.

Een eenvoudige afbeelding van 3 bij 3 kan 1 voor zwart en 0 voor wit gebruiken. Een zwart plusteken wordt weergegeven door de rijen 010, 111 en 010. Negen pixels van elk één bit hebben negen bits aan pixelinformatie nodig. De werkelijke opslag in een bestand kan naast die bits opvulling en andere informatie bevatten.

Meng licht met RGB

RGB slaat intensiteiten van rood, groen en blauw licht op. Met 8 bits per kanaal loopt elke intensiteit van 0 tot en met 255 en gebruikt een pixel 24 bits. Het aantal mogelijke kleuren is ${256}^3=2^{24}=\mathrm{16.777.216}$.

RGB is additieve menging van licht. Rood en groen licht samen geven geel. Een voorspelling op basis van het mengen van verf gebruikt een ander proces en levert het verkeerde model voor een scherm op.

Lees hexadecimale kleurcodes

Een webkleur gebruikt #RRGGBB: twee hexadecimale cijfers voor rood, dan groen en dan blauw. #FF8000 betekent (255, 128, 0), een oranje tint. #808080 betekent (128, 128, 128), een middengrijze tint; gelijke kanaalwaarden leveren grijs op. #0000FF geeft de grootste blauwe waarde met rood en groen op nul.

Elk paar is één byte. FF is dus 255, niet een paar afzonderlijke kleurintensiteiten. De # markeert de hele RGB-code en neemt geen kanaal in.

Het RGB-model en het paletmodel zoeken een pixelwaarde op verschillende manieren op. Bij directe RGB geeft het lezen van de pixel onmiddellijk de drie kanaalintensiteiten. Bij geïndexeerde kleur geeft het lezen van de pixel een nummer van een tabelvermelding en levert een tweede opzoeking de intensiteiten. Als je een paletvermelding verandert, kunnen daardoor veel weergegeven pixels met dezelfde index veranderen, terwijl hun opgeslagen pixelindices ongewijzigd blijven.

Sla een paletindex op

Als een afbeelding weinig kleuren gebruikt, kan die een kleurenpalet bewaren, een tabel met de geselecteerde kleuren. Een pixel slaat dan een index naar die tabel op. Een palet van 16 kleuren heeft vier bits per pixel nodig omdat vier bits 16 vermeldingen onderscheiden. Het palet zelf neemt ook opslagruimte in. GIF gebruikt maximaal 256 paletkleuren, zodat een index van 8 bits per pixel mogelijk is.

Voeg transparantie toe

Een alfakanaal beschrijft de ondoorzichtigheid. Een veelgebruikte schaal van 8 bits gebruikt 0 voor volledig transparant en 255 voor volledig ondoorzichtig, met tussenliggende waarden voor gedeeltelijke transparantie. Als je dat kanaal toevoegt aan RGB van 24 bits, krijg je RGBA van 32 bits. Alfa staat los van rood, groen en blauw: een volledig transparante pixel kan nog steeds opgeslagen kleurwaarden hebben die in de uiteindelijke afbeelding niet zichtbaar zijn.

De pixelgegevens van een ongecomprimeerde rasterafbeelding groeien met het aantal pixels en het aantal bits per pixel. Als je de eenheden bij elke stap vermeldt, kun je de hoeveelheid informatie onderscheiden van de bestandsgrootte in bytes die een programma voor bestandsweergave toont.

Bereken de pixelgegevens

Gebruik $\text{bits}=\text{breedte}\times \text{hoogte}\times \text{bits per pixel}$. Deel door 8 voor het aantal bytes. Je moet breedte en hoogte vermenigvuldigen omdat elke rij de volledige breedte aan pixels bevat.

Bepaal voor 1920 bij 1080 met 24 bits per pixel eerst het aantal van 2.073.600 pixels. Vermenigvuldig met 24 voor 49.766.400 bits en deel dan door 8 voor 6.220.800 bytes. Dat is ongeveer 6,2 MB, oftewel 5,93 MiB. Een andere eenheid verandert de onderliggende pixelgegevens niet.

Voor 640 bij 480 met 8-bitsgrijstinten zijn er 307.200 pixels. Acht bits per pixel geven 2.457.600 bits; gedeeld door 8 is dat 307.200 bytes, ongeveer 307 kB. Hier is door die ene byte per pixel het uiteindelijke aantal bytes gelijk aan het aantal pixels.

Voorspel veranderingen voordat je rekent

Als je de breedte verdubbelt, verdubbelt het aantal pixels in elke rij. Als je de hoogte verdubbelt, verdubbelt het aantal rijen. Als je beide verdubbelt, worden het aantal pixels en de benodigde opslag dus vier keer zo groot. Als je de diepte van 8 naar 24 bits per pixel verhoogt, verdrievoudigt de opslag bij dezelfde resolutie. Deze factoren vermenigvuldigen als beide veranderen.

De ruwe berekening geeft de pixelgegevens, niet noodzakelijk een volledig afbeeldingsbestand. Een bestand slaat ook metadata op, zoals breedte, hoogte, kleurdiepte en formaat. Een foto kan camera-instellingen, datum en locatie vastleggen. Palettabellen, headers, opvulling en compressie kunnen de uiteindelijke grootte in bytes ook veranderen.

Bereken bij een diepte onder acht bits eerst de volledige hoeveelheid pixelgegevens in bits voordat je omrekent. Een afbeelding van 100 bij 60 met één bit per pixel bevat 6.000 pixelbits, oftewel 750 verpakte bytes. Als je elke pixel als een byte zou behandelen, zou je die hoeveelheid acht keer te groot inschatten. Als een formaat elke rij tot een bepaalde grens aanvult, moet je die opvulling afzonderlijk toevoegen; de kleurdiepte verandert daardoor niet.

Breid de berekening uit naar video

Een video toont een reeks afbeeldingen die videobeelden heten. Bij 30 beelden per seconde heeft RGB-video van 1920 bij 1080 elke seconde $\mathrm{6.220.800}\times 30=\mathrm{186.624.000}$ bytes aan ongecomprimeerde beeldgegevens nodig, ongeveer 187 MB/s. Vermenigvuldig met de duur voor de totale hoeveelheid beeldgegevens. Geluid vraagt extra opslagruimte.

Deze hoge snelheid verklaart waarom gewone videobestanden worden gecomprimeerd. De snelheid van een gecomprimeerde video is een afzonderlijke grootheid; die kun je niet alleen uit de resolutie afleiden.

Vergelijk raster- en vectorafbeeldingen

Een vectorbestand kan een lijn van (0, 0) naar (100, 50) beschrijven, of een cirkel met een middelpunt, straal en vulkleur. Het hoeft geen afzonderlijke kleurwaarde op te slaan voor elk punt binnen de cirkel. Eenvoudige tekeningen kunnen daarom klein zijn. SVG is een veelgebruikt vectorformaat.

Een scherm heeft nog steeds pixels nodig. Rasterisatie zet de vormen om in een pixelraster op de gevraagde grootte. Als je vectorinstructies schaalt, blijft de geometrie van de vorm behouden; als je een bestaande rasterafbeelding vergroot, kun je geen beelddetail terughalen dat het oorspronkelijke raster nooit heeft vastgelegd.

Geluid is een trilling van de luchtdruk. Een microfoon zet die om in een analoog elektrisch signaal dat voortdurend verandert. Een analoog-digitaalomzetter doet regelmatige metingen, samples genoemd, en slaat elke meting als getal op.

Maak onderscheid tussen timing en meetdetail

De bemonsteringsfrequentie, gemeten in hertz, is het aantal samples dat per seconde per kanaal wordt genomen. Een frequentie van 44.100 Hz is 44,1 kHz. Cd’s gebruiken 44,1 kHz, geluidssporen bij video gebruiken vaak 48 kHz en traditionele telefoonaudio gebruikt 8 kHz. Samples leggen waarden op die tijdstippen vast; ze vormen geen continue registratie van elk tussenliggend moment.

De bitdiepte bepaalt hoeveel niveaus elke sample kan gebruiken. Acht bits geven 256 niveaus, 16 geven er 65.536 en 24 geven er 16.777.216. Een meting afronden op een niveau heet kwantisatie. Het verschil met de oorspronkelijke meting veroorzaakt een kwantisatiefout, die als ruis hoorbaar kan zijn. Meer bits bieden fijnere niveaus en verkleinen die fout.

De bemonsteringsfrequentie bepaalt het detail in de tijd; de bitdiepte bepaalt het detail in de gemeten amplitude. Als je de ene verhoogt, vervangt dat niet het verhogen van de andere.

Leg het frequentiebereik vast

Het bemonsteringstheorema vereist een bemonsteringsfrequentie die groter is dan twee keer de hoogste frequentie die je vastlegt. Om 20 kHz vast te leggen, moet de frequentie hoger zijn dan 40 kHz. Precies twee keer is onvoldoende voor een willekeurig signaal op de grens.

Bij 44,1 kHz ligt de theoretische grens onder 22,05 kHz. De ruimte boven ongeveer 20 kHz, de geschatte bovengrens van het menselijk gehoor, biedt plaats voor een anti-aliasingfilter. Frequenties boven de helft van de bemonsteringsfrequentie kunnen als onjuiste lagere frequenties verschijnen; dat heet aliasing. Een omzetter filtert die hoge frequenties vóór de bemonstering weg.

Een frequentie van 44.100 Hz geldt voor elk kanaal, niet voor de opname als gecombineerde stroom. Stereo slaat daarom elke seconde 88.200 samplewaarden op. De kanaalfactor hoort in de opslagformule omdat elk tijdstip een linker- en een rechterwaarde heeft. Die factor verdubbelt niet de hoogste frequentie die elk kanaal kan vastleggen; die grens volgt nog steeds uit de eigen bemonsteringsfrequentie van het kanaal.

Bereken ongecomprimeerde audio

Mono heeft één kanaal; stereo heeft er twee. De grootte van de gegevens is

Voor een stereo-opname van drie minuten met 44.100 Hz en 16 bits is de snelheid $44.100\times 16\times 2=\mathrm{1.411.200}$ bit/s. Vermenigvuldig met 180 seconden voor 254.016.000 bits en deel dan door 8: 31.752.000 bytes, ongeveer 31,8 MB.

Een mono-opname van tien seconden met 8.000 Hz en 8 bits geeft $8.000\times 8\times 1\times 10=640.000$ bits, oftewel 80.000 bytes. Een stereo-opname met dezelfde instellingen zou twee keer zoveel gebruiken.

Kies wat je opslaat

Hogere frequenties en bitdieptes vereisen meer ruimte. Cd-instellingen zijn meestal genoeg om te luisteren; studio’s gebruiken vaak 24 bits en 48 kHz of hoger om ruimte te houden voor verwerking en bewerking.

MIDI legt instructies voor noten vast: welke noten, wanneer ze beginnen, hun sterkte en de instrumentkeuzes. Het kan veel kleiner zijn dan een bemonsterde uitvoering, maar het afspelen hangt af van de beschikbare instrumentklanken. MIDI kan de melodie van een zanger als noten beschrijven; het kan niet de daadwerkelijk opgenomen stem bevatten.

Bij verliesloze compressie worden de oorspronkelijke bits bij het decomprimeren exact hersteld. Tekst, programmabestanden, spreadsheets en andere exacte gegevens hebben die eigenschap nodig. ZIP, PNG, GIF en FLAC zijn bekende verliesloze formaten. Ze benutten redundantie: herhaalde of voorspelbare informatie die korter kan worden beschreven.

Beschrijf herhaalde reeksen

Run-length encoding, of RLE, vervangt opeenvolgende identieke symbolen door een aantal en het symbool. De tekenreeks “AAAAAABBBCCCCCCCCD” van 18 tekens wordt “6A3B8C1D”, acht tekens volgens deze afspraak van aantal en symbool. Bij het decoderen wordt elk paar uitgeschreven: zes A’s, drie B’s, acht C’s en één D.

Hetzelfde idee is geschikt voor egale kleurvlakken in afbeeldingen. De pixelrij 0000000011110000 kun je beschrijven als acht nullen, vier enen en vier nullen. Een echt bestand moet vastleggen hoe aantallen en symbolen worden opgeslagen, zodat decoderen eenduidig is.

Door korte reeksen kan RLE de gegevens groter maken. “ABCD” wordt “1A1B1C1D”, een verdubbeling van het aantal tekens nog vóór een eventuele header. Compressie werkt alleen als de besparing groter is dan de kosten van het beschrijven van het patroon.

Verwijs naar een herhaalde reeks

Een woordenboekmethode vervangt een herhaalde reeks door een verwijzing. Methoden uit de LZ-familie liggen ten grondslag aan formaten zoals ZIP en PNG. In “hallo en dan hallo” kan het tweede “hallo” worden vervangen door een instructie om 13 tekens terug te gaan en er vijf te kopiëren. Spaties tellen als tekens. De decoder beschikt al over die eerdere tekst en kan de reeks uit de verwijzing reproduceren.

Geef veelvoorkomende symbolen kortere codes

Een code met variabele lengte gebruikt verschillende aantallen bits voor verschillende symbolen. Huffmancodering bouwt codes op basis van de frequentie van symbolen. In “ABRACADABRA” komt A vijf keer voor, B en R elk twee keer en C en D elk één keer. Een code met vaste breedte voor vijf symbolen heeft drie bits per symbool nodig, oftewel 33 bits voor elf letters.

Een geschikte prefixvrije code is A = 0, B = 10, R = 110, C = 1110 en D = 1111. De gecodeerde gegevens gebruiken $5\times 1+2\times 2+2\times 3+1\times 4+1\times 4=23$ bits. De codetabel voegt overhead toe, dus 23 bits alleen is niet de volledige bestandsgrootte.

Prefixvrij betekent dat geen code van een symbool het begin is van de code van een ander symbool. Als je 0110 leest, krijg je daarom A gevolgd door R zonder dat scheidingstekens nodig zijn. Door deze eigenschap kan een huffmandecoder een symbool herkennen zodra de code eindigt.

De decoder moet zowel de coderingsafspraak als de gegevens kennen. Voor een stroom met huffmancodering heeft de decoder de koppeling tussen symbolen en codes nodig; voor RLE moet die een aantal van een symbool kunnen onderscheiden. Een klein bericht kan bits aan gegevens besparen maar in totaal groter worden als deze beschrijving wordt meegerekend. Vergelijk de volledige oorspronkelijke en gecodeerde grootte om te bepalen of een methode het bestand daadwerkelijk heeft verkleind.

Meet de besparing en herken grenzen

De compressieverhouding is de oorspronkelijke grootte gedeeld door de gecomprimeerde grootte. Van 6 MB naar 2 MB gaan geeft 3:1. Gebruik aan beide kanten dezelfde eenheid.

Geen enkele verliesloze methode kan elk mogelijk bestand korter maken. Er zijn $2^n$ verschillende invoeren van n bits, maar slechts $2^n-1$ bitreeksen die korter zijn dan n bits. Voor exact herstel moeten verschillende originelen onderscheidbaar blijven, dus kunnen ze niet allemaal een kortere uitvoer krijgen. Willekeurige gegevens en al gecomprimeerde bestanden worden vaak weinig kleiner of groeien door toegevoegde overhead.

Compressie met verlies verwijdert informatie om de bestandsgrootte te verkleinen. Bij het decomprimeren ontstaat een versie die dicht bij het origineel ligt, maar waarin bepaalde details blijvend ontbreken. Foto’s, muziek, spraak en video kunnen geselecteerde verliezen verdragen die exacte tekst of programmagegevens niet kunnen verdragen.

Comprimeer afbeeldingen op basis van visueel belang

JPEG maakt gebruik van de verschillende gevoeligheid van het menselijk oog voor helderheid, kleur en fijne details. Een gebruikelijke JPEG verlaagt de resolutie van fijne kleurdetails en rondt fijne beelddetails af die in blokken van 8 × 8 worden weergegeven. De kwaliteitsinstelling bepaalt hoe sterk informatie wordt weggelaten. Sterkere compressie kan blokvorming of vervaging en randecho’s bij scherpe randen veroorzaken.

Een foto kan vaak ongeveer 10:1 bereiken met weinig zichtbaar verlies. Bij die verhouding zou een afbeelding met 6.220.800 bytes aan ruwe pixelgegevens gecomprimeerd ongeveer 622.080 bytes gebruiken, circa 0,6 MB. De verhouding is een voorbeeld, geen vaste eigenschap van elke JPEG.

Comprimeer geluid op basis van wat hoorbaar is

MP3 en AAC gebruiken perceptuele codering. Een zacht geluid kan worden gemaskeerd door een harder geluid met een nabije frequentie, zodat de encoder minder bits kan besteden aan informatie die een luisteraar waarschijnlijk niet hoort. Een kleiner bestand kan nog steeds vrijwel hetzelfde klinken als het origineel.

Bij een constante bitsnelheid is de grootte in bits gelijk aan bitsnelheid maal duur. Bij 128 kbit/s heeft een opname van drie minuten $128.000\times 180=\mathrm{23.040.000}$ bits nodig, oftewel 2.880.000 bytes, ongeveer 2,9 MB. Dat is ongeveer een elfde van de 1.411,2 kbit/s van ongecomprimeerde cd-audio. De gecomprimeerde snelheid beschrijft de gecodeerde stroom al; vermenigvuldig die niet opnieuw met de oorspronkelijke bitdiepte per sample.

Benut overeenkomsten tussen videobeelden

Opeenvolgende beelden tonen vaak bijna dezelfde scène. Videoformaten zoals H.264 en AV1 comprimeren beelddetails en beschrijven veel beelden met veranderingen of voorspellingen op basis van andere beelden. Zo wordt herhaalde informatie zowel in de tijd als binnen elk beeld verwijderd.

Stem het formaat af op het gebruik

Bewaar een verliesloos origineel voor toekomstige bewerking. Herhaald decoderen en opnieuw coderen met verlies kan generatieverlies toevoegen. Als je een JPEG met verlies naar PNG omzet, blijven de huidige gedecodeerde pixels behouden, maar kunnen eerder verwijderde details niet worden hersteld.

Meer compressie kan kwaliteit, verwerkingstijd of beide kosten. De bruikbare keuze hangt af van de inhoud en het gebruik van een bestand; het kleinste bestand is niet altijd het bruikbaarst.