M3: binary arithmetic, flags and bitwise operations

course/en/10-binary-arithmetic.md

@@ -0,0 +1,31 @@
+# Binary arithmetic and CPU flags
+
+Binary addition follows ordinary positional arithmetic with only two digits.
+
+## PREDICT
+
+What is `1111₂ + 0001₂` in a four-bit register?
+
+## STEP
+
+`1+1=10₂`, producing a carry. Thus `1111 + 0001 = 1 0000`. Keeping four result bits gives zero while the carry records unsigned overflow beyond the width.
+
+Subtraction can use borrow directly or addition of a two's-complement negative operand.
+
+## CPU flags
+
+Common flags include **C** carry, **Z** zero, **N** negative/top-bit state, and **V** signed overflow.
+
+For signed eight-bit arithmetic, `7F₁₆ + 01₁₆ = 80₁₆`. The mathematical +128 cannot be represented, so CPUs with an overflow flag report that condition.
+
+## OBSERVE
+
+Carry and signed overflow answer different questions about the same bit-level result.
+
+## EXPLAIN
+
+Flags allow later instructions to branch, compare and extend arithmetic without recomputing the operation.
+
+## Check yourself
+
+Compute `FF₁₆ + 01₁₆` and discuss C, Z and V for eight-bit arithmetic.

course/en/11-bitwise-operations.md

@@ -0,0 +1,27 @@
+# Bitwise operations
+
+Bitwise operations process corresponding bits independently.
+
+## PREDICT
+
+What is `1010 AND 1100`?
+
+## STEP
+
+**AND** requires both bits to be one. **OR** requires at least one. **XOR** is one when the bits differ. **NOT** inverts every bit.
+
+For `A=1010₂`, `B=1100₂`: AND gives `1000`, OR `1110`, XOR `0110`, and four-bit NOT A gives `0101`.
+
+Logical shifts move bits and fill with zero. Arithmetic right shift commonly preserves the sign bit. Rotates wrap bits around instead of discarding them; rotate-through-carry also includes the carry flag.
+
+## OBSERVE
+
+Width is essential: NOT zero has a different numerical result at 8 and 16 bits.
+
+## EXPLAIN
+
+These operations underpin register manipulation, protocols, graphics, compression and many low-level algorithms.
+
+## Check yourself
+
+Compute AND, OR and XOR for `3C₁₆` and `0F₁₆`.

course/en/12-bit-masks.md

@@ -0,0 +1,27 @@
+# Bit masks and bit fields
+
+A bit mask selects particular bits while leaving neighboring bits available for other meanings.
+
+## PREDICT
+
+How can bit 0 be set in `10100100₂` without changing the other bits?
+
+## STEP
+
+With `MASK=00000001₂`: set using OR, clear using AND with NOT MASK, toggle using XOR, and test using AND.
+
+Fields spanning several bits can be isolated with a mask and shifted down before interpretation.
+
+Suppose bit 7 means ENABLE, bit 3 IRQ and bit 0 READY. Then `10001001₂` carries three independent Boolean flags in one byte.
+
+## OBSERVE
+
+Hex makes masks compact: `11110000₂ = F0₁₆`, while `00001111₂ = 0F₁₆`.
+
+## EXPLAIN
+
+Bit fields efficiently pack small values, and masks let software manipulate one field without damaging the rest.
+
+## Check yourself
+
+Create a mask selecting bits 2 and 5, then show how to toggle bit 5 in `34₁₆`.

course/no/10-binaer-aritmetikk.md

@@ -0,0 +1,42 @@
+# Binær aritmetikk og CPU-flagg
+
+Binær addisjon følger de samme prinsippene som desimal addisjon, men hvert siffer kan bare være 0 eller 1.
+
+## PREDICT
+
+Hva blir `1111₂ + 0001₂` dersom registeret bare er fire bit bredt?
+
+## STEP
+
+De grunnleggende addisjonene er `0+0=0`, `0+1=1`, `1+0=1` og `1+1=10₂`. Den siste produserer en carry.
+
+For fire bit:
+
+`1111 + 0001 = 1 0000`
+
+Hvis bare fire resultatbit beholdes, blir resultatet `0000`, mens carry-bitten forteller at unsigned-resultatet ikke passet.
+
+Subtraksjon kan utføres direkte med borrow eller som addisjon av en toerkomplement-negativ verdi.
+
+## CPU-flagg
+
+Mange CPU-er registrerer egenskaper ved resultatet:
+
+- **C / Carry**: carry ut av toppbiten; relevant for unsigned aritmetikk.
+- **Z / Zero**: resultatet er null.
+- **N / Negative**: følger typisk toppbiten i resultatet.
+- **V / Overflow**: signed-resultatet kan ikke representeres i valgt bredde.
+
+Eksempel: signed 8-bit `7F₁₆ + 01₁₆ = 80₁₆`. Her er resultatmønsteret −128, men det matematiske resultatet +128 passer ikke. V settes på CPU-er som har et overflow-flagg.
+
+## OBSERVE
+
+Carry og overflow er ikke synonymer. De tolker samme bitoperasjon ut fra henholdsvis unsigned og signed aritmetikk.
+
+## EXPLAIN
+
+CPU-flagg lar etterfølgende instruksjoner ta beslutninger uten å gjenta hele beregningen. De er sentrale for sammenligning, hopp og aritmetikk med flere ord.
+
+## Sjekk deg selv
+
+Beregn `FF₁₆ + 01₁₆` og diskuter C, Z og V for 8-bit aritmetikk.

course/no/11-bitoperasjoner.md

@@ -0,0 +1,40 @@
+# Bitoperasjoner
+
+Bitvise operasjoner arbeider på hvert bitpar uavhengig.
+
+## PREDICT
+
+Hva blir `1010 AND 1100`?
+
+## STEP
+
+**AND** gir 1 bare når begge bit er 1. **OR** gir 1 når minst én bit er 1. **XOR** gir 1 når bitene er forskjellige. **NOT** inverterer hvert bit.
+
+For `A=1010₂` og `B=1100₂`:
+
+- `A AND B = 1000`
+- `A OR B = 1110`
+- `A XOR B = 0110`
+- `NOT A = 0101` dersom bredden er fire bit
+
+## Shifts
+
+Venstreskift flytter bit mot høyere posisjoner. Innen fast bredde tilsvarer ett logisk venstreskift ofte multiplikasjon med 2 når ingen relevant bit går tapt.
+
+Logisk høyreskift fyller med null. Aritmetisk høyreskift bevarer fortegnsbiten på signed toerkomplement-maskiner.
+
+## Rotates
+
+Rotate flytter bit rundt endene i stedet for å forkaste dem. Mange CPU-er har også rotate-through-carry, der carry-flagget inngår som en ekstra bit.
+
+## OBSERVE
+
+Alle operasjonene må forstås med en eksplisitt bitbredde. `NOT 00000000` er `11111111` i åtte bit, men en annen verdi dersom bredden er 16 bit.
+
+## EXPLAIN
+
+Bitoperasjoner er grunnverktøy for registre, protokoller, grafikk, komprimering, kryptografiske primitiver og lavnivåprogrammering.
+
+## Sjekk deg selv
+
+Beregn AND, OR og XOR for `3C₁₆` og `0F₁₆`.

course/no/12-bitmasker.md

@@ -0,0 +1,36 @@
+# Bitmasker og bitfelt
+
+En bitmaske velger bestemte bit i en verdi uten å påvirke resten.
+
+## PREDICT
+
+Et 8-bit register er `10100100₂`. Hvordan setter du bit 0 uten å endre de andre bitene?
+
+## STEP
+
+La `MASK = 00000001₂`.
+
+- sett bit: `value OR MASK`
+- nullstill bit: `value AND NOT MASK`
+- toggle bit: `value XOR MASK`
+- test bit: `value AND MASK`
+
+For flere bit kan masken inneholde flere ettall.
+
+Et felt på bit 4–6 kan isoleres med en maske og deretter skiftes ned til bit 0 før det tolkes som et lite heltall.
+
+## Registereksempel
+
+Anta at bit 7 betyr ENABLE, bit 3 IRQ og bit 0 READY. Da kan `10001001₂` leses som tre uavhengige boolske flagg i samme byte.
+
+## OBSERVE
+
+Hex gjør masker lettere å lese: `11110000₂ = F0₁₆` og `00001111₂ = 0F₁₆`.
+
+## EXPLAIN
+
+Bitfelt pakker mange små verdier effektivt. Masker lar programmet endre eller lese ett felt uten å ødelegge naboene.
+
+## Sjekk deg selv
+
+Lag en maske for bit 2 og 5. Vis hvordan bit 5 kan toggles i `34₁₆`.

exercises/no/04-aritmetikk-bit.md

@@ -0,0 +1,10 @@
+# Øvelser: aritmetikk og bitoperasjoner
+
+1. Legg sammen `A7₁₆ + 6D₁₆` som 8-bit og angi carry.
+2. Hva skjer med signed overflow i `64₁₆ + 32₁₆` som int8?
+3. Beregn `55₁₆ XOR FF₁₆`.
+4. Beregn `A5₁₆ AND 0F₁₆`.
+5. Skift `00110110₂` én posisjon til venstre og høyre logisk.
+6. Lag en maske for bit 1, 4 og 7.
+7. Beskriv hvordan du setter bit 4, nullstiller bit 1 og tester bit 7.
+8. Hvorfor må NOT alltid tolkes med kjent bitbredde?

solutions/no/04-aritmetikk-bit.md

@@ -0,0 +1,10 @@
+# Løsninger: aritmetikk og bitoperasjoner
+
+1. `A7 + 6D = 114₁₆`; 8-bit resultat er `14₁₆`, carry = 1.
+2. `64₁₆=100`, `32₁₆=50`; matematisk resultat 150 passer ikke i int8. Resultatmønsteret er `96₁₆`, og signed overflow oppstår.
+3. `55 XOR FF = AA₁₆`.
+4. `A5 AND 0F = 05₁₆`.
+5. Venstre: `01101100₂`; logisk høyre: `00011011₂`.
+6. `10010010₂ = 92₁₆`.
+7. OR med `10₁₆`; AND med komplementet av `02₁₆`; AND med `80₁₆` og test om resultatet er ulik null.
+8. NOT inverterer alle bit i den valgte representasjonen, så antallet bit bestemmer resultatmønsteret og den numeriske verdien.