Talstelsels

Vier streepjes in de kantlijn, het teken IV op een wijzerplaat, het woord vier, het cijfer 4: vier notaties, één en hetzelfde aantal. Het getal is niet zijn notatie. Dat onderscheid lijkt vergezocht, tot je beseft dat een computer een heel andere notatie gebruikt dan jij en er toch dezelfde getallen mee bedoelt.

Decimaal

Neem het getal 5074. Je leest dat in één oogopslag, maar wat staat er eigenlijk? Elke positie is een macht van tien waard:

\[ 5074 = 5 \times 10^3 + 0 \times 10^2 + 7 \times 10^1 + 4 \times 10^0 \]

Twee dingen maken dit systeem zo sterk:

  • De positie draagt betekenis. De 5 is geen vijf maar vijfduizend, vanwege haar plaats.
  • De nul houdt de plaats “bezet”. Zonder het symbool 0 kon je 5074 niet onderscheiden van 574.

Omdat we tien symbolen gebruiken (0 tot en met 9) en met machten van tien werken, heet dit het tientallig of decimaal stelsel: een positiestelsel met basis 10.

Hetzelfde getal in Romeinse cijfers, \(\overline{\text{V}}\text{LXXIV}\) is een rij symbolen die je optelt of aftrekt. Dit talstelsels is additief.

Binair

De keuze voor basis 10 is een gewoonte, geen noodzaak; ze gaat vermoedelijk terug op onze tien vingers. Kies je basis 2, dan heb je maar twee symbolen nodig en is elke positie een macht van twee waard. Dat is het binaire stelsel.

Tellen verloopt zoals je gewend bent, alleen zijn de symbolen veel sneller uitgeput: na 1 komt niet 2, maar 10.

decimaal 0 1 2 3 4 5 6 7 8
binair 0 1 10 11 100 101 110 111 1000

Om verwarring te vermijden schrijven we de basis als index: \(110_2\) is zes, \(110\) zonder index is honderdentien. Uitlezen doe je met machten van twee:

\[ 110101_2 = 1 \times 2^5 + 1 \times 2^4 + 0 \times 2^3 + 1 \times 2^2 + 0 \times 2^1 + 1 \times 2^0 = 53. \]

Waarom werkt een computer binair? Omdat twee toestanden technisch robuust zijn: spanning of geen spanning, een magnetisch veld in de ene of de andere richting. Tien spanningsniveaus betrouwbaar uit elkaar houden is moeilijk; twee is haalbaar.

Het voorvoegsel 0b is Pythons tegenhanger van onze index 2.

Opgave. Lees \(10110_2\) uit met machten van twee. Welk decimaal getal is het? Controleer pas daarna met een codecel.

\(10110_2 = 16 + 4 + 2 = 22\). De enen staan op de posities van \(2^4\), \(2^2\) en \(2^1\).

Opgave. Hoeveel verschillende getallen kun je schrijven met hoogstens zes binaire cijfers?

\(2^6 = 64\): de getallen 0 tot en met 63. Elk van de zes posities heeft twee mogelijkheden, en elke combinatie levert een ander getal op.

Van decimaal naar binair

De andere richting — een decimaal getal binair schrijven — doe je met herhaald delen door 2. De rest bij elke deling is telkens één binair cijfer, van rechts naar links:

\[ \begin{aligned} 53 &= 2 \times 26 + \mathbf{1}\\ 26 &= 2 \times 13 + \mathbf{0}\\ 13 &= 2 \times 6 + \mathbf{1}\\ 6 &= 2 \times 3 + \mathbf{0}\\ 3 &= 2 \times 1 + \mathbf{1}\\ 1 &= 2 \times 0 + \mathbf{1} \end{aligned} \]

De resten van onder naar boven gelezen: \(110101_2\). Dat klopt met het resultaat van daarnet.

Waarom werkt dit? De eerste rest vertelt of het getal even of oneven is — en dat is precies het laatste binaire cijfer. Wat na de deling overblijft, is hetzelfde getal zonder dat laatste cijfer, en daarop herhaal je de vraag.

Opgave. Schrijf 45 binair met herhaald delen door 2, en controleer je antwoord door de machten van twee weer op te tellen.

\(45 = 2 \times 22 + \mathbf{1}\), \(22 = 2 \times 11 + \mathbf{0}\), \(11 = 2 \times 5 + \mathbf{1}\), \(5 = 2 \times 2 + \mathbf{1}\), \(2 = 2 \times 1 + \mathbf{0}\), \(1 = 2 \times 0 + \mathbf{1}\). Van onder naar boven: \(101101_2\). Controle: \(32 + 8 + 4 + 1 = 45\).

Python bundelt de deling en de rest in één functie, divmod:

Oefening. Schrijf naar_binair(n) die een positief geheel getal omzet naar zijn binaire schrijfwijze als string — zonder bin te gebruiken.

De lus met divmod hierboven doet al het echte werk; verpak ze in een functie met een return.

def naar_binair(n):
    cijfers = ''
    while n > 0:
        n, rest = divmod(n, 2)
        cijfers = str(rest) + cijfers
    return cijfers

Verwacht resultaat: naar_binair(13) geeft '1101'.

Hexadecimaal

Binaire getallen worden snel lang: \(53\) is al zes cijfers. Daarom gebruiken informatici vaak basis 16, het hexadecimale stelsel. Dat vraagt zestien symbolen; na 9 gaan we verder met letters: A staat voor tien, B voor elf, …, F voor vijftien.

Dat het er net zestien zijn, is geen toeval: \(16 = 2^4\), dus één hexadecimaal cijfer is precies vier binaire cijfers. Omzetten tussen binair en hexadecimaal is daardoor puur opzoekwerk, groepje per groepje:

\[ \underbrace{1100}_{\text{C}}\ \underbrace{0100}_{\text{4}}{}_2 = C4_{16} = 12 \times 16 + 4 = 196. \]

Een hexadecimaal getal is dus een compacte spelling van een binair getal — vandaar dat je hex overal tegenkomt waar ruwe bytes getoond worden, van kleurcodes (#ff6600) tot foutmeldingen.

Opgave. Zet \(2F_{16}\) om naar decimaal én naar binair.

\(2F_{16} = 2 \times 16 + 15 = 47\). Binair: 2 is \(0010\), F is \(1111\), dus \(101111_2\) (de leidende nullen mag je weglaten).

Opgave. Zet het byte \(10111010_2\) om naar hexadecimaal. Splits eerst in groepjes van vier vanaf rechts.

\(\underbrace{1011}_{\text{B}}\ \underbrace{1010}_{\text{A}}\): \(1011_2 = 11 = B\) en \(1010_2 = 10 = A\), dus \(BA_{16}\). Als decimale controle: \(186\).

WaarschuwingVeelgemaakte fout

De omzetting per groepje van vier werkt alleen tussen binair en hexadecimaal (en tussen binair en octaal, met groepjes van drie). Tussen decimaal en binair bestaat er geen omzetting cijfer per cijfer — daar moet je echt rekenen.