22. Bity: &, %, !, LSH, RSH

Na čo to je

Bajt je osem bitov – ôsmich prepínačov, z ktorých každý je buď 0, alebo 1. Počítač Atari má veľa nastavení uložených tak, že každý bit bajtu znamená niečo iné: jeden zapína inverzné písmo, iný hovorí, či je stlačené tlačidlo. Bitové operácie dovolia pracovať s jednotlivými bitmi.

Kapitolu môžeš pri prvom čítaní preskočiť a vrátiť sa k nej, keď budeš bity potrebovať.

Dvojková sústava v skratke

Každý bit má svoju hodnotu – mocninu dvojky. Bity sa číslujú sprava, od 0:

Bit	7	6	5	4	3	2	1	0
Hodnota	128	64	32	16	8	4	2	1

Číslo je súčet hodnôt bitov, ktoré sú 1. Napríklad 12 je 00001100: bit 3 (hodnota 8) a bit 2 (hodnota 4), 8 + 4 = 12.

Ako sa to píše

Operátor	Slovom	Čo robí s každou dvojicou bitov
`a & b`	`a AND b`	výsledný bit je 1, len keď sú oba 1
`a % b`	`a OR b`	výsledný bit je 1, keď je aspoň jeden 1
`a ! b`	`a XOR b`	výsledný bit je 1, keď sú bity rôzne
`a LSH n`		posunie bity o `n` miest doľava (násobenie dvoma, `n`-krát)
`a RSH n`		posunie bity o `n` miest doprava (delenie dvoma, `n`-krát)

Znak a slovo sú to isté: a & b je a AND b. Sú to tie isté AND a OR ako v podmienkach (kapitola 9) – tam spájajú porovnania, tu pracujú s bitmi čísel.

K čomu sa hodia:

Chcem	Zápis	Príklad
zistiť, či je bit zapnutý	`IF x & maska THEN`	`IF x&128 THEN`
zapnúť bit	`x==%maska`	`x==%128`
vypnúť bit	`x==&(255−maska)`	`x==&127`
prepnúť bit na opačný	`x==!maska`	`x==!128`

Maska je číslo, ktoré má jednotky na bitoch, o ktoré ide.

Celý program

Súbor examples/bits.act:

Action!

; Bits: looking inside a byte

PROC Bits(BYTE value)        ; write a byte as eight binary digits
  BYTE i, mask

  mask=128
  FOR i=1 TO 8
  DO
    IF value&mask THEN
      Put('1)
    ELSE
      Put('0)
    FI
    mask==RSH 1
  OD
RETURN

PROC Show(BYTE value)
  Bits(value)
  Print(" = ")
  PrintBE(value)
RETURN

PROC Main()
  BYTE a, b

  a=12
  b=10
  Print("a           ")  Show(a)
  Print("b           ")  Show(b)
  Print("a AND b     ")  Show(a&b)
  Print("a OR b      ")  Show(a%b)
  Print("a XOR b     ")  Show(a!b)
  Print("a LSH 1     ")  Show(a LSH 1)
  Print("a RSH 2     ")  Show(a RSH 2)

  a=5
  a==%128                    ; switch bit 7 on
  Print("bit 7 on    ")  Show(a)
  a==&127                    ; switch bit 7 off
  Print("bit 7 off   ")  Show(a)
RETURN

Preklad a spustenie

action26 bits.act --sim

Čo uvidíš

a           00001100 = 12
b           00001010 = 10
a AND b     00001000 = 8
a OR b      00001110 = 14
a XOR b     00000110 = 6
a LSH 1     00011000 = 24
a RSH 2     00000011 = 3
bit 7 on    10000101 = 133
bit 7 off   00000101 = 5

Ako to funguje

Porovnaj stĺpce nad sebou:

a        00001100
b        00001010
a AND b  00001000    jednotka len tam, kde ju majú obe
a OR b   00001110    jednotka tam, kde ju má aspoň jedno
a XOR b  00000110    jednotka tam, kde sa líšia

a LSH 1 posunie všetko o miesto doľava: z 12 je 24, dvojnásobok.
a RSH 2 posunie o dve miesta doprava: 12 delené 4 je 3. Bity, ktoré „vypadnú“ z kraja, sa stratia.
a==%128 zapne bit 7 a ostatné nechá: z 5 je 133.
a==&127 – 127 je 01111111, všetky bity okrem siedmeho. AND s ním bit 7 vypne a ostatné nechá.

Procedúra Bits ukazuje, ako sa bity čítajú: maska začne na 128 (bit 7) a každým krokom sa posunie doprava (mask==RSH 1). value&mask je nenulové práve vtedy, keď je daný bit v value zapnutý – a podmienka bez porovnania platí, keď je výsledok nenulový.

Časté chyby

Čo sa stalo	Čo sa stane
`%` v zmysle „percentá“ alebo „zvyšok po delení“	v Action! je `%` bitové OR; zvyšok je `MOD`
`!` v zmysle „nie“	v Action! je `!` bitové XOR; opak podmienky sa píše obráteným porovnaním
posun `BYTE` hodnoty za 8 bitov (`1 LSH 8`)	výsledok je 0 – počíta sa v `BYTE` a bit vypadne; pre väčšie posuny použi `CARD` premennú
`x&mask=mask` bez zátvoriek	`error ACT023: illegal conditional expression` – porovnanie má prednosť pred `&`; píš `(x&mask)=mask`

Vyskúšaj si

Vypíš v dvojkovej sústave čísla 0 až 15.
Napíš BYTE FUNC IsOdd(BYTE n), ktorá zistí nepárnosť bitovou operáciou (nepárne číslo má zapnutý bit 0).
Kód malého písmena je o 32 väčší ako kód veľkého – líšia sa bitom 5. Preveď znak 'a na veľké písmeno vypnutím toho bitu.

Zhrnutie

Bajt má 8 bitov s hodnotami 1, 2, 4 … 128.
& (AND) vyberá a vypína bity, % (OR) zapína, ! (XOR) prepína.
LSH a RSH posúvajú bity – násobia a delia dvoma.
Test bitu: IF x&maska THEN.

Späť: 21. Záznamy · Ďalej: 23. Program vo viacerých súboroch